A Python programozási nyelv

Típusok

A Pythonban minden objektum. A Javatól eltérően nem különbözteti meg a beépített (primitív) típusokat a felhasználó által definiált típusoktól (osztályoktól). Minden objektum rendelkezik egy identitással, típussal és értékkel. Az identitás az objektum létrehozása után többé nem változik. Az `is' operátorral hasonlíthatjuk össze két objektum identitását, az id() metódus pedig visszadja egy objektum identitását (a jelenlegi implementációban ez az objektum címe). Hasonlóan egy objektum típusa is állandó az objektum élete alatt. Ez határozza meg, hogy az objektum milyen műveleteket támogat, milyen tulajdonságokkal rendlkezik, ill. az objektum lehetséges értékeit. Az objektumok értéke az objektum típusától függően változhat. A változtatható értékű objektumokat mutábilis, a nem változtatható értékű objektumokat immutábilis objektumoknak nevezzük.

Néhány objektum tartalmazhat referenciát más objektumokra. Ezeket összefoglaló néven konténer típusoknak nevezzük. Ilyen pl. a lista, a tuple, a szótár.

Az objektumok típusa nagy jelentőséggel bír. Immutábilis típusoknál előfordulhat, hogy új értéket kiszámító műveletek egy már létező objektumra mutató referenciát adnak vissza, míg mutábilis típusoknál ez nem megengedett.

A Python típus-hierarchiája

Az opcionális array modul egy másik példa a módosítható sorozat típusra.

Az opcionális könyvtári modul dbm, gdbm, bsddb további példa leképezés típusra.

 

A Python 2.3-ban már van standard halmaz adattípus. Az új halmaz modul tartalmazza a halmaz adattípus egy implementációját. A Set osztály megvátoztatható (mutable), van betesz (add()) és kivesz (remove()) művelet. Az ImmutableSet osztályt viszont nem lehet módosítani. Példa:

>>>import sets >>>S = sets.Set([1, 2, 3]) >>>S Set( [1, 2, 3] ) >>> 1 in S True >>> 0 in S >>>False >>>S.add(5) >>>S.remove(3) >>>S Set([1, 2, 5])

A 2.3-as Pythonban már volt sets (halmaz) modul. A 2.4-es verzióban a halmaz adattípus C implementációját adták a Python magjához, mint két új beépített típus, a set és a frozenset (A frozenset immutable verziója a set-nek.). Ezek gyors műveleteket tartalmaznak annak eldöntésére, hogy

A sets modul továbbra is a standard könyvtárban van, és akkor lehet hasznos, ha alosztályt szeretnénk létrehozni a Set vagy az ImmutableSet osztályból. Még nincs terv a sets modul kivételére a standard könyvtárból.

A boolean típus a 2.3-as verzióban jelent meg. Két új konstanst -True, False- adtak a beépített, szabványos __builtin__ modulhoz. Korábban a True és a False értékek 1 és 0-nak  (integer!) feleletek meg, és nem egy külön típus tipusértékhalmazának elemei voltak. Az  konverziós függvény neve bool, ami bármilyen Python értéket átkonvertál True-ra vagy False-ra.

Példa:

>>>bool(1) True >>>bool(2) False >>>bool([])      #l a paraméter egy üres lista False

A legtöbb beépített könyvtári modul és beépített függvény is megváltozott, olyan értelemben, hogy a visszatérési értékük Boolean lett és nem 0 vagy 1. 

A Boolean típus bevezetésének a célja, hogy a kód olvashatóbb legyen. Például, ha nézünk egy függvényt, amelyben return 1 utasítás van, akkor nem tudjuk, hogy az 1 a true-nak felel-e meg, vagy egy index, esetleg egy mennyiség.

Operátorok

Összehasonlítás

Az összehasonlító operátorok használata tetszőleges típusú objektumok között lehetséges. Az operátorok precedenciaértéke azonos. Az összehasonlításokat akár láncba is fűzhetjük, tehát a x < y <= z kifejezés ekvivalens azzal. hogy x < y and y <= z, lusta kiértékelés mellett.
A különböző típusú objektumok soha nem lehetnek egyenlőek összehasonlításkor, kivéve a numerikus típusúakat. Különböző típusú objektumok konzisztensen rendeződnek, ám a típusok sorrendje tetszőleges. Tehát pl. a [1, 2, "alma", "korte", 3] lista rendezés után lehet: [1,2,3, "alma, korte"], vagy ["alma", "korte", 1,2,3].
Az összehasonlító operátorok a következők:

< szigorúan kisebb mint
<= kisebb vagy egyenlõ
> szigorúan nagyobb mint
>= nagyobb vagy egyenlõ
== egyenlõ
!= nem egyenlõ ( "<>" is megengedett)
is objektumok azonossága (objektumok azonosak-e, nem értékek)
is not tagadott objektumazonosság
X < Y < Z < W várt jelentése a C-beni jelentéssel nem azonos

Igazságérték-tesztelés

A Pythonban minden objektumnak tesztelhető az igazságértéke. Az alábbi értékek adnak hamisat: Minden más objektum igaz logikai értékű.

Logikai operátorok

A logikai operátorok a következők: not X: ha X hamis akkor 1, különben 0
X or Y: ha X hamis akkor Y, különben X
X and Y: ha X hamis akkor X, különben Y
Az 'or' és az 'and' operátor kiértékelése lusta, tehát a második argumentum csak akkor értékelődik ki,ha az első kiértékelése után még nem állapítható meg a kifejezés logikai értéke.
A 'not' operátor precedenciája gyengébb, mint az nemlogikai operátoroké. Ebből következik, hogy a 'not a == b' kifejezés 'not (a == b)'-ként értelmezi az elemző.

Tagságot vizsgáló operátorok

x in y: az eredmény 1, ha x tagja az y sorozatnak

x not in y: az eredmény 1, ha x tagja az y sorozatnak

Azonosítót vizsgáló operátorok

x is y: az eredmény 1, ha id(x) értéke egyenlő az id(y) értékével

x is not y: az eredmény 1, ha id(x) értéke nem egyenlő az id(y) értékével

Minden numerikus típusra vonatkozó mûveletek:

abs(x) x abszolút értéke
int(x) x értékét integer típusra konvertáljuk

    Az int()  típuskonstrukciós függvény OverflowError helyett long integer-rel tér vissza, akkor, ha a  megadott string vagy a float típusú paraméter túl nagy integernek.

long(x) x értékét long integer típusra konvertáljuk
float(x) x értékét lebegõpontos számmá konvertáljuk
complex(karakterlánc) vagy complex(valós, imaginárius) : komplex számmá alakít.

    Pl.: complex(’2’) megfelel a (2+0j)-nek

-x x értékét negáljuk
+x x változatlan
x + y x és y összege
x - y x és y különbsége
x * y x és y szorzata
x / y x és y hányadosa
x % y x / y maradéka
x**y : az x-et az y-dik hatványra emeli
divmod(x, y) eredménye (x/y, x%y) tuple típusú változó
pow(x, y) x y-adik hatványa (xy)
coerce(ob1, ob2) : azonos típusra konvertálja az ob1 és az ob2 változókat, és az két számot tuple szerkezetként adja vissza.
round(lebeg, számjegy) : kerekíti a lebeg számot

Integer osztás eredménye mindig lefele kerekített integer.

Bitmûveletek integer és long integer típusú változókon

~x            x invertálása (1-es komplemens)
x ^ y        x és y változók értékeire bitenkénti kizáró VAGY
x & y       x és y változók értékeire bitenkénti kizáró ÉS
x | y          x és y változók értékeire bitenkénti VAGY
x << n     x bitjeinek eltolása balra n bittel
x >> n     x bitjeinek eltolása jobbra n bittel

Minden szekvencia típusú változóra (lista, tuple, sztring) alkalmazható operátorok

len(s) s hossza
min(s) legkisebb értékû elem s-ben
max(s) legnagyobb értékû elem s-ben
x in s 1 ha s egy elme azonos x-szel, különben 0
x not in s 0 ha s egy elme azonos x-szel, különben 1
s + t s és t konkatenációja
s * n, n * s s-t n-szer konkatenálja össze
s[i] s i-edik eleme, kezdõérték 0
s[i:j] s i-tõl j-ig vett része, szelete
i indextõl j indexig, de a j-edik elemet már nem tartalmazó, szelet
i alapbeállítás szerinti értéke 0, j alapbeállítás szerinti értéke len(s)
negatív értéket a szekvencia jobb végétõl számítjuk
s[i:j:k]s i-től j-ig vett szelete, k lépéssel.

A legtöbb sorozat típusú objektum összehasonlítása lexikografikus módon történik.

A 2.3-as verzióban az in operátort megváltozott a stringek esetén. Korábban, amikor az x in y-t kiértékeltük, ahol az x és az y string típusúak voltak, és az x csak egyszerű karakter lehetett -azaz egy hosszú string. Most már az x akármilyen hosszú string lehet, és az x in y true, akkor, ha az x „alstring”-je az y-nak. Ha az x az üres string, akkor az eredmény mindig true. Például:

 >>> ’ab’ in ’abcd’ True >>> ’ad’ in ’abcd’ False >>> ’’ in ’abcd’ True

Karakterláncokon végezhető alapműveletek

repr(): string-é konvertál, a tárolt érték tényleges karakteres formáját adja vissza
str(): string-é konvertál, de a repr()-el ellentétben ez jobban olvasható, formázott szöveges formát ad visssza.
A Stringekről, és a rajtuk végezhető műveletekről egy külön fejezetben, a "Stringkezelés" menüpont alatt olvashat részletesebben.

Módosítható szekvenciákra(listákra) vonatkozó operátorok

s[i] = x s s i-edik elemét x-re cseréljük
s[i:j] = t s i-tõl j-ig tartó szeletét t-re cseréljük
del s[i:j] szeletet törlünk (azonos a s[i:j] = [] mûvelettel)
s.append(x) x-et az s lista végéhez fûzzük
s.count(x) azon indexek számát adja vissza, melyekre s[i] == x, (vagyis x elõfordulási számát)
s.index(x) x legkisebb indexû elõfordulásának helyét adja vissza, (vagyis a legkisebb i-t, melyre s[i] == x)
s.insert(i, x) i-edik elem x lesz, a korábbi i-edik elem az i+1. elem, stb.  A lista elejére is beszúrhatunk, ha az i negatív.
s.remove(x) azonos a del s[s.index(x)] mûvelettel
s.reverse() s listát megfordítja (helyben)
s.sort() rendezi a listát (helyben)
s.extend(sorozat): hozzáfűzi a sorozat elemeit a listához.
s.pop([i]): visszaadja lista i-dik pozíciójában szereplő elemet, ha a pozíció nincs megadva, akkor az utolsót. A visszaadott        objektumot törli is a listából.
Opcionális paraméter: két argumentumos függvény -1, 0 vagy 1 értékkel tér vissza attól függõen, hogy az arg1 >,==,< arg2- nél.
IndexError hibaüzenetet kapunk, ha a szekvencia indextartománya érvénytelen értékhatárt jelöl.

Operátorok értéktáblás változókra (dictionary típus)

len(a) a-ban található elemek száma
a[k]: a k kulcsú eleme
a[k] = x: a[k] értéke x lesz
del a[k]: a[k] -t a-ból eltávolítjuk, kivesszük
a.items(): a elempárjainak (kulcs, érték) listáját adja vissza
a.keys(): a kulcsainak listáját adja vissza értékül
a.values(): a értékeinek listáját adja vissza értékül
a.has_key(k), k in a: True ha a-ban van k nevû kulcs, különben False
iter(d): visszaadja d szótár kulcsai fölötti iterátort. Ez megfelel a d.iterkeys() metódushívásnak.
fromkeys(seq, [value]): Elkészít egy szótárat a seq sorozat típus elemeit használva kulcsoknak, mindegyiknek value értéket beállítva
d.items(): visszatér a szótárról készült, (kulcs, érték) párok tartalmazó lista másolattal
d.iteritems(): visszatér a szótár (kulcs, érték) párjai feletti iterátorral
d.iterkeys() visszatér a szótár kulcsai feletti iterátorral
d.itervalues() visszatér a szótár értékei feletti iterátorral
d.keys(): visszaad egy másolatot a szótár kulcsairól
d.values(): visszaad egy másolatot a szótár értékeiről
s.clear(): a szótár minden elemét törli
s.get(kulcs, alapért): visszatérési értéke a kulcs értéke, illetve az alapért értéke, ha a kulcs nincs a szótárban.
s.copy(): másolatot hoz létre a szótárból
s.update(s1): felveszi a s1 szótár értékeit a s szótárba 
pop(key [,default]), amely visszaadja a kulcshoz tartozó értéket, és törli a kulcs-érétk párt a szótárból. Ha nincs ilyen kulcs, akkor a default-ot kapjuk vissza, ha az meg van adva, különben KeyError kivételt kapunk. Példa: 

>>> d = {1:2} >>> d {1: 2} >>> d.pop(4) Traceback (most recent call last): File "stdin", line 1, in ? KeyError: 4 >>> d.pop(1) 2 >>> d.pop(1) Traceback (most recent call last): File "stdin", line 1, in ? KeyError: ’pop(): dictionary is empty’ >>> d {}

TypeError hibaüzenetet kapunk, ha a kulcs helytelen értékû.
KeyError hibaüzenetet kapunk, ha nem létezõ kulcsot szeretnénk olvasni.

A halmaz típus műveletei:

len(s): s halmaz hosszát adja vissza
x in s: igazzal tér vissza, ha x eleme s halmaznak
s.isdisjoint(other): igazat ad, ha s és other metszete üres halmaz (diszjunkt halmazok)
s.issubset(other), s <= other: igazzal tér vissza, ha s részhalmaza az other halmaznak
s < other: igazat ad, ha s valódi részhalmaza other-nek
s > other, s >= other: igazat ad ha s-nek rézhalmaza (ill. valódi részhalmaza) az other halmaz
s.union(other, ...): visszaadja s és a paraméter halmazok unióját
s | other | ...: visszaadja a set, az other és a többi halmaz unióját
s.intersection(other, ...), s & other & ...: visszadja s, other és a többi halmaz metszetét
s.difference(other, ...), s - other - ...: Visszadja a halmazok különbségét. A művelet balasszociatív.
s.symmetric_difference(other), s ^ other: visszaadja azokat az elemeket, amelyek vagy s-ben vagy other-ben szerepelnek, de nem mindkettőben
s.copy(): Lemásolja s-et, és visszatér az új objektummal
A következő elemek kizárólag a módosítható halmazokra érvényesek:
s.update(other, ...), s |= other, ...: s halmazba felveszi az other és a többi halmaz azon elemeit, melyek nem szerepelnek s-ben
s.intersection_update(other), s &= other &= ...: kizárólag azokat az elemeket hagyja meg s-ben, melyek szerepelnek s-ben, other-ben és az összes többi halmazban
s.difference_update(other, ...), s -= other -= ...: Kiveszi s-ből az összes olyan elemet, amely megtalálható other-ben vagy az összes többiben
s.symmetric_difference_update(other), s ^= other s elemei közül csak azokat az elemeket tartja meg, amelyek valameyik halmazban megtalálhatóak, de mindkettőben nem
s.add(elem): elem-et beteszi s halmazba
s.remove(elem): elem-et kiveszi a halmazból. KeyError kivétel keletkezik, ha elem nem található s-ben
s.discard(elem): elem-et kiveszi a halmazból, ha az benne van
s.pop(): kivesz és visszaad egy tetszőleges elemet a halmazból
s.clear(): minden elemet töröl a halmazból

Fájl objektum operátorai

f.close(x) lezárja az f fájlt.
f.fileno(x) visszaadja a fájlleíró azonosítót (fd) az f fájlra.
f.flush(x) kiüríti a fájl belsõ pufferét.
f.isatty() 1, ha fájlt tty típusú eszközhöz kapcsolták, máskülönben 0.
f.read([méret]) legalább a méretnek megfelelõ mennyiségû adatot olvas a fájlból és azt sztring objektumként adja vissza. Ha nem adunk méretet, akkor a fájl végéig olvas.
f.readline() egy teljes sort olvas a fájlból.
f.readlines() a fájl végéig olvas a readline() operátorral és a beolvasott sorokból álló listát adja vissza értékül.
f.seek(offset, whence=0) beállítja a keresési pozíciót a fájlban, mint a
"stdio fseek()" függvénye.
whence == 0 , akkor abszolút indexelést használ,
whence == 1 , akkor az offset értékkel megadott értékkel a jelenlegi pozícióhoz képest,
whence == 2 , akkor az offset értékkel megadott értékkel a a fájl végéhez viszonyítva.
f.tell() visszaadja az olvasófej jelenlegi pozícióját a fájlban.
f.write(str) az str sztringet a fájlba írja.
f.writelines(list) a list sztringlistát a fájlba írja.

 

Megjegyzések a típusokhoz: Nincsen rekord, unió, halmaz, mutató típus. Saját adattípust, mint osztályobjektumot hozhatunk létre, eléggé furcsa módon (lásd osztályok). Nincs automatikus típuskonverzió, a típusok ekvivalenciája névekvivalencia.

Az összetett típusok összehasonlítása lexikografikusan történik.

Decimális típus

Amíg a legtöbb programozási nyelvben van lebegőpontos típus (a Python korábbi verziójában is volt már), sok ember - a programozókat is beleértve - nem tudja, hogy a lebegőpontos számok nem reprezentálják pontosan a decimális törteket. Ez az új Decimális típus már a felhasználók által megkívánt pontossággal reprezentálja a törteket. Habár lehet, hogy csak kicsik a "csalások", különböző műveleteknél - gondoljunk például a numerikus analízisnél tanult ... - a hiba nagysága hihetetlenül megnőhet.

Új modul, a decimal, a Python standard könyvtárában. Ez két osztályt tartalmaz, a Decimal és a Context. A Decimal reprezentálja a számokat, míg a Context-ban vannak a különböző beállítások, mint például a pontosság ésdefault kerekítési mód.

A decimális objektumok - immutable-k (megváltoztathatatlan). Integerekből vagy stringekből hozhatunk létre decimális objektumot.

>>> import decimal >>> decimal.Decimal(1972) Decimal("1972") >>> decimal.Decimal("1.1") Decimal("1.1")

így is megadhatunk egy decimális számot: Egy vektorban adjuk meg a decimális számot úgy, hogy a vektor első eleme jelöli az előjelet (0:+, 1:-), majd vektorban a számjegyeket, végül a kitevőt.

>>> decimal.Decimal((1, (1, 4, 7, 5), -2)) Decimal("-14.75")

Konvertálás lebegőpontos számról decimálissá: Javasolt sajátkezűleg konvertálni a lebegőpontos számról stringre, majd ezt átadni a Decimal konstruktoának. Pl.:

>>> f = 1.1 >>> decimal.Decimal(str(f)) Decimal("1.1") >>> decimal.Decimal('%.12f' % f) Decimal("1.100000000000")

Decimális számokon már lehet a megszokott műveleteket végezni: +, -, *, /, azonban a hatványozásnál van egy olyan kitétel, hogy a kitevő csak integer lehet. Pl.:

>>> a = decimal.Decimal('35.72') >>> b = decimal.Decimal('1.73') >>> a+b Decimal("37.45") >>> a-b Decimal("33.99") >>> a*b Decimal("61.7956") >>> a/b Decimal("20.64739884393063583815028902") >>> a ** 2 Decimal("1275.9184") >>> a**b Traceback (most recent call last): ... decimal.InvalidOperation: x ** (non-integer)

A decimális számokat lehet integerekkel kombinálni, azonban lebegőpontos számokkal nem. Pl.:

>>> a + 4 Decimal("39.72") >>> a + 4.5 Traceback (most recent call last): ... TypeError: You can interact Decimal only with int, long or Decimal data types. >>>

A decimális számokra használhatóak math és a cmath modulok függvényei, azonnal lebegőpontossá konvertálódnak, így elvesztik pontosságukat. A visszatérési érték nem decimális, hanem lebegőpontos érték lesz.

A Context típus:

Számos beállítást foglal magába a decimális típus műveleteire vonatkozóan.

A getcontext() hívással állíthatjuk be a fent említett értékeket. Pl.:

>>> decimal.getcontext().prec 28 >>> decimal.Decimal(1) / decimal.Decimal(7) Decimal("0.1428571428571428571428571429") >>> decimal.getcontext().prec = 9 >>> decimal.Decimal(1) / decimal.Decimal(7) Decimal("0.142857143")