Subsections


3. Kötetlen bevezető a Pythonba

A következő példákban a kimenetet és a bemenetet az elsődleges és másodlagos készenléti jelek - promptok - (">>" és "... ") meglétével, illetve hiányával különböztetjük meg. A példák kipróbálásához mindent be kell írnod a promptok után, amikor a prompt megjelenik; azok a sorok, amelyek előtt nincs prompt, a fordító kimenetei.

Jegyezd meg, hogy az önmagában álló másodlagos prompt a példa egyik sorában azt jelenti, hogy nem kell semmit írni a sorba; ez jelzi egy többsoros utasítás végét.

Ennek a kézikönyvnek sok példájában - még azokban is, amelyeket interaktív módon írtunk be - szerepelnek megjegyzések. A Pythonban a megjegyzések kettőskereszttel (hash, "#") kezdődnek és a sor végéig tartanak. Egy megjegyzés lehet sor elején, vagy követhet szóközt, tabulátor-karaktert, de ha egy karakterlánc belsejébe teszed, az nem lesz megjegyzés (lásd a példában!). A kettőskereszt karakter egy karakterláncon belül csak egy kettőskereszt.

Példák:

# ez az első megjegyzés
SPAM = 1                 # ez a második megjegyzés
                         # ... és ez a harmadik.
STRING = "# Ez nem megjegyzés."

print STRING 		 # ennek a kimenete a következő sor:
# Ez nem megjegyzés.


3.1 A Python használata számológépként

Próbáljunk ki néhány Python utasítást. Indítsuk el az értelmezőt, és várjuk meg az elsődleges promptot: ">>". (Nem kell sokáig várni.)


3.1.1 Számok

A parancsértelmező úgy működik, mint egy sima számológép: be lehet írni egy kifejezést, és az kiszámolja az értékét. A kifejezések nyelvtana a szokásos: a +, -, * és / műveletek ugyanúgy működnek, mint a legtöbb nyelvben (például, Pascal vagy C); zárójeleket használhatunk a csoportosításra. Például:

>>> 2+2
4
>>> # Ez egy megjegyzés
... 2+2
4
>>> 2+2  # és egy megjegyzés ugyanabban a sorban, ahol utasítás van
4
>>> (50-5*6)/4
5
>>> # Egészek osztása az eredmény lefelé kerekített értékét adja:
... 7/3
2
>>> 7/-3
-3

A C-hez hasonlóan az egyenlőségjellel ("=") lehet értéket adni egy változónak. Az értékadás után az értelmező újabb utasításra vár, látszólag nem történik semmi:

>>> szélesség = 20
>>> magasság = 5*9
>>> szélesség * magasság
900

(Az ékezetek nekem működtek interaktív módban, lehet, hogy a régebbi programváltozatok miatt érdemes kerülni. A a program elején adjuk meg hogy milyen kódtáblával dolgozunk, például windows alatt:

>>> # -*- coding: cp1250 -*- 
...

Linux alatt is működik az ékezetkezelés, a Linux telepítésekor a magyar nyelvet állítottam be, a Pythonban semmit nem kellett állítanom. - A fordító megjegyzése.)

Több változónak egyszerre tudunk értéket adni:

>>> x = y = z = 0  # Nulla lesz az x, y és z
>>> x
0
>>> y
0
>>> z
0

A programnyelv támogatja a lebegőpontos számábrázolást; azok a műveletek amelyeknél keverednek a típusok, az egészeket lebegőpontossá alakítják:

>>> 3 * 3.75 / 1.5
7.5
>>> 7.0 / 2
3.5

Complex numbers are also supported; imaginary numbers are written with a suffix of "j" or "J". Complex numbers with a nonzero real component are written as "(real+imagj)", or can be created with the "complex(real, imag)" function.

