**Python** interpretatutako programazio lengoaia bat da, ardatz bezala sintaxi garbi, erraz eta irakurgarri bat duelarik.

Paradigma anitzeko lengoaia bat da, objetuetara zuzenduriko programazioa, programazio inperatiboa eta, neurri txiki batean, programazio funtzionala jasaten ditu eta. Lengoaia interpretatu eta multiplataforma da.

Python Software Foundation -ek administratzen du. Kode zabaleko lizentzia bat dauka, Python Software Foundation License izenekoa, GNU-ren 2.1.1 lizentzia publiko orokorrarekin bateragarria.

Historia
--------

### Sorrera

Python 80ko hamarkadaren bukaeran izan zen sortua Herbehereetako Matematika eta Informatikako zentroan (CWI, Centrum Wiskunde & Informatica) Guido van Rossum-en eskutik. Lengoaia ABC lengoaiaren ondorengo gisa sortu zen, salbuespenak (exception, ingeleraz) kudeatu eta Amoeba sistema eragilearekin elkar eragin zezakeen hizkuntza zen.

Guido van Rossum
Lengoaiaren izena Monty Python umoristen omenez dago jarrita, hauekiko sortzailearen afizioa zela eta.

Python-en egile nagusia van Rossum da, eta lengoaiaren norabidea etengabe erabakitzen egiten duen lana errekonozitu egiten zaiola-eta askotan BDFL edo *Benevolent Dictator for Life* gisa ezaguna da.2018ko uztailaren 12 utzi zion ardura hori baina.

1991an, van Rossum-ek 0.9.0 bertsioaren kodea argitaratu zuen *alt.sources*-en. Garapen-egoera hartan bazeuden herentziadun klaseak, salbuespenen kudeaketa, funtzioak eta `str, list` eta `dict` bezalako mota modularrak. Hasierako argitaratze hartaz gain, *Modula-3* ren antzerakoa zen modulu-sistema bat argitaratu zuen; van Rossum-ek esan zuen modulu hura "Python-en programazio-unitate handiena" zela. Pythonen salbuespenak tratatzeko modua *Modula-3-*renaren oso antzerakoa da, `else` klausularen gehigarriarekin ere. 1994an *com.lang.python* eztabaida-foroa sortu zen, Pythonen erabiltzaile-komunitatean itzelezko hazkuntza ekarri zuena.

### Python 1.0

Pythonen 1.0 bertsioa 1994ko urtarrilean plazaratu zen. Argitaratze horrekin batera programazio funtzionalaren hainbat erreminta berriak etorri ziren izan ziren: `lambda`, `reduce`, `filter` eta `map`. Van Rossumek hau esan zuen: "Duela 12 urte, reduce(), filter() eta map() funtzionalitateak falta zirenean, hutsune horiek betetzeko adabakiak bidali zituen Lisp-eko hacker batek". Emailea Amrit Prem izan zen; argitaratze oharretan Lisp-i buruz ez da inolako aipamenik egiten baina.

CWI-k argitaratutako Python azken bertsio askea Python 1.2 izan zen. 1995ean, van Rossum-ek lengoaian lanean jarraitu zuen Virginiako *Corporation for National Research Initiatives*-en (CNRI), lengoaiaren zenbait bertsio berri argitaratu zituen bertan.

CNRI-an zegoelarik, van Rossum-ek *Computer Programming for Everybody* (CP4E) ekimena abiarazi zuen, programazioa jendearentzat ulergarriago eta erabilgarriago egiteko asmoz. Python-ek *, bere sintaxi garbi eta erraza zirela-eta, programazioa irakasteko alfabetizatze-kanpaina* hartan zeresan handia eman zuen. DARPA agentziak babestu zuen proiektua. 2007an CP4E kanpainari utzi zion.

Python 1.6.1 eta Python 1.6 bertsioak oso antzezekoak ziren, errore batzuen konponketekin eta GPLrekin bateragarria den lizentzia berri batekin.

