Python (ohjelmointikieli)

**Python** on ohjelmointikieli, jolle on tunnusomaista hyvä luettavuus, korkea abstraktiotaso ja kehittyneet kirjastot monilla eri sovellusalueilla. Python on niin kutsuttu tulkattu kieli, mikä tarkoittaa että sen suorituskyky on alhaisempi kuin käännetyn kielen.

Tioben Tiobe Indexin mukaan Python on maailman suosituin ohjelmointikieli. Pythonilla ohjelmointi on tuottavuudeltaan korkeaa jopa Javaan verrattuna.

Pythonin nousu vakavasti otettavaksi ohjelmointikieleksi käynnistyi Zope- ja Plone-tuotteiden myötä sekä suositun Blender-3D-mallinnusohjelman skriptauskielenä. Toinen tulkattu kieli nimeltä Perl oli suosittu Linux-käyttäjien parissa. Perl avasi tietä Pythonille demonstroimalla tulkatun kielen etuja. Python oli myös skriptikieli ja toimi Perlin korvikkeena. Monet Linux-käyttäjien skriptit alkoivat perustua Pythonille ja Perlin 6-versio ei ollut kovin suosittu. Python kamppaili myös jonkin aikaa Ruby-ohjelmointikielen kanssa, mutta ohitti sen suosiossa.

## Historia

Ensimmäinen versio Python-kielestä syntyi 1980-luvun loppupuolella. Alun perin kieli tehtiin jatkoksi ABC-ohjelmointikielelle korjaamalla siinä havaittuja puutteita ja tuomalla sen piirteisiin muun muassa poikkeusten käsittelyn. Kielen luoja Guido van Rossum on pysynyt kielen kehityksessä mukana koko sen historian ajan keskeisessä roolissa.

Python on alun perin nimetty brittiläisen komediaryhmä Monty Pythonin tunnetun *[[Monty Pythonin lentävä sirkus]]* -televisiosarjan mukaan. Python-nimi koettiin lisäksi tarpeeksi lyhyeksi, yksilöiväksi sekä sopivan mysteeriseksi. Kielen dokumentaation koodiesimerkeissäkin pyritään välttämään liiallista vakavuutta satunnaisilla viittauksilla ryhmän tuotantoon.

Alkuperäisestä Python-kielestä jalostettu Python 2.0 julkaistiin 16. lokakuuta 2000. Kielen toinen täysversio sisälsi useita uusia ominaisuuksia, mukaan lukien täydellisen roskienkeruumekanismin ja Unicode-tuen. Suurin muutos tapahtui kuitenkin itse kielen kehitysprosessissa, jossa Python-yhteisölle annettiin vapaammat kädet osallistua mukaan kielen kehitykseen.

Joulukuussa 2008 ilmestynyt Pythonin versio 3.0 toi kieleen jonkin verran uudistuksia. Periaatteena sen kehityksessä oli vähentää ominaisuuksien rinnakkaisia toteutustapoja poistamalla vanhoja tapoja tehdä asiat. Tästä seuraa, ettei kielen uusin versio ole taaksepäin yhteensopiva, eivätkä 2-versioiden mukaiset ohjelmat siis välttämättä toimi sellaisenaan. Muutoksia ovat muun muassa:
* 
```python
print
```
-avainsanan korvaaminen 
```python
print()
```
-funktiolla
* 
```python
raw_input
```
-funktion korvaaminen yksinkertaisempaan 
```python
input
```
-funktioon
* 
```python
with
```
-lause 
* Jako-operaattorin 
```python
/
```
 toiminnan muuttaminen niin, että 
```python
int/int
```
 palauttaa 
```python
float
```
-tyyppisen luvun. Vanhaa jakolaskuoperaattoria voidaan vielä käyttää kirjoittamalla 
```python
//
```


Version 3 ja sen tuomien muutosten käyttöönottoa on pyritty tukemaan monella tavalla. Versiolla 2.5 voi ottaa jo käyttöön joitain uudistuksia komennolla 
```python
from __future__ import *
```
. Samoin versiolla 2.6 voidaan ottaa käyttöön kaikki version 3.0 tuomat uudistukset. Lisäksi Python 2.6:lla voidaan aktivoida varoitukset vanhanmallisen koodin käytöstä. Tämä helpottaa vanhanmallisen lähdekoodin muuttamista versiolle 3.0 sopivaksi. Lisäksi saatavilla on `2to3` työkalu, joka muuttaa valtaosan 2-sarjan koodista 3-versioon.

