--->Kartenspiel programmieren<----

[AphrodiTe]

Vielen dank merlin emrys
und danach setzte ich einfach ein append() befehl ein um die karte aus der eigenen hand zu löschen.
danach wollte ich mit einem split() die karte splitten in wert und farbe.damit der computer bedienen kann und damit man am ende karten vergleichen kann.

melde mich dann eh ncohmal

kai

[merlin_emrys]

Noch ein Nachtrag:

"raw_input()" ist immer ein bisschen riskant, wie ich hier im Forum gelernt habe. Daher folgender Vorschlag:

Code: Alles auswählen

# -*- coding: cp1252 -*-
karten = ['herz 7', 'karo 9', 'pik dame']
print "Welche Karte möchtest Du spielen? Bitte gibt ein:"
for karte_nummer in range(1,len(karten)+1):
    print "%i für %s" % (karte_nummer, str(karten[karte_nummer-1]))
while True: 
    try: 
        Kartennummer=int(raw_input("Nur die Nummer von 1 - %i bitte: " % len(karten) )) 
    except ValueError: 
        print "Bitte gibt nur eine Nummer im angegebenen Bereich ein!" 
    if Kartennummer in range(1,len(karten)+1):
        break    

Zur Erklärung:
while True leitet eine Endlosschleife ein, die nur verlassen wird, wenn das Probramm einem "break" begegnen. Das tut es in diesem Fall erstmal nur, wenn es schafft, aus dem raw_input()-Ergebnis eine Zahl zu machen, denn das ist die Aufgabe von int(). Wenn das nicht hinhaut, wird die Eingabe nicht weiter behandelt - das heißt, auch wenn jemand da Python-Code eingibt, macht das Programm korrekt weiter, indem es sich einfach weigert, mit dieser Eingabe irgendetwas zu machen.
Und dann sorgt die if-Anweisung dafür, daß nicht eine Zahl genommen wird, die außerhalb der Kartenmenge liegt. Erst, wenn alles okay zu sein scheint, wird die Schleife verlassen und das Programm läuft weiter.

[BlackJack]

Beide male ist das `range()` ungünstig.

Im ersten Fall ist direktes iterieren über die Karten in Verbindung mit `enumerate()` idiomatischer. Selbst mit `xrange()` würde man beim Angeben der Grenzen 0 und ``len(karten)``, wobei die erste dann wegfallen kann, nur an einer Stelle die Korrektur im 1 machen müssen.

Beim zweiten `range()` wird nur für eine Bereichsüberprüfung eine Liste mit Zahlen erzeugt und in der dann linear gesucht. Das geht auch effizienter/schöner:

Code: Alles auswählen

def main():
    karten = ['herz 7', 'karo 9', 'pik dame']
    
    for i, karte in enumerate(karten):
        print '%d für %s' % (i + 1, karte)
    
    while True:
        try:
            nummer = int(raw_input('Nummer von 1 - %d bitte:' % len(karten)))
            karte = karten[nummer - 1]
            break
        except (ValueError, IndexError):
            print 'Bitte nur eine Nummer im angegebenen Bereich!'
    
    print 'Gewaehlt:', karte

Das ganze liesse sich auch in eine Funktion verpacken, die den Anwender aus einer Liste von Objekten eines auswählen lässt, und wäre damit wiederverwendbar.

Die Modellierung einer Karte als Zeichenkette in der zwei mehr oder weniger unabhängige Informationen, Farbe und Bild/Wert, zusammengefügt sind, ist äusserst ungünstig.

[Michael Schneider]

Nach dem Slicen gibt's die Objekte nicht mehrfach, nur mehr Referenzen darauf.

Natürlich Referenzen. "Gibt es mehrfach" meinte ich in dem Sinne, wie es z.B. Baupläne eines Hauses im Kopf und gleichzeitig auf Papier geben kann. Sonst hätte ich geschrieben, dass neue Objekte erzeugt werden.

Gruß,
Michael

[AphrodiTe]

vielen dank,
soll ich die befehle append() und del() in die wile-schleife mit einbauen oder eher anch der schleife schreiben?
wollten die karte die man gelegt hat aus der liste jetzt löschen mit del()
und eine neue liste erstellen mit appand()

vielen dank
kai

[merlin_emrys]

vielen dank,
soll ich die befehle append() und del() in die wile-schleife mit einbauen oder eher anch der schleife schreiben?

Es geht beides. Ich würde es eher nach der Schleife machen, aber ich kann nicht genau erklären, warum eigentlich.

[AphrodiTe]

ja ich ahbe es jertzt anch der Schleife eingebaut..

Code: Alles auswählen

