02 Strenger og printing.ipynb

{
  "cells": [
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Strenger (engelsk: strings) og printing\nEn streng er en rekke med tegn som oppfattes som tekst (engelsk: string of characters). Det er mange metoder som kan benyttes for å få fin output på skjermen og når vi lagrer resultatene våre i filer. Vi skal se på de enkleste. En full oversikt finnes på https://docs.python.org/3/, særlig på https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str og https://docs.python.org/3/library/string.html. Mange av metodene for strenger er tilsvarende som kommandoene for lister.\n\nVi begynner med å se på printing, deretter ser vi på metoder for strenger.\n\nDette er en kort introduksjon. I dokumentet er det en egen overskrift \"Ekstra materiale\". Alt som står under denne er stoff man godt kan se over hvis man har tid."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## Printing på skjermen\nEn sentral ting vi gjør med strenger er å skrive tekst og tall på skjermen. For å printe noe på skjermen skriver vi på en av følgende måter:\n\nprint(\"tekst her\")\n\nprint('tekst her')\n\nVi kan velge fritt mellom enkelt og dobbelt sitattegn, men strengen må startes og avsluttes med samme type."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(\"Her er det tekst.\")\nprint(\"Vi kan bruke æ, ø og å, og vi kan bruke tall som 3 og 4, og vi kan bruke symboler som $, [, µ osv. i tekst.\")",
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Her er det tekst.\nVi kan bruke æ, ø og å, og vi kan bruke tall som 3 og 4, og vi kan bruke symboler som $, [, µ osv. i tekst.\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Øving: Skriv noen print-kommandoer i cellen under og kjør cellen. Dersom du får noen feilmeldinger må du rette opp i dem før du går videre."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## Printing av variabler og uttrykk\nVi er ikke avhengige av å skrive teksten vi vil printe direkte i print-kommandoen. Vi kan printe verdien av en variabel som vist under. Legg merke til at vi kan printe verdien av x, selv om det er et heltall (engelsk: integer/int) og ikke en string/str. Vi kan også lage et uttrykk inne i print-kommandoen. Python begynner innerst og beregner først verdien av 2*3, og printer deretter resultatet."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "x = 3 # Denne linjen printes ikke, x får bare verdien 3. Tilsvarende på linje 2 og 4.\nvariabeltekst = \"Tekst her også.\"\nprint(variabeltekst)\nvariabeltekst = \"Nå er det ny tekst her, men jeg bruker samme variabelnavn og print-kommando.\"\nprint(variabeltekst)\nprint(x)\nprint(2*x)\nprint(type(variabeltekst))\nprint(type(x))",
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Tekst her også.\nNå er det ny tekst her, men jeg bruker samme variabelnavn og print-kommando.\n3\n6\n<class 'str'>\n<class 'int'>\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Øving: Du skal nå skrive fire linjer kode. 1: Lag en variabel som inneholder en tekst (streng). 2: Bruk en print-kommando for å printe teksten. 3: Gi variabelen nytt innhold. 4. Print det nye innholdet i variabelen."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Dersom vi vil printe en kombinasjon av tall og tekst kan vi transformere tallet til tekst med funksjonen str(). Dette er vist under. Prøv å modifisere koden ved å fjerne kommentartegnet (#) fra den siste linjen, og se på feilmeldingen som oppstår."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "tekst = 'Antall elementer er '\ntall = 5\nprint(tekst+str(tall))\n# print(tekst+tall)",
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Antall elementer er 5\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Et alternativ er å skrive med komma mellom elementene som skal printes. Legg merke til at det innfører et ekstra mellomrom."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "tekst = 'Antall elementer er '\ntall = 5\nprint(tekst,tall)\nprint('Dette er den',tall,'. gangen jeg er her.')\n# Kan slippe det unødvendige mellomrommet ved å bruke + men da må vi gjøre om tallet til string først.\nprint('Dette er den',str(tall)+'. gangen jeg er her.')",
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Antall elementer er  5\nDette er den 5 . gangen jeg er her.\nDette er den 5. gangen jeg er her.\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## Metoder for strenger\nNoen av metodene er på formen streng.metode(). Her er \"streng\" enten strengen selv, eller navnet til en variabel som inneholder en streng, mens \"metode\" er navnet på en av metodene som kan brukes på strenger. Parentesen etter \"metode\" er ofte tom, men for noen metoder skriver vi inn argumenter i denne parentesen for å styre hvordan metoden skal virke akkurat denne gangen.\n\nAndre metoder har andre former, f.eks.:\n* streng[4]\n* streng_1 + streng_2\n* len(streng)"
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Elementer og utvalg ved bruk av index\nVi kan plukke ut elementer fra en streng på følgende måter:\n* Elementet med index i: streng[i]\n* Elementene fra og med index i til (men ikke med) index j: streng[i:j]\n* Elementene fra og med index i til (men ikke med) index j, der vi plukker ut hvert element nummer k: streng[i:j:k]\n\nFor den siste varianten betyr k=2 at vi tar annethvert element. For k=3 tar vi hvert tredje element.\n\nVi må være bevisst at strenger i Python har index som begynner på 0. Dersom vi ber om en index som ikke finnes får vi en feilmelding. Under har vi en streng med 10 elementer, det vil si at indexene går fra 0 til 9. Legg merke til at mellomrommet mellom [ og { er et av tegnene."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "demotekst = \"abc123[ {%\"\nalpha = demotekst[0]\nprint(alpha)\nbeta = demotekst[2]\nprint(beta)\n#gamma = demotekst[10]\n#print(gamma)",
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": "a\nc\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Prøv å fjerne de to #-tegnene fra de siste to linjene og kjør den cellen på nytt. Feilmeldingen \"IndexError: string index out of range\" forteller oss at vi har prøvd å bruke en index som ikke eksisterer for det elementet vi ser på. Pilen peker på linje 6 for å fortelle oss hvor feilen oppsto. Sett #-tegnene tilbake igjen før du går videre. Selv om det er 10 elementer i strengen kan vi ikke be om streng[10], siden det vil være det ellevte elementet."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Øving: Tenk over hva som vil printes dersom følgende kommandoer kjøres. Når du har tenkt over det og skrevet ned resultatet, kjør kommandoene i en ny celle.\n* print(demotekst[4])\n* print(demotekst[7])"
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Øving: Skriv ned to linjer som gir følgende print på skjermen når de kjøres:\n\n[\n\na"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "#### Negative indexer\nVi kan bruke negative indexer for å referere til elementer en viss avstand fra slutten av strengen. Skriver vi streng[-1] refererer vi til det siste elementet, streng[-2] refererer til det nest siste elementet."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(demotekst[-1])\nprint(demotekst[-2])",
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": "%\n{\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Øving: Tenk over hva som vil printes dersom følgende kommandoer kjøres. Når du har tenkt over det og skrevet ned resultatet, kjør kommandoene i en ny celle.\n* print(demotekst[-8])\n* print(demotekst[-3])"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Øving: Skriv ned to linjer som gir følgende to linjer med print på skjermen når de kjøres. Bruk negative indexer.\n\n[\n\na"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "#### Utvalg av flere elementer (engelsk: slicing)\nVi kan gjøre et utvalg som vist under. I det første eksempelet velger vi alle elementene med index fra og med 2 til (men ikke med) 6. Effektivt betyr det index 2-5, og det gir element nummer 3-6 (siden indexene begynner på 0)."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(demotekst[2:6])",
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": "c123\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Øving: Tenk over hva som vil printes dersom følgende kommandoer kjøres. Når du har tenkt over det og skrevet ned resultatet, kjør kommandoene i en ny celle.\n* print(demotekst[4:7])\n* print(demotekst[0:9])"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Øving: Skriv ned to linjer som gir følgende to linjer med print på skjermen når de kjøres:\n\n3[ {\n\nbc"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "#### Utelatelse av indexer\nVi kan gå til enden av en streng ved å skrive streng[3:]. Ved å ikke ha noe avsluttende element går utvalget helt til og med det siste elementet. Vi kan også utelate den første indexen, da går utvalget fra og med det første elementet (index 0). Ved å kombinere disse kan vi skrive streng[:] for å få alle elementene. For en streng er dette mengingsløst siden vi bare kan skrive strengens navn i seg selv, men for en liste betyr dette noe."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(demotekst[3:])\nprint(demotekst[:5])\nprint(demotekst[:])",
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": "123[ {%\nabc12\nabc123[ {%\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Øving: Tenk over hva som vil printes dersom følgende kommandoer kjøres. Etter at du har bestemt deg og skrevet ned svaret ditt, kjør kommandoene og sjekk om det stemte.\n* print(demotekst[:-7])\n* print(demotekst[-5:])"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Lengden av en streng\nVi kan finne antall elementer i en streng ved å bruke len(streng). Legg merke til at mellomrom teller som et tegn. Dette er en svært nyttig kommando som brukes i mange sammenhenger. For å se det må vi bli bedre kjent med flere verktøy, som f.eks. lister (engelsk: lists) og løkker (engelsk: loops)."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(demotekst)\nprint(len(demotekst))",
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": "abc123[ {%\n10\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Legge sammen strenger\nDersom vi har flere strenger kan de slås sammen til én streng. Dette kan gjøres på flere måter, her er en den mest direkte og enkleste (i enkle tilfeller):"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "ord1 = \"Hei\"\nord2 = \"på\"\nord3 = \"deg\"\ntekst = ord1 + ord2 + ord3\nprint(tekst)",
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Heipådeg\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Det virket, men det mangler noe. Vi kan rette opp i det ved å legge inn mellomrom og et punktum manuelt."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "tekst = ord1 + \" \" + ord2 + \" \" + ord3 + \".\"\nprint(tekst)",
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Hei på deg.\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Dersom det er mange ord blir det kontraproduktivt (og nesten uoverkommelig) å skrive dette manuelt. Da kan vi bruke løkker eller automatisere på annet vis. Se annen del om for-løkker for et eksempel på dette."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Øving: Lag og print en setning på måten vist over."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Under definerer jeg noen variabler. Bruk dem for å lage og printe setningen \"Det er 12 måneder i året.\" med metoden vist over. Bruk den tomme linjen nederst i neste celle."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "ord1 = \"Det\"\nord2 = \"er\"\nord3 = 12\nord4 = \"måneder\"\nord5 = \"i\"\nord6 = \"året\"\n",
      "execution_count": 12,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Antageligvis brukte du en av de to metodene under:\n\n> tekst = ord1 + \" \" + ord2 + \" \" + ord3 + \" \" + ord4 + \" \" + ord5 + \" \" + ord6 + \".\"\n\n> print(tekst)\n\neller \n\n> print(ord1 + \" \" + ord2 + \" \" + ord3 + \" \" + ord4 + \" \" + ord5 + \" \" + ord6 + \".\")\n\nI så fall fikk du en feilmelding \"TypeError: unsupported operand type(s) for +: 'int' and 'str'\". Problemet her er at ord3 er av typen \"int\" mens de andre er av typen \"str\". Husk at \"int\" er integer eller heltall, mens \"str\" er string eller streng.\n\nVi kan fikse dette på to måter. Den ene måten er å skrive om definisjonen av ord3:\n\nord3 = \"12\"\n\nDen andre og mye kraftigere metoden er å transformere innholdet i variabelen \"ord3\" til type \"str\"."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "ord1 = \"Det\"\nord2 = \"er\"\nord3 = 12\nord4 = \"måneder\"\nord5 = \"i\"\nord6 = \"året\"\nprint(str(ord1) + \" \" + str(ord2) + \" \" + str(ord3) + \" \" + str(ord4) + \" \" + str(ord5) + \" \" + str(ord6) + \".\")",
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Det er 12 måneder i året.\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Det er selvfølgelig ikke nødvendig å endre typen til de andre ordene, men hvis man ikke vet om typen er \"str\" eller noe annet er det mulig å gjøre som vist over. Vær forsiktig, ikke alle typer objekter kan transformeres til \"str\"."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Over så vi et lite utvalg av alle metodene som finnes. For å få en fullstendig oversikt kan vi sjekke hjelpeteksten ved å skrive help(str). Hopp over alle linjene som begynner med dobbel understrek, som \\__add__(self, value, /). Det finnes veldig mange metoder, det viktigste nå er det som er vist over, og å være klar over hvor man kan finne mer informasjon. Teksten under kan være tunglest pga. formatet, husk at det også er beskrevet på nettsiden: https://docs.python.org/3/library/stdtypes.html#string-methods"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "help(str)",
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Help on class str in module builtins:\n\nclass str(object)\n |  str(object='') -> str\n |  str(bytes_or_buffer[, encoding[, errors]]) -> str\n |  \n |  Create a new string object from the given object. If encoding or\n |  errors is specified, then the object must expose a data buffer\n |  that will be decoded using the given encoding and error handler.\n |  Otherwise, returns the result of object.__str__() (if defined)\n |  or repr(object).\n |  encoding defaults to sys.getdefaultencoding().\n |  errors defaults to 'strict'.\n |  \n |  Methods defined here:\n |  \n |  __add__(self, value, /)\n |      Return self+value.\n |  \n |  __contains__(self, key, /)\n |      Return key in self.\n |  \n |  __eq__(self, value, /)\n |      Return self==value.\n |  \n |  __format__(...)\n |      S.__format__(format_spec) -> str\n |      \n |      Return a formatted version of S as described by format_spec.\n |  \n |  __ge__(self, value, /)\n |      Return self>=value.\n |  \n |  __getattribute__(self, name, /)\n |      Return getattr(self, name).\n |  \n |  __getitem__(self, key, /)\n |      Return self[key].\n |  \n |  __getnewargs__(...)\n |  \n |  __gt__(self, value, /)\n |      Return self>value.\n |  \n |  __hash__(self, /)\n |      Return hash(self).\n |  \n |  __iter__(self, /)\n |      Implement iter(self).\n |  \n |  __le__(self, value, /)\n |      Return self<=value.\n |  \n |  __len__(self, /)\n |      Return len(self).\n |  \n |  __lt__(self, value, /)\n |      Return self<value.\n |  \n |  __mod__(self, value, /)\n |      Return self%value.\n |  \n |  __mul__(self, value, /)\n |      Return self*value.n\n |  \n |  __ne__(self, value, /)\n |      Return self!=value.\n |  \n |  __new__(*args, **kwargs) from builtins.type\n |      Create and return a new object.  See help(type) for accurate signature.\n |  \n |  __repr__(self, /)\n |      Return repr(self).\n |  \n |  __rmod__(self, value, /)\n |      Return value%self.\n |  \n |  __rmul__(self, value, /)\n |      Return self*value.\n |  \n |  __sizeof__(...)\n |      S.__sizeof__() -> size of S in memory, in bytes\n |  \n |  __str__(self, /)\n |      Return str(self).\n |  \n |  capitalize(...)\n |      S.capitalize() -> str\n |      \n |      Return a capitalized version of S, i.e. make the first character\n |      have upper case and the rest lower case.\n |  \n |  casefold(...)\n |      S.casefold() -> str\n |      \n |      Return a version of S suitable for caseless comparisons.\n |  \n |  center(...)\n |      S.center(width[, fillchar]) -> str\n |      \n |      Return S centered in a string of length width. Padding is\n |      done using the specified fill character (default is a space)\n |  \n |  count(...)\n |      S.count(sub[, start[, end]]) -> int\n |      \n |      Return the number of non-overlapping occurrences of substring sub in\n |      string S[start:end].  Optional arguments start and end are\n |      interpreted as in slice notation.\n |  \n |  encode(...)\n |      S.encode(encoding='utf-8', errors='strict') -> bytes\n |      \n |      Encode S using the codec registered for encoding. Default encoding\n |      is 'utf-8'. errors may be given to set a different error\n |      handling scheme. Default is 'strict' meaning that encoding errors raise\n |      a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and\n |      'xmlcharrefreplace' as well as any other name registered with\n |      codecs.register_error that can handle UnicodeEncodeErrors.\n |  \n |  endswith(...)\n |      S.endswith(suffix[, start[, end]]) -> bool\n |      \n |      Return True if S ends with the specified suffix, False otherwise.\n |      With optional start, test S beginning at that position.\n |      With optional end, stop comparing S at that position.\n |      suffix can also be a tuple of strings to try.\n |  \n |  expandtabs(...)\n |      S.expandtabs(tabsize=8) -> str\n |      \n |      Return a copy of S where all tab characters are expanded using spaces.\n |      If tabsize is not given, a tab size of 8 characters is assumed.\n |  \n |  find(...)\n |      S.find(sub[, start[, end]]) -> int\n |      \n |      Return the lowest index in S where substring sub is found,\n |      such that sub is contained within S[start:end].  Optional\n |      arguments start and end are interpreted as in slice notation.\n |      \n |      Return -1 on failure.\n |  \n |  format(...)\n |      S.format(*args, **kwargs) -> str\n |      \n |      Return a formatted version of S, using substitutions from args and kwargs.\n |      The substitutions are identified by braces ('{' and '}').\n |  \n |  format_map(...)\n |      S.format_map(mapping) -> str\n |      \n |      Return a formatted version of S, using substitutions from mapping.\n |      The substitutions are identified by braces ('{' and '}').\n |  \n |  index(...)\n |      S.index(sub[, start[, end]]) -> int\n |      \n |      Like S.find() but raise ValueError when the substring is not found.\n |  \n |  isalnum(...)\n |      S.isalnum() -> bool\n |      \n |      Return True if all characters in S are alphanumeric\n |      and there is at least one character in S, False otherwise.\n |  \n |  isalpha(...)\n |      S.isalpha() -> bool\n |      \n |      Return True if all characters in S are alphabetic\n |      and there is at least one character in S, False otherwise.\n |  \n |  isdecimal(...)\n |      S.isdecimal() -> bool\n |      \n |      Return True if there are only decimal characters in S,\n |      False otherwise.\n |  \n |  isdigit(...)\n |      S.isdigit() -> bool\n |      \n |      Return True if all characters in S are digits\n |      and there is at least one character in S, False otherwise.\n |  \n |  isidentifier(...)\n |      S.isidentifier() -> bool\n |      \n |      Return True if S is a valid identifier according\n |      to the language definition.\n |      \n |      Use keyword.iskeyword() to test for reserved identifiers\n |      such as \"def\" and \"class\".\n |  \n |  islower(...)\n |      S.islower() -> bool\n |      \n |      Return True if all cased characters in S are lowercase and there is\n |      at least one cased character in S, False otherwise.\n |  \n |  isnumeric(...)\n |      S.isnumeric() -> bool\n |      \n |      Return True if there are only numeric characters in S,\n |      False otherwise.\n |  \n |  isprintable(...)\n |      S.isprintable() -> bool\n |      \n |      Return True if all characters in S are considered\n |      printable in repr() or S is empty, False otherwise.\n |  \n |  isspace(...)\n |      S.isspace() -> bool\n |      \n |      Return True if all characters in S are whitespace\n |      and there is at least one character in S, False otherwise.\n |  \n |  istitle(...)\n |      S.istitle() -> bool\n |      \n |      Return True if S is a titlecased string and there is at least one\n |      character in S, i.e. upper- and titlecase characters may only\n |      follow uncased characters and lowercase characters only cased ones.\n |      Return False otherwise.\n |  \n |  isupper(...)\n |      S.isupper() -> bool\n |      \n |      Return True if all cased characters in S are uppercase and there is\n |      at least one cased character in S, False otherwise.\n |  \n |  join(...)\n |      S.join(iterable) -> str\n |      \n |      Return a string which is the concatenation of the strings in the\n |      iterable.  The separator between elements is S.\n |  \n |  ljust(...)\n |      S.ljust(width[, fillchar]) -> str\n |      \n |      Return S left-justified in a Unicode string of length width. Padding is\n |      done using the specified fill character (default is a space).\n |  \n |  lower(...)\n |      S.lower() -> str\n |      \n |      Return a copy of the string S converted to lowercase.\n |  \n |  lstrip(...)\n |      S.lstrip([chars]) -> str\n |      \n |      Return a copy of the string S with leading whitespace removed.\n |      If chars is given and not None, remove characters in chars instead.\n |  \n |  partition(...)\n |      S.partition(sep) -> (head, sep, tail)\n |      \n |      Search for the separator sep in S, and return the part before it,\n |      the separator itself, and the part after it.  If the separator is not\n |      found, return S and two empty strings.\n |  \n |  replace(...)\n |      S.replace(old, new[, count]) -> str\n |      \n |      Return a copy of S with all occurrences of substring\n |      old replaced by new.  If the optional argument count is\n |      given, only the first count occurrences are replaced.\n |  \n |  rfind(...)\n |      S.rfind(sub[, start[, end]]) -> int\n |      \n |      Return the highest index in S where substring sub is found,\n |      such that sub is contained within S[start:end].  Optional\n |      arguments start and end are interpreted as in slice notation.\n |      \n |      Return -1 on failure.\n |  \n |  rindex(...)\n |      S.rindex(sub[, start[, end]]) -> int\n |      \n |      Like S.rfind() but raise ValueError when the substring is not found.\n |  \n |  rjust(...)\n |      S.rjust(width[, fillchar]) -> str\n |      \n |      Return S right-justified in a string of length width. Padding is\n |      done using the specified fill character (default is a space).\n |  \n |  rpartition(...)\n |      S.rpartition(sep) -> (head, sep, tail)\n |      \n |      Search for the separator sep in S, starting at the end of S, and return\n |      the part before it, the separator itself, and the part after it.  If the\n |      separator is not found, return two empty strings and S.\n |  \n |  rsplit(...)\n |      S.rsplit(sep=None, maxsplit=-1) -> list of strings\n |      \n |      Return a list of the words in S, using sep as the\n |      delimiter string, starting at the end of the string and\n |      working to the front.  If maxsplit is given, at most maxsplit\n |      splits are done. If sep is not specified, any whitespace string\n |      is a separator.\n |  \n |  rstrip(...)\n |      S.rstrip([chars]) -> str\n |      \n |      Return a copy of the string S with trailing whitespace removed.\n |      If chars is given and not None, remove characters in chars instead.\n |  \n |  split(...)\n |      S.split(sep=None, maxsplit=-1) -> list of strings\n |      \n |      Return a list of the words in S, using sep as the\n |      delimiter string.  If maxsplit is given, at most maxsplit\n |      splits are done. If sep is not specified or is None, any\n |      whitespace string is a separator and empty strings are\n |      removed from the result.\n |  \n |  splitlines(...)\n |      S.splitlines([keepends]) -> list of strings\n |      \n |      Return a list of the lines in S, breaking at line boundaries.\n |      Line breaks are not included in the resulting list unless keepends\n |      is given and true.\n |  \n |  startswith(...)\n |      S.startswith(prefix[, start[, end]]) -> bool\n |      \n |      Return True if S starts with the specified prefix, False otherwise.\n |      With optional start, test S beginning at that position.\n |      With optional end, stop comparing S at that position.\n |      prefix can also be a tuple of strings to try.\n |  \n |  strip(...)\n |      S.strip([chars]) -> str\n |      \n |      Return a copy of the string S with leading and trailing\n |      whitespace removed.\n |      If chars is given and not None, remove characters in chars instead.\n |  \n |  swapcase(...)\n |      S.swapcase() -> str\n |      \n |      Return a copy of S with uppercase characters converted to lowercase\n |      and vice versa.\n |  \n |  title(...)\n |      S.title() -> str\n |      \n |      Return a titlecased version of S, i.e. words start with title case\n |      characters, all remaining cased characters have lower case.\n |  \n |  translate(...)\n |      S.translate(table) -> str\n |      \n |      Return a copy of the string S in which each character has been mapped\n |      through the given translation table. The table must implement\n |      lookup/indexing via __getitem__, for instance a dictionary or list,\n |      mapping Unicode ordinals to Unicode ordinals, strings, or None. If\n |      this operation raises LookupError, the character is left untouched.\n |      Characters mapped to None are deleted.\n |  \n |  upper(...)\n |      S.upper() -> str\n |      \n |      Return a copy of S converted to uppercase.\n |  \n |  zfill(...)\n |      S.zfill(width) -> str\n |      \n |      Pad a numeric string S with zeros on the left, to fill a field\n |      of the specified width. The string S is never truncated.\n |  \n |  ----------------------------------------------------------------------\n |  Static methods defined here:\n |  \n |  maketrans(x, y=None, z=None, /)\n |      Return a translation table usable for str.translate().\n |      \n |      If there is only one argument, it must be a dictionary mapping Unicode\n |      ordinals (integers) or characters to Unicode ordinals, strings or None.\n |      Character keys will be then converted to ordinals.\n |      If there are two arguments, they must be strings of equal length, and\n |      in the resulting dictionary, each character in x will be mapped to the\n |      character at the same position in y. If there is a third argument, it\n |      must be a string, whose characters will be mapped to None in the result.\n\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Ekstra materiale\nStoffet under er nyttig, men kan vente til senere om du ikke vil se på det nå."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## Her følger mer om utvalg av elementer\n\nVi kan bruke negative indekser også når vi slicer en tekst:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "demotekst = \"abc123[ {%\"\nprint(demotekst[2:-4])\nprint(demotekst[-5:-1])",
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "text": "c123\n3[ {\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Øving: Tenk over hva som vil printes dersom følgende kommandoer kjøres. Når du har tenkt over det og skrevet ned resultatet, kjør kommandoene i en ny celle.\n* print(demotekst[-6:-3])\n* print(demotekst[-9:-1])"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Øving: Skriv ned to linjer som gir følgende print på skjermen når de kjøres. Bruk negative indexer for både start- og sluttpunktet.\n\n3[ {\n\nbc"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Vi kan også gjøre et utvalg av elementer som ikke følger direkte etter hverandre:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(demotekst[1:9:2])",
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "text": "b13 \n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Legg merke til at i det forrige eksempelet fikk vi elementene med index 1, 3, 5 og 7. Det neste ville vært 9, men vi skulle stoppe før 9, så det ble ikke med. Legg særlig merke til at mellomrommet på index 7 er med her, etter 3-tallet. Prøv å markere med musen for å se det."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Øving: Tenk over hva som vil printes dersom følgende kommandoer kjøres. Når du har tenkt over det og skrevet ned resultatet, kjør kommandoene i en ny celle.\n* print(demotekst[0:7:3])\n* print(demotekst[-9:6:2])"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Øving: Skriv ned fire linjer som gir følgende print på skjermen når de kjøres. Gjør det en gang med bare positive indexer og en gang med bare negative indexer for både start- og sluttpunktet.\n\nb3\n\nc3"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Dersom vi gjør et utvalg der vi ber om å starte på et element og stoppe på et tidligere element får vi ingen elementer. I eksempelet under produserer print-kommandoen ingenting fordi utvalget blir en streng uten elementer. Dette kan være aktuelt dersom vi ikke vet hvor mange elementer som skal være med, men har en formel for å beregne hva som er første og siste element. Dersom formlene gir en startverdi som er lik eller større enn sluttverdien blir lengden 0."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(demotekst[4:1])",
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "text": "\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Øving: Tenk over hva som vil printes dersom følgende kommandoer kjøres. Hvilke av kommandoene gir ingen output? Etter at du har bestemt deg og skrevet ned svaret ditt, kjør kommandoene og sjekk om det stemte.\n* print(demotekst[2:5:7])\n* print(demotekst[-2:3])\n* print(demotekst[-8:-3])\n* print(demotekst[-5:7:2])\n* print(demotekst[-3:8])"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## Gjenta en streng et visst antall ganger."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "\"tekst\" * 4",
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 18,
          "data": {
            "text/plain": "'teksttekstteksttekst'"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## Andre metoder for strenger\nHer er noen metoder som kan være nyttige."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "tekst = \"her er det tEKST og 2-3 tall. Er det sant.\"\nprint(tekst.capitalize()) # Gjør første bokstav stor og alle andre små.\nprint(tekst.title()) # Gjør første bokstav i hvert ord stor og alle andre små.\nprint(tekst.center(50, \"ø\")) # Legger på \"ø\" rundt teksten for at den skal bli 50 tegn lang.\nprint(tekst.count(\"e\")) # Teller antall forekomster av \"e\".\nprint(tekst.find(\" er\")) # Finner indexen der \" er\" står første gang.\nprint(tekst.find(\"eple\")) # Dersom teksten ikke finnes får vi tilbake -1.\nprint(tekst.isalnum()) # True dersom alle tegnene er bokstaver eller tall. \"alnum\" står for alphanumeric.\nprint(tekst.replace(\"er\",\"var\")) # Erstatter alle tilfeller av \"er\". Merk at \"Er\" i setning 2 ikke erstattes. Vi mister også \"er\" inne i ord.\nprint(tekst.replace(\" er \",\" var \")) # Erstatter alle tilfeller av \" er \". Vi kan ta med mellomrom for å sørge for at bare separate ord. Hva skjer dersom siste ord i en setning er \"er\"? Da har vi ikke \" er \", men kanskje \" er.\" eller \" er?\"\nprint(tekst.rstrip(\"asrhe.ln t\")) # Begynner på høyre side. Fjerner alle tegn som er gitt som argument. Stopper når et tegn ikke er i argumentet.\nprint(tekst.strip(\"asrhe.ln t\")) # Går gjennom strengen fra høyre og venstre side. Fjerner alle tegn som er gitt som argument. Stopper når et tegn ikke er i argumentet.",
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Her er det tekst og 2-3 tall. er det sant.\nHer Er Det Tekst Og 2-3 Tall. Er Det Sant.\nøøøøher er det tEKST og 2-3 tall. Er det sant.øøøø\n4\n3\n-1\nFalse\nhvar var det tEKST og 2-3 tall. Er det sant.\nher var det tEKST og 2-3 tall. Er det sant.\nher er det tEKST og 2-3 tall. Er d\ndet tEKST og 2-3 tall. Er d\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## Søk i tekst\nVi kan søke i teksten i en streng. Vi kan både sjekke om noe (ikke) finnes der (True/False) og telle antall forekomster av noe, og vi kan sjekke hvor i strengen noe finnes."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "demotekst3 = \"aaabcdefaklmnaa\"\nprint(demotekst3)\nprint(\"aa\" in demotekst3)\nprint(\"AA\" in demotekst3)\nprint(\"pqr\" not in demotekst3)\nprint(demotekst3.count(\"aa\"))\nprint(demotekst3.find(\"f\"))",
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "text": "aaabcdefaklmnaa\nTrue\nFalse\nTrue\n2\n7\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Legg merke til at det betyr noe om vi bruker store eller små bokstaver.\n\nLegg merke til at når \"aa\" er funnet blant de første tre a-ene kan ikke den andre a-en brukes i et par med den tredje a-en."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## Linjeskift (engelsk: newline) og tegnene \\ og \" og '"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(\"Tekst kan inneholde linjeskift ved å skrive\\nhvor som helst i teksten.\")\n\nprint(\"Den skrå streken indikerer at det kommer en spesiell kommando, f.eks. n for linjeskift.\")\n\nprint(\"For å vise \\\\ må vi skrive to stykker.\")\n\nprint(\"for å vise \\\" må vi skrive \\\\\\\", effektivt med tre \\\\ før \\\" i selve koden.\")\n\nprint('Alternativt kan vi bruke enkle sitattegn, de tillater \"doble sitattegn\" uten videre.')\n\nprint(\"Motsatt ser vi at doble sitattegn tillater 'enkle sitattegn' uten videre.\")",
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Tekst kan inneholde linjeskift ved å skrive\nhvor som helst i teksten.\nDen skrå streken indikerer at det kommer en spesiell kommando, f.eks. n for linjeskift.\nFor å vise \\ må vi skrive to stykker.\nfor å vise \" må vi skrive \\\", effektivt med tre \\ før \" i selve koden.\nAlternativt kan vi bruke enkle sitattegn, de tillater \"doble sitattegn\" uten videre.\nMotsatt ser vi at doble sitattegn tillater 'enkle sitattegn' uten videre.\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## Største og minste element i en streng\nVi kan finne \"største\" og \"minste\" element i en streng ved å bruke max(streng) og min(streng). Når vi gjør dette sorteres tegnene etter rekkefølgen definert i ASCII, se f.eks. denne siden: http://www.theasciicode.com.ar/\n\nTallene kommer før de store bokstavene som kommer før de små bokstavene. Det innebærer at en liten k er \"større\" enn en stor N, og at en stor G er \"mindre\" enn en liten b."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "demotekst4 = \"gikGNdb\"\nprint(demotekst4)\nprint(max(demotekst4))\nprint(min(demotekst4))",
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "text": "gikGNdb\nk\nG\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "###### Øystein Grøndahl, oktober 2018"
    }
  ],
  "metadata": {
    "anaconda-cloud": {},
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3",
      "language": "python"
    },
    "language_info": {
      "mimetype": "text/x-python",
      "nbconvert_exporter": "python",
      "name": "python",
      "pygments_lexer": "ipython3",
      "version": "3.5.4",
      "file_extension": ".py",
      "codemirror_mode": {
        "version": 3,
        "name": "ipython"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 1
}