Python (programozási nyelv)

Python
Paradigma	többelvű, objektumorientált, procedurális (imperatív), funkcionális, strukturált, reflektív
Jellemző kiterjesztés	.py, .pyi, .pyc, .pyd, .pyw, .pyz (3.5-től), pyo (3.5 előtt)
Megjelent	1991. február 20.
Tervező	Guido van Rossum
Fejlesztő	Python Software Foundation
Utolsó kiadás	3.13.1 (stabil verzió, 2024. december 3.)
Típusosság	erős, dinamikus, kacsa (hagyományosan); graduális (3.5 verziótól, de a CPythonban nincs implementálva)
Fordítóprogram	CPython, Jython, IronPython, PyPy
Dialektusok	Cython, RPython, Starlark
Megvalósítások	CPython, IronPython, Jython, Python for S60, PyPy, Stackless Python, MicroPython, CircuitPython
Hatással volt rá	ABC, Ada, ALGOL 68, APL, C,C++, CLU, Dylan, Haskell, Icon, Lisp, Modula-3, Perl, Standard ML
Befolyásolt nyelvek	Apache Groovy, Boo, Cobra, CoffeeScript, D, F#, Genie, Go, JavaScript, Julia, Nim, Ring, Ruby, Swift
Operációs rendszer	Windows, macOS, Linux/UNIX, Android és mások
Licenc	Python Software Foundation License
[http://python.org Weboldal]

A Python (angolos kiejtéssel [ˈpʰaɪθn̩], [ˈpʰaɪθɑn]) 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. Például a behúzások szintaktikailag is fontosak.

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.

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. 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énete

A 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. 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. 1991 februárjában jelent meg az első nyilvános változat (0.9.0 verzió néven) az alt.sources hírcsoportban. 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. 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. Már a Python 1-es verziója bírt bizonyos funkcionális képességekkel, melyeket azonban később kivezettek belőle. 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. A Python 2 utolsó hivatalos verziója a 2.7.18, ami 2020-ban jelent meg. 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. 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 2to3 képességet, amivel automatizálni lehet az áttérést. Eredetileg a Python 2.7 támogatását 2015-ben akarták befejezni, ám ezt elhalasztották 2020-ig, a már létező Python kódok sokasága miatt, és azért, mert az új verzió nem kompatibilis vele, így portolásra van szükség. Amellett, hogy nem adnak ki újabb javításokat, még biztonsági frissítések sem jelennek meg a 2.7 számára. Ezzel a legkorábbi támogatott verzió a 3.6 lett.

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, mivel az összes Python verzióval biztonsági problémák adódtak, beleértve a 2.7-et is. Ez lehetővé tette a távoli kódvégrehajtást és a cache-mérgezést.

2022-ben a 2022, Python 3.10.4 és 3.9.12 kiadását hozták előre, é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. 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. 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.

Az elavult smtpd modult el fogják távolítani a 3.12-es verzióból. További régi, elavult, már nem működő osztályokat és metódusokat is eltávolítanak, például a unittest modulból. Eltávolították a wstr és a wstr_ modulokat is, az UTF-8 alapértelmezetté tétele miatt.

Tervezési filozófia és képességek

Guido van Rossum, a Python tervezője, az OSCON konferencián 2006-ban

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 és metaobjektumokkal is. Kiegészítőkkel elérhetők további paradigmák, mint a szerződés alapú tervezés vagy a logikai programozás. 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. A szemétszedés referenciaszámláláson és ciklusfelderítésen alapul. 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 filter, map, reduce függvények, a list comprehension, szótárak, halmazok és generátor kifejezések. A standard könyvtár tartalmaz a Haskell nyelvtől és a Standard ML-től átvett funkcionális eszközöket (itertools és functools).

Magfilozófiáját a The Zen of Python (PEP 20) összegzi. A legfontosabb aforizmák:

• A szép jobb, mint a csúnya.
• Az explicit szebb, mint az implicit.
• Az egyszerű szebb, mint a bonyolult.
• A bonyolult jobb, mint a komplikált.
• Az olvashatóság számít.

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. 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. 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, 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. 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. Alex Martelli, a Python Foundation tagja és Python könyvszerző szerint Python kultúrában valamit okosnak nevezni nem számít bóknak.

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. 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, é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.

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. 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. és a Boa eszközkészlet elnevezésében.

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. A Python programozókat, különösen a tapasztalt szakértőket pedig Pythonistasnak nevezik.

Szintaxis és szemantika

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

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. Így a szkriptek szintaktikai szerkezetét a látható struktúra is reprezentálja. 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. A behúzás e célú használata Peter J. Landintól származik.

Egyszerű adattípusok

A Python 3 standard típushierarchiája

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.

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 SpamClass() vagy EggsClass(). Minden objektum. Objektumok a modulok, az osztályok, típusok és metódusok is. Az osztályok a metaclass típus példányai, ami a saját példánya. Ez lehetővé teszi a reflexiót és a metaprogramozást.

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.

A hosszú távú tervek között szerepel a graduális típusozás támogatása. A Python szintaxisa lehetővé teszi statikus típusok használatát, azonban ezeket nem ellenőrzi az alapértelmezett CPython implementáció.

A Python 3 beépített típusai

Típus	Mutabilitás	Leírás	Példák
bool	immutable	Kétértékű logikai adattípus	True False
bytearray	mutable	Bájtok sorozata.	bytearray(b'Some ASCII') bytearray(b"Some ASCII") bytearray([119, 105, 107, 105])
bytes	immutable	Bájtok sorozata.	b'Some ASCII' b"Some ASCII" bytes([119, 105, 107, 105])
complex	immutable	komplex szám adattípus valós és képzetes résszel.	3+2.7j 3 + 2.7j
dict	mutable	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} {}
types.EllipsisType	immutable	Ellipszis helyőrző, NumPy tömbök számára	... Ellipsis
float	immutable	Lebegőpontos szám, melynek pontossága az implementáló rendszertől függ, de többnyire a 64-bit esIEEE 754 szám 53 bites pontossággal.	1.33333
frozenset	immutable	Rendezetlen halmaz adattípus. Duplikátumokat nem tartalmazhat. Nem tipizált, azaz eltérő típusú elemeket is tartalmazhat, ha azok hasíthatóak.	frozenset([4.0, 'string', True])
int	immutable	Tetszőleges méretű egész szám adattípus.	42
list	mutable	List típus, ami eltérő típusokat is tartalmazhat, azaz nem tipizált lista.	[4.0, 'string', True] []
types.NoneType	immutable	Érték hiányát jelző objektumtípus, más nyelvekben gyakran null a megfelelője	None
types.NotImplementedType	immutable	Helyőrző, melyet túlterhelt operátorok adhatnak vissza nem támogatott operandustípusok jelzésére.	NotImplemented
range	immutable	Számok szekvenciája, melyet többnyire for ciklusok szervezésére használnak.	range(-1, 10) range(10, -5, -2)
set	mutable	Rendezetlen halmaz adattípus. Duplikátumokat nem tartalmazhat. Nem tipizált, azaz eltérő típusú elemeket is tartalmazhat, ha azok hasíthatóak.	{4.0, 'string', True} set()
str	immutable	Unicode string: Unicode kódpontok sorozata	'Wikipedia' "Wikipedia" """Többsoros string""" Többsoros string
tuple	immutable	Rendezett n-es.	(4.0, 'string', True) ('single element',) ()

