Python (programmeringssprog)

Fra Wikipedia, den frie encyklopædi
Gå til: navigation, søg
Disambig bordered fade.svg For alternative betydninger, se Python.

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 parenteser.

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

Pythons filosofi[redigér | redigér wikikode]

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 grammatiken 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[redigér | redigér wikikode]

>>> print 'Hello World !'
Hello World !
# Eller i den nye version (3.2)
>>> print("Hello World !")
Hello World !

Objektorienteret hello world[redigér | redigér wikikode]

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[redigér | redigér wikikode]

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: \{ \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[redigér | redigér wikikode]

Minimal version[redigér | redigér wikikode]

Dette er en Python-implementation af algoritmen Quicksort:

def quicksort(lst):
    if not lst:
      return []
    pivot = lst.pop()
    return [x for x in lst if x < pivot] + [pivot] + [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[redigér | redigér wikikode]

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[redigér | redigér wikikode]

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[redigér | redigér wikikode]

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[redigér | redigér wikikode]

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[redigér | redigér wikikode]

Commons-logo.svg
Wikimedia Commons har medier relateret til:

Fodnoter[redigér | redigér wikikode]