python 自动化 贪吃蛇

最新推荐文章于 2024-08-17 08:45:43 发布
最新推荐文章于 2024-08-17 08:45:43 发布
阅读量703 收藏 3
点赞数
文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53944807/article/details/124375428
版权 
import random
import pygame
import sys
from pygame.locals import *


# 错误码
ERR = -404
# 屏幕大小
Window_Width = 800
Window_Height = 500
# 刷新频率
Display_Clock = 17
# 一块蛇身大小
Cell_Size = 20
assert Window_Width % Cell_Size == 0
assert Window_Height % Cell_Size == 0
# 等价的运动区域大小
Cell_W = int(Window_Width/Cell_Size)
Cell_H = int(Window_Height/Cell_Size)
FIELD_SIZE = Cell_W * Cell_H
# 背景颜色
Background_Color = (0, 0, 0)
# 蛇头索引
Head_index = 0
# 运动方向
best_move = ERR
# 不同东西在矩阵里用不同的数字表示
FOOD = 0
FREE_PLACE = (Cell_W+1) * (Cell_H+1)
SNAKE_PLACE = 2 * FREE_PLACE
# 运动方向字典
move_directions = {
					'left': -1,
					'right': 1,
					'up': -Cell_W,
					'down': Cell_W
					}


# 关闭游戏界面
def close_game():
	pygame.quit()
	sys.exit()


# 检测玩家的按键
def Check_PressKey():
	if len(pygame.event.get(QUIT)) > 0:
		close_game()
	KeyUp_Events = pygame.event.get(KEYUP)
	if len(KeyUp_Events) == 0:
		return None
	elif KeyUp_Events[0].key == K_ESCAPE:
		close_game()
	return KeyUp_Events[0].key


# 显示当前得分
def Show_Score(score):
	score_Content = Main_Font.render('得分：%s' % (score), True, (255, 255, 255))
	score_Rect = score_Content.get_rect()
	score_Rect.topleft = (Window_Width-120, 10)
	Main_Display.blit(score_Content, score_Rect)


# 获得果实位置
def Get_Apple_Location(snake_Coords):
	flag = True
	while flag:
		apple_location = {'x': random.randint(0, Cell_W-1), 'y': random.randint(0, Cell_H-1)}
		if apple_location not in snake_Coords:
			flag = False
	return apple_location


# 显示果实
def Show_Apple(coord):
	x = coord['x'] * Cell_Size
	y = coord['y'] * Cell_Size
	apple_Rect = pygame.Rect(x, y, Cell_Size, Cell_Size)
	pygame.draw.rect(Main_Display, (255, 0, 0), apple_Rect)


# 显示蛇
def Show_Snake(coords):
	x = coords[0]['x'] * Cell_Size
	y = coords[0]['y'] * Cell_Size
	Snake_head_Rect = pygame.Rect(x, y, Cell_Size, Cell_Size)
	pygame.draw.rect(Main_Display, (0, 80, 255), Snake_head_Rect)
	Snake_head_Inner_Rect = pygame.Rect(x+4, y+4, Cell_Size-8, Cell_Size-8)
	pygame.draw.rect(Main_Display, (0, 80, 255), Snake_head_Inner_Rect)
	for coord in coords[1:]:
		x = coord['x'] * Cell_Size
		y = coord['y'] * Cell_Size
		Snake_part_Rect = pygame.Rect(x, y, Cell_Size, Cell_Size)
		pygame.draw.rect(Main_Display, (0, 155, 0), Snake_part_Rect)
		Snake_part_Inner_Rect = pygame.Rect(x+4, y+4, Cell_Size-8, Cell_Size-8)
		pygame.draw.rect(Main_Display, (0, 255, 0), Snake_part_Inner_Rect)


# 画网格
def draw_Grid():
	# 垂直方向
	for x in range(0, Window_Width, Cell_Size):
		pygame.draw.line(Main_Display, (40, 40, 40), (x, 0), (x, Window_Height))
	# 水平方向
	for y in range(0, Window_Height, Cell_Size):
		pygame.draw.line(Main_Display, (40, 40, 40), (0, y), (Window_Width, y))