### Python 2.0

2000. urtean Python garapen-taldearen gehiengoa BeOpen.com-era pasatu zen, BeOpen PythonLabs taldea sortuz. CNRIk 1.6 bertsioa publikoa izatea eskatu zuen, garapen horretan aritu ziren taldeak CNRItik alde egin zuen arte. BeOpen.com-en argitaratze bakarra Python 2.0 izan zen. Honen ostean, Guido van Rossum eta PythonLabs-eko gainontzeko garatzaileak Digital Creations taldean batu ziren berriro.

Python 2.0-k Haskell lengoaia funtzionalaren ezaugarri nagusi bat hartu zuen: konpresio bidezko listak. Egitura horretarako Python sintaxiak Haskell lengoaiaren itxura du, desberdintasun txiki batzuk ezik. Python 2.0-k, gainera, zabor-biltze sistema bat garatu zuen, erreferentzia ziklikoak batu eta bildu ahal izateko.

Argitalpen bikoitz horren ostean, eta van Rossum-ek CNRI utzi ostean (software komertzialeko garatzaileekin lan egiteko), Python GNU GPLn oinarritutako softwarearekin erabiltzeko ideia zabaldu zen. Ordura arte erabilitako lizentziak, Python License-ak, lizentzia Virginiako estatuak kudeatzen zuela adierazten zuen klausula bat zuen, eta hori ez zenbateragarria GPL lizentziarekin. CNRIk eta FSFk (Free Software Foundation) bat egin zuten Pythonen lizentzia GPL lizentzia librearekin bateragarria egiteko. 2001. urtean, van Rossumi *FSF Award for the Advancement of Free Software* saria eman zioten.

Python 2.1 bertsioa Python 1.6.1 eta Python 2.0-ren lan deribatua da. Bere lizentzia Python Software Foundation License bezala izendatu zen. Python 2.1 alfa bertsiotik aurrerako kode, dokumentazio eta espezifikazio gutziak Python Software Foundation (PSF) dute jabetzat, 2001 ean irabazasmorik gabeko elkartea.

Python 2.2 bertsioaren berritasun nagusi bat Pythoneko moten eta klaseen hierarkia batean bateratzea izan zen. Bateratzeak objektu-eredu kontsistente eta puru bat ekarri zuen. Icon lengoaian oinarritutako generatzaileak ere gehituak izan ziren bertsio berri honetan.

Python liburutegi estandarraz gain, mota askotako gehigarriek Java-ren eragin handi bat dute: `logging` paketea, 2.3 bertsioan gehitua izan zena, log4j-en oinarritua dago; SAX parserra, 2.0 bertsioan gehitu zen.

### Python 3.0

Formula bat kalkulatzen duen Python programa sinple bat.
Formula bat kalkulatzen duen Python programa sinple baten exekuzioaren adibidea.
Python 3.0 (Python 3000 edo py3k ere deitua) 2008an sortu zen. Bertsio hark funtsezko aldaketa batzuk ekarri zituen, baina ez zen bateragarria aurreko bertsioaren programekin. Oso aldaketa tipikoa da `print`funtzioaren argumentuak parentesien arte idatzi behar direla 3. bertsioan baina ez 2. bertsioan. Oso lagungarri diren zenbait programa-liburutegi oraindik Python2 bertsioan bakarrik eskaintzen dira. Python 3.0 bertsioaren ezaugarri berri asko Python 2 lengoaiara ere eraman izan ziren geroago eta Python 2.7 bertsioa sortu zuten horrela.

Ezaugarriak
-----------

Paradigma anitzeko programazio-lengoaia da Python. Objektuetara bideratutako programazioa edo programazio egituratua, baita programazio funtzionala edo aspektuetarako bideratutako programazioa baimentzen baititu. *Programazio logikoa* eta *kontratu bidezko diseinua* ere erabil daitezke lengoaiaren luzapenen bitartez. Lengoaiaren ezaugarri horiek kontuan hartzen dira beste lengoaiekin konparatzen denean.

