Gewinnspiel

[snafu]

Und was BlackJack sicherlich meint, läuft auf die Benutzung von Funktionen hinaus (was dir ja hier nicht gerade zum ersten Mal nahegelegt wird). Es wäre ideal, wenn man als Anwender deines Programms eigene Fragen hinzufügen könnte. Entweder mittels `fuege_frage_hinzu(meine_frage)` (wobei `meine_frage` hier ein Tupel in der bereits bekannten Form wäre) oder indem man aus einer Datei liest, die der Benutzer an einer bestimmte Stelle gespeichert hat. Letzteres schließt im Grunde ersteres (also die Hinzufügen-Funktion) mit ein und wäre wohl eher als Erweiterung zu verstehen, an die du dich jetzt auch noch nicht unbedingt heranwagen solltest.

[Gary123456]

Hi all,

@snafu)

Nichts für ungut, aber vielleicht solltest du es für heute gut sein lassen und mal ne Nacht drüber schlafen. Es ist nicht wirklich zielführend, wenn du hier alle halbe Stunde oder so etwas präsentierst, von dem du glaubst, dass es *jetzt aber* richtig sein müsste. Wie gesagt: Denke mehr über den Sinn diverser Tipps nach und weniger darüber, wie du eine bestimmte Vorgehensweise möglichst häufig im Programm anwenden kannst. Als Programmierer sollte man einfach wissen, wo genau ein bestimmter Datentyp geeignet erscheint. Immer nur das Schema F anzwenden, ist Blödsinn.

Das ist ein guter Tipp, denn Schlaf könnt ich wirklich gebrauchen. Ich hoffe dennoch, dass die Erfahrung mit der Zeit größer wird und auch meine Neugierde auf neues Wissen immer erhalten bleibt.

@BlackJack)

Dict ist in meinem neuen Buch noch nicht besprochen worden. Werde daher mal im Galileo Buch wieder mal nachsehen. Ich werde das jetzt so lange üben, bis ich das kann und auch zufriedenstellend in mein Programm einfügen. Denn wenn man die Hintergründe von Tupel und Listen kennt, weiss man wie wichtig sowas ist.

@snafu)

Ich habe vorher gesagt, dass ich alles Schritt für Schritt machen. Datenstruktur ist primär, danach kommt Verwendung von Funktionen und zu guter Letzt Klassen. Ich werde das Programm von Kapitel zu Kapitel umändern

[Gary123456]

Hi,

nun diesmal eine längere Antwort (hoffe zumindest mal).

Ich habe mir im anderen Buch nun das Kapitel 'Dictionarys' angesehen. Aber für mein Programm ist das denke ich noch unnötig.

Ich speichere alle Fragen und Antworten in einer Liste, um sie dann abrufen zu können.

Hab da etwas rumexperimentiert und habe dabei diesen Code erschaffen:

Code: Alles auswählen

import easygui

liste = [[("Was ist Fifa13?", ["Ein Computerspiel", "Eine Trompete", "Eine Uhr"]), ("Was ist Python?", ["Eine Programmiersprache", "Eine Computerschlange", "Das Internet"])]]


print liste[0][0][0] #Was ist Fifa13
print liste[0][0][1] #Antworten dazu in einer Liste
print 
print liste[0][1][0] #Was ist Python
print liste[0][1][1] #Antworten dazu in einer Liste
print
print liste[0][0][1][0] #Lösung für 1. Frage
print liste[0][1][1][0] # Lösung für 2. Frage
print

for i in liste[0][0][0]:
    print i, #Ausgabe der 1. Frage mit vielen Leerzeichen!(da ,)
print
for k in liste[0][1][0]:
    print k, #Ausgabe der 2. Frage mit vielen Leerzeichen (da ,)

Ich habe dabei genau kommentiert, was der ausgibt. Damit könnte ich praktisch wieder ein Programm schreiben, jedoch sind die vielen Indizes, wie BlackJack schon sagte, sehr kompliziert.

Man benutzt Datenstrukturen um Daten auf möglichst leichtem Wege zu speichern. Meiner Meinung eignen sich dafür Listen, Tupel und Dictionarys am Bestem. Nur das Aufrufen mehrerer Indizes ist kompliziert und daher auch viel Denkarbeit! Ich denke mir immer wieder, was die beste Taktik sei, Daten zu speichern, aber sie wieder aufzurufen?

