A Python programozási nyelv

Alprogramok, modulok

Szintaxis

A függvény definiálásának szintaxisa:

def <fvnév> ( <paramlist> ) : <suite>

A függvény törzse:

A függvény törzse a következő sorban beljebbkezdve kell, hogy legyen. A törzs opcionálisan kezdődhet egy string literállal, ami a függvény dokumentáció-stringje (docstring).

A return utasítás teszi lehetővé, hogy a függvény értéket adjon vissza. A függvény által visszaadott értékek egymásnak paraméterként is átadhatók. Csak egyetlen érték vagy objektum visszaadása engedélyezett, de tuple vagy lista adattípust használva több értéket is vissza tudunk adni. Az eljárás egy olyan függvény, amely a speciális NONE értéket adja vissza.

Végrehajtáskor a törzsben csak a lokális változók láthatóak. Azonban a global utasítással megnevezhetünk globális változókat, melyek ezután már láthatóak a törzsben.

2.1: Lexikális scope-ok.

x = 1
def outer():
    x = 2
    def inner():
        print x
    inner()

2.0-ban a futási eredmény 1, mert az inner() eljárásban lévő x a globális változót jelenti (statikus scope, l. Algol).

2.1-ben az inner() eljárásban lévő x az outer() névterében lévő változót jelenti (lexikális scope).

Függvények átnevezésére van lehetőség: Tegyük fel, hogy van egy fib nevű függvényünk (egy paramétere van)

>>>f = fib

Ezután már f-ként is hivatkozhatunk erre a függvényre.

Paraméterátadás