Python bidez idatzitako kodea oso trinko eta irakurgarria izan ohi da, horri begira diseinatuta dago-eta. Trinkoa da, beste arrazoi batzuez gain duen ezaugarri bati esker: aldagaiak ez dira deklaratu/erazagutu behar; erabili ahala esleitzen baitzaie mota.

Python lengoaia sinple, ulergarria eta ahaltsua da. Lengoaiak bere barruan dakarren funtzionalitatea ez da oso zabala, baina oso erraza da oinarrizko muin hori zabaltzea. Modulu eta metodo ahaltsu asko erraz aurkitzen dira sarean, eta gehienetan lizentzia libre batekin. Horrela, esate baterako, erraz txertatu daiteke interfaze programagarria behar duten aplikazioetan. Bereziki egokia da string-en tratamendu sakona eta hiztegi-bilaketa asko egin behar dituzten programazio-problemak bideratzeko. 

Lengoaia interpretatua da, erabiltzeko erraza hasieran. Aginduak banan-banan egikaritu daitezke aldez aurretik konpiladore batek programa osoa konpilatu gabe.

Python software libre eta irekia da. Mozkin-asmorik gabeko fundazio batek (Python Software Foundation) kudeatzen du Python lengoaiaren ohiko inplementazioa (CPython).

Testu-tratamenduetan oso erabilia den Perl lengoaiaren filosofia eta Pythonena nahiko diferenteak dira programak idazteko filosofik definitzeko orduan. Perl lengoaian hainbat modu diferente egoten dira tratamendu bera lortzeko (*There is more than one way to do it*), baina Python horren kontra doa eta saiatzen da adierazpide bakar eta intuitiboa definitzen (T*here should be one—and preferably only one—obvious way to do it*). Helburua da programa sinple, ulergarri eta ahaltsuak lortzea.

Python Hello word
### Datu motak

Aldagaiei hasierako balio bat esleitu ohi zaie, horrela aldagaiari balioaren mota hori lotzen baitzaio. Esleipenak idazteko eredua hau da:

```
aldag\_izena = balioa

```

#### Datu mota bakunak

Python-ek ondoko oinarrizko datu-motak ezagutzen ditu:

* Karaktere-kateak edo *string*ak (*str*). Adibidez: *'Kaixo'* edo *'emaitza' edo "Agur".* Komatxo sinpleak zein bikoitzak erabil daitezke. Kate hutsa ere izan daiteke.
* Osoko zenbakiak (*int*). Adibidez: *12* edo *-5.*
* Zenbaki errealak (*float*). Adibidez: *3.14* edo *-0.5*.
* Boolearrak (*bool*). Bi balio baino ez ditu onartzen *True* (egiazkoa) eta *False* (faltsua).
* Zerrendak (zenbakienak eta karaktere-kateenak). Adibidez: *[31, 28, 31, 30]* edo *['positibo', 'negatibo', 'zero'].* [] zerrenda hutserako erabiltzen da, hasieraketetan batez ere.
* Baliorik gabekoak (N*one*)

|  |  |  |
| --- | --- | --- |
| **Datu mota** | **ADIBIDEA** | **ESANAHIA** |
| str | 'Euro' | karaktere-katea |
| int | 1024 | zenbaki osoa |
| float | 3.14 | zenbaki erreala; kontuz, puntu hamartarra (ez koma) |
| bool | true | *egiazkoa* edo *faltsua* |
| None |  | mota hutsa |

#### Datu mota egituratuak

Datu mota egituratu erabilienak zerrendak, hiztegiak eta tuplak dira.

### Agindu motak

Oinarrizko aginduak esleipena (*aldag\_izena* = *balioa*) eta datu-idazketak (*print*) dira.

