Python (programozási nyelv)
A Python többek között a funkcionális, az objektumorientált, az aspektusorientált az imperatív és a procedurális programozási paradigmákat támogatja. Dinamikus típusokat és automatikus memóriakezelést használ, ilyen szempontból hasonlít a Scheme, Perl és Ruby nyelvekhez, emellett szigorú típusrendszerrel rendelkezik. Erőssége a gazdag szabványos programkönyvtár.[40][41] 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. Az egyik legnépszerűbb programozási nyelv.[42][43][44][45] Nyitott, közösségalapú fejlesztési modellt mutat fel, amit a közhasznú Python Software Foundation felügyel, ami a nyelv definícióját a CPython referenciaimplementációval gondozza. TörténeteA Python alapötlete az 1980-as évek végén született meg. A fejlesztést 1989 decemberében kezdte el Guido van Rossum a CWI-n.[46] A CWI (Centrum Wiskunde & Informatica, magyarul Matematikai és Informatikai Központ) egy kutatóintézet Amszterdamban. A nyelv a nevét a Monty Python csoportról kapta.[47] 1991 februárjában jelent meg az első nyilvános változat (0.9.0 verzió néven) az alt.sources hírcsoportban.[48] 1994-ben jött létre a comp.lang.python hírcsoport, ami egy jelentős mérföldkő volt a nyelv fejlődésében.[49] Szintén 1994-ben látott napvilágot az 1.0 verzió, amit az ezredfordulón, 2000 októberében követett a Python 2.0, majd pedig 2008-ban a Python 3.0.[50] Már a Python 1-es verziója bírt bizonyos funkcionális képességekkel, melyeket azonban később kivezettek belőle.[51] Kilenc alverziója jelent meg. A Python 2-es verziója vezetett be olyan képességeket, mint a ciklusfelismerő szemétszedés, a referenciaszámolás, a list comprehension és a Unicode támogatás.[52] A Python 2 utolsó hivatalos verziója a 2.7.18, ami 2020-ban jelent meg.[53] A 2.6-os verzióban bevezettek egy eszközt, amivel meg lehetett nézni, hogy mely kódszakaszokat nem támogatnak majd a jövőben.[54] A főbb verziók nem kompatibilisek egymással. A Python 3.0 több újdonságát visszavezették a Python 2.6-ba és Python 2.7-be. Az áttérés megkönnyítése érdekében a Python 3-ba berakták a Azóta a 3.6-os verzió támogatását megszüntették. 2021-ben felgyorsították a 3.8.8 és a 3.9.2 megjelenését,[61] mivel az összes Python verzióval biztonsági problémák adódtak, beleértve a 2.7-et is.[62] Ez lehetővé tette a távoli kódvégrehajtást[63] és a cache-mérgezést.[64] 2022-ben a 2022, Python 3.10.4 és 3.9.12 kiadását hozták előre,[65] és a 3.8.13 és 3.7.13 verziókat is gyorsítva adták ki, szintén biztonsági problémák miatt.[66] Amikor 2022 májusában megjelent a 3.9.13-as verzió, bejelentették, hogy a 3.9-es sorozat ezután csak biztonsági frissítéseket fog kapni.[67] 2022 szeptember 7-én a 3.10.7, 3.9.14, 3.8.14 és 3.7.14 jelent meg, mivel az előző verziók sérülékenynek bizonyultak a szolgáltatásmegtagadási támadásokkal szemben.[68][69] Az elavult Tervezési filozófia és képességek A Python egy többparadigmás programozási nyelv. Az objektumorientált és a strukturált programozás teljes támogatást élvez, a funkcionális programozást és az aspektusorientált programozást több képességgel támogatja, köztük metaprogramozással[71] és metaobjektumokkal[72] is. Kiegészítőkkel elérhetők további paradigmák, mint a szerződés alapú tervezés[73][74] vagy a logikai programozás.[75] Mindez lehetővé teszi, hogy a programozók azt a megközelítést válasszák, amelyiket akarják, vagy amit az adott feladathoz célszerűnek találnak. A Python dinamikus típusozást használ, de a 3.5-ös verziótól kezdve annotációban lehet jelezni a típusokat, hogy a külső szofverek által igényelt típus-kikövetkeztetést megkönnyítsék.[76][77] A szemétszedés referenciaszámláláson és ciklusfelderítésen alapul.[78] A névfeloldás dinamikus (késő kötés), ami azt jelenti, hogy a metódusnevek és a változónevek a program végrehajtása során kapcsolódnak össze. A Lisp hagyományai alapján funkcionális képességekkel bír, mint a Magfilozófiáját a The Zen of Python (PEP 20) összegzi. A legfontosabb aforizmák:[81]
Ahelyett, hogy az összes képességet beépítették volna a magba, a Pythont úgy tervezték, hogy bővíthető legyen. Ez a kompakt modularitás népszerűvé vált, mint programozható interfészek hozzáadása már létező alkalmazásokhoz. Van Rossum egy kis magnyelvet és egy áttekinthető, nagy standard könyvtárat vizionált könnyen bővíthető értelmezővel, mivel frusztrálta az ABC ellenkező megközelítése.[49][82] Ez lehetővé teszi, hogy Python kódból olyan modulokat hívjanak, amelyek más nyelven íródtak. Így például az időkritikus részek áttehetők C-be.[83] Megfordítva, Python modulok és pluginok írhatók más programok számára. Így használják a következőkhöz: Blender, Cinema 4D, GIMP, Maya, OpenOffice illetve LibreOffice, PyMOL, SPSS, QGIS vagy KiCad. A Python egyszerű, átlátható szintaxisra törekszik,[84] míg meghagyja a választás szabadságát a különböző programozási metodológiák között. A kulcsszavak számát is alacsonyan tartják az egyszerűség és átláthatóság érdekében.[85] Szemben a Perl megközelítésével, hogy többféleképpen is meg lehet csinálni, a Python azt a gondolatot karolja fel, hogy legyen egy nyilvánvaló mód megtenni valamit, és ez lehetőleg az egyetlen mód legyen.[81] Alex Martelli, a Python Foundation tagja és Python könyvszerző szerint Python kultúrában valamit okosnak nevezni nem számít bóknak.[86] A Python fejlesztői arra törekszenek, hogy elkerüljék a korai optimalizációt, és elutasítják a CPython referencia implementáció nem kritikus részeinek patcheit, melyek kisebb sebességnövekedést eredményeznek az érthetőség csökkentése mellett.[87] Ha fontos a sebesség, akkor a Python fejlesztő az időkritikus függvényeket átteszi egy olyan modulba, melyet egy gyorsabb nyelven írtak, például C-ben. További lehetőségek a PyPy, illetve a Cython használata. A Cython a Python kódot C-re fordítja, és közvetlen C-szintű API-hívásokat használ. A Python fejlesztői arra is törekszenek, hogy a nyelv használata örömet okozzon. Ezt tükrözi a névválasztás is: a név forrása a Monty Python,[88] és a tutorialok és referenciaanyagok alkalmankénti játékos megközelítése, például a ham (sonka) és eggs (tojás(ok)) szavak használata az általános foo és bar helyett. Ez utalás a Monty Python egy játékára.[89][90][91] Amellett, hogy Guido van Rossum kedvelte a Monty Python társulatot, a nevet úgy választotta, hogy a név legyen rövid, egyértelmű és misztikus.[88] Ezzel szemben a logó a kígyókkal való asszociációt támogatja, ami megnyilvánul a Python által befolyásolt Cobra nevének választásában.[92] és a Boa eszközkészlet elnevezésében.[93] Az angol nyelvű Python közösségben több neologizmus is született. A pythonic szó azt jelenti, hogy jól használják a Python idiómákat, a nyelvet folyékonyan, illetve természetesen használják, megfelelnek a minimalista filozófiának és az olvashatóságot is fontosnak tartják. Ezzel szemben egy nehezen érthető vagy egy nyersfordításnak kinéző kód unpythonic.[94][95] A Python programozókat, különösen a tapasztalt szakértőket pedig Pythonistasnak nevezik.[96][97] Szintaxis és szemantikaA nyelv egyik alapkoncepciója, hogy könnyen olvasható legyen. Formázása vizuálisan folyékony, és gyakran angol kulcsszavakat használ ott, ahol sok más nyelv központozást használ. Ennek célja az olvashatóság javítása. Sok más nyelvtől eltérően nem használ kapcsos zárójeleket a blokkok elhatárolására, és pontosvesszőt sem kötelező kitenni az egyes utasítások után, habár nem tilos. Viszont ha több utasítást írnak egy sorba, akkor azokat pontosvesszővel kell elválasztani. Kevesebb a szintaktikai kivétel és speciális eset, mint a C-ben vagy a Pascalban.[98] A Python nyelv behúzásokat használ a blokkok elkülönítésére kulcsszavak vagy kapcsos zárójelek helyett. Bizonyos utasítások, amelyek új blokkot nyitnak, a behúzás növelését követelik meg. A blokk addig tart, amikor a behúzás újra kisebb.[99] Így a szkriptek szintaktikai szerkezetét a látható struktúra is reprezentálja.[100] Angolul ezt a szabályt néha off-side rule néven emlegetik. Még néhány nyelv használja ezt a szabályt, mint például a Haskell és a Miranda, de a legtöbb nyelvben a behúzásnak nincs szemantikus jelentése. Egy programban a behúzás alapegységének egységesnek kell lennie, különben az szintaktikai hiba, melyet az értelmező IndentationError néven jelez. A szóközök és a tabulátorok keverése esetén elvész a hordozhatóság. Ugyanis a tabulátorok és a szóközök közötti átváltási arány a szövegszerkesztő, illetve az értelmező beállításától függ. A tabnanny modul segít megtalálni és megszüntetni a szóközök és a tabulátorok keverését. Konvenció szerint a behúzás alapegysége négy szóköz.[101] A behúzás e célú használata Peter J. Landintól származik. 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.[102][103] A Python kacsa-típusozást (duck-typing) használ. A változónevek nem típusozottak, de az objektumok igen. A típusmegkötéseket nem ellenőrzi fordítási időben; ha az adott típuson nem végezhető el az adott művelet, akkor az futási időben derül ki. A dinamikus típusozás azt jelenti, hogy az adattípus az értékhez és nem a változóhoz kötődik.A dinamikus típusozás mellett a nyelv erősen típusos, ami azt jelenti, hogy a nem jóldefiniált műveletek nem végezhetőek el. A típusvizsgálat szigorúbb, mint a Perl, de kevésbé szigorú, mint az Objective CAML esetén. A Pythonban osztályokkal lehet újabb típusokat definiálni. Új példányok az osztály hívásával hozhatók létre, például A 3.0 verzió előtt kétféle osztály volt, régi stílusú és új stílusú. A 3.x sorozat csak az új stílusú szemantikát támogatja.[104] A hosszú távú tervek között szerepel a graduális típusozás támogatása.[105] A Python szintaxisa lehetővé teszi statikus típusok használatát, azonban ezeket nem ellenőrzi az alapértelmezett CPython implementáció.[106]
AritmetikaA Python nyelvben az aritmetikai műveletek: ( Az osztás viselkedését a 3.0 verziótól kezdve változtatták meg. Python terminológiával a Mindig az alsó egészrészt venni következetességet jelent. Így mindig teljesül, hogy Lebegőpontos számokat a Az összehasonlítások kiértékelése is illeszkedik a matematikában szokásoshoz: Az egészaritmetika tetszőleges pontosságú. A A Python kiterjedt matematikai képességeit a függetlenül fejlesztett NumPy könyvtár bővíti. A Pythont ezzel kibővítve használják tudományos szkriptnyelvként numerikus adatfeldolgozásra és manipulációra.[118][119] Utasítások és vezérlő szerkezetekA Python utasítások közé tartoznak:
Az értékadás ( A Python nem támogatja a végrekurziót vagy az első osztályú kontinuációkat, és ezek Van Rossum szerint nincsenek is tervben. A generátorok kiterjesztésével azonban megvalósítható a korutinszerű viselkedés. A 2.5-ös verzió előtt a generátorok lusta iterátorok voltak; az adatok a generátor hívása után csak egy irányba mozogtak, a generátorból kifelé. Azóta a generátor hívása után is lehet vele kommunikálni, és a 3.3-tól kezdve több stack szinten át is lehet velük kommunikálni. KifejezésekNéhány Python kifejezés hasonlít C és Java kifejezésekhez, mások azonban különböznek:
A Python kikényszeríti a kifejezések és az utasítások megkülönböztetését, szemben a Ruby, a Common Lisp és a Scheme nyelvekkel. Ez bizonyos funkciók megduplázásához vezet:
Az utasítások nem lehetnek kifejezések részei, így a lista és más comprehensionök, illegve a lambda kifejezések nem tartalmazhatnak utasításokat, mivel kifejezések. Például egy értékadás sem lehet egy feltételes kifejezés része. Ennek az az előnye, hogy elkerülhető a klasszikus C programozási hiba, hogy összehasonlítás helyett véletlenül értékadást írnak. Ez C-ben értelmes dolog, habár többnyire tévedés, míg Pythonban szintaktikai hiba. KivételkezelésA kivételkezelés a 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 Az Ha nincs megfelelő 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 NameError('Hello')
A Python egyik elve szerint a kivételeket keletkezésükhöz közel kell kezelni. Ez a megközelítés hasznos robusztus inputfeltételek megalkotásához: while True:
num = input("Eine ganze Zahl eingeben: ")
try:
num = int(num)
except ValueError:
print("Eine _Zahl_, bitte!")
else:
break
Ez a programszakasz egy egész számot kér a felhasználótól, egészen addig, amíg az egy olyan stringet ad meg, ami egész számmá konvertálható. A kivételkezeléssel egy futás idejű kivételt kerül el, és helyette a felhasználó által is érthető üzenetet ír ki. A kivételkezelés szálbiztos, és a kivételek könnyen továbbíthatók a program tetszőleges szintjére. A dinamikus erőforrásokhoz való hozzáférést is leegyszerűsítik, mivel így elkerülhetők a race conditionök, hogy esetleg az elavult információk alapján többen ugyanahhoz az erőforráshoz akarnak hozzáférni. A Python kiterjedten használja a kivételkezelést hibafeltételek kezelésére. Ez olyan mélyen be van ágyazva, hogy még a szintaktikai hibák is elkaphatók és kezelhetők. Elkapható és kezelhető ( MetódusokA metódusok osztályban definiált függvények. Az Osztályok, öröklődésA 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.[134] 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). A protected tagváltozót vagy tagfüggvényt egy aláhúzással, a private tagváltozót vagy tagfüggvényt két aláhúzással jelöljük. Ezeket ugyan a hívó fél nem érheti el hagyományos módon, de elérheti mangled name alapján: 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[134]), é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 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 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.: Azonban azt is megtehetjük, hogy egy adat attribútumot később deklarálunk, mely a 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 class 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:
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. Habár a beépített típusok nem feltétlenül osztályok, lehet belőlük örökölni. Így bővíthetők például a stringek, az egész számok vagy a szótárak tulajdonságai. A típusok kiolvashatók és összehasonlíthatók. Mivel minden objektum, azért a típusok is objektumok. Egy objektum attribútumai kivonatolhatók szótárba. Funkcionális programozásA Python bír néhány, a funkcionális programozáshoz kötődő eszközzel. Ezeket a képességeket egészítik ki a Coconut[135] és más kiegészítők a funkcionális programozás megkönnyítésére. A funkcionális programozás elemei leegyszerűsíti a listák és a többi adatszerkezetek feldolgozását. Az egyszerűsítés egy módja a lista jelölés, ami a Haskellből származik. A kettő első öt hatványa Pythonban funkcionális eszközökkel: zahlen = [1, 2, 3, 4, 5]
zweierpotenzen = [2 ** n for n in zahlen]
Mivel a Pythonban a függvények átadhatók paraméterként, azért használhatók olyan módszerek, mint a Continuation-Passing Style. Ezt mutatja a következő példa Haskell Brooks Curry ötlete alapján: def add_and_print_maker(x):
def temp(y):
print("{} + {} = {}".format(x, y, x + y))
return temp
Így egyszerűen megoldható a curryzés is, amivel az általános függvényobjektumok problémaspecifikusokra bonthatók. Egy egyszerűbb példa: def curry(func, known_argument):
return lambda unknown_argument: func(unknown_argument, known_argument)
Ha a Más mechanizmusokkal együtt elérhetők a lezártak, Egy egyszerű példa vermet valósít meg, belülről listával reprezentálva: def stack():
l = []
def pop():
if not is_empty():
return l.pop()
def push(element):
l.append(element)
def is_empty():
return len(l) == 0
return pop, push, is_empty
pop, push, is_empty = stack()
Így kaphatók a ProgrampéldákHello world program: print('Hello, world!')
Program pozitív egész faktoriálisának számítására: n = int(input('Írj be egy egész számot, és kiírom a faktoriálisát: '))
if n < 0:
raise ValueError('Nemnegatív egész számot kell megadni.')
factorial = 1
for i in range(2, n + 1):
factorial *= i
print(factorial)
(Ez az egyszerűsített példa nem kezeli azt a hibát, ha szöveget írnak be szám helyett, csak az algoritmust demonstrálja.) Szabványos könyvtárakA 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.[136] 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. A kiterjedt szabványos könyvtárat a nyelv egyik előnyeként tartják számon. Például az internet használatához elérhetőek szabványos formátumok és protokollok, mint MIME és HTTP. Tartalmaz modulokat felhasználói felületekhez, lehetőséget adatbázisokkal végzett munkához, támogatja álvéletlen számok generálását,[137] reguláris kifejezések használatát és egységtesztelést. A szabványos könyvtárak egy része különböző külső specifikációkat követ, például a Web Server Gateway Interface (WSGI) implementációja, a wsgiref a PEP 333 szabványt.[138] Másik részét dokumentáció, a saját kódja és tesztkörnyezete specifikálja. Azonban, mivel a szabványos könyvtár legnagyobb része keresztplatformos Python kód, csak néhány modult kell átírni vagy helyettesíteni különböző implementációk számára. 2022 november 14-én a Python Package Index (PyPI), a független Python szoftverek hivatalos tára több, mint 415 000 csomagot tartalmazott széles körű funkcionalitással, mint például:[139]
A legtöbb modul platformfüggetlen, így nagyobb Python-programok is futtathatók Unix, Windows, macOS és más operációs rendszereken változtatás nélkül. Grafikus felhasználói felületekA Pythonnal együtt települő Tkinter modul segítségével grafikus felhasználói felület hozható létre. További közreműködőktől számos wrapper áll rendelkezésre. Ezek kapcsolatokat biztosítanak további GUI eszközkészletekhez, mint PyGTK, PyQt, wxPython, PyObjC és PyFLTK. A Tkinter modul tartalmazza a teknőcgrafikát is. Példa a Tkinter modulhoz from tkinter import *
fenster = Tk()
fenster.geometry("200x100")
label = Label(fenster, text="Hallo Welt!")
label.pack()
def befehl():
fenster.destroy()
button = Button(fenster, text="OK", command=befehl)
button.pack()
fenster.mainloop()
Példa a teknőcgrafikához import turtle
from turtle import speed, reset, goto
reset()
speed(0)
turtle.x = -200
turtle.y = 200
while turtle.y != -200:
goto(turtle.x, turtle.y)
turtle.x = - turtle.x
turtle.y = - turtle.y
goto(turtle.x, turtle.y)
goto(0, 0)
turtle.y = - turtle.y
turtle.x = - turtle.x
turtle.y -= 5
CsomagkezelésA Python támogatja a csomagkezelést, ebben segítenek a distutils és a setuptools. A csomagok megtalálhatók a PyPI-n (Python Package Index), és onnan tölthetők le telepítéshez. A csomagkezelést pip vagy régebbi rendszereken easy_install végzi. Az Anaconda csomagverzióit a conda kezeli. Fejlesztési környezetekA legtöbb Python implementáció, köztük a Cython is tartalmaz egy olvasás-kiértékelés-írás ciklust (read–eval–print loop, REPL), ami lehetővé teszi, hogy parancssoros értelmezőként működjenek, melybe szekvenciálisan adhatók utasítások, és eredményük azonnal kiértékelődik. A Python integrált fejlesztési környezettel (IDE) érkezik, melynek neve IDLE. További héjak, mint az IDLE és az IPython további képességeket adnak hozzá, mint az automatikus kiegészítés javítása, a session állapot megőrzése és a szintaktikus színezés. A Python számára készültek továbbá az Eric Python IDE, Spyder és a PyCharm fejlesztőkörnyezetek is. A Vim, az Emacs és más szövegszerkesztők is beállíthatók Python használatára. Ahogy a szabványos desktop integrált fejlesztési környezetek, vannak webböngésző alapú IDE-k is, mint például a SageMath, tudományos és matematikaintenzív fejlesztésekhez; a Canopy IDE, kereskedelmi integrált fejlesztési környezet, szintén tudományos célokra; és a PythonAnywhere, böngészőben működő IDE és hosting környezet.[140] A különböző GUI-eszközkészletekhez is vannak szerkesztőeszközök, mint például ezek számára: Tkinter (GUI-Builder), WxPython (wxGlade), PyQt (Qt Designer), PySide, PyGTK (Glade), Kivy és PyFLTK, melyekkel viszonylag egyszerűen építhetők felhasználó felületek. Interaktív használatAhogy a Lisp, Ruby, Groovy és a Perl, úgy a Python értelmezője is használható interaktív módban. Ekkor a kifejezéseket közvetlenül az ablakba írjuk, ahol rögtön megjelenik az eredmény. Ez nemcsak a kezdőknek előny, hanem tapasztalt programozók is kipróbálhatják egy-egy kódszakasz viselkedését, mielőtt még beírják a programba. Az Unix-szerű operációs rendszerek alá rendelkezésre állnak héjak is, melyek képesek a szokásos héj utasítások mellett Python utasítások és kifejezések feldolgozására is. Az IPython egy népszerű interaktív Python-héj bővített funkcionalitással. ImplementációkA Python2 támogatása véget ért. A 2-es fő verzióból az utolsó a 2020 április 20-án megjelent 2.7.18.[141][142] Ezzel a Python2 támogatása megszűnt.[143][144] Az áttérést sokrétű és részletes dokumentáció támogatja.[145][146][147] Léteznek a migrációt segítő eszközök is.[148] Más leírások segítik, hogy Python2 és Python3 szerint is értelmezhető kód készüljön.[149][150][151][152][153] Referencia implementációA referencia implementáció a CPython, ami C-ben készült, a C89 alapján, melyet válogatott C99 képességekkel egészítettek ki. Ez a C verzió azóta elavult.[154][155] A 3.11-es verziótól C11-et használnak.[156] A CPython tartalmazza a saját C kiegészítéseit is, de a független fejlesztéseket ez nem kötelezi: használhatnak C11-et vagy C++-t is.[157][158] A CPython a szkripteket köztes bájtkódra fordítja,[159] melyet saját virtuális gépe hajt végre.[160] A szabványos könyvtár egy része C-ben, másik része natív Pythonban íródott, és sok platformra elérhető, mint Windowsra és modern Unix-szerű operációs rendszerekre is, mint például macOS. Nem hivatalosan elérhető VMS-re is.[161] A hordozhatóság az egyik legfontosabb követelmény volt.[162] A Python 1 és 2 elérhető volt OS/2 és Solaris rendszerekre, de később ezt megszüntették.[163] A Windows XP-n az utolsó támogatott verzió a 3.4 volt. A Windows 7 és 8 támogatása a Python 3.9-cel szűnt meg.[164][165] További implementációk
Nem támogatott implementációkTovábbi just-in-time Python fordítók, melyek támogatását abbahagyták:
Keresztfordítók más nyelvekreTöbb fordító is van, melyek Python kódot, korlátozott Python kódot vagy egy Pythonhoz hasonló nyelvet fordítanak egy másik magas szintű programozási nyelvre:
|
