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,[35][36] melyet Guido van Rossum holland programozó kezdett el fejleszteni 1989 végén, majd hozott nyilvánosságra 1991-ben.[12] 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.[37][38][39] Például a behúzások szintaktikailag is fontosak.[40]

Python
Python logo and wordmark.svg

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);[9] graduális (3.5 verziótól, de a CPythonban nincs implementálva)[10]
Fordítóprogram CPython, Jython, IronPython, PyPy
Dialektusok Cython, RPython, Starlark[11]
Megvalósítások CPython, IronPython, Jython, Python for S60, PyPy, Stackless Python, MicroPython, CircuitPython
Hatással volt rá ABC,[12] Ada,[13] ALGOL 68,[14] APL,[15] C,[16]C++,[17] CLU,[18] Dylan,[19] Haskell,[20][15] Icon,[21] Lisp,[22] Modula-3,[14][17] Perl,[23] Standard ML[15]
Befolyásolt nyelvek Apache Groovy, Boo, Cobra, CoffeeScript,[24] D, F#, Genie,[25] Go, JavaScript,[26][27] Julia,[28] Nim, Ring,[29] Ruby,[30] Swift[31]
Operációs rendszer Windows, macOS, Linux/UNIX, Android[32][33] és mások[34]
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.[41][42]

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.[43][44][45][46] Nyitott, közösség alapú 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éneteSzerkesztés

A Python alapötlete az 1980-as évek végén született meg.[47][48] A fejlesztést 1989 decemberében kezdte el Guido van Rossum a CWI-n.[49] 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.[50] 1991 februárjában jelent meg az első nyilvános változat (0.9.0 verzió néven) az alt.sources hírcsoportban.[51] 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.[47] 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.[52] Már a Python 1-es verziója bírt bizonyos funkcionális képességekkel, melyeket azonban később kivezettek belőle.[53] 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.[54] A Python 2 utolsó hivatalos verziója a 2.7.18, ami 2020-ban jelent meg.[55] 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.[56] 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.[57] 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.[58][59] 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.[60][61] Ezzel a legkorábbi támogatott verzió a 3.6 lett.[62]

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

2022-ben a 2022, Python 3.10.4 és 3.9.12 kiadását hozták előre,[67] é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.[68] 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.[69] 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.[70][71]

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

Tervezési filozófia és képességekSzerkeszté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[73] és metaobjektumokkal[74] is. Kiegészítőkkel elérhetők további paradigmák, mint a szerződés alapú tervezés[75][76] vagy a logikai programozás.[77]

A Python dinamikus típusozást használ. 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 nagy standard könyvtárat vizionált könnyen bővíthető értelmezővel, mivel frusztrálta az ABC ellenkező megközelítése.[47]

A Python egyszerű, átlátható szintaxisra törekszik, míg meghagyja a választás szabadságát a különböző programozási metodológiák között. 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.[82]

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.[83] 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, [84] é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.[85][86][87]

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.[84] 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.[88] sowie dem Python-Toolkit „Boa“[89]

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

Szintaxis és szemantikaSzerkeszté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. 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.[94]

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.[95] Így a szkriptek szintaktikai szerkezetét a látható struktúra is reprezentálja.[96] 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, 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. Konvenció szerint a behúzás alapegysége négy szóköz.[97]

Egyszerű adattípusokSzerkeszté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.[98][99]

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 mellett a nyelv erősen típusos, ami azt jelenti, hogy a nem jóldefiniált műveletek nem végezhetőek el.

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(). 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.[100]

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


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.[103]
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.[104]
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.[105]
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',)

()

AritmetikaSzerkeszté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 [106] 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.

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.[107] Í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.[108]

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

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

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

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

Utasítások és vezérlő szerkezetekSzerkeszté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 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.[116] 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[117]
  • 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.

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ésekSzerkeszté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.[118] A hatványozás jele **.
  • A @ egy infix operátor, melyet a NumPy és más könyvtárak mátrixszorzásra használnak.[119][120]
  • 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.[121]
  • 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.[122] and objects by reference.[123] A referencia szerinti összehasonlításra az is operátor szolgál. Az összehasonlítások láncolhatók is, a <= b <= c.
  • A Python logikai operátorok and, or, és not ahelyett, hogy a &&, ||, ! szimbólumokat használná, mint a C és a Java.
  • Létezik a list comprehension típusú kifejezés, illetve az általánosabb generátor kifejezés.[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 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.[124]
  • 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.[125]
  • A % string formátum operátor a printf formázó operátorához hasonlóan működik. 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}'.[126]
  • A stringek összefűzését + jelöli, ez ugyanaz az operátor, amivel számokat adhatunk össze, például "spam" + "eggs" eremé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 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.[126]
  • 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 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ésSzerkeszté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')

