Du solltest am besten erst einmal die ``global``-Anweisungen aus dem Programm entfernen und dann vergessen, dass es diese Anweisung gibt. So auf den ersten Blick wird auch gar keine von den Anweisungen in dem Pogramm benötigt.
Werte sollten Funktionen in der Regel als Argumente betreten und als Rückgabewerte verlassen. Damit bleibt das Programm übersichtlicher und durchschaubarer und die Funktionen sind auch entkoppelter und lassen sich leichter einzeln testen und verwenden.
Auf Modulebene sollte so wenig wie möglich ausführbarer Code stehen. Der wird nur beim importieren ausgeführt, lässt sich also nicht wiederverwenden oder innerhalb eines Programmes noch einmal ausführen.
Zeilen sollten 80 Zeichen nicht überschreiten, damit der Text lesbar bleibt, unter anderem auch in Medien wie E-Mail oder `diff`\s. Vor und nach Operatoren wie zum Beispiel der Zuweisung ausserhalb von Argumentlisten für Funktionsdefinitionen und -aufrufe, und nach Kommata und Doppelpunkten, sollte ein Leerzeichen stehen.
Zuviele Namen in einer Funktion machen das ganze ein wenig unübersichtlich. `methode04()` ist ein wenig zu Umfangreich. Zum Beispiel wird `g` von der Modulebene verwendet, dann aber innerhalb der Funktion an einen anderen Wert gebunden. So etwas kann schnell zu Verwirrungen und eventuell Fehlern führen. `primer` wird anscheinend gar nicht verwendet.
Die `input()`-Funktion sollte man nach Möglichkeit nicht verwenden. Dort kann der Benutzer beliebigen Python-Code angeben, der ausgeführt wird! Sicherer ist `raw_input()` zu verwenden und den Rückgabewert entsprechend umzuwandeln. `float()` wird an einigen Stellen unnötig oft verwendet. Problematisch ist eigentlich nur die Division, weil die im Normalfall nur eine Fliesskommazahl als Ergebnis liefert, wenn mindestens einer der Operanden eine Fliesskommazahl ist. Das kann man aber mit einem ``from __future__ import division`` als ersten Import ändern. Dann sind alle Divisionen mit ``/`` Fliesskommadivisionen. Wenn man eine Ganzzahldivision haben möchte nimmt man den ``//``-Operator.
Natürlich kann man auch Werte für Sequenzen aus einer Datei berechnen. Dazu schreibt man am besten eine Funktion die alle nötigen Werte zur Berechnung und die Sequenz als Argument entgegennimmt. Die ruft man dann nacheinander mit allen Sequenzen aus der Datei auf.
In der `methode04()` gibt es sich wiederholenden Quelltext, den man in eine Funktion auslagern kann. Zum Beispiel auf der Sequenz anhand eines Dictionaries eine Summe für die Paare zu berechnen.
Mit OOP kann man auch einiges besser Strukturieren. Zum Beispiel ein `Sequence`-Objekt, dass weiss wieviele 'a', 't', 'g' und 'c' es enthält und für diese "Paarsummen" eine Methode bereithält.
Beispiel:
Code: Alles auswählen
class Sequence(object):
def __init__(self, data):
self.data = data
self.a = data.count('a')
self.c = data.count('c')
self.g = data.count('g')
self.t = data.count('t')
def __len__(self):
return len(self.data)
def __getitem__(self, key):
return self.data[key]
def pair_sum(self, weights):
return sum(weights.get(self[i:i+2], 0) for i in xrange(len(self)))
def test():
sequence = Sequence('gattaca')
print len(sequence) # -> 7
print sequence.a, sequence.c, sequence.g, sequence.t # -> 3 1 1 2
weights = {"aa": -9.1, "ac": -6.5, "ag": -7.8, "at": -8.6,
"ca": -5.8, "cc": -11.0, "cg": -11.9, "ct": -7.8,
"ga": -5.6, "gc": -11.1, "gg": -11.0, "gt": -6.5,
"ta": -6.0, "tc": -5.6, "tg": -5.8, "tt": -9.1}
print sequence.pair_sum(weights) # -> -41.6