Aritmetika

A Python nyelvben az aritmetikai műveletek: (+, -, *, /) mellett megkülönbözteti az // egészosztást és a % modulo operátort, ahol a maradék lehet negatív. A hatványozás jele a **, például 5**3 == 125 és 9**0.5 == 3.0. A @ a mátrixszorzás jele. A Mindezek az operátorok a matematikában megszokott módon működnek: a preferencia szabályok érvényesülnek, az operátorok infixek. Van unáris + és – operátor is, előjelek számára. A kacsa típusozás lehetővé teszi, hogy implicit konverzióval lehessen például összeszorozni egy egész és egy komplex számot explicit konverzió nélkül.

Az osztás viselkedését a 3.0 verziótól kezdve változtatták meg. Python terminológiával a / jeles osztás true division, míg a // jeles floor division. A korábbi verziókban a / jeles osztást classic divisionnek nevezték. Így 7//3 == 2, -7//3 == -3, 7.5//3 == 2.0 és -7.5//3 == -3.0. A Python 2.7 számára is elérhető ez a viselkedés: from __future__ import division kapcsolja be.

Mindig az alsó egészrészt venni következetességet jelent. Így mindig teljesül, hogy (a + b)//b == a//b + 1; és b*(a//b) + a%b == a, függetlenül a előjelétől. Azonban ez azt is jelenti, hogy a%b eredménye a [0, b) intervallumba esik, ha b pozitív, de a (b, 0] intervallumba, ha b negatív.

Lebegőpontos számokat a round kerekít a legközelebbi egészhez; a kapott érték azonban lebegőpontos ábrázolású marad. Kétség esetén párosra kerekít: round(1.5) és round(2.5) értéke is 2.0. A 3.0 előtti verziók az iskolai matematikából ismert módszert használták, amiben a pontosan a középre eső érték már nagynak számított: round(0.5) is 1.0 volt, és round(-0.5) eredménye −1.0 volt.

Az összehasonlítások kiértékelése is illeszkedik a matematikában szokásoshoz: a < b < c azt jelenti, hogy először elvégzi az a < b összehasonlítást, majd a b < c összehasonlítást, és az egész összehasonlítást az és művelettel kapja meg. C típusú nyelvekben az első összehasonlítás eredménye 0 vagy 1, és ezt hasonlítja össze c-vel.

Az egészaritmetika tetszőleges pontosságú. A decimal modul decimális lebegőpontos számokat biztosít, meghatározható pontossággal és különböző kerekítési módokkal. A fractions modul tetszőleges pontossággal kezel tört alakú racionális számokat.

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.

Utasítások és vezérlő szerkezetek

A Python utasítások közé tartoznak:

• az értékadás, egy = jellel
• az if utasítás, ami feltételesen végrehajtandó blokkot jelent. Kiegészülhet else és elif ágakkal, melyekből az else az utolsó.
• a for utasítás, ami egy iterálható objektumon halad át. Az iterálható objektum egyes elemei a ciklusmagban elérhetők egy változón keresztül.
• a while utasítás, ami addig hajtja végre a ciklusmagot, amíg a feltétele igaz
• a for és a while utasításokat else ág egészítheti ki, ami akkor hajtódik végre, ha a ciklus rendben lefutott, és nem break, return vagy kivétel szakította meg.
• a try utasítás, ami lehetővé teszi, hogy a blokkban keletkező kivételt elfogjanak egy except utasítás blokkjában, vagy a 3.11-es verziótól kezdve az except* blokkban, mellyel kivételcsoportok kaphatók el. Azt is biztosítja, hogy lefusson egy finally kód is, azzal a céllal, hogy rendet rakjon, értve ez alatt az erőforrások elengedését.
• a raise utasítás, amivel kivételek dobhatók, vagy elkapás után újradobhatók.
• a break utasítás, amivel ki lehet lépni egy ciklusból
• a continue utasítás, ami abbahagy az aktuális iterációt, és újat kezd
• a pass utasítás, ami nem jelent semmit. Arra való, hogy üres blokkokat jelezzen.
• a class utasítás, amivel osztály definiálható
• a def utasítás, amivel függvény vagy metódus definiálható
• a with utasítás, amivel környezetmenedzser blokkot definiál, az erőforrások egyszerűbb megszerzéséhez és felszabadításához. Technikailag ez magában foglalja a szükséges zár megszerzését és elengedését, vagy egy fájl megnyitását és bezárását a szokásos try/finally idióma helyett
• a del utasítás, amivel változók törölhetők
• a yield utasítás, mellyel generátorfüggvények több értéket is visszaadhatnak. Korutinok létrehozására használhatók.
• a return utasítás, amivel függvény visszatérési értéke adható meg
• az assert utasítás, amivel feltételek teljesülése ellenőrizhető
• az import utasítás, amivel modulok importálhatók, ezzel hozzáférve azok tartalmához. A modulok meghatározhatják, hogy mely elemek importálhatók belőlük.
• a mintaillesztés formája match … case … if.