# 显示开始界面
def Show_Start_Interface():
	title_Font = pygame.font.Font('simkai.ttf', 100)
	title_content = title_Font.render('贪吃蛇', True, (255, 255, 255), (0, 0, 160))
	angle = 0
	while True:
		Main_Display.fill(Background_Color)
		rotated_title = pygame.transform.rotate(title_content, angle)
		rotated_title_Rect = rotated_title.get_rect()
		rotated_title_Rect.center = (Window_Width/2, Window_Height/2)
		Main_Display.blit(rotated_title, rotated_title_Rect)
		pressKey_content = Main_Font.render('按任意键开始游戏！', True, (255, 255, 255))
		pressKey_Rect = pressKey_content.get_rect()
		pressKey_Rect.topleft = (Window_Width-200, Window_Height-30)
		Main_Display.blit(pressKey_content, pressKey_Rect)
		if Check_PressKey():
			# 清除事件队列
			pygame.event.get()
			return
		pygame.display.update()
		Snake_Clock.tick(Display_Clock)
		angle -= 5


# 显示结束界面
def Show_End_Interface():
	title_Font = pygame.font.Font('simkai.ttf', 100)
	title_game = title_Font.render('Game', True, (233, 150, 122))
	title_over = title_Font.render('Over', True, (233, 150, 122))
	game_Rect = title_game.get_rect()
	over_Rect = title_over.get_rect()
	game_Rect.midtop = (Window_Width/2, 70)
	over_Rect.midtop = (Window_Width/2, game_Rect.height+70+25)
	Main_Display.blit(title_game, game_Rect)
	Main_Display.blit(title_over, over_Rect)
	pygame.display.update()
	pygame.time.wait(500)
	while True:
		for event in pygame.event.get():
			if event.type == QUIT:
				close_game()
			elif event.type == KEYDOWN:
				if event.key == K_ESCAPE:
					close_game()


# 判断该位置是否为空
def Is_Cell_Free(idx, psnake):
	location_x = idx % Cell_W
	location_y = idx // Cell_W
	idx = {'x': location_x, 'y': location_y}
	return (idx not in psnake)


# 重置board
def board_reset(psnake, pboard, pfood):
	temp_board = pboard[:]
	pfood_idx = pfood['x'] + pfood['y'] * Cell_W
	for i in range(FIELD_SIZE):
		if i == pfood_idx:
			temp_board[i] = FOOD
		elif Is_Cell_Free(i, psnake):
			temp_board[i] = FREE_PLACE
		else:
			temp_board[i] = SNAKE_PLACE
	return temp_board


# 检查位置idx是否可以向当前move方向运动
def is_move_possible(idx, move_direction):
	flag = False
	if move_direction == 'left':
		if idx%Cell_W > 0:
			flag = True
		else:
			flag = False
	elif move_direction == 'right':
		if idx%Cell_W < Cell_W-1:
			flag = True
		else:
			flag = False
	elif move_direction == 'up':
		if idx > Cell_W-1:
			flag = True
		else:
			flag = False
	elif move_direction == 'down':
		if idx < FIELD_SIZE - Cell_W:
			flag = True
		else:
			flag = False
	return flag


# 广度优先搜索遍历整个board
# 计算出board中每个非SNAKE_PLACE元素到达食物的路径长度
def board_refresh(psnake, pfood, pboard):
	temp_board = pboard[:]
	pfood_idx = pfood['x'] + pfood['y'] * Cell_W
	queue = []
	queue.append(pfood_idx)
	inqueue = [0] * FIELD_SIZE
	found = False
	while len(queue) != 0:
		idx = queue.pop(0)
		if inqueue[idx] == 1:
			continue
		inqueue[idx] = 1
		for move_direction in ['left', 'right', 'up', 'down']:
			if is_move_possible(idx, move_direction):
				if (idx+move_directions[move_direction]) == (psnake[Head_index]['x'] + psnake[Head_index]['y']*Cell_W):
					found = True
				# 该点不是蛇身(食物是0才可以这样子写)
				if temp_board[idx+move_directions[move_direction]] < SNAKE_PLACE:
					if temp_board[idx+move_directions[move_direction]] > temp_board[idx]+1:
						temp_board[idx+move_directions[move_direction]] = temp_board[idx] + 1
					if inqueue[idx+move_directions[move_direction]] == 0:
						queue.append(idx+move_directions[move_direction])
	return (found, temp_board)


