Python (programozási nyelv)

Python
Paradigma	többelvű
Megjelent	1991
Tervező	Guido van Rossum
Fejlesztő	Python Software Foundation
Utolsó kiadás	3.2.3 (2012. április 11.)
Típusosság	erős, dinamikus
Fordítóprogram	CPython, Jython, IronPython, PyPy
Megvalósítások	CPython, IronPython, Jython, Python for S60, PyPy
Hatással volt rá	ABC, C, Haskell, Icon, Lisp, Modula-3, Perl, Smalltalk, Tcl
Befolyásolt nyelvek	Ruby, Boo
Operációs rendszer	platformfüggetlen
Licenc	Python Software Foundation License
Weboldal

A Python egy általános célú, nagyon magas szintű programozási nyelv, melyet Guido van Rossum holland programozó kezdett el fejleszteni 1989 végén, majd hozott nyilvánosságra 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, objektumorientá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.

A Python úgynevezett interpreteres nyelv, amely azt jelenti, hogy nincs különválasztva a forrás- és tárgykód, a megírt program máris futtatható, ha rendelkezünk a Python értelmezővel. A Python értelmezőt számos géptípusra és operációs rendszerre elkészítették, továbbá számtalan kiegészítő könyvtár készült hozzá, így rendkívül széles körben használhatóvá vált.

Története

A Python az Alapítványi Matematikai Központban, 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.

Jellemzői

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)

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

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.

Szabványos könyvtárak

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

Ismertebb Pythonra épülő alkalmazások

• a Zope alkalmazáskiszolgáló,
• ill. a Zope-ra épülő Plone tartalomkezelő-rendszer (CMS)
• Mailman levelezési listakezelő
• Trac projekt-kezelő rendszer
• a kéretlen reklámleveleket kiszűrő SpamBayes
• az egyik leghíresebb fájlcserélő szoftver, a BitTorrent eredeti implementációja

Külső hivatkozások

• Hivatalos weboldal
• Magyar Python honlap
• Gérard Swinnen : Tanuljunk meg programozni Python nyelven
• Raphael Marvie : Bevezetés a Pythonba példákkal
• Python 2.4 Quick Reference
• Python oktató régi és újabb honlapja (részben magyar)
• Egy jó bevezetés a Python programozási nyelvbe
• Guido van Rossum FSF díjat kap
• Regular Expression HOWTO A Python reguláris kifejezéskezeléséről angolul
• Dive into Python, angol, Python oktató programozóknak sok hasznos példával
• Python.lap.hu - linkgyűjtemény