# 3. En informell introduktion till Python

In the following examples, input and output are distinguished by the presence or absence of prompts (>>> and …): to repeat the example, you must type everything after the prompt, when the prompt appears; lines that do not begin with a prompt are output from the interpreter. Note that a secondary prompt on a line by itself in an example means you must type a blank line; this is used to end a multi-line command.

Du kan använda knappen ”Kopiera” (den visas i det övre högra hörnet när du håller muspekaren över eller trycker på ett kodexempel), som tar bort uppmaningar och utelämnar utdata, för att kopiera och klistra in inmatningsraderna i din tolk.

Många av exemplen i den här handboken, även de som skrivs in i den interaktiva prompten, innehåller kommentarer. Kommentarer i Python börjar med hashtecknet, `#`, och sträcker sig till slutet av den fysiska raden. En kommentar kan förekomma i början av en rad eller efter blanksteg eller kod, men inte inom en stränglitteral. Ett hash-tecken inom en stränglitual är bara ett hash-tecken. Eftersom kommentarer är till för att förtydliga koden och inte tolkas av Python, kan de utelämnas när du skriver in exempel.

Några exempel:

    # detta är den första kommentaren
    spam = 1 # och det här är den andra kommentaren
              # ... och nu en tredje!
    text = "# Det här är inte en kommentar eftersom den är inom citationstecken."

## 3.1. Använda Python som kalkylator

Let’s try some simple Python commands. Start the interpreter and wait for the primary prompt, `>>>`. (It shouldn’t take long.)

### 3.1.1. Nummer

The interpreter acts as a simple calculator: you can type an expression into it and it will write the value. Expression syntax is straightforward: the operators `+`, `-`, `*` and `/` can be used to perform arithmetic; parentheses (`()`) can be used for grouping. For example:

    >>> 2 + 2
    4
    >>> 50 - 5*6
    20
    >>> (50 - 5*6) / 4
    5.0
    >>> 8 / 5  # division always returns a floating-point number
    1.6

Heltalen (t.ex. `2`, `4`, `20`) har typen `int`, de med en bråkdel (t.ex. `5,0`, `1,6`) har typen `float`. Vi kommer att se mer om numeriska typer senare i handledningen.

Division (`/`) returnerar alltid en float. För att göra floor division och få ett heltalsresultat kan du använda operatorn `//`; för att beräkna resten kan du använda `%`:

    >>> 17 / 3  # classic division returns a float
    5.666666666666667
    >>>
    >>> 17 // 3  # floor division discards the fractional part
    5
    >>> 17 % 3  # the % operator returns the remainder of the division
    2
    >>> 5 * 3 + 2  # floored quotient * divisor + remainder
    17

Med Python är det möjligt att använda operatorn `**` för att beräkna potenser [1]:

    >>> 5 ** 2  # 5 squared
    25
    >>> 2 ** 7  # 2 to the power of 7
    128

Likhetstecknet (`=`) används för att tilldela en variabel ett värde. Därefter visas inget resultat före nästa interaktiva prompt:

    >>> width = 20
    >>> height = 5 * 9
    >>> width * height
    900

Om en variabel inte är ”definierad” (tilldelad ett värde) får du ett felmeddelande när du försöker använda den:

    >>> n  # try to access an undefined variable
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    NameError: name 'n' is not defined

Det finns fullt stöd för flyttal; operatorer med operander av blandad typ konverterar heltalsoperanden till flyttal:

    >>> 4 * 3.75 - 1
    14.0

I interaktivt läge tilldelas det senast utskrivna uttrycket till variabeln `_`. Detta innebär att när du använder Python som en skrivbordsräknare, är det något lättare att fortsätta beräkningar, till exempel:

    >>> tax = 12.5 / 100
    >>> price = 100.50
    >>> price * tax
    12.5625
    >>> price + _
    113.0625
    >>> round(_, 2)
    113.06

