In einer Montecarlo-Simulation habe ich die folgenden 7 Pokercards für 2 Spieler und 3 verschiedene Montecarlo-Läufe.

self.cards:

array([[[  6.,  12.],
    [  1.,   6.],
    [  3.,   3.],
    [  8.,   8.],
    [  1.,   1.],
    [  4.,   4.],
    [  2.,   2.]],

   [[  6.,   7.],
    [  1.,   1.],
    [  3.,   3.],
    [  2.,   2.],
    [ 12.,  12.],
    [  5.,   5.],
    [ 10.,  10.]],

   [[  6.,   3.],
    [  1.,  11.],
    [  2.,   2.],
    [  6.,   6.],
    [ 12.,  12.],
    [  6.,   6.],
    [  7.,   7.]]])

Die entsprechenden Anzüge sind:

self.suits

array([[[ 2.,  1.],
    [ 1.,  2.],
    [ 2.,  2.],
    [ 2.,  2.],
    [ 1.,  1.],
    [ 2.,  2.],
    [ 2.,  2.]],

   [[ 2.,  0.],
    [ 1.,  3.],
    [ 2.,  2.],
    [ 0.,  0.],
    [ 1.,  1.],
    [ 1.,  1.],
    [ 1.,  1.]],

   [[ 2.,  2.],
    [ 1.,  0.],
    [ 3.,  3.],
    [ 2.,  2.],
    [ 1.,  1.],
    [ 1.,  1.],
    [ 1.,  1.]]])

Nun möchte ich die Arrays so zusammenführen, dass das Kartenarray auf die 4. Dimension mit einer Größe von 4: 0 erweitert wird und alle Farben == 1, 1 alle Farben == 2, 2 alle Farben == enthält 3 und 3 alle Farben == 4

Ich kann problemlos 4 verschiedene Arrays erstellen:

club_cards=(self.suits == 1) * self.cards 
diamond_cards=(self.suits == 2) * self.cards 
heart_cards=(self.suits == 3) * self.cards 
spade_cards=(self.suits == 4) * self.cards

und dann stapeln Sie sie zusammen:

stacked_array=np.stack((club_cards,diamond_cards, heart_cards, spade_cards),axis=0)

Das Ergebnis hat erwartungsgemäß die Form (4, 3, 8, 2)

array([[[[  1.,  12.],
         [  1.,   1.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [-11.,   0.]],

        [[ 12.,  12.],
         [ 10.,  10.],
         [  5.,   5.],
         [  1.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.]],

        [[ 12.,  12.],
         [  7.,   7.],
         [  6.,   6.],
         [  1.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.]]],


       [[[  8.,   8.],
         [  6.,   6.],
         [  4.,   4.],
         [  3.,   3.],
         [  2.,   2.],
         [  0.,   0.],
         [  0.,   0.],
         [ -4.,  -4.]],

        [[  6.,   3.],
         [  3.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [ -6.,  -9.]],

        [[  6.,   6.],
         [  6.,   3.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [ -6.,  -6.]]],


       [[[  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [-12., -12.]],

        [[  0.,   1.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [-12., -11.]],

        [[  2.,   2.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [-10., -10.]]],


       [[[  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [-12., -12.]],

        [[  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [-12., -12.]],

        [[  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [-12., -12.]]]])

Während dies in dem obigen Fall sinnvoll sein kann, ist es nicht immer möglich, insbesondere wenn mehr als 4 Fälle gestapelt werden müssen. Dies bringt mich zu meiner Frage:

Wie kann ich das mit Rundfunk machen? Im Folgenden meine spezifischen Fragen:

ch habe ein paar Dinge ausprobier

Konzentrieren wir uns auf den ersten Schritt, um die Booleschen Werte für Anzüge zu ermitteln == np.arange (4) (der zweite Schritt ist nur eine Multiplikation mit den Karten, die auf dieselbe Weise wie die Anzüge gesendet werden müssen). Ich verstehe, dass wir eine Dimension für das Farbenarray hinzufügen möchten, sollten wir dies also nicht mit der 3-Punkt-Notation signalisieren:self.suits[...,:,:,:]==np.arange(4)? Stattdessen scheint das Folgende fast zu funktionieren:self.suits[:,:,:,None]==np.arange(4) (mit der Ausnahme, dass die Dimension an der falschen Stelle hinzugefügt wird). Folgendes funktioniert auch nicht:self.suits[None,:,:,:]==np.arange(4). Wie kann ich das Array in der ersten Dimension erweitern, damit die Ergebnisse mit denen im obigen Stapel übereinstimmen?

nter welchen Umständen brauche ich das... und wenn dasNone? Ich würde erwarten, das @ zu verwend... Wie würde dies signalisieren, dass diese Dimension nach Bedarf erweitert werden muss (in diesem Fall auf eine Größe von 4)? Warum scheint dies falsch zu sein und stattdessen wird None verwendet?