Az értékadás (=) összekapcsol egy referenciát egy külön, dinamikusan allokált objektummal. Bármikor bármely változó hozzákapcsolható bármely objektumhoz. A változónevek általános referenciatartók meghatározott referenciatípus nélkül – viszont az objektumok, melyekre hivatkoznak, típusosak. Ezt úgy nevezik, hogy a nyelv dinamikusan típusos, szemben a statikusan típusos nyelvekkel, ahol a változónevek csak bizonyos típusú változókra hivatkozhatnak.

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ések

Néhány Python kifejezés hasonlít C és Java kifejezésekhez, mások azonban különböznek:

• Az összeadás, kivonás és szorzás ugyanúgy viselkedik, viszont az osztás különbözik. Pythonban kétféle osztás van: a / jel lebegőpontos osztást, míg a // egészosztást jelent. A hatványozás jele **.
• A @ egy infix operátor, melyet a NumPy és más könyvtárak mátrixszorzásra használnak.
• A := rozmár operátor (walrus operator) a 3.8-as verziótól kezdve használható. Egy nagyobb kifejezés részeként ad értéket változóknak.
• Az == jel érték szerint hasonlít össze, szemben a Javával, ahol a primitív típusokat hasonlítja össze érték szerint, az objektumokat pedig referencia szerint. A referencia szerinti összehasonlításra az is operátor szolgál. Az összehasonlítások láncolhatók is, a <= b <= c.
• A Python logikai operátorok and, or, és not ahelyett, hogy a &&, ||, ! szimbólumokat használná, mint a C és a Java.
• Létezik a list comprehension típusú kifejezés, illetve az általánosabb generátor kifejezés.
• A névtelen függvények lambda kifejezésekkel írhatók le, azonban a törzs csak egyetlen kifejezésből állhat.
• A feltételes operátor formája x if c else y, ami különbözik a számos nyelvben elérhető c ? x : y formától.
• A Python különbséget tesz listák és tuple-k között. A listák írásmódja [1, 2, 3], változtathatók, így nem lehetnek szótárak kulcsai. A szótárak kulcsainak megváltoztathatatlansága a konzisztencia megőrzését segíti. A tuple-k írásmódja (1, 2, 3), nem változtathatók, és lehetnek kulcsok szótárban. A tuple-kon végzett műveletek nem a tuple-t változtatják meg, hanem új tuple-t hoznak létre, így a + operátor is új tuple-t hoz létre. Ha a t tuple eredetileg (1, 2, 3), akkor az t = t + (4, 5) értékadás úgy értékelődik ki, hogy először a t + (4, 5) számítás végződik el, melynek eredménye (1, 2, 3, 4, 5), és ez lesz értékül adva a t változónak. A tuple-t határoló zárójelek elhagyhatók, ha ez nem okoz félreértést.
• Definiálhatók range-ek. A definiálás módja: range(vég); range(kezdet, vég); vagy range(kezdet, vég, lépés). Valójában csak a vég paraméter kötelező. A kezdet alapértelmezetten nulla, a lépés egy.
• A listák, tuple-ök és range-ek szekvenciának számítanak. A szekvenciának vannak további típusai is.
• A szekvenciák és más adatszerkezetek kicsomagolása támogatott. Ami azt jelenti, hogy több változó kaphat értéket egy adatszerkezetből. Például fruits = ["apple", "banana", "cherry"]; x, y, z = fruits Valójában, változó helyett szerepelhet más is, aminek értéket lehet adni, az adatszerkezet pedig iterálható objektum.
• A % string formátum operátor a printf formázó operátorához hasonlóan működik. Objetumokat implicit konvertál stringgé. Például a "spam=%s eggs=%d" % ("blah", 2) kiértékelése "spam=blah eggs=2". A 2.6-os verziótól kezdve ezt a string format() metódusa egészíti ki. Például "spam={0} eggs={1}".format("blah", 2). A 3.6-os verziótól kezdve rendelkezésre állnak az "f-string"ek is: spam = "blah"; eggs = 2; f'spam={spam} eggs={eggs}'.
• A stringek összefűzését + jelöli, ez ugyanaz az operátor, amivel számokat adhatunk össze, például "spam" + "eggs" eredménye "spameggs". Ha a stringek számokat tartalmaznak, akkor nem történik konverzió, hanem stringszerűen adódnak össze, például "2" + "2" eredménye "22". A stringek létrehozásuk után nem módosíthatók; a műveletek új stringeket hoznak létre. A stringek ugyanúgy iterálhatók, mint a listák, tuple-ök, szótárak és range-ek.
• A nyelvben többféle string literál is van:

• Egy vagy dupla idézőjeles stringek: Több más nyelvtől, mint Unix héjak vagy a Perl eltérően ezek a stringek ugyanúgy működnek. Escape-elni a \ karakterrel lehet. A string interpoláció a 3.6-os verziótól kezdve érhető el, formázott string literálokként.
• Háromidézőjeles, többsoros stringek. Az idézőjelek lehetnek egyszeres vagy dupla idézőjelek, de nem keverhetők. A héjak, Perl vagy Ruby nyelvekben szokásos helyszíni dokumentumok szerepét tölthetik be.
• Nyers stringek, melyeket r prefix jelöl. Ezek a stringek nem értelmeződnek. Hasznosak olyankor, amikor gyakoriak a literális \ karakterek, mint Windows elérési útvonalak vagy reguláris kifejezések.

• A listák más nyelvek tömbjeihez hasonlóan szeletelhetők. Az egyes elemek hivatkozhatók, mint a[key], részlisták úgy, mint a[kezdet:vég] vagy a[kezdet:vég:lépés]. Az indexelés nullától kezdődik; a negatív indexek a végtől számítódnak visszafelé. Így az utolsó elem a -1-edik, az az előtti a -2-edik, és így tovább. A szeletelésben a résztömbök a kezdet indextől kezdve a vég indexig, de azt már bele nem véve számítódnak. A harmadik paraméter lehetővé teszi elemek átugrását vagy megfordítását. A szélső elemekre vonatkozó kezdet és vég paraméter elhagyható: a[:] az eredeti tömb másolatát adja.
• A halmazok (set) képesek akárhány elemet befogadni, de egy elemet csak egyszer tartalmazhatnak. Rendelkezésre állnak a matematikából ismert halmazműveletek, mint az unió, a metszet és a differencia. A halmazból is van nem módosítható, ez a frozenset.

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:

• for ciklusok és list comprehension-ök
• if blokkok és feltételes kifejezések
• az exec() és az eval() beépített függvények; az előbbi utasítások, az utóbbi kifejezések számára

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é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')

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ő (except KeyboardInterrupt: …) a megszakítás jel is (interrupt signal, SIGINT, Ctrl + C).

Metódusok

A metódusok osztályban definiált függvények. Az instance.method(argument) hívásmód szintaktikus cukor a Class.method(instance, argument) helyett. Pythonban az osztályokban a metódusokban kötelező a self paraméter, ami az osztálypéldányra hivatkozik. A self paraméter akkor is kötelező, ha a metódusnak nem kell hozzáférnie a példányhoz. A legtöbb objektumorientált nyelvben a this implicit adódik át (lásd C++, Java, Objective-C, Ruby). Az operátorok (aritmetikai, összehasonlítás, hossz, konverzió) felüldefiniálhatók meghatározott nevű metódusokkal.

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. 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: OsztalyNév_tag_név (protected) vagy OsztalyNév__tag_név (private) néven. A rendszer speciális jelentést tulajdonít azoknak a tagoknak, melyek neve nemcsak hogy két aláhúzással kezdődik, de azzal is végződik. Ha valamit el akarunk rejteni a külvilág elől, akkor tegyük egy függvény belsejébe, vagy egy modulba, mivel egy modul eldöntheti, hogy mit exportál.

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), é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 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:

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

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ás

A 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 é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 curry-függvényt hívjuk, akkor az két kötelező paramétert vár, és a függvény második paraméterének helyettesítése. A curry egy függvényt ad vissza, ami csak egy paramétert vár, de ugyanazt csinálja, mint a func, de csak egy paramétert vár.

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 pop, push, is_empty függvényobjektumokkal módosítható és vizsgálható a verem, ahelyett, hogy közvetlenül hozzá kellene férni az l objektumhoz.

Programpéldák

Hello 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á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. 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, 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. 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:

• automatizálás
• adatelemzés
• adatbázisok
• dokumentáció
• grafikus felhasználói felületek
• képfeldolgozás
• gépi tanulás
• mobilalkalmazások
• multimédia
• hálózatkezelés
• tudományos számítások
• rendszeradminisztráció
• teszt környezetek
• szövegfeldolgozás
• web keretrendszerek
• internetes adatbányászat

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ületek

A 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

Egyszerű Tkinter ablak

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

Csokornyakkendő alakú ábra sűrű vonalkázásból

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és

A 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örnyezetek

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

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álat

Ahogy 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ók

A 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. Ezzel a Python2 támogatása megszűnt. Az áttérést sokrétű és részletes dokumentáció támogatja. Léteznek a migrációt segítő eszközök is. Más leírások segítik, hogy Python2 és Python3 szerint is értelmezhető kód készüljön.

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. A 3.11-es verziótól C11-et használnak. 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. A CPython a szkripteket köztes bájtkódra fordítja, melyet saját virtuális gépe hajt végre. 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. A hordozhatóság az egyik legfontosabb követelmény volt.

A Python 1 és 2 elérhető volt OS/2 és Solaris rendszerekre, de később ezt megszüntették. 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.

További implementációk

• A PyPy gyors, szabványos implementáció a 2.7 és 3.8 verziók számára. Just-in-time compiler, ami gyakran szignifikáns sebességbeli javulást hoz a CPythonnal szemben, de bizonyos C-ben írt könyvtárak nem használhatók vele. Az EU támogatásával készült a Parrot számára.
• A Stackless Python a CPython forkja, ami microthreadeket használ. Nem használ hívási vermet, hanem ugyanezt a programok masszív konkurrenssé tételével oldja meg. A PyPynak is van hívási verem nélküli verziója.
• A MicroPython és CircuitPython mikrovezérlők számára implementálja a Pythont. Felhasználói közé tartozik a Lego Mindstorms EV3.
• A Pyston a Python futás idejű környezetének variánsa, ami just-in-time fordítást használ a Python programok felgyorsításához.
• A Cinder a CPython 3.8 performanciaorientált forkja, ami számos optimalizációt használ, köztük a bájtkód inline cache-elést, a korutinok mohó kiértékelését, és egy kísérleti bájtkód fordítót.