del Deine_Karten[nummer-1]
print Deine_Karten

das funktioniert super.
nur wenn ich angeben will dass er in eine neue liste die karte reinschreiben soll macht er es nciht.
habe mir das gedacht:

Code: Alles auswählen

stich.append(Deine_Karten[nummer-1])

stich ist die neue liste die ich vorher schon erstellt ahbe

kai

[merlin_emrys]

Was kommt denn für eine Fehlermeldung?
Ich habe die beiden Befehle jetzt mal in meine letzte Schleifenversion eingebaut (habe keine Lust, sie umzutexten... ), und da scheint es zu funktionieren:

Code: Alles auswählen

# -*- coding: cp1252 -*-
karten = ['herz 7', 'karo 9', 'pik dame']
stich = []
print "Welche Karte möchtest Du spielen? Bitte gibt ein:"
for karte_nummer in range(1,len(karten)+1):
    print "%i für %s" % (karte_nummer, str(karten[karte_nummer-1]))
while True: 
    try: 
        Kartennummer=int(raw_input("Nur die Nummer von 1 - %i bitte: " % len(karten) )) 
    except ValueError: 
        print "Bitte gibt nur eine Nummer im angegebenen Bereich ein!" 
    if Kartennummer in range(1,len(karten)+1):
        print "Gewählt wurde: ", karten[Kartennummer-1]
        stich.append(karten[Kartennummer-1])
        del karten[Kartennummer-1]
        break    
print stich
print karten

Dann bekomme ich:

Code: Alles auswählen

>>> 
Welche Karte möchtest Du spielen? Bitte gibt ein:
1 für herz 7
2 für karo 9
3 für pik dame
Nur die Nummer von 1 - 3 bitte: 2
Gewählt wurde:  karo 9
['karo 9']
['herz 7', 'pik dame']

Edit:
Noch eine Frage an BlackJack: Du hast geschrieben, meine zweite range()-Anwendung sei ungünstig. Ich habe jetzt doch mal meinen Code umgetextet, weil ich mir ein bestimmtes Phänomen nicht erklären konnte. Aber wenn ich die range()-Funktion weglasse, bricht das Programm bei einer zu hohen Zahleneingabe mit einer Fehlermeldung ab, was ich als eher störend empfinde. Jetzt bin ich verwirrt... Wie könnte man falsche Zahleneingaben noch "abfangen"?

(Das erwähnte Phänomen ist leider nicht reproduzierbar: Als ich bei ein paar Testläufen nur die Eingabetaste gedrückt habe, wurde immer zunächst die Meldung "Bitte gibt nur ...." angezeigt und dann der Auswahltext wieder angezeigt, aber sofort (d.h. ohne weitere Eingabe von mir) die Karte 'pik dame' ausgewählt. Jetzt passiert es nicht mehr... Weiß irgendwer, was da los war? Ich verwende zum Testen python 2.4 mit IDLE.)

[schlangenbeschwörer]

Was passiert denn? Gibts ne Fehlermeldung?

[AphrodiTe]

hi merlin emrys,
das prob hatte ich auch als ich es ohne die def main(): kopiert habe...alle tabs müssen stimmen...
hab es dann ncoh hinbekommen...


hoffe es geht danach
kai

[Michael Schneider]

Hallo!

Und gewöhn Dir bitte die ungarische Notation bei Namen ab. Das ist schrecklich und irreführend wenn man den Typ mal ändern sollte und nicht die Namen anpasst.

Offenbar hat er die von mir abgeschaut. Die Idee habe ich ohne speziellen Namen aus einem alten Programmierbuch abgeschaut und sie hat sich bislang als sehr nützlich erwiesen.

Was meine Verständnislosigkeit angeht, so hat diese inzwischen ein globales Maximum erreicht. Warum scheint hier jeder gegen die Konvention zu sein, den Typ einer Referenz im Namen kenntlich zu machen (was ja laut Wikipedia.de auch gar nicht die ursprüngliche Ungarische Notation ist)?

1.) Ich habe in Pep 8 nur diese Passage gefunden:

In Python,
this style is generally deemed unnecessary because attribute and method
names are prefixed with an object, and function names are prefixed with a
module name.

Sie ist also bekannt und es wird nicht davon abgeraten, sie zu verwenden.

2.) Wenn man eine Variable MyButton hat und sie nach einer Änderung nur noch einen Index enthält, dann müsste man diesen Namen auch ändern.

3.) Wenn man neuen Code das erste mal liest, ist diese Hilfe zweifellos Gold wert. Sieht man irgendwo

Code: Alles auswählen

Namen.keys()