Denna variabel bör behandlas som skrivskyddad av användaren. Tilldela inte uttryckligen ett värde till den — du skulle skapa en oberoende lokal variabel med samma namn som maskerar den inbyggda variabeln med sitt magiska beteende.

Förutom `int` och `float` har Python stöd för andra typer av tal, till exempel `Decimal` och `Fraction`. Python har också inbyggt stöd för komplexa tal, och använder suffixet `j` eller `J` för att ange den imaginära delen (t.ex. `3+5j`).

### 3.1.2. Text

Python kan manipulera text (representerad av typen `str`, s.k. ”strängar”) såväl som siffror. Detta inkluderar tecken ”`!`”, ord ”`kanin`”, namn ”`Paris`”, meningar ”`Got your back.`”, etc. ”`Yay! :)`”. De kan omslutas av enkla citattecken (`'...'`) eller dubbla citattecken (`"...'`) med samma resultat [2].

    >>> 'spam eggs'  # single quotes
    'spam eggs'
    >>> "Paris rabbit got your back :)! Yay!"  # double quotes
    'Paris rabbit got your back :)! Yay!'
    >>> '1975'  # digits and numerals enclosed in quotes are also strings
    '1975'

För att citera ett citat måste vi ”undkomma” det genom att föregå det med `\`. Alternativt kan vi använda den andra typen av citattecken:

    >>> 'doesn\'t'  # use \' to escape the single quote...
    "doesn't"
    >>> "doesn't"  # ...or use double quotes instead
    "doesn't"
    >>> '"Yes," they said.'
    '"Yes," they said.'
    >>> "\"Yes,\" they said."
    '"Yes," they said.'
    >>> '"Isn\'t," they said.'
    '"Isn\'t," they said.'

I Python-skalet kan strängdefinitionen och utdatasträngen se olika ut. Funktionen `print()` ger en mer läsbar utdata genom att utelämna de omslutande citattecknen och skriva ut undangömda tecken och specialtecken:

    >>> s = 'First line.\nSecond line.'  # \n means newline
    >>> s  # without print(), special characters are included in the string
    'First line.\nSecond line.'
    >>> print(s)  # with print(), special characters are interpreted, so \n produces new line
    First line.
    Second line.

Om du inte vill att tecken som inleds med `\` ska tolkas som specialtecken kan du använda raw strings genom att lägga till ett `r` före det första citatet:

    >>> print('C:\this\name')  # here \t means tab, \n means newline
    C:      his
    ame
    >>> print(r'C:\this\name')  # note the r before the quote
    C:\this\name

Det finns en subtil aspekt av råa strängar: en rå sträng får inte sluta med ett udda antal `\`-tecken; se Frågor och svar-artikeln för mer information och lösningar.

Stränglitteraler kan sträcka sig över flera rader. Ett sätt är att använda tredubbla citationstecken: `"""..."""` eller `'''...'''`. Tecken i slutet av raden inkluderas automatiskt i strängen, men det är möjligt att förhindra detta genom att lägga till en `\` i slutet av raden. I följande exempel inkluderas inte den inledande nya linjen:

    >>> print("""\
    ... Usage: thingy [OPTIONS]
    ...      -h                        Display this usage message
    ...      -H hostname               Hostname to connect to
    ... """)
    Usage: thingy [OPTIONS]
         -h                        Display this usage message
         -H hostname               Hostname to connect to

    >>>

Strängar kan konkateneras (sammanfogas) med operatorn `+` och upprepas med `*`:

    >>> # 3 times 'un', followed by 'ium'
    >>> 3 * 'un' + 'ium'
    'unununium'

Två eller flera stränglitteraler (dvs. de som är inneslutna mellan citattecken) bredvid varandra konkateneras automatiskt.

    >>> 'Py' 'thon'
    'Python'

Denna funktion är särskilt användbar när du vill bryta långa strängar:

    >>> text = ('Put several strings within parentheses '
    ...         'to have them joined together.')
    >>> text
    'Put several strings within parentheses to have them joined together.'

Detta fungerar dock bara med två literaler, inte med variabler eller uttryck:

    >>> prefix = 'Py'
    >>> prefix 'thon'  # can't concatenate a variable and a string literal
      File "<stdin>", line 1
        prefix 'thon'
               ^^^^^^
    SyntaxError: invalid syntax
    >>> ('un' * 3) 'ium'
      File "<stdin>", line 1
        ('un' * 3) 'ium'
                   ^^^^^
    SyntaxError: invalid syntax

Om du vill sammanfoga variabler eller en variabel och en bokstav, använd `+`:

    >>> prefix + 'thon'
    'Python'

Strängar kan indexeras (subskriberas), varvid det första tecknet har index 0. Det finns ingen separat teckentyp, utan ett tecken är helt enkelt en sträng av storleken ett:

    >>> word = 'Python'
    >>> word[0]  # character in position 0
    'P'
    >>> word[5]  # character in position 5
    'n'

Index kan också vara negativa tal, för att börja räkna från höger:

    >>> word[-1]  # last character
    'n'
    >>> word[-2]  # second-last character
    'o'
    >>> word[-6]
    'P'

Observera att eftersom -0 är samma sak som 0, börjar negativa index från -1.

Förutom indexering stöds även slicing. Medan indexering används för att få fram enskilda tecken, kan du med slicing få fram en delsträng:

    >>> word[0:2]  # characters from position 0 (included) to 2 (excluded)
    'Py'
    >>> word[2:5]  # characters from position 2 (included) to 5 (excluded)
    'tho'

Slice-index har användbara standardvärden; ett utelämnat första index har standardvärdet noll, ett utelämnat andra index har standardvärdet storleken på den sträng som ska skivas:

    >>> word[:2]   # character from the beginning to position 2 (excluded)
    'Py'
    >>> word[4:]   # characters from position 4 (included) to the end
    'on'
    >>> word[-2:]  # characters from the second-last (included) to the end
    'on'

Notera att början alltid är inkluderad och slutet alltid exkluderat. Detta säkerställer att `s[:i] + s[i:]` alltid är lika med `s`:

    >>> word[:2] + word[2:]
    'Python'
    >>> word[:4] + word[4:]
    'Python'

Ett sätt att komma ihåg hur skivorna fungerar är att tänka på indexen som pekande mellan tecken, med vänsterkanten på det första tecknet numrerat 0. Sedan har högerkanten på det sista tecknet i en sträng med n tecken index n, till exempel:

     +---+---+---+---+---+---+
     | P | y | t | h | o | n |
     +---+---+---+---+---+---+
     0   1   2   3   4   5   6
    -6  -5  -4  -3  -2  -1

Den första talraden anger positionen för indexen 0…6 i strängen; den andra talraden anger motsvarande negativa index. Skivan från i till j består av alla tecken mellan kanterna märkta i respektive j.

För icke-negativa index är längden på en skiva skillnaden mellan indexen, om båda är inom gränserna. Till exempel är längden på `ord[1:3]` 2.

Försök att använda ett index som är för stort kommer att resultera i ett felmeddelande:

    >>> word[42]  # the word only has 6 characters
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    IndexError: string index out of range

Slice-index som ligger utanför intervallet hanteras dock på ett elegant sätt när de används för slicing:

    >>> word[4:42]
    'on'
    >>> word[42:]
    ''

Python-strängar kan inte ändras — de är immutable. Därför resulterar tilldelning till en indexerad position i strängen i ett fel:

    >>> word[0] = 'J'
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: 'str' object does not support item assignment
    >>> word[2:] = 'py'
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: 'str' object does not support item assignment

Om du behöver en annan sträng ska du skapa en ny:

    >>> 'J' + word[1:]
    'Jython'
    >>> word[:2] + 'py'
    'Pypy'

Den inbyggda funktionen `len()` returnerar längden på en sträng:

    >>> s = 'supercalifragilisticexpialidocious'
    >>> len(s)
    34

Se även

Text Sequence Type — str

  Strängar är exempel på sekvenstyper och stöder de vanliga operationer som stöds av sådana typer.

Strängmetoder

  Strängar har stöd för ett stort antal metoder för grundläggande omvandlingar och sökning.

f-strängar

  Stränglitteraler som har inbäddade uttryck.

Format string syntax

  Information om strängformatering med `str.format()`.

strängformatering i stil med printf

  De gamla formateringsoperationerna som används när strängar är den vänstra operanden i operatorn `%` beskrivs mer i detalj här.

### 3.1.3. Listor

Python känner till ett antal compound-datatyper, som används för att gruppera andra värden. Den mest mångsidiga är list, som kan skrivas som en lista med kommaseparerade värden (objekt) mellan hakparenteser. Listor kan innehålla objekt av olika typer, men vanligtvis har alla objekt samma typ.

    >>> squares = [1, 4, 9, 16, 25]
    >>> squares
    [1, 4, 9, 16, 25]

Precis som strängar (och alla andra inbyggda sequence-typer) kan listor indexeras och skivas:

    >>> squares[0]  # indexing returns the item
    1
    >>> squares[-1]
    25
    >>> squares[-3:]  # slicing returns a new list
    [9, 16, 25]

Listor stöder också operationer som konkatenering:

    >>> squares + [36, 49, 64, 81, 100]
    [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Till skillnad från strängar, som är immutable, är listor en mutable typ, dvs. det är möjligt att ändra deras innehåll:

    >>> cubes = [1, 8, 27, 65, 125]  # something's wrong here
    >>> 4 ** 3  # the cube of 4 is 64, not 65!
    64
    >>> cubes[3] = 64  # replace the wrong value
    >>> cubes
    [1, 8, 27, 64, 125]

You can also add new items at the end of the list, by using the `list.append()` method (we will see more about methods later):

    >>> cubes.append(216)  # add the cube of 6
    >>> cubes.append(7 ** 3)  # and the cube of 7
    >>> cubes
    [1, 8, 27, 64, 125, 216, 343]

Enkel tilldelning i Python kopierar aldrig data. När du tilldelar en lista till en variabel, refererar variabeln till den existerande listan. Alla ändringar som du gör i listan genom en variabel kommer att ses genom alla andra variabler som refererar till den:

    >>> rgb = ["Red", "Green", "Blue"]
    >>> rgba = rgb
    >>> id(rgb) == id(rgba)  # they reference the same object
    True
    >>> rgba.append("Alph")
    >>> rgb
    ["Red", "Green", "Blue", "Alph"]

Alla slice-operationer returnerar en ny lista som innehåller de begärda elementen. Detta innebär att följande slice returnerar en skallig kopia av listan:

    >>> correct_rgba = rgba[:]
    >>> correct_rgba[-1] = "Alpha"
    >>> correct_rgba
    ["Red", "Green", "Blue", "Alpha"]
    >>> rgba
    ["Red", "Green", "Blue", "Alph"]

Tilldelning till skivor är också möjlig, och detta kan till och med ändra listans storlek eller rensa den helt:

    >>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
    >>> letters
    ['a', 'b', 'c', 'd', 'e', 'f', 'g']
    >>> # replace some values
    >>> letters[2:5] = ['C', 'D', 'E']
    >>> letters
    ['a', 'b', 'C', 'D', 'E', 'f', 'g']
    >>> # now remove them
    >>> letters[2:5] = []
    >>> letters
    ['a', 'b', 'f', 'g']
    >>> # clear the list by replacing all the elements with an empty list
    >>> letters[:] = []
    >>> letters
    []

Den inbyggda funktionen `len()` gäller även för listor:

    >>> letters = ['a', 'b', 'c', 'd']
    >>> len(letters)
    4

Det är möjligt att nesta listor (skapa listor som innehåller andra listor), till exempel:

    >>> a = ['a', 'b', 'c']
    >>> n = [1, 2, 3]
    >>> x = [a, n]
    >>> x
    [['a', 'b', 'c'], [1, 2, 3]]
    >>> x[0]
    ['a', 'b', 'c']
    >>> x[0][1]
    'b'

## 3.2. Första stegen mot programmering

Naturligtvis kan vi använda Python för mer komplicerade uppgifter än att lägga ihop två och två. Vi kan till exempel skriva en första undersekvens av Fibonacci-serien på följande sätt:

    >>> # Fibonacci series:
    >>> # the sum of two elements defines the next
    >>> a, b = 0, 1
    >>> while a < 10:
    ...     print(a)
    ...     a, b = b, a+b
    ...
    0
    1
    1
    2
    3
    5
    8

I detta exempel introduceras flera nya funktioner.

- Den första raden innehåller en multipeltilldelning: variablerna `a` och `b` får samtidigt de nya värdena 0 och 1. På den sista raden används detta igen, vilket visar att uttrycken på höger sida alla utvärderas först innan någon av tilldelningarna äger rum. Uttrycken på höger sida utvärderas från vänster till höger.

- Slingan `while` körs så länge villkoret (här: `a < 10`) förblir sant. I Python, precis som i C, är alla heltalsvärden som inte är noll sanna; noll är falskt. Villkoret kan också vara en sträng eller ett listvärde, i själva verket vilken sekvens som helst; allt med en längd som inte är noll är sant, tomma sekvenser är falska. Testet som används i exemplet är en enkel jämförelse. Standardoperatorerna för jämförelser skrivs på samma sätt som i C: `<` (mindre än), `>` (större än), `==` (lika med), `<=` (mindre än eller lika med), `>=` (större än eller lika med) och `!=` (inte lika med).

- Slingans brödtext är indragen: indrag är Pythons sätt att gruppera satser. Vid den interaktiva prompten måste du skriva en tabb eller ett mellanslag för varje indragen rad. I praktiken kommer du att förbereda mer komplicerad inmatning för Python med en textredigerare; alla anständiga textredigerare har en automatisk indenteringsfunktion. När en sammansatt sats skrivs in interaktivt måste den följas av en tom rad för att visa att den är klar (eftersom parsern inte kan gissa när du har skrivit den sista raden). Observera att varje rad inom ett basblock måste vara indragen lika mycket.

- Funktionen `print()` skriver ut värdet på det eller de argument som den får. Den skiljer sig från att bara skriva det uttryck du vill skriva (som vi gjorde tidigare i räknarexemplen) genom sättet den hanterar flera argument, flyttalsmängder och strängar. Strängar skrivs ut utan citattecken och ett mellanslag infogas mellan objekten, så att du kan formatera saker snyggt, så här:

      >>> i = 256*256
      >>> print('The value of i is', i)
      The value of i is 65536

  Nyckelordsargumentet end kan användas för att undvika ny rad efter utdata, eller avsluta utdata med en annan sträng:

      >>> a, b = 0, 1
      >>> while a < 1000:
      ...     print(a, end=',')
      ...     a, b = b, a+b
      ...
      0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

Fotnoter

[1]

Eftersom `**` har högre prioritet än `\-` kommer `\-3**2` att tolkas som `\-(3**2)` och därmed resultera i `\-9`. För att undvika detta och få `9` kan du använda `(-3)**2`.

[2]

Till skillnad från andra språk har specialtecken som `\n` samma betydelse med både enkla (`'...'`) och dubbla (`"...'`) citattecken. Den enda skillnaden mellan de två är att inom enkla citattecken behöver du inte undkomma `"` (men du måste undkomma `\'`) och vice versa.