A Python komplex számokat is tud kezelni - a képzetes részt a "j"vagy "J" jellel képezhetjük. A komplex számot "(valós+képzetes j)" alakban vagy "complex(valós, képzetes)" alakban írhatjuk, ha a képzetes rész nem nulla.

>>> 1j * 1J
(-1+0j)
>>> 1j * complex(0,1)
(-1+0j)
>>> 3+1j*3
(3+3j)
>>> (3+1j)*3
(9+3j)
>>> (1+2j)/(1+1j)
(1.5+0.5j)

A komplex számokat gyakran két lebegőpontos számmal ábrázolják - a képzetes és a valós résszel. A z komplex számnak ezeket a részeit a z.real és z.imag utasításokkal olvashatjuk vissza.

>>> a=1.5+0.5j
>>> a.real
1.5
>>> a.imag
0.5

The conversion functions to floating point and integer (float(), int() and long()) don't work for complex numbers -- there is no one correct way to convert a complex number to a real number. Use abs(z) to get its magnitude (as a float) or z.real to get its real part.

A lebegőpontos és egész típusú konverziós függvények (float(), int() és long()) nem működnek komplex számokra. A komplex - valós számok közötti konverziónak több lehetségesmódja is van - ahhoz, hogy egy komplex számból valósat csinálj, használd az abs(z) utasítást, hogy megkapd a nagyságát (lebegőpontosként) vagy a z.real utasítást, ha a valós része kell.

>>> a=3.0+4.0j
>>> float(a)
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: can't convert complex to float; use abs(z)
>>> a.real
3.0
>>> a.imag
4.0
>>> abs(a)  # sqrt(a.real**2 + a.imag**2)
5.0
>>>
>>> float(8) # lebegopontos alakra konvertal. kimenete: 8.0

Interaktív módban az utoljára kiírt kifejezés értéke a '_' (alsóvonás) változóban van. Így ha a Pythont asztali számológépként használod, akkor egyszerűbb folytatni a számolásokat, például:

>>> adó = 12.5 / 100
>>> ár = 100.50
>>> ár * adó
12.5625
>>> ár + _
113.0625
>>> round(_, 2)
113.06
>>>

