用python创建两人内存匹配游戏

我正在用python开发一个两人内存匹配游戏。游戏应该有一个6x6的网格，隐藏数字从1到18。玩家将为他们的两次猜测指定行和列，如果匹配，玩家将获得一分。同样的玩家将继续。如果两次猜测不匹配，则下一个玩家继续。每个回合程序都应该询问玩家是否想继续。最后，程序应显示每个玩家的总对数

到目前为止，这是我一直在做的事情，我知道这并不多，我希望能得到一点帮助

x = "▫️️"

answerGrid = [['a  ', 'z  ', 'p  ', 'i  ', 'z  ', 'o  '],
              ['x  ', 'x  ', 'f  ', 'l  ', 'u  ', 'h  '],
              ['d  ', 'd  ', 'l  ', 'o  ', 'p  ', 'f  '],
              ['c  ', 'i  ', 'm  ', 'a  ', 'h  ', 'g  '],
              ['y  ', 'u  ', 's  ', 'b  ', 'y  ', 'k  '],
              ['g  ', 'm  ', 'c  ', 'k  ', 's  ', 'b  ']]

blankGrid = [[x, x, x, x, x, x],
             [x, x, x, x, x, x],
             [x, x, x, x, x, x],
             [x, x, x, x, x, x],
             [x, x, x, x, x, x],
             [x, x, x, x, x, x]]

guesses = 0
guess1 = "  "
guess2 = "  "
option = 0
emptySpaces = 0
correctGuesses = []
rowsAvailable = ["a", "b", "c", "d", "e", "f"]
colsAvailable = ["1", "2", "3", "4", "5", "6"]
cont = 0

---

我可能会从使网格易于使用开始。以下面的代码为例：

grid_width = 6
grid_height = 6
grid_dimensions_product = (grid_width * grid_height)

if grid_dimensions_product % 2 != 0:
    raise ValueError("Product of grid dimensions must be divisible by two!")

number_of_pairs = grid_dimensions_product // 2

print(f"For a {grid_width}x{grid_height} grid, you'll have {number_of_pairs} pairs.")

输出：

For a 6x6 grid, you'll have 18 pairs.

ValueError: Product of grid dimensions must be divisible by two!

通过这样的设置，我们可以随时更改网格的尺寸，以便在游戏中引入更多种类。对的数量将动态计算，这是可取的，因为我们不喜欢硬编码的东西。但是，网格尺寸必须始终相乘，以生成可被2整除的乘积。这是一个要求，因为我们可能最终没有足够的对（网格上没有匹配对的位置）-例如，5 x 5网格将有12对，因此总共只有24个数字。这就是if语句存在的原因。下面是同样的代码，但网格尺寸无效：

grid_width = 5
grid_height = 5
grid_dimensions_product = (grid_width * grid_height)

if grid_dimensions_product % 2 != 0:
    raise ValueError("Product of grid dimensions must be divisible by two!")

number_of_pairs = grid_dimensions_product // 2

print(f"For a {grid_width}x{grid_height} grid, you'll have {number_of_pairs} pairs.")

输出：

For a 6x6 grid, you'll have 18 pairs.

ValueError: Product of grid dimensions must be divisible by two!

一旦我们有了

数字\u对

，我们就可以生成一个隐藏数字列表，稍后我们将使用该列表填充网格：

hidden_numbers = list(range(1, number_of_pairs + 1)) * 2
print(hidden_numbers)

请记住，

范围

是独占的。如果我们想要包含数字1-18，我们必须将+1添加到范围的唯一一端。我们将范围转换成一个列表，然后将列表乘以2，得到数字1-18，两次：

输出：

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]

现在，我们必须洗牌隐藏的数字。在代码顶部，写下：

from random import shuffle

导入

shuffle

功能。它将一个列表作为一个参数，并在适当的位置对其内容进行洗牌

hidden_numbers = list(range(1, number_of_pairs + 1)) * 2
shuffle(hidden_numbers)

hidden_number_iter = iter(hidden_numbers)

grid = []

# Generate the grid
for y in range(grid_height):
    row = [next(hidden_number_iter) for x in range(grid_width)]
    grid.append(row)

# Print the grid
for y in range(grid_height):
    print(grid[y])

洗牌后，我们为

隐藏的\u编号

列表创建一个迭代器。这将允许我们轻松地从无序列表中获取“下一个”隐藏号码。如果您不熟悉迭代器，下面是迭代器行为的一个快速示例：

>>> my_list = ["A", "B", "C"]
>>> my_list_iterator = iter(my_list)
>>> next(my_list_iterator)
'A'
>>> next(my_list_iterator)
'B'
>>> next(my_list_iterator)
'C'
>>> next(my_list_iterator)
Traceback (most recent call last):
  File "<pyshell#34>", line 1, in <module>
    next(my_list_iterator)
StopIteration
>>> 

每次重新启动脚本时，隐藏数字列表将以不同的顺序显示。以下是完整的脚本：

from random import shuffle

grid_width = 6
grid_height = 6
grid_dimensions_product = (grid_width * grid_height)

if grid_dimensions_product % 2 != 0:
    raise ValueError("Product of grid dimensions must be divisible by two!")

number_of_pairs = grid_dimensions_product // 2

hidden_numbers = list(range(1, number_of_pairs + 1)) * 2
shuffle(hidden_numbers)

hidden_number_iter = iter(hidden_numbers)

grid = []

# Generate the grid
for y in range(grid_height):
    row = [next(hidden_number_iter) for x in range(grid_width)]
    grid.append(row)

# Print the grid
for y in range(grid_height):
    print(grid[y])