Strenger

# I kildekoden kan streng-verdier oppgis på fire ulike måter
print('apostrof')
print("hermetegn")
print('''trippel-apostrof''')
print("""trippel-hermetegn""")

# Hvilken variant som brukes har absolutt ingenting å si
print('foo' == "foo") # True

# Så hvorfor ha flere varianter?
# Svar 1: kompabilititet
# Svar 2: for å enklere skrive hermetegn og apostrof
print("Her er 'apostrof'")
print('Her er "hermetegn"')
print("""Her er både "hermetegn" og 'apostrofer'""")

print("Hvis vi kun bruker "hermetegn" går det galt")

# Et tegn med en bakstrek foran seg, som \n, er en escape-sekvens.
# Selv om det ser ut som to tegn, er det bare ett tegn når Python er
# ferdig med å lese kildekoden. I tilfellet \n er dette et linjeskift.

# Merk at de to setningene under gjør det samme
print("abc\ndef")  # \n er ett enkelt linjeskift
print("""abc
def""") # Trippel-hermetegn/apostrof tillater linjeskift uten escape-sekvens

print("""\
Du kan bruke bakstrek på slutten av en linje for å ekskludere
et påfølgende linjeskiftet i kildekoden. Dette er svært sjeldent
brukt, men et anvendelsesområde er som i dette eksempelet, på
starten av en lengre streng over flere linjer. På den måten kan
hele strengen bli skrevet inn med samme indentering (altså ingen
indentering).
""")

print("Hermetegn i hermetegn-streng: \"")
print("Bakstrek: \\")
print("Linjeskift: [\n]")
print("Tab: [\t]")
print()

print("Denne teksten er skilt av tab'er, 3 per linje:")
print("abc\tdef\tg\nhi\tj\\\tk\n---")
print()

# En escape-sekvens telles som ett tegn
s = "a\\b\"c\td"
print("s =", s)
print("len(s) =", len(s))

def print_string_conversion(x):
    print("type:", type(x))
    print(" str:", str(x))
    print("repr:", repr(x))
    print()

print("Vanligvis konverteres verdier til streng med str-funksjonen")
print("Å bruke repr-funksjonen gir for mange vanlige typer samme resultat")
print_string_conversion(10)
print_string_conversion(True)
print_string_conversion(2/11)

print("Men for strenger, viser repr oss whitespace og escape-sekvenser.")
print_string_conversion("   Mellomrom\ttab   ")
print_string_conversion("Linje\nskift")

# Generelt vil `repr` vise mer detaljert informasjon enn `str`.
# Hensikten med `str` er at resultatet skal være leselig, hensikten
# med `repr` er å gi oss presis informasjon.

print("For andre typer kan forskjellen være stor")
import datetime
today = datetime.datetime.now()
print_string_conversion(today)

import string
print(string.ascii_letters)   # abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
print(string.ascii_lowercase) # abcdefghijklmnopqrstuvwxyz
print("-----------")
print(string.ascii_uppercase) # ABCDEFGHIJKLMNOPQRSTUVWXYZ
print(string.digits)          # 0123456789
print("-----------")
print(string.punctuation)     # '!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'
print(string.printable)       # siffer + bokstaver + tegn + whitespace
print("-----------")
print(string.whitespace)      # mellomrom + tab + linjeskift etc....
print("-----------")

print("abc" + "def") # Konkatenasjon 
print("abc" * 3)     # Repetisjon
print(len("abc"))    # Lengde
print()

 # Medlemskap (sjekk om venstresiden finnes som substreng av høyresiden)
print("a" in "abc")  # True
print("bc" in "abc") # True
print("ac" in "abc") # False, 'ac' er ikke sammenhengde i 'abc'
print("A" in "abc")  # False, 'A' er ikke det samme som 'a'
print("" in "abc")   # True, den tomme strenger er alltid en substreng

# .upper og .lower endre teksten til bare store eller små bokstaver
s = "FooBar"
print(s)
print(s.lower())
print(s.upper())
print("---") 

# .replace bytter ut substrenger
print(s.replace("o", "ahr"))
print("hahahaha".replace("hah", "l"))
print("hahahaha".replace("hah", "h"))
print("---")

# .split() deler opp en streng i biter, og legger bitene i en liste
names = "Marshall,Rubble,Chase,Rocky,Zuma,Sky"
print(names)
print(names.split(","))
print("---")