# 根据board中元素值
# 从蛇头周围4个领域点中选择最短路径
def choose_shortest_safe_move(psnake, pboard):
	best_move = ERR
	min_distance = SNAKE_PLACE
	for move_direction in ['left', 'right', 'up', 'down']:
		idx = psnake[Head_index]['x'] + psnake[Head_index]['y']*Cell_W
		if is_move_possible(idx, move_direction) and (pboard[idx+move_directions[move_direction]]<min_distance):
			min_distance = pboard[idx+move_directions[move_direction]]
			best_move = move_direction
	return best_move


# 找到移动后蛇头的位置
def find_snake_head(snake_Coords, direction):
	if direction == 'up':
		newHead = {'x': snake_Coords[Head_index]['x'],
				   'y': snake_Coords[Head_index]['y']-1}
	elif direction == 'down':
		newHead = {'x': snake_Coords[Head_index]['x'],
				   'y': snake_Coords[Head_index]['y']+1}
	elif direction == 'left':
		newHead = {'x': snake_Coords[Head_index]['x']-1,
				   'y': snake_Coords[Head_index]['y']}
	elif direction == 'right':
		newHead = {'x': snake_Coords[Head_index]['x']+1,
				   'y': snake_Coords[Head_index]['y']}
	return newHead


# 虚拟地运行一次
def virtual_move(psnake, pboard, pfood):
	temp_snake = psnake[:]
	temp_board = pboard[:]
	reset_tboard = board_reset(temp_snake, temp_board, pfood)
	temp_board = reset_tboard
	food_eated = False
	while not food_eated:
		refresh_tboard = board_refresh(temp_snake, pfood, temp_board)[1]
		temp_board = refresh_tboard
		move_direction = choose_shortest_safe_move(temp_snake, temp_board)
		snake_Coords = temp_snake[:]
		temp_snake.insert(0, find_snake_head(snake_Coords, move_direction))
		# 如果新的蛇头正好是食物的位置
		if temp_snake[Head_index] == pfood:
			reset_tboard = board_reset(temp_snake, temp_board, pfood)
			temp_board = reset_tboard
			pfood_idx = pfood['x'] + pfood['y'] * Cell_W
			temp_board[pfood_idx] = SNAKE_PLACE
			food_eated = True
		else:
			newHead_idx = temp_snake[0]['x'] + temp_snake[0]['y'] * Cell_W
			temp_board[newHead_idx] = SNAKE_PLACE
			end_idx = temp_snake[-1]['x'] + temp_snake[-1]['y'] * Cell_W
			temp_board[end_idx] = FREE_PLACE
			del temp_snake[-1]
	return temp_snake, temp_board


# 检查蛇头和蛇尾间是有路径的
# 避免蛇陷入死路
def is_tail_inside(psnake, pboard, pfood):
	temp_board = pboard[:]
	temp_snake = psnake[:]
	# 将蛇尾看作食物
	end_idx = temp_snake[-1]['x'] + temp_snake[-1]['y'] * Cell_W
	temp_board[end_idx] = FOOD
	v_food = temp_snake[-1]
	# 食物看作蛇身(重复赋值了)
	pfood_idx = pfood['x'] + pfood['y'] * Cell_W
	temp_board[pfood_idx] = SNAKE_PLACE
	# 求得每个位置到蛇尾的路径长度
	result, refresh_tboard = board_refresh(temp_snake, v_food, temp_board)
	temp_board = refresh_tboard
	for move_direction in ['left', 'right', 'up', 'down']:
		idx = temp_snake[Head_index]['x'] + temp_snake[Head_index]['y']*Cell_W
		end_idx = temp_snake[-1]['x'] + temp_snake[-1]['y']*Cell_W
		if is_move_possible(idx, move_direction) and (idx+move_directions[move_direction] == end_idx) and (len(temp_snake)>3):
			result = False
	return result


# 根据board中元素值
# 从蛇头周围4个领域点中选择最远路径
def choose_longest_safe_move(psnake, pboard):
	best_move = ERR
	max_distance = -1
	for move_direction in ['left', 'right', 'up', 'down']:
		idx = psnake[Head_index]['x'] + psnake[Head_index]['y']*Cell_W
		if is_move_possible(idx, move_direction) and (pboard[idx+move_directions[move_direction]]>max_distance) and (pboard[idx+move_directions[move_direction]]<FREE_PLACE):
			max_distance = pboard[idx+move_directions[move_direction]]
			best_move = move_direction
	return best_move 