MetódusokSzerkesztés

A metódusok osztályban definiált függvények. Az instance.method(argument) hívásmód szintaktikus cukorka 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).[127] Az operátorok (aritmetikai, összehasonlítás, hossz, konverzió) feüldefiniálhatók meghatározott nevű metódusokkal.[128]

Osztályok, öröklődésSzerkeszté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.[129] 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[129]), é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 kompatibilis a kivétellel, ha ugyanabban az osztályban vannak vagy a kivétel az elkapni kívánt típus leszármazottja. Példa:

class B:
    pass
class C(B):
    pass
class D(C):
    pass
 
for c in [B,C,D]:
    try:
        raise c()
    except D:
        print("D")
    except C:
        print("C")
    except B:
        print("B")

Az eredmény B,C,D ebben a sorrendben. Ha azonban az except ágakat fordítva írtuk volna, akkor az eredmény B,B,B lett volna, mert a legelső illeszkedő except-ág aktivizálódik.

ProgrampéldákSzerkesztés

Hello world program:

print('Hello, world!')

Program pozitív egész faktoriálisának számítására:

n = int(input('Írj be egy egész számot, és kiírom a faktoriálisát: '))

if n < 0:
    raise ValueError('Nemnegatív egész számot kell megadni.')

factorial = 1
for i in range(2, n + 1):
    factorial *= i

print(factorial)

(Ez az egyszerűsített példa nem kezeli azt a hibát, ha szöveget írnak be szám helyett, csak az algoritmust demonstrálja.)

Szabványos könyvtárakSzerkeszté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.[130] 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,[131] 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.[132] 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:[133]

Fejlesztési környezetekSzerkeszté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.

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

ImplementációkSzerkesztés

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

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

További implementációkSzerkesztés

  • A PyPy gyors, szabványos implementáció a 2.7 és 3.8 verziók számára.[147][148] 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.[149]
  • 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.[150]
  • A MicroPython és CircuitPython mikrovezérlők számára implementálja a Pythont. Felhasználói közé tartozik a Lego Mindstorms EV3.[151]
  • 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.[152]
  • 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.[153]

Nem támogatott implementációkSzerkeszté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,

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

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

PerformanciaSzerkesztés

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

FejlesztéseSzerkeszté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.[172] Python coding style is covered in PEP 8.[173] 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.[172]

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

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

[181]

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

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

API dokumentáció generátorokSzerkeszté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.[186]

ElnevezéseSzerkeszté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.[187] 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.[187][188] A hivatalos Python dokumentáció is sok helyen hivatkozik a Monthy Pythonra.[189][190]

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égeSzerkeszté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.[191] 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.[192]).[193]

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

A Pythont használó nagy szervezetek közé tartozik a Wikipédia, Google, [195]Yahoo!,[196] CERN,[197] NASA,[198]Facebook,[199] Amazon, Instagram,[200] Spotify,[201] és néhány kisebb, mint az ILM[202] és az ITA.[203] A Reddit nagy többségében Pythonban íródott.[204]

FelhasználásaSzerkesztés

 
A Python felhasználása

A Python lehet webalkalmazások szkriptnyelve, például a mod_wsgi segítségével használható Apache webszerverhez.[205] A Web Server Gateway Interface egy szabványos API, szintén erre a célra. A webes keretrendszerek, mint 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ú programozás megkönnyítésére a NumPy, SciPy, és Matplotlib a legelterjedtebbek.[206][207] 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.[208] 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.[209]

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

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.

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,[215] Inkscape, Scribus és Paint Shop Pro;[216] 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.[217] 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.[218]

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

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

Ismertebb Pythonra épülő alkalmazásokSzerkeszté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 modellező-animációs program, ami ezért GE-ként is működik, Pythonból scriptelhető

Befolyásolt nyelvekSzerkesztés

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

  • Boo: a behúzás szerepe, hasonló szintaxissal és objektummodellel.

[224]

  • Cobra: hasonló szintaxis. Az Acknowledgements a befolyásoló nyelvek közül elsőként említi.