# .join() limer sammen strenger med en limestreng
print("+".join(names.split(",")))
print(s.join("ABC"))
print("---")

# .strip() fjerner whitespace foran og bak
s = "   FooBar  \n "
print(s, len(s))
print(s.strip(), len(s.strip()))
print("---")

# Kjør koden for å se en tabell av hva funksjonene returnerer
def print_cell(test):
    print(f"{str(test):9}", end="")

def print_row(s):
    print(f" {s:4}  ", end="")
    print_cell(s.isalnum())
    print_cell(s.isalpha())
    print_cell(s.isdigit())
    print_cell(s.islower())
    print_cell(s.isspace())
    print_cell(s.isupper())
    print()

def print_table():
    print("  s   isalnum  isalpha  isdigit  islower  isspace  isupper")
    for s in "ABCD,ABcd,abcd,ab12,1234,-123,1.0,    ,AB?!".split(","):
        print_row(s)

print_table()

print("Dette er et ran".count("et")) # 2
print("Dette er ETT ran".count("et")) # 1
print("-------")
print("Hunder og katter".startswith("Hun"))     # True
print("Hunder og katter".startswith("Hun der")) # False
print("-------")
print("Hunder og katter".endswith("er"))      # True
print("Hunder og katter".endswith("mer"))     # False
print("-------")
print("Hunder og katter".find("og"))          # 7
print("Hunder og katter".find("eller"))       # -1
print("-------")
print("Hunder og katter".index("og"))         # 7
print("Hunder og katter".index("eller"))      # Krasj!

s = "abcdefgh"
print(s)
print(s[0]) # a
print(s[1]) # b
print(s[2])
print()

length = len(s)
print(s[length - 1])
print(s[length]) # Krasjer (string index out of range)

s = "abcdefgh"
print(s)
print(s[-1]) # Snarvei for s[len(s) -  1]
print(s[-2])

# Beskjæring er som å indeksere, men vi kan hente ut mer enn ett tegn
#
# For en streng s vil s[<start>:<slutt>] evaluere til en streng som
# begynner med tegnet på indeks <start> i s og går opp til men ikke
# inkludert tegnet på indeks <slutt>.
#
# Minner dette om range(a, b)?

s = "abcdefgh"
print(s)
print(s[0:3])
print(s[1:3])
print()

print(s[2:3])
print(s[3:3])
print("---")

s = "abcdefgh"
print(s)
print(s[3:])
print(s[:3])
print(s[:])
print("---")

# Dette er ikke vanlig, men illustrerer slektskapet med range()
#
# For en streng s vil s[<start>:<slutt>:<steg>] beskjære strengen
# ved å begynne med tegnet på indeks <start>, og gå opp til <slutt>
# med mellomrom på <steg>

s = "abcdefgh"
print(s)
print(s[1:7:2])
print(s[1:7:3])
print("---")
print(s[0:len(s):2])
print(s[::2])
print(s[1::2])
print("---")
print(s[3:0:-1])
print("---")

s = "abcdefgh"

print("Dette virker, men er forvirrende:")
print(s[::-1])

print("Dette virker også, men er fremdeles forvirrende:")
print("".join(reversed(s)))

print("Beste løsning: skriv funksjon med selvforklarende navn.")
def reversed_string(s):
    return s[::-1]

print(reversed_string(s)) # klart og tydelig!

s = "abcd"
# Vanlig for-løkke over lengden til s
for i in range(len(s)):
    print(i, s[i])

print("---")
# Med enumerate blir det to iterander, både indeks og selve tegnet
for i, c in enumerate(s): 
    print(i, c)

s = "abcd"
for c in s:
    print(c)

names = "Marshall,Rubble,Chase,Rocky,Zuma,Sky"
for name in names.split(","):
    print(name)

# Med indeksering
for i, name in enumerate(names.split(",")):
    print(i, name)

quotes = """\
Dijkstra: Simplicity is prerequisite for reliability.
Knuth: If you optimize everything, you will always be unhappy.
Dijkstra: Perfecting oneself is as much unlearning as it is learning.
Knuth: Beware of bugs in the above code; I have only proved it correct, \
not tried it.
Dijkstra: Computer science is no more about computers than astronomy is \
about telescopes.
"""

