Seit 2002 Diskussionen rund um die Programmiersprache Python
https://www.python-forum.de/
Das hat etwas mit der Erdrotation zu tun, ist aber viel komplex um das hier zu erläutern.derdon hat geschrieben:EyDu: Du empfiehlst aufsteigende ganze Zahlen als Schlüssel für dicts zu verwenden? Warum?
Code: Alles auswählen
def umfang_rechteck(a,b):
return a*b
def end():
raise KeyboardInterrupt
def main():
options = {'1': dict(str='Umfang Rechteck', func=umfang_rechteck, params=('a','b')),
'e': {'func': end},
}
def print_menu():
print 'Menu'
for i in range(1, len(options)):
print '%s. %s' %(i, options[str(i)]['str'])
print 'e for end'
print
def get_choice():
exercise = None
while not exercise:
choice = raw_input('Bitte treffen Sie eine Auswahl: ')
exercise = options.get(choice, None)
params = {}
for param in exercise.get('params', ()):
params[param] = int(raw_input("Bitte einen Wert fuer %s eingeben: " %param))
return exercise['func'], params
try:
while True:
print_menu()
func, kwargs = get_choice()
print func(**kwargs)
print
except KeyboardInterrupt:
print 'end'
if __name__ == '__main__':
main()
Ich rede von den zwei Zeilen, die meine Funktionen für die Berechnungen haben.BlackJack hat geschrieben:@rolgal_reloaded: `main()` weil Code und Variablen auf Modulebene unsauber sind. Da besteht halt immer die Gefahr, dass man die aus versehen oder absichtlich zur Kommunikation zwischen Funktionen oder Methoden verwendet und damit unnötige Abhängigkeiten einbaut die schwerer zu verstehen sind.
Von welchen zwei Zeilen Code redest Du? Überleg Dir mal wie man bei Deinem Code weitere Funktionen hinzufügt und wie das bei jbs' Code aussieht.
Code: Alles auswählen
def get_choice():
exercise = None
while not exercise:
choice = raw_input('Bitte treffen Sie eine Auswahl: ')
exercise = options.get(choice, None)
Was willst du uns also damit sagen?http://docs.python.org/library/stdtypes.html#dict.get hat geschrieben:If default is not given, it defaults to None
Ich bin eigentlich davon ausgegangen, dass aus "Benutzereingabe" und "nicht in die Berechnungsfunktion" deutlich wird, dass du nicht die Berechnung in Dictionaries packen sollst.rolgal_reloaded hat geschrieben:Und ob die Funktionen im Dict. besser lesbar sind....da kann ich sie doch frisch ausschreiben, der Zweizeiler ist mir da sympahtischer, oder gibts in deiner Fassung einen wesentlichen Vorteil?
Mit Dekoratoren wirds dann doch ganz schön magischEyDu hat geschrieben:Es läuft im Prinzip auf jbs Vorschlag mit den "options" Hinaus. Auch wenn ich kein inneres Dictionary sondern ein Tupel verwenden würde. Mit Dekoratoren kann man das ganze aber noch schöner gestalten.
.Ich bündle die Sachen, die zusammen gehören. Jede Aufgabe hat eine Nummer, die auch später dann im Menü auftaucht. Diese ist zugleich der Key. Unter dem Wert verbergen sich dann die Beschreibung, die ich unglücklicherweise auf die Schnelle `str` genannt habe. Vielleicht wäre hier `desc` besser gewesen. Dann bildet ja jede Option im Menü eine Funktion ab, weshalb diese ebenfalls hinzugefügt wird. Dazu kommen noch die Parameter, die benötigt werden. Alternativ könnte man die Funktion untersuchen und schauen, welche Parameter sie benötigt und danach entsprechend fragen. Wenn man es dann noch besser haben möchte, könnte man die Docstrings auswerten, die zuvor noch sinnvoll erstellt werden müssen.rolgal_reloaded hat geschrieben:Erst jetzt habe ich gesehen, dass ich den Code von jbs doch nicht geschnallt habe. Wofür überhaupt options?
LG
r_r
@edit:
ach nee, forget it
Code: Alles auswählen
# -*- coding: utf-8 -*-
class Collection(object):
def __init__(self):
self.functions = {}
def __call__(self, description, output="{0}"):
def wrapper(function):
name = function.func_name
varnames = function.func_code.co_varnames
argcount = function.func_code.co_argcount
args = varnames[:argcount]
self.functions[name] = (function, description, output, args)
return function
return wrapper
def __getitem__(self, name):
return self.functions[name]
collection = Collection()
@collection("multiplies {1} with {2}", "{1}*{2}={0}")
def mul(a, b):
return a * b
@collection("squares {1}")
def square(a):
return a**2
def main():
while True:
name = raw_input("function:")
function, description, output, args = collection[name]
print '"%s" %s:' % (name, description.format(name, *args))
params = [float(raw_input(" %s=" % arg)) for arg in args]
x = function(*params)
print output.format(x, *params)
if __name__ == "__main__":
main()Code: Alles auswählen
function:mul
"mul" multiplies a with b:
a=2
b=3
2.0*3.0=6.0
function:square
"square" squares a:
a=4
16.0
function:
Naja, alltäglich ist das nicht. Mein Lehrer ist fasziniert davonEyDu hat geschrieben:Wo ist denn hier Magie?
. Nennt man sowas nicht deklarativ? Weil so imperativ sieht das nicht mehr aus.Du beschreibst die Funktion und lässt den Rest automatisch machen.Die deklarative Programmierung ist ein Programmierparadigma, bei dem die Beschreibung des Problems im Vordergrund steht. Der Lösungsweg wird dann automatisch ermittelt.