## Ominaisuudet

* Tuottavuus: Pythonista on sanottu, että sitä käyttäen ohjelmoija voi olla 10 kertaa tuottavampi kuin Javaa käyttäen ja 100 kertaa tuottavampi kuin C-kieltä käyttäen.
* Luettavuus: Yleisesti ottaen luonteenomaista Pythonille on pyrkimys selkeään ja luettavaan ohjelmakoodiin. Kauneuden ja yksinkertaisuuden tavoitteleminen ovat keskeinen osa kielen suunnittelufilosofiaa.
* Interaktiivisuus: Python on tulkattava kieli, eli ohjelmat ovat valmiita ajettaviksi välittömästi kääntämättä niitä ensin. Erityisesti tämä lisää kielen interaktiivisuutta eli mahdollistaa ohjelmoimisen ja testaamisen lyhyissä sykleissä.
* Paradigmaattisuus: Python-kieltä on kehitetty tukemaan useita ohjelmointitapoja; erityisesti sitä voi käyttää oliopohjaisena, proseduraalisena tai funktionaalisena ohjelmointikielenä. 
* Dynaamisuus: Pythonissa esim. muuttujan tyyppiä ei erikseen määritellä, vaan se määräytyy siihen tallennettavan objektin tyypin perusteella ajon aikana. Python-kääntäjät eivät siis tee tyyppitarkistuksia käännösaikaisesti, jolloin virheet aiheuttavat pääsääntöisesti ajonaikaisia poikkeuksia. Tämä voi helpottaa yksinkertaisempien ohjelmien interaktiivista kehitystä, mutta vaikeuttaa monimutkaisempien ohjelmien kehitystä.

### Interaktiivinen tulkki
Pythonia voi kokeilla helposti interaktiivisen tulkin avulla:

```python
>>> print("Hello, world!")
Hello, world!
>>> 2*42 
84
>>> # Määritellään funktio ja kutsutaan sitä:
>>> def tuntipalkka(palkka, aika):
>>>     return palkka / aika
>>>
>>> tuntipalkka(210, 8)
26.25
```


### Esimerkki syntaksista

```python
n = int(input('Type a number, and its factorial will be printed: '))

if n < 0:
    raise ValueError('You must enter a non-negative integer')

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

print(factorial)
```


## Käyttöaiheet

Python on yksi suosituimmista ohjelmointikielistä, joten sille on kehitetty runsaasti suosittuja kirjastoja, ohjelmistokehyksiä ja rajapintoja, joiden avulla voidaan luoda paljon erilaisia sovelluksia esim. numeerisen laskennan, grafiikan ja web-kehityksen alueilla.

### Numeerinen laskenta ja tieteellinen laskenta
Pythonia voi käyttää aina yksinkertaisesta numeerisesta laskennasta datatieteeseen ja vaativaan tieteelliseen laskentaan (esim. kirjastot NumPy, SciPy, skicit-learn, pandas). Kuvaajien tekemiseen on useita suosittuja kirjastoja (esim. matplotlib, seaborn, plotly, bokeh). Scipy on riippuvainen NumPy kirjastosta. Seaborn perustuu matplotlib kirjastoon. Pythonille on saatavana PyTorch ja TensorFlow-kirjasto, jotka liittyvät koneoppimiseen. Pythonin statsmodels kirjasto sopii esimerkiksi erilaisten tilastollisten mallien estimointiin sekä tilastollisen datan tutkimiseen.

### Kuvat ja graafiset käyttöliittymät
Pythonissa itsessään ei ole mahdollisuutta ladata kuvia tai muuta mediaa, mutta tämä onnistuu esimerkiksi Pygame-moduulin (ks. Simple DirectMedia Layer) tai Pygletin avulla. Python sisältää Tkinter-kirjaston Tk-käyttöliittymäkirjaston käyttöön, mikä tulee Pythonin standardiasennuksessa. Pythonilla voidaan tehdä graafisia käyttöliittymiä muun muassa käyttämällä C++-kielellä kirjoitettua Qt-käyttöliittymäkirjastoa. Myös esim wxPython-, PySide- ja Kivy-kirjastolla voi tehdä GUI-ohjelmia.