for line in quotes.splitlines():
    if line.startswith("Knuth"):
        print(line)

paragraph = """\
Denne strengen
inneholder linjeskift.
"""

for line in paragraph.splitlines(keepends=True):
    print("Line:", repr(line))

# Det er mange måter å skrive en is_palindrome(s) -funksjon
# Her er flere. Hvilken er best?

def reversed_string(s):
    return s[::-1]

def is_palindrome1(s):
    return (s == reversed_string(s))

def is_palindrome2(s):
    for i in range(len(s)):
        if (s[i] != s[len(s)-1-i]):
            return False
    return True

def is_palindrome3(s):
    for i in range(len(s)):
        if (s[i] != s[-1-i]):
            return False
    return True

def is_palindrome4(s):
    while (len(s) > 1):
        if (s[0] != s[-1]):
            return False
        s = s[1:-1]
    return True

def is_palindrome5(s):
    if len(s) <= 1:
        return True
    if s[0] != s[-1]:
        return False
    return is_palindrome5(s[1:-1])

print(is_palindrome1("abcba"), is_palindrome1("abca"))
print(is_palindrome2("abcba"), is_palindrome2("abca"))
print(is_palindrome3("abcba"), is_palindrome3("abca"))
print(is_palindrome4("abcba"), is_palindrome4("abca"))
print(is_palindrome5("abcba"), is_palindrome5("abca"))

# For å finne unicode-verdien (ordinal) til et tegn
c1 = "A"
u1 = ord(c1)
print(c1, u1)

# For å konvertere en ordinal tilbake til et tegn (character)
u2 = 97
c2 = chr(u2)
print(c2, u2)

# Skriv ut alfabetet
for i in range(ord("A"), ord("Z") + 1):
    print(chr(i), end="")
print()

print('"A" < "a":', "A" < "a") # True, siden 65 < 97 er True
print('"a" < "A":', "a" < "A") # False

def compare_lt(s1, s2):
    print(f"{repr(s1)} < {repr(s2)}: {s1 < s2}")

compare_lt("abc", "abx") # True, siden c har lavere ordinal enn liten x
compare_lt("abc", "abX") # False, siden c ikke har lavere ordinal enn stor X
print()
compare_lt("abc", "abc") # False, når verdiene er like vil ikke < gi True
compare_lt("ab", "abc") # True, den første strengen er prefiks for den andre
compare_lt("ac", "abc") # False, c har ikke lavere ordinal enn b

# Vi kan utnytte ordinalene for å kryptere en melding
def encode(message, shift):
    message = message.upper()
    result = ""
    for c in message:
        ordinal = ord(c) - ord("A")
        ordinal = (ordinal + shift) % (ord("Z") - ord("A") + 1)
        result += chr(ord("A") + ordinal)
    return result

def decode(message, shift):
    return encode(message, -shift)

# Eksempel på kryptering
print(encode("ABCDEFGHIJKLMNOPQRSTUVWXYZ", 3))
print(encode("HELLOCRYPTO", 5))

# Eksempel på dekryptering
print(decode("DEFGHIJKLMNOPQRSTUVWXYZABC", 3))
print(decode("MJQQTHWDUYT", 5))

# Merk: dette vil ikke fungere i nettleseren/Brython

# Du kan kopiere read_file og write_file -funksjonene og bruke dem
# i din egen kode

def read_file(path):
    """ Given the file path (file name) of a plain text file, returns
    the content of the file as a string. """
    with open(path, "rt", encoding='utf-8') as f:
        return f.read()

def write_file(path, contents):
    """ Writes the contents to the file with the given file path. If
    the file does not exist, it will be created. If the file does
    exist, its old content will be overwritten. """
    with open(path, "wt", encoding='utf-8') as f:
        f.write(contents)

# Eksempler på bruk.
# Vi oppretter en fil foo.txt med et gitt innhold
contents_to_write = "Dette er en test!\nDet er bare en test!"
write_file("foo.txt", contents_to_write)

# V leser en fil foo.txt og lagrer innholdet som en streng
contents_read = read_file("foo.txt")
assert(contents_read == contents_to_write)

print("Sjekk at filen foo.txt ble opprettet, og kikk på innholdet.")

import os
cwd = os.getcwd()
print(cwd)

import os
directory_of_current_file = os.path.dirname(__file__)
os.chdir(directory_of_current_file) # endrer cwd