Érték szerinti paraméterátadás van. (bár az objektum-referencia szerinti jobb leírás volna, ugyanis ha például egy lista az argumentum, akkor a függvény által végzett változtatásokat látni fogja a hívó. (pl. listaelem beszúrását)

A paraméter lista:

Adhatunk az argumentumoknak alapértéket, amit a definiáláskor létező értékek alapján vesznek fel.

Azonban figyelnünk kell arra, hogyha ugyanabban a függvényben kötelező és alapértelmezett paramétereket is szeretnénk megadni, akkor a függvény definíciójában az összes kötelező paramétert az alapértelmezett paramétereket előtt kell definiálni. 

i=5
def f(arg = i):print arg
i=6
f()

5-öt fog kiírni.

Név és pozíció szerint is hivatkozhatunk egy paraméterre. (De ha egyszer hivatkoztunk név szerint, utána már nem lehet pozíció szerint) Egy argumentumnak kétszer nem adhatunk értéket.

Lehetőség van változó argumentumszámú függvény definiálására is. Ennek két változata van, a nem kulcsszavas és a kulcsszavas. Ahhoz, hogy szükség estén több argumentumot adhassunk át anélkül, hogy szintaktikai hibát kapnánk egy nem kulcsszavas, változó hosszúságú argumentumlistát vehetünk fel a függvény definícióban. Ennek a típusa tuple lesz, és a név előtti '*'-gal jelöljük. A függvény hívásakor a "létszám feletti", nem kulcsszavas argumentumok ebbe tuple-ba kerülnek bele. Például:

def fv1(normal1, normal2, *tup):         print '1. normal argumentum:', normal1 print '2. normal argumentum:', normal2 for i in tup: print 'tovabbi argumentumok:', i

A kulcsszavas, változó hosszúságú argumentumlistát akkor használhatjuk amikor a függvény hívásában további, kulcsszavakkal megadott értékek is szerepelhetnek. Ilyenkor a függvény paraméterlistájába fel kell venni egy '**'-gal jelölt paramétert, aminek a típusa szótár lesz. Például:

def fv2(normal1, normal2, **szotar):         print '1. normal argumentum:', normal1 print '2. normal argumentum:', normal2 for i in szotar: print 'tovabbi argumentumok= %s=%s' %(i, szotar[i]) #kiírja a szótár elemeit kulcs=érték alakban

Rekurzió

Természetesen van rekurzió a nyelvben, de a mélységre korlát érvényes, mely a sys modul getrecursionlimit metódusával kérdezhető le ill. a setrecursionlimit-tel állítható be. Az alapértelmezett érték 1000.

Lambda formák

Funkcionálisprogramozás-hívőknek megmelengetheti a szívét az egyszerű lambda-függvények kezelése. A lambda kulcsszó használatával kisméretű anonymous függvények definiálhatók, pl.:

lambda a, b: a+b

...a két paraméter összegét adja vissza. Lambda-formák bárhol használhatóak, ahol függvényobjektumokra van szükség. Szintaktikusan egy kifejezésre korlátozottak, szemantikusan pedig csak "szintaktikus cukra" a normál függvénydefiníciónak. Hasonlóan a beágyazott függvényekhez, a lambda függvények nem hivatkozhatnak a definícót tartalmazó scope-ban élő változókra. Ezt ki lehet kerülni az alapértelmezett paraméterek használatával:

 

def make_incrementor(n):
        return lambda x, incr=n: x+incr
 
f = make_incrementor(42)
print f(0)                     # 42
print f(1)                     # 43
 

Beépített függvények

abs(x) Egy szám abszolút értékét adja vissza.

all(iterable) Igazat ad vissza, ha iterable minden eleme True igazságértékű. (vagy ha az iterable üres).

any(iterable) Igazat ad vissza, ha iterable valamely eleme True igazságértékű.

apply(f, args)
Az < f > függvényt/metódust <args> argumentumokkal hívja meg.

basestring() Ez az absztakt típus az str és unicode stringek ősosztálya. Nem lehet példányosítani, viszont tesztelni lehet segítségével, hogy egy objektum az str vagy unicode pédánya-e.

>>> isinstance("Hello", basestring)
True

bin(x) Egy integer értéket átkonvertál bináris string-gé. Ha x nem int objektum, akkor definiálnia kell az __index__() függvényt, amely integer értéket ad vissza.

bool([x]) Egy tetszőleges objektumot árkonvertál bool-ra, a szabványos igazságérték-tesztelés szerint. Ha az x paraméter hiányzik, akkor False-al tér vissza.

callable(x) 1 értéket ad, ha x hívható, különben 0.

chr(i) Egy karakter értékû sztringet ad vissza, mely ASCII kódja megadott i egész szám.

classmethod(function) Visszaadja a function-t, mint osztálymetódust. Az osztálymetódus első paramétere az osztály maga (mint ahogy az objektummetódus első paramétere az objektum). Osztálymetódus deklarálására egy példa:

class C:
@classmethod
def f(cls, arg1, arg2, ...): ...
A @classmethod egy függvény dekorátor.

cmp(x,y) Negatív, zéró, positív értéket add vissza, ha x <, ==, > y -hoz viszonyítva.

coerce(x,y) Tuple típusú változót ad vissza eredményül a két argumentumot egy közös típusra konvertálva.

compile(sztring, fájlnév, fajta)
<sztring> értékét kódobjektummá konvertálja ( code object).
<fájlnev> -et hibafeljegyzésre használjuk, bármilyen sztring lehet.
<fajta> vagy 'eval' ha a <sztring> egy sima folyamat, különben 'exec'- nek kell lennie.

complex([real[, imag]]) Létrehoz egy komplex számot real valós és imag imaginárius résszel, továbbá stinget vagy tetszőleges numerikus értéket konvertál komplex-szé. Ha az első paraméter egy string, akkor kompley számmá konverálja a függvény azt, ilyenkor nem lehet második paramétere a függvénynek. Ha nincs paraméter megadva, akkor a 0j számot adja vissza a függvény.

delattr(object, name) A függvény kitörli az object objektum name argumentumát (string).

dict([arg]) Létrehoz egy új adatszótárat (mapping), az opcionális arg paraméterből felépítve a kezdeti értékeit.

dir([object]) Ha nincs argumentuma, akkor a jelenlegi érvényességi kör szimbólumtáblájában található nevek listáját adja vissza értékül. Egy modul, osztály (class) vagy osztálypéldány (class instance) objektum értékkel történõ meghívásakor annak az attribútum szótárában található nevek listáját adja vissza értékül.

divmod(a,b) (a/b, a%b) tuple típusú változót szolgáltat eredményül.

enumerate() : lásd a fejezet végén

eval(s, globális, helyi )
Kiértékeli az < s > sztringet az esetlegesen megadott < globális >, <helyi> érvényességi körökben található változóknak megfelelõen.
<s>-ben nem lehet üres vagy újsor. <s> lehet kódobjektum is.
Például: x = 1; incr_x = eval('x + 1')

filter(függvény, lista)
Létrehoz egy listát a megadott < lista > változó elemeibõl, melyre a <függvény> igaz értéket add vissza. A <függvény> egy paraméteres.

float(x) Az x számot lebegõpontos számmá konvertálja.

getattr(objektum, név)
getattr meghívja a <nev>-et az <objektum>-ból.
getattr(x, 'foobar') <=> x.foobar

format(value[, format_spec]) Átalakítja value-t a format_spec által leírt formává. A formátum specifikációról részletesebben a String kezelés fejezetben olvashat.

frozenset([iterable]) Létrehoz egy frozenset objektumot, kezdeti értékeit felépítve az opcionális

getattr(object, name[, default]) Visszaadja object name nevű (string) attribútumát. Ha az attribútum nem létezik, akkor az opcionáális default értéket adja vissza a függvény, egyébként pedig TypeError keletkezik.

globals() Visszaadja a globális szimbólumtáblát reprezentáló adatszótárat.

hasattr(objektum, név)
Igaz értéket ad, ha az <objektum>-nak van <név> nevezetû attribútuma.

hash(objektum) Visszaadja az objektum hash értékét (ha van ilyen értéke).

hex(x) A számot hexadecimális sztringgé konvertálja.

id(objektum) Egy objektum egyedi egész 'azonosító' számát szolgáltatja.

input([prompt]) Kiírja a prompt jelet, ha megadtuk. Beolvassa az input jelet és kiértékeli.

int(x) Egy számot sima egész számmá (integer) konvertál.

isinstance(object, classinfo) Igazzal tér vissza, ha object a classinfo argumentum egy példánya, illetve ha annak egy közvetlen vagy inderikt leszármazottja. A classinfo lehet objektumokat tartalmazó tuple is, ebben az esetben igazat ad a függvény, ha valamelyik objektumra teljesül az isinstance() reláció.

issubclass(object, classinfo) Igazzal tér vissza, ha object a classinfo direkt vagy indirekt leszármazottja. A classinfo lehet objektumokat tartalmazó tuple is, ebben az esetben igazat ad a függvény, ha valamelyik objektumra teljesül az issubclass() reláció.

iter(object[, sentinel]) Visszatér egy iterátor objektummal. Ha egy argumentummal hívjuk meg a függvényt, akkor az object argumentum egy olyan gyűjtemény kell, hogy legyen, amely támogatja az iterátor protokollt (__iter__() függvény), vagy a szekvencia protokollt (__getitem__() függvény, 0 tól induló integer index argumentummal). Ha a második, sentinel paraméter is adott, akkor az object kötelezően egy callable (hívható) típus kell, hogy legyen. Ilyenkor a függvény minden next() híváskot meghívja az object-et, és ha a visszatérési értéke megegyezik sentinel-lel, akkor StopIteration kivétel keletkezik.
Egy használati esete a kétargumentumó iter()-nek lehet az, amikor addig akarunk egy fájlból sorokat olvasni, amíg egy adott sorkoz el nem érünk. Pl:

with open("mydata.txt") as fp:
for line in iter(fp.readline, "STOP"):
process_line(line)

len(s)

list([iterable]) Létrehoz egy új lista objektumot, amelynek az elemei ugyanazok, mint az iterable elemei.

locals() Visszaadja a jelenlegi, helyi szimbólumtáblát reprezentáló adatszótárat.

long(x) Egy számot hosszú egész számmá konvertál (long integer).

map(függvény, lista, ...)
A <függvény>-t alkalmazza a <lista> minden elemére és egy listát ad vissza értékül. Ha további <listát> adunk meg, akkor a <függvény>-nek ennyi argumentumot feldolgozni és az minden híváskor átadásra kerül a függvénynek.

map(function, iterable, ...) A function függvényt alkalmazza az iterable objektum minden elemére, és visszaadja az eredményeket tartalmazó listát. Ha további iterable paraméterei vannak a függvénynek, akkor a function-nek is annyival több formális paraméterrel kell rendelkeznie, és ezt az objektumok elemeire párhuzamosan alkalmazza a map() függvény. Ha egyik iterable rövidebb, mint a másik, akkor a map() úgy veszi, mint hogyha további None értékei lennének.

max(s) Egy nem üres szekvencia legnagyobb elemét adja vissza értékül.

min(s) Egy nem üres szekvencia legkisebb elemét adja vissza értékül.

next(iterator[, default]) Visszaadja az iterator következő elemét azértal, hogy meghavjí annak next() metódusát.

object() Létrehoz egy attribútumok és metódusok nélküli objektumot.

oct(x) Egy számot oktális sztring értékké konvertál.

open(fájlnév [, mód='r', [bufferméret=<implementáció függõ>]])
Fájlobjektumot ad vissza értékként. Az elsõ két argumentum megegyezik a C nyelv "stdio open" függvényének argumentumaival. < bufferméret > 0, ha nem pufferelünk; 1, ha sor-pufferelt, negatív, ha rendszerbeállított, minden más esetben a megadott méret (körüli).

ord(c) A <c> (1 hosszúságú sztring) ASCII kódját szolgáltatja.

pow(x, y [, z]) x y [modulo z] hatványát adja vissza értékül.

range(start [,end [, lépés]])
A >= start és < end értékek közötti egész számokból képzett listát ad vissza értékül.
Egy argumentummal, lista 0-tól ..<argumentum>-1 értékig.
Két argumentummal, lista <start> értéktõl..<end>-1 értékig.
Három argumentummal, lista <start> értéktõl <end> értékig <lépés>- sel.

raw_input([prompt])
A prompt értékét kiírja, ha megadott, majd sztringet olvas be a standard
inputról.

reduce(f, lista [, inicializáló])
Az <f> bináris függvényt a <lista> elemeire úgy, hogy a listát egyetlen értékre redukálja.
Ha <inicializáló> értéket adtunk, akkor azt a <lista> értékeihez fûzzük.

reload(modul) Újraelemzi és -inicializálja a már importált modult. Interaktív módban nagyon hasznos, ha újra akarunk tölteni egy már javított modult. Ha modul szintaktikailag helyes volt, de hibaüzenetet kaptunk inicializáláskor, akkor azt újra kell importálni, mielõtt arra a reload() utasítást végrehajtanánk.

repr(object) Egy objektum kinyomtatható reprezentációját adja vissza értékül. Azonos az ´objektum´ kifejezéssel (fordított idézõjeleket használva).

round(x,n=0) x lebegõpontos értékét a tizedes pont után n számjegyre kerekítve adja vissza.

reversed(seq) Visszatér egy fordított bejárású iterátorral. A seq kötelezően egy olyen objektum, amely implementálja a __reversed__() metódust, vagy támogatja a szekvencia protokollt (__len__() és __getitem__() függvények, 0-tól kezdődő indexelés).

set([iterable]) Létrehoz egy halmaz objektumot az opcionális iterable elemeiből.

setattr(objektum, név, érték)
Ez a getattr() ellentétes mûvelete.
setattr(o, 'foobar', 3) <=> o.foobar = 3

sorted(iterable[, cmp[, key[, reverse]]]) Visszatér az iterable elemeiből képzett rendezett listával. Az opcionális cmp paraméter egy kétargumentumú függvény, amely negatív, pozitív vagy 0 értéket kll, hogy viszsaadjon attól függően, hogy két elem közül az első vagy a második a kisebb, vagy egyenlőek.
Az opcionális key paraméter egy egyargumentumú függvény, amely arra való, hogy a lista elemből olyan elemet állítson elő, amely az összehasonlítás alapját képezheti. pl. key=str.lower.
A reverse egy logikai érték. Ha igaz, akkor fordított sorrendben rendezi a gyűjteményt.

sum(iterable, start=0) Visszaadja a két elem összegét. Csak szám típusú paramétert lehet neki megadni, tehát nem lehet például stringek konkatenálására használni.

str(objektum) Egy sztring értéket ad vissza, mely egy objektum jól nyomtatható reprezentációját adja vissza.

tuple(lista) a <lista> típusú változóval azonos elemekbõl álló tuple típusú változót hoz létre.

type(objektum) Egy objektum típusát adja értékül.
Például: if type(x) == type(''): print 'Ez egy sztring.'

vars([object]) Argumentumok nélkül dictionary típusú változót szolgáltat eredményül az aktuális helyi szimbólumtáblának megfelelõen. Modul, osztály (class) vagy az osztály példány (class instance) objektum argumentumként örténõ meghívásával dictionary típusú változót ad vissza az objektum szimbólumtáblájának megfelelõen.A "%" formázó operátor alkalmazásával nagyon jól használható.

xrange(start [, end [, lépés]])
Hasonlít a range() -hez, de valójában nem tárolja a teljes listát. Jól használható "for" ciklusokban, amikor nagy az értéktartomány, de kevés a rendelkezésünkre álló memória.

zip([iterable, ...]) Visszaad egy tuple-okból álló listát, ahol az i-edik tuple az iteráltak i-edik elemeit tartalmazza. Az eredménylista hossza a legrövidebb iterált hosszával egyezik meg

Az enumerate() függvény:

Van egy új beépített függvény a Python 2.3.2-es verziójában, az enumerate(thing), amit ciklusokban használhatunk, és ahol a thing egy iterátor vagy  egy sorozat lehet. Visszatérési értéke egy itarátort, ami (0, thing[0]), (1, thing[1]), (2, thing[2]), stb.. Például gyakran előfordul, hogy egy lista minden elemét valamilyen számítás segítségével -amely függ a lista aktuális elemeitől- módosítani szeretnénk. Ekkor

for i in range(len(lista))     item=lista[i]     . . .     # elvégezzük a számítást     lista[i]= result

helyett írhatjuk a következőt:

for i, item in enumerate(lista) . . .# elvégezzük a számítást, az item-be bekerült a lista i-dik eleme lista[i]=result  

Generátorok

A Python 2.2-ben a generátorok opcionális tulajdonságok, a from __future__ import generators utasítással használhatók. A 2.3-ban a generátorok már mindig jelen vannak, nem kell importálni.

Amikor meghívunk egy függvényt, akkor az kap egy saját névteret, ahol a lokális változók létrejönnek. Amikor a függvény a return utasításhoz ér, a lokális változók megszűnnek, és az eredménnyel visszatér a hívóhoz. Később, amikor hívjuk ugyanezt a függvényt, az új lokális változókat kap. De mi van akkor, ha folytatni akarjuk a függvényeljárást ott, ahol abbahagytuk? Erre adnak lehetőséget a generátorok. Például:

def generate_ints(N): for i in range(N): yield i

A yield egy új kulcsszó, amit a generátoroknak vezettek be. Ha egy függvény tartalmaz egy yield utasítást, akkor generátor függvényként működik. Amikor generátor függvényt hívunk, az nem egy egyszerű értéket ad vissza, hanem egy generátor objektumot, amit támogat az iterátor protokoll. A példában a yield utasítást végrehajtva a generátor kimeneti értéke az i lesz, hasonlóan, mint a return utasításnál.  A különbség a return és a yield között az, hogy egy yield hatótávolságának  az állapota generátor végrehajtása után „félbeszakadt” lesz, a lokális változók pedig eltárolódnak. A következő hívásnál a .next() metódust kell használni, és a függvény újra elkezdi a végrehajtást mindjárt a yield után. Például:

>>> gen = generate_ints(3) >>> gen <generator object at 0x8117f90> >>> gen.next() 0 >>> gen.next() 1 >>> gen.next() 2 >>> gen.next() Traceback (most recent call last): File "stdin", line 1, in ? File "stdin", line 2, in generate_ints StopIteration

Megengedett például a következő utasítás is: a, b, c=generate_ints(5).

A generátor függvény törzsében a return utasítást csak érték nélkül lehet használni, ami után a generátor már semmilyen értéket nem tud visszaadni. Ha a return után valamilyen értéket írunk, mint például reutrn 5, akkor szintaktikus hibát kapunk.

A generátor eredményének végére mutat a StopIteration.

A generátorok segítségével egyszerű megvalósítani a bináris fa in-order bejárását:

def inorder(t): if t: for x in inorder(t.bal): yield x yield t.ertek for x in inorder(t.jobb): yield x