dann kann man daraus allein nicht sehen, dass wahrscheinlich ein Fehler vorliegt. Heißt es aber

Code: Alles auswählen

lNamen.keys()

sieht man schon beim Überfliegen, dass hier eine Dictionary-Methode auf eine Liste angewendet wird.

Im Sinne einer freien Meinungsbildung bitte ich höflichst um eine sachliche Diskussion - vielleicht auch in einem neuen Thread, wenn ihn jemand öffnen könnte.

Grüße,
Michael

[BlackJack]

@merlin_emrys: (Bessere) Alternative zur Bereichsüberprüfung:

Code: Alles auswählen

if x in range(a, b): pass

# =>

if a <= x < b: pass

Gehen wir mal von x=50, a=0 und b=100 aus, dann wird im ersten Fall eine Liste mit 100 Zahlen erzeugt und dann folgen 50 Vergleiche bis klar ist, dass `x` im Bereich ist. Für `x`\e die nicht im Bereich sind, werden immer 100 Vergleiche gemacht. Beim zweiten Fall sind es immer nur zwei Vergleiche und es wird nicht jedesmal eine Liste erzeugt und nach dem Test wieder verworfen.

@Michael Schneider: Den Typ in einer dynamischen Sprache im Namen zu kodieren ist einfach irreführend und läuft dem "duck typing" zuwieder.

zu 2) Damit hast Du ein komplett anderes Objekt und damit auch die Bedeutung verändert. Das sollte sich natürlich auch im Namen wiederspiegeln.

zu 3) Das eine nicht vorhandene Methode aufgerufen wird, kann man nur zur Laufzeit feststellen, egal wie der Name aussieht. Das findet man durch Tests, die man sowieso machen muss, weil kein Name garantiert das bei `lNamen` *wirklich* eine Liste an den Namen gebunden ist. Desweiteren will man das in der Regel auch gar nicht so festlegen. An `lKarten` kann man eine Liste binden. Wenn gar nicht die ganze `list()`-API benötigt wird, kann es aber günstiger sein ein Tupel, ein `set()` oder vielleicht ein Objekt vom Typ `Talon` oder `Hand` zu binden ohne das sich am Programm etwas ändert. Nur ist der Name `lKarten` dann "falsch", also irreführend.

Was Du da so ein bisschen über Namenskonvention einführen willst, ist statische Typinformation. Mit den gleichen Argumenten wollen ja immer wieder Leute Python zu Java machen. "Aber dann kann man ja schon vorher Typfehler erkennen"…

[AphrodiTe]

hallo allerseits,
ich wollte mit karte.split() eine karte splitten...z.b. aus herz 7 wird [herz, 7]
danach kann ich ja mit if karte[0]=herz nachgucken ob die karte herz oder pik oder kreuz oder karo ist.
wenn jetzt klar ist dass die karte herz ist soll python bei dem gegner 1 in der kartenliste nachgucken und endscheiden ob er auch herz hat.
wie kann ich das machen.
hier mien programm bisher:

Code: Alles auswählen

from random import randint


def draw_card(lKarten):
    if not lKarten:
        return ()
    return lKarten.pop(randint(0, len(lKarten)-1))
   
lFarben = ["Kreuz", "Pik", "Herz", "Karo"]
lWerte = ["7", "8", "9", "10", "Bube", "Dame", "Koenig", "Ass"]
lKarten = [(sFarbe, sWert) for sWert in lWerte for sFarbe in lFarben]

print "Deine Karten"
Deine_Karten = []    
for i in xrange(10):
    got_card = draw_card(lKarten)   
    Deine_Karten.append(got_card)

Gegner1_Karten = []    
for i in xrange(10):
    got_card = draw_card(lKarten)   
    Gegner1_Karten.append(got_card)

Gegner2_Karten = []    
for i in xrange(10):
    got_card = draw_card(lKarten)   
    Gegner2_Karten.append(got_card)



def Anfang():
    stich=[]
    for i, karte in enumerate(Deine_Karten):
            print '%d für %s' % (i + 1, karte)
       
    while True:
        try:
            nummer = int(raw_input('Welche Karte möchtest du spielen?Nummer von 1 - %d bitte:' % len(Deine_Karten)))
            karte = Deine_Karten[nummer - 1]
            break
        except (ValueError, IndexError):
            print 'Bitte nur eine Nummer im angegebenen Bereich!'
       
    print 'Gewaehlt:', karte
del Deine_Karten[nummer-1]
stich.append(Deine_Karten[nummer-1])
print stich
print Deine_Karten
karte=karte.split()

    



Anfang()

[merlin_emrys]

