B - Universität Tübingen

Bioinformatik
für Lebenswissenschaftler
Sandra Gesing
SS 2010
Python - Einführung
Abt. Simulation biologischer Systeme
WSI/ZBIT, Eberhard Karls Universität Tübingen
Python – Zuweisungen, Ausgaben
• Das einfachste das wir tun können ist zunächst die
beiden Strings zum Alignment zu definieren
• Beispielsweise wollen wir die Sequenzen ACGT und
AGT alinieren
• Diese Sequenzen können wir nun Variablen zuweisen,
damit wir
– bequem darauf Bezug nehmen können
– den Programmcode schreiben können, ohne die Sequenzen
im Programmcode zu verwenden (Trennung von Daten und
Code)
• Eine Zuweisung in Python erfolgt mit Hilfe des
Gleichheitszeichens:
A = 'ACGT'
• Die Anführungszeichen instruieren den Interpreter
(Python) dabei ACGT als Zeichenkette aufzufassen
2
Python – Zuweisungen, Ausgaben
•
•
•
•
•
•
A = 'ACGT'
A ist dabei der Name der Variablen, die nach der
Zuweisung den Wert ‘ACGT‘ besitzt
Entsprechend kann man nicht nur Zeichenketten, sondern
auch numerische Werte zuweisen:
Summe = 0
Weist z.B. der Variable mit dem Namen „Summe“ den
Wert Null zu
Die Namen von Variablen sind dabei frei wählbar, müssen
aber aus einem Wort bestehen (also keine Leerzeichen),
dürfen keine Sonderzeichen außer „_“ enthalten und
dürfen nicht mit einer Zahl anfangen
Gültige Namen:
meine_variable, Wert15
Ungültige Namen:
meine-Variable, 15ter_wert
3
Python – Ausgaben
• Möchte man in Python Ausgaben tätigen so erscheinen diese
standardmäßig auf der Konsole (dem Fenster in dem Sie gerade
arbeiten)
• Das Python-Kommando print gibt einen Text oder Werte aus
• Wir können dies am Prompt des Python-Interpreters
nachvollziehen:
• Beispiel:
Ausgabe des Textes „Bioinformatik“:
>>> print 'Bioinformatik'
Bioinformatik
>>>
Zuweisung und Ausgabe des Wertes einer Variablen:
>>> distanz = 15
>>> print distanz
15
>>>
4
Ausführung eines Programms
• Mit dem Interpreter kann man natürlich nicht nur interaktiv arbeiten,
sondern man kann ihn auch komplette Programme abarbeiten lassen
• Dabei liest der Interpreter das Programm vollständig und führt die
Zeilen nacheinander aus, beginnend mit der ersten Zeile
• Ein sehr triviales Programm kann z.B. das Produkt zweier Zahlen
berechnen und ausgeben:
x = 15
print 'x = ', x
y = 456
print 'y = ', y
print 'Produkt', x * y
• Der Operator * berechnet dabei das Produkt der beiden Zahlen, das
Komma trennt beim Print-Kommando unterschiedliche Ausgaben
voneinander
• Man kann dieses Programm nun in einer Datei speichern (z.B. unter
dem Namen „trivial.py“)
• Ruft man nun den Interpreter mit diesem Dateinamen als Argument
auf, so führt er das Programm aus („python trivial.py”)
5
Ausführen des Programms
• Um das Programm auszuführen, rufen wir nun von der
Kommandozeile aus den Interpreter mit dem
Dateinamen unseres Programmcodes auf
$ python trivial.py
x = 15
y = 456
Produkt 6840
x = 15
print 'x = ', x
y = 456
print 'y = ', y
print 'Produkt', x * y
• Der Interpreter lädt daraufhin das Programm und
arbeitet es Zeile für Zeile ab
• Die Zuweisungen erzeugen keine Ausgaben,
erscheinen also nicht auf der Konsole
6
Python – Strings
• Alle wichtigen Operationen auf Zeichenketten kann man auch in Python
auf einfachste Weise durchführen:
• Beispiel: ein String A = 'ACGT' und ein String B = 'AGT'
Problem
Notation
Python
Ergebnis
Auswahl eines
Zeichens
a1
b3
A[0]
B[2]
`A`
`T`
Konkatenierung BA
B+A
`AGTACGT`
Substring
A[2..3]
A[1:3]
`CG`
Präfix
A[1..2]
A[:2]
`AC`
Suffix
A[2..4]
A[1:]
`CGT`
Aufgepasst: Python nummeriert die Elemente eines Strings von Null an!
7
Python – Schleifen
• Kontrollstrukturen steuern den Ablauf eines
Programms
• Der Interpreter beginnt mit der Ausführung des
Programms in der ersten Codezeile und arbeitet das
Programm Zeile für Zeile ab
• Kontrollstrukturen erlauben es, diese Abfolge zu
verändern
• Schleifen zählen zu den wichtigsten
Kontrollstrukturen
• Sie erlauben es, bestimmte Codeteile (den
zugehörigen Schleifenkörper oder Rumpf) mehrmals
zu durchlaufen
• Die Anzahl Durchläufe durch die Schleife wird dabei
durch den Schleifenkopf gesteuert
8
Python – Schleifen
• Python kennt For-Schleifen, bei denen eine Schleifenvariable
eine Folge von Werten durchläuft und für jeden dieser Werte der
Rumpf ausgeführt wird
• Der Kopf definiert dabei die Schleifenvariable und die möglichen
Werte
• Der Rumpf wird vom Kopf durch Einrückung unterschieden
• Der Rumpf kann eine oder mehrere Zeilen Code enthalten
• Die Funktion range(Wert) erzeugt dabei eine Liste von Wert
Zahlen, die bei 0 anfangen und jeweils um eins erhöht werden
for i in range(10):
print i
• Dieses kurze Programm gibt dementsprechend die Zahlen von 0
bis 9 aus
9
Python – Bedingungen
• Bedingungen erlauben es Programmteile nur dann auszuführen,
wenn eine bestimmte Bedingung erfüllt ist
• In Python heißt das entsprechende Konstrukt if-else:
if distanz < 5:
print 'Distanz gering'
else:
print 'Distanz zu gross!'
• Die Bedingung der if-Zeile kann auf verschiedene
Vergleichsoperatoren zurückgreifen (Auswahl):
== Gleichheit
<
Echt kleiner
<= Kleiner oder gleich
!= Ungleichheit
>
Echt größer
>= Größer oder gleich
• Ist die Bedingung erfüllt, wird der Block nach if ausgeführt,
andernfalls der Block nach else
10
Python – Funktionen
• Funktionen in Programmiersprachen sind ähnlich zu
mathematischen Funktionen, es gibt jedoch einige Unterschiede
• Prinzipiell verwendet man Funktionen um häufig benutzten
Code nicht mehrmals schreiben zu müssen
• Funktionen sind abgeschlossene Codestücke, denen Argumente
übergeben werden und die einen Rückgabewert haben können
• In Python werden Funktionen mit Hilfe des def-Schlüsselwortes
definiert
• Funktionen haben einen Namen, eine Liste von Argumenten und
einen Codeblock der die eigentliche Rechnung durchführt
• Beispiel: Eine Funktion, die zu einer Zahl deren doppelten Wert
zurückliefert
def doppelt(x):
return 2 * x
print doppelt(4)
• Das Schlüsselwort return definiert dabei den Rückgabewert
der Funktion
11
Ein Pythonprogramm
A = 'ACGT'
B = 'A-GT'
def d(a, b):
if a == b:
return 0
else:
return 1
distanz = 0
for i in range(len(A)):
distanz = distanz + d(A[i], B[i])
print 'Distanz des Alignments:', distanz
12
Ein Pythonprogramm - Blöcke
A = 'ACGT'
B = 'A-GT'
def d(a, b):
if a == b:
return 0
else:
return 1
distanz = 0
for i in range(len(A)):
distanz = distanz + d(A[i], B[i])
print 'Distanz des Alignments:', distanz
13
Ein Pythonprogramm - Blöcke
A = 'ACGT'
B = 'A-GT'
def d(a, b):
if a == b:
return 0
else:
return 1
distanz = 0
for i in range(len(A)):
distanz = distanz + d(A[i], B[i])
print 'Distanz des Alignments:', distanz
14
Ein Pythonprogramm - Blöcke
A = 'ACGT'
B = 'A-GT'
def d(a, b):
if a == b:
return 0
else:
return 1
distanz = 0
for i in range(len(A)):
distanz = distanz + d(A[i], B[i])
print 'Distanz des Alignments:', distanz
15
Ein Pythonprogramm - Blöcke
A = 'ACGT'
B = 'A-GT'
def d(a, b):
if a == b:
return 0
else:
return 1
Einrückung immer mit Tab oder
Leerzeichen, aber Konsistent!
distanz = 0
for i in range(len(A)):
distanz = distanz + d(A[i], B[i])
print 'Distanz des Alignments:', distanz
16
Ein Pythonprogramm - Ablauf
A = 'ACGT'
B = 'A-GT'
Zuweisung, “A” ist nun ein Text (String), mit Wert: ACGT
def d(a, b):
if a == b:
return 0
else:
return 1
distanz = 0
for i in range(len(A)):
distanz = distanz + d(A[i], B[i])
print 'Distanz des Alignments:', distanz
17
Ein Pythonprogramm - Ablauf
A = 'ACGT'
B = 'A-GT'
def d(a, b):
if a == b:
return 0
else:
return 1
distanz = 0
for i in range(len(A)):
distanz = distanz + d(A[i], B[i])
print 'Distanz des Alignments:', distanz
18
Ein Pythonprogramm - Ablauf
A = 'ACGT'
B = 'A-GT'
def d(a, b):
if a == b:
return 0
else:
return 1
distanz = 0
for i in range(len(A)):
distanz = distanz + d(A[i], B[i])
print 'Distanz des Alignments:', distanz
19
Ein Pythonprogramm - Ablauf
A = 'ACGT'
B = 'A-GT'
def d(a, b):
if a == b:
return 0
else:
return 1
Dieser Block wird nicht ausgeführt sondern
nur registriert! Immer wenn im weiteren
Verlauf nun die Funktion d aufgerufen wird,
wird dieser Block ausgeführt.
distanz = 0
for i in range(len(A)):
distanz = distanz + d(A[i], B[i])
print 'Distanz des Alignments:', distanz
20
Ein Pythonprogramm - Ablauf
A = 'ACGT'
B = 'A-GT'
def d(a, b):
if a == b:
return 0
else:
return 1
distanz = 0 Zuweisung, “distanz” ist nun eine (Ganz-)Zahl, Wert 0
for i in range(len(A)):
distanz = distanz + d(A[i], B[i])
print 'Distanz des Alignments:', distanz
21
Ein Pythonprogramm - Ablauf
A = 'ACGT'
B = 'A-GT'
def d(a, b):
if a == b:
return 0
else:
return 1
distanz = 0
for i in range(len(A)):
distanz = distanz + d(A[i], B[i])
print 'Distanz des Alignments:', distanz
22
Ein Pythonprogramm - Ablauf
A = 'ACGT'
B = 'A-GT'
def d(a, b):
if a == b:
return 0
else:
return 1
Um die for Schleife ausführen zu können muss
zuerst der innerste Ausdruck ausgewertet
werden. In diesem Fall “len(A)”, die
Auswertung ergibt den Wert 4.
distanz = 0
for i in range(len(A)):
distanz = distanz + d(A[i], B[i])
print 'Distanz des Alignments:', distanz
23
Ein Pythonprogramm - Ablauf
A = 'ACGT'
B = 'A-GT'
def d(a, b):
if a == b:
return 0
else:
return 1
Nun kann der range Befehl ausgewertet
werden. In diesem Fall hat der das Argument
4. Das Ergebnis davon ist eine Liste:
[0, 1, 2, 3]
distanz = 0
for i in range(len(A)):
distanz = distanz + d(A[i], B[i])
print 'Distanz des Alignments:', distanz
24
Ein Pythonprogramm - Ablauf
A = 'ACGT'
B = 'A-GT'
def d(a, b):
if a == b:
return 0
else:
return 1
Die for Schleife wird nun 4 mal ausgeführt,
wobei die Laufvariable i nacheinander die
Werte 0-3 annimmt. Bei jedem Durchlauf wird
der darunterstehende Block ausgeführt.
distanz = 0
for i in range(len(A)):
distanz = distanz + d(A[i], B[i])
print 'Distanz des Alignments:', distanz
25
Ein Pythonprogramm - Ablauf
A = 'ACGT'
B = 'A-GT'
def d(a, b):
if a == b:
return 0
else:
return 1
Im Block der Schleife wird wiederum der
innerste Befehl zuerst ausgeführt. Ein Zugriff
auf den i.ten Buchstaben im Text A. Im ersten
Durchlauf (i == 0) hat A[i] also den Wert 'A'.
distanz = 0
for i in range(len(A)):
distanz = distanz + d(A[i], B[i])
print 'Distanz des Alignments:', distanz
26
Ein Pythonprogramm - Ablauf
A = 'ACGT'
B = 'A-GT'
def d(a, b):
if a == b:
return 0
else:
return 1
B[i] wird gleich ausgewertet. Die Auswertung
ergibt ebenfalls den Wert 'A'
distanz = 0
for i in range(len(A)):
distanz = distanz + d(A[i], B[i])
print 'Distanz des Alignments:', distanz
27
Ein Pythonprogramm - Ablauf
A = 'ACGT'
B = 'A-GT'
def d(a, b):
if a == b:
return 0
else:
return 1
Nun kommt die Auswertung von d. Dazu springt
Python an die Stelle im Programm an dem d
definiert wird und führt diese Stelle aus.
distanz = 0
for i in range(len(A)):
distanz = distanz + d(A[i], B[i])
print 'Distanz des Alignments:', distanz
28
Ein Pythonprogramm - Ablauf
A = 'ACGT'
B = 'A-GT'
def d(a, b):
if a == b:
return 0
else:
return 1
d wird aufgerufen mit den
Argumenten a=='A' und b=='A', beides
sind Buchstaben, das findet Python
erst jetzt heraus!
distanz = 0
for i in range(len(A)):
distanz = distanz + d(A[i], B[i])
print 'Distanz des Alignments:', distanz
29
Ein Pythonprogramm - Ablauf
A = 'ACGT'
B = 'A-GT'
def d(a, b):
if a == b:
return 0
else:
return 1
Die Buchstaben die in a und b stecken
werden nun verglichen, in unserem
Fall sind beide gleich, also wird direkt
in der unteren Zeile weitergemacht.
distanz = 0
for i in range(len(A)):
distanz = distanz + d(A[i], B[i])
print 'Distanz des Alignments:', distanz
30
Ein Pythonprogramm - Ablauf
A = 'ACGT'
B = 'A-GT'
def d(a, b):
if a == b:
return 0
else:
return 1
Mit dem return Kommando wird der
Block der mit def begonnen hat
beendet. Python springt wieder an die
Stelle zurück von der d aufgerufen
wurde.
distanz = 0
for i in range(len(A)):
distanz = distanz + d(A[i], B[i])
print 'Distanz des Alignments:', distanz
31
Ein Pythonprogramm - Ablauf
A = 'ACGT'
B = 'A-GT'
def d(a, b):
if a == b:
return 0
else:
return 1
d(A[i], B[i]) ergibt einen Wert von 0.
Damit lässt sich “distanz” neu
berechnen:
0 = 0 + 0 → das ergibt wiederum 0
distanz = 0
for i in range(len(A)):
distanz = distanz + d(A[i], B[i])
print 'Distanz des Alignments:', distanz
32
Ein Pythonprogramm - Ablauf
A = 'ACGT'
B = 'A-GT'
def d(a, b):
if a == b:
return 0
else:
return 1
Analog werden die drei restlichen
Durchläufe ausgewertet. Wobei beim
Zweiten der Vergleich (i == 1) in d
Ungleichheit ergibt und damit 1
zurückgegeben und zu “distanz”
addiert wird
distanz = 0
for i in range(len(A)):
distanz = distanz + d(A[i], B[i])
print 'Distanz des Alignments:', distanz
33
Ein Pythonprogramm - Ablauf
A = 'ACGT'
B = 'A-GT'
def d(a, b):
if a == b:
return 0
else:
return 1
In der letzten Zeile gibt das print
Kommando zuerst den Text und
danach den Wert von “distanz” aus.
Das Programm ist damit
durchgelaufen.
distanz = 0
for i in range(len(A)):
distanz = distanz + d(A[i], B[i])
print 'Distanz des Alignments:', distanz
34