### Verkkosivustojen tekeminen WSGI-rajapinnalla
Python on yleistynyt verkkosivustojen ohjelmointikielenä ja Python-kielelle on saatavilla sekä minimaalisia että kehittyneitä kehitysympäristöjä (esim. Django). Pythonia voidaan ajaa palvelimella WSGI (*Web Server Gateway Interface*) -rajapinnan avulla, joka on viime aikoina kehitetty Pythonilla toteutettujen verkkosivustojen suorituskykyistä ajoa varten. Muita kehitysympäristöjä verkko-ohjelmointiin on esimerkiksi web2py ja TurboGears. 

### Rajapinnat yleisille tietokantaohjelmistoille
Pythonille on saatavilla rajapintoja tietokantojen (MySQL, PostgreSQL, SQLite) käsittelyyn. Python 3 sisältää SQLite-tietokannan standardikirjastossa (sqlite3).

### C- ja C++ -laajennukset sekä CUDA
Pythonia voi laajentaa C- ja C++-ohjelmointikielillä. Toisaalta Pythonia voi sisällyttää C- ja C++-kielisiin ohjelmiin skriptikielenä. Mainittavaa on myös kyky vuorovaikuttaa matlabin kanssa. Nvidian grafiikkapiirien CUDA-ohjelmointi on mahdollista Pythonilla; tällä tavalla laskenta voidaan antaa grafiikkapiirin rinnakkain suoritettavaksi.

### Muita käyttökohteita ja kirjastoja
Pythonissa on myöskin PDF-tiedostojen hallintaan tarkoitettu pypdf-kirjasto.Qiskit taas on kvanttiohjelmointiin soveltuva IBM:n kehittämä kirjasto.

## Oliopohjainen ohjelmointi Pythonissa

Python tukee oliopohjaista ohjelmointia (OOP), joka on ohjelmointiparadigma, jossa keskitytään objektien ja luokkien käyttöön. Tämä lähestymistapa on yleinen monissa ohjelmointikielissä. Pythonin avulla ohjelmoijat voivat luoda olioita käyttäjän määrittämien luokkien perusteella. Luokat määritellään Pythonissa class-avainsanalla, ja ne toimivat suunnitelmina olioille, jotka voivat sisältää ominaisuuksia (attribuutteja) ja toimintatapoja (metodeja).

Esimerkiksi:
```python
class Ajoneuvo:
    def __init__(self, merkki, malli):
        self.merkki = merkki
        self.malli = malli
    
    def esittele(self):
        return f"Tämä on {self.merkki} {self.malli}."
```
Yllä olevassa esimerkissä `Ajoneuvo`-luokka sisältää konstruktorin `__init__`, joka asettaa auton merkin ja mallin. `esittele`-metodi puolestaan tulostaa tiedot ajoneuvosta.

Oliopohjaisen ohjelmoinnin (OOP) etuna on erityisesti koodin uudelleenkäytettävyys ja modulaarisuus.

### Periytyminen Pythonissa
Periytyminen on OOP:n keskeinen ominaisuus, joka mahdollistaa uuden luokan määrittämisen olemassa olevan luokan pohjalta. Python tukee periytymistä, jossa aliluokka voi periä yliluokan ominaisuudet ja metodit. Tämä mahdollistaa olemassa olevan koodin uudelleenkäytön ja helpottaa ohjelman laajentamista ja ylläpitoa.

Esimerkki periytymisestä:
```python
class Polkupyora(Ajoneuvo):
    def __init__(self, merkki, malli, vaihteet):
        super().__init__(merkki, malli)
        self.vaihteet = vaihteet

    def esittele(self):
        return f"Tämä on {self.merkki} {self.malli} polkupyörä, jossa on {self.vaihteet} vaihdetta."
```
Tässä esimerkissä `Polkupyora`-luokka perii `Ajoeneuvo`-luokan ominaisuudet ja metodit, mutta lisää siihen oman `vaihteet`-attribuutin ja muokkaa `esittele`-metodia kertomaan myös vaihteista.
```python
ajoneuvo1 = Ajoneuvo("Toyota", "Corolla")
print(ajoneuvo1.esittele())

pyora1 = Polkupyora("Tunturi", "XC", 7)
print(pyora1.esittele())
```
Tässä esimerkissä luodaan `Ajoneuvo`-olio ja `Polkupyora`-olio, ja molempien `esittele`-metodit tulostavat niille ominaiset tiedot.