Nun ändere ich das Programm so ab, damit die Fragen mit einer GUI ausgegeben werden:

Code: Alles auswählen

import easygui

liste = [[("Was ist Fifa13?", ["Ein Computerspiel", "Eine Trompete", "Eine Uhr"]), ("Was ist Python?", ["Eine Programmiersprache", "Eine Computerschlange", "Das Internet"])]]

ende = 1
punkte = 0

while ende == 1:
    frage1 = easygui.buttonbox(liste[0][0][0], choices = liste[0][0][1])
    frage2 = easygui.buttonbox(liste[0][1][0], choices = liste[0][1][1])
    if frage1 == liste[0][0][1][0]:
        punkte += 100
    if frage2 == liste[0][1][1][0]:
        punkte += 100
    ende = 0

print punkte

In diesem Programm sind immer die ersten Möglichkeiten die richtigen Antworten. Da wäre meine erste Frage schon mal, wie man die vermischen kann. Somit habe ich mir das Modul random etwas angeschaut und habe dabei random.shuffle() gefunden.

In der Hoffnung das dieses geht:

Code: Alles auswählen

import easygui, random

liste = [[("Was ist Fifa13?", ["Ein Computerspiel", "Eine Trompete", "Eine Uhr"]), ("Was ist Python?", ["Eine Programmiersprache", "Eine Computerschlange", "Das Internet"])]]

ende = 1
punkte = 0

while ende == 1:
    frage1 = easygui.buttonbox(liste[0][0][0], choices = random.shuffle(liste[0][0][1]))
    frage2 = easygui.buttonbox(liste[0][1][0], choices = random.shuffle(liste[0][1][1]))
    if frage1 == liste[0][0][1][0]:
        punkte += 100
    if frage2 == liste[0][1][1][0]:
        punkte += 100
    ende = 0

print punkte

Wurde ich nochmals enttäuscht. Dann wäre ja wieder der erste Anlaufpunkt, was da schief läuft, denn wenn ich sowas teste:

Code: Alles auswählen

import random
l = [3, 1, 3, 4, 5, 6]
random.shuffle(l)
print l

geht alles. (Auch getestet mit strings!)

Aber diese Fragen sind etwas abseits vom Thema, denn ich will ja eigentlich wissen, was Ihr euch unter Datenstruktur vorstellt. Wie schon gesagt, definiere ich eine Datenstruktur als große Datenspeicherung, z.B. Listen, die man dann später mit den verschiedenen Indizes aufrufen kann.

Dann dacht ich mir, in Google werd ich schon was sinnvolles finden- Nun, was man findet, sind Erklärungen über Listen, Dictionarys und Tupel - mehr nicht.

Ich zerbrech mir den Kopf dabei. Aber wenigstens bin ich schon viel weiter als vor einigen Wochen!

Bye

[BlackJack]

@Gary123456: Die äusserste Liste könntest Du schon mal weglassen, denn da ist ja nur ein Element drin und der erste Index ist *immer* 0.

Den zweiten Indexzugriff wirst Du los in dem Du den nicht hart im Programm kodierst, sondern eine Schleife über die Elemente schreibst. Das Du das nicht machst ist ja genau der Grund warum das bei Dir immer alles so unflexibel ist und Du auch immer Code schreiben musst wenn neue Fragen hinzukommen. Wenn Du Anfängst Namen zu nummerieren (`frage1`, `frage2`, …) und Quelltext dafür zu wiederholen ist das ein Zeichen, dass Du eine Schleife und/oder Funktion(en) verwenden solltest.

Den dritten Indexzugriff wirst Du los, in dem Du in dieser Schleife die Elemente nicht an einen Namen bindest, sondern gleich an zwei verschiedene Namen, denn die Tupel enthalten ja immer die Frage und die Antworten.

`random.shuffle()` „mischt” die Elemente einer Liste. Es gibt weder eine neue Liste zurück, noch gibt es die Liste die übergeben wurde zurück. Darum kannst Du den Aufruf nicht als `choices`-Argument an die `buttonbox()` übergeben. Ausserdem müsstest Du Dir merken was die erste Antwort vor dem `shuffle()` war, denn nach dem Aufruf der Funktion ist diese Information ja verloren.

