gesucht wird eine kreative Methode um Sachaufgaben zu erstellen

[Pitwheazle]

Na dann muss ich mal schauen, ob ich das verstehe. Danke!

[__blackjack__]

@Pitwheazle: Du sollst da gar keinen Text eingeben, denn "list()" ist ja eine Zeichenkette, die ist auch nicht aufrufbar. Aufrufbar heisst das kann man aufrufen. Funktionen und Methoden und Datentypen kann man in Python aufrufen (unter anderem). Wenn Du `list` aufrufst, dann ist das Ergebnis eine neue Liste und bei `dict` bekommt man ein neues Wörterbuch:

Code: Alles auswählen

In [7]: list()
Out[7]: []

In [8]: dict()
Out[8]: {}

Das `default`-Argument muss etwas sein was später von dem Rahmenwerk *aufgerufen* werden kann und daraufhin einen neuen Wert erzeugt, falls man keinen Wert übergeben hat. Irgendwie müssen diese Werte ja erzeugt werden. Du kannst da auch einen Lambda-Ausdruck angeben der erzeugt was Du haben willst, also ``default=lambda: []`` oder ``default=lambda: list()``, oder Du schreibst eine Funktion ``def create_default: return []`` und gibst die an: ``default=create_default``. Am einfachsten ist aber ``default=list`` weil `list` aufrufbar ist und eine neue Liste liefert wenn man das tut.

[Pitwheazle]

Das `default`-Argument muss etwas sein was später von dem Rahmenwerk *aufgerufen* werden kann und daraufhin einen neuen Wert erzeugt, falls man keinen Wert übergeben hat. Irgendwie müssen diese Werte ja erzeugt werden. Du kannst da auch einen Lambda-Ausdruck angeben der erzeugt was Du haben willst, also ``default=lambda: []`` oder ``default=lambda: list()``, oder Du schreibst eine Funktion ``def create_default: return []`` und gibst die an: ``default=create_default``. Am einfachsten ist aber ``default=list`` weil `list` aufrufbar ist und eine neue Liste liefert wenn man das tut.

Lieber @__blackjack__, ich habe Abitur (gar nicht mal schlecht), das große Latinum (erschwindelt) ein Mathe- und Physikstudium (allerdings nur Schmalspur als Lehramt) ... und muss jetzt wieder feststellen, dass mich das intelektuell überfordert. Ich fürchte, ich werde das nie endgültig verstehen und werde weiter auf eure geduldige Hilfe angewiesen sein.
Ich verstehe jetzt (vielleicht erstmalig), wie sich die begriffsstutzigen unter meinen Schülerinnen und Schülern gefühlt haben müssen, wenn sie trotz meiner geduldigen Erklärungen den entsprechenden Sachverhalt nicht verstanden haben.

Zum Evaluieren von Formeln gibt es Module, die das sicher können (das hier scheint so eins zu sein).

Das ist ja genial! Das funktioniert prima! Ich mir nicht träumen lassen, dass es sowas fertig gibt. Das "simplify" habe ich in meinem bestehenden Rechntrainer mühselig selbst programmiert.
Das ist das erste Mal, dass ich bewusst eine Bibliothek einsetze. Die muss ich, wenn ich meine Sachaufgaben fertig habe, dann wohl auch in uber.space installieren?

[Pitwheazle]

Nachdem das mit der Liste ja funktioniert, erscheint es mir doch sinnvoll, lieber ein dict zu verwenden.
Anstelle von

[[5, 10, 15, 20, 25], [1, 1.2, 1.5, 2, 2.5]]

wollte ich jeweils eine Liste für die Variablen erstellen, aus der ich dann zufällig eine auswähle, aber
{"liste_a":[5, 10, 15, 20, 25], "liste_b":[1, 1.2, 1.5, 2, 2.5]}
funktioniert (natürlich) wieder nicht und weder
{"liste_a":5, 10, 15, 20, 25, "liste_b":1, 1.2, 1.5, 2, 2.5}
noch
{"liste_a":(5, 10, 15, 20, 25), "liste_b":(1, 1.2, 1.5, 2, 2.5)}
Was ist da falsch? Bei meiner Suche finde ich hier nur Beispiele mit Strings aber nicht mit Zahlenwerten - geht das nicht?

[Dennis89]

Hallo,

was genau funktioniert denn an deinem ersten Beispiel nicht. Bei mir gehts:

Code: Alles auswählen

>>> pitwheazle_dictonary = {"liste_a":[5, 10, 15, 20, 25], "liste_b":[1, 1.2, 1.5, 2, 2.5]}
>>> print(pitwheazle_dictonary.values())
dict_values([[5, 10, 15, 20, 25], [1, 1.2, 1.5, 2, 2.5]])
>>> print(pitwheazle_dictonary.keys())
dict_keys(['liste_a', 'liste_b'])

Grüße
Dennis

[Pitwheazle]

Ich habe jetzt eine Liste mit einer unterschiedlichen Listen von Variablen - z.B. mit 2 Variablen:

Code: Alles auswählen

[[5, 10, 15, 20, 25], [1, 1.2, 1.5, 2, 2.5]]

Es kann aber auch nur eine oder mehr als 2 sein. Jetzt habe ich folgenden Code um die Variablen festzulegen:

Code: Alles auswählen

        items = len(variable)           # variablen insgesamt 
        a=random.choice(variable[0])
        if items>1:
            b=random.choice(variable[1])          
        if items>2:
            c=random.choice(variable[2]) 
        if items>3:
            d=random.choice(variable[3])... 

das lässt sich doch sicher mit

Code: Alles auswählen

for item in variable ...

eleganter lösen?

Und ein Nachtrag: Wie ich mich kenne, bekomme ich dann auch diesen Code

Code: Alles auswählen

text = aufgabe.text.format(a,b) 

auch nicht auf die unterschiedliche Anzahl von Variablen angepasst.

[Pitwheazle]

was genau funktioniert denn an deinem ersten Beispiel nicht. Bei mir gehts:

Entschuldige, ich habe die Antwort anscheinend vergessen loszuschicken:
ich wollte dir die Fehlermeldung kopieren, die angezeigt wird, wenn ich die Beispiele in meinem JSONField eintrage - jetzt funktioniert es - warum auch immer.

[Dennis89]

Hallo,

ich rätsle schon seit einiger Zeit, aber ich kann immer nur vermuten was das eigentliche Ziel ist. 'aufgabe.text.format(a, b)' nimmt nur zwei Argumente entgegen, weiter oben hast du eine Liste mit einer undefinierten Anzahl von Zahlen, die da irgendwie rein sollen.
Könntest du bitte einen kleinen vollständigen Beispielcode zeigen, damit man sieht was das Ziel ist?

Grüße
Dennis

[Pitwheazle]