## Rakenne

Pythonissa kaikki rakenteet määritellään objekteina, joilla on identiteetti (
```python
id()
```
), tyyppi (
```python
type()
```
) ja arvo. Objektin tyyppi kertoo, millaisia operaatioita se sallii ja mitä arvoja se voi saada. Identiteettinä toimii CPython-toteutuksessa objektin osoite muistissa. 

### Paketit ja moduulit
Korkeimmalla hierarkian tasolla Python-ohjelmat muodostuvat paketeista ja moduuleista. Paketit ovat erityisiä moduuleja, jotka vastaavat tiedostojärjestelmän kansioita, siinä missä varsinaiset moduulit vastaavat tiedostoja näissä kansioissa. Moduuleihin viitataan tiedostopolun tavoin mallilla
```python
import paketti.alipaketti.moduuli as mdl
```
 ja niillä on attribuutteja kuten 
```python
__name__
```
 ja 
```python
__file__
```
. Tavallisia paketteja voidaan määritellä lisäämällä kansioon`__init__.py`-niminen tiedosto, jolloin Python tulkitsee tämän kansion Python-paketiksi ja kansiossa olevat Python-tiedostot moduuleiksi. Python-skriptin ajon aloittava moduuli saa nimen
```python
__main__
```
 (eli
```python
__name__ == "__main__"
```
 on totta). 

### Luokat ja funktiot
Python-tulkki ajaa ohjelmat blokkeina yhdessä kehyksessä kerrallaan. Blokkeja muodostavat hierarkisesti skriptit, moduulit, luokat ja funktiot. Nimet näkyvät vain kunkin blokin sisällä, ellei näkyvyyttä olla muutettu
```python
global
```
- tai 
```python
nonlocal
```
-avainsanoilla, tai kyseessä ole funktio, jolloin nimet näkyvät kaikille funktion sisältämille blokeille.

Sanastollisesti kukin koodiblokki koostuu nimistä (
```python
muuttuja
```
), avainsanoista (
```python
for
```
), literaaleista (
```python
2.5
```
), operaattoreista (
```python
==
```
), erottimista (
```python
(
```
) ja näiden muodostamista fyysisistä ja loogisista riveistä. Python käyttää lauseiden ryhmittelyyn sisennystä – ei kaarisulkeita kuten monet muut kielet. Kaksoispisteitä käytetään koottuja lauseita aloitettaessa (esim.
```python
for i in range(10):
```
), mutta muuten uusi rivi ja oikea sisennys riittää rivin ja lauseen päätteeksi.

Luokat määritellään syntaksilla
```python
class Luokka(Yläluokka1, Yläluokka2):
```
 ja luokan sisältö sisennetään tästä, mikä luo paikalliseen ympäristöön luokka-objektin. Luokassa määriteltyjä muuttujia kutsutaan attribuuteiksi ja funktioita metodeiksi. Metodien ensimmäinen argumentti ottaa vastaan aina objektin ja argumentin nimenä käytetään
```python
self
```
, jolloin metodia voidaan kutsua tyylillä
```python
objekti.metodi()
```
. Luokille voidaan antaa erityisiä metodeja, jotka määrittelevät, mitä Pythoniin sisäänrakennetut operaattorit ja funktiot tekevät kyseisen tyypin objekteille (engl. *operator overloading*). Näitä ovat muun muassa
```python
__init__()
```
(alustus),
```python
__str__()
```
(tekstiesitys),
```python
__lt__()
```
(
```python
<
```
-operaattori) ja
```python
__eq__()
```
(
```python
==
```
-operaattori). Uusi luokka voi siten emuloida sisäänrakennettuja tyyppejä, kun sille määritellään tarvittavat erityismetodit.

Funktiot määritellään tyylillä
```python
def func(arg=None, *args, **kwargs):
```
 ja funktion sisältö sisennetään tästä, mikä luo paikalliseen ympäristöön kyseisen nimisen funktio-objektin.