# 让蛇头朝着蛇尾运行一步
def follow_tail(psnake, pboard, pfood):
	temp_snake = psnake[:]
	temp_board = board_reset(temp_snake, pboard, pfood)
	# 将蛇尾看作食物
	end_idx = temp_snake[-1]['x'] + temp_snake[-1]['y'] * Cell_W
	temp_board[end_idx] = FOOD
	v_food = temp_snake[-1]
	# 食物看作蛇身
	pfood_idx = pfood['x'] + pfood['y'] * Cell_W
	temp_board[pfood_idx] = SNAKE_PLACE
	# 求得每个位置到蛇尾的路径长度
	result, refresh_tboard = board_refresh(temp_snake, v_food, temp_board)
	temp_board = refresh_tboard
	# 还原
	temp_board[end_idx] = SNAKE_PLACE
	# temp_board[pfood_idx] = FOOD
	return choose_longest_safe_move(temp_snake, temp_board)


# 如果蛇和食物间有路径
# 则需要找一条安全的路径
def find_safe_way(psnake, pboard, pfood):
	safe_move = ERR
	real_snake = psnake[:]
	real_board = pboard[:]
	v_psnake, v_pboard = virtual_move(psnake, pboard, pfood)
	# 如果虚拟运行后，蛇头蛇尾间有通路，则选最短路运行
	if is_tail_inside(v_psnake, v_pboard, pfood):
		safe_move = choose_shortest_safe_move(real_snake, real_board)
	else:
		safe_move = follow_tail(real_snake, real_board, pfood)
	return safe_move


# 各种方案均无效时，随便走一步
def any_possible_move(psnake, pboard, pfood):
	best_move = ERR
	reset_board = board_reset(psnake, pboard, pfood)
	pboard = reset_board
	result, refresh_board = board_refresh(psnake, pfood, pboard)
	pboard = refresh_board
	min_distance = SNAKE_PLACE
	for move_direction in ['left', 'right', 'up', 'down']:
		idx = psnake[Head_index]['x'] + psnake[Head_index]['y']*Cell_W
		if is_move_possible(idx, move_direction) and (pboard[idx+move_directions[move_direction]]<min_distance):
			min_distance = pboard[idx+move_directions[move_direction]]
			best_move = move_direction
	return best_move


# 运行游戏
def Run_Game():
	# 一维数组来表示蛇运动的矩形场地
	board = [0] * FIELD_SIZE
	# 蛇出生地
	start_x = random.randint(5, Cell_W-6)
	start_y = random.randint(5, Cell_H-6)
	snake_Coords = [{'x': start_x, 'y': start_y},
					{'x': start_x-1, 'y': start_y},
					{'x': start_x-2, 'y': start_y}]
	apple_location = Get_Apple_Location(snake_Coords)
	while True:
		for event in pygame.event.get():
			if event.type == QUIT:
				close_game()
			elif event.type == KEYDOWN:
				if event.key == K_ESCAPE:
					close_game()
		Main_Display.fill(Background_Color)
		draw_Grid()
		Show_Snake(snake_Coords)
		Show_Apple(apple_location)
		Show_Score(len(snake_Coords)-3)
		# 重置board
		reset_board = board_reset(snake_Coords, board, apple_location)
		board = reset_board
		result, refresh_board = board_refresh(snake_Coords, apple_location, board)
		board = refresh_board
		# 如果蛇可以吃到食物
		if result:
			best_move = find_safe_way(snake_Coords, board, apple_location)
		else:
			best_move = follow_tail(snake_Coords, board, apple_location)
		if best_move == ERR:
			best_move = any_possible_move(snake_Coords, board, apple_location)
		if best_move != ERR:
			newHead = find_snake_head(snake_Coords, best_move)
			snake_Coords.insert(0, newHead)
			head_idx = snake_Coords[Head_index]['x'] + snake_Coords[Head_index]['y']*Cell_W
			end_idx = snake_Coords[-1]['x'] + snake_Coords[-1]['y']*Cell_W
			if (snake_Coords[Head_index]['x'] == apple_location['x']) and (snake_Coords[Head_index]['y'] == apple_location['y']):
				board[head_idx] = SNAKE_PLACE
				if len(snake_Coords) < FIELD_SIZE:
					apple_location = Get_Apple_Location(snake_Coords)
			else:
				board[head_idx] = SNAKE_PLACE
				board[end_idx] = FREE_PLACE
				del snake_Coords[-1]
		else:
			return
		pygame.display.update()
		Snake_Clock.tick(Display_Clock)