Nem támogatott implementációk

További just-in-time Python fordítók, melyek támogatását abbahagyták:

• A Google 2009-ben elkezdett egy projektet Unladen Swallow néven, ami az LLVM segítségével ötszörösére próbálta gyorsítani a Python-értelmezőt, és szálkezelési képességeit annyira javítani, hogy kihasználhasson akár ezer magot is, amikor a többi implementáció globális interpreter lockot szenved.
• A Psyco egy azóta félbehagyott just-in-time specializáló fordító, ami integrálható CPythonnal és futás közben a bájtkódot gépi kódra fordítja. A kibocsátott kódot optimalizálja bizonyos adattípusokra, így gyorsabb lehet, mint a szabványos Python kód. Nem támogatja a 2.7-es vagy a későbbi verziókat.
• A PyS60 a Nokia által 2005-ben kiadott Series 60 mobiltelefonokra készült Python 2 értelmező volt. Sok modult implementált a szabványos könyvtárból, és tartalmazott további modulokat a Symbian operációs rendszerhez való integrációhoz. A Nokia N900 a GTK felhasználói felületet is támogatja, így a programok megírhatók és futtathatók a célkészüléken.

Keresztfordítók más nyelvekre

Tö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:

• Brython, Transcrypt és Pyjs (utolsó kiadás 2012) JavaScriptre fordít
• Cython, ami a Python 2.7 egy bővítését képes C-re fordítani. Az eredmény kód használható Python 3-mal és más nyelvekkel, például C++-szal.
• Nuitka, C-re fordít
• Numba, az LLVM használatával gépi kódra fordít
• Pythran, a Python 3 egy részét C++-ra (C++11).
• RPython, képes C-re fordítani. Ezt használják a PyPy értelmező fordításához.
• Python → 11l → C++ transpiler, a Python 3 egy részét C++-ra fordítja (C++17).

Speciális:

• MyHDL, Python alapú hardverleíró nyelv (hardware description language, HDL), ami MyHDL kódot fordít Verilog vagy VHDL kódra.

Régebbi projektek, vagy Python 3-mal nem használható projektek:

• Google Grumpy, utolsó kiadás 2017-ben. Python 2-t fordít Gora.
• IronPython lehetővé teszi Python 2.7 programok futását. Egy alfa kiadás is megjelent 2021-ben, ami Python 3.4-et fordított, és további fejlesztéseket ígértek. Elérhető a .NET Common Language Runtime-ban.
• Jython, 2.7-et fordít Java bájtkódra. Lehetővé teszi Java könyvtárak használatát Python programokban.
• Pyrex (utolsó kiadás 2010) és Shed Skin (utolsó kiadás 2013) C-re és C++-ra fordítottak.

Performancia

A különböző Python implementációk performanciáját nem numerikus, hanem kombinatorikus munkamennyiséggel az EuroSciPy '13 mutatta be. A Python performanciájának összehasonlítását más nyelvekkel a The Computer Language Benchmarks Game is végzi.

Fejlesztése

A Python fejlesztését a Python Enhancement Proposal (PEP) határozza meg, az elsődleges mechanizmus, ami tartalmazza a nagyobb fejlesztések javaslatát, a közösség véleményének begyűjtését, és a Python tervezési döntéseinek dokumentációját. A Python kódolási stílust a PEP 8 írja le. A Python kódolási stílust a PEP 8 tartalmazza. A külsős PEP javaslatokat a Python közösség és a vezető tanács véleményezi és kommentálja.

A nyelv fejlesztése megfelel a CPython referencia implementációnak. A python-dev levelezőlista a nyelv fejlesztésének elsődleges fóruma. A specifikus kérdéseket eredetileg az alapítvány által fenntartott Roundupban vitatták meg. 2022-ben a megbeszéléseket és a hibabejelentéseket átköltöztették a GitHubra. A fejlesztést eredetileg saját fenntartású Mercurial repositoryban tartották, de 2017 januárjában a GitHubra költöztették.

A CPython nyilvános kiadása háromféle lehet. A verziószámot ennek megfelelően növelik:

• Visszafelé nem kompatibilis fejlesztések. Az addig már létező kódokat portolni kell. Ekkora változtatások eddig nem történtek túl gyakran: a 2.0 megjelenését 8 évvel követte a 3.0-ás verzió. A 4.0-ás verzió 2021 májusában nem volt tervben, és Guido van Rossum szerint nem biztos, hogy lesz ilyen.
• Nagyobb kiadások, melyek visszafelé kompatibilisek, de bővítik a nyelv képességeit. A verziószám középső részét növelik. A Python 3.9-től kezdve évenként egy várható. Minden ilyen nagyobb verzió még évekig támogatott, kisebb hibajavításokat adnak ki hozzá.
• Bugfixek, hibajavítások várhatóan három havonta érkeznek. Ezek nem adnak új képességeket, csak hibákat javítanak, biztonsági problémákat oldanak meg. A legkisebb verziószámot növelik.

A végső kiadások előtt sok alfa, béta kiadás és release-candidate is elérhető nyilvánosan, hogy a végső kiadás előtt még tesztelhessék őket. Habár minden kiadásnak van időzítése, ezt későbbre tolhatják, ha a kód megbukott a teszteken. A Python fejlesztői csapata nagy egységteszt készletekkel figyeli a kód állapotát.