Datuen irakurketa *input* funtzioa erabiliz egiten da, ez da egiten agindu baten bitartez beste lengoaia askotan bezala.

Adibidez, 

```
# r erradioa duen zirkulu baten azalera kalulatzea
r = int(input("Idatzi zirkuluaren erradioaren luzera:"))
azalera = 3,1416 \* R \*\* 2;
print("Zirkularen azalera:", azalera)

```

### Kontrol-egiturak

#### Baldintzapeko egiturak

*if* egiturak balio du agindu-multzo bat soilik kasu batzuetan egikaritzeko, baldintza bat betetzen denean, alegia. Kontrol-egitura hau programazio-lengoaia guztietan dago. Hala ere, Python lengoaian erabiltzen denean idazkeran (sintaxian) bi diferentzia azpimarratu behar dira:

* Baldintza ondoren ':' karakterea idatzi behar da, eta *else* hitz erreserbatuaren ondoren ere bai.
* Tabulazioaren erabilera oso zurruna da Python-en, programako blokeen egituraren ondo islatu behar da tabulazioaren bitartez. Agindu-bloke berri bat tabulazio batez bereizten da, eta blokeko agindu guztiak lerrokatuta azaldu behar dira tabulazio-maila berdinarekin.

Egituraren eredua hau da:

```
if <baldintza> :
    <aginduak>
else:
    <aginduak>

```
Baldintza espresio boolear baten bidez adierazten da. Baldintza betetzen bada segidan duen agindu multzoa egikarituko da. Baldintza bete ezean, *else* adarra baldin badago adar horri dagokion agindu-multzoa egikarituko da. Ez badago *else* adarra, berriz, egitura honetan ez da ezer egingo.

*Hautazkoa da else* adarra idaztea. Adibidez, ondoko programa-zatian agertzen den *if* egitura sinplea da:

```
if n < 0:
   n = -n # Balio absolutua

```
Aldiz, honako zati honetan egitura osoa dugu:

```
# zenbaki handiena kalkulatzeko
a = int(input("sakatu bi zenbakietako bat: "))
b = int(input("sakatu bestea: "))
if a > b:
   hand = a
else:
   hand = b
   print("handiena:", hand)

```
Ondoko ñabardura hauek hartu behar dira kontuan:

* Baldintzazko espresioan berdintasuna adierazteko == eragilea erabili behar da eta ez = eragilea (esleipenetan bakarrik erabiltzen da hori).
* != eragilea erabiltzen da balio desberdinak bereizteko.
* Baldintzazko espresioa *and*, *or* eta *not* eragileekin osaturiko baldintza konposatua izan daiteke.
* Eragilerik erabiltzen ez bada, alegia, aldagai baten izena besterik erabiltzen ez bada *if* egituraren baldintza gisa, emaitza egiazkoa izango da aldagaiaren balioa *None* ez den bitartean.
* *if* egitura baten barruan beste *if* egitura bat egon daiteke, horrelakoetan *if habiatua* esaten diogu bigarrenari. Gainera, *elif* ere erabili daiteke *else* adarraren ordez "*else if*" adierazteko. Horrela, ondoko kodean *if* baten barruan hiru adar agertzen dira:

```
if n < 0:
	print ("negatiboa")
elif n==0:
	print ("zero")
else:
	print ("positiboa")

```

#### Iterazio-egiturak

##### *while* kontrol-egitura

Egitura errepikakor orokorrena da *while*. Honela erabiltzen da:

```
while <jarraitzeko-baldintza> :
   <aginduak>

```

  

Jarraitzeko baldintza ebaluatu ondoren, *egiazkoa* (ez *None*) lortu bada, egiturari dagozkion agindua edo agindu-multzoa exekutatuko da, eta gero baldintzako espresioa berriro ebaluatzera itzuliko da, begizta osatuz. Espresioaren emaitza *faltsua* denean, *while* egitura osoaren exekuzioa bukatutzat emango da eta hurrengo sententziara (tabulazioaren arabera) pasatuko da, *while* egiturako gorputza berriro exekutatu gabe.

