A Python programozási nyelv 2.

Általános célú programozási nyelv, Guido van Rossum holland programozó dolgozott ki. Könnyű olvashatóság jellemzi. A Python többek között a funkcionális, az objektumorientált, az imperatív és a procedurális programozási paradigmákat támogatja. Dinamikus típusokat és automatikus memóriakezelést használ. A Python úgynevezett interpreteres nyelv, ami 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.

Egyszerű adattípusok

A Python különbséget tesz a mutálható és a mutálhatatlan típusok között. Ezek a fogalmak első közelítésben a megváltoztathatóságra utalnak, ám a pontos különbség ennél finomabb.[12][13]

A Python 3 beépített típusai

típus leírás példa

str

Unicode string

'Wikipédia'

"Wikipédia"

"""Több

soros

string"""

bytearray

Bájtok (mutálható) sorozata.

bytearray(b'Some ASCII')

bytearray(b"ASCII karakterek")

bytearray([119, 105, 107, 105])

bytes

Bájtok (mutálhatatlan) sorozata.

b'ASCII karakterek'

b"ASCII karakterek"

bytes([119, 105, 107, 105])

list

List típus, ami eltérő típusokat is tartalmazhat, azaz nem tipizált lista.

[4.0, 'string', True]

tuple

Rendezett n-es.

(4.0, 'string', True)

set

frozenset

Rendezetlen halmaz adattípusok. Duplikátumokat nem tartalmazhatnak.

Nem tipizáltak, azaz eltérő típusú elemeket is tartalmazhatnak, ha azok hasíthatóak.

{4.0, 'string', True}

frozenset([4.0, 'string', True])

dict

Hasítótábla, más néven szótár vagy asszociatív tömb adattípus.

Kulcs-érték párokat tartalmazhat. A kulcsoknak hasíthatónak kell lenniük.

{'key1': 1.0, 3: False}

int

Tetszőleges méretű egész szám adattípus.

42

float

Lebegőpontos szám, melynek pontossága az implementáló rendszertől függ.

3.1415927

complex

komplex szám adattípus valós és képzetes résszel.

3+2.7j

bool

Kétértékű logikai adattípus.

True

False

Kivételkezelés

A kivételkezelés a try kulcsszóval történik. Például így:

try:

    f()

except (NameError,TypeError):

    print('Az f függvény végrehajtása során NameError vagy TypeError lépett fel.')

except Exception:

    print('Nem várt kivétel lépett fel.')

else:

    print('Semmilyen kivétel nem lépett fel.')

finally:

    print('Ez a mondat mindenképp kiíródik.')

Ha olyan kivétel lép fel a try blokkban, ami valamely except ágban szerepel, akkor a vezérlés az illető except ágnak adódik át. Egy except ág több kivételtípust is kezelhet, az egyes kivételtípusokat vesszővel elválasztva lehet megadni.

Az except ág lefutása után a try blokk utáni részen folytatódik a program. Ha nem lép fel semmilyen kivétel, akkor a vezérlés az else ágra kerül a lefutás után, ha az létezik. Mindig csak egy except ág fut le. Ha az utolsó except ág nem ad meg kivételtípust, akkor az kezeli az összes olyan kivételt, amit a megelőző ágak nem kezeltek. Végül szerepelhet egy opcionális finally blokk, ami mindenképpen lefut.

Ha nincs megfelelő except ág, akkor továbbadódik a kivétel a tartalmazó blokknak. Az except ágakban fellépő kivételek szintén a tartalmazó blokknak adódnak át. Ha egyáltalán nincs try blokk, például egy függvényben, akkor minden kivétel a tartalmazó blokknak adódik át.

def hibas_fuggveny():

    x=1/0

try:

    hibas_fuggveny()

except ZeroDivisionError as ex:

    print('Nullával osztás.', ex)

A nyelv tartalmaz beépített kivételeket, de a lehetőség van saját kivételeket definiálására is. A kivételek paraméterezhetőek, típusuktól függően más és más paraméterük lehet. Kivétel kiváltására a raise kulcsszó alkalmazható:

raise NameError('Hello')

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 nem publikusnak szánt adatokat, azonban maga a nyelv semmi biztosítékot nem nyújt arra, hogy hívó fél is valóban így fogja kezelni[14]. A tagváltozó vagy tagfüggvényt kezdhetjük egy aláhúzással, ezzel jelezvén, hogy ezt nem publikusnak szánjuk (gyakorlatilag a protected, package-private vagy privát láthatóságot szánjuk az adott tagnak).

class MyObject(object):

    def __init__(self, name):

        self._name = name   # Jelezzük, hogy ez egy protected vagy package-private adat

                            # nem szeretnénk, ha direktben használná bárki

                            # kivéve a csomagot, amiben van/leszármazott osztályokat

myobj = MyObject("Ez a nevem")

print(myobj._name) # De ez csak egy jelzés, kívülről ugyanúgy elérhető, mint bármely más adat

Különbségek a C++-hoz képest, hogy az osztály- és objektumváltozók publikusak (kivéve a dupla aláhúzással kezdődőeket, amik egy speciális mechanizmusnak köszönhetően megóvhatják a kódunkat például az öröklődéskor előforduló névfelüldefiniálásoktól[14]), é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ő (garbage collector) 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(object):

    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 az összeadás operátor (+) a "__add__", "__radd__", "__ladd__" segítségével, a szorzás operátor (*) 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(object):

    <statement-1>

    ...

    <statement-N>

