Synopsis: I denne artikel vil jeg forsøge at give et kort og hurtigt indblik i programmeringssproget Python, der desværre er alt for overset.
Kategori: Programmering/Andre. Direkte link til artiklen: Artikel 483. Artiklen kan også ses i ren HTML.
Python er et programmeringssprog på niveau med C, C++, Java osv. Oftest sammenlignes det med Perl, Tcl og Java, men har dog væsentlige fordele på flere punkter:
Som det fremgår af ovenstående er der altså ingen umiddelbar undskyldning for ikke at se nærmere på sproget. Eneste ulempe ved sproget er, at det ikke er lige så hurtigt som kompileret C eller C++, men i de fleste tilfælde vil Python være hurtigt nok. Nu tænker du måske "hvis Python ikke er et kompileret sprog, hvad er det så?" - Python er et fortolket sprog, der oversættes til byte code og køres af PVM på CPU'en:
Source (.py) -> Byte code (.pyc) -> Runtime (PVM)
Byte code'n er low-level kompileret Python kode, der er komplet planformsuafhængigt.
PVM står for Python Virtual Machine, der eksekverer byte code og er skrevet specifikt til platformen.
Sidste nye version af Python (p.t. 2.3.4) hentes fra http://www.python.org. Installationsfilen fylder ca. 10MB og er en almindelig WISE installation, der guider dig gennem forløbet. Python installeres som standard i c:\Python23.
Alternativt kan man benytte Jython, som er Python (oftest omtalt som CPython, når Jython også nævnes) skrevet i Java. Dette er dog noget langsommere, da Java selv kører på en virtuel maskine. Jython nævnes ikke mere i denne artikel, da jeg kun har beskæftiget mig med CPython.
Når Python er installeret på din computer kan du komme hurtigt i gang i Pythons shell IDLE, der tillader interaktiv kodning med syntaksfarvning. Dette er et udmærket miljø til at starte med Python.
Alle eksempler i denne artikel tager udgangspunkt i IDLE, hvor ">>>" indikerer vores statement linie.
Operationer på typer behandles senere, men først en oversigt:
Kommentarer i Python kode startes med et hash (#) og fortsætter linien ud (se eksempel 1).
Python skelner mellem store og små bogstaver overalt. Variabler kan bestå af tegnene a-z, A-Z, 0-9 og _ (underscore) og skal være minimum ét tegn lange. Desuden må de ikke starte med 0-9.
Det er desuden værd at bemærke, at Python arbejder med referencer (modsat værdier), hvis ikke andet angives.
Variabler kan tildeles som følger:
Eksempel 1:
>>> min_var = 'noget tekst' # Simpel form
>>> var1 = var2 = var3 = 'indhold' # Multiple assignment (reference til _samme_ streng
>>> [pi, e] = [3.14, 2.72] # Liste assignment
>>> (pi, e) = (3.14, 2.72) # Tuple assigment
>>> pi, e = 3.14, 2.72 # Som ovenstående
>>> x += 1 # Augmented assignment (x tælles én op)
Augmented assignment gælder også -, /, % osv.
IDLE udskriver som standard, men i .py filer skal man benytte print. Følgende eksempel vil udskrive den samme streng to gange i IDLE, men i en .py fil vil var kun udskrives på tredje linie:
Eksempel 2:
var = 'noget tekst her'
var
print var
Indentering (indrykning) er meget vigtigt i Python. I Java (og mange andre sprog) afgrænses blokke af "tuborg"-klammer {}. Det kan man ikke i Python og er faktisk en hovedårsag til, at Python er så letlæst, da man tvinges til at have orden på sine indrykninger.
Vi springer straks til et eksempel for at illustrere - her et if-statement:
Eksempel 3:
if <condition>: # Generel struktur
<statements>
[elif <conditionN>:
<statements>]*
[else:
<statements>]?
>>> if 2 >= 5:
print 'Næppe'
else:
print 'Ja, nemlig ja'
# Vil udskrive: Ja, nemlig ja
Som antydet med [], * og ? kan elif og else udelades - elif kan desuden optræde et vilkårligt antal gange.
Python er udstyret med to løkke-strukturer - en generel konstruktion samt en konstruktion til gennemløb af sekvenser (liste, tupler m.v.). While-løkken er den generelle, der kører så længe et givent udsagn er sandt. Derfor er en uendelig løkke let at lave. Strukturen for while er som følger:
Eksempel 4:
while <condition>:
<statements>
[else
<statements>]?
>>> i = 1
>>> while i < 10:
i += 1
if i == 5:
continue
elif i == 9:
break
print i, # Ingen newline
else:
print 'Løkken kørte færdig'
# Vil udskrive: 2 3 4 6 7 8
Her er fyldt lidt ekstra på, men det er stadig relativt simpelt. Så længe i er mindre end 10 tælles den én op. Er i lig 5 startes løkken forfra (de næste statements udføres ikke) og er i lig 9 afbrydes løkken. Således vil else-delen ikke udføres (dette sker, hvis løkken bliver færdig (<condition> == False) uden brug af break.
For-løkken laver gennemløb af lister m.v. Derfor vil jeg lige præsentere den indbyggede funktion range(), der tit kan være nyttig i denne sammenhæng. Følgende skulle gerne give et indblik i dens argumenter og opførsel:
Eksempel 5:
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(1, 5)
[1, 2, 3, 4]
>>> range(10, 20, 2)
[10, 12, 14, 16, 18]
For-løkken ser ud som følger:
Eksempel 6:
for <item> in <sequence>:
<statements>
[else:
<statements>]?
>>> for i in range(5):
print i,
else:
print '- og nu er jeg færdig'
# Vil udskrive: 0 1 2 3 4 - og nu er jeg færdig
Ligesom i while-løkken kan der benyttes break og continue med samme effekt. Desuden kan de indbyggede metoder keys() og values() være gode at kende, hvis man kunne tænke sig at iterere over et dictionary. Benyt da mit_dictionary.keys() som <sequence>.
Indexing og slicing kan udføres på strenge, lister og tupler. Man benytter hårde parenteser [] og kan - som navnene antyder - hente et indeks eller slice (stykke). Skrives et tal mellem parenteserne vil der hentes et indeks. Slicing laves med et kolon (:). Eksempelvis vil [0:2] hente det nulte og første indeks osv.:
Eksempel 7:
>>> l = [112, 911, 'ild']
>>> l[1]
911
>>> l[0:2]
[112, 911]
>>> l[:2]
[112, 911] # Som ovenstående
>>> l[-2]
911
>>> l[1:]
[911, 'ild']
>>> l[:]
[112, 911, 'ild'] # NB: Dette er en kopi af l
Formatering af strenge kan foregå ligesom C's sprintf funktion, hvor % benyttes til at indsætte variabler. De mest normale er %s (streng), %d (decimal) og %i (heltal). Efter strengen angives variablen / variablerne i en liste eller tuple adskilt fra strengen med et procenttegn (%).
Desuden er der en hel metoder, der knytter sig til strenge. En par eksempler er replace(), upper() og split().
Funktionen len() - der også kan bruges på lister, tupler og dictionaries - returnerer antallet af tegn i en streng.
Repetition af strenge kan foregå med * operatoren. Konkatinering klares med +. Desuden kan operatoren in bruges til at undersøge, hvorvidt en streng findes i en anden streng.
Eksempel 8:
>>> s = '%s is %i years old' % ('Jens', 20)
>>> print s
Jens is 20 years old
>>> s2 = s.replace('Jens is', 'I\'m')
>>> s2
"I'm 20 years old"
>>> s.split(' ')
['Jens', 'is', '20', 'years', 'old']
>>> len(s2)
16
>>> '-' * 20 + '|-'
'--------------------|-'
Lister kan - som strenge - gentages og konkatineres med * og +.
Nyttige metoder er: append(), extend(), sort() og reverse(). Bemærk, at disse udføres direkte på listen:
Eksempel 9:
>>> l = range(3)
>>> l + [3, 4]
[0, 1, 2, 3, 4]
>>> l.append(5)
>>> l
[0, 1, 2, 5]
>>> l.extend([6, 7, 8])
>>> l
[0, 1, 2, 5, 6, 7, 8]
>>> l.reverse()
>>> l
[8, 7, 6, 5, 2, 1, 0]
Dette var en kort introduktion til Python. Jeg håber du fik noget ud af at læse den, og jeg kan på det kraftigste anbefale, at du kigger nærmere på Python. Man kan rigtig, rigtig meget og det er meget let at komme i gang med. Desuden bliver man glad for, at indrykning afgrænser blokke, når man først har vænnet sig til det.
- Jens Gram, http://www.jensgram.dk/
2004/10/24: Første version publiceret