Python programen idazkeraren berezitasunak kontrol-egitura honetan ere azaltzen dira: tabulazioa zurruna da eta ':' karakterea jarri beharra dago baldintza ondoren.

Zenbaki baten faktoriala kalkulatzen duen programan *while* egitura bat ikus daiteke. Bertan, egitura errepikakorraren baldintza *i<=n* da, eta bloke bat osatzen duten bi sententziek osatzen dute gorputza. *While* egitura errepikakorra *if* egitura baten barruan dago, *else* adarrean hain zuzen. Ohartzekoa da tabulazioa nola dagoen eginda: ezker-ezkerrean hasieraketa eta *if* egitura, koxka bat eskuinerantz sententzia gehienak *while* egitura barne, eta hirugarren mailan errepikatuko diren bi sententziak. Azken sententzia (*print*) ez da errepikatuko inolaz ere, 2. mailan dagoelako.

```
# n faktoriala
n=int(input('Sakatu zenbaki bat, bere faktoriala kalkulatzeko: '))
if n <= 0:
    print ("Errorea: zenbakia positiboa behar da");
else:
    fakt = 1
    i = 2
    while i <= n:
         fakt = fakt \* i	
          i = i+1
    print (fakt)

```

##### *for .. in* kontrol-egitura

  

Egitura errepikakor honekin posible da zerrenda eta datu-egitura batzuetan (zerrendak, bektoreak edo matrizeak, batez ere) elementu bakoitzerako agindu batzuk errepikatzea. Honela idazten da:

```
for <aldagaia> in <zerrenda> :
   <aginduak> # aldagaia erabiliko da elementua aipatzeko

```
C bezalako lengoaiatan ez dagoen egitura hau oso erosoa da zerrendak eta hiztegiak lantzeko. Adibidez, programa honek zerrenda bateko elementu guztiak idazten ditu:

```
#Zerrenda bateko elementu guztiak for .. in kontrol-egitura batekin
zerrenda = ['negatiboa','zero','positiboa']
for elem in zerrenda:
    print ("Osagaia:", elem)

```
Programa horren exekuzioak honako irteera hau sortuko luke:

```
>>>
Osagaia: negatiboa
Osagaia: zero
Osagaia: positiboa

```

Beste lengoaia batzuetan ohikoa da *for* kontrol-egitura kopuru batez gobernatzea. C lengoaiaz, adibidez, *for(i=1;i<n;i++)* moduko egitura oso ohikoa da. Pythonez hori egiteko *range* erabiltzea da irtenbide zuzenena. Zerrenda baten osagai guztiei edo *string* baten karaktere guztiei dagokien iterazioa kontrolatzeko *range* funtzioa erabili ohi da. Osagai kopurua, zenbaki bat alegia, da *range* funtzioaren parametroa, emaitza 0 eta balio horren arteko osoko balio guztiak izanik. *for in range()* ohiko egitura bihurtuko zaigu. Adibidez:

```
# String baten karaktereak kontatzea range funtzioa erabiliz
katea=input('Sakatu karaktere-katea: ')
kar=input('Sakatu kontatzeko karakterea: ')
luzera=len(katea)
kont = 0
for i in range(luzera):
    if katea[i] == kar:
        kont = kont+1
print(kar, 'karakterearen kopurua:', kont)

```

Eta hau da programa horrren exekuzioaren adibide bat:

```
>>>
Sakatu karaktere-katea: amama etorri zen atzo
Sakatu kontatzeko karakterea: a
a karakterearen kopurua: 4

```
  

##### *break* eta *continue aginduak*

*break* sententziak begiztaren exekuzioan bat-bateko amaiera eragiten du, begizta ondoko hurrengo blokera joanez. "AGUR" (letra larriz) idatzi arte oihartzunarena egiten duen programa da hau:

