Python (programozási nyelv)

**Python**
‎
Paradigma:	többelvű
Megjelenés:	1990
Tervezte:	Guido van Rossum
Fejlesztő:	Python Software Foundation
Utolsó kiadása:	2.5 / 2006. szeptember 19.
Típusosság:	erős, dinamikus
Fordítóprogram:	CPython, Jython, IronPython, PyPy
Kiindulási nyelv:	ABC, C, Haskell, Icon, Lisp, Modula-3, Perl, Smalltalk, Tcl
Befolyásolt nyelvek:	Ruby, Boo
Operációs rendszer:	keresztplatformos
Licenc:	Python Software Foundation License
Weboldal:	http://www.python.org

A Python egy nagyon magas szintű programozási nyelv, melyet Guido van Rossum dán programozó hozott létre 1991-ben. A nyelv tervezési filozófiája az olvashatóságot és a programozói munka megkönnyítését helyezi előtérbe a futási sebességgel szemben.

A Python többféle programozási paradigmát is támogat (funkcionális, objektum-orientált és imperatív). Dinamikus típusokat és automatikus memóriakezelést használ, ilyen szempontból hasonlít a Tcl, Scheme, Perl és Ruby nyelvekhez, emellett szigorú típusrendszerrel rendelkezik.

Tartalomjegyzék

[szerkesztés] Története

A Python a Stichting Matematikai Centrumban, Amszterdamban (Hollandia) készült, szerzője Guido Rossum. Nevét a Monty Python csoportról kapta. Az értelmező és a szabványos könyvtárak forrás- és (a legtöbb platformra) bináris kódjai szabadon elérhetőek.

[szerkesztés] Jellemzői

[szerkesztés] Egyszerű adattípusok

None (null típus)
karakterlánc
egész szám (32-bites)
hosszú egész (tetszőleges hosszúságú egész szám)
"tuple" (tetszőleges elemeket tartalmazó szekvencia, de ennek elemei nem változtathatóak)
lista (tetszőleges elemeket tartalmazó szekvencia, helyben változtatható elemekkel)
szótár (asszociációs tömb, azaz kulcs-érték párok)
halmaz (2.3-as verziótól)
Egyéb, belső típusok – csak a teljesség kedvéért: Kód objektum (Code object) Keret objektum (Frame object) (Traceback object) (Slice object)

[szerkesztés] Kivételkezelés

Lekezeletlen kivétel esetén kiíródik a kiváltó programsor, a verem felderítésének (stack backtrace) módszerével. Kivétel lekezelése:

    try ... except vagy try ... finally

try…except:

Ha fellép egy kivétel a try blokkban, ami meg van említve egy except ágban, akkor a vezérlés az except ágnak adódik. Az except ág lefutása után a try blokk utáni részen folytatódik a program (nincs lehetőség folytatni a hibánál). Tovább adódik a külső try blokknak (ha van külső try blokk), ha nincs ebben a try blokkban lekezelve a fellépett kivétel, vagy az except ágban is kiváltódik egy. Ha nem lép fel semmilyen kivétel a try blokkban, akkor a vezérlés else ágra kerül. Tehát a try blokknak lehet else ágat írni. Létrehozhatunk saját kivételeket és vannak előre definiált kivételek is. A kivételek paraméterezhetőek, típusuktól függően más és más paraméterük lehet (több paramétert listában kell átvenni). Például:

try:
    valami()
except NameError,x:
    print x,'nincs definiálva'

Egyszerre csak egy except ág fut le, és ha utolsónak írunk egy szimpla except ágat, akkor az elfogja az összes kivételt. Több kivétel esetén zárójelbe téve vesszővel felsorolva (tuple-ként) adhatjuk meg:

 try:
    ...
 except (NameError,TypeError):
    ...
 except:
    print 'Nem várt kivétel lépett fel'
 else:
    print 'semmilyen kivétel nem lépett fel'

A try blokk a blokkban hívott függvények által kiváltott kivételt is lekezeli! Például:

 def hibas_fuggveny():
    x=1/0
 try:
    hibas_fuggveny()
 except ZeroDivisionError, reszlet:
    print 'Futási hiba kezelése:',reszlet

output: Handling run-time error: integer division or modulo

Kivétel kiváltására a raise utasítás alkalmazható.

 raise NameError,'Hello'

A második argumentum a kivételkezelő paramétere lesz. Saját kivétel létrehozása (egy változónak string értéket kell adni, tehát érdemes, hogy a változó nevét adjuk):

 my_exc = 'my_exc'
 try:
    raise my_exc
 except my_exc:
    print 'Na, most boldog lehetek'

A try…finally blokk finally része mindenképpen lefut, ez egy rendberakási lehetőség. Ha kivétel lép fel, akkor a finally rész lefutása után a kivétel újra kiváltódik. A finally rész akkor is lefut, ha break vagy return utasítással hagyjuk el a try blokkot. Egy try blokknak lehet except ága, vagy finally ága, de egyszerre a kettő nem lehet, viszont egymásba ágyazhatjuk a try blokkokat. Létrehozhatunk kivételosztályokat is.

[szerkesztés] Osztályok, öröklődés

A Python osztálymechanizmusának tervezésénél a szempont az volt, hogy minimális szintaktikai és szemantikai újdonságokat vezessenek be. C++ és a Modula-3 osztálymechanizmusának a keveréke. Többszörös öröklődésre is lehetőséget ad, a származtatott osztály átdefiniálhatja az ősosztálya(inak) metódusait, egy metódus hívhatja az ősosztály metódusát ugyanazon a néven. Az objektumok tartalmazhatnak privát adatokat. Különbségek a C++-hoz képest, hogy az osztály- és objektumváltozók publikusak (kivéve a dupla aláhuzással kezdődőeket), és minden tagfüggvény virtuális.

