[PYTHON] Programmierverbesserungskurs 2

Dies ist das zweite Mal im Programmierverbesserungskurs.

Betrachten Sie ein Programm mit Tetris als Thema.

Klicken Sie hier für das Kommentarvideo

Betrachten Sie die Datenstruktur von Tetris

Tetris ist ein Tetrimino, der aus 4 Blöcken besteht Es ist ein Puzzlespiel, das vor Ort arrangiert wird.

Ein Puzzlespiel wie dieses Perfekt zum Programmieren von Material !!

Lassen Sie uns sofort darüber nachdenken.

1. Zeichnen wir das Material des Tetris-Spiels

1.1 Felddigitalisierung

Mit dem Feld der Tafel (10 x 20 Quadrate) Andere als die oben genannten Blöcke Folgendes Lassen Sie uns das Feld in Daten konvertieren.

■□□□□□□□□□□■ ■□□□□□□□□□□■ ■□□□□□□□□□□■ ■□□□□□□□□□□■ ■□□□□□□□□□□■ ■□□□□□□□□□□■ ■□□□□□□□□□□■ ■□□□□□□□□□□■ ■□□□□□□□□□□■ ■□□□□□□□□□□■ ■□□□□□□□□□□■ ■□□□□□□□□□□■ ■□□□□□□□□□□■ ■□□□□□□□□□□■ ■□□□□□□□□□□■ ■□□□□□□□□□□■ ■□□□□□□□□□□■ ■□□□□□□□□□□■ ■□□□□□□□□□□■ ■□□□□□□□□□□■ ■■■■■■■■■■■■

Trinkgeld:

Es ist ärgerlich, schwarze und weiße Quadrate einzeln anzuzeigen. Verwenden wir die Wiederholung.

Insgesamt gibt es 21 Linien multipliziert mit 12 Quadraten.

1.1 Antwort

Erstellen und geben Sie die Daten einfach wie oben beschrieben aus. Das Zusammenhalten der Daten erleichtert die Wiederverwendung.

Wenn Sie den Listentyp für Daten verwenden, die vertikal und horizontal ausgerichtet sind Es ist einfach auszudrücken und zu verwalten.

Das Multiplizieren einer Liste ist eine wiederholte Hinzufügung von Elementen ist eine Verkettung von Elementen.

data = [['■'] + ['□']*10 + ['■']]*20 + [['■']*12]

for y in data:
    print(''.join(y))

In diesem Fall werden die Daten als Zeichen ausgegeben.

Im Falle eines Puzzlespiels, wenn Sie die Daten als Zeichenkette speichern Es gibt auch einige Probleme, deshalb denke ich oft numerisch.

data = [[1] + [0]*10 + [1]]*20 + [[1]*12]

for y in data:
    for x in y:
        print('■' if x==1 else '□',end='')
    print()

■ Wenn 1 Wenn □, werden die Daten als 0 gespeichert und zum Zeitpunkt der Ausgabe konvertiert.

Jetzt sind die Ergebnisse zusammen.

1.2 Tetrimino-Datenkonvertierung

Tetrimino (7) □■□□　□■□□　□■□□　□□■□　□■□□　□□■□　□□□□ □■□□　□■■□　□■□□　□□■□　□■■□　□■■□　□■■□ □■□□　□■□□　□■■□　□■■□　□□■□　□■□□　□■■□ □■□□　□□□□　□□□□　□□□□　□□□□　□□□□　□□□□

Lassen Sie uns die oben genannten 7 Arten von Tetrimino in Daten umwandeln

1.2 Antwort

Dies ist auch wie ein Listentyp, der numerische Werte und Zeichen als Werte verwendet, wenn er im Spiel verwendet wird Es ist einfacher auszudrücken, wenn Sie einen Datentyp mit einer festen Anzahl von vertikalen und horizontalen verwenden.

Betrachtet man die Rotation der sieben Tetriminos unabhängig voneinander Die Wiederverwendung ist einfacher, wenn Sie sie als Listentyp mit vertikalen und horizontalen 4x4-Quadraten definieren.

line = [[0,1,0,0],[0,1,0,0],[0,1,0,0],[0,1,0,0]]
tblo = [[0,1,0,0],[0,1,1,0],[0,1,0,0],[0,0,0,0]]
lr   = [[0,1,0,0],[0,1,0,0],[0,1,1,0],[0,0,0,0]]
ll   = [[0,0,1,0],[0,0,1,0],[0,1,1,0],[0,0,0,0]]
hr   = [[0,1,0,0],[0,1,1,0],[0,0,1,0],[0,0,0,0]]
hl   = [[0,0,1,0],[0,1,1,0],[0,1,0,0],[0,0,0,0]]
sq   = [[0,0,0,0],[0,1,1,0],[0,1,1,0],[0,0,0,0]]