wenn jetzt klar ist dass die karte herz ist soll python bei dem gegner 1 in der kartenliste nachgucken und endscheiden ob er auch herz hat.
wie kann ich das machen.

mit der Verbindung 'if ... in ...' kann man nur nach ganzen Listenelementen suchen. Insofern muß man die Listenelemente vermutlich einzeln durchgehen. Ich habe mich mal wieder bei einer Codeformulierung von BlackJack bedient:

Code: Alles auswählen

gesuchtes_Symbol = 'herz'
for i, karte in enumerate(karten): 
    if gesuchtes_Symbol in karten[i]:
        print "Karte %s hat das richtige Symbol." % karten[i]

Die Alternative wäre, von der Zuordnung der Karten als Tupel wegzugehen und sich etwas anderes auszudenken, was ein einfacheres Suchen ermöglicht... Allerdings bin ich mir da selbst nicht so sicher, was da wohl geschickt wäre.

@ BlackJack: Danke! Wird sofort in meinen Programmen entsprechend geändert...

[Michael Schneider]

Hallo!

Ich habe meine Antwort auf BlackJack bezüglich Typinformationen im Namen verlegt in Thread: "Typinformation im sNamen - Pro/Contra"
http://www.python-forum.de/topic-12025.html

Michael

[Michael Schneider]

Hallo AphrodiTe,

wie wäre es mal wieder mit einer Listenlösung?

Code: Alles auswählen

from random import shuffle
lFarbspiel = ["Ass", "10", "Koenig", "Dame", "9", "8", "7"]
lNullspiel = ["Ass", "Koenig", "Dame", "Bube", "10", "9", "8", "7"]
lFarben = ["Kreuz", "Pik", "Herz", "Karo"]

#   erzeuge je eine Liste mit allen Karten einer Farbe -> Nullspiel
#   -> Listen ohne Buben fuer Grand und Farbspiele moeglich
dKartenSet = {}
for sFarbe in lFarben:
    dKartenSet[sFarbe] = [(sFarbe, sWert) for sWert in lNullspiel]

#   Kartendeck erzeugen und durchmischen
lKarten = [(sFarbe, sWert) for sWert in lNullspiel for sFarbe in lFarben]
shuffle(lKarten)

#   10 Karten auf Hand nehmen
lHand = lKarten[:10]

### Auswertung #####################################################

#   Handkarten anzeigen
print "#"*80
print "Karten auf der Hand:"
for tKarte in sorted(lHand):
    print "%s %s  " % tKarte,
print "\n"

for sFarbe in lFarben:
    print "Karten der Farbe %s auf der Hand:" % sFarbe,
    print filter(lambda t: t in dKartenSet[sFarbe], lHand)
    print

Zum Lösungsansatz:
Ich habe vier Listen erzeugt, die jeweils alle Kartentupel einer Farbe enthalten. Die kann man jetzt nur für Null nehmen, man kann aber auch Listen ohne die Buben anfertigen und für Farb- und Grandspiele nehmen.

filter ist eine eingebaute Funktion, der man zwei Parameter übergibt. Der Erste ist eine Funktion (in diesem Fall eine mit Lambda schnelldefinierte Funktion, die prüft, ob das übergebene Kartentupel in der gewünschten Farbliste ist), der Zweite ist eine Sequenz (oder iterierbares Objekt), deren Elemente in einer Schleife an die Funktion (Parameter 1) übergeben wird. Ergebnis ist eine Liste aller Elemente des zweiten Parameters, für die die Funktion den Wahrheitswert True ergab.

Praktisch bedeutet das, dass Du genau die Karten einer Hand in einer Liste erhältst, die die entsprechende Farbe haben. Wenn Du aus jeder Hand eine Karte ausgewählt hast, kannst Du mit meiner weiter oben vorgestellten Funktion bequem die höchstwertige davon ermitteln.

Grüße,
Michael
Gruß,
Michael

[Vingdoloras]

also erstmal...
ich hab hier häufig gesehn, dass ihr, um Zahlen einzulesen

Code: Alles auswählen

int(raw_input())

benutzt... mein Lehrer hat mir gesagt, dass das dasselbe ist wie

Code: Alles auswählen

input()

was zwar nur ein paar Zeichen spart, aber Fehler vorbeugt,
denn man kann sehr schnell eine Klammer vergessen.
z.B.

Code: Alles auswählen

