30个酷炫、简单又有趣的Python项目+源代码[2023]
我们已经涵盖了30个有趣的Python项目，让您可以进行实际的编程练习，从制作一个人工智能聊天机器人到货币转换器
无论您当前的技能水平如何，学习构建Python项目都是提升技能和增强个人投资组合的可靠方式。没有什么比实际编码和构建Python项目更有效的方式了！
此外，在2023年成为Python大师可以为您在职业生涯中打开许多大门，让您有机会获得世界上最好的工作机会，更不用说每年超过10万美元的薪资了。
在本文中，我们包含了30个有趣的Python项目，涵盖从初学者到中级和高级的Python项目，您可以利用这些项目来挑战自己或提升自己的Python编程技巧。
另外，如果您正在寻求一些额外的帮助，我们刚刚发布了我们自己的课程，《Python与约翰博士》，我们在教学过程中采用学术的方法，同时还构建了值得展示的Python项目。
我应该使用Python构建什么？
这是一个很好的问题，特别是如果您刚开始使用Python编程。
首先，您应该知道Python在各个领域都有许多 Python应用，所以您有很多选择。
当然，Python在数据科学、数据分析、机器学习和人工智能方面有着良好的声誉，但它的应用领域远不止于此。
在Web开发方面，由于像Django和Flask这样的流行Web应用框架，Python也非常出色。
同样地，Python也非常适合自动化重复任务，这也是它作为脚本语言的起源。
简而言之，您可以用Python构建很多东西，但是如果您正在寻找灵感，那么您来对地方了！
我为您准备了30个Python项目供您投入其中，从初学者到高级都有。
那么，让我们开始吧！
初学者的Python项目
让我们从一些初学者项目开始，非常适合刚开始学习并且想要学习Python的初学者。当然，如果您渴望尝试一些更具挑战性的项目，可以向下滚动查看更高级的项目。
1. Mad Libs 生成器
这是最有趣的初学者Python项目之一，更不用说它能让您练习如何使用字符串、变量和连接了，这对于所有Python应用的所有技能水平来说都是必不可少的。
Mad Libs生成器根据用户输入数据作为形容词、代词和动词进行收集和操作。该程序将这些数据进行排列并构建出一个故事。
源代码：
'''Mad Libs 生成器-------------------------------------------------------------'''# 对用户提出的问题noun = input('选择一个名词：')p_noun = input('选择一个复数名词：')noun2 = input('选择一个名词：')place = input('给一个地方的名称：')adjective = input('选择一个形容词（描述词）：')noun3 = input('选择一个名词：')# 根据用户的输入打印一个故事print('------------------------------------------')print('善待你的', noun, '-脚的', p_noun)print('因为一个鸭子可能是某人的', noun2, '，')print('善待你的', p_noun, '在', place)print('那里的天气总是', adjective, '。\n')print('你可能认为这是', noun3, '，')print('确实是。')print('------------------------------------------')2. 猜数字
这个初学者Python项目是一个有趣的游戏，它生成一个随机数（在特定范围内），用户必须在获得提示后猜出该数。对于用户猜错的每一次，他们都会获得额外的提示，但这会减小他们的最终得分。
这个程序是体验Python标准库的一个很好的途径，因为它使用Python的random模块生成随机数。您还可以通过条件语句、打印格式化、用户定义的函数和各种Python运算符进行一些实践。
源代码：
'''猜数字游戏-------------------------------------------------------------'''import randomattempts_list = []def show_score(): if not attempts_list: print('当前没有最高分，这个分数是你的！') else: print(f'当前最高分是 {min(attempts_list)} 次尝试')def start_game(): attempts = 0 rand_num = random.randint(1, 10) print('你好旅行者！欢迎来到猜数字游戏！') player_name = input('请告诉我你的名字：') wanna_play = input( f'嗨，{player_name}，你想玩猜数字游戏吗？（输入Yes/No）：') if wanna_play.lower() != 'yes': print('那很好，谢谢！') exit() else: show_score() while wanna_play.lower() == 'yes': try: guess = int(input('请选择1到10之间的一个数字：')) if guess < 1 or guess > 10: raise ValueError( '请猜一个给定范围内的数字') attempts += 1 attempts_list.append(attempts) if guess == rand_num: print('太棒了！你猜对了！') print(f'你用了 {attempts} 次机会') wanna_play = input( '你想再玩一次吗？（输入Yes/No）：') if wanna_play.lower() != 'yes': print('那很好，祝你好运！') break else: attempts = 0 rand_num = random.randint(1, 10) show_score() continue else: if guess > rand_num: print('太高了') elif guess < rand_num: print('太低了') except ValueError as err: print('糟糕！那不是有效的值。再试一次...') print(err)if __name__ == '__main__': start_game()3. 石头剪刀布
本石头剪刀布程序使用函数和条件语句模拟了一个广受欢迎的游戏。因此，将这些关键概念牢牢掌握在手？您还将使用Python列表存储一组有效的响应，然后使用它们创建一个优雅且Pythonic的条件语句。
作为导入其他库的许多Python编码项目之一，该程序使用了标准库的random、os和re模块。
看一下下面的代码，您将看到这个Python项目主意要求用户通过传递一个表示石头、纸或剪刀的字符来首先发起攻击。在评估输入字符串之后，条件逻辑检查是否有赢家。
源代码：
'''石头剪刀布-------------------------------------------------------------'''import randomimport osimport redef check_play_status(): valid_responses = ['yes', 'no'] while True: try: response = input('您想重新开始游戏吗？（是或否）：') if response.lower() not in valid_responses: raise ValueError('只能回答是或否') if response.lower() == 'yes': return True else: os.system('cls' if os.name == 'nt' else 'clear') print('谢谢参与游戏！') exit() except ValueError as err: print(err)def play_rps(): play = True while play: os.system('cls' if os.name == 'nt' else 'clear') print('') print('石头，剪刀，布 - 出拳！') user_choice = input('请选择您的武器' ' [R]ock], [P]aper, or [S]cissors: ') if not re.match("[SsRrPp]", user_choice): print('请选择一个字母：') print('[R]ock, [P]aper, or [S]cissors') continue print(f'您选择了： {user_choice}') choices = ['R', 'P', 'S'] opp_choice = random.choice(choices) print(f'我选择了： {opp_choice}') if opp_choice == user_choice.upper(): print('平局！') play = check_play_status() elif opp_choice == 'R' and user_choice.upper() == 'S': print('石头打败剪刀，我赢了！') play = check_play_status() elif opp_choice == 'S' and user_choice.upper() == 'P': print('剪刀打败纸！我赢了！') play = check_play_status() elif opp_choice == 'P' and user_choice.upper() == 'R': print('纸打败石头，我赢了！') play = check_play_status() else: print('您赢了！\n') play = check_play_status()if __name__ == '__main__': play_rps()4. 掷骰子生成器
作为最适合初学者的Python项目之一，这个程序模拟了掷一个或两个骰子。这也是巩固对用户定义函数、循环和条件语句的理解的好方法。这些对于初学Python的人来说是基本技能，并且很可能是你学习的首要内容，无论是通过在线课程还是Python书籍。
作为我们的简单Python项目之一，这是一个相当简单的程序，它使用Python的random模块来复制骰子掷出的随机性。你还会注意到，在你掷骰子后，我们使用os模块来清除屏幕。
请注意，你可以将最大骰子值更改为任何数字，以模拟在许多桌面和角色扮演游戏中经常使用的多面骰子。
源代码：
'''骰子掷出生成器-------------------------------------------------------------'''import randomimport osdef num_die(): while True: try: num_dice = input('骰子数量：') valid_responses = ['1', 'one', 'two', '2'] if num_dice not in valid_responses: raise ValueError('只能输入1或者2') else: return num_dice except ValueError as err: print(err)def roll_dice(): min_val = 1 max_val = 6 roll_again = 'y' while roll_again.lower() == 'yes' or roll_again.lower() == 'y': os.system('cls' if os.name == 'nt' else 'clear') amount = num_die() if amount == '2' or amount == 'two': print('正在掷骰子...') dice_1 = random.randint(min_val, max_val) dice_2 = random.randint(min_val, max_val) print('掷出的点数为：') print('骰子一：', dice_1) print('骰子二：', dice_2) print('总和：', dice_1 + dice_2) roll_again = input('再掷一次吗？') else: print('正在掷骰子...') dice_1 = random.randint(min_val, max_val) print(f'掷出的点数是：{dice_1}') roll_again = input('再掷一次吗？')if __name__ == '__main__': roll_dice()5. 绞刑游戏
这是一个令人愉快的Python项目，模拟了猜词游戏“绞刑”。我们使用了一个预定义的单词列表来进行猜测，但你可以通过使用第三方的字典API来改进它。
这个Python项目使用循环、函数和字符串格式化来打印绞刑的进展。它还让你尝试标准库的random、time和os模块。
具体来说，我们使用random模块来选择要猜测的单词，使用os模块来清除屏幕，使用time模块的.sleep()函数来引入暂停以增强游戏流畅性。
如果你正在参加一门Python课程而且对这门语言还不熟悉，那么这是一个很好的中型项目，可以让你自我挑战！
源代码：
'''绞刑游戏-------------------------------------------------------------'''import randomimport timeimport osdef play_again(): question = '您是否要再玩一次？y = 是, n = 否 \n' play_game = input(question) while play_game.lower() not in ['y', 'n']: play_game = input(question) if play_game.lower() == 'y': return True else: return Falsedef hangman(word): display = '_' * len(word) count = 0 limit = 5 letters = list(word) guessed = [] while count < limit: guess = input(f'绞刑词：{display} 请输入您的猜测：\n').strip() while len(guess) == 0 or len(guess) > 1: print('无效的输入，请输入一个字母\n') guess = input( f'绞刑词：{display} 请输入您的猜测：\n').strip() if guess in guessed: print('糟糕！您已经尝试过这个猜测，请重新尝试！\n') continue if guess in letters: letters.remove(guess) index = word.find(guess) display = display[:index] + guess + display[index + 1:] else: guessed.append(guess) count += 1 if count == 1: time.sleep(1) print(' _____ \n' ' | \n' ' | \n' ' | \n' ' | \n' ' | \n' ' | \n' '__|__\n') print(f'错误的猜测：还剩{limit - count}次机会\n') elif count == 2: time.sleep(1) print(' _____ \n' ' | | \n' ' | | \n' ' | \n' ' | \n' ' | \n' ' | \n' '__|__\n') print(f'错误的猜测：还剩{limit - count}次机会\n') elif count == 3: time.sleep(1) print(' _____ \n' ' | | \n' ' | | \n' ' | | \n' ' | \n' ' | \n' ' | \n' '__|__\n') print(f'错误的猜测：还剩{limit - count}次机会\n') elif count == 4: time.sleep(1) print(' _____ \n' ' | | \n' ' | | \n' ' | | \n' ' | O \n' ' | \n' ' | \n' '__|__\n') print(f'错误的猜测：还剩{limit - count}次机会\n') elif count == 5: time.sleep(1) print(' _____ \n' ' | | \n' ' | | \n' ' | | \n' ' | O \n' ' | /|\ \n' ' | / \ \n' '__|__\n') print('错误的猜测。你已经被绞死了！\n') print(f'单词是：{word}') if display == word: print(f'恭喜！您已经正确猜出了单词\'{word}\'！') breakdef play_hangman(): print('\n欢迎来到绞刑游戏\n') name = input('请输入您的姓名：') print(f'你好 {name}！祝你好运！') time.sleep(1) print('游戏即将开始！\n让我们来玩绞刑游戏！') time.sleep(1) os.system('cls' if os.name == 'nt' else 'clear') words_to_guess = [ '一月', '边界', '影像', '电影', '承诺', '孩子们', '肺', '玩具娃娃', '押韵', '损害', '植物', '你好', '世界' ] play = True while play: word = random.choice(words_to_guess) hangman(word) play = play_again() print('感谢您的参与！希望您能再来玩！') exit()if __name__ == '__main__': play_hangman()6. 密码强度检查器
如果你想学习如何创建一个应用程序，这个Python项目可能是一个很好的补充，因为它可以让你检查密码是否足够强大。
它通过检查给定密码中的字母、数字、特殊字符和空格字符的数量，并根据这些结果生成一个分数来实现这一点。因此，这是学习条件语句、函数和字符串格式化的另一种很棒的方式。
我们还使用了Python标准库中的字符串和getpass模块。这使我们能够访问字符串字符的全范围，以与我们的密码的字符组成进行比较，而.getpass()函数让我们在输入密码时隐藏它。
源代码：
'''密码强度检查器-------------------------------------------------------------'''import stringimport getpassdef check_password_strength(): password = getpass.getpass('输入密码：') strength = 0 remarks = '' lower_count = upper_count = num_count = wspace_count = special_count = 0 for char in list(password): if char in string.ascii_lowercase: lower_count += 1 elif char in string.ascii_uppercase: upper_count += 1 elif char in string.digits: num_count += 1 elif char == ' ': wspace_count += 1 else: special_count += 1 if lower_count >= 1: strength += 1 if upper_count >= 1: strength += 1 if num_count >= 1: strength += 1 if wspace_count >= 1: strength += 1 if special_count >= 1: strength += 1 if strength == 1: remarks = ('这是一个非常糟糕的密码。' '尽快更改。') elif strength == 2: remarks = ('这是一个弱密码。' '你应该考虑使用更强的密码。') elif strength == 3: remarks = '您的密码还可以，但可以改进。' elif strength == 4: remarks = ('您的密码很难猜测。' '但您可以使其更安全。') elif strength == 5: remarks = ('现在这是一个非常强大的密码！' '黑客猜不到这个密码！') print('您的密码有：') print(f'{lower_count}个小写字母') print(f'{upper_count}个大写字母') print(f'{num_count}个数字') print(f'{wspace_count}个空格') print(f'{special_count}个特殊字符') print(f'密码分数：{strength / 5}') print(f'备注：{remarks}')def check_pwd(another_pw=False): valid = False if another_pw: choice = input( '您想检查另一个密码的强度吗（y/n）：') else: choice = input( '您想检查您的密码的强度吗（y/n）：') while not valid: if choice.lower() == 'y': return True elif choice.lower() == 'n': print('退出...') return False else: print('无效的输入...请重试。\n')if __name__ == '__main__': print('===== 欢迎使用密码强度检查器 =====') check_pw = check_pwd() while check_pw: check_password_strength() check_pw = check_pwd(True)7. 数字转换为文字
这个Python项目的想法是将通过用户输入提供的整数转换为对应的文字。这个程序支持最多12位数的数字，但你可以随意修改程序来处理更大的数字（提示：需要条件语句和循环）。
作为基本Python项目的一个易于理解的示例，这个简单但有效的程序可以拓展你的循环、用户输入和条件语句的技能，还可以熟悉Python中元组和列表的使用。
你还可以尝试一些对你来说可能是新的数学运算，比如模（%）运算符，用于返回整数除法的余数。
如果你对这些技术中的任何一项都是新的，你可以考虑在你的Python IDE中安装一个AI编码助手，以帮助你理解任何你觉得难以理解的代码块。
源代码：
'''将数字转换为英文-------------------------------------------------------------'''
ones = ('零', '一', '二', '三', '四', '五', '六', '七', '八', '九')
twos = ('十', '十一', '十二', '十三', '十四', '十五', '十六', '十七', '十八', '十九')
tens = ('二十', '三十', '四十', '五十', '六十', '七十', '八十', '九十', '百')
suffixes = ('', '千', '百万', '十亿')
def fetch_words(number, index):
if number == '0': return '零'
number = number.zfill(3)
hundreds_digit = int(number[0])
tens_digit = int(number[1])
ones_digit = int(number[2])
words = '' if number[0] == '0' else ones[hundreds_digit]
if words != '':
words += '百'
if tens_digit > 1:
words += tens[tens_digit - 2]
words += ones[ones_digit]
elif(tens_digit == 1):
words += twos[((tens_digit + ones_digit) % 10) - 1]
elif(tens_digit == 0):
words += ones[ones_digit]
if(words.endswith('零')):
words = words[:-len('零')]
else:
words += ' '
if len(words) != 0:
words += suffixes[index]
return words
def convert_to_words(number):
length = len(str(number))
if length > 12:
return '本程序支持最多12位数字。'
count = length // 3 if length % 3 == 0 else length // 3 + 1
copy = count
words = []
for i in range(length - 1, -1, -3):
words.append(fetch_words(str(number)[0 if i - 2 < 0 else i - 2 : i + 1], copy - count))
count -= 1
final_words = ''
for s in reversed(words):
final_words += (s + ' ')
return final_words
if __name__ == '__main__':
number = int(input('输入任意数字：'))
print('%d 的英文为：%s' %(number, convert_to_words(number)))
8. 井字棋游戏
井字棋（Tic-Tac-Toe）是一种经典的双人游戏，涉及一个由九个格子组成的方格。每个玩家交替使用 O 或 X 在相应的格子上标记，任何一方玩家成功在对角线、水平线或竖直线上标记三个 O 或 X，即获胜。每个玩家在试图创建自己的连线时，也必须阻止对手。
这是一个非常有趣的 Python 项目，对初学者来说独一无二，因为它使用了面向对象的编程。在这个项目中，我们将创建一个名为 TicTacToe 的新类。然后，我们将使用该类来通过类属性和方法表示游戏的特点。
仔细研究这些方法，看看我们如何使用面向对象的编程方式来整洁地封装模拟该游戏所需的各种行为。
这个 Python 项目创意的一些新方面包括使用嵌套循环来检查网格的列、行和对角线是否处于获胜状态，以及使用 Python 的 set 数据类型来包含唯一值。此程序还使用 Python 的 random 模块来选择一个随机玩家开始游戏，但这在现在对你来说更加熟悉了。
源代码：
'''井字棋-------------------------------------------------------------'''
import random
class TicTacToe:
def __init__(self):
self.board = []
def create_board(self):
for i in range(3):
row = []
for j in range(3):
row.append('-')
self.board.append(row)
def get_random_first_player(self):
return random.randint(0, 1)
def fix_spot(self, row, col, player):
self.board[row][col] = player
def has_player_won(self, player):
n = len(self.board)
board_values = set()
# check rows
for i in range(n):
for j in range(n):
board_values.add(self.board[i][j])
if board_values == {player}:
return True
else:
board_values.clear()
# check cols
for i in range(n):
for j in range(n):
board_values.add(self.board[j][i])
if board_values == {player}:
return True
else:
board_values.clear()
# check diagonals
for i in range(n):
board_values.add(self.board[i][i])
if board_values == {player}:
return True
else:
board_values.clear()
board_values.add(self.board[0][2])
board_values.add(self.board[1][1])
board_values.add(self.board[2][0])
if board_values == {player}:
return True
else:
return False
def is_board_filled(self):
for row in self.board:
for item in row:
if item == '-':
return False
return True
def swap_player_turn(self, player):
return 'X' if player == 'O' else 'O'
def show_board(self):
for row in self.board:
for item in row:
print(item, end=' ')
print()
def start(self):
self.create_board()
player = 'X' if self.get_random_first_player() == 1 else 'O'
game_over = False
while not game_over:
try:
self.show_board()
print(f'\n轮到玩家 {player} 了')
row, col = list(
map(int, input('输入行和列编号以固定位置：').split()))
print()
if col is None:
raise ValueError('没有足够的值可供解包（期望 2，得到 1）')
self.fix_spot(row - 1, col - 1, player)
game_over = self.has_player_won(player)
if game_over:
print(f'玩家 {player} 赢得了比赛！')
continue
game_over = self.is_board_filled()
if game_over:
print('比赛平局！')
continue
player = self.swap_player_turn(player)
except ValueError as err:
print(err)
print()
self.show_board()
if __name__ == '__main__':
tic_tac_toe = TicTacToe()
tic_tac_toe.start()
</
9. 计算器
这是我们的另一个简单Python项目，它创建了一个带有加法、减法、乘法和除法功能的基本计算器应用程序。
这是适用于学习如何使用循环、函数、条件语句、用户输入和字符串格式化的Python实践项目之一。我们还使用了Python的os模块，在用户完成计算动作后清除屏幕。
一旦你掌握了这个项目的概念，考虑扩展功能以包括乘方或其他更复杂的计算。
如果你已经在使用像GitHub Copilot或Amazon CodeWhisperer这样的AI编码助手，你还可以考虑尝试通过添加新功能来进行实验。不过，最好先自己尝试一下！
示例代码：
'''计算器-------------------------------------------------------------'''
import osdef addition(): os.system('cls' if os.name == 'nt' else 'clear') print('加法') continue_calc = 'y' num_1 = float(input('输入一个数字：')) num_2 = float(input('再输入一个数字：')) ans = num_1 + num_2 values_entered = 2 print(f'当前结果：{ans}') while continue_calc.lower() == 'y': continue_calc = (input('继续输入（y/n）：')) while continue_calc.lower() not in ['y', 'n']: print('请键入‘y’或‘n’') continue_calc = (input('继续输入（y/n）：')) if continue_calc.lower() == 'n': break num = float(input('再输入一个数字：')) ans += num print(f'当前结果：{ans}') values_entered += 1 return [ans, values_entered]def subtraction(): os.system('cls' if os.name == 'nt' else 'clear') print('减法') continue_calc = 'y' num_1 = float(input('输入一个数字：')) num_2 = float(input('再输入一个数字：')) ans = num_1 - num_2 values_entered = 2 print(f'当前结果：{ans}') while continue_calc.lower() == 'y': continue_calc = (input('继续输入（y/n）：')) while continue_calc.lower() not in ['y', 'n']: print('请键入‘y’或‘n’') continue_calc = (input('继续输入（y/n）：')) if continue_calc.lower() == 'n': break num = float(input('再输入一个数字：')) ans -= num print(f'当前结果：{ans}') values_entered += 1 return [ans, values_entered]def multiplication(): os.system('cls' if os.name == 'nt' else 'clear') print('乘法') continue_calc = 'y' num_1 = float(input('输入一个数字：')) num_2 = float(input('再输入一个数字：')) ans = num_1 * num_2 values_entered = 2 print(f'当前结果：{ans}') while continue_calc.lower() == 'y': continue_calc = (input('继续输入（y/n）：')) while continue_calc.lower() not in ['y', 'n']: print('请键入‘y’或‘n’') continue_calc = (input('继续输入（y/n）：')) if continue_calc.lower() == 'n': break num = float(input('再输入一个数字：')) ans *= num print(f'当前结果：{ans}') values_entered += 1 return [ans, values_entered]def division(): os.system('cls' if os.name == 'nt' else 'clear') print('除法') continue_calc = 'y' num_1 = float(input('输入一个数字：')) num_2 = float(input('再输入一个数字：')) while num_2 == 0.0: print('请键入第二个数字大于0') num_2 = float(input('再输入一个数字：')) ans = num_1 / num_2 values_entered = 2 print(f'当前结果：{ans}') while continue_calc.lower() == 'y': continue_calc = (input('继续输入（y/n）：')) while continue_calc.lower() not in ['y', 'n']: print('请键入‘y’或‘n’') continue_calc = (input('继续输入（y/n）：')) if continue_calc.lower() == 'n': break num = float(input('再输入一个数字：')) while num == 0.0: print('请键入一个大于0的数字') num = float(input('再输入一个数字：')) ans /= num print(f'当前结果：{ans}') values_entered += 1 return [ans, values_entered]def calculator(): quit = False while not quit: results = [] print('简单的Python计算器！') print('输入‘a’进行加法运算') print('输入‘s’进行减法运算') print('输入‘m’进行乘法运算') print('输入‘d’进行除法运算') print('输入‘q’退出') choice = input('选择：') if choice == 'q': quit = True continue if choice == 'a': results = addition() print('答案 = ', results[0], ' 总输入次数：', results[1]) elif choice == 's': results = subtraction() print('答案 = ', results[0], ' 总输入次数：', results[1]) elif choice == 'm': results = multiplication() print('答案 = ', results[0], ' 总输入次数：', results[1]) elif choice == 'd': results = division() print('答案 = ', results[0], ' 总输入次数：', results[1]) else: print('抱歉，无效的字符')if __name__ == '__main__': calculator()10. 倒计时时钟和计时器
这个 Python 项目主意很有趣！在这里，我们创建了一个倒计时计时器，它通过用户输入要求用户提供一个秒数，然后逐秒倒计时直到显示一条消息。
我们使用 Python 时间模块的 .sleep() 函数来暂停 1 秒的时间间隔。结合一些巧妙的字符串格式化来生成倒计时显示效果。
源代码：
'''倒计时计时器-------------------------------------------------------------'''import timedef countdown(user_time): while user_time >= 0: 分钟, 秒数 = divmod(user_time, 60) 计时器 = '{:02d}:{:02d}'.format(分钟, 秒数) print(计时器, end='\r') time.sleep(1) user_time -= 1 print('起飞！')if __name__ == '__main__': user_time = int(input("请输入一个时间（以秒为单位）：")) countdown(user_time)带源代码的中级 Python 项目
11. 二分查找算法
对于所有有抱负的编程人员，在某时某刻，都要尝试在他们的 Python 编程项目中探索二分查找算法！我知道当我刚开始的时候，我最常犯的一些Python错误涉及经典算法，比如这个。
这个用于二分查找的 Python 项目接受一个有序列表（数组），然后持续将搜索值与数组的中间值进行比较。
根据搜索值是小于还是大于中间值，将列表分割（分而治之的策略）以减小搜索空间，逐渐接近给定的搜索值。这种持续的分割导致对数时间复杂度。
如果你看一下下面的代码，你会看到我们实现了两个解决方案：条件循环和递归。这两种方法都很优雅，所以请随意尝试每一种。
如果你对递归还不熟悉，这是一个很好的引导，因为它演示了我们如何通过每次递归调用“减小”问题的规模，即通过将列表分割为当前中间元素的一侧。
我们还将递归的基本情况定义为中间元素等于搜索元素的时刻。在这种情况下，递归将停止并通过调用堆栈返回 True 值。
如果这些听起来对你来说很陌生，考虑使用像GitHub Copilot这样的工具来更好地理解这个经典的算法。
源代码：
'''二分查找-------------------------------------------------------------'''def binary_search(a_list, an_item): first = 0 last = len(a_list) - 1 while first <= last: 中间点 = (first + last) // 2 if a_list[中间点] == an_item: return True else: if an_item < a_list[中间点]: last = 中间点 - 1 else: first = 中间点 + 1 return Falsedef binary_search_rec(a_list, first, last, an_item): if len(a_list) == 0: return False else: 中间点 = (first + last) // 2 if a_list[中间点] == an_item: return True else: if an_item < a_list[中间点]: last = 中间点 - 1 return binary_search_rec(a_list, first, last, an_item) else: first = 中间点 + 1 return binary_search_rec(a_list, first, last, an_item)if __name__ == '__main__': a_list = [1, 4, 7, 10, 14, 19, 102, 2575, 10000] print('二分查找：', binary_search(a_list, 4)) print('递归二分查找：', binary_search_rec(a_list, 0, len(a_list) -1, 4))12. 归并排序算法
归并排序是另一个流行的编程挑战，在寻找 Python 任务时，有抱负的编程人员经常会面对。
这种分而治之的策略将一组数字分割成相等的部分，然后递归地对其进行排序，最后将它们重新组合以生成排序后的列表。
如果你刚刚完成了二分查找的例子，你可能会注意到一些因为分割和减小问题规模而具有相似性的地方。你是对的，这意味着你可能已经意识到我们需要使用递归。
这个Python实现的归并排序使用递归来处理分治过程。问题规模的不断缩小使得当递归基本情况达到时，即问题规模为一个元素或更小时，问题可以得到解决。
实际上，这个Python程序会继续递归地将列表分割，直到达到基本情况。此时，它开始对问题的较小部分进行排序，生成较小的已排序数组，然后重新组合这些数组，最终生成一个完全排序的数组。如果你熟悉大O符号，你会好奇地知道归并排序的大O为（n logn）。
源代码：
'''归并排序-------------------------------------------------------------'''def merge_sort(a_list): print("正在分割 ", a_list) if len(a_list) > 1: mid_point = len(a_list)//2 left_half = a_list[:mid_point] right_half = a_list[mid_point:] merge_sort(left_half) merge_sort(right_half) i=0 j=0 k=0 while i < len(left_half) and j < len(right_half): if left_half[i] <= right_half[j]: a_list[k] = left_half[i] i += 1 else: a_list[k] = right_half[j] j += 1 k += 1 while i < len(left_half): a_list[k] = left_half[i] i += 1 k += 1 while j < len(right_half): a_list[k] = right_half[j] j += 1 k += 1 print("正在合并 ", a_list)if __name__ == '__main__': a_list = [45, 7, 85, 24, 60, 25, 38, 63, 1] merge_sort(a_list) print(a_list)13. 密码生成器
这是一个有趣的Python项目，它使用secrets和string模块生成强大和安全的密码，就像你可以使用流行的密码管理器一样。
string模块获取所有可能的字母、数字和特殊字符，而secrets模块允许我们获得加密安全的密码。
这个项目的代码相对简单，它使用循环不断生成密码，直到密码包含至少一个特殊字符和两个数字。当然，你可以根据自己的超强密码规则进行修改！
源代码：
'''密码生成器-------------------------------------------------------------'''import secretsimport stringdef create_pw(pw_length=12): letters = string.ascii_letters digits = string.digits special_chars = string.punctuation alphabet = letters + digits + special_chars pwd = '' pw_strong = False while not pw_strong: pwd = '' for i in range(pw_length): pwd += ''.join(secrets.choice(alphabet)) if (any(char in special_chars for char in pwd) and sum(char in digits for char in pwd) >= 2): pw_strong = True return pwdif __name__ == '__main__': print(create_pw())14. 货币转换器
这是几个Python项目想法中的一个，要求我们安装其中一个最受欢迎的Python库，就是requests模块。这个模块不包含在Python标准库中，所以请使用源代码中显示的pip命令在你的系统上安装它。
有了requests模块，我们可以向Fixer API发出HTTP请求，从而可以将一种货币转换为另一种货币。你可能会注意到我们正在使用第三方API，所以你需要注册以获得一个免费的API密钥。然后你可以将你的API密钥输入到源代码中显示的字段中，你就可以开始了！
这个项目让你可以练习循环和用户输入，但它通过使用HTTP请求来获取JSON格式的API数据而扩展了这一点。
如果你对JSON不熟悉，它非常类似于一个Python字典，这意味着我们可以访问键值对以获取我们想要的数据。在这个例子中，我们要查找API调用的货币转换结果。
查看Fixer API网站上的文档以获取更多关于不同数据的详细信息。
源代码：
'''货币转换器---------------------------------------------------------pip install requests'''import requestsdef convert_currency(): init_currency = input('输入初始货币：') target_currency = input('输入目标货币：') while True: try: amount = float(input('输入金额：')) except: print('金额必须是数字！') continue if not amount > 0: print('金额必须大于0！') continue else: break url = ('https://api.apilayer.com/fixer/convert?to=' + target_currency + '&from=' + init_currency + '&amount=' + str(amount)) payload = {} headers = {'apikey': 'YOUR API KEY'} response = requests.request('GET', url, headers=headers, data=payload) status_code = response.status_code if status_code != 200: print('糟糕，出了点问题。请稍后重试！') quit() result = response.json() print('转换结果：' + str(result['result']))if __name__ == '__main__': convert_currency()15. 自动发送生日邮件
这个 Python 项目使用标准的 smtplib、EmailMessage 和 datetime 模块，以及 pandas 和 openpyxl（需要通过以下命令 pip 安装），用于发送自动化生日电子邮件。
该程序从一个包含所有朋友详细信息的 Excel 表格中读取数据（请参见下方源代码中的 Excel 表格格式）。然后，如果今天是他们的生日，它会给他们发送一封电子邮件，并在你的电子表格中记录他们已经收到了电子邮件。
我们使用 smtplib 和 EmailMessage 模块创建了与我们的电子邮件账户和消息的 SSL 连接。然后，我们使用了 pandas dataframe 在 Python 程序中存储电子表格样式的数据（这是数据科学家必备的技能）。最后，我们使用了 datetime 模块的 .strftime() 函数进行日期格式化。
所以，有很多新技能需要掌握！
重要提示：自 2022 年 5 月起，Google 加强了对访问 Gmail 的“不安全应用程序”的限制。如果要在您的 Gmail 账户中使用此代码，您需要遵循一些额外的步骤。但不用担心，这些步骤很简单，我们已经列出来了。
- 进入您的 Google 账户的“管理账户”页面
- 点击“安全性”
- 启用两步验证（可以使用您喜欢的任何方法）
- 点击“应用密码”
- 点击“选择应用程序”，选择“邮箱”
- 点击“选择设备”并选择“其他（自定义名称）”，输入“Python 生日应用程序”
- 点击“生成”，然后保存该密码
现在，您可以使用下面的代码中的此应用程序密码轻松访问您的 Gmail 账户！
源代码：
'''生日电子邮件发送器---------------------------------------------------------pip install pandas openpyxlexcel 文件列名：姓名，电子邮件，生日（MM/DD/YYYY），上次发送（YYYY）'''import pandas as pdfrom datetime import datetimeimport smtplibfrom email.message import EmailMessagedef send_email(recipient, subject, msg): GMAIL_ID = '你的电子邮件地址' GMAIL_PWD = '你的密码' email = EmailMessage() email['Subject'] = subject email['From'] = GMAIL_ID email['To'] = recipient email.set_content(msg) with smtplib.SMTP_SSL('smtp.gmail.com', 465) as gmail_obj: gmail_obj.ehlo() gmail_obj.login(GMAIL_ID, GMAIL_PWD) gmail_obj.send_message(email) print('电子邮件已发送至 ' + str(recipient) + '，主题：\'' + str(subject) + '\'，消息：\'' + str(msg) + '\'')def send_bday_emails(bday_file): bdays_df = pd.read_excel(bday_file) today = datetime.now().strftime('%m-%d') year_now = datetime.now().strftime('%Y') sent_index = [] for idx, item in bdays_df.iterrows(): bday = item['Birthday'].to_pydatetime().strftime('%m-%d') if (today == bday) and year_now not in str(item['Last Sent']): msg = '生日快乐，' + str(item['Name'] + '！') send_email(item['Email'], '生日快乐', msg) sent_index.append(idx) for idx in sent_index: bdays_df.loc[bdays_df.index[idx], 'Last Sent'] = str(year_now) bdays_df.to_excel(bday_file, index=False)if __name__ == '__main__': send_bday_emails(bday_file='你的生日列表.xlsx')16. 队列
这个Python项目创建了一个新的类来实现队列。当你需要处理先入先出（FIFO）的情况，比如消息队列、CPU任务等，队列是计算机科学中常见的数据结构。
代码很简单，并且可以提供一些面向对象编程的练习。试着使用队列来理解它是如何工作的，然后你就可以在其他项目中使用这种数据结构了。
源代码：
'''队列数据结构------------------------------------------------------'''class Queue: def __init__(self): self.items = [] def __repr__(self): return f'Queue对象：数据={self.items}' def is_empty(self): return not self.items def enqueue(self, item): self.items.append(item) def dequeue(self): return self.items.pop(0) def size(self): return len(self.items) def peek(self): return self.items[0]if __name__ == '__main__': q = Queue() print(q.is_empty()) q.enqueue('第一个') q.enqueue('第二个') print(q) print(q.dequeue()) print(q) print(q.size()) print(q.peek())17. 帕斯卡三角形
这个Python项目使用条件语句和循环打印出帕斯卡三角形。它还使用了标准库的math模块和阶乘函数来计算用于生成三角形中的值的”组合数”公式。
尝试更改三角形的初始数字，以查看”组合数”公式如何用于生成三角形中的连续值。
源代码：
'''帕斯卡三角形------------------------------------------------------"n选择k"或nCk的组合数 = n！/（k！*（n-k）！）'''from math import factorialdef pascal_triangle(n): for i in range(n): for j in range(n-i+1): print(end=' ') for j in range(i+1): print(factorial(i)//(factorial(j)*factorial(i-j)), end=' ') print()if __name__ == '__main__': pascal_triangle(5)18. 二十一点
作为最酷的Python项目之一，这个项目会吸引喜欢纸牌游戏的人，因为我们将模拟二十一点。这是一个非常流行的纸牌游戏，规则相对简单：最重要的是你需要达到21点才能赢，或者你需要比庄家得分高而不爆牌!
这是目前列表中最大的项目。它结合了我们之前介绍过的大部分技巧，包括创建类、循环、条件语句、导入模块、接受用户输入和字符串格式化。
花点时间来逐个学习代码的不同部分，并将其与之前的项目相关联，看看不同的技术如何一起工作。你之前都见过这些，只不过稍微不同地组合在一起形成了一个完整的游戏模拟器。
我们应该说，尽量不要一整天都玩这个！但是如果你这样做，我们完全理解！
源代码：
'''二十一点------------------------------------------------------'''import randomimport osclass Card: def __init__(self, card_face, value, symbol): self.card_face = card_face self.value = value self.symbol = symboldef show_cards(cards, hidden): s = '' for card in cards: s = s + '\t ________________' if hidden: s += '\t ________________' print(s) s = '' for card in cards: s = s + '\t| |' if hidden: s += '\t| |' print(s) s = '' for card in cards: if card.card_face in ['J', 'Q', 'K', 'A']: s = s + '\t| {} |'.format(card.card_face) elif card.value == 10: s = s + '\t| {} |'.format(card.value) else: s = s + '\t19. Reddit Bot
这个 Python 项目创建了一个自动化的 Reddit 机器人，使用了一些新模块，即 praw 和 enchant（见 pip install 命令）。
这是一个相对简单的概念，因为程序会检查所选子论坛中的每个评论，然后回复包含预定义“触发短语”的评论。为此，我们使用 praw 模块与 Reddit 进行交互，并使用 enchant 生成与评论相似的单词，这样我们就能做出恰当的回复。
如果你想学习如何在自己的子论坛中回答问题，这个想法非常有用。只需要扩展这段代码以包括预定义问题的自动回复（你可能已经注意到 Reddit 上其他人在使用这种方式了！）。
重要提示：你需要查看这些说明来获得 client_id、client_secret、username、password 和 user_agent，因为你需要这些信息通过 API 接口向 Reddit 发表评论。
源代码：
'''Reddit Reply Bot-------------------------------------------------------------pip install praw pyenchant'''import prawimport enchantdef reddit_bot(sub, trigger_phrase): reddit = praw.Reddit( client_id='your_client_id', client_secret='your_client_secret', username='your_username', password='your_pw', user_agent='your_user_agent' ) subreddit = reddit.subreddit(sub) dict_suggest = enchant.Dict('en_US') for comment in subreddit.stream.comments(): if trigger_phrase in comment.body.lower(): word = comment.body.replace(trigger_phrase, '') reply_text = '' similar_words = dict_suggest.suggest(word) for similar in similar_words: reply_text += (similar + ' ') comment.reply(reply_text)if __name__ == '__main__': reddit_bot(sub='Python', trigger_phrase='useful bot')
20. Fibonacci 生成器
斐波那契数列在我们的生活中可能是最重要的数列之一，因为它们在自然界中出现得如此频繁。
下面的 Python 代码使用递归生成斐波那契数列，而且为了防止计算时间过长，我们实现了记忆化来缓存计算过的值。
你会注意到，对于这个递归算法，基本情况是检查给定的斐波那契数列值是否已经存在于缓存中，如果是，则返回该值（这是一个时间复杂度为常数的操作），这样可以节省大量的计算时间。
源代码：
'''Fibonacci Sequence-------------------------------------------------------------'''fib_cache = {}def fib_memo(input_val): if input_val in fib_cache: return fib_cache[input_val] if input_val == 0: val = 0 elif input_val < 2: val = 1 else: val = fib_memo(input_val - 1) + fib_memo(input_val - 2) fib_cache[input_val] = val return valif __name__ == '__main__': print('======== Fibonacci Series ========') for i in range(1, 11): print(f'Fibonacci ({i}) : {fib_memo(i)}')
高级 Python 项目点子
21. 聊天机器人
这个 Python 项目使用 chatterbot 模块（参见下面的 pip install 说明）训练一个自动化聊天机器人来回答你提出的任何问题！我知道，我们现在使用了 AI！
你会发现，程序是这个列表中相对较小的 Python 项目之一，但如果你想学习更多或扩展代码的功能，可以随时查阅 ChatterBot 文档以及更广泛的 AI 聊天机器人领域。
如果你对构建 AI 机器人产生了兴趣，请查看我们的24 小时 Python 聊天机器人课程，了解如何使用与 OpenAI 的 ChatGPT 相同的工具构建一个基于 AI 的聊天机器人。
如果你对更多的 AI 内容感兴趣，请查看 OpenAI 的最新功能，可以让你自己构建你自己的 GPT。
重要提示：ChatterBot 已经不再得到积极维护。这意味着你需要对 Python 安装文件夹中的“Lib/site-packages/chatterbot”目录下的 tagging.py 文件进行一小部分修改。
别担心，这很简单，我们已经包含了您需要使用的确切源代码，如下所示。
源代码：
'''聊天机器人------------------------------------------------------------1）pip install ChatterBot chatterbot-corpus spacy2）python3 -m spacy download en_core_web_sm 或...选择您喜欢的语言3）导航到Python3目录4）修改Lib/site-packages/chatterbot/tagging.py 以正确加载 'en_core_web_sm''''from chatterbot import ChatBotfrom chatterbot.trainers import ChatterBotCorpusTrainerdef create_chat_bot(): chatbot = ChatBot('Chattering Bot') trainer = ChatterBotCorpusTrainer(chatbot) trainer.train('chatterbot.corpus.english') while True: try: bot_input = chatbot.get_response(input()) print(bot_input) except (KeyboardInterrupt, EOFError, SystemExit): breakif __name__ == '__main__': create_chat_bot()
修改tagging.py：
找到第一个代码片段，它是PosLemmaTagger类的__init__方法的一部分。将其替换为if/else语句。
注意：此示例是针对我们在示例中使用的英语库的，但如果您愿意，随时切换到其他语言。
# 将此替换为:self.nlp = spacy.load(self.language.ISO_639_1.lower())# 用此替换:if self.language.ISO_639_1.lower() == 'en': self.nlp = spacy.load('en_core_web_sm')else: self.nlp = spacy.load(self.language.ISO_639_1.lower())
22. 文本转语音
此Python项目使用一系列新库将现有文章转换为可播放的mp3文件。您需要安装nltk（自然语言工具包），newspaper3k和gtts（请参阅pip install指示）。
您会发现该程序很简单，我们只需传入要转换的文章的URL，然后让我们定义的函数使用我们新安装的模块进行文本到语音转换。
所以，下次您想要将文章转换为可播放的播客时，可以尝试一下，这绝对是您应该复制的酷Python代码之一！
源代码：
'''文本转语音------------------------------------------------------------pip install nltk newspaper3k gtts'''import nltkfrom newspaper import Articlefrom gtts import gTTSdef text_to_speech(url): article = Article(url) article.download() article.parse() nltk.download('punkt') article.nlp() article_text = article.text language = 'en' my_obj = gTTS(text=article_text, lang=language, slow=False) my_obj.save("read_article.mp3")if __name__ == '__main__': text_to_speech( url='https://hackr.io/blog/top-tech-companies-hiring-python-developers' )
23. 图书馆管理系统
作为更高级的Python项目之一，该程序使用面向对象编程来模拟图书馆管理系统。
在此示例中，我们创建了Library和Student类，可以使用它们来创建我们的图书馆系统及其用户。然后，我们实现了一个简单的用户界面，要求用户从一系列标准的图书馆操作中选择，如借书或还书。
这是一个简单而强大的示例，展示了如何通过Python和面向对象编程构建真实世界的系统。请随意扩展这些类以包含其他有用的功能，例如唯一的书籍ID，同一本书的多个副本，归还书籍的日期，迟归书籍的费用，或您认为图书馆应该具有的任何其他功能！
源代码：
'''图书馆-------------------------------------------------------------'''class Library: def __init__(self, books): self.books = books def show_avail_books(self): print('我们的图书馆可以为您提供以下图书：') print('================================================') for book, borrower in self.books.items(): if borrower == 'Free': print(book) def lend_book(self, requested_book, name): if self.books[requested_book] == 'Free': print( f'{requested_book}已被标记为\'借出\'，借给：{name}') self.books[requested_book] = name return True else: print( f'对不起，{requested_book}目前已借出给：{self.books[requested_book]}') return False def return_book(self, returned_book): self.books[returned_book] = 'Free' print(f'感谢还书：{returned_book}')class Student: def __init__(self, name, library): self.name = name self.books = [] self.library = library def view_borrowed(self): if not self.books: print('您没有借阅任何书籍') else: for book in self.books: print(book) def request_book(self): book = input( '请输入您想借阅的书籍的名称 >> ') if self.library.lend_book(book, self.name): self.books.append(book) def return_book(self): book = input( '请输入您想归还的书籍的名称 >> ') if book in self.books: self.library.return_book(book) else: print('您没有借阅过那本书，请尝试其他书籍...')def create_lib(): books = { '最后一战': 'Free', '饥饿游戏': 'Free', '破解编程面试': 'Free' } library = Library(books) student_example = Student('Your Name', library) while True: print(''' ==========图书馆菜单=========== 1. 显示可用图书 2. 借书 3. 还书 4. 查看您的书籍 5. 退出''' ) choice = int(input('输入您的选择：')) if choice == 1: print() library.show_avail_books() elif choice == 2: print() student_example.request_book() elif choice == 3: print() student_example.return_book() elif choice == 4: print() student_example.view_borrowed() elif choice == 5: print('再见') exit()if __name__ == '__main__': create_lib()
24. 乒乓游戏机
这是一个非常有趣和有趣的项目，因为我们使用Python turtle模块来模拟经典的街机游戏乒乓球！
我们使用了turtle模块的各种方法来创建游戏组件并检测球与玩家挡板的碰撞。我们还定义了一系列按键绑定来设置左右玩家挡板的用户控制。随意尝试游戏的设置，以更好地了解每个设置的工作原理和对整个游戏的影响。
在引入这些全新的turtle图形函数之外，我们还使用字符串格式化来输出当前记分板和用户定义的函数来保持代码的整洁。这些是你现阶段应该熟悉的概念。
源代码：
'''乒乓游戏机-------------------------------------------------------------'''import turtledef update_score(l_score, r_score, player, score_board): if player == 'l': l_score += 1 else: r_score += 1 score_board.clear() score_board.write('左玩家: {} -- 右玩家: {}'.format( l_score, r_score), align='center', font=('Arial', 24, 'normal')) return l_score, r_score, score_boarddef setup_game(): screen = turtle.Screen() screen.title('乒乓游戏机') screen.bgcolor('white') screen.setup(width=1000, height=600) l_paddle = turtle.Turtle() l_paddle.speed(0) l_paddle.shape('square') l_paddle.color('red') l_paddle.shapesize(stretch_wid=6, stretch_len=2) l_paddle.penup() l_paddle.goto(-400, 0) r_paddle = turtle.Turtle() r_paddle.speed(0) r_paddle.shape('square') r_paddle.color('black') r_paddle.shapesize(stretch_wid=6, stretch_len=2) r_paddle.penup() r_paddle.goto(400, 0) ball = turtle.Turtle() ball.speed(40) ball.shape('circle') ball.color('blue') ball.penup() ball.goto(0, 0) ball.dx = 5 ball.dy = -5 score_board = turtle.Turtle() score_board.speed(0) score_board.color('blue') score_board.penup() score_board.hideturtle() score_board.goto(0, 260) score_board.write('左玩家: 0 -- 右玩家: 0', align='center', font=('Arial', 24, 'normal')) return screen, ball, l_paddle, r_paddle, score_boarddef pong_game(): game_components = setup_game() screen = game_components[0] ball = game_components[1] l_paddle = game_components[2] r_paddle = game_components[3] score_board = game_components[4] l_score = 0 r_score = 0 def l_paddle_up(): l_paddle.sety(l_paddle.ycor() + 20) def l_paddle_down(): l_paddle.sety(l_paddle.ycor() - 20) def r_paddle_up(): r_paddle.sety(r_paddle.ycor() + 20) def r_paddle_down(): r_paddle.sety(r_paddle.ycor() - 20) screen.listen() screen.onkeypress(l_paddle_up, 'e') screen.onkeypress(l_paddle_down, 'x') screen.onkeypress(r_paddle_up, 'Up') screen.onkeypress(r_paddle_down, 'Down') while True: screen.update() ball.setx(ball.xcor()+ball.dx) ball.sety(ball.ycor()+ball.dy) if ball.ycor() > 280: ball.sety(280) ball.dy *= -1 if ball.ycor() < -280: ball.sety(-280) ball.dy *= -1 if ball.xcor() > 500: ball.goto(0, 0) ball.dy *= -1 l_score, r_score, score_board = update_score( l_score, r_score, 'l', score_board) continue elif ball.xcor() < -500: ball.goto(0, 0) ball.dy *= -1 l_score, r_score, score_board = update_score( l_score, r_score, 'r', score_board) continue if ((ball.xcor() > 360) and (ball.xcor() < 370) and (ball.ycor() < r_paddle.ycor()+40) and (ball.ycor() > r_paddle.ycor()-40)): ball.setx(360) ball.dx *= -1 if ((ball.xcor() < -360) and (ball.xcor() > -370) and (ball.ycor() < l_paddle.ycor()+40) and (ball.ycor() > l_paddle.ycor()-40)): ball.setx(-360) ball.dx *= -1if __name__ == '__main__': pong_game()
25. 速度打字測試
這是一個有趣的Python項目，測試你能多快而準確地打出一個句子。
這個程式需要我們使用tkinter模塊創建一個圖形用戶界面（GUI）。如果你對GUI還不熟悉，這個例子是一個不錯的入門，因為我們使用了一系列簡單的標籤、按鈕和輸入字段來創建一個窗口。我們還使用了Python的timeit模塊來處理打字測試的計時方面，並使用random模塊隨機選擇一個測試短語。
在這個例子中，我們只添加了兩個測試短語，但你可以隨意嘗試更多，甚至集成第三方詞典以得到更多的示例。
源代碼：
'''Speed Typing Test-------------------------------------------------------------'''import tkinterfrom timeit import default_timer as timerimport randomdef speed_test(): speed_test_sentences = [ '這是一個隨機的句子檢查速度。', '速度，我是閃電麥昆。' ] sentence = random.choice(speed_test_sentences) start = timer() main_window = tkinter.Tk() main_window.geometry('600x400') label_1 = tkinter.Label(main_window, text=sentence, font='times 20') label_1.place(x=150, y=10) label_2 = tkinter.Label(main_window, text='開始打字', font='times 20') label_2.place(x=10, y=50) entry = tkinter.Entry(main_window) entry.place(x=280, y=55) def check_result(): if entry.get() == sentence: end = timer() label_3.configure(text=f'時間：{round((end-start), 4)}秒') else: label_3.configure(text='錯誤的輸入') button_1 = tkinter.Button(main_window, text='完成', command=check_result, width=12, bg='grey') button_1.place(x=150, y=100) button_2 = tkinter.Button(main_window, text='再試一次', command=speed_test, width=12, bg='grey') button_2.place(x=250, y=100) label_3 = tkinter.Label(main_window, text='', font='times 20') label_3.place(x=10, y=300) main_window.mainloop()if __name__ == '__main__': speed_test()
26. 文本編輯器
在我們上一個tkinter示例的基礎上，這個有趣的Python項目創建了一個GUI，模擬了我們自己的文本編輯器。這個例子還使用了標準的GUI組件，包括標籤、按鈕和輸入字段。
但是，我們還添加了像真正的文本編輯器那樣打開和保存文件的功能。如果你對文件處理還不熟悉，這個Python項目是理解如何讀取和保存文件的一個很好的方式。
請通過下面的代碼進行實驗，以巩固你的理解，看看是否可以擴展這個代碼以創建其他你習慣在文本編輯器中使用的功能，比如'查找單詞'功能。
源代碼：
'''Text Editor-------------------------------------------------------------'''import tkinter as tkfrom tkinter.filedialog import askopenfilename, asksaveasfilenamedef text_editor(): def open_file(): filepath = askopenfilename( filetypes=[('文本文件', '*.txt'), ('所有文件', '*.*')] ) if not filepath: return txt_edit.delete(1.0, tk.END) with open(filepath, 'r') as input_file: text = input_file.read() txt_edit.insert(tk.END, text) window.title(f'文本編輯器 - {filepath}') def save_file(): filepath = asksaveasfilename( defaultextension='txt', filetypes=[('文本文件', '*.txt'), ('所有文件', '*.*')], ) if not filepath: return with open(filepath, 'w') as output_file: text = txt_edit.get(1.0, tk.END) output_file.write(text) window.title(f'文本編輯器 - {filepath}') window = tk.Tk() window.title('文本編輯器') window.rowconfigure(0, minsize=800, weight=1) window.columnconfigure(1, minsize=800, weight=1) txt_edit = tk.Text(window) fr_buttons = tk.Frame(window, relief=tk.RAISED, bd=2) btn_open = tk.Button(fr_buttons, text='打開', command=open_file) btn_save = tk.Button(fr_buttons, text='另存為...', command=save_file) btn_open.grid(row=0, column=0, sticky='ew', padx=5, pady=5) btn_save.grid(row=1, column=0, sticky='ew', padx=5) fr_buttons.grid(row=0, column=0, sticky='ns') txt_edit.grid(row=0, column=1, sticky='nsew') window.mainloop()if __name__ == '__main__': text_editor()
27. 数独求解器
这个Python项目使用pygame库（查看pip安装说明）来实现一个用于自动求解数独难题的GUI。我们使用了几个用户定义的函数来创建GUI，如下所示。
为了解决数独难题，该程序使用了一种回溯算法，该算法逐步检查解决方案，如果当前解决方案不可行，则采用或放弃当前解决方案。
放弃解决方案的这一步骤是回溯方法的定义特征，因为程序会回退以尝试新的解决方案，直到找到一个有效的解决方案。此过程会逐步进行，直到整个格子被正确填充为止。
请随意尝试不同的数独问题，甚至考虑扩大问题格子的大小（如果这样做的话，您将需要一个新的基本图像）。
源代码：
'''数独求解器------------------------------------------------------------pip install pygame图片链接：https://www.pngitem.com/pimgs/m/210-2106648_empty-sudoku-grid-grid-6x6-png-transparent-png.png'''import pygamepygame.font.init()screen = pygame.display.set_mode((600, 600))pygame.display.set_caption('使用回溯法解决数独问题')img = pygame.image.load('icon.png')pygame.display.set_icon(img)font1 = pygame.font.SysFont('comicsans', 40)font2 = pygame.font.SysFont('comicsans', 20)x = 0y = 0dif = 500 / 9val = 0# 默认数独棋盘grid = [ [7, 8, 0, 4, 0, 0, 1, 2, 0], [6, 0, 0, 0, 7, 5, 0, 0, 9], [0, 0, 0, 6, 0, 1, 0, 7, 8], [0, 0, 7, 0, 4, 0, 2, 6, 0], [0, 0, 1, 0, 5, 0, 9, 3, 0], [9, 0, 4, 0, 6, 0, 0, 0, 5], [0, 7, 0, 3, 0, 0, 0, 1, 2], [1, 2, 0, 0, 0, 7, 4, 0, 0], [0, 4, 9, 2, 0, 6, 0, 0, 7]]def get_coord(pos): x = pos[0] // dif y = pos[1] // difdef draw_box(): for i in range(2): pygame.draw.line(screen, (255, 0, 0), (x * dif-3, (y + i) * dif), (x * dif + dif + 3, (y + i)*dif), 7) pygame.draw.line(screen, (255, 0, 0), ((x + i) * dif, y * dif), ((x + i) * dif, y * dif + dif), 7)def draw(): for i in range(9): for j in range(9): if grid[i][j] != 0: pygame.draw.rect(screen, (0, 153, 153), (i * dif, j * dif, dif + 1, dif + 1)) text1 = font1.render(str(grid[i][j]), 1, (0, 0, 0)) screen.blit(text1, (i * dif + 15, j * dif + 15)) for i in range(10): if i % 3 == 0: thick = 7 else: thick = 1 pygame.draw.line(screen, (0, 0, 0), (0, i * dif), (500, i * dif), thick) pygame.draw.line(screen, (0, 0, 0), (i * dif, 0), (i * dif, 500), thick)def draw_val(val): text1 = font1.render(str(val), 1, (0, 0, 0)) screen.blit(text1, (x * dif + 15, y * dif + 15))def raise_error_1(): text1 = font1.render('WRONG !!!', 1, (0, 0, 0)) screen.blit(text1, (20, 570))def raise_error_2(): text1 = font1.render('Wrong !!! Not a valid Key', 1, (0, 0, 0)) screen.blit(text1, (20, 570))def valid(m, i, j, val): for it in range(9): if m[i][it] == val: return False if m[it][j] == val: return False it = i // 3 jt = j // 3 for i in range(it * 3, it * 3 + 3): for j in range(jt * 3, jt * 3 + 3): if m[i][j] == val: return False return Truedef solve(grid, i, j): while grid[i][j] != 0: if i < 8: i += 1 elif i == 8 and j < 8: i = 0 j += 1 elif i == 8 and j == 8: return True pygame.event.pump() for it in range(1, 10): if valid(grid, i, j, it) == True: grid[i][j] = it x = i y = j screen.fill((25528. 网站连接性检查器
这个Python项目使用urllib和tkinter模块来测试网站的连通性。
我们使用tkinter模块创建了一个GUI，让用户输入一个网址。和之前的示例一样，这包括标签、按钮和输入字段。
收集到用户的网址之后，我们将其传递给自定义的函数，通过urllib模块的.getcode()函数返回当前网站的HTTP状态码。
对于这个示例，我们只是简单地确定HTTP代码是否为200。如果是，我们就知道该网站正常工作；否则，我们会告诉用户该网站不可用。
你可以扩展这段代码，以更细致地处理各种HTTP响应代码，所以请随意添加吧！
源代码：
'''网站连接性检查器-------------------------------------------------------------将网址输入为http(s)://www.yourwebsite.com'''import urllib.requestimport tkinter as tkdef test_connectivity(): window = tk.Tk() window.geometry('600x400') head = tk.Label(window, text='网站连接性检查器', font=('Calibri 15')) head.pack(pady=20) def check_url(): web = (url.get()) status_code = urllib.request.urlopen(web).getcode() website_is_up = status_code == 200 if website_is_up: tk.Label(window, text='网站可用', font=('Calibri 15')).place(x=260, y=200) else: tk.Label(window, text='网站不可用', font=('Calibri 15')).place(x=260, y=200) url = tk.StringVar() tk.Entry(window, textvariable=url).place(x=200, y=80, height=30, width=280) tk.Button(window, text='检查', command=check_url).place(x=285, y=150) window.mainloop()if __name__ == '__main__': test_connectivity()
29. 语言检测器
这个Python项目使用langdetect模块（参见pip安装说明）来帮助我们识别输入的语言。如果你不确定需要处理的语言是什么，这个项目非常有用。
这是另一个示例，我们使用tkinter创建了一个简单的GUI，包括标签、按钮和输入字段。然后我们可以从输入字段收集文本，并使用langdetect处理它来确定输入的是哪种语言。最后，我们将结果打印到GUI上，让用户知道结果。
请注意，langdetect返回的结果是缩写的语言代码。例如，如果我们输入英文文本，返回值将是'en'。
源代码：
'''语言检测器-------------------------------------------------------------pip install langdetect'''from langdetect import detectimport tkinter as tkdef detect_lang(): window = tk.Tk() window.geometry('600x400') head = tk.Label(window, text='语言检测器', font=('Calibri 15')) head.pack(pady=20) def check_language(): new_text = text.get() lang = detect(str(new_text)) tk.Label(window, text=lang, font=('Calibri 15')).place(x=260, y=200) text = tk.StringVar() tk.Entry(window, textvariable=text).place( x=200, y=80, height=30, width=280) tk.Button(window, text='检查语言', command=check_language).place(x=285, y=150) window.mainloop()if __name__ == '__main__': detect_lang()
30. Netflix推荐系统
为了最后画龙点睛，我们为大家准备了一个特别令人兴奋的Python项目！这是一个Netflix推荐系统，非常适合有志于成为数据科学家的人。实际上，如果你正在考虑学习机器学习课程，这个项目是一个巩固你的新技能的绝佳选择。
为了创建这个项目，你需要导入一系列模块，包括tkinter、re、nltk、pandas和numpy（关于新模块的pip安装说明请参考）。你还需要下载一个包含Netflix电影和电视节目的Kaglge数据集。
我们将使用tkinter创建我们的GUI，其中包括标签、按钮和输入字段。用户可以输入他们在Netflix上喜欢的电视节目或电影，以根据他们的口味返回推荐。
推荐引擎使用演员、导演、评级、国家和类型等作为机器学习（ML）的“特征”。然后，代码使用“余弦相似度”方法基于用户输入找到类似的结果。这在清洗数据和准备数据进行处理时广泛使用pandas和numpy。
这个例子中有很多东西需要解释，因为它使用了很多Python数据科学概念。
最好的方法是慢慢研究代码，然后进一步研究机器学习（ML）、“特征”和“余弦相似度”。
然后，您将能够了解如何根据相似性使用数据集生成推荐。如果您是一位有抱负的数据科学家，这是一个绝佳的项目来进行初步尝试！
源代码：
'''Netflx推荐引擎------------------------------------------------------------pip install pandas numpy nltk'''from nltk.tokenize import word_tokenizeimport numpy as npimport pandas as pdimport reimport nltkimport tkinter as tkfrom nltk.corpus import stopwordsnltk.download('stopwords')data = pd.read_csv('netflixData.csv')data = data.dropna(subset=['Cast', 'Production Country', 'Rating'])movies = data[data['Content Type'] == 'Movie'].reset_index()movies = movies.drop(['index', 'Show Id', 'Content Type', 'Date Added', 'Release Date', 'Duration', 'Description'], axis=1)movies.head()tv = data[data['Content Type'] == 'TV Show'].reset_index()tv = tv.drop(['index', 'Show Id', 'Content Type', 'Date Added', 'Release Date', 'Duration', 'Description'], axis=1)tv.head()actors = []for i in movies['Cast']: actor = re.split(r', \s*', i) actors.append(actor)flat_list = []for sublist in actors: for item in sublist: flat_list.append(item)actors_list = sorted(set(flat_list))binary_actors = [[0] * 0 for i in range(len(set(flat_list)))]for i in movies['Cast']: k = 0 for j in actors_list: if j in i: binary_actors[k].append(1.0) else: binary_actors[k].append(0.0) k += 1binary_actors = pd.DataFrame(binary_actors).transpose()directors = []for i in movies['Director']: if pd.notna(i): director = re.split(r', \s*', i) directors.append(director)flat_list_2 = []for sublist in directors: for item in sublist: flat_list_2.append(item)directors_list = sorted(set(flat_list_2))binary_directors = [[0] * 0 for i in range(len(set(flat_list_2)))]for i in movies['Director']: k = 0 for j in directors_list: if pd.isna(i): binary_directors[k].append(0.0) elif j in i: binary_directors[k].append(1.0) else: binary_directors[k].append(0.0) k += 1binary_directors = pd.DataFrame(binary_directors).transpose()countries = []for i in movies['Production Country']: country = re.split(r', \s*', i) countries.append(country)flat_list_3 = []for sublist in countries: for item in sublist: flat_list_3.append(item)countries_list = sorted(set(flat_list_3))binary_countries = [[0] * 0 for i in range(len(set(flat_list_3)))]for i in movies['Production Country']: k = 0 for j in countries_list: if j in i: binary_countries[k].append(1.0) else: binary_countries[k].append(0.0) k += 1binary_countries = pd.DataFrame(binary_countries).transpose()genres = []for i in movies['Genres']: genre = re.split(r', \s*', i) genres.append(genre)flat_list_4 = []for sublist in genres: for item in sublist: flat_list_4.append(item)genres_list = sorted(set(flat_list_4))binary_genres = [[0] * 0 for i in range(len(set(flat_list_4)))]for i in movies['Genres']: k = 0 for j in genres_list: if j in i: binary_genres[k].append(1.0) else: binary_genres[k].append(0.0) k += 1binary_genres = pd.DataFrame(binary_genres).transpose()ratings = []for i in movies['Rating']: ratings.append(i)ratings_list = sorted(set(ratings))binary_ratings = [[0] * 0 for i in range(len(set(ratings_list)))]for i in movies['Rating']: k = 0 for j in ratings_list: if j in i: binary_ratings[k].append(1.0) else: binary_ratings[k].append(0.0) k += 1binary_ratings = pd.DataFrame(binary_ratings).transpose()binary = pd.concat([binary_actors, binary_directors, binary_countries, binary_genres], axis=1, ignore_index=True)actors_2 = []for i in tv['Cast']: actor2 = re.split(r', \s*', i) actors_2.append(actor2)flat_list_5 = []for sublist in actors_2: for item in sublist: flat_list_5.append(item)actors_list_2 = sorted(set(flat_list_5))binary_actors_2 = [[0] * 0 for i in range(len(set(flat_list_5)))]for i in tv['Cast']: k = 0 for j in actors_list_2: if j in i: binary_actors_2[k].append(1.0) else: binary_actors_2[k].append(0.0) k += 1binary_actors_2 = pd.DataFrame(binary
从哪里开始学习Python
如今，在绝大多数商业领域中，人工智能（AI）、机器学习（ML）和数据科学的采用不断增长。这些领域的主要共同之处之一就是它们以某种方式使用Python编程语言。
2023年学习Python，你有很多选择，可以建立我们列出的Python项目，也可以寻找有用的Python教程。
此外，如果你喜欢深入、互动式的学习体验，我们也推荐你参加我们的新Python课程。
总结
以上就是所有内容了。30个酷炫、有趣且令人兴奋的Python项目，提供从简单到高级的源代码。
无论你想要构建什么，我们的Python项目都会有适合你的内容，因为我们包括了游戏、面向对象编程、GUI、人工智能（AI）、机器学习（ML）、API、机器人、标准库模块和数个第三方库。
我们所有的Python项目有一个共同点，那就是它们需要你将理论知识付诸实践。这是考验自己并提升Python技能的绝佳方式，让你成为更优秀的实践程序员。
喜欢挑战这些Python项目，准备深入学习Python了吗？请看：
常见问题
1. Python适合大型项目吗？
虽然有人认为Python比其他流行语言如C和C++运行速度要慢，但Python仍被许多顶尖科技公司广泛使用，因为它非常灵活、易于维护，并提供了大量的库和来自社区的支持。
2. 我的第一个Python项目应该是什么？
可以参考我们介绍过的任何Python初学者项目，包括Mad Libs、石头剪刀布、猜词游戏或井字棋！
读者们还在阅读：
Leave a Reply