[Sirius3]

Hi Gary123456,

was die Funktion shuffle betrifft, die durchwürfelt eine bestehende Liste und erzeugt keine neue.
Du musst also erst Deine Antworten kopieren, dann shuffeln und dann buttonbox damit aufrufen.

Was die vielen Indizes betrifft: normalerweise greift man auf Listen nie direkt zu, sondern tut irgendetwas mit jedem Element, also z.B:

Code: Alles auswählen

for frage in fragen:
    if beantworte_frage(frage):
        punkte += 100
    else:
        versuche -= 1

Tuple kann man vor dem Benutzen entpacken:

Code: Alles auswählen

frage_antwort = ("Was ist Fifa13?", ["Ein Computerspiel", "Eine Trompete", "Eine Uhr"])
frage, antworten = frage_antwort
richtige_antwort = antworten[0]

Damit wird alles viel übersichtlicher, und Indizes kommen in meinen Beispielen so gut wie gar nicht mehr vor.

[Gary123456]

Damit wird alles viel übersichtlicher, und Indizes kommen in meinen Beispielen so gut wie gar nicht mehr vor.

Dann sollte ich mir tatsächlich mal dieses Tuple Unpacking ansehen. Danke mal vorerst!

was die Funktion shuffle betrifft, die durchwürfelt eine bestehende Liste und erzeugt keine neue.
Du musst also erst Deine Antworten kopieren, dann shuffeln und dann buttonbox damit aufrufen.

OK Danke!

[snafu]

Und du solltest dir Schleifen anschauen. Schleifen sind elementar beim Programmieren.

[Gary123456]

@BlackJack)

Deine Antwort habe ich übersehen.

Die äusserste Liste könntest Du schon mal weglassen, denn da ist ja nur ein Element drin und der erste Index ist *immer* 0.

Ich mach mir wieder das Leben schwer!

Ich denke, ich leg mal fragen und antworten in Tupeln und lass die mit Hilfe von for Schleifen ausgeben

@snafu)

Habe ich schon längst. Und das sogar paar mal. Und auch damit paar Übungen gemacht.

[snafu]

Dann ist das wohl wieder der Unterschied zwischen "wissen, dass es etwas gibt" und "wissen wie man es sinnvoll einsetzen kann".

[Gary123456]

Ich werde noch irre.

Code: Alles auswählen

import easygui

liste = ("Was ist Fifa13?", ["Ein Computerspiel", "Ein Texteditor", "Ein Taschenrechner"])
frage, antworten = liste #frage = "Was ist Fifa13?" , antwort = ["Ein Computerspiel", "Ein Texteditor", "Ein Taschenrechner"]
richtige_antwort = antworten[0] #richtige_antwort = "Ein Computerspiel"

frage1 = easygui.buttonbox(frage, choices = antworten)

if frage1 == richtige_antwort:
	easygui.msgbox("Rischtisch")

Habe mich da jetzt an Sirius Tipp gehalten. Funktioniert super, nur wie geht das mit anderen Fragen in einer Liste?
2 verschachtelte for-Schleifen würde auch nicht helfen, oder doch? Habe jetzt verschiedenes probiert:

Versuch1 :
Zwei Listen erstellt. Eine war für Fragen zuständig, die andere für Antworten. ich habe dann mit Hilfe einer for-Schleife die erste Liste iteriert. Diese gibt somit alle Antworten aus (type = String). Danach habe ich die zweite Liste iteriert. Diese gibt dann die zwei Tupel aus, die die Elemente in der Liste bilden. Danach habe ich eine verschachtelte Schleife gebildet, indem ich der Variable i pro Iteration die Elemente der Liste Fragen zugewiesen habe und darin nochmal eine for schleife, die der Variablen j die Elemente der Antworten Liste ausgibt. Nun ist die Ausgabe wieder falsch.

Code: Alles auswählen

fragen = ["Was ist Fifa13?", "Was ist eine Computermaus?"]
antworten = [("Ein Computerspiel", "Eine Uhrzeit", "Ein Programm"), ("Steuerungsgeraet", "Tastatur", "Message")]

for i in fragen: #Gibt die Fragen aus!
	print i 
print

for j in antworten: #Gibt die 2 Elemente aus!
	print j 
print 

