精选20个爆火的Python实战项目(含源码)，直接拿走不谢！
今天给大家介绍20个非常实用的Python项目，帮助大家更好的学习Python。
完整版Python项目源码，【点击这里】领取！
① 猜字游戏
import random
def guess_word_game():
words = ["apple", "banana", "cherry", "grape", "orange"]
target_word = random.choice(words)
guessed_letters = []
attempts = 6
print("欢迎来到猜字游戏！")
print("提示：这个单词是一种水果。")
print("_ " * len(target_word))
while attempts > 0:
guess = input("请输入一个字母：").lower()
if len(guess)!= 1 or not guess.isalpha():
print("请输入一个有效的字母。")
continue
if guess in guessed_letters:
print("你已经猜过这个字母了。")
continue
guessed_letters.append(guess)
if guess in target_word:
print("正确！")
display_word = ""
for letter in target_word:
if letter in guessed_letters:
display_word += letter + " "
else:
display_word += "_ "
print(display_word)
if "_" not in display_word:
print(f"恭喜你猜对了！答案是{target_word}。")
break
else:
attempts -= 1
print(f"错误！你还有{attempts}次机会。")
if attempts == 0:
print(f"游戏结束。答案是{target_word}。")
你可以这样调用这个游戏：
if __name__ == "__main__":` `guess_word_game()
这个猜字游戏从给定的水果单词列表中随机选择一个单词，让玩家通过猜测单个字母来猜出这个单词。玩家有 6 次错误猜测的机会。每次猜测后，游戏会显示已猜对的字母在单词中的位置，以及还剩下多少次机会。如果玩家猜对了所有字母，游戏会显示祝贺消息并结束；如果玩家用完了所有机会，游戏会显示答案并结束。
② 闹钟
import tkinter as tk
from datetime import datetime
from playsound import playsound
class AlarmClock:
def __init__(self):
self.root = tk.Tk()
self.root.title("闹钟")
self.hour_var = tk.StringVar()
self.minute_var = tk.StringVar()
self.second_var = tk.StringVar()
tk.Label(self.root, text="小时：").grid(row=0, column=0)
tk.Entry(self.root, textvariable=self.hour_var).grid(row=0, column=1)
tk.Label(self.root, text="分钟：").grid(row=1, column=0)
tk.Entry(self.root, textvariable=self.minute_var).grid(row=1, column=1)
tk.Label(self.root, text="秒：").grid(row=2, column=0)
tk.Entry(self.root, textvariable=self.second_var).grid(row=2, column=1)
tk.Button(self.root, text="设置闹钟", command=self.set_alarm).grid(row=3, column=0, columnspan=2)
def set_alarm(self):
hour = int(self.hour_var.get())
minute = int(self.minute_var.get())
second = int(self.second_var.get())
while True:
now = datetime.now()
current_hour = now.hour
current_minute = now.minute
current_second = now.second
if current_hour == hour and current_minute == minute and current_second == second:
playsound('alarm_sound.wav')
break
def run(self):
self.root.mainloop()
if __name__ == "__main__":
alarm_clock = AlarmClock()
alarm_clock.run()
在运行这个程序之前，请确保安装了playsound库。同时，准备一个名为alarm_sound.wav的音频文件作为闹钟声音。这个程序允许用户输入小时、分钟和秒来设置闹钟，当到达设定时间时，会播放指定的音频文件。
③ 骰子模拟器
可以通过选择1到6之间的随机整数，来完成骰子模拟。
④ 二维码
⑤ 语言检测
示例。
⑥ 加密和解密
def encrypt(text, shift):
encrypted_text = ""
for char in text:
if char.isalpha():
if char.islower():
encrypted_char = chr((ord(char) - ord('a') + shift) % 26 + ord('a'))
else:
encrypted_char = chr((ord(char) - ord('A') + shift) % 26 + ord('A'))
encrypted_text += encrypted_char
else:
encrypted_text += char
return encrypted_text
def decrypt(text, shift):
return encrypt(text, 26 - shift)
# 示例用法
original_text = "Hello, World!"
shift_value = 3
encrypted = encrypt(original_text, shift_value)
print(f"加密后的文本：{encrypted}")
decrypted = decrypt(encrypted, shift_value)
print(f"解密后的文本：{decrypted}")
在这个例子中，encrypt函数接受一个文本和一个偏移量作为参数，对文本中的字母进行加密。如果字符是小写字母，将其转换为对应的加密后的小写字母；如果是大写字母，进行类似的处理。非字母字符保持不变。decrypt函数通过反向偏移量来解密文本，实际上就是再次调用加密函数，但使用反向的偏移量。
示例。
⑦ URL缩短
from flask import Flask, render_template, request
import pyshorteners
app = Flask(__name__)
@app.route('/', methods=['GET', 'POST'])
def index():
short_url = None
if request.method == 'POST':
long_url = request.form['long_url']
s = pyshorteners.Shortener()
short_url = s.tinyurl.short(long_url)
return render_template('index.html', short_url=short_url)
if __name__ == '__main__':
app.run(debug=True)
同时，你需要一个名为index.html的模板文件，内容如下：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>URL Shortener</title>
</head>
<body>
<h1>URL Shortener</h1>
<form method="post">
<label for="long_url">输入长 URL：</label>
<input type="text" id="long_url" name="long_url">
<input type="submit" value="缩短">
</form>
{% if short_url %}
<p>缩短后的 URL：{{ short_url }}</p>
{% endif %}
</body>
</html>
这个程序创建了一个简单的 Web 应用，用户在表单中输入一个长 URL，点击 “缩短” 按钮后，程序使用pyshorteners库将长 URL 缩短，并在页面上显示缩短后的 URL。
⑧ 音乐播放器
import tkinter as tk
import pygame
class MusicPlayer:
def __init__(self):
self.root = tk.Tk()
self.root.title("音乐播放器")
self.song_list = []
self.current_song_index = 0
self.load_button = tk.Button(self.root, text="加载音乐", command=self.load_songs)
self.load_button.pack()
self.play_button = tk.Button(self.root, text="播放", command=self.play_song)
self.play_button.pack()
self.pause_button = tk.Button(self.root, text="暂停", command=self.pause_song)
self.pause_button.pack()
self.next_button = tk.Button(self.root, text="下一首", command=self.next_song)
self.next_button.pack()
self.prev_button = tk.Button(self.root, text="上一首", command=self.prev_song)
self.prev_button.pack()
pygame.mixer.init()
def load_songs(self):
file_paths = tk.filedialog.askopenfilenames(filetypes=[("音频文件", "*.mp3;*.wav")])
self.song_list = list(file_paths)
def play_song(self):
if self.song_list:
pygame.mixer.music.load(self.song_list[self.current_song_index])
pygame.mixer.music.play()
def pause_song(self):
pygame.mixer.music.pause()
def next_song(self):
if self.song_list:
self.current_song_index = (self.current_song_index + 1) % len(self.song_list)
self.play_song()
def prev_song(self):
if self.song_list:
self.current_song_index = (self.current_song_index - 1) % len(self.song_list)
self.play_song()
def run(self):
self.root.mainloop()
if __name__ == "__main__":
player = MusicPlayer()
player.run()
这个音乐播放器可以加载多个音频文件，并提供播放、暂停、上一首和下一首的功能。它使用tkinter创建了用户界面，使用pygame库来播放音乐。
请注意，在运行代码之前，请确保已经安装了pygame库。可以使用pip install pygame来安装。
选择音乐文件所在的文件夹，点击播放，即可听见音乐。
⑨ 生命游戏
生命游戏由英国数学家约翰·H·康威设计的，是一种类似于生物社会的兴衰和交替的游戏。
board = [[1, 0, 0], [1, 0, 0], [1, 0, 0]]
# 邻居数组为给定的单元格找到8个相邻的单元格
neighbors = [(1, 0), (1, -1), (0, -1), (-1, -1), (-1, 0), (-1, 1), (0, 1), (1, 1)]
rows = len(board)
cols = len(board[0])
# 创建一个原始板的副本
copy_board = [[board[row][col] for col in range(cols)] for row in range(rows)]
# 逐个单元地迭代
for row in range(rows):
for col in range(cols):
# 对于每个单元计算邻居的数量
live_neighbors = 0
for neighbor in neighbors:
r = (row + neighbor[0])
c = (col + neighbor[1])
# 检查相邻细胞的有效性，以及它是否原来是一个活细胞
# 评估是针对副本进行的，因为它永远不会更新。
if (r < rows and r >= 0) and (c < cols and c >= 0) and (copy_board[r][c] == 1):
live_neighbors += 1
# 规则1或规则3
if copy_board[row][col] == 1 and (live_neighbors < 2 or live_neighbors > 3):
board[row][col] = 0
# 规则4
if copy_board[row][col] == 0 and live_neighbors == 3:
board[row][col] = 1
print(board)
Turtle模块提供了在二维平面上移动的环境。
Turtle可以实现位置、航向和各种可能的状态和动作。
roo = tu.Turtle() # 创建对象
wn = tu.Screen() # 屏幕对象
wn.bgcolor("black") # 屏幕背景
wn.title("分形树")
roo.left(90) # 移动
roo.speed(20) # 速度
def draw(l): # 以长度'l'作为参数的递归函数
if l < 10:
return
else:
roo.pensize(2) # 设置画笔大小
roo.pencolor("yellow") # 画笔颜色
roo.forward(l) # 朝向
roo.left(30) # 移动
draw(3 * l / 4) # 绘制
roo.right(60) # 移动
draw(3 * l / 4) # 绘制
roo.left(30) # 移动
roo.pensize(2)
roo.backward(l) # 返回初始位置
draw(20) # 绘制20次
roo.right(90)
roo.speed(2000)
# recursion
def draw(l):
if (l < 10):
return
else:
roo.pensize(2)
roo.pencolor("magenta") # magenta
roo.forward(l)
roo.left(30)
draw(3 * l / 4)
roo.right(60)
draw(3 * l / 4)
roo.left(30)
roo.pensize(2)
roo.backward(l)
draw(20)
roo.left(270)
roo.speed(2000)
# recursion
def draw(l):
if (l < 10):
return
else:
roo.pensize(2)
roo.pencolor("red") # red
roo.forward(l)
roo.left(30)
draw(3 * l / 4)
roo.right(60)
draw(3 * l / 4)
roo.left(30)
roo.pensize(2)
roo.backward(l)
draw(20)
roo.right(90)
roo.speed(2000)
# recursion
def draw(l):
if (l < 10):
return
else:
roo.pensize(2)
roo.pencolor('#FFF8DC') # white
roo.forward(l)
roo.left(30)
draw(3 * l / 4)
roo.right(60)
draw(3 * l / 4)
roo.left(30)
roo.pensize(2)
roo.backward(l)
draw(20)
########################################################
def draw(l):
if (l < 10):
return
else:
roo.pensize(3)
roo.pencolor("lightgreen") # lightgreen
roo.forward(l)
roo.left(30)
draw(4 * l / 5)
roo.right(60)
draw(4 * l / 5)
roo.left(30)
roo.pensize(3)
roo.backward(l)
draw(40)
roo.right(90)
roo.speed(2000)
# recursion
def draw(l):
if (l < 10):
return
else:
roo.pensize(3)
roo.pencolor("red") # red
roo.forward(l)
roo.left(30)
draw(4 * l / 5)
roo.right(60)
draw(4 * l / 5)
roo.left(30)
roo.pensize(3)
roo.backward(l)
draw(40)
roo.left(270)
roo.speed(2000)
# recursion
def draw(l):
if (l < 10):
return
else:
roo.pensize(3)
roo.pencolor("yellow") # yellow
roo.forward(l)
roo.left(30)
draw(4 * l / 5)
roo.right(60)
draw(4 * l / 5)
roo.left(30)
roo.pensize(3)
roo.backward(l)
draw(40)
roo.right(90)
roo.speed(2000)
# recursion
def draw(l):
if (l < 10):
return
else:
roo.pensize(3)
roo.pencolor('#FFF8DC') # white
roo.forward(l)
roo.left(30)
draw(4 * l / 5)
roo.right(60)
draw(4 * l / 5)
roo.left(30)
roo.pensize(3)
roo.backward(l)
draw(40)
########################################################
def draw(l):
if (l < 10):
return
else:
roo.pensize(2)
roo.pencolor("cyan") # cyan
roo.forward(l)
roo.left(30)
draw(6 * l / 7)
roo.right(60)
draw(6 * l / 7)
roo.left(30)
roo.pensize(2)
roo.backward(l)
draw(60)
roo.right(90)
roo.speed(2000)
# recursion
def draw(l):
if (l < 10):
return
else:
roo.pensize(2)
roo.pencolor("yellow") # yellow
roo.forward(l)
roo.left(30)
draw(6 * l / 7)
roo.right(60)
draw(6 * l / 7)
roo.left(30)
roo.pensize(2)
roo.backward(l)
draw(60)
roo.left(270)
roo.speed(2000)
# recursion
def draw(l):
if (l < 10):
return
else:
roo.pensize(2)
roo.pencolor("magenta") # magenta
roo.forward(l)
roo.left(30)
draw(6 * l / 7)
roo.right(60)
draw(6 * l / 7)
roo.left(30)
roo.pensize(2)
roo.backward(l)
draw(60)
roo.right(90)
roo.speed(2000)
# recursion
def draw(l):
if (l < 10):
return
else:
roo.pensize(2)
roo.pencolor('#FFF8DC') # white
roo.forward(l)
roo.left(30)
draw(6 * l / 7)
roo.right(60)
draw(6 * l / 7)
roo.left(30)
roo.pensize(2)
roo.backward(l)
draw(60)
wn.exitonclick()
绘制时间较长，结果如下，挺好看的。
⑪ 计算器
import tkinter as tk
class Calculator:
def __init__(self):
self.root = tk.Tk()
self.root.title("简单计算器")
self.expression = ""
self.display_var = tk.StringVar()
self.display = tk.Entry(self.root, textvariable=self.display_var, font=('Helvetica', 20))
self.display.grid(row=0, column=0, columnspan=4)
buttons = [
'7', '8', '9', '/',
'4', '5', '6', '*',
'1', '2', '3', '-',
'0', '.', '=', '+',
'C'
]
row_val = 1
col_val = 0
for button in buttons:
tk.Button(self.root, text=button, padx=20, pady=20, command=lambda b=button: self.button_click(b)).grid(row=row_val, column=col_val)
col_val += 1
if col_val > 3:
col_val = 0
row_val += 1
def button_click(self, button):
if button == '=':
try:
result = str(eval(self.expression))
self.display_var.set(result)
self.expression = result
except:
self.display_var.set("错误")
self.expression = ""
elif button == 'C':
self.display_var.set("")
self.expression = ""
else:
self.expression += button
self.display_var.set(self.expression)
def run(self):
self.root.mainloop()
if __name__ == "__main__":
calculator = Calculator()
calculator.run()
这个计算器可以进行基本的加、减、乘、除运算，并且有清除（C）和等于（=）按钮。它使用 Tkinter 创建了一个简单的图形用户界面，包含一个显示区域和多个按钮。当用户点击按钮时，相应的操作会被执行，结果会显示在显示区域中。
运行代码，出现一个计算器，非常好用！
⑫ 猜数游戏
运行代码,结果展示
⑬ 图像转换器
from PIL import Image
import os
def convert_image(input_path, output_path, output_format):
try:
img = Image.open(input_path)
img.save(output_path, format=output_format)
print(f"成功将 {input_path} 转换为 {output_path}")
except Exception as e:
print(f"转换失败：{e}")
# 示例用法
input_image_path = "input.jpg"
output_image_path = "output.png"
output_format = "PNG"
convert_image(input_image_path, output_image_path, output_format)
在这个示例中，convert_image函数接受输入图像路径、输出图像路径和目标格式作为参数。它使用Pillow库打开输入图像，然后将其保存为指定的格式。你可以根据实际情况修改输入和输出路径以及目标格式。
请注意，确保已经安装了Pillow库，可以使用pip install Pillow进行安装。
运行代码，选择图片，点击转换按钮，即可完成图像格式变换。
⑭ 重量转换器
def convert_weight(value, from_unit, to_unit):
units = {
"gram": 1,
"kilogram": 1000,
"pound": 453.592,
"ounce": 28.3495
}
if from_unit not in units or to_unit not in units:
return "Invalid units"
return value * units[from_unit] / units[to_unit]
# 示例用法
weight = 100
print(f"{weight} grams is {convert_weight(weight, 'gram', 'kilogram')} kilograms.")
print(f"{weight} grams is {convert_weight(weight, 'gram', 'pound')} pounds.")
print(f"{weight} grams is {convert_weight(weight, 'gram', 'ounce')} ounces.")
这个重量转换器函数接受三个参数：要转换的数值、原始单位和目标单位。它使用一个字典来存储不同单位之间的换算比例，然后根据给定的数值和单位进行换算。你可以根据实际需求进行扩展和改进，比如添加用户输入功能，以便在运行时获取数值和单位。
运行代码，出现界面，输入数值，点击转换。
⑮ 年龄和性别检测
以下是一个使用 Python 进行年龄和性别检测的示例代码，这里使用了第三方库face_recognition和opencv-python，请确保在运行代码前安装好这些库。
import face_recognition
import cv2
import numpy as np
import datetime
def detect_age_gender(frame):
face_locations = face_recognition.face_locations(frame)
for top, right, bottom, left in face_locations:
face_image = frame[top:bottom, left:right]
# 使用深度学习模型进行性别和年龄预测
# 这里使用示例值，实际应用中需使用专业模型进行预测
gender = np.random.choice(['Male', 'Female'])
age = np.random.randint(18, 60)
cv2.rectangle(frame, (left, top), (right, bottom), (0, 255, 0), 2)
cv2.putText(frame, f'{gender}, {age} years old', (left, top - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
return frame
cap = cv2.VideoCapture(0)
while True:
ret, frame = cap.read()
if ret:
result_frame = detect_age_gender(frame)
cv2.imshow('Age and Gender Detection', result_frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
cap.release()
cv2.destroyAllWindows()
⑯ 人脸检测
原图如下。
⑰ 铅笔素描
结果如下。
⑱ 文本编辑器
import tkinter as tk
from tkinter import filedialog
class TextEditor:
def __init__(self, root):
self.root = root
self.root.title("简单文本编辑器")
self.text_area = tk.Text(root)
self.text_area.pack(fill=tk.BOTH, expand=True)
self.menu_bar = tk.Menu(root)
self.file_menu = tk.Menu(self.menu_bar, tearoff=0)
self.file_menu.add_command(label="打开", command=self.open_file)
self.file_menu.add_command(label="保存", command=self.save_file)
self.menu_bar.add_cascade(label="文件", menu=self.file_menu)
root.config(menu=self.menu_bar)
def open_file(self):
file_path = filedialog.askopenfilename()
if file_path:
with open(file_path, 'r') as file:
content = file.read()
self.text_area.delete(1.0, tk.END)
self.text_area.insert(tk.END, content)
def save_file(self):
file_path = filedialog.asksaveasfilename(defaultextension=".txt")
if file_path:
content = self.text_area.get(1.0, tk.END)
with open(file_path, 'w') as file:
file.write(content)
if __name__ == "__main__":
root = tk.Tk()
editor = TextEditor(root)
root.mainloop()
这个文本编辑器具有打开和保存文件的功能。它使用 Tkinter 的菜单和文本区域来实现基本的文本编辑操作。
结果如下：
⑲ 图像分割
如果具有视觉的机器人是按颜色来计算糖果的数量，那么了解糖果之间的界限对它来说就很重要。
from skimage.io import imread
from skimage import color
import numpy as np
import matplotlib.pyplot as plt
# 读取图片
cimage = imread('photo.jpg')
fig, ax = plt.subplots(figsize=(20, 20))
ax.imshow(cimage)
ax.axis('off')
# RGB转为LAB
lab_img = color.rgb2lab(cimage)
x, y, z = lab_img.shape
# 显示颜色
to_plot = cimage.reshape(x * y, 3)
colors_map = to_plot.astype(np.float) / 256
# 创建数据
scatter_x = []
scatter_y = []
for xi in range(x):
for yi in range(y):
L_val = lab_img[xi, yi][0]
A_val = lab_img[xi, yi][1]
B_val = lab_img[xi, yi][2]
scatter_x.append(A_val)
scatter_y.append(B_val)
plt.figure(figsize=(20, 20))
plt.xlabel("a* from green to red")
plt.ylabel("b* from blue to yellow")
plt.scatter(scatter_x, scatter_y, c=colors_map)
# 显示
plt.show()
我们可以使用散点图，根据糖果的颜色对图像进行分割。
最后我们可以根据颜色，正确地分割图像中的糖果。
def filter_color(L_val_min, A_val_min, A_val_max, B_val_min, B_val_max):
filtered_image = np.copy(cimage)
for xi in range(x):
for yi in range(y):
L_val = lab_img[xi, yi][0]
A_val = lab_img[xi, yi][1]
B_val = lab_img[xi, yi][2]
if L_val > L_val_min and A_val > A_val_min and A_val < A_val_max and B_val > B_val_min and B_val < B_val_max:
pass
else:
filtered_image[xi, yi] = [255,255,255]
return filtered_image
lab_img = color.rgb2lab(cimage)
yellow = filter_color(70, -50, 0, 30, 100)
red = filter_color(30, 25, 100, 0, 100)
green = filter_color(50, -128, -20, 0, 50)
blue = filter_color(50, -40, 30, -128, -20)
white = filter_color(93, -25, 25, -25, 25)
pink = filter_color(50, 20, 128, -50, 0)
fig, ax = plt.subplots(nrows=3, ncols=2, figsize=(20,20))
ax[0][0].imshow(pink)
ax[0][0].set_title("pink Candies")
⑳ 模拟时钟
使用Tkinter制作一个简单的模拟时钟GUI应用程序。
import tkinter as tk
import time
def update_clock():
current_time = time.strftime('%H:%M:%S')
label.config(text=current_time)
root.after(1000, update_clock)
root = tk.Tk()
root.title("模拟时钟")
label = tk.Label(root, font=('Helvetica', 48))
label.pack(pady=20)
update_clock()
root.mainloop()
这段代码首先导入了必要的库，然后定义了一个函数来更新时钟显示。在主程序中，创建了一个 Tkinter 窗口，设置了标题，创建了一个用于显示时间的标签，并通过调用update_clock函数启动时钟的更新循环。每隔 1000 毫秒（1 秒），时钟会更新一次显示。
结果如下：
如果你是准备学习Python或者正在学习（想通过Python兼职），下面这些你应该能用得上：
包括：Python安装包、Python web开发，Python爬虫，Python数据分析，人工智能、自动化办公等学习教程。带你从零基础系统性的学好Python！