Also im Prinzip geht es darum Sachaufgaben mit Zufallszahlen zu erstellen. Die Texte speichere ich in der Datenbank, ebenso Listen (neuerdings Dics) mit den Variablen und den Lösungsweg als String (z.B. a•b). Im View werden die Teile wieder zusammengesetzt. Mit parser.parse('a‘ = a).evaluate({}) usw. wird dann die Lösung berechnet.Da in den verschiedenen Texten unterschiedliche Anzahlen von Variablen auftauchen, wollte ich das Erstellen der Variablen vereinfachen. Für den „parser“ Code benötige ich die Namen der Variablen, also z.B. „a=20“ - die Namen kann man aber wohl nicht aus den keys der dicts erstellen. Ich habe Kollegen im Netz gefunden, die ähnliche Probleme haben, aber keine Lösungen dazu. Ich werde das wohl mit „if“, „eilif“ ... anstelle von „for ... in“ lösen.

[grubenfox]

Und ein Nachtrag: Wie ich mich kenne, bekomme ich dann auch diesen Code

Code: Alles auswählen

text = aufgabe.text.format(a,b) 

auch nicht auf die unterschiedliche Anzahl von Variablen angepasst.

"Variable" im Sinne von Variable in Python und/oder "Variable" im Sinne von Variable in der Mathematik?

Was ist mit dem *?
Hier als Python-Funktionsdefinition:

Code: Alles auswählen

def format( *a):
    print(type(a))
    print(str(a))

ungetestet müsste die eigentlich gesuchte Methoden-Definition so aussehen:

Code: Alles auswählen

def format(self, *a):
    print(type(a))
    print(str(a))

[Pitwheazle]

Dankeschön

[Sirius3]

Ich bin bei der ganzen Diskussion nicht mehr mitgekommen, wo denn das eigentliche Problem ist.
Eigentlich steht doch schon alles da, nur noch nicht in einem Code:

Code: Alles auswählen

import random
import sympy

text = "Wie viele {a}cm lange Stücke kann man von einer {b}m langen Leiste absägen?"
ergebnis = "100*b/a"
variablen_auswahl = {"a": [5,10,15,20,25], "b": [1,1.2,1.5,2,2.5]}

variablen = {
    name: random.choice(werte)
    for name, werte in variablen_auswahl.items()
}
print(text.format(**variablen))
print("Lösung:", sympy.sympify(ergebnis).subs(variablen))

[grubenfox]

mich hat es wohl bei der variablen Verwendung des Wortes Variablen aus der Bahn geworfen... (bei meinen eigenen Programmen nutze ich ja meist deutschsprachige Begriffe für z.b. Variablen- oder Funktionsnamen. Da wähne ich mich dann auf der sicheren Seite dass es zu keinen Namenskollisionen zwischen meinen deutschsprachigen Definitionen und den englischen Bezeichnern der Programmiersprache bzw. Bibliothek kommt. Aber wenn hier gleichzeitig über Mathematik und Programmcode geschrieben wird... und z.b. eben Variablen und Funktionen erwähnt werden...)

[Pitwheazle]

Ich bin bei der ganzen Diskussion nicht mehr mitgekommen, wo denn das eigentliche Problem ist.

Das Problem besteht jetzt noch darin, dass ich auch noch ein Ergebnis berechnen muss. @sparrow hatte die geniale Idee mit diesem "parser" Code und der funktioniert auch prima. Da muss ich aber in z.B. "parser.parse('a‘ = a).evaluate({}) " das a mit dem entsprechenden Wert ersetzen und das habe ich noch nicht mittels "for ... in" hinbekommen, da ich die eine wechselnde Anzahl von Variablen von a bis f ersetzen muss.
Ich bin auf Reisen, das dauert alles etwas länger mit meinem kleinen 12" Bildschirm, ich schicke nachher meinen "uneleganten" Code mit "if ... elif".

[Pitwheazle]

mich hat es wohl bei der variablen Verwendung des Wortes Variablen aus der Bahn geworfen... (bei meinen eigenen Programmen nutze ich ja meist deutschsprachige Begriffe für z.b. Variablen- oder Funktionsnamen.

Ich habe ja auch schon geschrieben, dass ich meinen Code möglichst mit deutschen Benennungen schreibe. Hast du eine Idee, wie ich die Variablen aus der Mathematik "a=20" von denen im Code "a=20" unterscheiden kann?

[Pitwheazle]

Hier ist mein uneleganter Code:

Code: Alles auswählen

        stellen=parameter[2]            # Anz der Dezimalstellen
        variable=parameter[3]
        print(variable)
        term=aufgabe.loe_weg
        parser = Parser()            
        items = len(variable)           # varaiable insgesamt 
        a=b=c=d=e=f=""
        if items>0:
            a=random.choice(variable["a"])
            if 'a' in term:
                term=parser.parse(term).substitute('a',a).toString()
        if items>1:
            b=random.choice(variable["b"])
            if 'b' in term:
                term=parser.parse(term).substitute('b',b).toString()          
        if items>2:
            c=random.choice(variable["c"])
            if 'c' in term:
                term=parser.parse(term).substitute('c',c).toString()  
        if items>3:
            d=random.choice(variable["d"]) 
            if 'd' in term:
                term=parser.parse(term).substitute('d',d).toString() 
        if items>4:
            e=random.choice(variable["e"])
            if 'e' in term:
                term=parser.parse(term).substitute('e',e).toString() 
        if items>5:
            e=random.choice(variable["f"])
            if 'f' in term:
                term=parser.parse(term).substitute('f',f).toString() 
        term=term.replace("(","").replace(")","")
        ergebnis=parser.parse(term).evaluate({}) 
        print(ergebnis)       
        text = aufgabe.text.format(a,b,c,d,e,f)
        print(text) 
        pro_text = aufgabe.pro_text+term
        variable = ""
        frage = aufgabe.links_text
        einheit = aufgabe.rechts_text
        rest=""
        if stellen==0:
            if ergebnis%1:
                anmerkung=aufgabe.anmerkung
                rest = "+Rest"
            ergebnis=ergebnis//1
        print(ergebnis)
        term=term.replace(".",",")
        lsg = term + "=" + format_zahl(ergebnis,stellen) + rest
        print(lsg)

Er funktioniert:
{'a': [5, 10, 15, 20, 25], 'b': [1, 1.2, 1.5, 2, 2.5]}
16.666666666666664
Wie viele 15cm lange Stücke kann man von einer 2.5m langen Leiste absägen?
16
100*2,5/15=16+Rest[/code]

Noch eine Anmerkung: Das

Code: Alles auswählen

 if 'x' in term:

habe ich eingefügt, da nicht alle Variable zur Berechnung des Ergebnsisses eingesetzt werden. So kann ich z.B. auch Namen zufällig einsetzen oder Zahlen, die nicht für die Lösung benötigt werden.

[Sirius3]

Es ist schade, dass Du gar nicht auf meinen Code eingehst. Denn der zeigt, wie man mit dem Deinem Problem umgehen muß.
1. Du hast Variablen, die Namen haben, also ist es wichtig, diese Namen überall einzusetzen, also auch im Aufgabentext.
2. Für die Zuordnung Name -> Wert gibt es in Python Wörterbücher. Und mit Wörterbüchern kann man auch in Schleifen arbeiten.

Wenn man mit replace auf Ausdrücke losgeht, macht man irgendwas falsch, vor allem, wenn man Klammern einfach so löscht.

[grubenfox]

Ich habe ja auch schon geschrieben, dass ich meinen Code möglichst mit deutschen Benennungen schreibe. Hast du eine Idee, wie ich die Variablen aus der Mathematik "a=20" von denen im Code "a=20" unterscheiden kann?

Nicht wirklich... der Vorschlag Mathematik und Informatik nicht zu vermischen ist ja nun nicht wirklich zielführend. Bei den Gleichungen (also hier die mathematischen Ausdrücke mit Gleichheitszeichen oder ähnlichem) könnte man theoretisch auf die griechischen Buchstaben ausweichen. Aber ob das hier im Forum machbar ist?

Nur bei den normalen Sätzen ist eine Variable halt entweder eine Variable (math.) oder eine Variable (Python)....
Wobei.. vielleicht genau so? Aber schön zu lesen ist das dann auch nicht.

[Pitwheazle]

Es ist schade, dass Du gar nicht auf meinen Code eingehst. Denn der zeigt, wie man mit dem Deinem Problem umgehen muß.

Ich hatte halt zwischenzeilich schon mal alleine probiert das zum Laufen zu bringen. ich probiere das mit den Namen später noch aus - so ist der Code ja wirklich nicht schön.

2. Für die Zuordnung Name -> Wert gibt es in Python Wörterbücher. Und mit Wörterbüchern kann man auch in Schleifen arbeiten.

Das hatte ich ja versucht. Unbedarft war ich davon ausgegangen, dass "a" im Wörterbuch ein Key ist und ich brauche das a halt dann als Variablenname. Bisher hatte ich das nicht hinbekommen und nach Recherchen im Internet den Versuch aufgegeben (da wurde u.A. empfohlen, den Versuch keys in Varaiablenamen (identifier) zu wandeln aufzugeben) - aber wenn du da hoffnungsvoll bist gehe ich da ebenfalls nochmals hoffnungsvoll dran.

Wenn man mit replace auf Ausdrücke losgeht, macht man irgendwas falsch, vor allem, wenn man Klammern einfach so löscht.

Ich habe zunächst mal die Klammern rausgeworfen, weill ich den Schülerinnen und Schülern, wenn sie auf "Lösung anzeigen" klicken, den Lösungsweg anzeigen wollte und der wurde von parse z.B. zu "(1.2*(100/5))=24" anstelle von - "1,2*100/5" ich fürchte, das verstehen sie nicht auf Anhieb und werden sich auch nicht weiter darauf einlassen. Dass ich bei weiteren Aufgaben u.U. auch eine Klammer im Lösungsweg benötige habe ich schon vorgeplant.

[Pitwheazle]

Hast du eine Idee, wie ich die Variablen aus der Mathematik "a=20" von denen im Code "a=20" unterscheiden kann?

Ich könnte ja in Zukunft "a=20" (math) und "a=20" (code) schreiben? Oder nur "variable (math)" und "variable (code)".
Griechische Buchstaben sind für mich Benennungen für Winkel und mit denen werde ich mich (oder auch wir uns ) als nächstes beschäftigen. Da habe ich schon große Bedenken, wie ich das mit den kartesischen- und den Polarkoordinaten bei den Winkelbogen löse.