20个爆火的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 次错误猜测的机会。每次猜测后，游戏会显示已猜对的字母在单词中的位置，以及还剩下多少次机会。
• 如果玩家猜对了所有字母，游戏会显示祝贺消息并结束；如果玩家用完了所有机会，游戏会显示答案并结束。
  

② 闹钟

闹钟是一种具有可以在预先设定的时间被激活以响铃的功能的时钟，用于唤醒打工人们。使用Python中的DateTime模块来创建闹钟，并用Pvthon中的playsound库来播

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之间的随机整数，来完成骰子模拟。

import random
# 设置最大值和最小值
min_val =1max val = 6
# 是否继续
roll again = "yes"
# 循环
while roll _again == "yes" or roll _again == "y":print(“开始掷骰子”)print("般子数值是:)
# 第一轮
print(random.randint(min val, max val))
# 第二轮
print(random,randint(min_val, max_val))
# 是否继续
roll again = input("是否继续掷骰子?(是的话,输入yes或者y)")

④ 二维码

二维码是用于将数据编码和解码为机器可读的方法。包含一个白色背景上的黑色方块网格，可以被任何成像设备(如手机)读取

import pyqrcode
# 设置二维码信息
s= "https://www.baidu.com"
# 生成二维码
url = pyqrcode.create(s)
# 保存二维码
url,svg("baidu.svg",scale=8)

⑤ 语言检测

当你需要处理包含不同语言数据，且数据非常大的时候，语言检测就派上用场了。使用Python中的langdetect包，可以在几行代码内检测超过55种不同的语言。

from langdetect import detec
text = input(“输入信息:")

• 示例：
  

⑥ 加密和解密

密码术意味着更改消息的文本，以便不知道你秘密的人永远不会理解你的消息。下面就来创建一个GUI应用程序，使用Python进行加密和解密在这里，我们需要编写使用无限循环的代码，代码将不断询问用户是否要加密或解

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缩短

短网址由于易于记忆和输入，因此在数字营销领域非常受欢迎。这里给大家介绍一下，如何使用Python创建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。

⑧ 音乐播放器

音乐播放器，可让你快速轻松地管理和收听所有音乐文件。应该不少小伙伴都使用过，网易云音乐、QQ音乐、酷狗音乐等，这里小F将使用Pygame和Tkinter，来创建一个音乐播放器

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 inrange(cols)] for row inrange(rows)]

# 逐个单元地迭代
for row inrange(rows):
for col inrange(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] == 1and (live_neighbors < 2or live_neighbors > 3):
            board[row][col] = 0
# 规则4
if copy_board[row][col] == 0and live_neighbors == 3:
            board[row][col] = 1

print(board)

• 结果如下：

#输入
board = [[1, 0, 0], [1, 0, 0], [1, 0, 0]]
# 输出
board = [[0, 0, 0], [1, 1, 0], [0, 0, 0]]

⑩5Turtle模块提供了在二维平面上移动的环境。

Turtle可以实现位置、航向和各种可能的状态和动作。

import turtle as tu

roo = tu.Turtle()  # 创建对象
wn = tu.Screen()  # 屏幕对象
wn.bgcolor("black")  # 屏幕背景
wn.title("分形树")
roo.left(90)  # 移动
roo.speed(20)  # 速度