A PyCon egy nagyobb akadémiai konferencia a Pythonról. Vannak speciális Python mentoráló programok, mint a Pyladies.

A Python 3.10 elavulttá tette a wstr típust, melyet majd a 3.12-ben el fognak távolítani. need to be modified by then), Ez több kiegészítőt is érinteni fog. Ugyanez a verzió vezette be a mintaillesztést a nyelvbe.

API dokumentáció generátorok

A Python API számára dokumentációt generáló eszközök közé tartozik többek között a pydoc (a szabványos könyvtár része), a Sphinx, a Pdoc és forkjai, a Doxygen és a Graphviz.

Elnevezése

Guido van Rossum a Monty Python színjátszócsoport nyomán nevezte el a nyelvet, akiknek játékát a Python fejlesztése közben élvezte. A Monthy Pythonra azóta is gyakran hivatkoznak a Python kultúrában és kódokban. Erre példa a metaszintaktikus változók elnevezése: a más programnyelvekben szokásos foo és bar helyett a ham és az eggs szavakat használják. A hivatalos Python dokumentáció is sok helyen hivatkozik a Monthy Pythonra.

A Pythonra utal a Py rövidítés is, ami a nyelv jellemző kiterjesztése is. A Pythonhoz készült a PyGame SDL API, melyet gyakran játékokhoz használnak. A PyQt és PyGTK API-k a Qt-hoz és a GTK-hoz. A PyPy pedig egy Python implementáció.

Népszerűsége

A TIOBE Programming Community Indexen 2003 óta az első tíz egyike, és október 21-én átvette a vezetést a C-től és a Javától. Az év programozási nyelve 2007-ben, 2010-ben, 2018-ban és 2020-ban, mivel az év legnagyobb szavazatnövekedést elért nyelve. Ez egyedül a Pythonnak sikerült.).

Egy tapasztalati tanulmány szerint a szkript nyelvek, mint a Python, hatékonyabbak a problémamegoldásban, mint a kompileres nyelvek; erősségük a string manipuláció, a mappákban való keresés, és memóriahasználatban jobb, mint a Java, és nem sokkal rosszabb, mint a C és a C++.

A Pythont használó nagy szervezetek közé tartozik a Wikipédia, Google,Yahoo!, CERN, NASA,Facebook, Amazon, Instagram, Spotify, és néhány kisebb, mint az ILM és az ITA. A Reddit nagy többségében Pythonban íródott.

Felhasználása

A Python felhasználása

A Python elő van telepítve a legtöbb Linux disztribúcióhoz, de a legtöbb más operációs rendszerhez is ingyen hozzáférhető. Még a Symbian mobil operációs rendszerhez is van. Az AmigaOS 4.0-tól az operációs rendszer része a Python.

A Python lehet webalkalmazások szkriptnyelve, például a mod_wsgi segítségével használható Apache webszerverhez. A Web Server Gateway Interface egy szabványos API, szintén erre a célra. A webes keretrendszerek, mint TurboGears, web2py, Django, Pylons, Pyramid, TurboGears, web2py, Tornado, Flask, Bottle, és Zope támogatja összetett alkalmazások fejlesztését. A Pyjs és az IronPython kliens oldali Ajax alkalmazásokhoz való. Az SQLAlchemy egy adatleképező relációs adatbázisokhoz. A Twisted számítógépek közötti kommunikáció programozását segíti. Ezt használja a Dropbox is. A tudományos célú felhasználást célozza a Jupyter projekt.

A tudományos célú programozás megkönnyítésére a NumPy, SciPy, és Matplotlib a legelterjedtebbek. A SciPy és az Anaconda több tudományos könyvtárat foglal össze, és tesz elérhetővé. Léteznek a Biopython és az Astropy specializált programkönyvtárak is. A SageMath egy komputeralgebrai rendszer Pythonban programozható notebook interfésszel. A matematika több területét is lefedi, mint az algebrát, a kombinatorikát, a numerikus matematikát, a számelméletet, és az analízist. Az OpenCV-nek van kapcsoló API-ja, ami gazdag készlettel támogatja a számítógépes látást és képfeldolgozást.

A Pythont gyakran használják a mesterséges intelligencia fejlesztésében, és gépi tanulási folyamatokban olyan könyvtárak segítségével, mint TensorFlow, Keras, Pytorch, és Scikit-learn. A természetes nyelvek feldolgozásához gyakori választás a Python, modularitása, egyszerű szintaxisa, és gazdag szövegfeldolgozó képessége miatt.

Az oktatásban gyakran bevetik, mivel egyrészt kezdőbarát, másrészt elég képességgel bír arra, hogy közvetítse a programozás elméleti alapjait, és akár teljes grafikus felületű alkalmazásokat írjanak vele, adatbázisokat kezeljenek, adatokat elemezzenek vele. Az ifjúság számára több könyv is íródott, amelyek a Pythonon keresztül vezetik be őket a programozásba.

Az iskolákban és az egyetemeken világszerte alkalmazzák informatikai képzésre. Így 6. osztálytól kezdve számos online tanulóplatform áll ingyen rendelkezésre; a többségük több nyelven. Például a kanadai Waterloo Egyetem által üzemeltetett Computer Science Circles elérhető németül is, a német szövetségi informatikai versenyek jóvoltából. A TigerJythont a Berni Pedagógiai Főiskola gondozza, és főként a svájci informatikaoktatásban használatos.

A 100-Dollar-Laptop projekt keretében a Python a felhasználói felületek szabványos nyelve. Mivel a program gyerekek iskolai képzését célozza, az így készült grafikus felület gombnyomásra megjeleníti az éppen futó forráskódot. Így a gyerekek lehetőséget ksapnak a mögöttes információs technika felfedezésére és tetszés szerint betekinteni a kulisszák mögé.

