Cours d'amélioration de la programmation 2

C'est la deuxième fois du cours d'amélioration de la programmation.

Considérez un programme avec Tetris comme sujet.

Cliquez ici pour la vidéo de commentaire

Considérez la structure de données de Tetris

«Tetris» est un «Tetrimino» composé de 4 blocs C'est un jeu de puzzle qui s'organise sur le terrain.

Un jeu de puzzle comme celui-ci Parfait pour le matériel de programmation !!

Pensons-y immédiatement.

1. Dessinons la matière du jeu Tetris

1.1 Numérisation sur le terrain

Avec le champ de la planche (10 x 20 carrés) Blocs qui entourent autre que ci-dessus Les éléments suivants Convertissons le champ en données.

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

Pointe:

C'est ennuyeux d'afficher les carrés en noir et blanc un par un. Utilisons la répétition.

Au total, il y a 21 lignes multipliées par 12 carrés.

1.1 Réponse

Créez et sortez simplement les données comme ci-dessus. Conserver les données ensemble facilite leur réutilisation.

Si vous utilisez le type de liste pour les données alignées verticalement et horizontalement C'est facile à exprimer et à gérer.

La multiplication d'une liste est une addition répétitive d'éléments est une concaténation d'éléments.

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

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

Dans ce cas, les données sont sorties sous forme de caractères,

Dans le cas d'un jeu de puzzle, si vous stockez les données sous forme de chaîne de caractères Il y a aussi des problèmes, donc je pense souvent numériquement.

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

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

■ Si 1 Si □, les données sont stockées à 0 et converties au moment de la sortie.

Maintenant, les résultats sont réunis.

1.2 Conversion de données Tetrimino

Tétrimino (7) □■□□　□■□□　□■□□　□□■□　□■□□　□□■□　□□□□ □■□□　□■■□　□■□□　□□■□　□■■□　□■■□　□■■□ □■□□　□■□□　□■■□　□■■□　□□■□　□■□□　□■■□ □■□□　□□□□　□□□□　□□□□　□□□□　□□□□　□□□□

Convertissons les 7 types de tétrimino ci-dessus en données

1.2 Réponse

C'est aussi comme un type de liste qui utilise des valeurs numériques et des caractères comme valeurs lors de son utilisation dans le jeu Il sera plus facile à exprimer si vous utilisez un type de données avec un nombre fixe de vertical et horizontal.

Considérant la rotation des sept Tetriminos indépendamment Il serait plus facile de le réutiliser si vous le définissez comme un type de liste avec des carrés verticaux et horizontaux 4x4.

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. Créons une fonction qui fait tourner Tetrimino

Utilisation des données Tetrimino que j'ai créées précédemment Créons une fonction rotation qui tourne de 90 degrés

def rotate(data ,angle):
En traitement
    return data

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

Si vous faites pivoter ce 90 degrés

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

2. Réponse

Commencez par préparer les données Tetrimino.

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

Il est difficile d'écrire le code de dessin à chaque fois, alors faites-en une fonction.

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

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

2. Comment utiliser la fonction answer [:: -1] et la fonction zip

Utiliser «[:: -1]» sur une liste fera une copie superficielle de la liste originale dans l'ordre inverse. La fonction zip extrait à plusieurs reprises un élément du début de chaque argument pour créer un Tuple.

Lorsqu'ils sont combinés, les éléments pivotent de 90 degrés.

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]))

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

Pour résumer dans une fonction

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. Answer Comment utiliser la bibliothèque numpy

La bibliothèque numpy contient de telles données matricielles Certains ont la capacité de fonctionner.

numpy.rot90 (données, nombre de rotations)

Faites pivoter le tableau de nombres de 90 degrés dans le sens antihoraire Spécifiez 0 ~ pour le nombre de rotations, faites pivoter 90 degrés avec 1 Dans le sens des aiguilles d'une montre lorsque le nombre de rotations est réglé sur-

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)

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

Cela peut être fait en 2 lignes.

Résumé

Comment penser la structure des données et comment exploiter les données Un jeu de puzzle est recommandé.

Nous continuerons de le faire, alors essayez de le résoudre de différentes manières.

Eh bien.

Informations sur l'auteur

HP d'Otsu py: http://www.otupy.net/

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

Twitter： https://twitter.com/otupython