@Cortez: Noch ein paar Anmerkungen zum Quelltext: Die Klasse macht hier absolut keinen Sinn. Das sieht man im Grunde schon am Namen. Exemplare dieser Klasse stehen nicht für einen Test. Und es fällt mir auch kein passender Name für die Klasse ein. Dir etwa?
Namen schreibt man in Python klein_mit_unterstrichen, ausgenommen Konstanten (KOMPLETT_GROSS) und Klassen (MixedCase).
Um das ``=`` bei Zuweisungen ausserhalb von Argumentlisten schreibt man üblicherweise Leerzeichen. Zwischen Funktionsnamen und öffnender Klammer dagegen kein Leerzeichen. Das machst Du bei `print()` überall.
`array_irgendwas` ist ein falscher Name für eine *Liste*. Listen sind keine Arrays. Es gibt in Python auch Arrays, darum kann so etwas für Verwirrung sorgen. Aber auch `list` oder `liste` sollte in Namen nicht auftauchen. Den Leser interessiert doch weniger welcher Grunddatentyp hinter dem Namen steht, als vielmehr was der Wert im Kontext des Programms *bedeutet*. Um das Programm leichter zu verstehen ist es doch wichtiger zu wissen das in der einen Liste irgendwelche Zahlen und in der anderen Noten stehen, statt das das eine die erste Liste im Code ist und die andere die Zweite. Sequenzdatentypen bennent man üblicherweise in der Mehrzahl des Namens, den man einem einzelnen Element geben würde. Also hier beispielsweise `zahlen` und `noten`.
`Funk1()` und `Funk2()` sind ganz offensichtlich keine Methoden, weil die überhaupt nicht auf das Objekt zugreifen auf dem sie sitzen. Wenn man die aus der Klasse heraus holt, sieht man auch das `Rechnung()` ebenfalls keine Methode ist. Und mit `summe3` wird nirgends etwas gemacht. Irgendwelche Zahlen mit Noten aufzuaddieren macht ja auch gar keinen Sinn. Insgesamt macht `Berechne()` keinen Sinn. Das berechnet den Durchschnitt von irgendwelchen Zahle und den von Noten. Was hat das miteinander zu tun? Was wäre denn ein passender, nicht-generischer Name für diese Funktion?
Wenn man das ``global`` in `Funk1()` und `Funk2()` durch Rückgabewerte ersetzt, sieht man, dass beide Funktionen exakt das gleiche machen. Das ist also in Wirklichkeit nur eine einzige Funktion. Der man auch einen deutlich besseren Namen als `Funk_irgendwas` geben kann. Funktionen werden üblicherweise nach der Tätigkeit benannt, die sie durchführen. Also beispielsweise `berechne_durchschnitt()` in diesem Fall.
Zudem lässt sich die Funktion mit der eingebauten `sum()`-Funktion drastisch verkürzen.
`Arraybefüllen()` und `Array2befüllen()` heissen nicht nur verdammt ähnlich, sondern sehen auch extrem ähnlich aus. Wenn man die die Liste einfach selbst erzeugen und zurückgeben lässt, dann sind das auch ganz normale Funktionen die aus der ”Klasse” raus müssen, und wenn man den einzigen Unterschied durch ein Argument in diesen Code hinein bringt, dann ist das auch nur *eine* Funktion.
`Anzahl` sollte nicht an eine Zeichenkette mit Ziffern, sondern an eine Zahl gebunden werden.
Nun hat die ”Klasse” keine Methoden mehr. Nur noch die beiden globalen Listen die nicht wirklich etwas miteinander zu tun haben. Also weg mit der Klasse.
Da bleiben dann drei Funktionen übrig. Eine um den Durchschnitt zu berechnen. Eine um den Benutzer nach Zahlen zu fragen. Und die Hauptfunktion für den restlichen Code:
Code: Alles auswählen
#!/usr/bin/env python3
def berechne_durchschnitt(werte):
summe = sum(werte)
return (summe, summe / len(werte))
def erfrage_zahlen(bezeichnung_einzahl, bezeichnung_mehrzahl):
zahlen = list()
for _ in range(int(input(f'Wieviele {bezeichnung_mehrzahl}: '))):
zahlen.append(int(input(f'Bitte {bezeichnung_einzahl} eingeben: ')))
print(zahlen)
return zahlen
def main():
zahlen = erfrage_zahlen('Zahl', 'Zahlen')
noten = [1] + erfrage_zahlen('Note', 'Noten')
zahlendurchschnitt = berechne_durchschnitt(zahlen)
notendurchschnitt = berechne_durchschnitt(noten)
print('`Zahlen` enthält die Werte', zahlen)
print('Der Durchschnitt von `Zahlen` beträgt:', zahlendurchschnitt)
print('`Noten` enthält die Werte', noten)
print('Der Durchschnitt von `Noten` beträgt', notendurchschnitt)
if __name__ == '__main__':
main()
Wenn man sich das anschaut was übrig bleibt und in der Hauptfunktion landet, dann sieht man wieder ein Muster. Da wird immer abwechselnd etwas für allgemeine Zahlen und für Noten gemacht. Wenn man das so umordnet, das erst alles für Zahlen und dann alles für Noten in der Funktion steht, sieht man, dass beides fast gleich ist, und sich nur geringfügig voneinander unterscheidet:
Code: Alles auswählen
def main():
zahlen = erfrage_zahlen('Zahl', 'Zahlen')
zahlendurchschnitt = berechne_durchschnitt(zahlen)
print('`Zahlen` enthält die Werte', zahlen)
print('Der Durchschnitt von `Zahlen` beträgt:', zahlendurchschnitt)
noten = [1] + erfrage_zahlen('Note', 'Noten')
notendurchschnitt = berechne_durchschnitt(noten)
print('`Noten` enthält die Werte', noten)
print('Der Durchschnitt von `Noten` beträgt', notendurchschnitt)
Hier lassen sich die Unterschiede aus den beiden Abschnitten als Daten herausziehen und in einer Schleife abarbeiten:
Code: Alles auswählen
def main():
for anfangswerte, bezeichnung_einzahl, bezeichnung_mehrzahl in [
([], 'Zahl', 'Zahlen'), ([1], 'Note', 'Noten')
]:
werte = (
anfangswerte
+ erfrage_zahlen(bezeichnung_einzahl, bezeichnung_mehrzahl)
)
durchschnitt = berechne_durchschnitt(werte)
print(f'`{bezeichnung_mehrzahl}` enthält die Werte {werte}')
print(
f'Der Durchschnitt von `{bezeichnung_mehrzahl}` beträgt:'
f' {durchschnitt}'
)
