【Dison夏令营 Day 25】用Python写个2048

于 2024-07-21 06:30:00 发布
阅读量524 收藏 6
点赞数 4
分类专栏： Python夏令营 文章标签： python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41446370/article/details/140578843
版权

在本文中，我们将用 python 代码和逻辑来设计一款你经常在智能手机上玩的 2048 游戏。如果您对该游戏不熟悉，强烈建议您先玩一下该游戏，以便了解其基本功能。

如何玩 2048 .NET？

1.有一个 4*4 的网格，可以填入任何数字。一开始，随机填入两个 2 的单元格。其余单元格为空。

  1. 我们必须按下四个键中的任意一个，才能向上、向下、向左或向右移动。当我们按下任何一个键时，单元格中的元素就会向该方向移动，如果该行（向左或向右移动时）或该列（向上和向下移动时）中包含两个相同的数字，它们就会相加，然后该方向上的极端单元格就会填入该数字，其余单元格就会再次变空。‘

3.网格压缩后，任何随机空格都会被填上 2。

在这里插入图片描述
4.按照上述过程，我们必须通过加法将元素翻倍，并在任意一个单元格中组成 2048。如果我们能做到这一点，我们就赢了。

在这里插入图片描述

5.但是，如果在游戏过程中没有空格可以填入新的 2，那么游戏就结束了。

在这里插入图片描述

在上述过程中，您可以看到 2048 游戏图形用户界面的快照。但所有的逻辑都在主代码中。因此，为了完全理解背后的逻辑，我们可以假设上述网格是一个 4*4 矩阵（一个有四行四列的列表）。下面是上述游戏在没有图形用户界面的情况下进行输入和输出的方法。

例如

Commands are as follows : 
'W' or 'w' : Move Up
'S' or 's' : Move Down
'A' or 'a' : Move Left
'D' or 'd' : Move Right
[0, 0, 0, 0]
[0, 0, 0, 0]
[0, 0, 0, 0]
[0, 0, 2, 0]
Press the command : a
GAME NOT OVER
[0, 0, 0, 2]
[0, 0, 0, 0]
[0, 0, 0, 0]
[2, 0, 0, 0]
Press the command : s
GAME NOT OVER
[0, 0, 0, 0]
[0, 0, 0, 0]
[0, 0, 2, 0]
[2, 0, 0, 2]
Press the command : d
GAME NOT OVER
[0, 0, 0, 0]
[0, 0, 0, 0]
[2, 0, 0, 2]
[0, 0, 0, 4]
Press the command : a
GAME NOT OVER
[0, 2, 0, 0]
[0, 0, 0, 0]
[4, 0, 0, 0]
[4, 0, 0, 0]
Press the command : s
GAME NOT OVER
[0, 0, 0, 0]
[0, 0, 0, 0]
[0, 0, 0, 0]
[8, 2, 0, 2]
.
.
.
And the series of input output will go on till we lose or win!

编程方法 ：

  • 我们将设计每个逻辑函数，例如，我们正在执行左扫，然后通过反转矩阵并执行左扫，将其用于右扫。
  • 向上移动可以通过转置然后向左移动来完成。
  • 向下移动可以通过转置和向右移动来实现。
  • 注释中详细解释了程序中的所有逻辑。强烈建议阅读所有注释。

下面有两个 python 文件，一个是包含主驱动代码的 2048.py，另一个是包含所有函数的 logic.py。要使用这些函数，应将 logic.py 导入 2048.py。只需将这两个文件放在同一文件夹中，然后运行 2048.py，即可完美运行。

logic.py

# logic.py to be 
# imported in the 2048.py file

# importing random package
# for methods to generate random
# numbers.
import random

# function to initialize game / grid
# at the start
def start_game():

	# declaring an empty list then
	# appending 4 list each with four
	# elements as 0.
	mat =[]
	for i in range(4):
		mat.append([0] * 4)

	# printing controls for user
	print("Commands are as follows : ")
	print("'W' or 'w' : Move Up")
	print("'S' or 's' : Move Down")
	print("'A' or 'a' : Move Left")
	print("'D' or 'd' : Move Right")

	# calling the function to add
	# a new 2 in grid after every step
	add_new_2(mat)
	return mat

