--->Kartenspiel programmieren<----

[AphrodiTe]

ja habe ich =),
also eigentlich genau wie beim skat.
karo<herz<pik<kreuz <----Trumpf lassen wir mal weg...

7<8<9<10<dame<könig<ass<bube

die gegner sollen nach keinem schema ziehen(noch nciht)...sie sollen erstmal von anderen spielern (indem fall mir) gesteuert werden

vielen dank#
kai

[schlangenbeschwörer]

Ich hab auch mal ein Kartenspiel geschrieben (ich müsste es mal fertigschreiben), und das mit den Werten ist echt ein kleines Problem...
Ich habe es so gelöst, das ich im Programm die Karten so verarbeitet hab, das eine Karte durch ein Zahlenpaar dargestellt wurde. Eine Zahl für die Farbe und eine für den Wert. Damit kann man gut rechnen und auch leicht bestimmen, welche "wertvoller" ist. Vor der Ausgabe/ nach der Eingabe, wird dann halt noch übersetzt. Aber ich denke das ist einfacher, als jedesmal Strings zu vergleichen. Und so kann man auch leichter kompliziertere Sachen prüfen, zB ob es sich um eine Bildkarte handelt usw.

[AphrodiTe]

heißt das z.b alle herz karten zahlen zuzuordnen die durch drei teilbar sind??

[BlackJack]

Er hat jeder Karte ein Zahlen*paar* zugeordnet, am besten in der Reihenfolge (Wert, Farbe), weil die Tupel selbst dann schon einfach vergleichbar sind.

Allerdings sollte man das IMHO schon in Klassen verpacken.

[AphrodiTe]

könnt ihr vielleicht ein beispiel machen weil ich das os nciht verstehe sryy
was kommt danahc

[AphrodiTe]

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 Hand"
for i in xrange(10):
    print "gezogene Karte: %s %s" % draw_card(lKarten)

wie kann ich die gezogenen karten in eine seperate liste apcken?

[merlin_emrys]

wie kann ich die gezogenen karten in eine seperate liste apcken?

Indem Du zunächst eine leere Liste erzeugst und die Karten dann vor oder nach der Bildschirmmeldung mit append() hinzufügst.

Edit:
Ich habe keine Ahnung von Skat. Pokern kann ich, aber Skat...
Wenn alle Karokarten geringeren "Wert" haben als alle Herzkarten, kann man das "Symbol" als Zehnerstelle einer zweiziffrigen Zahl nehmen und die "Zahl" bzw. das "Bild" als Einerstelle.
Was ich mir vorstellen könnte, ist, daß bei der Tupel-Version etwas ähnliches gemacht wurde. Du kannst für jede Karte ein Tupel ("Symbolwert", "Bildwert") erstellen, wobei Symbolwert z.B. Karo = 1, Herz = 2 usw. ist und Bildwert Sieben = 1, Acht = 2 usw.
Dann kannst Du einfacher als bei der zweiziffrigen Zahl sagen: "Ich möchte jetzt die Symbole vergleichen" oder "Ich möchte den Bildwert vergleichen" - Du nimmst einfach den jeweiligen Tupelwert, indem Du die erste Position oder die zweite abfragst. Dabei mußt Du nur darauf achten, daß die erste Position des Tupels die Nummer "0" hat, also Tupel[1] die zweite Position ist.

Verstehe ich Dich jetzt richtig, daß Du im Grunde alle drei Spieler steuern willst? Oder soll ein anderer Mensch den eigentlichen Spieler darstellen?

[AphrodiTe]

Also...
die 2 andern spieler sollen erstmal von mir gesteuert werden.wenn das spiel fertig ist will ich dass sie sich sozusagen selber steuern...
aber ncohmal zu den listen.
ich verstehe das mit dem append nciht.
python sagt mir dass append nciht defeniert ist...kannste mir den append() befehl mal mit einbauen in das:

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 Hand"
for i in xrange(10):
    print "gezogene Karte: %s %s" % draw_card(lKarten)

[Michael Schneider]

Hallo BlackJack,

Nimm um Himmels willen `shuffle()`. Dieses gepoppe ist ja nicht mit anzusehen.

Deine Abneigung gegenüber Poppen kann ich nicht nachvollziehen. Gerade weil das Problem war, von einem Stapel zu ziehen, kommt das pop der Realität doch am nächsten. Du kannst Elemente entnehmen (pop) und auch wieder draufschieben. Dass das Poppen aus der Liste nicht die effektivste Methode ist, sollte beim Ausgeben von Skatkarten nebensächlich sein, selbst auf einem 386er.
Das Slicen von Teillisten ist kein Ziehen und die Objekte gibt es dann mehrfach.

@Michael: Was immer Du da über `shuffle()` denkst ist mit Sicherheit falsch. Das ist zum Mischen einer Sequenz gedacht und tut auch genau das.

Ok, Du hast recht. Habe mir das Modul nochmal angesehen und es geht tatsächlich nur einmal durch die Liste (wäre auch extrem dumm, wenn nicht). Ich habe damals nur den Austausch gesehen:

Code: Alles auswählen

x[i], x[j] = x[j], x[i]

... und habe das zu fix überflogen.

Grüße,
Michael

[Leonidas]

Nimm um Himmels willen `shuffle()`. Dieses gepoppe ist ja nicht mit anzusehen.

Deine Abneigung gegenüber Poppen kann ich nicht nachvollziehen. Gerade weil das Problem war, von einem Stapel zu ziehen, kommt das pop der Realität doch am nächsten. Du kannst Elemente entnehmen (pop) und auch wieder draufschieben. Dass das Poppen aus der Liste nicht die effektivste Methode ist, sollte beim Ausgeben von Skatkarten nebensächlich sein, selbst auf einem 386er.

Es geht nicht um die Performance sondern darum, dass man quasi selbst etwas nachimplementiert, was es schon gibt. Das Problem ist hierbei, dass man damit Zeit verliert, weil man es implementieren muss und möglicherweise eine Fehlerquelle bekommt, wenn der Code sich irgendwie im Index irrt. ``random.shuffle()`` hingegen funktioniert (da es ja auch sehr ausführlich getestetwurde). Definitiv.

[BlackJack]

@Michael Schneider: Der Realität kommt `shuffle()` und `pop()` ohne Index am nächsten, also das was ich vorgeschlagen habe. Nach dem Slicen gibt's die Objekte nicht mehrfach, nur mehr Referenzen darauf. Und natürlich kann man die Slices in der Originalliste auch löschen. Man muss die Realität auch nicht bis ins kleinste Detail nachbilden wenn es einfachere oder zweckmässigere Modellierungen gibt.

@AphrodiTe: `append()` ist eine Methode auf Listen. Hast Du schon das Tutorial in der Python-Dokumentation durchgearbeitet? Das ist für die Grundlagen zu empfehlen.

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.

[Michael Schneider]

Hallo,

von mir aus kann man auch Shuffle verwenden. Aber wenn ich das hier eingebe:

Code: Alles auswählen

shuffle(lKarten)
print len(lKarten)

Bekomme ich nur eine Liste mit 28 Karten, statt 32. Warum?

Ich habe mal noch eine Funktion geschrieben, die zu jedem Stich die gueltige Werteliste der Karten berechnet. Den Index der Karte innerhalb dieser Liste kann man verwenden, um den Rang der Karte innerhalb des Stiches zu ermitteln. Die Liste respektiert neben der Farbe und dem Wert auch die Art des Spiels (Grand, Null, Farbe) und die ausgespielte Karte:

Code: Alles auswählen

from random import randint

#   Initialisierung
lFarbspiel = ["Ass", "10", "Koenig", "Dame", "9", "8", "7"]
lNullspiel = ["Ass", "Koenig", "Dame", "Bube", "10", "9", "8", "7"]
lFarben = ["Kreuz", "Pik", "Herz", "Karo"]

lKarten = [(sFarbe, sWert) for sWert in lFarbspiel for sFarbe in lFarben]


def draw_card(lKarten):
    if not lKarten:
        return ()
    return lKarten.pop(randint(0, len(lKarten)-1))

def create_order_list(tAusgespielt, sSpiel="Grand"):
    """Erzeugt eine Liste, die die Reihenfolge der Kartenwerte darstellt.

    tAusgespielt - erwartet ein Kartentupel aus (Farbe, Wert)
    sSpiel       - die Spielart: "Grand", "Null", "Kreuz", "Pik", "Herz", "Karo"
    """
    lOrder = []
    
    #   die Karte wird zerlegt in Farbe und Wert
    sAusspielFarbe, sAusspielWert = tAusgespielt

    #   Beim Grand gilt die Wertordnung des Farbspiels, Buben sind Trumpf    
    if sSpiel == "Grand":
        #   Trumpf (Buben) einfuegen
        lOrder.extend([(sFarbe, "Bube") for sFarbe in lFarben])
        #   Farbe der ausgespielten Karte einfuegen
        lOrder.extend([(sAusspielFarbe, sWert) for sWert in lFarbspiel])
        #   Sonstige Karten einfuegen
        lOrder.extend([(sFarbe, sWert) for sFarbe in lFarben
                                           for sWert in lFarbspiel
                                               if not sFarbe==sAusspielFarbe])

    #   Beim Nullspiel reihen sich 10 und Bube ein
    elif sSpiel == "Null":
        #   Farbe der ausgespielten Karte einfuegen
        lOrder.extend([(sAusspielFarbe, sWert) for sWert in lNullspiel])
        #   Sonstige Karten einfuegen
        lOrder.extend([(sFarbe, sWert) for sFarbe in lFarben
                                           for sWert in lNullspiel
                                               if not sFarbe==sAusspielFarbe])

    #   Bei Farbspielen ist 10 > Koenig, Buben sind hoechste Trumpf
    elif sSpiel in lFarben:
        #   Buben einfuegen
        lOrder.extend([(sFarbe, "Bube") for sFarbe in lFarben])
        #   Trumpffarbe (= Spielfarbe) einfuegen
        lOrder.extend([(sSpiel, sWert) for sWert in lFarbspiel])
        #   Farbe der ausgespielten Karte einfuegen, wenn sie nicht Trumpf ist
        if not sSpiel == sAusspielFarbe:
            lOrder.extend([(sAusspielFarbe, sWert) for sWert in lFarbspiel])
        #   Sonstige Karten einfuegen
        lOrder.extend([(sFarbe, sWert) for sFarbe in lFarben
                                           for sWert in lFarbspiel
                                               if not sFarbe in (sAusspielFarbe, sSpiel)])

    else:
        print "Spielart '%s' ist nicht bekannt" % sSpiel
    return lOrder        