```
print("Oihartzuna. AGUR sakatu arte ez da ondoko begizta bukatuko");
while True:
    mezu=input("Zure mezua:")
    if (mezu == "AGUR"):
        break;
    print (mezu)
print("AGUR. Bukatu da.")

```
Hala ere, *break* eta *continue aginduen erabilera ez* da oso komenigarria, programaren exekuzioaren ulermena eta egiaztapena zailtzen du eta. Soilik oso salbuespenezko kasuetan komeni da erabiltzea. Aurreko programa honela idatz daiteke erraz *break* eta *continue* agindurik gabe:

```
print("Oihartzuna. AGUR sakatu arte ez da ondoko begizta bukatuko");
mezu=input("Zure mezua:")
while (mezu != "AGUR"):
    print (mezu)
    mezu=input("Zure mezua:")
print("AGUR. Bukatu da.")

```

### Azpiprogramak, funtzioak

dagoen Python lengoaian *funtzioak* dira azpiprogramak definitzeko baliabide bakarra. Berdin definitzen dira programan balio bat itzultzeko erabiltzen diren azpiprogramak (beste lengoaia batzuetan *funtzioak* horiek dira) eta agindu moduan erabiltzen direnak (beste lengoaia batzuetan *prozedura* edo *azpierrutina* deituak).

*Bi* hitz erreserbatu erabiltzen dira funtzioen definizioan: *def* definizioari hasiera emateko, eta *return* behar izatekotan emaitza itzultzeko. Beste sententzia batzuetan bezala (*if* kontrol-egituran, esaterako) definizioaren lehen lerroaren bukaeran ':' karakterea zehaztu behar izan da.

```
# Zenbaki baten faktoriala kalkulatu funtzio bat erabiliz
# Funtzioaren definizioa
def faktorial (n):
    fakt = 1;
    i = 2;
    while i <= n:
        fakt = fakt \* i
        i=i+1
    return (fakt)
# Programa nagusia, funtzioa erabiltzen duena
m=int(input('Idatzi zenbaki bat, bere faktoriala kalkulatzeko: '))
if m <= 0:
    print ("Errorea: zenbaki positiboa behar da")
else:
    print(faktorial(m))

```

Erabilera
---------

### Erabilera-estatistikak

2003az gero Python etengabe egon da gehien erabilitako 10 lengoaien artean TIOBE programazio-komunitatearen sailkapenean, eta *urteko programazio-lengoaia* izendatu zuten 2007, 2010 eta 2018 urteetan. 2015eko irailean bostgarrena izan zen sailkapen horretan. eta 2018an hirugarrena.

### Enpresa handietan

Enpresa handi askotan erabiltzen da Python, besteak beste hauetan: Google, Yahoo, CERN eta NASA.

### Aplikazioetan

Gutxienez aplikazio hauen programazioan erabili da Python lengoaia:

* Anaconda (Python banaketa)
* Arduino
* Chromium
* Cinnamon
* CUDA
* Dropbox
* Ethereum
* Git
* LOLCODE
* Markdown
* MATE
* MongoDB
* Natural Language Toolkit
* Nmap
* Odoo
* OpenShot
* Quine (programa)
* R (programazio-lengoaia)
* Rhythmbox
* Spotify
* Sublime Text
* Tor (nabigatzailea)
* Virtaal
* VirtualBox
* Wine-Doors
* Word2vec
* WordNet
* Zim (softwarea)

Hizkuntzalaritzan eta gizarte zientzietan ere hainbat erabilera izan ditu.

Sintaxia
--------

Idazkera trinkoa du, beste arrazoi batzuez gain duen ezaugarri bati esker: aldagaiak ez dira deklaratu/erazagutu behar; erabili ahala esleitzen baitzaie mota. Hau errore-iturri arriskutsua izan badaiteke ere, interpretatzaileak errore asko detektatzen ditu exekuzio-garaian.