# function to add a new 2 in
# grid at any random empty cell
def add_new_2(mat):

# choosing a random index for
# row and column.
	r = random.randint(0, 3)
	c = random.randint(0, 3)

	# while loop will break as the
	# random cell chosen will be empty
	# (or contains zero)
	while(mat[r] != 0):
		r = random.randint(0, 3)
		c = random.randint(0, 3)

	# we will place a 2 at that empty
	# random cell.
	mat[r] = 2

# function to get the current
# state of game
def get_current_state(mat):

	# if any cell contains
	# 2048 we have won
	for i in range(4):
		for j in range(4):
			if(mat[i][j]== 2048):
				return 'WON'

	# if we are still left with
	# atleast one empty cell
	# game is not yet over
	for i in range(4):
		for j in range(4):
			if(mat[i][j]== 0):
				return 'GAME NOT OVER'

	# or if no cell is empty now
	# but if after any move left, right,
	# up or down, if any two cells
	# gets merged and create an empty
	# cell then also game is not yet over
	for i in range(3):
		for j in range(3):
			if(mat[i][j]== mat[i + 1][j] or mat[i][j]== mat[i][j + 1]):
				return 'GAME NOT OVER'

	for j in range(3):
		if(mat[3][j]== mat[3][j + 1]):
			return 'GAME NOT OVER'

	for i in range(3):
		if(mat[i][3]== mat[i + 1][3]):
			return 'GAME NOT OVER'

	# else we have lost the game
	return 'LOST'

# all the functions defined below
# are for left swap initially.

# function to compress the grid
# after every step before and
# after merging cells.
def compress(mat):

	# bool variable to determine
	# any change happened or not
	changed = False

	# empty grid 
	new_mat = []

	# with all cells empty
	for i in range(4):
		new_mat.append([0] * 4)
		
	# here we will shift entries
	# of each cell to it's extreme
	# left row by row
	# loop to traverse rows
	for i in range(4):
		pos = 0

		# loop to traverse each column
		# in respective row
		for j in range(4):
			if(mat[i][j] != 0):
				
				# if cell is non empty then
				# we will shift it's number to
				# previous empty cell in that row
				# denoted by pos variable
				new_mat[i][pos] = mat[i][j]
				
				if(j != pos):
					changed = True
				pos += 1

	# returning new compressed matrix
	# and the flag variable.
	return new_mat, changed

# function to merge the cells
# in matrix after compressing
def merge(mat):
	
	changed = False
	
	for i in range(4):
		for j in range(3):

			# if current cell has same value as
			# next cell in the row and they
			# are non empty then
			if(mat[i][j] == mat[i][j + 1] and mat[i][j] != 0):

				# double current cell value and
				# empty the next cell
				mat[i][j] = mat[i][j] * 2
				mat[i][j + 1] = 0

				# make bool variable True indicating
				# the new grid after merging is
				# different.
				changed = True

	return mat, changed

# function to reverse the matrix
# means reversing the content of
# each row (reversing the sequence)
def reverse(mat):
	new_mat =[]
	for i in range(4):
		new_mat.append([])
		for j in range(4):
			new_mat[i].append(mat[i][3 - j])
	return new_mat

# function to get the transpose
# of matrix means interchanging
# rows and column
def transpose(mat):
	new_mat = []
	for i in range(4):
		new_mat.append([])
		for j in range(4):
			new_mat[i].append(mat[j][i])
	return new_mat

# function to update the matrix
# if we move / swipe left
def move_left(grid):

	# first compress the grid
	new_grid, changed1 = compress(grid)

	# then merge the cells.
	new_grid, changed2 = merge(new_grid)
	
	changed = changed1 or changed2

	# again compress after merging.
	new_grid, temp = compress(new_grid)

	# return new matrix and bool changed
	# telling whether the grid is same
	# or different
	return new_grid, changed

# function to update the matrix
# if we move / swipe right
def move_right(grid):

	# to move right we just reverse
	# the matrix 
	new_grid = reverse(grid)

	# then move left
	new_grid, changed = move_left(new_grid)

	# then again reverse matrix will
	# give us desired result
	new_grid = reverse(new_grid)
	return new_grid, changed