int(raw_input("Gib eine Zahl ein!")

Ich wollte auch ein Skat Prog schreiben, mein Vater hat mich davon abgebracht, denn die KI zu Programmieren wäre wirklich zu hoch...
aber sowas, wie du es willst, wäre für den Anfang machbar.

Nun weiß ich nicht, was ihr im Unterricht macht. Du sagst zum Beispiel, du kennst nur ein paar Grundfunktionen oder so, aber nutzt schon Listen. Ich weiß zwar nicht, warum, aber wir haben mit Listen erst vor kurzem angefangen.
Ich würde dir das Buch "Python 2.x" empfehlen, wenn du 2.4 mit ILDE nutzt, ich habs durchgelesen, als Anfänger versteht man zwar nicht alles auf anhieb, aber ich könnte jetzt mit den Zehntklässlern meiner Schule mithalten (ich bin Neuntklässler und hab dieses Schuljahr mit Python angefangen) zumindest, was die Theorie angeht.

Oder schau dir mal das an:
http://abop-german.berlios.de/

...

nun zum eigentlichen Thema wieder^^
man könnte doch ne Klasse "kartenstapel" und ne Klasse "Hand" erstellen, die man so definiert, dass bei "stapel minus hand" der Hand eine bestimmte menge Karten zugewiesen wird und bei
"stapel mal irgendwas" der stapel gemischt wird zum beispiel... dass würde alles in getrennte Abschnitte teilen, die leichter zu lösen wären.
Allerdings weiß ich nicht, wie es sich mit dem Skat verhält, da ich die Regeln noch nicht so gut kenne...

[Vingdoloras]

ich hoffe der thread is überhaupt noch aktiv
ich weiß nich ob das klappt, probierts mal aus

Code: Alles auswählen

from random import randint

class Kartenstapel:
    def __init__(self):
        self.inhalt=["Karo 7","Karo 8","Karo 9","Karo 10",
                     "Karo Bube","Karo Dame","Karo Koenig",
                     "Karo Ass","Herz 7","Herz 8","Herz 9",
                     "Herz 10","Herz Bube","Herz Dame",
                     "Herz Koenig","Herz Ass","Pik 7","Pik 8",
                     "Pik 9","Pik 10","Pik Bube","Pik Dame",
                     "Pik Koenig","Pik Ass","Kreuz 7","Kreuz 8",
                     "Kreuz 9","Kreuz 10","Kreuz Bube","Kreuz Dame",
                     "Kreuz Koenig","Kreuz Ass",]
        # Die Liste mit den Karten, mehr wird für den Stapel ja nicht gebraucht
    def __sub__(self,other): # nur für die Verwendung mit der Später
        # erstellten Klasse "Hand" nützlich
        karte=self.inhalt.pop(randint(0,len(self.inhalt)-1))
        other+karte # other darf nur aus Klasse "Hand" instanziert sein

class Hand:
    def __init__(self):
        self.inhalt=[]
        # anfangs leer
    def __add__(self,other):
        self.inhalt.append(other)
        print "Sie haben %s gezogen."%other

dann halt einfach eingeben

Code: Alles auswählen

stapel=Kartenstapel()
hand=Hand()
stapel-hand

[BlackJack]

`input()` führt beliebigen Python-Quelltext aus, darum sollte man das nicht verwenden. Ausserdem können da bei Falscheingaben genau so Fehler entstehen wie bei `raw_input()`, d.h. für ein robustes Programm muss man sowieso eine Fehlerbehandlung vorsehen.

Die Operatoren auf diese Weise zu überschreiben ist keine gute Idee. Das macht das Programm nur unverständlich weil niemand auf Anhieb weiss was ``stapel - hand`` bedeuten soll. Ich hätte zum Beispiel spontan darauf getippt, dass ein neuer Kartenstapel erzeugt wird, der alle Karten von `stapel` enthält ausser denen die in `hand` auch vorhanden sind. Eben was man beim "abziehen" so erwarten würde. Und dann würde ich mich wundern warum das Ergebnis an keinen Namen gebunden wird.

Klassennamen werden per Konvention übrigens in "MixedCase" geschrieben, also `Kartenspiel` und `Hand`.

[Leonidas]

also erstmal...
ich hab hier häufig gesehn, dass ihr, um Zahlen einzulesen

Code: Alles auswählen

int(raw_input())

benutzt... mein Lehrer hat mir gesagt, dass das dasselbe ist wie

Code: Alles auswählen

input()

Das stimmt so nicht. Wenn du unter `help(input)` nachschlägst kannst du dort lesen, dass es `eval(raw_input())` entspricht. Das ist nicht das gleiche, denn damit kannst du beliebigen Code ausführen und du kannst dir nicht sicher sein, dass das was eingetippt wurde eine Zahl ist. Kann alles mögliche sein und wenn du darauf zugreifst und es keine Zahl ist dann knallts später an irgendeiner Stelle.