Bestalde interpretazioa eraginkorra izan dadin programen formatua eta programazio-egitura batzuk zurrun samarrak dira. Hauek dira kontuan hartzeko xehetasun garrantzitsu batzuk:

* Tabulazioa. Ikusiko denez agindu-blokeen mugak tabulazio bidez antzematen ditu interpretatzaileak (C lengoaiako giltzen ordez, adibidez). *`Tab`* teklarekin edo zuriuneekin sortuko da, baina modulu berean era kontsistentean egin behar da, beti berdin, edo beti*`Tab`* bitartez edo beti zuriuneen bitartez.
* ':' karakterea: programazio-egitura batzuetan (*`if`*, *`else`*, *`while`* eta *`for`* esaterako) karaktere hori jarri behar da lehenengo lerroaren bukaeran egiturako espresioaren ondoren (baldintza-edo). Beste programazio-lengoaietan aritutakoei ahaztu ohi zaie hasieran.
* Parentesien erabilera. Baldintzak ez dira derrigorrez parentesi artean idatzi behar, baina funtzio-deietan beharrezkoak dira. Python2 lengoaian ez ziren beharrezkoak funtzio deietan, baina Python3an bai. Adibidez, inprimatzeko erabiltzen den *`print`* funtzioan argumentuak parentesi artean zehaztu behar dira beti, baina ohitura zaharrak direla-eta horiek ahaztea ohiko errorea izaten da.

Programa adibideak
------------------

Kaixo mundua adibidea (python2):

```
print "Kaixo mundua!"

```

Kaixo mundua adibidea (python3):

```
print ("Kaixo mundua!")

```

Zenbaki baten faktoriala (python3):

```
n=int(input('Sakatu zenbaki bat, bere faktoriala kalkulatzeko: '))
if n <= 0:
    print ("Errorea: zenbakia positiboa behar da");
else:
    fakt = 1
    i = 2
    while i <= n:
       fakt = fakt \* i	
       i = i+1
    print (fakt)

```

Programatzeko garapen plataformak eta liburutegiak
--------------------------------------------------

* Spyder kode irekiko plataforma anitzetarako garapen integraturako ingurune bat da (IDE), Python lengoaiaz zientzia-programazioan aritzeko. Spyderrek Pythonerako hainbat pakete zientifiko ospetsu integratzen ditu, besteak beste, NumPy, SciPy, Matplotlib, pandas, IPython, SymPy eta Cython, baita kode irekiko beste software batzuk ere.  MIT lizentziarekin banatzen da.
* Jupiter Notebook web-zerbitzuak Python programak exekutatu eta garatzeko aukera ematen du sarearen bitartez, norberaren konputagailu edo telefonoan ezer instalatu gabe.
* Anaconda Python banaketa

* Spyder logoSpyder logo
* Keras (sare neuronalak)Keras (sare neuronalak)
* Pytorch (sare neuronalak)Pytorch (sare neuronalak)
* NumpyNumpy
* IPythonIPython
* PandasPandas
* SympySympy
* SciPySciPy

Erreferentziak
--------------

