Python (programmeringssprog)

Python er et dynamisk og fortolket platformsuafhængigt programmeringssprog, oprindeligt udviklet af hollænderen Guido van Rossum. Python er tilgængeligt under en Open Source-licens. Pythons grammatik adskiller sig fra de fleste andre programmeringsprog ved at logiske programdele i Python opdeles ved hjælp af indrykning (eng. indentation) snarere end ved hjælp af tuborgparenteser.

Siden Python 2.0 har sproget kunnet håndtere Unicode-tekst.

Pythons filosofi 

Python er et multi-paradigme-sprog. Det betyder at programmørerne ikke bliver tvunget til at bruge en bestemt udviklingsmodel, men kan vælge mellem flere forskellige. Python understøtter blandt andet objektorientering, struktureret programmering, funktionel programmering og aspektorienteret programmering. Andre paradigmer er understøttet af udvidelser. For eksempel udvider pyDBC og Contracts for Python kontraktprogrammering på samme måde som programmeringssproget Eiffel. Python benytter sig af dynamisk typetjek og garbage collection. En væsentlig feature er den dynamiske binding, dvs. at navne på funktioner og variable først tilknyttes deres respektive objekter på afviklingstidspunktet.

Som kontrast til de mange forskellige paradigmer der understøttes, er grammatikken meget simpel, og stort set fri for syntaktisk sukker. Den væsentligste forskel fra de fleste andre sprog på dette punkt er at der ikke bruges tegn til angivelse af logiske niveauer. I stedet angives en logisk programblok ved ensartet indrykning med mellemrum eller tabulatortegn. Dette er et udslag af udviklernes kultur eller ideologi, hvor sproget er udformet så konstruktioner der bliver betragtet som "smukke", "entydige" eller "simple" favoriseres.

Et andet vigtigt mål for Pythons udviklere er at sproget skal være sjovt at bruge. Det ses blandt andet i navngivningen (efter tv-serien Monty Pythons Flyvende Cirkus), i de mange mere eller mindre skjulte referencer til Monty Pythons-sketches i koden og en fra tid til anden munter tilgang til sproget i vejledninger og referencemanualer. Et eksempel er brugen af metasyntaktiske variabler, hvor man ofte ser spam og eggs brugt i eksempler, hvor man ellers ofte ser foo og bar.

Hello world 
>>> print("Hello World !")
Hello World !

Objektorienteret hello world 
class HelloWorld:

  def __init__(self, besked='hello world'):
    self.besked = besked

  def skriv_besked(self):
    print(self.besked)

myobject = HelloWorld()
myobject.skriv_besked()

List Comprehensions 
Pythonsyntaksen tillader list comprehensions, der er en enkel måde at
opbygge en liste på.

Syntaksen ligger tæt op ad den matematiske syntaks for mængder.

For eksempel er definitionen af mængden over alle rationale tal:

I Python ville følgende list comprehension give en liste af rationale
tal hvis tæller og nævner begge ligger mellem 0 og 99:
[n / float(m) for n in range(100) for m in range(100)]
(m konverteres til float for at undgå heltalsdivision)

Quicksort

Minimal version 
Dette er en Python-implementation af algoritmen Quicksort:
def quicksort(lst):
    if len(lst) <= 1:
      return lst
    pivot = lst.pop()
    return quicksort([x for x in lst if x < pivot]) + [pivot] + quicksort([x for x in lst if x >= pivot])
Implementationen bør ikke bruges i praksis.
Python-implementationen optimerer ikke hale-rekursive funktioner, så de undgår at bruge en stak.
Derfor vil nedenstående funktion give en RuntimeError ved tilstrækkeligt store lister.
>>>> quicksort(range(1000))
RuntimeError: maximum recursion depth exceeded

Praktisk version 
En iterativ implementation vil derfor være mere brugbar:
def quicksort(lst):
    lst = list(lst)
    queue = [(0, len(lst))]
    while queue:
        a, b = queue.pop()
        if a == b:
            continue
        pivot = lst[a]
        lesser  = [x for x in lst[a+1:b] if x < pivot]
        greater = [x for x in lst[a+1:b] if x >= pivot]
        lst[a:b] = lesser + [pivot] + greater
        queue.append((a, a + len(lesser)))
        queue.append((a + len(lesser) + 1, b))
    return lst
Man kan tale om, at der er lavet en manuel optimering af halerekursion.

Effektiv Sortering 
Den simpleste måde at sortere en liste på i Python er selvfølgelig at bruge den
indbyggede metode "sort()", eller generatoren "sorted()":
lst.sort()  # sorter listen

for i in sorted(lst):  # itererer listen i sorteret orden
    print i

Generators 
Følgende er en Python-generator, der returnerer samtlige primtal i rækkefølge:
import math
import sys

def primes(N=sys.maxint):

    def isprime(n):
        return bool([i for i in xrange(2, int(math.sqrt(n)+1)) if n % i == 0])

    for n in xrange(2, N):
        if isprime(n):
            yield n
Det er nu muligt at udtrække det antal primtal, der er nødvendigt, ved at iterere
igennem det generatorobjekt, funktionen returnerer. Python vil indstille beregningen
hver gang den når yield, returnere værdien og herefter vente på, at næste værdi
skal bruges. Man kan sige at generatorobjekterne minder om lazy evaluering.

Her beregnes de første 10 primtal:
for i in primes():
    if i > 10:
        break
    print i

Python i forskning 
Flere forskere anvender Python som del af deres forskning,
ligesom der findes en lang række beregnings- og forskningsorienterede biblioteker til Python.

Eksterne henvisninger 

 Python Programming Language , download 
 Python Documentation 
 http://www.linuxbog.dk/python/bog/  (Begynderbog på dansk)

Fodnoter 

Programmeringssprog