# function to update the matrix
# if we move / swipe up
def move_up(grid):

	# to move up we just take
	# transpose of matrix
	new_grid = transpose(grid)

	# then move left (calling all
	# included functions) then
	new_grid, changed = move_left(new_grid)

	# again take transpose will give
	# desired results
	new_grid = transpose(new_grid)
	return new_grid, changed

# function to update the matrix
# if we move / swipe down
def move_down(grid):

	# to move down we take transpose
	new_grid = transpose(grid)

	# move right and then again
	new_grid, changed = move_right(new_grid)

	# take transpose will give desired
	# results.
	new_grid = transpose(new_grid)
	return new_grid, changed

# this file only contains all the logic
# functions to be called in main function
# present in the other file

代码解释：

  1. 代码首先导入随机软件包。
  2. 该软件包提供了生成随机数的方法。
  3. 接着，声明 start_game() 函数。
  4. 该函数将用于在程序开始时初始化游戏/网格。
  5. 该函数首先声明一个名为 mat 的空 list。
  6. 然后，它附加了四个列表，每个列表有四个元素，每个元素的值为 0。
  7. 这些列表代表游戏/网格上的单元格。
  8. 第一个列表（mat[0] ）代表 0 号单元格，以此类推。
  9. 接下来，for 循环遍历 4 个值（i 在 range(4) 中）。
  10. 每个值都会生成一个包含 4 个元素（[0] * 4）的新列表。
  11. 这些列表分别代表游戏/网格上 4 个可能的位置。
  12. 代码初始化了一个空列表，然后追加了四个列表，每个列表有四个元素。
  13. 第一个列表有 0 个元素，第二个列表有 1 个元素，第三个列表有 2 个元素，以此类推。
  14. 代码首先声明了两个变量 r 和 c，这两个变量将保存新 2 插入网格的行数和列数。
  15. 接下来，代码会调用一个名为 add_new_2() 的函数。
  16. 该函数有一个参数，即 mat。
  17. mat 是一个 Python 列表对象（一种存储多个项目的数据结构）。
  18. add_new_2() 函数首先选择两个随机数 r 和 c，然后使用这两个随机数指定新 2 插入网格的行和列。
  19. 最后，函数返回 mat 作为结果。
  20. 在计算机上运行这段代码时，您会看到类似下面的内容：W’或’w’：向上移动 S’或’s’：向下移动 A’ 或 ‘a’ : 向左移动 D’ 或 ‘d’ : 向右移动
  21. 代码首先随机选择行和列索引。
  22. 然后，它使用这些值在网格中选择一个新的空白单元格来添加新的 2。
  23. 最后，以新选择的单元格为参数调用 add_new_2 函数。
  24. 代码首先声明了两个变量。
  25. 第一个变量 mat 是一个包含四个整数的数组。
  26. 第二个变量 r 是一个介于 0 和 3 之间的随机数。
  27. 然后，代码循环遍历 mat 数组中的每个整数。
  28. 它会检查存储在 mat 数组中该位置的值是否与 2048 匹配（这是本游戏的获胜条件）。
  29. 如果符合，代码将返回 “WON”。
  30. 如果匹配数组中仍有尚未检查的单元格，代码将继续循环检查这些单元格。
  31. 对于每个尚未检查的单元格，代码都会检查其值是否与 2048 匹配。
  32. 如果不匹配，代码就会宣布玩家获胜并结束程序执行。
  33. 如果 mat 中的所有单元格都已检查过，或者其中一个单元格包含 2048（获胜条件），则不能宣布获胜，控制权将传回 get_current_state()，以便开始新一轮检查。
  34. 代码将检查矩阵 (mat) 中的每个单元格，看其是否包含 2048 的值。
  35. 如果有单元格包含 2048，代码将返回 “WON”。
  36. 如果在循环过程中的任何时候，mat 中所有四个单元格的值都为 0，则游戏尚未结束，代码将继续循环检查 mat 中的剩余单元格。
  37. 代码首先会检查游戏是否已经结束。
  38. 如果尚未结束，代码会检查是否有单元格被合并。
  39. 如果两个单元格已经合并，那么游戏结束，代码返回 “GAME NOT OVER”。
  40. 否则，代码将继续检查棋子的移动，直到有一个单元格是空的或者游戏结束。
  41. 如果出现平局，我们将宣布游戏失败。
  42. 代码将检查给定坐标处的单元格是否相等。
  43. 如果相等，则返回 “游戏未结束”。
  44. 如果不相等，则返回 “输了”。
  45. 代码通过将每个单元格的值复制到一个新列表来压缩网格。
  46. 代码首先创建一个空列表，然后循环矩阵中的所有单元格。
  47. 对于每个单元格，代码会计算新列表中所有单元格值的总和。
  48. 然后将该总和赋值给 i 变量。
  49. 下一行将创建一个名为 changed 的 bool 变量。
  50. 该变量将跟踪自上次调用 compress() 以来是否发生了任何变化。
  51. 如果没有变化，那么 changed 将被设置为 False。
  52. 否则，changed 变为 True。
  53. 接下来，代码会将每个单元格的值复制到一个新的列表中，从而压缩网格。
  54. 具体做法是循环遍历 mat 中的所有单元格，并将每个单元格的值乘以 4 。
  55. 最后，代码将这些列表相加，创建 new_mat。
  56. 代码在合并单元格前后的每一步都会压缩网格。
  57. bool 变量 changed 用于确定是否发生了变化。
  58. 如果没有变化，代码就会创建一个空网格。
  59. 代码首先声明了两个变量：changed 和 new_mat。
  60. changed 变量将记录矩阵中的单元格是否被修改。
  61. new_mat 变量将保存压缩矩阵向左移动一行后乘以 2 的结果。
  62. 接下来，代码会依次循环每一列。
  63. 对于该列中的每个单元格，如果其值等于下一个单元格的值，并且它们不是空的，那么就会重复检1. 查以确保它们仍然相等。
  64. 如果相等，则将它们的值设置为原始值的 2 倍，并清空该列中的下一个单元格，以便为将来的计算保留一个新值。
  65. 下一步将调用 merge() 函数。
  66. 该函数将一个 4×4 单元的矩阵作为输入，并根据单元格的值将其中的所有单元格合并在一起。
  67. 如果有任何单元格被修改，那么在将其返回给调用者之前，将在该函数中更新它们的值。
  68. 代码首先声明一个变量 i 代表行号，j 代表列号。
  69. 然后循环查看矩阵中的每个单元格，检查当前单元格的值是否与该行的下一个单元格一致，并确保两个单元格都不是空的。
  70. 如果这两个条件都满足，那么当前单元格的值就会加倍，并在该行的下一个单元格中设置为 0。
  71. 矩阵中的每一行都会重复这一过程。
  72. 代码首先创建一个布尔变量 “changed”，用于表示合并后的新网格是否不同。
  73. 如果网格不同，代码就会执行 reverse() 函数将矩阵反转，使其按原来的顺序显示。
  74. 然后使用 transpose() 函数交换行和列。
  75. 最后，update_mat() 函数将使用这两个函数来更改 mat 的内容。
  76. 代码首先创建一个名为 changed 的布尔变量，并将其设置为 True。
  77. 然后调用 reverse() 函数反转矩阵。
  78. 然后调用 transpose() 函数交错行和列。
  79. 最后，以这两个函数为参数调用 update_mat()，以更改 mat 的内容。
  80. 代码首先定义了两个变量：changed 和 mat。
  81. 一旦矩阵被合并，changed 变量将被设置为 True，因此代表新的网格。
  82. mat 变量将保持不变，因为它并不代表新网格。
  83. 下一个代码块定义了一个函数 reverse，该函数将反转 mat 变量中的行序列。
  84. 方法是在每一行添加一个空列表，然后引用该行中的各个列表项。
  85. 最后，还定义了 transpose 函数，用于交换 mat 中的行和列。
  86. 代码首先会压缩网格，从而缩小网格。
  87. 接下来，代码会合并新网格中的单元格，然后返回新矩阵和已更改的 bool 值。
  88. 最后，代码再次压缩新矩阵。
  89. 压缩的第一步是通过删除重复值来缩小每一行和每一列的大小。
  90. 第二步是将相邻的单元格合并在一起，使它们形成一个具有完整原始值的单元格。
  91. 最后，代码会再次压缩合并单元格，以再次创建一个更小的网格。
  92. 代码首先压缩网格，然后合并单元格并返回新的压缩网格。
  93. 然后，再次压缩新网格，并比较两个结果。
  94. 最后，返回新矩阵和已更改的 bool。
  95. 本节代码用于更新屏幕上的网格。
  96. 代码首先会检查用户是否向右或向左移动了手指（或轻扫）。
  97. 如果用户向右移动了手指（或轻扫），代码就会反向更新网格。
  98. 接下来，如果用户向上移动了手指（或轻扫），那么代码就不会反转矩阵，而是取其转置值并相应1地更新网格。
  99. 代码首先反转网格矩阵。
  100. 这对于向右或向上移动是必要的。
  101. 然后，根据输入的方向更新网格矩阵。
  102. 最后，返回更新后的网格和更改后的值。
  103. 代码首先创建两个新变量 new_grid 和 changed。
  104. 然后，代码使用 move_left 函数将网格向左移动。
  105. 接着，代码对新网格进行转置，创建一个新矩阵。
  106. 最后，代码同时返回原始网格和转置矩阵。
  107. move_down 函数的工作方式与此类似。
  108. 首先，它会创建两个新变量 new_grid 和 changed。
  109. 然后使用 move_down 函数向下移动。
  110. 再次，使用 transpose 创建一个新矩阵。
  111. 最后，原始网格和转置矩阵都会返回。
  112. 代码首先创建一个新的 2×2 网格。
  113. 然后，将新网格最左边的一列向下移动一行，最右边的一列向上移动一行。
  114. 最后，代码将新创建的网格转置，使其恢复到原来的形式。
  115. 如果在一个 3×3 矩阵上运行这段代码，它会将矩阵的左上角向下移动一行，将矩阵的右下角向上移动一行。