Ezt a változót csak olvasható változóként kezelhetjük. Ne adjunk értéket neki - mert ha adunk, akkor létrehozunk egy független helyi változót azonos névvel, amely meggátolja a beépített változó elérését. (Ha egy globális változó nevével létrehozunk egy helyi változót, akkor az értelmező a helyit használja.


3.1.2 Karakterláncok

A számok mellett a Python karakterláncokkal is tud műveleteket végezni. A karakterláncokat idézőjelek vagy aposztrófok közé kell zárni:

>>> 'spam eggs'
'spam eggs'
>>> 'doesn\'t'
"doesn't"
>>> "doesn't"
"doesn't"
>>> '"Yes," he said.'
'"Yes," he said.'
>>> "\"Yes,\" he said."
'"Yes," he said.'
>>> '"Isn\'t," she said.'
'"Isn\'t," she said.'

Egy karakerláncot többféle módon bonthatunk szét több sorba. Azt a sort, amelyet folytatni szeretnénk, vissza-perjellel (back-slash-jellel: $\backslash$-el) zárjuk le, ezzel jelezve, hogy a következő sor ennek a sornak a logikai folytatása

hello = "Ez egy nagyon hosszú karakterlánc, amely\n\
több sorból áll. Ugyanúgy választható el mint C-ben.\n\
    Jegyezd meg, hogy a soreleji szóközök és tabulátorok\
 fontosak.\n"
print hello

A soremelést a

 \n
jellel adtuk meg. Ez a következőket fogja kiírni:

Ez egy nagyon hosszú karakterlánc, amely
több sorból áll. Ugyanúgy választható el mint C-ben.
    Jegyezd meg, hogy a soreleji szóközök és tabulátorok fontosak.

Ha ``raw'' (nyers, bármiféle konverzió nélkül pontosan azt adja vissza, amit beírsz) karakterláncot szeretnél készítesz, a \n karakterpár nem konvertálódik újsor karakterre. A forráskódban lévő összes sortörés és sorvégi \ jel megmarad:

hello = r"Ez egy hosszú karakterlánc, amely több sorból áll,\n\
ahogy C-ben csinálnád!"

print hello

Ezt fogja kiírni:

Ez egy hosszú karakterlánc, amely több sorból áll,\n\
ahogy C-ben csinálnád!.

Vagy a karakterláncot hármas idézőjellel vehetjük körül: """ vagy '''. Ilyenkor az újsort nem kell jelölnöd mert azok jelölés nélkül benne lesznek a karakterláncban.

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

Ez a következő kimenetet adja:

Usage: thingy [OPTIONS] 
     -h                        Display this usage message
     -H hostname               Hostname to connect to

Az értelmező ugyanúgy írja ki a karakterlánc-műveletek eredményét, ahogy begépeltük a bemenetre: idézőjelekben, a belső idézőjeleket és más érdekes karaktereket vissza-perjelekkell megvédve, hogy a pontos értéket megmutassa. (Az ékezetes betűknek a kódját adja vissza vissza-perrel az elején. A vissza-perrel kezdődő speciális jelentésű részeket nevezik escape sorozatoknak, escape karaktereknek... - a ford.) A karakterlánc dupla idézőjelben van, ha egyszeres idézőjelet tartalmaz, de kétszereset nem, különben egyszeres idézőjelben. (A később sorrakerülő print utasítást használhatjuk a karakterláncok idézőjel és escape sorozatok nélküli kiíratásához.)

Karakterláncokat a + művelettel ragaszthatunk össze és *-gal ismételhetünk.

>>> szo = 'Segít' + 's'
>>> szo
'Segíts'
>>> '<' + szo*5 + '>'
'<SegítsSegítsSegítsSegítsSegíts>'

Két egymást követő karakterláncot az értelmező magától összevon; az első sor fentebb lehetne "szo = 'Segít' 's'" is; ez csak két a beégetett karakterláncokra (string literal) érvényes, teszőleges karakterlánc-kifejezésekre nem:

>>> import string
>>> 'str' 'ing'                   #  <-  helyes.
'string'
>>> string.strip('str') + 'ing'   #  <-  helyes.
'string'
>>> string.strip('str') 'ing'     #  <-  ez nem megy.
  File "<stdin>", line 1
    string.strip('str') 'ing'
                            ^
SyntaxError: invalid syntax

A karakterláncokat fel lehet bontani al-karakterláncokra (indexelni); ahogy a C-ben is, a karakterlánc első karaktere a nullás indexű. Nincs külön karakter típus; egy karakter, az egy egységnyi hosszúságú karakterlánc. Ahogy az Icon-ban, az rész-karakterláncokat szeletelő jelölési móddal jelölhetünk ki: a két indexet kettősponttal választjuk el.

>>> szo[4]
't'
>>> szo[0:2]
'Se'
>>> szo[2:4]
'gí'

A szeletek indexeinek hasznos alapértékei vannak; az elhagyott első index nullát jelent, ha a másodikat hagyjuk el, akkor a karakterlánc végéig tart a szelet.

>>> szo[:2]    # Az első két karakter
'Se'
>>> szo[2:]    # Minden karakter, az első kettőt kivéve
'gíts'

A C-vel szemben a karakterláncot nem lehet megváltoztatni. Ha egy indexelt helynek értéket adunk, hibaüzenetet kapunk:

>>> szo[0] = 'x'
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: object doesn't support item assignment
>>> szo[:1] = 'Splat'
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: object doesn't support slice assignment

Jóllehet, új karakterláncot létrehozni a részeik összerakásával könnyen és hatékony módon lehet:

>>> 'x' + szo[1:]
'xegíts'
>>> 'Vidít' + szo[5]
'Vidíts'

Itt van egy hasznos, az eredeti változóval azonos értékű karakterlánc: s[:i] + s[i:] egyenlő az s-el.

>>> szo[:2] + szo[2:]
'Segíts'
>>> szo[:3] + szo[3:]
'Segíts'

A valótlan méretű szeleteket az értelmező okosan kezeli: egy indexet ami túl nagy helyettesíti a karakterlánc méretével, ha az alsó határ nagyobb mint a felső, akkor egy üres karakterlánccal tér vissza.

>>> szo[1:100]
'egíts'
>>> szo[10:]
''
>>> szo[2:1]
''

Az indexek negatív számok is lehetnek, ekkor jobb oldalról számol. Például:

>>> szo[-1]     # Az utolsó karakter
's'
>>> szo[-2]     # Az utolsó előtti
't'
>>> szo[-2:]    # Az utolsó kettő karakter
'ts'
>>> szo[:-2]    # Az összes, kivéve az utolsó kettő
'Segí'

Jegyezd meg, hogy a -0 valóban azonos a 0-val, így ez nem jobbról számol!

>>> szo[-0]     # (mivel -0 és 0 egyenlőek)
'S'

A tartományon kívüli negatív indexeket megcsonkítja a Python, de ez nem működik egyetlen elemmel (azaz egyetlen karakterláncra):

>>> szo[-100:]
'Segíts'
>>> szo[-10]    # hiba
Traceback (most recent call last):
  File "<stdin>", line 1
IndexError: string index out of range

(Mivel kívül van az index a megengedett tartományon.)

Úgy a legkönnyebb megjegyezni hogy működnek a szeletek, ha azt képzeljük, hogy az indexek a karakterek közé mutatnak, az első karakter bal élét számozzuk nullának. Ekkor az n karakterből álló karakterlánc utolsó karakterének jobb éle az n, például:

 +---+---+---+---+---+---+ 
 | S | e | g | í | t | s |
 +---+---+---+---+---+---+ 
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1

Az első sorban álló számok adják a 0...5 indexeket a karakterláncban; a második sor mutatja a megfelelő negatív indexeket. Az i-től j-ig terjedő szelet mindazokat a karaktereket tartalmazza, amelyek az i és j jelű élek között vannak.

A nem negatív indexek esetén a szelet hossza az indexek különbségével egyenlő, ha mindkettő a valódi szóhatárokon belül van. Például a szo[1:3] hossza 2 (szo[ettől:eddig]).

Ford.: az indexek valójában egy-egy konkrét karakterre mutatnak, ezért a fenti ábra így helyénvaló:

 +---+---+---+---+---+---+ 
 | S | e | g | í | t | s |
 +---+---+---+---+---+---+ 
   0   1   2   3   4   5   6
  -6  -5  -4  -3  -2  -1

Ebből világosan látszik, hogy a 0. elem az 'S', és a 3. elem az 'í' betű. A Python szeletelési paraméterei pozíciótól pozícióig (szo[ettől:eddig]) működik, de az utolsó elem már nem tartozik a halmazba:

print szo[0:6] 	# a 0. karaktertől a 6.-ig (de 6-os már nem!)
		# kiírja a szót.

A beépített len() függvény a karakterlánc hosszával tér vissza:

>>> s = 'legeslegelkáposztásíthatatlanságoskodásaitokért'
>>> len(s)
47

See Also:

Sorozat jellegű típusok
Itt található az Ascii és a Unicode karakterláncok leírása; példák a sorozat jellegű típusokra, illetve az ezen típusokkal végezhető műveletek leírása.
Karakterlánc metódusok
A hagyományos és a Unicode karakterláncok is sok metódussal rendelkeznek az alapvető karakerlánc műveletek, keresés területén.
Karakterlánc formázó műveletek
A formázó műveletek akkor kerülnek használatba, amikor egy karakterlánc a % operátor baloldali operandusa - további részletek itt olvashatók.


3.1.3 Unicode szövegek

A Python 2.0-tól kezdve egy új adattípust használhatnak a programozók: az Unicode objektumot. Ezt Unicode adatok (lásd http://www.unicode.org) tárolására és feldolgozására használhatjuk. Ez együtt használható a többi karakterláncot tartalmazó objektummal: automatikus átalakítás (konverzió) jön létre, ahol szükséges.

Az Unicode-nak megvan az az előnye, hogy a modern és ősi irat minden karakteréhez egy sorszámot rendel. Korábban csak 256 lehetséges sorszámot használtak a karakterek leírásához, és egy szöveg rendszerint kapcsolódott egy kódlaphoz, amely leképezte a sorszámokat a karakterekre. Ez rengeteg kavarodáshoz vezetett, főleg a programok más nyelvekre fordításakor (internationalization = "i18n", azaz "i" + 18 karakter + "n"). Az Unicode megoldotta a problémát azzal, hogy egyetlen kódlapot definiál a világ valamennyi nyelvéhez.

Unicode karakterláncokat ugyanolyan egyszerű Pythonban létrehozni, mint a hagyományos szövegeket:

>>> u'Hello World !'
u'Hello World !'

Az idézőjel előtti kis "u" mutatja, hogy Unicode karakterláncot kell létrehozni. Ha speciális karaktereket szeretnénk használni a szövegben, ezt megtehetjük Python Unicode-Escape kódolásával. A következő példa megmutatja, hogyan:

>>> u'Hello\u0020World !'
u'Hello World !'

A \u0020 escape-sorozat jelzi, hogy egy 0x0020 (a szóköz karakter) sorszámú Unicode karaktert kell beszúrni az adott helyen.

Más karaktereket úgy értelmez, hogy az illető karakter sorszámát felhasználja közvetlenül Unicode sorszámként. Ha szabványos Latin-1 kódolású szöveget használunk (ezt a kódolást használják sok nyugat-európai államban) észrevehetjük, hogy az Unicode első 256 karaktere ugyanaz, mint a Latin-1-es kódolás első 256 karaktere.

Szakértőknek: Van egyfajta nyers mód (raw mode), amilyen a normál karakterláncoknál is. Az idézőjel elé 'ur'-et kell írni, hogy a Python a Raw-Unicode-Escape kódolást használja. Ez a fenti \ uXXXX konverziót csak akkor fogja alkalmazni, ha páratlan számú vissza-per jel van a kis 'u' előtt.

>>> ur'Hello\u0020World !'
u'Hello World !'
>>> ur'Hello\\u0020World !'
u'Hello\\\\u0020World !'

A nyers mód akkor a leghasznosabb, ha sok vissza-per jelet kell beírni, mint például reguláris kifejezéseknél.

A szabványos kódoláson kívül is számos egyéb mód van a Pythonban Unicode szövegek létrehozására valamely ismert kódolás alapján.

A beépített unicode()függvény gondoskodik a használható Unicode kódolók és dekódolók eléréséről. Néhány közismertebb az ilyen kódolások közül, amelyeket átkódolhatunk: Latin-1, ASCII, UTF-8, és UTF-16. Az utóbbi kettő változó hosszúságú kódolás, amely minden Unicode karaktert egy vagy két bájton tárol. Az alapértelmezett kódolás az ASCII, amely a 0-tól 127-ig terjedő karaktereket alakítja át, a többit hibautasítással elutasítja. Ha az Unicode karakterláncot kiíratjuk, fájlba írjuk, vagy az str() függvénnyel átalakítjuk eszerint a kódolás szerint megy végbe.

>>> u"abc"
u'abc'
>>> str(u"abc")
'abc'
>>> u"äöü"
u'\xe4\xf6\xfc'
>>> str(u"äöü")
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-2: ordinal not in range(128)

Ahhoz, hogy a Unicode karakterláncot egy 8-bites karakterlánccá alakítsuk a Unicode objektum egy encode() metódussal szolgál, amely egy argumentumot vár, a kódolás nevét. Kisbetűs kódolásneveket használjunk.

>>> u"äöü".encode('utf-8')
'\xc3\xa4\xc3\xb6\xc3\xbc'

Ha van egy speciális kódolású adatunk, és meg szeretnénk kapni a megfelelő Unicode karakterláncot, a unicode() függvényt használjuk második argumentumként a kódolás nevével.

>>> unicode('\xc3\xa4\xc3\xb6\xc3\xbc', 'utf-8')
u'\xe4\xf6\xfc'


3.1.4 Listák

A Python többfajta összetett adattípust ismer, amellyel több különböző értéket csoportosíthatunk. A legsokoldalúbb a lista, amelyet vesszőkkel elválasztott értékekként írhatunk be szögletes zárójelbe zárva. A lista elemeinek nem kell azonos típusúaknak lenniük.

>>> a = ['spam', 'tojások', 100, 1234]
>>> a
['spam', 'tojások', 100, 1234]

Ahogy a karakterlánc-indexek, úgy a lista-indexek is 0-val kezdődnek, és a listákat is szeletelhetjük, összeilleszthetjük és így tovább:

>>> a[0]
'spam'
>>> a[3]
1234
>>> a[-2]
100
>>> a[1:-1]
['tojások', 100]
>>> a[:2] + ['sonka', 2*2]
['spam', 'tojások', 'sonka', 4]
>>> 3*a[:3] + ['Boe!']
['spam', 'tojások', 100, 'spam', 'tojások', 100, 'spam', 'tojások', 100, 'Boe!']

A karakterláncokkal ellentétben - amelyek megváltoztathatatlanok - a listák egyes elemeit módosíthatjuk:

>>> a
['spam', 'tojások', 100, 1234]
>>> a[2] = a[2] + 23
>>> a
['spam', 'tojások', 123, 1234]

A szeleteknek értékeket is adhatunk és ez akár a lista elemszámát is megváltoztathatja:

>>> # Pár elem átírása:
... a[0:2] = [1, 12]
>>> a
[1, 12, 123, 1234]
>>> # Pár elem törlése:
... a[0:2] = []
>>> a
[123, 1234]
>>> # Pár elem beszúrása:
... a[1:1] = ['bletch', 'xyzzy']
>>> a
[123, 'bletch', 'xyzzy', 1234]
>>> a[:0] = a     # Beszúrja magát (pontosabban egy másolatát) a saját elejére.
>>> a
[123, 'bletch', 'xyzzy', 1234, 123, 'bletch', 'xyzzy', 1234]

A beépített len() függvény listákra is alkalmazható:

>>> len(a)
8

A listák egymásba ágyazása is lehetséges:

>>> q = [2, 3]
>>> p = [1, q, 4]
>>> len(p)
3
>>> p[1]
[2, 3]
>>> p[1][0]
2
>>> p[1].append('xtra')     # Nézd meg az 5.1-es szakaszt!
>>> p
[1, [2, 3, 'xtra'], 4]
>>> q
[2, 3, 'xtra']

Figyeld meg, hogy az utolsó példában p[1] és q valóban ugyanarra az objektumra hivatkozik! Még később visszatérünk az objektumok értelmezésére.


3.2 Első lépések a programozás felé

Természetesen a Pythont sokkal összetettebb feladatokra is használhatjuk annál, minthogy kiszámoljuk 2+2 értékét. Például írhatunk egy rövid ciklust a Fibonacci-sorozat kiszámolására:

>>> # Fibonacci-sorozat:
... # az előző két elem összege adja a következőt
... a, b = 0, 1
>>> while b < 10:
...       print b
...       a, b = b, a+b
... 
1
1
2
3
5
8

Ebben a példában a Python több új tulajdonságát megtaláljuk:

See About this document... for information on suggesting changes.