#   erzeugt 3 Kartensets a 10 Karten ('Spieler 1', 'Spieler 2', 'Spieler 3') und den Skat
dKartenSets = {}
for iSpieler in xrange(1, 4):
    dKartenSets["Spieler %i" % iSpieler] = [draw_card(lKarten) for i in xrange(10)]
dKartenSets["Skat"] = lKarten

################################################################################
#   Auswertung/Test
print "Deine Hand"
for tKarte in sorted(dKartenSets["Spieler 1"]):
    print "gezogene Karte: %s %s" % tKarte

#   einen Stich zusammenstellen und fuer verschiedene Spiele gegenueberstellen
t1, t2, t3 = ("Karo", "Dame"), ("Karo", "10"), ("Kreuz", "Ass")
lStich = [t1, t2, t3]

print "="*60
print "Karten des Stichs:", lStich
print "%s %s wird ausgespielt" % t1
for sSpiel in ("Grand", "Null", "Karo", "Kreuz", "Pik"):
    print "\nbeim %s:" % sSpiel
    lKartenWert = create_order_list(tAusgespielt=t1, sSpiel=sSpiel)
    print sorted(lStich, key=lKartenWert.index)

Geht aber bestimmt auch einfacher und besser für Anfänger geeignet.

@BlackJack, hast wieder mal recht. Ich dachte Du wärst kategorisch gegens Poppen.

Grüße,
Michael

[merlin_emrys]

Aber wenn ich das hier eingebe:

Code: Alles auswählen

shuffle(lKarten)
print len(lKarten)

Bekomme ich nur eine Liste mit 28 Karten, statt 32. Warum?

Das kann ich nicht reproduzieren; bei mir sind es nach dem shufflen noch immer 32 Karten... Welche fehlen denn? (Bein Pokern würde ich ja zuerst gezielt nachsehen, ob noch alle Asse dasind, aber ich nehme an, das ist beim Skat nicht so relevant...? Andernfalls würde ich mit der KI mal über Mogeln beim Kartenspiel reden wollen ...)

[Rebecca]

Deine Abneigung gegenüber Poppen kann ich nicht nachvollziehen.

Ich auch nicht.

SCNR

[BlackJack]

Ich wurde ja auch falsch verstanden. Ich bin nur gegen wildes, zufälliges poppen, anstelle eines effizienten poppens immer schön der Reihe nach, von hinten.

[mkesper]

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.

Kommt dieser Unsinn etwa vom Lehrer? Dann sollte ihn schleunigst mal jemand ans Forum oder zumindest an PEP0008 verweisen.

Wir haben neulich in der schule mit python angefangen.

[AphrodiTe]

kann ich mit

Code: Alles auswählen

x=["a","b","c"]
if a in x:
    print "a ist in der liste"

fragen ob was in der liste ist??

[CM]

Probier' es doch einfach aus, aber um einem Mißverständnis vorzubeugen, das aus Deinem Snippet glänzt:

Code: Alles auswählen

>>> l = ['a', 'b', 'c']
>>> a in l
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined
>>> 'a' in l
True
>>> x = 'a'
>>> x in l
True

Gruß,
Christian

[AphrodiTe]

Tut mir leid dass ich es nciht raffe aber iwie will es nciht in meinen kopf rein.
ich ahbe eine liste in der 10 karten drinne stehen.
und dann will ich fragen welche karte der benutzer spielen möchte und überprüfen ob die karte in der liste vorhanden ist.

Code: Alles auswählen

karten=["herz 7",...."karo 8"]
x=raw_input("Welche Karte willst du spielen?")

und was kommt dann?
if x in karten = true ???

vielen dank
kai

[merlin_emrys]

Man könnte es so machen, aber das Problem ist in meinen Augen die Tippfehleranfälligkeit. Python ist da ziemlich "pinibel". Ich würde dem Nutzer daher nur eine Auswahl von 1-10 stellen:

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]))
Kartennummer = raw_input("Bitte nur die Nummer eingeben: ")

Edit:
"zu_legende_Karte" war oben nicht gut eingesetzt. Es ist
zu_legende_Karte = karten[Kartennummer-1]

Der Term -1 ist wieder nur ästhetischen Kriterien geschuldet - ich bin es gewöhnt, Karten von "1" an zu zählen, eine "Karte 0" finde ich einfach irritierend.