2048.py

# 2048.py

# importing the logic.py file
# where we have written all the
# logic functions used.
import logic

# Driver code
if __name__ == '__main__':
	
# calling start_game function
# to initialize the matrix
	mat = logic.start_game()

while(True):

	# taking the user input
	# for next step
	x = input("Press the command : ")

	# we have to move up
	if(x == 'W' or x == 'w'):

		# call the move_up function
		mat, flag = logic.move_up(mat)

		# get the current state and print it
		status = logic.get_current_state(mat)
		print(status)

		# if game not over then continue
		# and add a new two
		if(status == 'GAME NOT OVER'):
			logic.add_new_2(mat)

		# else break the loop 
		else:
			break

	# the above process will be followed
	# in case of each type of move
	# below

	# to move down
	elif(x == 'S' or x == 's'):
		mat, flag = logic.move_down(mat)
		status = logic.get_current_state(mat)
		print(status)
		if(status == 'GAME NOT OVER'):
			logic.add_new_2(mat)
		else:
			break

	# to move left
	elif(x == 'A' or x == 'a'):
		mat, flag = logic.move_left(mat)
		status = logic.get_current_state(mat)
		print(status)
		if(status == 'GAME NOT OVER'):
			logic.add_new_2(mat)
		else:
			break

	# to move right
	elif(x == 'D' or x == 'd'):
		mat, flag = logic.move_right(mat)
		status = logic.get_current_state(mat)
		print(status)
		if(status == 'GAME NOT OVER'):
			logic.add_new_2(mat)
		else:
			break
	else:
		print("Invalid Key Pressed")

	# print the matrix after each
	# move.
	print(mat)