1. 1 2 3 4     *LIBURUA: "Python programazio-lengoaia" – Oinarriak eta aplikazioak.*  (Noiz kontsultatua: 2019-07-04).
2. ↑   Stephenson, Ben.  (2014). *The Python workbook : a brief introduction with exercises and solutions.*  ISBN 978-3-319-14240-1. PMC 902672338. (Noiz kontsultatua: 2021-09-07).
3. ↑   Hunt, John.  (2019). *Advanced guide to Python 3 programming.*  ISBN 978-3-030-25943-3. PMC 1121080214. (Noiz kontsultatua: 2021-09-07).
4. ↑   Downey, Allen,. *Think Python.*  (Second edition, updated for Python 3. argitaraldia) ISBN 9781491939420. PMC 932322857. (Noiz kontsultatua: 2019-10-08).
5. 1 2   «The Making of Python» *www.artima.com* (Noiz kontsultatua: 2019-07-04).
6. 1 2   «General Python FAQ — Python 3.7.4rc2 documentation» *docs.python.org* (Noiz kontsultatua: 2019-07-04).
7. ↑   «1. Whetting Your Appetite — Python 3.7.4rc2 documentation» *docs.python.org* (Noiz kontsultatua: 2019-07-04).
8. ↑   «Guido van Rossum dimite como líder de Python – La mirada del replicante» *web.archive.org* 2018-07-12 (Noiz kontsultatua: 2019-07-04).
9. ↑   «The fate of reduce() in Python 3000» *www.artima.com* (Noiz kontsultatua: 2019-07-04).
10. ↑   «Computer Programming for Everybody» *web.archive.org* 2009-02-23 (Noiz kontsultatua: 2019-07-04).
11. ↑   «Computer Programming for Everybody» *web.archive.org* 2007-03-12 (Noiz kontsultatua: 2019-07-04).
12. ↑   «What's New in Python 2.0» *web.archive.org* 2007-03-29 (Noiz kontsultatua: 2019-07-04).
13. ↑   «History and License — Python 3.7.4rc2 documentation» *docs.python.org* (Noiz kontsultatua: 2019-07-04).
14. ↑   «What’s New in Python 2.2 — Python 3.7.4rc2 documentation» *docs.python.org* (Noiz kontsultatua: 2019-07-04).
15. ↑   **(Ingelesez)** «PEP 282 -- A Logging System» *Python.org* (Noiz kontsultatua: 2019-07-04).
16. ↑   «TIOBE Index | TIOBE - The Software Quality Company» *www.tiobe.com* (Noiz kontsultatua: 2019-10-29).
17. ↑   Hammond, Michael.  (2020). *Python for linguists.*  ISBN 978-1-108-64240-8. PMC 1137212647. (Noiz kontsultatua: 2021-09-07).
18. ↑   Hovy, Dirk.  (2020). *Text analysis in Python for social scientists : discovery and exploration.*  ISBN 978-1-108-87335-2. PMC 1228814422. (Noiz kontsultatua: 2021-09-07).
19. ↑   **(Ingelesez)** «Node.js vs Python: Which backend technology to choose in 2021?» *Insights on Latest Technologies - Simform Blog* 2021-02-19 (Noiz kontsultatua: 2021-08-18).
20. ↑    *Official repository for Spyder: The Scientific Python Development Environment - spyder-ide/spyder.*  Spyder IDE 2019-01-02 (Noiz kontsultatua: 2019-01-02).
21. ↑   Grehan, Rick. «Spyder review» *Techworld* (Noiz kontsultatua: 2019-01-02).

Ikus, gainera
-------------

* Programazio-lengoaien arteko konparazioa
* Spyder (softwarea)
* Pytorch
* Keras

Kanpo estekak
-------------

* **(Ingelesez)** Python lengoaiaren web gune ofiziala
* PYTHON programazio-lengoaia: oinarriak eta aplikazioak liburuko hainbat programaren kodea libreki deskargatzeko gunea
* Sudokuak ebazteko gai den Python programa bat (Igor Leturia, Eibar.org)
* 

|  |  |
| --- | --- |
| Autoritate kontrola | 
* **Wikimedia proiektuak**
* Wd Datuak: Q28865
* Commonscat Multimedia: Python (programming language)
* MediaWiki MediaWiki: Python

---

* **Identifikadoreak**
* BNF: 13560465c (data)
* GND: 4434275-5
* LCCN: sh96008834
* NKC: ph170668
* SUDOC: 051626225

 |

* Wd Datuak: Q28865
* Commonscat Multimedia: Python (programming language)
* MediaWiki MediaWiki: Python