Eredetileg a Raspberry Pi (Python Interpreter)-t a ROM-ba integrált Python-értelmezővel szállították. A Python azóta is a Raspberry Pi egyik legfontosabb nyelve. Szabványos operációs rendszere, a Raspberry Pi OS kiterjedt Python-könyvtárral bír a hardver irányítására.

Játék céljára is használják, például a Pygame segítségével, amivel 2D játékok fejleszthetők. Például tartalmazza az EVE Online, World in Conflict és a Civilization IV.

A Pythont több szoftvertermékbe is beágyazták szkriptelési célra, mint végeselem módszer programkönyvtárakba, például Abaqusba; 3D paraméteres modellezőkbe, mint a FreeCAD; 3D animációs csomagokba, mint 3ds Max, Blender, Cinema 4D, Lightwave, Houdini, Maya, modo, MotionBuilder, Softimage; a Nuke vizuális effekt kompozitorba; 2D képszerkesztőkbe, mint GIMP, Inkscape, Scribus és Paint Shop Pro; kottaíró programokba, mint scorewriter és capella. A GNU Debugger a Pythont használja forrásszöveg formázásra, hogy megmutasson összetett szerkezeteket, mint C++ konténerek. Az Esri javasolja a Pythont, mint a legjobb választást szkriptek írására ArcGIS-ban. Több videójátékban is előfordul. A Google App Engine három programozási nyelv közül enged választást, az első a Python, a másik kettő a Java és a Go. Alkalmazza a Google és a Youtube is.

Sok operációs rendszerben a Python szabványos komponens. Alapértelmezetten tartalmazza a legtöbb Linux-disztribúció, az AmigaOS 4 (Python 2.7), FreeBSD, NetBSD, és OpenBSD (csomag), és terminálból használható. Sok Linux-disztribúció telepítője Pythonban íródott: az Ubuntu által használt Ubiquity telepítő, és a Red Hat Linux és a Fedora Linux Anaconda telepítője. A Gentoo Linux Pythont használ a Portage csomagkezelőjéhez.

Az információs biztonságban kiterjedten használható.

A Sugar Labs által fejlesztett One Laptop per Child XO nagy része Pythonban íródott. A Raspberry Pi fő felhasználói programozási nyelve.

A LibreOffice tartalmazza a Pythont, és tervezik a Java kivezetését. A benne levő Python Scripting Provider 2013 február 7-től, a 4.0 verziótól kezdve mag képesség.

Legnépszerűbb Python keretrendszerek

1. Django
2. Flask
3. Pyramid
4. Bottle
5. CherryPy
6. Tornado

Ismertebb Pythonra épülő alkalmazások

A LAMP tartalmazza a Pythont is

• 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
• A Blender 3D-s modellező-animációs program, ami ezért GE-ként is működik, Pythonból scriptelhető

Befolyásolt nyelvek

A Python terve és filozófiája hatással volt más nyelvekre.

• Boo: a behúzás szerepe, hasonló szintaxissal és objektummodellel.
• Cobra: hasonló szintaxis. Az Acknowledgements a befolyásoló nyelvek közül elsőként említi.
• A JavaScriptre forduló CoffeeScript szintaxisát a Python ihlette.
• ECMAScript/JavaScript: iterátorok és generátorok
• GDScript, egy Pythonhoz hasonló nyelv. Ez van beépítve a Godot játékmotorba.
• Go, melyet arra terveztek, hogy felgyorsítsák a fejlesztést dinamikus nyelveken, mint például Python. A tömbök is a Pythonhoz hasonlóan szeletelhetők.
• Groovy, a Python filozófiájának átültetésére Javába
• Julia, melyet olyan használhatóra terveztek általános programozáshoz, mint a Python.
• Nim, a behúzások használatában és szintaxisában
• Ruby. Tervezője, Matsumoto Yukihiro egy Perlnél többre képes, és a Pythonnál objektumorientáltabb nyelvet akart, ezért tervezte a Rubyt.
• Swift, szintaxisában.

A Python fejlesztésének módszereit is átvették más nyelvek. Például az, hogy a változtatásokhoz igényelnek egy dokumentumot a fejlesztés céljáról és a kapcsolódó problémákról, a Tcl, az Erlang és a Swift fejlesztéséhez is használjanak.

Kritikák

A metódusok definíciójánál az első paraméternek a példányt jelentő self-nek kell lennie. Andrew Kuchling, szerző és sokéves gyakorlattal bíró Python-programozó nem elegánsnak és nem objektumorientáltnak érzi. A nyelv tervezője, van Rossum szerint erre azért van szükség, mivel lehetővé tesz bizonyos fontos konstrukciókat. Továbbá megfelel az explicit jobb, mint az implicit alapelvnek is.

A 3.0 előtti verziókban explicit meg kellett adni a metódusdefiníciókban a szülőosztályt és a példányt, amikor a szülő osztály megfelelő metódusát hívták. Ezt a DRY-elv (ne ismételd önmagadat) megsértésének tekintették, és az átnevezéseket is akadályozta. A 3.0 verziótól kezdve erre nincs szükség.

A CPython Global Interpreter Lock (GIL)-ja lelassítja a futást multiprocesszoros környezetben. A Jython és az IronPython mentes ettől. Hivatalos oldalon nem tervezik, hogy alternatívát találjanak rá. Ehelyett azt javasolják, hogy ha sok szálra van szükség, akkor szálak helyett több egymással kommunikáló folyamatot használjanak (lásd multiprocessing modul).