[225]

  • A JavaScriptre forduló CoffeeScript szintaxisát a Python ihlette.
  • ECMAScript/JavaScript: iterátorok és generátorok[226]
  • GDScript, egy Pythonhoz hasonló nyelv. Ez van beépítve a Godot játékmotorba.[227]
  • Go, melyet arra terveztek, hogy felgyorsítsák a fejlesztést dinamikus nyelveken, mint például Python.[228] A tömbök is a Pythonhoz hasonlóan szeletelhetők.
  • Groovy, a Python filozófiájának átültetésére Javába[229]
  • Julia, melyet olyan használhatóra terveztek általános programozáshoz, mint a Python.[28]
  • Nim, a behúzások használatában és szintaxisában[230]
  • 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.[231]
  • Swift, szintaxisában.[232]

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

JegyzetekSzerkeszté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 3.11 Released With Big Performance Improvements, Task Groups For Async I/O (angol nyelven), 2022. október 24. (Hozzáférés: 2022. október 25.)
  6. Python 3.11 released (angol nyelven), 2022. október 24. (Hozzáférés: 2022. október 25.)
  7. Python 3.11.0 is now available (angol nyelven), 2022. október 24. (Hozzáférés: 2022. október 25.)
  8. Python 3.12.0 alpha 2 released (angol nyelven), 2022. november 15. (Hozzáférés: 2022. november 16.)
  9. 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.)
  10. 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.)
  11. Starlark Language. [2020. június 15-i dátummal az eredetiből archiválva]. (Hozzáférés: 2019. május 25.)
  12. 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).”
  13. 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.)
  14. 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.”
  15. 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.”
  16. 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.” 
  17. 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”
  18. 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.”
  19. 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”
  20. 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.”
  21. 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.)
  22. 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.”
  23. 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.”
  24. CoffeeScript. coffeescript.org . [2020. június 12-i dátummal az eredetiből archiválva]. (Hozzáférés: 2018. július 3.)
  25. 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.)
  26. 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.)
  27. 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.)
  28. 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 [...]”
  29. 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.)
  30. 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 
  31. 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.”
  32. test — Regression tests package for Python — Python 3.7.13 documentation. docs.python.org . (Hozzáférés: 2022. május 17.)
  33. platform — Access to underlying platform's identifying data — Python 3.10.4 documentation. docs.python.org . (Hozzáférés: 2022. május 17.)
  34. 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.)
  35. What is Python Good For? (angol nyelven). General Python FAQ. Python Foundation. (Hozzáférés: 2008. szeptember 5.)
  36. General Python FAQ. python.org. Python Software Foundation. (Hozzáférés: 2009. június 27.)
  37. What is Python? Executive Summary (angol nyelven). Python documentation. Python Foundation. (Hozzáférés: 2007. március 21.)
  38. What is Python Good For?. General Python FAQ. Python Software Foundation. (Hozzáférés: 2008. szeptember 5.)
  39. What is Python? Executive Summary. Python documentation. Python Software Foundation. (Hozzáférés: 2007. március 21.)
  40. Kuhlman, Dave: A Python Book: Beginning Python, Advanced Python, and Python Exercises. [2012. június 23-i dátummal az eredetiből archiválva].
  41. 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."
  42. 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.)
  43. Stack Overflow Developer Survey 2022 (angol nyelven). Stack Overflow . (Hozzáférés: 2022. augusztus 12.)
  44. 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.)
  45. 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.”
  46. 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.)
  47. a b c 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.)
  48. The Making of Python. Artima Developer. (Hozzáférés: 2007. március 22.)
  49. A Brief Timeline of Python. Guido van Rossum. (Hozzáférés: 2009. január 20.)
  50. http://docs.python.org/2/faq/general.html#why-is-it-called-python
  51. 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.)
  52. http://www.python.org/download/releases
  53. Guido van Rossum: Kommentar zur Entfernung einiger funktionaler Konzepte (angol nyelven). (Hozzáférés: 2014. augusztus 11.)
  54. A. Kuchling, Moshe Zadka: Dokumentation Python 2.0 (angol nyelven). Python Software Foundation. (Hozzáférés: 2014. augusztus 11.)
  55. 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.)
  56. heise.de: Python 2.6 öffnet Wege zu Version 3 vom 2. Oktober 2008, abgerufen am 4. Oktober 2008
  57. 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.)
  58. 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.)
  59. 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.)
  60. 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.)
  61. 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.)
  62. 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.)
  63. 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.)
  64. 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.)
  65. 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.)
  66. 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.)
  67. 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.)
  68. 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.)
  69. 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.)
  70. 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.)
  71. CVE - CVE-2020-10735. cve.mitre.org. (Hozzáférés: 2022. szeptember 16.)
  72. Python Insider: Python 3.12.0 alpha 1 released. (Hozzáférés: 2022. október 31.)
  73. 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.)
  74. 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.)
  75. 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.)
  76. Contracts for Python. [2020. június 15-i dátummal az eredetiből archiválva]. (Hozzáférés: 2011. szeptember 24.)
  77. PyDatalog. [2020. június 13-i dátummal az eredetiből archiválva]. (Hozzáférés: 2012. július 22.)
  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. Python Cookbook, 2nd Edition. O'Reilly Media, 230. o. (2005). ISBN 978-0-596-00797-3 
  83. Python Culture. ebeab , 2014. január 21. [2014. január 30-i dátummal az eredetiből archiválva].
  84. 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.)
  85. Offizielle Python FAQ, sowie Python Tutorial, 1. fejezet
  86. 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.)
  87. 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']”
  88. The Cobra Programming Language (angol nyelven). cobra-language.com
  89. Boa Constructor home (angol nyelven). boa-constructor.sourceforge.net
  90. 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.)
  91. 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.)
  92. 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.)
  93. 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.)
  94. 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.)
  95. 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.)
  96. 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 
  97. 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.)
  98. Python Documentation - 3. Data Types. (Hozzáférés: 2013. október 7.)
  99. Immutable vs mutable types - Python. (Hozzáférés: 2013. október 7.)
  100. 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.)
  101. 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.)
  102. 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.)
  103. 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”.”
  104. 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.)
  105. Built-in Types. [2020. június 14-i dátummal az eredetiből archiválva]. (Hozzáférés: 2019. október 3.)
  106. 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.)
  107. 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.)
  108. 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.)
  109. round, <https://docs.python.org/py3k/library/functions.html#round>. Hozzáférés ideje: 14 August 2011
  110. round, <https://docs.python.org/library/functions.html#round>. Hozzáférés ideje: 14 August 2011
  111. The C Programming Language, 2nd, 206. o. (1988) 
  112. 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.)
  113. 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.)
  114. 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.)
  115. 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.)
  116. 8. Errors and Exceptions — Python 3.12.0a0 documentation. docs.python.org . (Hozzáférés: 2022. május 9.)
  117. 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.)
  118. division. python.org . [2006. július 20-i dátummal az eredetiből archiválva]. (Hozzáférés: 2014. július 30.)
  119. 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.)
  120. 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.)
  121. 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.)
  122. 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.)
  123. 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.)
  124. 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.)
  125. 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.)
  126. 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.)
  127. 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.)
  128. Beyond the Basic Stuff with Python: Best Practices for Writing Clean Code (en nyelven). No Starch Press, 322. o. (2020). ISBN 978-1-59327-966-0 
  129. a b 9. Classes — Python 3.7.0 documentation. docs.python.org. (Hozzáférés: 2018. szeptember 1.)
  130. 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.)
  131. 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.)
  132. 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.)
  133. Modulecounts. Modulecounts , 2022. november 14. [2022. június 26-i dátummal az eredetiből archiválva].
  134. Canopy. www.enthought.com . [2017. július 15-i dátummal az eredetiből archiválva]. (Hozzáférés: 2016. augusztus 20.)
  135. 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.)
  136. 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.)
  137. PEP 7 – Style Guide for C Code | peps.python.org. peps.python.org . (Hozzáférés: 2022. április 28.)
  138. 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.)
  139. 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.)
  140. 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.)
  141. Python 2.5 internals. [2012. augusztus 6-i dátummal az eredetiből archiválva]. (Hozzáférés: 2011. április 19.)
  142. history [vmspython]. www.vmspython.org . [2020. december 2-i dátummal az eredetiből archiválva]. (Hozzáférés: 2020. december 4.)
  143. 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.)
  144. 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.)
  145. 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.)
  146. Download Python (angol nyelven). Python.org . [2020. december 8-i dátummal az eredetiből archiválva]. (Hozzáférés: 2020. december 13.)
  147. PyPy compatibility. Pypy.org. [2020. június 6-i dátummal az eredetiből archiválva]. (Hozzáférés: 2012. december 3.)
  148. Team, The PyPy: Download and Install (angol nyelven). PyPy , 2019. december 28. (Hozzáférés: 2022. január 8.)
  149. 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.)
  150. 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.)
  151. 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.)
  152. 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.) 
  153. 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.)
  154. 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.)
  155. 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.)
  156. Brython. brython.info . [2018. augusztus 3-i dátummal az eredetiből archiválva]. (Hozzáférés: 2021. január 21.)
  157. 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.)
  158. 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.)
  159. 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.)
  160. 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.)
  161. 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.)
  162. Archived copy. [2021. április 18-i dátummal az eredetiből archiválva]. (Hozzáférés: 2021. január 20.)
  163. The Python → 11l → C++ transpiler
  164. google/grumpy, 2020. április 10. [2020. április 15-i dátummal az eredetiből archiválva]. (Hozzáférés: 2020. március 25.)
  165. Projects. opensource.google . [2020. április 24-i dátummal az eredetiből archiválva]. (Hozzáférés: 2020. március 25.)
  166. 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.)
  167. 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].
  168. IronPython.net /. ironpython.net . [2021. április 17-i dátummal az eredetiből archiválva].
  169. Jython FAQ. www.jython.org . [2021. április 22-i dátummal az eredetiből archiválva]. (Hozzáférés: 2021. április 22.)
  170. Murri, Riccardo (2013). „Performance of Python runtimes on a non-numeric scientific code” European Conference on Python in Science (EuroSciPy).. 
  171. The Computer Language Benchmarks Game. [2020. június 14-i dátummal az eredetiből archiválva]. (Hozzáférés: 2020. április 30.)
  172. 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.)
  173. 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.)
  174. 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.)
  175. Moving Python's bugs to GitHub [LWN.net]
  176. 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.)
  177. 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.)
  178. 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.)
  179. 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.)
  180. 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.)
  181. 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.)
  182. 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.)
  183. 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.)
  184. 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.)
  185. 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.)
  186. 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.)
  187. 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.)
  188. 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.)
  189. Learning Python: Powerful Object-Oriented Programming (en nyelven). O'Reilly Media, Inc., 17. o. (2009). ISBN 9781449379322 
  190. Python (en nyelven). Peachpit Press, xv. o. (2002). ISBN 9780201748840 
  191. 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.)
  192. 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.)
  193. 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.)
  194. 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.)
  195. 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.)
  196. 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.)
  197. (2006. július 31.) „Python : the holy grail of programming”. CERN Bulletin (31/2006), Kiadó: CERN Publications. (Hozzáférés ideje: 2012. február 11.)  
  198. 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.)
  199. 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.)
  200. 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.)
  201. 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.)
  202. 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.)
  203. 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.)
  204. 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
  205. 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.)
  206. {cite journal |last=Oliphant |first=Travis |title=Python for Scientific Computing |journal=Computing in Science and Engineering |volume=9 |issue=3 |pages=10–20 |year=2007 |url=https://www.h2desk.com/blog/python-scientific-computing/ |doi=10.1109/MCSE.2007.58 |citeseerx=10.1.1.474.6460 |bibcode=2007CSE.....9c..10O |s2cid=206457124 |access-date=10 April 2015 |archive-date=15 June 2020 |archive-url=https://web.archive.org/web/20200615193226/https://www.h2desk.com/blog/python-scientific-computing/ |url-status=live }}
  207. (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 ideje: 2014. július 7.)  
  208. 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
  209. 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.)
  210. 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.)
  211. 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.)
  212. 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.)
  213. 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.)
  214. 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.)
  215. 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.)
  216. jasc psp9components. [2008. március 19-i dátummal az eredetiből archiválva].
  217. 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.)
  218. Python Language Guide (v1.0). Google Documents List Data API v1.0. [2010. július 15-i dátummal az eredetiből archiválva].
  219. 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.)
  220. Immunity: Knowing You're Secure. [2009. február 16-i dátummal az eredetiből archiválva].
  221. Core Security. Core Security . [2020. június 9-i dátummal az eredetiből archiválva]. (Hozzáférés: 2020. április 10.)
  222. 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.)
  223. 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.)
  224. 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.)
  225. 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.)
  226. 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.)
  227. 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.)
  228. 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.) 
  229. 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.)
  230. 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).”
  231. 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.)
  232. 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.”
  233. 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.)
  234. 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.)
  235. 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.)

ForrásokSzerkesztés

FordításSzerkeszté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 jelzi, nem szolgál a cikkben szereplő információk forrásmegjelöléseként.

További információkSzerkesztés

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

Kapcsolódó szócikkekSzerkesztés