A Python a szokásos értelemben nem használ konstruktor és destruktor függvényeket, de a nem kötelezően definiálandó, speciális "__init__" és "__del__" tagfüggvényeket a rendszer az objektumpéldány létrehozásakor, illetve az objektum explicit törlésekor ("del" utasítás) vagy amikor a "szemétgyűjtő" felszabadítja a tárhelyet, automatikusan meghívja. Az "__init__"-et nagyon gyakran használják az tagváltozók kezdeti értékadására:

  class MyObject:
    def __init__(self,name):
       self.name = name
 
  myobj = MyObject("Ez a nevem")
  print myobj.name # Kiírja, hogy "Ez a nevem"

Az osztályok maguk is objektumok – valójában a Pythonban minden adattípus objektum. A 2.2-es verziótól kezdve a beépített típusokat is bővítheti a felhasználó. Minden operátor felüldefiniálható speciális nevű tagfüggvényekben. (Például a "+" a "__add__", "__radd__", "__ladd__" segítségével, a "*" a "__mul__", "__rmul__", "__lmul__" segítségével stb.)

Ugyanarra az objektumra több néven is lehet hivatkozni, objektumok esetében értékadás alapértelmezés szerint referenciát (hivatkozást) jelent, nem új objektumpéldány létrehozását.

Osztálydefiníció:

 class ClassName:
    statement-1
    ...
    statement-N
 
#Például:
 
 class MyClass:
    "Egy egyszerű példa osztály"
    i = 42
    def f(x):
        return 'hello world!'

Az osztálynak mielőtt hatása lenne, a vezérlésnek rá kell futnia az osztálydefinícióra, így akár egy if-ágban is lehet osztálydefiníció! Az osztály-objektum az osztálydefiníció végén automatikusan létrejön. Példányosítani úgy tudunk, mintha egy paraméter nélküli függvényt hívnánk meg ( x = MyClass() ). Az adat attribútumok, mint lokális változók, nem előre definiálandók: első használatukkor jönnek létre. Példa:

 x = MyClass
 x.counter = 1
 while x.counter < 10:
     x.counter = x.counter * 2
 print x.counter
 del x.counter

Ez a kis példa 16-ot ír ki (nem a legegyszerűbb módon), és semmilyen nyoma nem marad az osztályban, hisz a del utasítással töröltük. Metódus attribútum:

x.f helyes hivatkozás, hisz MyClass.f egy függvény
x.i helytelen, hiszen MyClass.i nem függvény

x.f nem ugyanaz, mint MyClass.f! x.f egy metódus objektum, nem függvényobjektum. x.f() – ki fogja írni: hello world. Ugyanis az objektum, mint első argumentum átadódik a függvénynek, azaz x.f() ekvivalens MyClass.f(x) -el.

További megjegyzések:

az adat attribútumok felülírják az ugyanolyan nevű metódus attribútumot! Ezért célszerű valamilyen névkonvencióval kizárni az ilyen lehetőséget.
nincs lehetőség az adatelrejtésre – az adat attribútumokat éppúgy elérik a metódusok, mint az objektum kliensei.
az előbbi megjegyzés lehetővé teszi, hogy kliensek elrontsák az invariánst, ha meglévő adat attribútumot írnak. Ezt kerülni kell, mivel a nyelv nem nyújt rá lehetőséget.
ha létezik egy __init__() metódusa az osztálynak, akkor példányosításkor az objektum létrehozása után meghívódik, átadva a példányosításkor esetleg megadott paramétereket:

    class Complex:
        def __init__(self, realpart, imagpart):
            self.r = realpart
            self.i = imagpart
 
    x = Complex(3.0,-4.5)
#(többszörös) öröklődés
 
class DerivedClassName([modulename.]Base1[,[[modulename.]Base2,…])

Ha egy hivatkozást nem talál az aktuális osztályban, akkor Base1-ben keresi,ha Base1-ben sincs, akkor Base1 őseiben. Ezután ha még mindig nem találta, akkor Base2-ben kezdi el keresni, és így tovább. Rekord vagy struct-szerű objektumok létrehozása:

 class Dolgozo:
    pass        # ez egy űres osztálydefiníció
 
 John = Dolgozo()
 John.nev = 'John Cosinus'
 John.osztaly = 'Matematikai reszleg'
 John.fizetes = 42000

A kivételek lehetnek osztályok és nem csak string objektumok. Forma: raise instance vagy raise Class, instance. Egy except klóz kompatibilis a kivétellel, ha ugyanabban az osztályban vannak vagy a kivétel egy ősosztályban van. Példa:

 class B:
    pass
 class C(B):
    pass
 class D(C):
    pass
 
 for c in [B,C,D]:
    try:
        raise c()
    except D:
        print "D"
    except C:
        print "C"
    except B:
        print "B"

Az eredmény B,C,D ebben a sorrrendben. Ha azonban az except ágakat fordítva írtuk volna, akkor az eredmény B,B,B lett volna, mert a legelső illeszkedő except ág aktivizálódik.

[szerkesztés] Szabványos könyvtárak

A Pythonnak igen kiterjedt és széleskörű standard könyvtára van, amit még kiegészítenek az egyéb (mások által megírt) publikus modulok. A könyvtár adattípusokat tartalmaz, amelyeket egyébként a nyelv magjának tekintenek (pl. számok és listák). Tartalmaz még beépített függvényeket és kivételeket, melyeket használni lehet import nélkül, viszont a legnagyobb része természetesen modulokban van. Ezek egy részét C-ben írták meg, és be van építve az interpreterbe, másokat python forráskódban kell importálni.