Python (Programmeerspraak)

**Python** is en dynaamsch Programmeerspraak, de normalerwies in en Interpreter utföhrt warrt. Mit Python kann 'n objektorienteert, aspektorienteert un ok funkschonaal arbeiden. Butendem hett Python en ümfangrieke Standardbibliotheek un vele inbote Datentypen un kann somit op vele Rebeden insett worrn.

Een Besünnerheid vun Python is, dat de Programmstruktur dör dat Inrücken vun de Regen billt warrt. Annere Spraken bruukt dor Klemmen oder Slötelwöör vör.

Een seggt, dat Python besünners eenfach to lehren is, üm dat de Spraak en eenfache un klore Syntax hett. Siet 2008 is Python faken ünner de eersten teihn Programmeerspraken in de TIOBE Programming Community Index.

## Historie

Utklamüüstert worrn is Python vun Guido van Rossum an 'n Anfang vun de 1990er Johren. Van Rossum sien Teel weer dat, en Spraak mit en klore Syntax to schapen, de eenfach to lesen un eenfach to lehren is. Basis weer de Programmeerspraak ABC, an de van Rossum ok arbeidt hett. De Naam vun Python weer inspireert vun de britischen Komikers Monty Python.

Hüüttodaags warrt Python vun de Python Software Foundation wiederentwickelt, de ok de Standardimplementatschoon vun Python — CPython — maakt. CPython is Open Source, in C programmeert un löppt op vele verschedene Bedrievssystemen.

## Besünnerheiten

Python is een vun de wenigen Spraken, wo dat Inrücken vun de Regen en wichtig Bedüden hett un mit to de Syntax tohöört. Dat süht to 'n Bispill so ut:


```python
if faarv == 'root':
    print 'Dat is root.'
else:
    print 'Dat is keen root.'
```


De Idee is, dat de Programmen dor lesborer dör warrt un mehr as Pseudocode utseht, man dat gifft ok vele Minschen, de dat nich goot finnt.

Python bruukt de Oort vun dynaamsch Typisierung, de sik Duck Typing nöömt. Dat heet, üm en Aktschoon mit een Objekt uttoföhren, is dat wichtig, wat dat Objekt in de Momang vör Egenschoppen un Methoden hett, un nich, wat 't vör 'n Typ is. Butendem proberen Python-Programmerer lever ut, wat en Egenschopp geven is un fangt denn möögliche Fehler af, as dat se vörher de Typ prüfen doot. Dat warrt dör de ümfangrieke Mööglichkeiten, in Python Fehler to behanneln, eenfacher maakt.

So as vele annere Skriptspraken ok verwalt Python de Spieker vun alleen, wenn de Programmerer ne'e Objekte anleggt oder Objekte bruukt, de wassen köönt. Spieker vun Objekten, op de keen Variable mehr wiest, warrt ok vun alleen wedder freegeven.

De CPython-Interpreter lett sik eenfach in annern Code inboen, dorüm gifft dat vele Programmen, de Python as Skriptspraak bruukt (dorünner Blender un GIMP). Op de anner Siet kann 'n ok C- oder C++-Code in CPython inbinnen, wat goot is, üm de Delen vun 'n Python-Code uttolagern, de besünners veel Rekentiet nödig hebbt oder üm fardige C-Bibliotheken un Drievers to bruken.

De grundleggend Philosophie vun Python kann 'n in dat Dokument "PEP 20 (The Zen of Python)" nakieken. De wichtigsten Punkten sünd:

* Beautiful is better than ugly (Schöön is beter as asig.)
* Explicit is better than implicit. (Explizit is beter as implizit.)
* Simple is better than complex. (Eenfach is beter as komplex.)
* Complex is better than complicated. (Komplex is beter as vigeliensch.)
* Readability counts. (Dat is wichtig, dat 'n de Code goot lesen kann.)

Code, de disse Philosophie ümsetten deit un de Idioms vun Python op gode Oort bruukt, warrt in de Python-Community geern "pythoonsch" (engelsch pythonic) nöömt.

## Datentypen

Dat gifft eenfache Datentypen för boolsche Werte, Tallen (hele Tallen, Fleetkommatallen, komplexe Tallen) un Tekenkeden.

Blangen de normaal Arithmetik mit hele Tallen un Fleetkommatallen ünnerstütt Python ok Tallen, de so groot un so akkerat warrn köönt as een mag. För Tekenkeden gifft dat en groten Barg Operatschonen so as Tosamenfögen, Ersetten, Söken un annere. Tekenkeden sünd aver in Python unverännerliche Objekte (so as t. B. in Java), dorüm geevt all Operatschonen op Tekenkeden jümmers en ne'e Tekenkeed torüch.

Butendem gifft dat Sammeldatentypen, to 'n Bispill de List:


```python
farfen = ['root', 'geel', 'blau']
print(farven[1])
# Gifft 'geel' ut
```


Oder de assoziative List (Wöörbook, engelsch dictionary):


```python
farven = {'red': 'root', 'yellow': 'geel', 'blue': 'blau'}
print(farven['yellow'])
# Gifft 'geel' ut
```


Wiedere Sammeldatentypen sünd Tupel un Mengen.

Listen, Tupel un Tekenkeden sünd sorteerte Folgen, de vele Egenschoppen gemeen hebbt: Een kann dor to 'n Bispill över itereren oder Indexe bruken, üm op de enkelde Elemente totogriepen.

In Python is allens en Objekt: Klassen, Typen, Methoden, Module un so wieder. De Klass vun en Klass is en Metaklass. Butendem verhollt sik de Datentypen jüstso as Klassen un föögt sik dormit in dat Objektsystem vun Python in; dorüm kann ok vun inbote Datentypen afleiden, üm sik sien egen Datentypen to boen. In Python is dat ok mööglich, vun mehr as een Klass togliek aftoleiden.

## Syntax un Semantik

Vertwiegen fangt mit dat Slötelwoort `if` an. Een kann ok noch `elif`-Statements un een `else`-Statement anhangen:


```python
if farv == 'root':
    print('Dat is root.')
elif farv == 'blau':
    print('Dat is blau.')
elif farv == 'geel':
    print('Dat is geel.')
else:
    print(u'Dor heff ik noch nie nich vun höört.')
```


En switch-Statement gifft dat in Python nich. För komplexere Vertwiegen is dat gang un geev, en Wöörbook to bruken.

Vun Slöpen gifft dat in Python twee Oorden. De eerste is de `for`-Slööp, wo an 'n Anfang vun de Slööp al kloor is, wat de Iteratschonen sünd:


```python
farfen = ['root', 'geel', 'blau']

for farf in farfen:
    print('Dat is ' + farf)
```


Een kann de for-Slööp över all Objekte billen, de itereerbar sünd. Dor höört de Sammeldatenypen un Folgen to, man een kann ok op vele Oorden egene itereerbare Objekte boen. Üm över hele Tallen to itereren, kann een de `range`-Funkschoon bruken:


```python
for i in range(10): print(i)
```


De tweede Slööp is de `while`-Slööp, de so lang lopen deit, as en Utdruck wohr is:


```python
tall = 0

while tall < 10:
    tall = tall + 1
```


Anners as in annere Programmeerspraken gifft dat keen `do`-`while`-Slööp in Python. Dor warrt normalerwies en while-Slööp mit en `break`-Statement för bruukt:


```python
while True:
    # do wat
    if tall > 10:
        break
```


Üm Code tosamen to faten, kunn 'n Funkschonen insetten:


```python
def middelweert(a, b):
    return (a + b) / 2

print(middelweert(3, 5))
```

En Funkschoon is in Python en ganz normaal Objekt un kann so sülvst en Parameter vun en Funkschoon sien oder en Variable towiesen warrn. Mit dat Slötelwoort `lambda` kann 'n anonyme Funkschonen maken, man binnen en `lamda`-Funkschoon geiht blots 'n lütten Deel vun de normale Syntax vun Python.

Dat Behanneln vun Fehlers süht in Python so ut:


```python
try:
  x = 1 / y
except ZeroDivisionError:
  x = 0
```


Een kann ok mehrere `except`-Statements bruken, üm verschedene Oorden vun Fehlers aftofangen un sünnert to behanneln. Üm dat dat in Python so eenfach is, all mööglichen Fehlers to behanneln, versöökt Python-Programmerer mehrst nich, Fehlers dör Prüfen to verhöden, man se fangt lever all Fehlers af, de opdükern köönt. Op engelsch gifft dat dor de Snack "It is Easier to Ask for Forgiveness than Permission" för, wat so veel heet as "Dat is eenfacher, sik to enschülligen as üm Verlööf to fragen".

## Websteden

* Offizielle Websteed (engelsch)
* Learn Python in 10 minutes (engelsch)
## Brons