Anfänger Hilfe zu Sequenzen, Dict...

Wenn du dir nicht sicher bist, in welchem der anderen Foren du die Frage stellen sollst, dann bist du hier im Forum für allgemeine Fragen sicher richtig.
Benutzeravatar
keppla
User
Beiträge: 483
Registriert: Montag 31. Oktober 2005, 00:12

Freitag 18. Mai 2007, 14:44

Ist es egal ob man xrange oder range benutzt?
im prinzip ja.
range gibt als Antwort eine liste, in der die Werte stehen, xrange einen iterator, der die zahlen on-the-fly erzeugt, womit xrange weniger Speicher benötigt.
Aber praktisch gesehen ist es eigentlich egal, und gerade als Anfänger sollte man die Finger von Optimierung lassen.
thelittlebug
User
Beiträge: 188
Registriert: Donnerstag 20. Juli 2006, 20:46
Wohnort: Wien
Kontaktdaten:

Freitag 18. Mai 2007, 17:13

bei

Code: Alles auswählen

for x in range(10**7): pass
schnappt sich Python ~150MB Ram, bei 10**8 wären das ja dann ~1,5GB Ram wo xrange eigentlich "keinen merkbaren" Ramverbrauch hat.

Ich hätte eher behauptet das es darauf ankommt, brauche ich die Liste die range zurückliefert dann bleib ich dabei. Gehts darum ne Schleife zu bauen würd ich xrange nehmen.

lgherby
ete
User
Beiträge: 218
Registriert: Montag 19. Februar 2007, 13:19
Kontaktdaten:

Dienstag 22. Mai 2007, 16:29

Vielen Dank für die Erklärung!


Ich habs jetzt fertig und es funktioniert...

Mein nächstes Ziel ist dann, das ganze mit Tkinter grafisch zu programmieren...Ich kann ja mein Grundgerüst mal posten :roll:

Code: Alles auswählen

# Tm Berechnung

from math import*


sequenz=raw_input("Please enter your sequenz!")
string=sequenz

t=sequenz.count("t")
a=sequenz.count("a")
g=sequenz.count("g")
c=sequenz.count("c")

# Basis < 13 Nukleotide
# Tm=2°C (A+T) + 4°C (G+C)

def methode01():
    global t,a,g,c
    Tm01=(2*(a+t))+(4*(g+c))
    print Tm01


# Basis > 13 Nukleotide
# Tm=64.9+41*(G+C-16.4)/(A+T+G+C)

def methode02():
    global t,a,g,c
    Tm02=64.9+41*(g+c-16.4)/(a+t+g+c)
    print Tm02


# Salzkonezntration 14-70 N
# Tm=81,5°C + 16,6 * (log[M+]) + 0,41 * (%G+C) -(500/N)

def methode03():
    global t,a,g,c
    M=raw_input("Please enter the salt conc in mol/L without unit!")
    GC=(float(g)+float(c))/(float(t)+float(a)+float(g)+float(c))*100 # auf und abrunden!?
    N=t+a+g+c
    Tm03=81.5+16.6*(log10(float(M)))+0.41*float(GC)-(500.0/float(N))
    print Tm03

# Nearest Neighbour Methode