代码解释：

  1. 代码首先导入逻辑模块。
  2. 该模块包含我们将在程序中使用的所有函数。
  3. 接下来，我们需要一个函数来初始化矩阵。
  4. 这是通过调用 start_game() 函数完成的。
  5. while 循环一直运行到用户按下键盘上的任意键（W、S、A、D）为止。
  6. 每按一次键，我们都会调用逻辑中的一个函数。
  7. 这些函数是 move_up()、move_down() 和 move_left()。
  8. 我们还需要调用 get_current_state()，以获取矩阵当前状态的信息。
  9. logic 中的每个函数都需要两个参数：mat 和 flag。
  10. mat 是矩阵对象，flag 是表示向上移动的 "W "或表示向下移动的 “S”。
  11. 如果你还记得本章前面的内容，这些都是对变量的引用，用于存储有关游戏棋盘的数据。
  12. 调用每个函数后，我们会打印出结果，然后使用状态变量检查游戏是否结束。
  13. 如果还没有结束，我们就使用 add_new_2() 在矩阵中添加新的一行。
  14. 否则，我们就跳出循环，因为在这个代码块中已经没有其他事情可做了！
  15. 最后，在
  16. 代码首先导入 logic.py 文件。
  17. 该文件包含本项目中使用的所有函数。
  18. 接着，我们编写了驱动程序代码。
  19. 在这段代码中，我们将检查按键的输入，并根据输入情况调用 logic.py 文件中的某个函数。
  20. 我们将在本文稍后部分详细讨论这些函数。
  21. while 循环用于跟踪用户输入并执行其中的相应代码。
  22. 该循环中的代码将一直执行，直到用户按下任何其他键或游戏结束。
  23. 在 if 语句中，我们将检查不同的按键，并根据输入情况调用 logic.py 中的一个函数
