For alternative betydninger, se
Python
.
(
Se ogsa artikler, som begynder med Python
)
Python logo.
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 handtere
Unicode
-tekst.
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 pa samme made som programmeringssproget
Eiffel
. Python benytter sig af dynamisk typetjek og
garbage collection
. En væsentlig feature er den dynamiske binding, dvs. at navne pa funktioner og variable først tilknyttes deres respektive objekter pa 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 pa 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 sa konstruktioner der bliver betragtet som "smukke", "entydige" eller "simple" favoriseres.
Et andet vigtigt mal 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
.
>>>
print
(
"Hello World !"
)
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
()
Pythonsyntaksen tillader list comprehensions, der er en enkel made at
opbygge en liste pa.
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 undga heltalsdivision)
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, sa de undgar at bruge en stak.
Derfor vil nedenstaende funktion give en RuntimeError ved tilstrækkeligt store lister.
>>>>
quicksort
(
range
(
1000
))
RuntimeError
:
maximum
recursion
depth
exceeded
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.
Den simpleste made at sortere en liste pa 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
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 nar yield, returnere værdien og herefter vente pa, 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
Flere forskere anvender Python som del af deres forskning
[1]
,
ligesom der findes en lang række beregnings- og forskningsorienterede biblioteker til Python.