```python
=
```
määrittelee parametrille oletusarvon,
```python
*
```
kaappaa ylimääräiset nimeämättömät argumentit yhteen tuple-objektiin ja
```python
**
```
kaappaa ylimääräiset nimetyt argumentit yhteen sanakirjaan. Funktion argumentiksi voidaan antaa myös lauseke; tällöin vaaditaan, että
```python
*lauseke
```
palauttaa generaattorin ja
```python
**lauseke
```
palauttaa kuvauksen (esim. sanakirjan). Funktioita määritellessä tyyppivihjeet ovat muotoa
```python
def func(x: Tyyppi) -> Tyyppi:
```
. Ennen funktion määritelmää voi lisäksi olla useita ns. decorator-lauseita – mallia
```python
@deco(arg)
```
– jotka ottavat funktion argumenttina ja palauttavat sen jollakin tavalla muunnettuna.

### Kootut lauseet
Luokkien ja funktioiden lisäksi koottuja lauseita ovat 
* toistamiseen
```python
for x in y
```
 tai 
```python
while
```
 ja näissä
```python
break
```
 ja 
```python
continue
```

* ehdolliseen suorittamiseen perinteinen
```python
if..elif..else
```
tai hahmonsovituksena
```python
match..case..case
```
 ja hahmomääritelmissä esim.
```python
if
```
(engl. *guard*),
```python
|
```
(tai) ja
```python
_
```
(mitä tahansa)
* poikkeuksienhallintaan
```python
try..except..as..else..finally
```
 ja
* kontekstinhallintaan
```python
with..as
```
(yleensä avoin tiedosto).

### Lauseita
Yksinkertaisia lauseita Pythonissa ovat muun muassa
* muuttujaan sijoittaminen kuten 
```python
x = [1, 2]
```

* operaattorisijoittaminen kuten 
```python
x += 1
```
(sama kuin
```python
x = x + 1
```
) 
* tyyppiannotaatiot kuten 
```python
x: int = 1
```

* 
```python
assert
```
, joka testaa sen jälkeen kirjoitetun ehdon
* 
```python
return
```
, joka pysäyttää funktion ja palauttaa objektin (tai
```python
None
```
)
* 
```python
import x as y
```
 tai 
```python
from x import y as z
```
, joka tuo moduulin sisällön käyttöön
* 
```python
break
```
, joka pysäyttää ympäröivän silmukan
* 
```python
continue
```
, joka siirtää ympäröivän silmukan suoraan seuraavaan toistoon
* 
```python
del
```
, joka poistaa nimen tai korvaa arvon tyhjällä
* 
```python
yield
```
, joka tekee funktiosta generaattorin ja palauttaa objektin (toistuvasti)
* 
```python
raise
```
, joka toimeenpanee poikkeuksen
* 
```python
pass
```
 jota ei tee mitään
* 
```python
global
```
, joka tuo nimen käytettäväksi ylimpään nimiavaruuteen, ja
* 
```python
nonlocal
```
, joka mahdollistaa pääsyn ulommissa näkyvyyksissä määriteltyihin nimiin.

### Lausekkeita
Lausekkeita Pythonissa ovat muun muassa
* nimet kuten 
```python
muuttuja
```
 tai 
```python
__yksityinen_funktio
```

* literaalit kuten 
```python
"string"
```
 ja 
```python
1.56
```

* lausekelistat kuten 
```python
1.2, 5.5, 10.2
```
 tai 
```python
()
```

* näkymät kuten 
```python
[1,2,3]
```
, 
```python
{"yksi", "kaksi"}
```
 ja 
```python
{"avain": 1.2}
```
(huom. listanäkymä voi sisältää literaalien lisäksi myös ns. comprehension-lauseen mallia
```python
[..for..in..if..]
```
)
* nimettömät generaattorit kuten 
```python
(x^2 for x in range(10))
```

* attribuuttireferenssi kuten 
```python
objekti.muuttuja
```

* tilaukset kuten 
```python
objekti[5]
```
(
```python
__getitem__()
```
)
* viipaloinnit kuten 
```python
nimi[0:10:2]
```

* kutsut kuten 
```python
nimi()
```

* 
```python
await
```
-lauseke, joka tauottaa ko-rutiinin ajon 
* potenssioperaattori
```python
**
```

