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.

You can toggle the display of prompts and output by clicking on >>> in the upper-right corner of an example box. If you hide the prompts and output for an example, then you can easily copy and paste the input lines into your interpreter.

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:

# this is the first comment
spam = 1  # and this is the second comment
          # ... and now a third!
text = "# This is not a comment because it's inside quotes."

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 at it and it will write the value. Expression syntax is straightforward: the operators +, -, * and / work just like in most other languages (for example, Pascal or C); 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. Strings

Besides numbers, Python can also manipulate strings, which can be expressed in several ways. They can be enclosed in single quotes ('...') or double quotes ("...") with the same result 2. \ can be used to escape quotes:

>>> 'spam eggs'  # single quotes
'spam eggs'
>>> '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.'

In the interactive interpreter, the output string is enclosed in quotes and special characters are escaped with backslashes. While this might sometimes look different from the input (the enclosing quotes could change), the two strings are equivalent. The string is enclosed in double quotes if the string contains a single quote and no double quotes, otherwise it is enclosed in single quotes. The print() function produces a more readable output, by omitting the enclosing quotes and by printing escaped and special characters:

>>> '"Isn\'t," they said.'
'"Isn\'t," they said.'
>>> print('"Isn\'t," they said.')
"Isn't," they said.
>>> s = 'First line.\nSecond line.'  # \n means newline
>>> s  # without print(), \n is included in the output
'First line.\nSecond line.'
>>> print(s)  # with print(), \n produces a 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:\some\name')  # here \n means newline!
C:\some
ame
>>> print(r'C:\some\name')  # note the r before the quote
C:\some\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.

String literals can span multiple lines. One way is using triple-quotes: """...""" or '''...'''. End of lines are automatically included in the string, but it’s possible to prevent this by adding a \ at the end of the line. The following example:

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

produces the following output (note that the initial newline is not included):

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.

In addition to indexing, slicing is also supported. While indexing is used to obtain individual characters, slicing allows you to obtain substring:

>>> 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.

Formatted string literals

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]

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:

>>> squares[:]
[1, 4, 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 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]

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

Of course, we can use Python for more complicated tasks than adding two and two together. For instance, we can write an initial sub-sequence of the Fibonacci series as follows:

>>> # 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.

• The print() function writes the value of the argument(s) it is given. It differs from just writing the expression you want to write (as we did earlier in the calculator examples) in the way it handles multiple arguments, floating point quantities, and strings. Strings are printed without quotes, and a space is inserted between items, so you can format things nicely, like this:

  >>> 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.