#Például:

class MyClass(object):

    "Egy egyszerű példa osztály"

    i = 42

    def f(self):

        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 az osztály nevével, valamint a paraméterlista megadásával tudunk. Üres paraméterlistát is jeleznünk kell (nem úgy, mint C++-ban), egy üres zárójel-párral, különben az osztály referenciáját másoljuk egy változóba. (pl.: x = MyClass() ). Az objektumok tagváltozóit nem az osztálydefinícióban deklaráljuk, hanem az objektum inicializálására használt "__init__" metódusban, hiszen ezek így lokálisan, adott objektumpéldányra lesznek érvényesek, míg az osztálydefinícióban deklarált változók az egész osztályra (így bármely objektumára is) érvényesek lesznek.

Azonban azt is megtehetjük, hogy egy adat attribútumot később deklarálunk, mely az használatkor jön létre. Példa:

class MyObject(object):

    i = 42  # összes objektumpéldányra érvényes változó

            # (hasonlít a hagyományos statikus változókhoz, de nem teljesen ugyanaz a működése)

    def __init__(self):

        self.counter = 0  # objektum inicializáláskor létrehozunk egy tagváltozót

ctr = MyObject()

ctr.counter += 10  # módosítjuk a tagváltozó értékét

print(ctr.counter)  # 10

print(ctr.i)  # 42

ctr.anotherCounter = 0  # deklarálunk egy új adattagot az adott objektumba

print(ctr.anotherCounter)  # 0

MyObject.i = 100  # Az osztályban lévő i változót módosítjuk

anotherOne = MyObject()  # Létrehozunk egy másik objektumpéldányt

print(anotherOne.i)  # 100

print(ctr.i)  # 100

# print(ctr.anotherCounter)  # ebben az objektumban nincs ilyen tagváltozó

A del utasítással megszüntethetünk bármilyen változót, akár objektum-tagváltozót is.

class MyObject(object):

    def __init__(self):

        self.counter = 0

ctr = MyObject()

ctr.counter += 10

print(ctr.counter)  # 10

del ctr.counter

# print(ctr.counter) # itt már nincs ilyen tagváltozónk

Egy másik példa

def MyClass(object):

    i = 42

    def f(self):

        return 'hello world!'

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, hiszen a del utasítással töröltük a létrehozott counter nevű változót.

Ügyeljünk rá, hogy x.f nem ugyanaz, mint MyClass.f, mivel az első az hivatkozás az adott objektum egy tagfüggvényére (metódus típusú objektumra való hivatkozás), amely hivatkozás futás közben megváltozhat (tehát például más metódusra mutat), míg a MyClass.f a f függvény prototípusa, ezáltal függvény típusú objektumra való hivatkozás! 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) -szel.

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 lehetővé teszi, hogy kliensek elrontsák az invariánst, ha meglévő adat attribútumot írnak felül. Ezt a programozónak kell megoldania, 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 Alma(object):

    def __init__(self, szin, iz):

        self.szin = szin

        self.iz = iz

x = Alma("piros", "savanyu")

A Python lehetőséget nyújt a többszörös öröklődésre, melynek szintaxisa az alábbiak szerint néz ki:

class DerivedClassName([modulename.]Base1[,[[modulename.]Base2,…]):

    <statement-1>

    ...

    <statement-N>

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ására is van lehetőség, a már ismertetettek szerint, például egy üres osztály deklarálásával, majd az üres osztály egy példányát feltölthetjük:

 class Dolgozo:

    pass        # ez egy üres osztálydefiníció

 John = Dolgozo()

 John.nev = 'John Cosinus'

 John.osztaly = 'Matematikai reszleg'

 John.fizetes = 42000

Azonban, ha ilyen céljaink vannak, sokkal inkább ajánlott a szótár (asszociatív tömb) használata, hogy feleslegesen ne terheljük az interpretert ilyen dummy osztályok, majd abból keletkező objektumok létrehozásával:

dolgozok = list()

John = {'nev': 'John Cosinus',

      'osztaly': 'Matematikai részleg',

      'fizetes': 42000}

dolgozok.append(John)

Jason = dict()

Jason['nev'] = 'Jason Cosinus'

Jason['osztaly'] = 'Matematikai reszleg'

Jason['fizetes'] = 42000

dolgozok.append(Jason)

A kivételek korábban lehettek egyszerű string objektumok, azonban Python 3-ban csak és kizárólag a "BaseException" osztály, vagy leszármazottjának egy példánya lehet.

Forma: raise instance. Egy except klóz kompatibilis a kivétellel, ha ugyanabban az osztályban vannak vagy a kivétel az elkapni kívánt típus leszármazottja. 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 sorrendben. 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.

>>> var = [[1,1,1],[1,1,1],[1,1,1]]
>>> print var
[[1, 1, 1], [1, 1, 1], [1, 1, 1]]

feltöltése

for i in range(3)
  for j in range(3)
    tomb[i,j] = érték

vagy

tomb = []

tomb2 = [1,2,3]
tomb3 = [4,5,6]
tomb4 = [7,8,9]
tomb.append(tomb2)
tomb.append(tomb3)
tomb.append(tomb4)
print tomb[2][1] # 8, a 2-es indexű sor 1-es indexű eleme.
print tomb # [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

http://www.codeskulptor.org/

Ezen a felületen bárki gyakorolthat, nem kell környezet, nem kell letölteni semmit csak programozni phytonban.