defdraw(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
defdraw(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
defdraw(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
defdraw(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)
########################################################
defdraw(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
defdraw(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
defdraw(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
defdraw(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)
########################################################
defdraw(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
defdraw(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
defdraw(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
defdraw(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()

• 绘制时间较长，结果如下，挺好看的。
  

⑪ 计算器

Kivy是一个免费的开源Python库，可以快速轻松地开发高度交互的跨平台应用程序

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 创建了一个简单的图形用户界面，包含一个显示区域和多个按钮。
• 当用户点击按钮时，相应的操作会被执行，结果会显示在显示区域中。
• 运行代码，出现一个计算器，非常好用！
  

⑫ 猜数游戏

猜数字游戏目的是猜测出程序想出的数字，基本逻辑：程序随机选择1到100之间的一个数字或任何其他数字组合，然后它会要求玩家输入它的建议。然后它会检查这个数字是否与计算机随机生成的数字相同;如果是，则玩家获胜

import random

# 创建随机数
n=random.randrange(1,100)
# 获取输入
guess =int(input("输入任意数值:"))
while n!= guess:# 判断是否正确
# 小于
if guess < n:
print("太小了")
guess =int(input("再次输入数值:“))
# 大于
elif guess > n:
print("太大了!")
guess=int(input("再次输入数值:“))
else:
break

• 运行代码，结果展示：
  

⑬ 图像转换器

我们知道有大量的图像文件格式可用于存储图形数据，最流行的便是JPG和PNG。使用Python中的Tkinter库和PIL库，创建一个将PNG图像转换为JPG的应用程序。

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进行安装。
• 运行代码，选择图片，点击转换按钮，即可完成图像格式变换。
  

⑭ 重量转换器

重量换算是指单位值乘以标准换算值，使用Python中的Tkinter库创建一个重量转换器应用程序

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编程语言带你完成使用机器学习进行年龄和性别检测的任务

首先需要编写用于检测人脸的代码，因为如果没有人脸检测，我们将无法进一步完成年龄和性别预测的任务。

下一步是预测图像中人的性别。在这里，我将性别网络加载到内存中，并将检测的人脸通过网络传输，用于性别检测任务
下一个任务是预测图像中人类的年龄。这里我将加载网络并使用前向传递来获取输出。由于网络架构与性别网络相似，我们可以充分利用所有输出来获得任务的预期

以下是一个使用 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()

⑯ 人脸检测

构建一个检测人脸的程序是开始机器学习计算机视觉任务的好方法，使用Python的OpenCV库进行人脸检测的任务。

import cv2
face cascade =cv2.CascadeClassifier("face detector.xml')
img = cv2.imread('imagejpg’)
faces =face cascade.detectMultiscale(img, 1.1,10)

for (x, y, w, h) in faces:
cv2.rectangle(img, (x, y). (x+w, y+h). (255, 0, 0). 2)
cv2.imwrite("face detected.png", img)
print('Successfully saved')

• 原图如下：
  
  

⑰ 铅笔素描

使用不到20行的Python代码将图像转换为铅笔素描

import cv2
image = cv2.imread("dogjpg")
cv2.imshow("Dog", image)
cv2.waitKey(0)

gray_image = cv2.cvtColor(image, cV2.COLOR BGR2GRAY)
cv2.imshow("New Dog", gray _image)
cv2.waitKey(0)

inverted image =255 -gray _image
cv2.imshow("Inverted",inverted image)
cv2.waitKey()

blurred = cv2.GaussianBlur(inverted image, (21, 21), 0)

inverted blurred= 255 -blurred
pencil sketch =cv2.divide(gray image, inverted blurred, scale=256.0)
cv2.imshow("Sketch",pencil sketch)
cv2.waitKey(0)

cv2.imshow("original image", image)
cv2.imshow("pencil sketch", pencil sketch)

• 结果如下：
  

⑱ 文本编辑器

使用Python创建一个文本编辑器GU，它可以创建、打开、编辑和保存文本文件。所有小部件的排列方式应使按钮小部件位于窗口布局的左侧，而文本框小部件位于

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 inrange(x):
for yi inrange(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()

• 我们可以使用散点图，根据糖果的颜色对图像进行分割。
  
• 最后我们可以根据颜色，正确地分割图像中的糖果

deffilter_color(L_val_min, A_val_min, A_val_max, B_val_min, B_val_max):
    filtered_image = np.copy(cimage)
for xi inrange(x):
for yi inrange(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")
ax[0][0].axis('off')

ax[0][1].imshow(yellow)
ax[0][1].set_title("yellow Candies")
ax[0][1].axis('off')

ax[1][0].imshow(red)
ax[1][0].set_title("red Candies")
ax[1][0].axis('off')

ax[1][1].imshow(green)
ax[1][1].set_title("green Candies")
ax[1][1].axis('off')

ax[2][0].imshow(white)
ax[2][0].set_title("white Candies")
ax[2][0].axis('off')

ax[2][1].imshow(blue)
ax[2][1].set_title("blue Candies")
ax[2][1].axis('off')
plt.show()

⑳ 模拟时钟

使用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所有方向的学习路线图，清楚各个方向要学什么东西
• ② 100多节Python课程视频，涵盖必备基础、爬虫和数据分析
• ③ 100多个Python实战案例，学习不再是只会理论
• ④ 华为出品独家Python漫画教程，手机也能学习

可以扫描下方二维码领取【保证100%免费】