DisonTangor
关注
  • 4
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
marqu-dison
03-27
【标题】"marqu-dison"可能是指一个与前端开发相关的项目或库，可能是某个设计师或开发者使用的名字作为项目的代号。"麦迪逊"在中国通常不会被用作技术术语，但在这里可能是指个人或者团队的名称，或者是项目的一个...
Dison:JavaScript中的新解析器框架
05-14
由于使用的 hash 查找匹配，当前效率只有 Esprima 的 1/2 左右，到时候会将hash大头映射为数组下标查找，应该性能可以高一截，不过还有其他事情要处理，现在主要用于测试，这个改了不利于调试延后在做 Examples: { ...
【Dison夏令营 Day 15】 Python 鸡蛋捕手
weixin_41446370的博客
07-11 1050
在本次课程中，我们使用 Python 创建了经典的 "抓蛋 "游戏。在这个游戏中，每抓到一个鸡蛋就能赢得 10 分，而每掉落一个鸡蛋就会损失一条命。小时候，我们都玩过 "抓鸡蛋 "游戏。我们使用海龟软件包在 Python 中实现了这个游戏。在这个抓蛋游戏中，您必须用一个篮子抓住掉落在屏幕上的鸡蛋，这将考验您的注意力和反应能力。要设计一个鸡蛋捕手游戏，您需要创建一个动画，显示鸡蛋随机掉落的位置和一个篮子将鸡蛋全部接住的过程。构建地板、篮子和鸡蛋是用 Python 创建鸡蛋捕手游戏的第一步。
【Dison夏令营 Day 08】Python游戏：掷骰子
weixin_41446370的博客
07-04 857
掷骰子游戏是最简单但也最有趣的游戏之一。在本文中，我们将使用两种方法在 Python 中实现掷骰子游戏。在本文中，我们讨论了用 Python 实现掷骰子游戏的两种方法。您可以更改程序中使用的变量来定制游戏。这将帮助你进一步了解 while 循环、随机模块和 if-else 语句。
【Dison夏令营 Day 14】使用 Python 创建贪吃蛇
weixin_41446370的博客
07-10 502
在本教程中，您将学习如何制作小蛇游戏。该游戏是一款街机游戏，逻辑非常简单，因此是演示如何用 Pygame 构建游戏的理想示例。玩家扮演一条蛇，如果吃到苹果，蛇就会生长。游戏的目标是在不撞到自己的情况下吃掉尽可能多的苹果。这在游戏的早期阶段非常容易，但随着蛇的长度增加，难度也会越来越大。
【Dison夏令营 Day 23】Python 中的四连棋游戏
weixin_41446370的博客
07-19 899
在开始之前，让我们先了解一下什么是连接四游戏。它是一种双人连线棋盘游戏，玩家选择一种颜色，然后轮流将彩色圆盘投放到一个七列六行垂直悬挂的网格中。棋子直接落下，占据列内最低的可用空间。游戏的目的是最先将自己的四个棋子排成水平、垂直或对角线。四子连环是一种解谜游戏。第一个玩家只要走对一步棋，就能永远获胜。听起来很有趣吧？让我们来了解一下如何用 python 编程语言编码这个游戏。
【Dison夏令营 Day 21】用Python编写绘图
weixin_41446370的博客
07-16 227
绘画 - 在屏幕上绘制线条和形状。单击标记形状的起点，再次单击标记形状的终点。可使用键盘选择不同的形状和颜色。
【Dison夏令营 Day 20】用Python编写五子棋
weixin_41446370的博客
07-16 130
五子棋起源于中国，是全国智力运动会竞技项目之一，是一种两人对弈的纯策略型棋类游戏。双方分别使用黑白两色的棋子，下在棋盘直线与横线的交叉点上，先形成五子连珠者获胜。computer.py 文件主要是电脑的算法。gobanggame.py 主游戏文件。button.py 重新按钮。
【Dison夏令营 Day 24】使用 Python 制作小飞侠
最新发布
weixin_41446370的博客
07-20 272
在本文中，我们将使用 Python 乌龟模块来创建 Fidget Spinner。它是一个类似于画板的 Python 功能，可以让我们命令乌龟在上面画来画去！我们可以使用 turtle.forward() 和 turtle.right() 等函数来移动乌龟。
【Dison夏令营 Day 19】用Python编写迷宫游戏
weixin_41446370的博客
07-15 358
在本教程中，您将学习如何制作一款迷宫游戏。玩法很简单，就是用箭头键在迷宫中移动。
【Dison夏令营 Day 02】使用 Python 玩井字游戏
weixin_41446370的博客
06-28 922
井字游戏是一种双人游戏，在 3×3 正方形网格上进行。每位玩家轮流占据一个单元格，目标是按水平、垂直或对角线模式放置三个标记。一名玩家使用十字 "X "作为标记，另一名玩家则使用无 "O "标记。
DPDMCalculadora-Dev:Exercícioformativo-卡尔库拉多拉。 Móveis分配论学科奖-BSI-Mark Joselli教授
03-16
DPDMCalculadora-Dev项目可能涉及使用特定编程语言（如Java、Python或C#）来创建一个计算器应用。 2. **用户界面（UI）设计**：计算器应用需要一个直观且易于使用的界面，这涉及到界面元素的布局、颜色搭配和交互...
基于单片机的12864液晶
01-15
`dison_off`子程序控制液晶屏的开关，接收一个参数a，当a为0时关闭屏幕，为1时打开。`reset`子程序执行复位操作，确保液晶屏在使用前处于已知的初始状态。 `delay`子程序通常用于实现定时延时，这是液晶操作中经常...
Banet, A. G. Jr. (Ed.). (1976). Creative psychotherapy: A source book. La Jolla, CA: University Associates, 358 pp., [dollar]10.00 (paper)
06-29
dison Wesley, 344 pp., $19.95. This introductory textbook outlines theoretical and practical considerations for con- ducting psychotherapy. There are four parts, including theoretical and ...
Banet, AG Jr. (Ed.)。 (1976)。 创造性心理治疗：源书。 加利福尼亚州拉霍亚：University Associates，358 页，[美元]10.00（纸）
06-29
dison Wesley, 344 pp., $19.95. This introductory textbook outlines theoretical and practical considerations for con- ducting psychotherapy. There are four parts, including theoretical and ...
Hokanson, J. E. (1983). Introduction to the therapeutic process. Reading, MA: Addison Wesley, 344 pp., [dollar]19.95
06-29
dison Wesley, 344 pp., $19.95. This introductory textbook outlines theoretical and practical considerations for con- ducting psychotherapy. There are four parts, including theoretical and ...
霍坎森，JE (1983)。 介绍治疗过程。 马萨诸塞州雷丁市：Addison Wesley，344 页，[美元]19.95
06-29
dison Wesley, 344 pp., $19.95. This introductory textbook outlines theoretical and practical considerations for con- ducting psychotherapy. There are four parts, including theoretical and ...
EasyUI+v1.3.4官方API中文版
03-24
在EasyUI的官方API中文版中，开发者可以找到关于如何使用这个框架的详细指南。API文档通常包括以下几部分： 1. **组件介绍**：每个EasyUI组件（如datagrid、panel、dialog等）都有详细的介绍，包括基本用法、属性、...
ppm文档管理
04-18
该系统的核心功能在于提供一个安全、高效且易于使用的平台，以便企业或个人可以有效地管理和追踪其文档库。下面将详细阐述该系统的关键组件和工作原理。 首先，`jdbc.properties` 文件是系统配置的重要部分，它位于...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值