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.

For alternative betydninger, se Python. (Se også artikler, som begynder med Python)

Python logo.

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: ${\displaystyle \{{\frac {m}{n}}|m\in \mathbb {Z} ,n\in \mathbb {N} \setminus \emptyset \}}$

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^[1], ligesom der findes en lang række beregnings- og forskningsorienterede biblioteker til Python.

Eksterne henvisninger

Wikimedia Commons har medier relateret til: Python (programmeringssprog)

• Python Programming Language (engelsk), download (engelsk)
• Python Documentation (engelsk)
• http://www.linuxbog.dk/python/bog/ Arkiveret 4. februar 2012 hos Wayback Machine (Begynderbog på dansk)

Fodnoter

1. Python Success Stories