def methode04():

    global string

    kalium=input("Please enter the M Kalium in mol/L")
    magnesium=input("Please enter the M Magnesium in mol/L")
    enden=input("Wieviel überhängende Enden?")
    primer=input("Please enter your primer concentration in mol/L")

    ### Enthalpie H

    # Wärmemenge, die bei konst Temperatur, Druck und Volumen aufgenommen oder abgeben wird.
    # Berechnet aus Enthalpie der Reaktionsproukte minus der Enthalpie der Reaktanten.
    # Einheit kcal/mol

    werte = {"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}
    wertH=0
    
    for i in xrange(len(string)-1):
        paar = string[i:i+2]
        if paar in werte:
                wertH +=werte[paar]

    enthalpie_he = (-5000 * enden) / 1000          # in kcal/mol

    gesamt_enthalpie_h_kcalmol = wertH + (enthalpie_he)  

    enthalpie_h = gesamt_enthalpie_h_kcalmol * 1000     # Ergebnis in cal/mol
   


    ### Freie Energie G
    
    werte = {"aa":-1.55 , "ac":-1.40 , "ag":-1.45 , "at":-1.25 ,
            "ca":-1.15 , "cc":-2.30 , "cg":-3.05 , "ct":-1.45 ,
            "ga":-1.15 , "gc":-2.70 , "gg":-2.30 , "gt":-1.40 ,
            "ta":-0.85 , "tc":-1.15 , "tg":-1.15 , "tt":-1.55}
            
    wertG=0
            
    for i in xrange(len(string)-1):
        paar = string[i:i+2]
        if paar in werte:
                wertG +=werte[paar]

    freie_energie_ge = enden * -1000 / 1000          # in kcal/mol

    gesamt_freie_energie_g_kcalmol = wertG + (freie_energie_ge) + 2.2   

    g = gesamt_freie_energie_g_kcalmol * 1000      # Ergebnis in cal/mol

    ### Salzkonzentration

    s =(kalium)+4*(magnesium)**0.5         # Ergebnis

    ### Tm Formel

    upper = 298.2 * (enthalpie_h)
    lower = enthalpie_h - (g) + 1.99 * (298.2)* log(4*10**-7)
    l = 1.0 + 0.7 * (s)
    salz = s / l
    ls =log10(salz)

    tm = (upper/lower) + 16.6 * ls - 269.3

    return tm
Jetzt hab ich 2 Fragen

1) Kann ich es so programmieren, das mehrere Sequenzen sich berechnen lassen z.B. aus einer Text Datei raus? Ich habe ca. 500 Sequenzen.

2) Kann ich die Ausgabe von 1 in ein Excel file mit diesem Code http://www.python-forum.de/topic-10136. ... ight=excel exportieren?

Danke schonmal :)

ete
BlackJack

Dienstag 22. Mai 2007, 18:21

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
ete
User
Beiträge: 218
Registriert: Montag 19. Februar 2007, 13:19
Kontaktdaten:

Mittwoch 23. Mai 2007, 15:28

Danke für die Tips, ich werds sie gleich mal umsetzen :o
ete
User
Beiträge: 218
Registriert: Montag 19. Februar 2007, 13:19
Kontaktdaten:

Dienstag 5. Juni 2007, 16:17

So nach langer Krankheit hab ich mich wieder an die Arbeit gemacht :D

Ich habe versucht alle Verbesserungen die BlackJack angemerkt hat umzusetzen.

Jetzt sind noch einige Sachen offen, die ich nicht verstehe oder umsetzen kann.


1. "Werte sollten Funktionen in der Regel als Argumente betreten und als Rückgabewerte verlassen."

Könnte mir jemand ein Beispiel für meinen Code geben?
Ich habe das nicht so gemacht, weil ich wollte das irgend jemand nach einer Frage die Werte eingeben soll und nicht methode03(M,GC,N) aufrufen soll. Vielleicht versteh ich die Anregung falsch!?


2. "Auf Modulebene sollte so wenig wie möglich ausführbarer Code stehen. "

Blöde Frage aber was ist die Modulebene? Alles ausserhalb einer Funktion und Klasse?

Sorry für die blöden Fragen aber ich möcht ja was lernen :roll:

ete
schlangenbeschwörer
User
Beiträge: 419
Registriert: Sonntag 3. September 2006, 15:11
Wohnort: in den weiten von NRW
Kontaktdaten:

Dienstag 5. Juni 2007, 18:47

1.

Code: Alles auswählen

def bearbeiteX(X):
    machwas1(x)
    machwas2(x)
    x = x.methode1()
    ...
    return x

def main():
    print machwas(input("Frag nach X"))

main()
    
2.
Ja, Modulebene ist, was nicht in Klassen oder Funktionen steht.
Antworten