for i in fragen:
	for j in antworten:
		print i, j

Versuch2:

Das war dann der 1 Code (siehe ganz oben)

Mittendrin habe ich kleine Sachen getestet und auch wieder mal paar leichte ForSchleifen gebildet.

Daraufhin habe ich mir den Tipp von snafu zu Herzen genommen und for-Schleifen nochmals durchgelesen. Daher jetzt meine Erklärung mit einem simplen Beispiel:

Code: Alles auswählen

for i in range(5):
	print i

Zuerst sollte angemerkt werden, dass range eine Liste mit 5 Elementen erstellt (Liste = [0, 1, 2, 3, 4]). Die Anzahl an Iterationen ist gleich der Anzahl der Elemente in der Liste. In unserem Beispiel printet es bei jeder Iteration einen Wert der Liste. Um genauer zu sein: Bei jeder Iteration bekommt die Variable i einen Wert zugeweisen (in diesem Falle ein Element der Liste). So bekommt diese Variable beim ersten Durchlauf den Wert0, beim zweiten Durchlauf den Wert 1 usw. bis es bei Wert4 angekommen ist. Da die for Schleife die Anzahl der Durchläufe bestimmt, wird sie Zählerschleife genannt. Die while Schleife ist Bedingungen ausgesetzt. z.B. läuft sie nur so lange, bis ein Wert False ist, denn dann hört sie auf.

Dann ist es, wie snafu schon sagte, fehlt mir das "Wissen, wie man es sinnvoll einsetzen kann".

Nochmal zu Sirius3)
Diese Codezeile:

Code: Alles auswählen

if beantworte_frage(frage):

ist mir unklar. Denke aber, dass Du von einer selbst erstellten Funktion ausgehst, habe ich recht?

Ich habe immer noch keinen Schimmer wie ich das anwenden soll. Theorie ist denke ich mal da, Praxis ist eben nicht da. Was soll ich nur tun?

Aber auch den anderen Tipp von snafu werde ich mir nochmals zu Herzen nehmen, denn für heute ist Schluss. Kann nicht mehr. Habe auch noch was für die Schule zu tun!

[Sirius3]

Sehr gut, Garry123456, Du bist knapp davor es zu kapieren, nur ein kleiner Tipp:
Was ergibt eine for-Schleife über eine FrageAntwortTupel-Liste?

[xeike]

Hi Gary123456,

Ich habe mir im anderen Buch nun das Kapitel 'Dictionarys' angesehen. Aber für mein Programm ist das denke ich noch unnötig.

Was hälst du denn von folgender Vorgehensweise? Im Dictionary "menu" sind die Funktionen, die aufgerufen werden, wenn ein Benutzer etwas eingibt, schon enthalten. Also "quiz", "neue_frage" und "ende" sind Funktionen in Python, die du noch schreiben müsstest. Die Schlüssel des Dictionaries könnten unmittelbar als Tasten bei der Benutzereingabe verwendet werden.

Code: Alles auswählen

menu = dict({1:('Quiz', quiz), 2:('Neue Frage', neue_frage), 3: ('Ende', ende)})

def zeige_menu(menu_dict):
    for taste in menu_dict.keys():
        text, funktion = menu_dict[taste]
        print('Drücke {0} für {1}'.format(taste, text))

Meine nur, dann hättest du auch dict() untergebracht.

Bei deinen Quizfragen könntest du auch so vorgehen.

Code: Alles auswählen

quizfrage = dict({nummer:('Frage', 'Erste Antwort', 'Zweite Antwort', Richtige_Antwort_index)})

Xe

[Gary123456]

Du hast mich doch noch zum programmieren bewegt. Schließlich war ich nicht müde, sondern mein Hirn hat gebrummt.

Nachdem ich ein anderes Problem jetzt beseitigt habe (richtige Kodierung), habe ich lange getüftelt.

Ganz simpler Code:

Code: Alles auswählen

# -*- coding: iso-8859-1 -*-
frage_antwort = ("Was ist Fifa13?", ["Computerspiel", "Computermaus", "Computertastatur"])

for i in frage_antwort: # gibt in seperaten Zeilen Frage und die Liste der Antwortmöglichkeiten aus 
	print i 

Ausgabe wäre:

Code: Alles auswählen