t_minos = [line,tblo,lr,ll,hr,hl,sq]

for mino in t_minos:
    for y in mino:
        for x in y:
            print('■' if x==1 else '□',end='')
        print()
    print()

□■□□ □■□□ □■□□ □■□□

□■□□ □■■□ □■□□ □□□□

□■□□ □■□□ □■■□ □□□□

□□■□ □□■□ □■■□ □□□□

□■□□ □■■□ □□■□ □□□□

□□■□ □■■□ □■□□ □□□□

□□□□ □■■□ □■■□ □□□□

2. Erstellen wir eine Funktion, die Tetrimino dreht

Verwenden der zuvor erstellten Tetrimino-Daten Erstellen wir eine Funktion "drehen", die sich um 90 Grad dreht

def rotate(data ,Winkel):
wird bearbeitet
    return data

□■□□ □■■□ □■□□ □□□□

Wenn Sie diese um 90 Grad drehen

□□□□ □■■■ □□■□ □□□□

2. Antworte

Bereiten Sie zunächst die Tetrimino-Daten vor.

data = [[0,1,0,0],[0,1,1,0],[0,1,0,0],[0,0,0,0]]

Es ist mühsam, den Zeichnungscode jedes Mal zu schreiben, also machen Sie ihn zu einer Funktion.

def print_block(block):
    for y in block:
        for x in y:
            print('■' if x==1 else '□',end='')
        print()
print_block(data)

□■□□ □■■□ □■□□ □□□□

2. Verwendung der Antwort [:: -1] und der Zip-Funktion

Wenn Sie "[:: -1]" für eine Liste verwenden, wird eine flache Kopie der ursprünglichen Liste in umgekehrter Reihenfolge erstellt. Die Funktion "zip" extrahiert wiederholt ein Element vom Anfang jedes Arguments, um ein "Tupel" zu erstellen.

In Kombination werden die Elemente um 90 Grad gedreht.

data = [[0,1,0,0],[0,1,1,0],[0,1,0,0],[0,0,0,0]]
print_block(data[::-1])

□□□□ □■□□ □■■□ □■□□

print_block(zip(*data[::-1]))

□□□□ □■■■ □□■□ □□□□

In einer Funktion zusammenfassen

def rotate(data,num):
    tmp = data.copy()
    if num==0:
        return tmp
    rotated = list(map(list, zip(*tmp[::-1])))
    for i in range(num//90-1):
        rotated = list(map(list, zip(*rotated[::-1])))
    return rotated
​
data = [[0,1,0,0],[0,1,1,0],[0,1,0,0],[0,0,0,0]]
block = rotate(data,270)
print_block(block)

□□□□ □■□□ ■■■□ □□□□

2. Antwort Verwendung der Numpy-Bibliothek

Die Numpy-Bibliothek enthält solche matrixartigen Daten Einige haben die Fähigkeit zu arbeiten.

numpy.rot90 (Daten, Anzahl der Umdrehungen)

Drehen Sie das Zahlenfeld um 90 Grad gegen den Uhrzeigersinn Geben Sie 0 ~ für die Anzahl der Umdrehungen an und drehen Sie mit 1 um 90 Grad Im Uhrzeigersinn, wenn die Anzahl der Umdrehungen auf- eingestellt ist

import numpy as np

def rotate2(data,num):
    return np.rot90(data.copy(),-num//90)

data = [[0,1,0,0],[0,1,1,0],[0,1,0,0],[0,0,0,0]]
block = rotate2(data,90)
print_block(block)

□□□□ □■■■ □□■□ □□□□

Dies kann in 2 Zeilen erfolgen.

Zusammenfassung

Wie man über die Datenstruktur nachdenkt und wie man die Daten bedient Ein Puzzlespiel wird empfohlen.

Wir werden dies auch weiterhin tun. Bitte versuchen Sie es auf verschiedene Arten zu lösen.

Na dann.

Informationen zum Autor

HP von Otsu py: http://www.otupy.net/

Youtube： https://www.youtube.com/channel/UCaT7xpeq8n1G_HcJKKSOXMw

Twitter： https://twitter.com/otupython