# 主函数
def main():
	global Main_Display, Main_Font, Snake_Clock
	pygame.init()
	Snake_Clock = pygame.time.Clock()
	Main_Display = pygame.display.set_mode((Window_Width, Window_Height))
	Main_Font = pygame.font.Font('simkai.ttf', 18)
	pygame.display.set_caption('AI_snake')
	Show_Start_Interface()
	while True:
		Run_Game()
		Show_End_Interface()



if __name__ == '__main__':
	main()

nycSerendipity
关注
python实现自动贪吃蛇，含完整代码
.
03-24 2056
通过运行程序，您可以看到自动化贪吃蛇AI前进向食物并吃掉它的过程，同时避免碰到障碍物和自己的身体。总的来说，Python自动化实现贪吃蛇游戏需要掌握Pygame库，了解A*算法和二维数组的处理方法。本文提供了完整的代码和详细的描述，希望能够帮助您更深入地理解Python编程和人工智能算法，实现更加高效、有趣的程序。贪吃蛇游戏是一款经典、简单却挑战性极高的小游戏，让我们忍不住想用代码去写一个自动化的贪吃蛇游戏。在这个过程中，需要注意处理贪吃蛇的身体长度和食物的位置，以及防止贪吃蛇撞到自己或撞到屏幕边缘。
代码全解：Python实现自动玩贪吃蛇程序
m0_64519234的博客
03-24 1548
录 实现效果 代码 实现效果 先看看效果 这比我手动的快多了，而且是单机的，自动玩没惹骂我，哈哈 ，多人游戏整个自动玩会被骂死~ 代码 没装软件的先安装一下软件，没装模块的安装一下pygame模块。 pip install pygame 导入模块 import pygame,sys,time,random from pygame.locals import * 定义颜色变量 redColour = pygame.Color(255,0,0) blackColour = pygame.Color(0
今天给大家演示哈密顿环自动玩贪吃蛇小游戏呀~
TA_Python的博客
12-01 564
开发工具 Python版本：3.6.4 相关模块： pygame模块； 以及一些python自带的模块。 关注公众号：Python学习指南，回复“AI贪吃蛇2”即可获取相关文件 环境搭建 安装Python并添加到环境变量，pip安装需要的相关模块即可。 原理简介 这里我们主要讲如何设计算法来自动玩贪吃蛇小游戏。先来简单介绍一下哈密顿环的定义(引自维基百科)： 哈密顿图是一个无向图，由哈密顿爵士提出， 由指定的起点前往指定的终点，途中经过所有其他节点且只经过一次。 在图论中是指含有哈密顿回路的图， 闭
【python教程入门学习】Python实现自动玩贪吃蛇程序
梦子微信
01-10 2268
这篇文章主要介绍了通过Python实现的简易的自动玩贪吃蛇游戏的小程序，文中的示例代码讲解详细，感兴趣的小伙伴可以跟随小编一起学一学 实现效果 先看看效果 这比我手动的快多了，而且是单机的，自动玩没惹骂我，哈哈 ，多人游戏整个自动玩会被骂死~ 代码 没装软件的先安装一下软件，没装模块的安装一下pygame模块。 | 1 | `pip install pygame` | 导入模块 | 1 2 | `import` `pygame,sys,time,random` `from` `pygame.``loc
贪吃蛇自动寻路
最新发布
weixin_73238667的博客
08-17 200
【代码】贪吃蛇自动寻路。
表弟打把王者的时间，我就用python写了个自动玩贪吃蛇的程序
热门推荐
人生苦短， 还不用Python？
01-04 1万+
表弟最近放假了天天打王者，作业也不做，气得我差点想给他买三年高考五年模拟了…
python版AI贪吃蛇
weixin_37559696的博客
11-29 875
本文转自：https://mp.weixin.qq.com/s?__biz=MzU2NDI1MjkwNA==&amp;mid=2247484020&amp;idx=1&amp;sn=73aa1452ddba05ae233e3e4a3aaa2ad6&amp;chksm=fc4c9bf3cb3b12e5877f0bfc64c819bf7ffc302d1ad473ed3bea618cc923e978c...
python带你体验贪吃蛇肝大分得快乐~完全全自动
weixin_62853513的博客
06-07 273
大家早好、午好、晚好吖 ❤ ~欢迎光临本文章。
Python贪吃蛇实训报告.doc
06-20
【Python贪吃蛇游戏设计与实现】 贪吃蛇游戏是一款深受玩家喜爱的经典游戏，它源自于简单的编程概念，但能够提供丰富的游戏体验。在Python中，我们可以利用pygame库来实现这个游戏，该库提供了图形用户界面和游戏...
Python大作业小游戏源码-Python实现AI贪吃蛇.zip
10-14
在这个“Python大作业小游戏源码-Python实现AI贪吃蛇”项目中，我们将探讨如何利用Python来创建一个经典的AI版贪吃蛇游戏。 首先，我们要了解贪吃蛇游戏的基本规则。游戏中的蛇会移动，吃食物，每吃一次食物，蛇的...
(深信息)用python实现贪吃蛇小游戏毕业设计报告 .docx
07-05
Python 3.8是Python语言的一个重要版本，提供了许多新特性和改进，而PyCharm则是一个强大的IDE，对Python开发提供了良好的支持，包括代码高亮、调试、自动完成等功能，极大地提高了开发效率。 在需求分析部分，报告...
自动贪吃蛇.html
07-09
这是一个原生JavaScript写的自动贪吃蛇源码，学习web前端一个非常好的案例！欢迎大家下载浏览
自动版贪吃蛇 （graphics.h）
04-09
用到了graphics.h头文件 简单易懂，你懂的～～
基于python的自动控制的贪吃蛇游戏设置
10-06
本压缩文件是基于python编译的贪吃蛇游戏，游戏设置蛇可以自动移动吃掉树莓，不需要手动操作，实现了一种自动控制。
贪吃蛇小游戏(自动行走)_C版本
12-09
自己实现的贪吃蛇小游戏。代码可能有点乱。
自动寻路贪吃蛇C++源码
09-16
自动寻路贪吃蛇C++源码,解压即得，可直接在Virsual Studio里打开工程，运行即玩，可自动寻路，可加速
【源码直送】Python会自己动的贪吃蛇脚本❤
xff123456_的博客
03-25 675
好东西大家一起分享❤
C51自动贪吃蛇程序
狂奔的兔子
12-08 1366
C51平台加点阵屏可以贪吃蛇，程序实现如下，但还不够智能，只能看一步路，还是会出现把自己困死的情况，看提供一种思路，请大家能加以补充，提供更好的思路，感谢大家 单片机：STC89C52RC 点阵：8*8单色点阵 点阵驱动： 行：74HC595 列：P0口 主函数 #include "config.h" //*********主函数*************// void main() { initTimer0(); while(1)startSnake(); } 贪吃蛇源码 /
[Python贪吃蛇]使用python实现简易贪吃蛇
wahzx的博客
10-16 1678
这次，我们使用python实现简易的贪吃蛇，食物会在限定屏幕区域随机出现，当蛇头触碰到食物时，食物消失，同时蛇的长度增加一。当蛇头触碰到蛇身任意一个地方时，游戏结束。当蛇头或蛇身超出屏幕范围时，不会判定死亡，而是会在屏幕对应的另一端出现。食物产生方法中，通过随机数产生食物的随机横纵坐标在移动方法中，当蛇头的坐标和食物坐标重合时，更新新的“蛇头”，同时产生新的食物（调用食物产生方法）事件处理方法用于捕获玩家操控的按键，并作出相应的方向变换pygame.display.set_caption("贪吃蛇")
Python实现的贪吃蛇小游戏及其自动追踪功能
资源摘要信息: "snake_snake_snake小游戏_python_贪吃蛇_" 知识点: 1. Python 编程语言基础 - Python 是一种高级编程语言，以其简洁明了的语法和强大的库支持而闻名。本游戏采用 Python 编写，说明 Python 适用于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

nycSerendipity

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值