Python (programozási nyelv)

általános célú, magas szintű programozási nyelv


A Python (angolos kiejtéssel [ˈpʰaɪθn̩], [ˈpʰaɪθɑn]) egy általános célú, nagyon magas szintű programozási nyelv,[34][35] melyet Guido van Rossum holland programozó kezdett el fejleszteni 1989 végén, majd hozott nyilvánosságra 1991-ben.[11] 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.[36][37][38] Például a behúzások szintaktikailag is fontosak.[39]

Python

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

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

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.[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 2to3 képességet, amivel automatizálni lehet az áttérést.[55] 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.[56][57] 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.[58][59] Ezzel a legkorábbi támogatott verzió a 3.6 lett.[60]

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 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,[70] az UTF-8 alapértelmezetté tétele miatt.

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

 
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[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 filter, map, reduce függvények, a list comprehension, szótárak, halmazok és generátor kifejezések.[79] 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).[80]

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

  • 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.[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 szemantika Szerkesztés

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.[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 Szerkesztés

 
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.[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 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.[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]

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.[107]
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.[108]
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.[109]
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 Szerkesztés

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[110] 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.[111] Í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.[112]

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.[113] 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.[114]

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.[115]

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.[116] A fractions modul tetszőleges pontossággal kezel tört alakú racionális számokat.[117]

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ő szerkezetek Szerkesztés

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.[120] 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[121]
  • 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 matchcaseif.

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

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.[122] A hatványozás jele **.
  • A @ egy infix operátor, melyet a NumPy és más könyvtárak mátrixszorzásra használnak.[123][124]
  • 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.[125]
  • 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.[126][127] A referencia szerinti összehasonlításra az is operátor szolgál.[128] 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.[79]
  • 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.[129]
  • 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.[130]
  • 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}'.[131]
  • 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.[131]
  • 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ó előtti 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 Szerkeszté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 Szerkesztés

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).[132] Az operátorok (aritmetikai, összehasonlítás, hossz, konverzió) felüldefiniálhatók meghatározott nevű metódusokkal.[133]

Osztályok, öröklődés Szerkeszté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.[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: 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[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 __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

def MyClass(object):
    i = 42
    def f(self):
        return 'hello world!'

x = MyClass()
x.counter = 1
while x.counter < 10:
    x.counter = x.counter * 2
print(x.counter)
del x.counter

Ez a kis példa 16-ot ír ki (nem a legegyszerűbb módon), és semmilyen nyoma nem marad az osztályban, hiszen a del utasítással töröltük a létrehozott counter nevű változót.

Ügyeljünk rá, hogy x.f nem ugyanaz, mint MyClass.f, mivel az első az hivatkozás az adott objektum egy tagfüggvényére (metódus típusú objektumra való hivatkozás), amely hivatkozás futás közben megváltozhat (tehát például más metódusra mutat), míg a MyClass.f a f függvény prototípusa, ezáltal függvény típusú objektumra való hivatkozás! x.f egy metódus objektum, nem függvényobjektum. x.f() – ki fogja írni: hello world. Ugyanis az objektum, mint első argumentum átadódik a függvénynek, azaz x.f() ekvivalens MyClass.f(x) -szel.

További megjegyzések:

  • az adat attribútumok felülírják az ugyanolyan nevű metódus attribútumot! Ezért célszerű valamilyen névkonvencióval kizárni az ilyen lehetőséget.
  • nincs lehetőség az adatelrejtésre – az adat attribútumokat éppúgy elérik a metódusok, mint az objektum kliensei.
  • az előbbi lehetővé teszi, hogy kliensek elrontsák az invariánst, ha meglévő adat attribútumot írnak felül. Ezt a programozónak kell megoldania, mivel a nyelv nem nyújt rá lehetőséget.
  • ha létezik egy __init__() metódusa az osztálynak, akkor példányosításkor az objektum létrehozása után meghívódik, átadva a példányosításkor esetleg megadott paramétereket:
class Alma(object):
    def __init__(self, szin, iz):
        self.szin = szin
        self.iz = iz
 
x = Alma("piros", "savanyu")

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

class DerivedClassName([modulename.]Base1[,[[modulename.]Base2,]):
    <statement-1>
    ...
    <statement-N>

Ha egy hivatkozást nem talál az aktuális osztályban, akkor Base1-ben keresi, ha Base1-ben sincs, akkor Base1 őseiben. Ezután ha még mindig nem találta, akkor Base2-ben kezdi el keresni, és így tovább. Rekord vagy struct-szerű objektumok létrehozására is van lehetőség, a már ismertetettek szerint, például egy üres osztály deklarálásával, majd az üres osztály egy példányát feltölthetjük:

 class Dolgozo:
    pass        # ez egy üres osztálydefiníció
 
 John = Dolgozo()
 John.nev = 'John Cosinus'
 John.osztaly = 'Matematikai reszleg'
 John.fizetes = 42000

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

dolgozok = list()

John = {'nev': 'John Cosinus',
      'osztaly': 'Matematikai részleg',
      'fizetes': 42000}
dolgozok.append(John)

Jason = dict()
Jason['nev'] = 'Jason Cosinus'
Jason['osztaly'] = 'Matematikai reszleg'
Jason['fizetes'] = 42000
dolgozok.append(Jason)

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

Szabványos könyvtárak Szerkesztés

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.[135] 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,[136] 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.[137] 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:[138]

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

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

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

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

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.[139]

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

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

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.[140][141] Ezzel a Python2 támogatása megszűnt.[142][143] Az áttérést sokrétű és részletes dokumentáció támogatja.[144][145][146] Léteznek a migrációt segítő eszközök is.[147] Más leírások segítik, hogy Python2 és Python3 szerint is értelmezhető kód készüljön.[148][149][150][151][152]

Referencia implementáció Szerkesztés

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

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

További implementációk Szerkesztés

  • A PyPy gyors, szabványos implementáció a 2.7 és 3.8 verziók számára.[165][166] 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.[167] 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.[168]
  • A MicroPython és CircuitPython mikrovezérlők számára implementálja a Pythont. Felhasználói közé tartozik a Lego Mindstorms EV3.[169][170]
  • 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.[171][172]
  • 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.[173]

Nem támogatott implementációk Szerkesztés

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,

[174] 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.[175]

Keresztfordítók más nyelvekre Szerkesztés

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:

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.[184][185][186]
  • 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.[187] Elérhető a .NET Common Language Runtime-ban.[188]
  • Jython, 2.7-et fordít Java bájtkódra. Lehetővé teszi Java könyvtárak használatát Python programokban.[189]
  • Pyrex (utolsó kiadás 2010) és Shed Skin (utolsó kiadás 2013) C-re és C++-ra fordítottak.

Performancia Szerkesztés

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

Fejlesztése Szerkesztés

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.[192] A Python kódolási stílust a PEP 8 írja le.[193] 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.[192]

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. [194] 2022-ben a megbeszéléseket és a hibabejelentéseket átköltöztették a GitHubra.[195] A fejlesztést eredetileg saját fenntartású Mercurial repositoryban tartották, de 2017 januárjában a GitHubra költöztették.[196]

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.[197]
  • 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ó.[198][199] Minden ilyen nagyobb verzió még évekig támogatott, kisebb hibajavításokat adnak ki hozzá.[200]
  • 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.

[201]

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.[202]

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.[203] need to be modified by then),[204] Ez több kiegészítőt is érinteni fog. Ugyanez a verzió vezette be a mintaillesztést a nyelvbe.[205]

API dokumentáció generátorok Szerkesztés

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.[206]

Elnevezése Szerkesztés

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.[207] 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.[207][208] A hivatalos Python dokumentáció is sok helyen hivatkozik a Monthy Pythonra.[209][210]

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

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.[211] 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.[212]).[213]

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++.[214]

A Pythont használó nagy szervezetek közé tartozik a Wikipédia, Google, [215]Yahoo!,[216] CERN,[217] NASA,[218]Facebook,[219] Amazon, Instagram,[220] Spotify,[221] és néhány kisebb, mint az ILM[222] és az ITA.[223] A Reddit nagy többségében Pythonban íródott.[224]

Felhasználása Szerkesztés

 
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.[225] 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.[226]

A tudományos célú programozás megkönnyítésére a NumPy, SciPy, és Matplotlib a legelterjedtebbek.[227][228] 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.[229] 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.[230]

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.[231][232][233][234] 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.[235]

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.[236][237][238][239][240][241] 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.[242]

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.[243] A TigerJythont a Berni Pedagógiai Főiskola gondozza, és főként a svájci informatikaoktatásban használatos.[244]

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.[245] Í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.[246] 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,[247] Inkscape, Scribus és Paint Shop Pro;[248] 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.[249] 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.[250] Alkalmazza a Google és a Youtube is.[251]

Sok operációs rendszerben a Python szabványos komponens. Alapértelmezetten tartalmazza a legtöbb Linux-disztribúció,[252] 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ó.[253][254]

A Sugar Labs által fejlesztett One Laptop per Child XO nagy része Pythonban íródott.[255] 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.[256]

Legnépszerűbb Python keretrendszerek Szerkesztés

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

Ismertebb Pythonra épülő alkalmazások Szerkesztés

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

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

  • Boo: a behúzás szerepe, hasonló szintaxissal és objektummodellel.[257]
  • Cobra: hasonló szintaxis. Az Acknowledgements a befolyásoló nyelvek közül elsőként említi.[258]
  • A JavaScriptre forduló CoffeeScript szintaxisát a Python ihlette.
  • ECMAScript/JavaScript: iterátorok és generátorok[259]
  • GDScript, egy Pythonhoz hasonló nyelv. Ez van beépítve a Godot játékmotorba.[260]
  • Go, melyet arra terveztek, hogy felgyorsítsák a fejlesztést dinamikus nyelveken, mint például Python.[261] A tömbök is a Pythonhoz hasonlóan szeletelhetők.
  • Groovy, a Python filozófiájának átültetésére Javába[262]
  • Julia, melyet olyan használhatóra terveztek általános programozáshoz, mint a Python.[27]
  • Nim, a behúzások használatában és szintaxisában[263]
  • 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.[264]
  • Swift, szintaxisában.[265]

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,[266] az Erlang[267] és a Swift fejlesztéséhez is használjanak.[268]

Kritikák Szerkesztés

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ó[269] nem elegánsnak és nem objektumorientáltnak érzi.[270] A nyelv tervezője, van Rossum szerint erre azért van szükség, mivel lehetővé tesz bizonyos fontos konstrukciókat.[271] 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.[272]

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).[273][274]

Jelen implementációkban a Python futása lassabb, mint sok kompileres nyelvé,[275] de hasonló a Perlhez,[276] a PHP-hoz[277] a Darthoz[278] és a Rubyhoz.[279] 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.[280] 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,[281] 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.

Jegyzetek Szerkesztés

  1. General Python FAQ — Python 3.9.2 documentation. docs.python.org . [2012. október 24-i dátummal az eredetiből archiválva]. (Hozzáférés: 2021. március 28.)
  2. Holth, Moore: PEP 0441 – Improving Python ZIP Application Support, 2014. március 30. [2018. december 26-i dátummal az eredetiből archiválva]. (Hozzáférés: 2015. november 12.)
  3. File extension .pyo was removed in Python 3.5. See PEP 0488 Archiválva 2020. június 1-ji dátummal a Wayback Machine-ben.
  4. Python 0.9.1 part 01/21. alt.sources archives. [2021. augusztus 11-i dátummal az eredetiből archiválva]. (Hozzáférés: 2021. augusztus 11.)
  5. Python | endoflife.date (angol nyelven), 2023. augusztus 10. (Hozzáférés: 2023. augusztus 16.)
  6. Łukasz Langa: Python Insider: Python 3.11.5, 3.10.13, 3.9.18, and 3.8.18 is now available, 2023. augusztus 24. (Hozzáférés: 2023. augusztus 25.)
  7. Python 3.12.0 release candidate 3 now available (angol nyelven), 2023. szeptember 19. (Hozzáférés: 2023. szeptember 19.)
  8. Why is Python a dynamic language and also a strongly typed language – Python Wiki. wiki.python.org . [2021. március 14-i dátummal az eredetiből archiválva]. (Hozzáférés: 2021. január 27.)
  9. PEP 483 – The Theory of Type Hints. Python.org . [2020. június 14-i dátummal az eredetiből archiválva]. (Hozzáférés: 2018. június 14.)
  10. Starlark Language. [2020. június 15-i dátummal az eredetiből archiválva]. (Hozzáférés: 2019. május 25.)
  11. a b Why was Python created in the first place?. General Python FAQ. Python Software Foundation. [2012. október 24-i dátummal az eredetiből archiválva]. (Hozzáférés: 2007. március 22.) „I had extensive experience with implementing an interpreted language in the ABC group at CWI, and from working with this group I had learned a lot about language design. This is the origin of many Python features, including the use of indentation for statement grouping and the inclusion of very high-level data types (although the details are all different in Python).”
  12. Ada 83 Reference Manual (raise statement). [2019. október 22-i dátummal az eredetiből archiválva]. (Hozzáférés: 2020. január 7.)
  13. a b Kuchling, Andrew M.: Interview with Guido van Rossum (July 1998). amk.ca, 2006. december 22. [2007. május 1-i dátummal az eredetiből archiválva]. (Hozzáférés: 2012. március 12.) „I'd spent a summer at DEC's Systems Research Center, which introduced me to Modula-2+; the Modula-3 final report was being written there at about the same time. What I learned there later showed up in Python's exception handling, modules, and the fact that methods explicitly contain 'self' in their parameter list. String slicing came from Algol-68 and Icon.”
  14. a b c itertools — Functions creating iterators for efficient looping — Python 3.7.1 documentation. docs.python.org . [2020. június 14-i dátummal az eredetiből archiválva]. (Hozzáférés: 2016. november 22.) „This module implements a number of iterator building blocks inspired by constructs from APL, Haskell, and SML.”
  15. van Rossum, Guido (1993). „An Introduction to Python for UNIX/C Programmers”. Proceedings of the NLUUG Najaarsconferentie (Dutch UNIX Users Group). „even though the design of C is far from ideal, its influence on Python is considerable.” 
  16. a b Classes. The Python Tutorial. Python Software Foundation. [2012. október 23-i dátummal az eredetiből archiválva]. (Hozzáférés: 2012. február 20.) „It is a mixture of the class mechanisms found in C++ and Modula-3”
  17. Lundh, Fredrik: Call By Object. effbot.org. [2019. november 23-i dátummal az eredetiből archiválva]. (Hozzáférés: 2017. november 21.) „replace "CLU" with "Python", "record" with "instance", and "procedure" with "function or method", and you get a pretty accurate description of Python's object model.”
  18. Simionato, Michele: The Python 2.3 Method Resolution Order. Python Software Foundation. [2020. augusztus 20-i dátummal az eredetiből archiválva]. (Hozzáférés: 2014. július 29.) „The C3 method itself has nothing to do with Python, since it was invented by people working on Dylan and it is described in a paper intended for lispers”
  19. Kuchling, A. M.: Functional Programming HOWTO. Python v2.7.2 documentation. Python Software Foundation. [2012. október 24-i dátummal az eredetiből archiválva]. (Hozzáférés: 2012. február 9.) „List comprehensions and generator expressions [...] are a concise notation for such operations, borrowed from the functional programming language Haskell.”
  20. PEP 255 – Simple Generators. Python Enhancement Proposals. Python Software Foundation, 2001. május 18. [2020. június 5-i dátummal az eredetiből archiválva]. (Hozzáférés: 2012. február 9.)
  21. More Control Flow Tools. Python 3 documentation. Python Software Foundation. [2016. június 4-i dátummal az eredetiből archiválva]. (Hozzáférés: 2015. július 24.) „By popular demand, a few features commonly found in functional programming languages like Lisp have been added to Python. With the lambda keyword, small anonymous functions can be created.”
  22. re — Regular expression operations — Python 3.10.6 documentation. docs.python.org . (Hozzáférés: 2022. szeptember 6.) „This module provides regular expression matching operations similar to those found in Perl.”
  23. CoffeeScript. coffeescript.org . [2020. június 12-i dátummal az eredetiből archiválva]. (Hozzáférés: 2018. július 3.)
  24. The Genie Programming Language Tutorial. [2020. június 1-i dátummal az eredetiből archiválva]. (Hozzáférés: 2020. február 28.)
  25. Perl and Python influences in JavaScript. www.2ality.com , 2013. február 24. [2018. december 26-i dátummal az eredetiből archiválva]. (Hozzáférés: 2015. május 15.)
  26. Rauschmayer, Axel: Chapter 3: The Nature of JavaScript; Influences. O'Reilly, Speaking JavaScript . [2018. december 26-i dátummal az eredetiből archiválva]. (Hozzáférés: 2015. május 15.)
  27. a b Why We Created Julia. Julia website , 2012. február 1. [2020. május 2-i dátummal az eredetiből archiválva]. (Hozzáférés: 2014. június 5.) „We want something as usable for general programming as Python [...]”
  28. Ring Team: Ring and other languages. ring-lang.net. ring-lang, 2017. december 4. [2018. december 25-i dátummal az eredetiből archiválva]. (Hozzáférés: 2017. december 4.)
  29. Bini, Ola. Practical JRuby on Rails Web 2.0 Projects: bringing Ruby on Rails to the Java platform. Berkeley: APress, 3. o. (2007). ISBN 978-1-59059-881-8 
  30. Lattner, Chris: Chris Lattner's Homepage. Chris Lattner, 2014. június 3. [2018. december 25-i dátummal az eredetiből archiválva]. (Hozzáférés: 2014. június 3.) „The Swift language is the product of tireless effort from a team of language experts, documentation gurus, compiler optimization ninjas, and an incredibly important internal dogfooding group who provided feedback to help refine and battle-test ideas. Of course, it also greatly benefited from the experiences hard-won by many other languages in the field, drawing ideas from Objective-C, Rust, Haskell, Ruby, Python, C#, CLU, and far too many others to list.”
  31. test — Regression tests package for Python — Python 3.7.13 documentation. docs.python.org . (Hozzáférés: 2022. május 17.)
  32. platform — Access to underlying platform's identifying data — Python 3.10.4 documentation. docs.python.org . (Hozzáférés: 2022. május 17.)
  33. Download Python (angol nyelven). Python.org . [2018. augusztus 8-i dátummal az eredetiből archiválva]. (Hozzáférés: 2021. május 24.)
  34. What is Python Good For? (angol nyelven). General Python FAQ. Python Foundation. (Hozzáférés: 2008. szeptember 5.)
  35. General Python FAQ. python.org. Python Software Foundation. (Hozzáférés: 2009. június 27.)
  36. What is Python? Executive Summary (angol nyelven). Python documentation. Python Foundation. (Hozzáférés: 2007. március 21.)
  37. What is Python Good For?. General Python FAQ. Python Software Foundation. (Hozzáférés: 2008. szeptember 5.)
  38. What is Python? Executive Summary. Python documentation. Python Software Foundation. (Hozzáférés: 2007. március 21.)
  39. Kuhlman, Dave: A Python Book: Beginning Python, Advanced Python, and Python Exercises. [2012. június 23-i dátummal az eredetiből archiválva].
  40. About Python. Python Software Foundation. [2012. április 20-i dátummal az eredetiből archiválva]. (Hozzáférés: 2012. április 24.), second section "Fans of Python use the phrase "batteries included" to describe the standard library, which covers everything from asynchronous processing to zip files."
  41. PEP 206 – Python Advanced Library. Python.org . [2021. május 5-i dátummal az eredetiből archiválva]. (Hozzáférés: 2021. október 11.)
  42. Stack Overflow Developer Survey 2022 (angol nyelven). Stack Overflow . (Hozzáférés: 2022. augusztus 12.)
  43. The State of Developer Ecosystem in 2020 Infographic (angol nyelven). JetBrains: Developer Tools for Professionals and Teams . [2021. március 1-i dátummal az eredetiből archiválva]. (Hozzáférés: 2021. március 5.)
  44. index | TIOBE – The Software Quality Company. www.tiobe.com . [2018. február 25-i dátummal az eredetiből archiválva]. (Hozzáférés: 2021. február 2.) „Python has won the TIOBE programming language of the year award! This is for the fourth time in the history, which is a record! The title is awarded to the programming language that has gained most popularity in one year.”
  45. PYPL PopularitY of Programming Language index (angol nyelven). pypl.github.io . [2017. március 14-i dátummal az eredetiből archiválva]. (Hozzáférés: 2021. március 26.)
  46. A Brief Timeline of Python. Guido van Rossum. (Hozzáférés: 2009. január 20.)
  47. http://docs.python.org/2/faq/general.html#why-is-it-called-python
  48. HISTORY. Python source distribution. Python Foundation. [2016. február 17-i dátummal az eredetiből archiválva]. (Hozzáférés: 2007. március 21.)
  49. a b Venners, Bill: The Making of Python. Artima Developer. Artima, 2003. január 13. [2016. szeptember 1-i dátummal az eredetiből archiválva]. (Hozzáférés: 2007. március 22.)
  50. http://www.python.org/download/releases
  51. Guido van Rossum: Kommentar zur Entfernung einiger funktionaler Konzepte (angol nyelven). (Hozzáférés: 2014. augusztus 11.)
  52. A. Kuchling, Moshe Zadka: Dokumentation Python 2.0 (angol nyelven). Python Software Foundation. (Hozzáférés: 2014. augusztus 11.)
  53. Peterson, Benjamin: Python Insider: Python 2.7.18, the last release of Python 2. Python Insider , 2020. április 20. [2020. április 26-i dátummal az eredetiből archiválva]. (Hozzáférés: 2020. április 27.)
  54. heise.de: Python 2.6 öffnet Wege zu Version 3 vom 2. Oktober 2008, abgerufen am 4. Oktober 2008
  55. 2to3 – Automated Python 2 to 3 code translation. docs.python.org . [2020. június 4-i dátummal az eredetiből archiválva]. (Hozzáférés: 2021. február 2.)
  56. PEP 373 – Python 2.7 Release Schedule. python.org. [2020. május 19-i dátummal az eredetiből archiválva]. (Hozzáférés: 2017. január 9.)
  57. PEP 466 – Network Security Enhancements for Python 2.7.x. python.org. [2020. június 4-i dátummal az eredetiből archiválva]. (Hozzáférés: 2017. január 9.)
  58. Sunsetting Python 2 (angol nyelven). Python.org . [2020. január 12-i dátummal az eredetiből archiválva]. (Hozzáférés: 2019. szeptember 22.)
  59. PEP 373 – Python 2.7 Release Schedule (angol nyelven). Python.org . [2020. január 13-i dátummal az eredetiből archiválva]. (Hozzáférés: 2019. szeptember 22.)
  60. Python Developer's Guide — Python Developer's Guide. devguide.python.org . [2020. november 9-i dátummal az eredetiből archiválva]. (Hozzáférés: 2019. december 17.)
  61. Langa, Łukasz: Python Insider: Python 3.9.2 and 3.8.8 are now available. Python Insider , 2021. február 19. [2021. február 25-i dátummal az eredetiből archiválva]. (Hozzáférés: 2021. február 26.)
  62. Red Hat Customer Portal – Access to 24x7 support and knowledge. access.redhat.com . [2021. március 6-i dátummal az eredetiből archiválva]. (Hozzáférés: 2021. február 26.)
  63. CVE – CVE-2021-3177. cve.mitre.org . [2021. február 27-i dátummal az eredetiből archiválva]. (Hozzáférés: 2021. február 26.)
  64. CVE – CVE-2021-23336. cve.mitre.org . [2021. február 24-i dátummal az eredetiből archiválva]. (Hozzáférés: 2021. február 26.)
  65. Langa, Łukasz: Python Insider: Python 3.10.4 and 3.9.12 are now available out of schedule. Python Insider , 2022. március 24. (Hozzáférés: 2022. április 19.)
  66. Langa, Łukasz: Python Insider: Python 3.10.3, 3.9.11, 3.8.13, and 3.7.13 are now available with security content. Python Insider , 2022. március 16. (Hozzáférés: 2022. április 19.)
  67. Langa, Łukasz: Python Insider: Python 3.9.13 is now available. Python Insider , 2022. május 17. (Hozzáférés: 2022. május 21.)
  68. Python Insider: Python releases 3.10.7, 3.9.14, 3.8.14, and 3.7.14 are now available. pythoninsider.blogspot.com, 2022. szeptember 7. (Hozzáférés: 2022. szeptember 16.)
  69. CVE - CVE-2020-10735. cve.mitre.org. (Hozzáférés: 2022. szeptember 16.)
  70. Python Insider: Python 3.12.0 alpha 1 released. (Hozzáférés: 2022. október 31.)
  71. The Cain Gang Ltd.: Python Metaclasses: Who? Why? When?. [2009. május 30-i dátummal az eredetiből archiválva]. (Hozzáférés: 2009. június 27.)
  72. 3.3. Special method names. The Python Language Reference. Python Software Foundation. [2018. december 15-i dátummal az eredetiből archiválva]. (Hozzáférés: 2009. június 27.)
  73. PyDBC: method preconditions, method postconditions and class invariants for Python. [2019. november 23-i dátummal az eredetiből archiválva]. (Hozzáférés: 2011. szeptember 24.)
  74. Contracts for Python. [2020. június 15-i dátummal az eredetiből archiválva]. (Hozzáférés: 2011. szeptember 24.)
  75. PyDatalog. [2020. június 13-i dátummal az eredetiből archiválva]. (Hozzáférés: 2012. július 22.)
  76. Guido van Rossum, Ivan Levkivskyi: PEP 483 – The Theory of Type Hints (angol nyelven), 2014. december 19.
  77. Cite web-hiba: a title paramétert mindenképpen meg kell adni!Guido van Rossum, Jukka Lehtosalo, Łukasz Langa:
  78. Extending and Embedding the Python Interpreter: Reference Counts (angol nyelven). Docs.python.org. [2012. október 18-i dátummal az eredetiből archiválva]. (Hozzáférés: 2020. június 5.) „Since Python makes heavy use of malloc() and free(), it needs a strategy to avoid memory leaks as well as the use of freed memory. The chosen method is called reference counting.”
  79. a b Hettinger, Raymond: PEP 289 – Generator Expressions. Python Enhancement Proposals. Python Software Foundation, 2002. január 30. [2020. június 14-i dátummal az eredetiből archiválva]. (Hozzáférés: 2012. február 19.)
  80. 6.5 itertools – Functions creating iterators for efficient looping. Docs.python.org. [2020. június 14-i dátummal az eredetiből archiválva]. (Hozzáférés: 2016. november 22.)
  81. a b Peters, Tim: PEP 20 – The Zen of Python. Python Enhancement Proposals. Python Software Foundation, 2004. augusztus 19. [2018. december 26-i dátummal az eredetiből archiválva]. (Hozzáférés: 2008. november 24.)
  82. Bill Venners: Interview mit Guido van Rossum (angol nyelven), 2003. január 13.
  83. Verwendung fremdsprachiger Module (angol nyelven)
  84. Marty Alchin.szerk.: Apress: Pro Python (2010. szeptember 19.) 
  85. 2. Lexical analysis Python 3.7.2rc1 documentation.
  86. Python Cookbook, 2nd Edition. O'Reilly Media, 230. o. (2005). ISBN 978-0-596-00797-3 
  87. Python Culture. ebeab , 2014. január 21. [2014. január 30-i dátummal az eredetiből archiválva].
  88. a b General Python FAQ. Python v2.7.3 documentation. Docs.python.org. [2012. október 24-i dátummal az eredetiből archiválva]. (Hozzáférés: 2020. június 4.)
  89. Offizielle Python FAQ, sowie Python Tutorial, 1. fejezet
  90. 15 Ways Python Is a Powerful Force on the Web. [2019. május 11-i dátummal az eredetiből archiválva]. (Hozzáférés: 2018. július 3.)
  91. pprint — Data pretty printer — Python 3.11.0 documentation. docs.python.org . [2021. január 22-i dátummal az eredetiből archiválva]. (Hozzáférés: 2022. november 5.) „stuff = ['spam', 'eggs', 'lumberjack', 'knights', 'ni']”
  92. The Cobra Programming Language (angol nyelven). cobra-language.com
  93. Boa Constructor home (angol nyelven). boa-constructor.sourceforge.net
  94. Clark, Robert: How to be Pythonic and why you should care. Medium , 2019. április 26. [2021. augusztus 13-i dátummal az eredetiből archiválva]. (Hozzáférés: 2021. január 20.)
  95. Code Style — The Hitchhiker's Guide to Python. docs.python-guide.org . [2021. január 27-i dátummal az eredetiből archiválva]. (Hozzáférés: 2021. január 20.)
  96. Goodger, David: Code Like a Pythonista: Idiomatic Python. [2014. május 27-i dátummal az eredetiből archiválva]. (Hozzáférés: 2009. március 24.)
  97. How to think like a Pythonista. [2018. március 23-i dátummal az eredetiből archiválva]. (Hozzáférés: 2009. március 24.)
  98. Is Python a good language for beginning programmers?. General Python FAQ. Python Software Foundation. [2012. október 24-i dátummal az eredetiből archiválva]. (Hozzáférés: 2007. március 21.)
  99. Myths about indentation in Python. Secnetix.de. [2018. február 18-i dátummal az eredetiből archiválva]. (Hozzáférés: 2011. április 19.)
  100. Guttag, John V.. Introduction to Computation and Programming Using Python: With Application to Understanding Data. MIT Press (2016. augusztus 12.). ISBN 978-0-262-52962-4 
  101. PEP 8 – Style Guide for Python Code. Python.org . [2019. április 17-i dátummal az eredetiből archiválva]. (Hozzáférés: 2019. március 26.)
  102. Python Documentation - 3. Data Types. (Hozzáférés: 2013. október 7.)
  103. Immutable vs mutable types - Python. (Hozzáférés: 2013. október 7.)
  104. The Python Language Reference, section 3.3. New-style and classic classes, for release 2.7.1. [2012. október 26-i dátummal az eredetiből archiválva]. (Hozzáférés: 2011. január 12.)
  105. Type hinting for Python. LWN.net, 2014. december 24. [2019. június 20-i dátummal az eredetiből archiválva]. (Hozzáférés: 2015. május 5.)
  106. mypy – Optional Static Typing for Python. [2020. június 6-i dátummal az eredetiből archiválva]. (Hozzáférés: 2017. január 28.)
  107. 15. Floating Point Arithmetic: Issues and Limitations — Python 3.8.3 documentation. docs.python.org . [2020. június 6-i dátummal az eredetiből archiválva]. (Hozzáférés: 2020. június 6.) „Almost all machines today (November 2000) use IEEE-754 floating point arithmetic, and almost all platforms map Python floats to IEEE-754 “double precision”.”
  108. PEP 237 – Unifying Long Integers and Integers. Python Enhancement Proposals. Python Software Foundation, 2001. március 11. [2020. május 28-i dátummal az eredetiből archiválva]. (Hozzáférés: 2011. szeptember 24.)
  109. Built-in Types. [2020. június 14-i dátummal az eredetiből archiválva]. (Hozzáférés: 2019. október 3.)
  110. PEP 465 – A dedicated infix operator for matrix multiplication. python.org. [2020. május 29-i dátummal az eredetiből archiválva]. (Hozzáférés: 2018. július 3.)
  111. PEP 238 – Changing the Division Operator. Python Enhancement Proposals. Python Software Foundation, 2001. március 11. [2020. május 28-i dátummal az eredetiből archiválva]. (Hozzáférés: 2013. október 23.)
  112. Why Python's Integer Division Floors, 2010. augusztus 24. [2020. június 5-i dátummal az eredetiből archiválva]. (Hozzáférés: 2010. augusztus 25.)
  113. round, <https://docs.python.org/py3k/library/functions.html#round>. Hozzáférés ideje: 14 August 2011
  114. round, <https://docs.python.org/library/functions.html#round>. Hozzáférés ideje: 14 August 2011
  115. The C Programming Language, 2nd, 206. o. (1988) 
  116. Batista, Facundo: PEP 0327 – Decimal Data Type. Python.org . [2020. június 4-i dátummal az eredetiből archiválva]. (Hozzáférés: 2015. szeptember 26.)
  117. What's New in Python 2.6 — Python v2.6.9 documentation. docs.python.org . [2019. december 23-i dátummal az eredetiből archiválva]. (Hozzáférés: 2015. szeptember 26.)
  118. 10 Reasons Python Rocks for Research (And a Few Reasons it Doesn't) – Hoyt Koepke. www.stat.washington.edu . [2020. május 31-i dátummal az eredetiből archiválva]. (Hozzáférés: 2019. február 3.)
  119. Shell, Scott: An introduction to Python for scientific computing, 2014. június 17. [2019. február 4-i dátummal az eredetiből archiválva]. (Hozzáférés: 2019. február 3.)
  120. 8. Errors and Exceptions — Python 3.12.0a0 documentation. docs.python.org . (Hozzáférés: 2022. május 9.)
  121. Highlights: Python 2.5. Python.org . [2019. augusztus 4-i dátummal az eredetiből archiválva]. (Hozzáférés: 2018. március 20.)
  122. division. python.org . [2006. július 20-i dátummal az eredetiből archiválva]. (Hozzáférés: 2014. július 30.)
  123. PEP 0465 – A dedicated infix operator for matrix multiplication. python.org . [2020. június 4-i dátummal az eredetiből archiválva]. (Hozzáférés: 2016. január 1.)
  124. Python 3.5.1 Release and Changelog. python.org . [2020. május 14-i dátummal az eredetiből archiválva]. (Hozzáférés: 2016. január 1.)
  125. What's New in Python 3.8. [2020. június 8-i dátummal az eredetiből archiválva]. (Hozzáférés: 2019. október 14.)
  126. Chapter 15. Expressions – 15.21.1. Numerical Equality Operators == and !=. Oracle Corporation. [2020. június 7-i dátummal az eredetiből archiválva]. (Hozzáférés: 2016. augusztus 28.)
  127. Chapter 15. Expressions – 15.21.3. Reference Equality Operators == and !=. Oracle Corporation. [2020. június 7-i dátummal az eredetiből archiválva]. (Hozzáférés: 2016. augusztus 28.)
  128. Learning Python, 2nd Edition (angol nyelven). Safari Books Online, 2003. december 23.
  129. 4. Built-in Types — Python 3.6.3rc1 documentation. python.org . [2020. június 14-i dátummal az eredetiből archiválva]. (Hozzáférés: 2017. október 1.)
  130. 5.3. Tuples and Sequences — Python 3.7.1rc2 documentation. python.org . [2020. június 10-i dátummal az eredetiből archiválva]. (Hozzáférés: 2018. október 17.)
  131. a b PEP 498 – Literal String Interpolation. python.org . [2020. június 15-i dátummal az eredetiből archiválva]. (Hozzáférés: 2017. március 8.)
  132. Why must 'self' be used explicitly in method definitions and calls?. Design and History FAQ. Python Software Foundation. [2012. október 24-i dátummal az eredetiből archiválva]. (Hozzáférés: 2012. február 19.)
  133. Beyond the Basic Stuff with Python: Best Practices for Writing Clean Code (angol nyelven). No Starch Press, 322. o. (2020). ISBN 978-1-59327-966-0 
  134. a b 9. Classes — Python 3.7.0 documentation. docs.python.org. (Hozzáférés: 2018. szeptember 1.)
  135. Node.js vs Python: Which backend technology to choose in 2021? (amerikai angol nyelven). Insights on Latest Technologies - Simform Blog, 2021. február 19. (Hozzáférés: 2021. május 28.)
  136. Batista, Facundo: PEP 327 – Decimal Data Type. Python Enhancement Proposals. Python Software Foundation, 2003. október 17. [2020. június 4-i dátummal az eredetiből archiválva]. (Hozzáférés: 2008. november 24.)
  137. Eby, Phillip J.: PEP 333 – Python Web Server Gateway Interface v1.0. Python Enhancement Proposals. Python Software Foundation, 2003. december 7. [2020. június 14-i dátummal az eredetiből archiválva]. (Hozzáférés: 2012. február 19.)
  138. Modulecounts. Modulecounts , 2022. november 14. [2022. június 26-i dátummal az eredetiből archiválva].
  139. Canopy. www.enthought.com . [2017. július 15-i dátummal az eredetiből archiválva]. (Hozzáférés: 2016. augusztus 20.)
  140. Benjamin Peterson: Python Insider: Python 2.7.18, the last release of Python 2
  141. heise online: Programmiersprachen: Lang lebe Python 3 – finales Release von Python 2
  142. Python Software Foundation: Press Release 20-Dec-2019
  143. Golem.de: IT-News für Profis
  144. Porting Python 2 Code to Python 3 — Python 3.7.13 documentation
  145. The Conservative Python 3 Porting Guide — Conservative Python 3 Porting Guide 1.0 documentation
  146. Lennart Regebro: Supporting Python 3 — Supporting Python 3: An in-depth guide (angol nyelven)
  147. 25.4. 2to3 – Automated Python 2 to 3 code translation — Python 2.7.18 documentation
  148. six: pypi.python.org és https://pythonhosted.org/six/ Archiválva 2019. január 8-i dátummal a Wayback Machine-ben
  149. Python-Modernize — modernize 0.6.1 documentation
  150. Easy, clean, reliable Python 2/3 compatibility — Python-Future documentation
  151. Victor Stinner: sixer: Add Python 3 support to Python 2 applications using the six module.
  152. limodou: 2to6
  153. Mailman 3 Why aren't we allowing the use of C11? - Python-Dev - python.org (angol nyelven). mail.python.org . [2021. április 14-i dátummal az eredetiből archiválva]. (Hozzáférés: 2021. március 1.)
  154. Issue 35473: Intel compiler (icc) does not fully support C11 Features, including atomics – Python tracker. bugs.python.org . [2021. április 14-i dátummal az eredetiből archiválva]. (Hozzáférés: 2021. március 1.)
  155. PEP 7 – Style Guide for C Code | peps.python.org. peps.python.org . (Hozzáférés: 2022. április 28.)
  156. 4. Building C and C++ Extensions — Python 3.9.2 documentation. docs.python.org . [2021. március 3-i dátummal az eredetiből archiválva]. (Hozzáférés: 2021. március 1.)
  157. van Rossum, Guido: PEP 7 – Style Guide for C Code. Python Enhancement Proposals. Python Software Foundation, 2001. június 5. [2020. június 1-i dátummal az eredetiből archiválva]. (Hozzáférés: 2008. november 24.)
  158. CPython byte code. Docs.python.org. [2020. június 5-i dátummal az eredetiből archiválva]. (Hozzáférés: 2016. február 16.)
  159. Python 2.5 internals. [2012. augusztus 6-i dátummal az eredetiből archiválva]. (Hozzáférés: 2011. április 19.)
  160. history [vmspython]. www.vmspython.org . [2020. december 2-i dátummal az eredetiből archiválva]. (Hozzáférés: 2020. december 4.)
  161. An Interview with Guido van Rossum. Oreilly.com. [2014. július 16-i dátummal az eredetiből archiválva]. (Hozzáférés: 2008. november 24.)
  162. Download Python for Other Platforms (angol nyelven). Python.org . [2020. november 27-i dátummal az eredetiből archiválva]. (Hozzáférés: 2020. december 4.)
  163. Changelog — Python 3.9.0 documentation. docs.python.org . [2021. február 7-i dátummal az eredetiből archiválva]. (Hozzáférés: 2021. február 8.)
  164. Download Python (angol nyelven). Python.org . [2020. december 8-i dátummal az eredetiből archiválva]. (Hozzáférés: 2020. december 13.)
  165. PyPy compatibility. Pypy.org. [2020. június 6-i dátummal az eredetiből archiválva]. (Hozzáférés: 2012. december 3.)
  166. Team, The PyPy: Download and Install (angol nyelven). PyPy , 2019. december 28. (Hozzáférés: 2022. január 8.)
  167. speed comparison between CPython and Pypy. Speed.pypy.org. [2021. május 10-i dátummal az eredetiből archiválva]. (Hozzáférés: 2012. december 3.)
  168. Application-level Stackless features — PyPy 2.0.2 documentation. Doc.pypy.org. [2020. június 4-i dátummal az eredetiből archiválva]. (Hozzáférés: 2013. július 17.)
  169. Python-for-EV3 (angol nyelven). LEGO Education . [2020. június 7-i dátummal az eredetiből archiválva]. (Hozzáférés: 2019. április 17.)
  170. MicroPython – Python for microcontrollers (angol nyelven). micropython.org
  171. Yegulalp, Serdar. „Pyston returns from the dead to speed Python”, 2020. október 29.. [2021. január 27-i dátummal az eredetiből archiválva] (Hozzáférés ideje: 2021. január 26.) 
  172. Pyston. Python Performance
  173. cinder: Instagram's performance-oriented fork of CPython. (angol nyelven). GitHub . [2021. május 4-i dátummal az eredetiből archiválva]. (Hozzáférés: 2021. május 4.)
  174. Plans for optimizing Python. Google Project Hosting, 2009. december 15. [2016. április 11-i dátummal az eredetiből archiválva]. (Hozzáférés: 2011. szeptember 24.)
  175. Python on the Nokia N900. Stochastic Geometry , 2010. április 29. [2019. június 20-i dátummal az eredetiből archiválva]. (Hozzáférés: 2015. július 9.)
  176. Brython. brython.info . [2018. augusztus 3-i dátummal az eredetiből archiválva]. (Hozzáférés: 2021. január 21.)
  177. Transcrypt – Python in the browser (angol nyelven). transcrypt.org . [2018. augusztus 19-i dátummal az eredetiből archiválva]. (Hozzáférés: 2020. december 22.)
  178. Transcrypt: Anatomy of a Python to JavaScript Compiler. InfoQ . [2020. december 5-i dátummal az eredetiből archiválva]. (Hozzáférés: 2021. január 20.)
  179. Nuitka Home | Nuitka Home (angol nyelven). nuitka.net . [2020. május 30-i dátummal az eredetiből archiválva]. (Hozzáférés: 2017. augusztus 18.)
  180. Borderies, Olivier: Pythran: Python at C++ speed !. Medium , 2019. január 24. [2020. március 25-i dátummal az eredetiből archiválva]. (Hozzáférés: 2020. március 25.)
  181. Pythran — Pythran 0.9.5 documentation. pythran.readthedocs.io . [2020. február 19-i dátummal az eredetiből archiválva]. (Hozzáférés: 2020. március 25.)
  182. Archived copy. [2021. április 18-i dátummal az eredetiből archiválva]. (Hozzáférés: 2021. január 20.)
  183. The Python → 11l → C++ transpiler
  184. google/grumpy, 2020. április 10. [2020. április 15-i dátummal az eredetiből archiválva]. (Hozzáférés: 2020. március 25.)
  185. Projects. opensource.google . [2020. április 24-i dátummal az eredetiből archiválva]. (Hozzáférés: 2020. március 25.)
  186. Francisco, Thomas Claburn in San: Google's Grumpy code makes Python Go. www.theregister.com . [2021. március 7-i dátummal az eredetiből archiválva]. (Hozzáférés: 2021. január 20.)
  187. GitHub – IronLanguages/ironpython3: Implementation of Python 3.x for .NET Framework that is built on top of the Dynamic Language Runtime. GitHub . [2021. szeptember 28-i dátummal az eredetiből archiválva].
  188. IronPython.net /. ironpython.net . [2021. április 17-i dátummal az eredetiből archiválva].
  189. Jython FAQ. www.jython.org . [2021. április 22-i dátummal az eredetiből archiválva]. (Hozzáférés: 2021. április 22.)
  190. Murri, Riccardo (2013). „Performance of Python runtimes on a non-numeric scientific code”. European Conference on Python in Science (EuroSciPy). 
  191. The Computer Language Benchmarks Game. [2020. június 14-i dátummal az eredetiből archiválva]. (Hozzáférés: 2020. április 30.)
  192. a b PEP 1 – PEP Purpose and Guidelines. Python Enhancement Proposals. Python Software Foundation, 2000. június 13. [2020. június 6-i dátummal az eredetiből archiválva]. (Hozzáférés: 2011. április 19.)
  193. PEP 8 – Style Guide for Python Code. Python.org . [2019. április 17-i dátummal az eredetiből archiválva]. (Hozzáférés: 2019. március 26.)
  194. Cannon, Brett: Guido, Some Guys, and a Mailing List: How Python is Developed. python.org. Python Software Foundation. [2009. június 1-i dátummal az eredetiből archiválva]. (Hozzáférés: 2009. június 27.)
  195. Moving Python's bugs to GitHub [LWN.net]
  196. Python Developer's Guide — Python Developer's Guide. devguide.python.org . [2020. november 9-i dátummal az eredetiből archiválva]. (Hozzáférés: 2019. december 17.)
  197. Hughes, Owen: Programming languages: Why Python 4.0 might never arrive, according to its creator (amerikai angol nyelven). TechRepublic , 2021. május 24. (Hozzáférés: 2022. május 16.)
  198. PEP 602 – Annual Release Cycle for Python (angol nyelven). Python.org . [2020. június 14-i dátummal az eredetiből archiválva]. (Hozzáférés: 2019. november 6.)
  199. Changing the Python release cadence [LWN.net]. lwn.net . [2019. november 6-i dátummal az eredetiből archiválva]. (Hozzáférés: 2019. november 6.)
  200. Norwitz, Neal: [Python-Dev] Release Schedules (was Stability & change), 2002. április 8. [2018. december 15-i dátummal az eredetiből archiválva]. (Hozzáférés: 2009. június 27.)
  201. PEP 6 – Bug Fix Releases. Python Enhancement Proposals. Python Software Foundation, 2001. március 15. [2020. június 5-i dátummal az eredetiből archiválva]. (Hozzáférés: 2009. június 27.)
  202. Python Buildbot. Python Developer’s Guide. Python Software Foundation. [2020. június 5-i dátummal az eredetiből archiválva]. (Hozzáférés: 2011. szeptember 24.)
  203. 1. Extending Python with C or C++ — Python 3.9.1 documentation. docs.python.org . [2020. június 23-i dátummal az eredetiből archiválva]. (Hozzáférés: 2021. február 14.)
  204. PEP 623 – Remove wstr from Unicode (angol nyelven). Python.org . [2021. március 5-i dátummal az eredetiből archiválva]. (Hozzáférés: 2021. február 14.)
  205. PEP 634 – Structural Pattern Matching: Specification (angol nyelven). Python.org . [2021. május 6-i dátummal az eredetiből archiválva]. (Hozzáférés: 2021. február 14.)
  206. Documentation Tools (angol nyelven). Python.org . [2020. november 11-i dátummal az eredetiből archiválva]. (Hozzáférés: 2021. március 22.)
  207. a b Whetting Your Appetite. The Python Tutorial. Python Software Foundation. [2012. október 26-i dátummal az eredetiből archiválva]. (Hozzáférés: 2012. február 20.)
  208. In Python, should I use else after a return in an if block?. Stack Overflow. Stack Exchange, 2011. február 17. [2019. június 20-i dátummal az eredetiből archiválva]. (Hozzáférés: 2011. május 6.)
  209. Learning Python: Powerful Object-Oriented Programming (angol nyelven). O'Reilly Media, Inc., 17. o. (2009). ISBN 9781449379322 
  210. Python (angol nyelven). Peachpit Press, xv. o. (2002). ISBN 9780201748840 
  211. TIOBE Index. TIOBE – The Software Quality Company. [2021. október 12-i dátummal az eredetiből archiválva]. (Hozzáférés: 2021. október 13.)
  212. Blake, Troy: TIOBE Index for January 2021 (angol nyelven). Technology News and Information by SeniorDBA , 2021. január 18. [2021. március 21-i dátummal az eredetiből archiválva]. (Hozzáférés: 2021. február 26.)
  213. TIOBE Software Index: TIOBE Programming Community Index Python, 2015. [2015. szeptember 7-i dátummal az eredetiből archiválva]. (Hozzáférés: 2015. szeptember 10.)
  214. Prechelt, Lutz: An empirical comparison of C, C++, Java, Perl, Python, Rexx, and Tcl, 2000. március 14. [2020. január 3-i dátummal az eredetiből archiválva]. (Hozzáférés: 2013. augusztus 30.)
  215. Quotes about Python. Python Software Foundation. [2020. június 3-i dátummal az eredetiből archiválva]. (Hozzáférés: 2012. január 8.)
  216. Organizations Using Python. Python Software Foundation. [2018. augusztus 21-i dátummal az eredetiből archiválva]. (Hozzáférés: 2009. január 15.)
  217. (2006. július 31.) „Python : the holy grail of programming”. CERN Bulletin (31/2006), Kiadó: CERN Publications. (Hozzáférés: 2012. február 11.)  
  218. Shafer, Daniel G.: Python Streamlines Space Shuttle Mission Design. Python Software Foundation, 2003. január 17. [2020. június 5-i dátummal az eredetiből archiválva]. (Hozzáférés: 2008. november 24.)
  219. Tornado: Facebook's Real-Time Web Framework for Python – Facebook for Developers (amerikai angol nyelven). Facebook for Developers . [2019. február 19-i dátummal az eredetiből archiválva]. (Hozzáférés: 2018. június 19.)
  220. What Powers Instagram: Hundreds of Instances, Dozens of Technologies. Instagram Engineering, 2016. december 11. [2020. június 15-i dátummal az eredetiből archiválva]. (Hozzáférés: 2019. május 27.)
  221. How we use Python at Spotify (amerikai angol nyelven). Spotify Labs , 2013. március 20. [2020. június 10-i dátummal az eredetiből archiválva]. (Hozzáférés: 2018. július 25.)
  222. Fortenberry, Tim: Industrial Light & Magic Runs on Python. Python Software Foundation, 2003. január 17. [2020. június 6-i dátummal az eredetiből archiválva]. (Hozzáférés: 2012. február 11.)
  223. Taft, Darryl K.: Python Slithers into Systems. eWeek.com. Ziff Davis Holdings, 2007. március 5. [2021. augusztus 13-i dátummal az eredetiből archiválva]. (Hozzáférés: 2011. szeptember 24.)
  224. GitHub – reddit-archive/reddit: historical code from reddit.com., The Reddit Archives, <https://github.com/reddit-archive/reddit>. Hozzáférés ideje: 20 March 2019
  225. Usage statistics and market share of Python for websites, 2012. [2021. augusztus 13-i dátummal az eredetiből archiválva]. (Hozzáférés: 2012. december 18.)
  226. Jupyter, Mathematica, and the Future of the Research Paper (angol nyelven)
  227. Oliphant, Travis (2007). „Python for Scientific Computing”. Computing in Science and Engineering 9 (3), 10–20. o. [2020. június 15-i dátummal az eredetiből archiválva]. DOI:10.1109/MCSE.2007.58. (Hozzáférés: 2022. november 30.)  
  228. (2011) „Python for Scientists and Engineers”. Computing in Science and Engineering 13, 9–12. o. DOI:10.1109/MCSE.2011.36. (Hozzáférés: 2014. július 7.)  
  229. Science education with SageMath, Innovative Computing in Science Education, <http://visual.icse.us.edu.pl/methodology/why_Sage.html>. Hozzáférés ideje: 22 April 2019 Archivált másolat. [2020. június 15-i dátummal az eredetiből archiválva]. (Hozzáférés: 2022. november 30.)
  230. OpenCV: OpenCV-Python Tutorials. docs.opencv.org . [2020. szeptember 23-i dátummal az eredetiből archiválva]. (Hozzáférés: 2020. szeptember 14.)
  231. TensorFlow: Large-scale machine learning on heterogeneous systems. TensorFlow.org . Google Research, 2015. november 9. [2015. november 20-i dátummal az eredetiből archiválva]. (Hozzáférés: 2015. november 10.)
  232. Python eats away at R: Top Software for Analytics, Data Science, Machine Learning in 2018: Trends and Analysis. KDnuggets . KDnuggets. [2019. november 15-i dátummal az eredetiből archiválva]. (Hozzáférés: 2018. május 30.)
  233. Who is using scikit-learn? — scikit-learn 0.20.1 documentation. scikit-learn.org . [2020. május 6-i dátummal az eredetiből archiválva]. (Hozzáférés: 2018. november 30.)
  234. Google supercharges machine learning tasks with TPU custom chip. Google Cloud Platform Blog . [2016. május 18-i dátummal az eredetiből archiválva]. (Hozzáférés: 2016. május 19.)
  235. Natural Language Toolkit — NLTK 3.5b1 documentation. www.nltk.org . [2020. június 13-i dátummal az eredetiből archiválva]. (Hozzáférés: 2020. április 10.)
  236. Computer Science Circles – ein kostenfreier Dienst des Centre for Education in Mathematics and Computing, University of Waterloo.
  237. Programmieren lernen mit Python. App Camps gemeinnützige Unternehmergesellschaft, Hamburg
  238. Programming for Data Science with Python, Udacity
  239. Einstieg ins Programmieren mit Python. Web 2 Unterricht, 3. September 2017
  240. Python – die Programmiersprache für imperative und objektorientierte Programmierung. Bildungsserver Berlin-Brandenburg
  241. Programmieren mit Python. Bildungsserver Rheinland-Pfalz
  242. Például Programmieren supereasy – Einfacher Einstieg in Scratch und Python. Carol Vorderman és Jon Woodcock könyve, Dorling Kindersley Verlag, vagy Python 4 Kids von Gregor Lingl, Mitp Verlag
  243. Programmieren lernen. Bundesweite Informatikwettbewerbe. Ein Projekt der Gesellschaft für Informatik e. V., des Fraunhofer-Verbunds IUK-Technologie und des Max-Planck-Instituts für Informatik.
  244. Flyer TigerJython – Programmierkonzepte mit Python Archiválva 2021. július 12-i dátummal a Wayback Machine-ben (PDF; 468 kB) Pädagogischen Hochschule Bern
  245. OLPC-Wiki: „Python für den 100-Dollar-Laptop
  246. Zühlke, Karin: Erstmals »Live on stage«: Farnell zeigt den Raspberry Pi Nachwuchs (angol nyelven)
  247. Installers for GIMP for Windows – Frequently Asked Questions, 2013. július 26. [2013. július 17-i dátummal az eredetiből archiválva]. (Hozzáférés: 2013. július 26.)
  248. jasc psp9components. [2008. március 19-i dátummal az eredetiből archiválva].
  249. About getting started with writing geoprocessing scripts. ArcGIS Desktop Help 9.2. Environmental Systems Research Institute, 2006. november 17. [2020. június 5-i dátummal az eredetiből archiválva]. (Hozzáférés: 2012. február 11.)
  250. Python Language Guide (v1.0). Google Documents List Data API v1.0. [2010. július 15-i dátummal az eredetiből archiválva].
  251. Quotes about Python. Abgerufen am 25. Juni 2011.
  252. Python Setup and Usage. Python Software Foundation. [2020. június 17-i dátummal az eredetiből archiválva]. (Hozzáférés: 2020. január 10.)
  253. Immunity: Knowing You're Secure. [2009. február 16-i dátummal az eredetiből archiválva].
  254. Core Security. Core Security . [2020. június 9-i dátummal az eredetiből archiválva]. (Hozzáférés: 2020. április 10.)
  255. What is Sugar?. Sugar Labs. [2009. január 9-i dátummal az eredetiből archiválva]. (Hozzáférés: 2012. február 11.)
  256. 4.0 New Features and Fixes. LibreOffice.org. The Document Foundation, 2013. [2014. február 9-i dátummal az eredetiből archiválva]. (Hozzáférés: 2013. február 25.)
  257. Gotchas for Python Users. boo.codehaus.org. Codehaus Foundation. [2008. december 11-i dátummal az eredetiből archiválva]. (Hozzáférés: 2008. november 24.)
  258. Esterbrook, Charles: Acknowledgements. cobra-language.com. Cobra Language. [2008. február 8-i dátummal az eredetiből archiválva]. (Hozzáférés: 2010. április 7.)
  259. Proposals: iterators and generators [ES4 Wiki]. wiki.ecmascript.org. [2007. október 20-i dátummal az eredetiből archiválva]. (Hozzáférés: 2008. november 24.)
  260. Frequently asked questions. Godot Engine documentation . [2021. április 28-i dátummal az eredetiből archiválva]. (Hozzáférés: 2021. május 10.)
  261. Kincaid, Jason. „Google's Go: A New Programming Language That's Python Meets C++”, TechCrunch, 2009. november 10.. [2010. január 18-i dátummal az eredetiből archiválva] (Hozzáférés ideje: 2010. január 29.) 
  262. Strachan, James: Groovy – the birth of a new dynamic language for the Java platform, 2003. augusztus 29. [2007. április 5-i dátummal az eredetiből archiválva]. (Hozzáférés: 2007. június 11.)
  263. Yegulalp, Serdar: Nim language draws from best of Python, Rust, Go, and Lisp. InfoWorld , 2017. január 16. [2018. október 13-i dátummal az eredetiből archiválva]. (Hozzáférés: 2020. június 7.) „Nim's syntax is strongly reminiscent of Python's, as it uses indented code blocks and some of the same syntax (such as the way if/elif/then/else blocks are constructed).”
  264. An Interview with the Creator of Ruby. Linuxdevcenter.com. [2018. április 28-i dátummal az eredetiből archiválva]. (Hozzáférés: 2012. december 3.)
  265. Lattner, Chris: Chris Lattner's Homepage. Chris Lattner, 2014. június 3. [2015. december 22-i dátummal az eredetiből archiválva]. (Hozzáférés: 2014. június 3.) „I started work on the Swift Programming Language in July of 2010. I implemented much of the basic language structure, with only a few people knowing of its existence. A few other (amazing) people started contributing in earnest late in 2011, and it became a major focus for the Apple Developer Tools group in July 2013 [...] drawing ideas from Objective-C, Rust, Haskell, Ruby, Python, C#, CLU, and far too many others to list.”
  266. TIP #3: TIP Format. tcl.tk. Tcl Developer Xchange, 2000. szeptember 14. [2017. július 13-i dátummal az eredetiből archiválva]. (Hozzáférés: 2008. november 24.)
  267. EEP 1: EEP Purpose and Guidelines. erlang.org, 2007. január 29. [2020. június 15-i dátummal az eredetiből archiválva]. (Hozzáférés: 2011. április 19.)
  268. Swift Evolution Process. Swift Programming Language Evolution repository on GitHub , 2020. február 18. [2020. április 27-i dátummal az eredetiből archiválva]. (Hozzáférés: 2020. április 27.)
  269. A. M. Kuchling (angol nyelven)
  270. Archiválva [Dátum hiányzik] dátummal a(z) www.amk.ca archívumban Hiba: ismeretlen archívum-URL
  271. Guido van Rossum: Why explicit self has to stay
  272. PEP 3135 – New Super (angol nyelven). Python.org
  273. Library and Extension FAQ — Python 3.7.0 documentation (angol nyelven). Python.org
  274. Rossum, Guido van van: It isn’t Easy to Remove the GIL (angol nyelven). Artima.com
  275. Python–C (angol nyelven). [2015. december 26-i dátummal az eredetiből archiválva]. (Hozzáférés: 2015. december 25.)
  276. Python–Perl (angol nyelven). [2015. december 26-i dátummal az eredetiből archiválva]. (Hozzáférés: 2015. december 25.)
  277. Benchmark-Vergleich Python–PHP (angol nyelven). [2015. december 26-i dátummal az eredetiből archiválva]. (Hozzáférés: 2015. december 25.)
  278. Benchmark-Vergleich Python–Dart (angol nyelven). [2015. december 26-i dátummal az eredetiből archiválva]. (Hozzáférés: 2015. december 25.)
  279. Benchmark-Vergleich Python–Ruby (angol nyelven). [2015. december 26-i dátummal az eredetiből archiválva]. (Hozzáférés: 2015. december 25.)
  280. [halott link]
  281. Python Patterns – An Optimization Anecdote (angol nyelven). Python.org

Források Szerkesztés

  • 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. szeptember 19.) 
  • 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 Szerkeszté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 Szerkesztés

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

Kapcsolódó szócikkek Szerkesztés