* unääriset operaattorit kuten 
```python
+5
```
, 
```python
-2
```
 ja 
```python
~x
```
(
```python
__invert__()
```
)
* binääriset aritmeettiset operaattorit
```python
+
```
, 
```python
-
```
, 
```python
*
```
, 
```python
@
```
(matriisitulo),
```python
/
```
, 
```python
//
```
(
```python
__floordiv__()
```
) ja
```python
%
```
(
```python
__mod__()
```
)
* binääriset bittioperaattorit
```python
|
```
(tai),
```python
&
```
(ja) ja
```python
^
```
(poissulkeva tai)
* vertailulausekkeet
```python
<
```
, 
```python
>
```
, 
```python
==
```
, 
```python
>=
```
, 
```python
<=
```
, 
```python
!=
```
, 
```python
in
```
, 
```python
not in
```
, 
```python
is
```
 ja 
```python
is not
```

* Boolen operaattorit
```python
and
```
, 
```python
or
```
 ja 
```python
not
```
(huom.
```python
and
```
 ja 
```python
or
```
eivät palauta totuusarvoja vaan viimeisimmän lausekkeen arvon, ja Boolen operaatioissa
```python
None
```
, 
```python
0
```
 ja tyhjät tietorakenteet saavat myös totuusarvon
```python
False
```
)
* mursu-operaattori
```python
:=
```
, joka antaa nimen lausekkeelle ja palauttaa sen arvon
* tiivis ehtolause
```python
x if y else z
```
 ja
* nimettömät funktiot kuten 
```python
lambda x, y: x**y
```
.

### Tyypit
Sisäänrakennettuja tyyppejä ovat muun muassa
* numerotyypit kuten 
```python
numbers.Number
```
, 
```python
numbers.Integral
```
eli
```python
int
```
 ja 
```python
bool
```
, 
```python
numbers.Real
```
eli
```python
float
```
 ja 
```python
numbers.Complex
```
eli
```python
complex
```

* 
```python
None
```
, joka edustaa puuttuvaa arvoa
* sekvenssityypit kuten 
```python
str
```
, 
```python
tuple
```
, 
```python
bytes
```
, 
```python
list
```
, 
```python
bytearray
```
, 
```python
array
```

* kuvaustyyppi
```python
dict
```
(sanakirja)
* kutsuttavat tyypit kuten käyttäjän määrittelemät ja sisäänrakennetut funktiot, metodit, generaattorit, ko-rutiinit, instanssimetodit, luokat ja luokkainstanssit  
* moduulit, jotka edustavat loogista joukkoa objekteja
* I/O, joka edustaa avoimia tiedostoja
* 
```python
NotImplemented
```
, joka edustaa puuttuvaa toteutusta
* 
```python
Ellipsis
```
 tai 
```python
...
```
 jota käytetään pääasiassa viipalointilausekkeissa edustamaan jotakin jatkumoa tai väliä 
* sisäiset tyypit kuten koodi-, ajokehys-, traceback- ja viipaleobjektit sekä staattisten metodien ja luokkametodien objektit. 

Python on dynaamisesti tyypittävä, joten Pythonissa voidaan käyttää ns. ankkatyypitystä () eli objektin attribuutteja ja metodeja käytetään varsinaisesta tyypistä huolimatta ja mahdolliset tyyppivirheet otetaan vastaan ja käsitellään ("helpompi pyytää anteeksi kuin lupaa"). Kun tyyppivirheitä ei ole, objekti on käytännössä haluttua tyyppiä, koska sillä on sama rajapinta ("liikkuu ja vaakkuu kuin ankka, eli kyseessä on ankka"). Ankkatyypityksellä voidaan toteuttaa näin olio-ohjelmoinnin polymorfinen korvaus ilman periytymistä ja eksplisiittistä riippuvuutta valittuun tyyppiobjektiin.

### Ko-rutiinit
Ko-rutiinit (esim.
```python
async def func(x):
```
) ovat erityisiä funktioita, jotka sallivat ajon tauottamisen ja jatkamisen käyttämällä avainsanoja
```python
await
```
, 
```python
async for
```
 ja 
```python
async with
```
lauseita.