Jelen implementációkban a Python futása lassabb, mint sok kompileres nyelvé, de hasonló a Perlhez, a PHP-hoz a Darthoz és a Rubyhoz. Ez részben azon múlik, hogy a Cython fejlesztésénél a kód érthetősége elsőbbséget élvez a sebességgel szemben. A közösség olyan szaktekintélyekre hivatkozik, mint Donald Knuth és Tony Hoare, akik eltanácsolnak a korai optimalizálástól. Ha a Python kód optimalizálás után még mindig nem elég gyors, akkor vagy JIT-fordítót kell használni, mint a PyPy, vagy pedig gépközelebbi nyelvekbe kiszervezni az időkritikus részeket, például C-be.

Források

• Python for Artificial Intelligence. Wiki.python.org, 2012. július 19. [2012. november 1-i dátummal az eredetiből archiválva]. (Hozzáférés: 2012. december 3.)
• (2005. augusztus 1.) „AI in Python”. AI Expert Newsletter, Kiadó: Amzi!. (Hozzáférés: 2012. február 11.) 
• PyAIML 0.8.5 : Python Package Index. Pypi.python.org. (Hozzáférés: 2013. július 17.)
• Artificial Intelligence: A Modern Approach, 3rd, Upper Saddle River, NJ: Prentice Hall (2009). ISBN 978-0-13-604259-4 
• Allen B. Downey. Programmieren lernen mit Python, 2., Köln (u. a.): O’Reilly, 297. o. (2014. december 17.) 
• Bernd Klein. [Inhaltsverzeichnis Einführung in Python 3. Für Ein- und Umsteiger], 2., bővített és átdolgozott, München: Hanser (2014) 
• Mark Lutz. [Inhaltsverzeichnis Learning Python], 5., O’Reilly (2013) 
• Hans Petter Langtangen: A Primer on Scientific Programming with Python. .4. Auflage. Springer, 2014, ISBN 978-3-642-54958-8
• Mark Pilgrim, Florian Wollenschein: Python 3 – Intensivkurs. 1. Auflage. Springer, 2010, ISBN 978-3-642-04376-5
  (Deutsche Übersetzung von Dive Into Python 3 google-books)
• Mark Pilgrim: Dive Into Python 3. 2. Auflage. Springer, 2009, ISBN 1-4302-2415-0 (Download verfügbar)
• John Paul Mueller. [bei der Deutschen Nationalbibliothek Python programmieren lernen für Dummies], 1., Weinheim: Wiley (2015) 
• szerk.: Martina Glöde: Programmieren supereasy. Einfacher Einstieg in Scratch und Python. München: Dorling Kindersley (2015) 
• Warren D. Sande; Carter Sande. Hello World! Programmieren für Kids und andere Anfänger, 2., aktualizált és bővített, München: Hanser (2014) 
• Michael Bonacina: Python 3 Programmieren für Einsteiger: Der leichte Weg zum Python-Experten, 2. Auflage. BMU Verlag, Landshut 2019, ISBN 978-3-96645-007-2.
• Michael Weigend. Python ge-packt, 6., Frechen: mitp (2015) 
• Johannes Ernesti; Peter Kaiser. Python 3. Das umfassende Handbuch, 5., aktualizált kiadás, Bonn: Rheinwerk (2017) 
• Mark Lutz. Python. Kurz & gut, 5., Köln et al.: O’Reilly (2014) 
• Luciano Ramalho. Fluent Python. Clear, concise, and effective programming [archivált változat], 1., Sebastopol CA u. a.: O’Reilly (2015). Hozzáférés ideje: 2022. december 18. [archiválás ideje: 2019. március 22.] 
• Gregor Lingl: Python für Kids. 4. Auflage. bhv, 2010, ISBN 3-8266-8673-X.
• Farid Hajji: Das Python-Praxisbuch. 1. Auflage. Addison-Wesley, 2008, ISBN 978-3-8273-2543-3.
• Hans P. Langtangen: Python Scripting for Computational Science. 3. Auflage. Springer, 2008, ISBN 3-540-43508-5.
• Michael Weigend: Objektorientierte Programmierung mit Python. mitp-Verlag, 1. Auflage 2006, ISBN 3-8266-0966-2.
• Felix Bittmann. [Inhaltsverzeichnis Praxishandbuch Python 3. Konzepte der Programmierung verstehen und anwenden], 1., Norderstedt: Books on Demand (2020) 

Fordítás

Ez a szócikk részben vagy egészben a Python (programming language) című angol Wikipédia-szócikk fordításán alapul. Az eredeti cikk szerkesztőit annak laptörténete sorolja fel. Ez a jelzés csupán a megfogalmazás eredetét és a szerzői jogokat jelzi, nem szolgál a cikkben szereplő információk forrásmegjelöléseként.

Ez a szócikk részben vagy egészben a Python (Programmiersprache) című német Wikipédia-szócikk fordításán alapul. Az eredeti cikk szerkesztőit annak laptörténete sorolja fel. Ez a jelzés csupán a megfogalmazás eredetét és a szerzői jogokat jelzi, nem szolgál a cikkben szereplő információk forrásmegjelöléseként.

További információk

A Wikimédia Commons tartalmaz Python (programozási nyelv) témájú médiaállományokat.

• Hivatalos weboldal
• Magyar Python honlap
• Magyar nyelvű könyvek
• A hivatalos oktató (tutorial) magyarul a Python 3.x verzióihoz és a (2.x) verzióihoz Archiválva 2020. február 17-i dátummal a Wayback Machine-ben (ez utóbbi nem frissült jó ideje)
• Legnépszerűbb Python keretrendszerek

Kapcsolódó szócikkek

• NumPy