Was ist Fifa13?
['Computerspiel', 'Computermaus', 'Computertastatur']

Eigentlich genau das was ich haben wollte!

Nun habe ich mich gefragt, was ich mit dem anfangen könnte. So habe ich mir gedacht, ob es nicht möglich wäre, dass die 2. Elemente des Tupels zwei verschiedenen Variablen zugeweisen werden könnte in einer Schleife?

z.B. so in etwas (der Code geht nich):

Code: Alles auswählen

for i, j in frage_antwort:
    Mache das ...

das der Variable i die Frage als String zugewiesen wird und der Variable j die Liste der möglichen Antworten?

So während ich dies hier schreibe - such ich nach anderen Lösungen.

Dann - uch - was ganz anderes:

Code: Alles auswählen

# -*- coding: iso-8859-1 -*-
import easygui

def Frage():
	liste = []
	for i in antwort:
		liste.append(i)
	fragen = easygui.buttonbox(frage, choices = liste)
	return fragen



frage = "Test"
antwort = ['Frag', 'hddsad', 'wjdsa']
a = Frage()
if a == antwort[0]:
	print "right"

frage = "Hello World"
antwort = ["Test", "Dingstel", "Drum"]
b = Frage()
if b == antwort[1]:
	print "haha"

Eine kleine Datenstruktur. Ist aber damit auch der Code viel kürzer? Aber wenigstens ein Gedanke daran!

Jetzt ist doch die eigentliche Frage, wie ich mehrere Frage in einer Liste mit Hilfe einer Funktion ausgeben kann. Das geht dann wieder nur mit for. Aber wie?

Danach noch ein try:

Code: Alles auswählen

# -*- coding: iso-8859-1 -*-
import easygui

frage = ["Test1", "Test2", "Test3"]
antwort = (["Test", "Test2", "Test3"], ["Test4", "Test5", "Test6"], ["Test7", "Test8", "Test9"])

k = 0

for i in frage:
	easygui.buttonbox(i, choices = antwort[k])
	k += 1

Und es funktioniert! Das ist doch mal ein guter Ansatz für eine gute Datenstruktur, oder nicht? Ich freu mich direkt. Jetzt habe ich wenigstens frage und antwort in Listen und Tupel gespeichert, jetzt müsste ich nur noch in der Theorie die antwort Liste kopieren (Stop! Ist ja ein Tupel. Kann man jedoch ändern) in eine andere Variable und diese dann vermischt anzeigen, wobei bei der Originalen immer der erste Wert die richtige Lösung ist und somit kann ich es dann abfragen. Morgen folgt dann evtl der richtige Code.

Aber die spannendste und wichtigste Frage für mich ist jetzt:
Ist das eine richtige Datenstruktur? Und ist sie gut?

@xeike) Das werde ich sicher später im Programm aufnehmen, wenn ich im Buch das Kapitel Funktionen durchgenommen habe.

[BlackJack]

@xeike: Ein Wörterbuch in dem Werte unter fortlaufenden Nummern gespeichert werden ist nicht sinnvoll. Das ist letztlich eine umständliche Liste. Mit dem zusätzlichen Nachteil, das die Reihenfolge der Ausgabe von diesem Menü willkürlich ist.

[Sirius3]

@Gary123456: jetzt bist Du wieder drei Schritte zurückgegangen. Eine gute Datenstruktur ist eine, in der Dinge, die zusammen gehören, auch zusammen bleiben. Bei Dir also: (Frage, Antwort)
Das in zwei Listen zu speichern, ist genau das Gegenteil.

[Gary123456]

Und jetzt leg ich mich schlafen -.-

@Gary123456: jetzt bist Du wieder drei Schritte zurückgegangen. Eine gute Datenstruktur ist eine, in der Dinge, die zusammen gehören, auch zusammen bleiben. Bei Dir also: (Frage, Antwort)
Das in zwei Listen zu speichern, ist genau das Gegenteil.

Ich muss mir dann einfach genau überlegen wie das geht. Und das schaff ich dann wieder nicht. So sicher, so unglaublich sicher war ich mir, dass das gestimmt hatte. Aber nein - heute ist mein "unproduktiver" Tag.

Trotzdem vielen, vielen Dank!

[JonnyDamnnox]