### Generaattorifunktiot
Generaattorifunktiot palauttavat generaattorin, jolla on
```python
__next__()
```
, 
```python
send
```
, 
```python
throw()
```
 ja 
```python
close()
```
-metodit. Tyypillisesti
```python
for
```
-silmukka käyttää sitä tuottamaan (
```python
yield
```
) arvoja silmukkaan – näin koko iteroitavaa objektia ei tarvitse pitää muistissa kerralla. Generaattorikorutiini on tätä vastaava, mutta asynkroninen.

## Käyttö

Python-tulkkia käytetään pääasiassa komentoriviltä antamalla ensimmäisessä argumentissa Python-skriptin tiedostonimi (esim.
```python
python hei-maailma.py
```
). Python-tulkin aloitusympäristössä on alustettuna kolme moduulia –
```python
sys
```
, 
```python
builtins
```
 ja 
```python
__main__
```
– ja kaikki sisäänrakennetut ja standardimoduulit ovat käytettävissä
```python
import
```
-lauseella. Interaktiivisessa tilassa tulkki käsittelee yhden lauseen kerrallaan, muuten koko lähdetiedoston.

Ympäristönhallintaohjelmat (esim. conda, venv) mahdollistavat useiden eri Python- ja kirjastoversioiden käytön samassa käyttöjärjestelmässä ilman konflikteja.

### Ohjelmistot
Versionhallintajärjestelmä GNU Bazaar sekä siitä forkattu Breezy on toteutettu Pythonilla. Avoimen lähdekoodin Odoo-yritysohjelmisto, jota käyttää 19&nbsp;000 yritystä. Syväoppimiseen perustuva tekoälyohjelmisto, Stable Diffusion on kirjoitettu täysin Pythonilla. Stable Diffusion onkin yksi suosituimmista, tehokkaimmista ja monipuolisimmista tekoälyistä joka pystyy luomaan kuvia pelkän syötetyn tekstin perusteella.

### Sivustot ja kuluttajasovellukset
Pythonilla (suurimmaksi osaksi pääkielenä) on kirjoitettu myös lukuisia muita tunnettuja sovelluksia ja sivustoja kuten YouTube, Google, Spotify, Instagram, Reddit, Dropbox ja Quora.

## Toteutukset

Python-kielestä on tehty useita toteutuksia. Tunnetuimmat ovat C-ohjelmointikielellä tehty alkuperäinen (kielen määrittelevä) toteutus ja Java-ohjelmointikielellä tehty Jython. Muita toteutuksia ovat esimerkiksi IronPython .NET- ja Mono-alustoille sekä Python-kielellä itsellään uudelleentoteutettu PyPy. Mobiilialustoista Python on sovitettu myös Symbian S60 -alustalle . Lisäksi kielestä on kehitetty Maemo-alustaan optimoitu versio . Sulautettujen järjestelmien ohjelmointiin on myös MicroPython.

Python-tulkki ja -kirjastot on kehitetty avoimen lähdekoodin projektina, ja niitä levitetään Pythonin oman lisenssin (Python Software Foundation License) alaisena, joka on yhteensopiva myös GPL-lisenssin kanssa. Pythonin lisenssi sallii lisäksi kaikenlaisen kaupallisen käytön ja jopa kaupallisen uudelleenlevittämisen.

Python-koodin tulkitseminen ja ajoa edeltävä optimointi saattavat joskus olla hitaita prosesseja, ja Pythonia ajetaankin useimmiten tavukoodina hieman Javan tapaan. Tämä vie ohjelman suorituksesta pois yhden hitaammista vaiheista, tulkkaamisen tavukoodiksi; tulkkaamattoman Python-skriptin ajaminen saattaa olla moninkertaisesti tavallisen C-kielisen ohjelman ajamista hitaampaa.

## Lähteet

## Aiheesta muualla

* Python-kielen kotisivu 
* Ilmainen Python3-verkkokurssi
* Suomenkielinen Python-opas (122ss.) 
* Suomenkielinen Python-grafiikkaohjelmointiopas (92ss.) 
* Suomenkielinen Python-opas graafisten käyttöliittymien toteuttamisesta (50ss.)
* Ohjelmointiputka: Python 3 -opas
* Vanhala, Erno; Nikula, Uolevi: Python 3 – ohjelmointiopas, versio 1.0 (2010)
* MicroPython