Das tolle an Python ist doch, dass man durch die "Selbstdeklarierung" der Variablen nicht vorher wissen muss, wieviele Variablen man hat.
Mittelwert berechnen... der Mittelwert ist doch Summe der Werte durch ihre Anzahl, wa?
Okay das saehe dann so aus:
Code: Alles auswählen
def mittelwert(*werte):
# als Tipp: sum() bildet die Summe aus den (numerischen) Elementen
# einer Liste, len() gibt die Laenge von Elementen (zB Listen oder Strings) zurueck,
# damit wir Fließkommagenauigkeit bekommen, wandeln wir einfach einen der
# Operanden in einen float um.
return sum(werte)/float(len(werte))
Nun musst du noch die Eingabe der Zahlen realisieren...
Das kann auf deine Weise machen... oder einfach ueber Parameter. Ich bevorzuge meist Zweiteres.
Damit das funktioniert, muessen wir aber die erste Funktion ein wenig aendern:
Code: Alles auswählen
def mittelwert(werte):
# als Tipp: sum() bildet die Summe aus den (numerischen) Elementen
# einer Liste, len() gibt die Laenge von Elementen (zB Listen oder Strings) zurueck,
# damit wir Fließkommagenauigkeit bekommen, wandeln wir einfach einen der
# Operanden in einen float um.
return sum(werte)/float(len(werte))
...das Sternchen wuerde normalerweise ermoeglichen, beliebig viele Variablen zu uebergeben (zB: mittelwert(1,2,3,4,5)) ...aber da wir ja bereits eine Liste haben (naemlich die Argumentenliste), nutzen wir die gleich direkt:
Code: Alles auswählen
def mittelwert(werte):
# als Tipp: sum() bildet die Summe aus den (numerischen) Elementen
# einer Liste, len() gibt die Laenge von Elementen (zB Listen oder Strings) zurueck,
# damit wir Fließkommagenauigkeit bekommen, wandeln wir einfach einen der
# Operanden in einen float um.
return sum(werte)/float(len(werte))
if __name__ == '__main__':
import sys
print mittelwert(sys.argv[1:])
All das ist nun auch garnicht so schwierig in deinem Programm fuer die Berechnung (ich habs schonwieder vergessen
) - achja - des Korrelationskoeffizienten zu verwenden.
r_xy = summe aus (x_i minus mittelwert von x) mal (y_i minus mittelwert yon y) / wurzel von summe aus (x_i minus mittelwert von x)^2 mal wurzel von summe aus (y_i minus mittelwert von y)^2
Das uebersetzt nach Python und in eine Funktion gesteckt ergaebe ungefaehr folgendes:
Code: Alles auswählen
def r_xy(x, y, x_i, y_i):
# die Doppelsternchen sind uebrigens fuer Potenzrechnungen gedacht (^2 => **2)
# **0.5 ersetzt die Funktion math.sqrt()
return ((x_i - mittelwert(x))*(y_i - mittelwert(y))) / (((x_i - mittelwert(x))**2 * (y_i - mittelwert(y)**2)))**0.5
Sieht aus wie Lisp... ist es aber nicht ^^
Aber man braucht nichtmal das Modul
math.
Ich vermute mal,
x und
y sind Listen von Zahlen. Was die anderen Variablen zu bedeuten haben, weiß ich allerdings nicht
Okay, so weit so gut... nun wird noch eine Moeglichkeit gebraucht, die Werte in das Programm zu bringen.
Das ginge einerseits ueber den Input-Stream, andererseits ueber Argumente. Ich (der ja normalerweise die Argumentenuebergabe bevorzugt) glaube, dass man bei den komplizierten Angaben, das Programm wohl besser ja jeden Wert extra fragen lassen sollte.
An sich brauch das Programm (wenn ich das hier richtig verstehe) die Werte
x_i und
y_i und zwei Listen von Werten, naemlich
x und
y.
Das saehe bei mir (schnell und grob zusammengehackt) so aus:
Code: Alles auswählen
def werte_erfragen():
# folgende Schleife Fragt solange (und immerwieder) nach dem Wert, bis er erfolgreich
# in einen Integer umgewandelt werden konnte. Brauchst man eine Kommazahl,
# ersetzt man int() einfach durch float()
while True:
try:
x_i = int(raw_input("Wert fuer x_i? "))
break # hier wird die Schleife beendet, falls alles gut ging
except:
print "\nFehler in der Eingabe. Nur Zahlen sind erlaubt!"
# nun das ganze nochmal fuer y_i:
while True:
try:
y_i = int(raw_input("Wert fuer y_i? "))
break
except:
print "\nFehler in der Eingabe. Nur Zahlen sind erlaubt!"
# Ein wenig kniffliger wird es, eine Liste von Werten abzufragen. An sich, aber
# kein Problem in Python:
while True:
try:
x = raw_input("Bitte kommaseparierte Liste fuer x-Werte angeben: ")
x = x.split(",")
# Hier nun eine Listcomprehension. Diese ermoeglicht einige Arbeit
# und "Schleiferei" in einer einzigen Zeile:
x = [int(wert) for wert in x]
break
except:
print "\nFehler bei der Eingabe. Bitte nur Zahlen und Kommas eingeben",
print "(zB so: 25,27,4,3,4)"
# so, nun noch die Liste fuer y:
while True:
try:
y = raw_input("Bitte kommaseparierte Liste fuer y-Werte angeben: ")
y = y.split(",")
y = [int(wert) for wert in y]
break
except:
print "\nFehler bei der Eingabe. Bitte nur Zahlen und Kommas eingeben",
print "(zB so: 25,27,4,3,4)"
Die Abfrage einer Liste von Zahlen ginge mit Hilfe einer Listcomprehension uebrigens auch in einer Zeile:
Code: Alles auswählen
x = [int(wert) for wert in raw_input("Bitte kommaseparierte Liste fuer x-Werte angeben: ").split(',')]
Natuerlich muessen dann noch die while-Schleife, break und das try-except-Statement drumrum. Falls wieder Kommazahlen erwuenscht sind, bitte int() durch float() ersetzen.
An sich haben wir nun alles, was wir brauchen:
- eine Funktion zur Berechnung des Mittelwertes
- eine Abfrage fuer all die benoetigten Werte und somit auch...
- Werte fuer x, y, x_i und y_i
- eine Funktion zur Berechnung von r_xy
All das zu einem Programm zusammen zu fuehren, sollte nicht zu schwierig sein. Also dann mal ran und viel Spaß weiterhin mit Python