Hallo,
Ich hab das Gefühl der Gary versucht schon die ganze Zeit jemanden dazu zu bringen das ihm jemand erklärt was eine Datenstruktur ist (also hab ich aus den posts rausgelesen).
Bin auch noch neuling, aber was ich weiß ist:

Eine Datenstruktur ist einfach eine Struktur aus Daten. Z.b.
a = ("wort1", "wort2", "wort3", "wort4, wort5")
Das reicht schon.
Du kannst auf einzelne Elemente zugreifen:
a[0] = "wort1"
Oder auf mehrere gleichzeitig:
a[2:4] = ("wort3", "wort4", "wort5")
a[:3] = ("wort1", "wort2", "wort3")
und noch ganz andere Sachen. Du kannst Elemente natürlich irgendwo Speichern, wieder aufrufen. Oder auch einzelne Elemente vom Nutzer eingeben lassen oder die Reihenfolge ändern, dinge daraus löschen, verändern oder hinzufügen usw. Du hast also Daten, die du auf strukturierte Weise manipulieren und speichern kannst. Dafür gibts dann eben tupel, listen, dicionarys usw. Je nachdem nutzt man dann das angemessenste.
Hier wäre vielleicht ein dictionary gut:
quiz = {"Frage1": "Antwort1", "Frage2": "Antwort2"}
Dann kannst du wieder:
quiz["Frage1"]
"Antwort1"
quiz["Frage2"]
"Antwort2"
oder die Elemente ändern:
quiz["Frage1"] = "Antwort2"
quiz["Frage1"]
"Antwort2"
usw
(hab jetzt aber nicht jeden code von dir gesehen, ist jetzt nur so spontan als inspiration)

Versuchs mal selbst.

Ich hoffe das war angemessen, hab auch erst vor ein paar Wochen hobbymäßig angefangen. Solange ich noch die Freizeit geniesen kann

Gruß
Guten Morgen

[Gary123456]

@JonnyDamnox)

Das war nicht direkt das Problem. Was eine Datenstruktur habe ich schon längst "ergoogelt" und auch verstanden. Wie schon gesagt, Theorie ist da, Praktisch kann ichs eben noch nicht.

Dictionary für Antworten finde ich eher unpassend, ich denke das bringt eine Liste-Tupel-Liste viel mehr. Nur diese per for Schleife zu iterieren fällt mir schwer. Dass werde ich hoffentlich bald selber schaffen.

Ich kann fast schon im Schlaf auf Listen zugreifen, sie ändern. Ich glaube, dass hat man in den kryptischen Indizen Zugriffe gesehen

Werde mich jetzt wieder damit beschäftigen und hoffe, eine Lösung zu finden!

[Gary123456]

Code: Alles auswählen

# -*- coding: iso-8859-1 -*-
import easygui

frage_antwort = (("Was ist Fifa13?",["Ein Computerspiel", "Ein Monster", "Eine Uhrzeit"]), ("Was ist eine Computermaus?", ["Ein Steuerungsgeraet", "Eine Tastatur", "Ein Bildschirm"]), ("Test1", ["Test2", "Test3", "Test4"]))


for i, k in frage_antwort:
	easygui.buttonbox(i, choices = k)

aber was macht eig dieses i, k eig ? Ist das wieder Tupel Unpacking? Bedeutet das jetzt, dass der Variable i immer die Fragen zugewiesen werden und der Variablen k immer die Liste mit den Fragen?

Und die wichtigste Frage: Ist das eine richtige Datenstruktur?

[BlackJack]

@Gary123456: Zwischen ``for`` und ``in`` muss etwas stehen was auch links von einer Zuweisung mit ``=`` stehen darf. Also auch mehrere Namen durch Kommas getrennt für „tupel unpacking”. Das müsste korrekter übrigens „iterable unpacking” heissen, denn es gehen nicht nur Tupel sondern generell iterierbare Objekte mit der entsprechenden Anzahl von Elementen.

Edit: Die Namen `i` und `k` sind hier natürlich äusserst unschön. Nicht nur dass sie nichts darüber aussagen was die Werte bedeuten, so sind das auch noch klassische Zählvariablennamen. Dann auch noch innerhalb einer Schleife. Da würde jeder erfahrene Programmierer mit ganzen Zahlen rechnen, aber nicht mit Zeichenketten und Listen.