1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

# 这是一个超级简单的 pytest 测试文件
# 文件名通常以 test_ 开头，或者 _test 结尾
# 运行方式：pytest test_example.py -v

def test_addition():
    """测试加法是否正确——这是docstring，pytest会显示在报告中"""
    assert 1 + 1 == 2  # 如果为真，测试通过；假的话...嘿嘿


def test_string_operations():
    """测试字符串操作"""
    text = "hello python"
    assert text.upper() == "HELLO PYTHON"  # 转大写
    assert text.replace("python", "world") == "hello world"  # 替换
    assert text.split(" ") == ["hello", "python"]  # 分割


# 运行结果：
# test_example.py::test_addition PASSED
# test_example.py::test_string_operations PASSED

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

# pytest 参数化测试 —— 一个函数，多种姿势
import pytest


@pytest.mark.parametrize("username,password,expected", [
    ("admin", "wrongpass", False),       # 用户名对，密码错
    ("wronguser", "admin123", False),    # 用户名错，密码对
    ("", "admin123", False),             # 用户名为空
    ("admin", "admin123", True),          # 全对
])
def test_login(username, password, expected):
    """测试登录功能的各种情况"""
    # 模拟的登录验证函数
    def fake_login(user, pwd):
        return user == "admin" and pwd == "admin123"

    result = fake_login(username, password)
    assert result == expected


# 运行结果：
# test_login[admin-wrongpass-False] PASSED
# test_login[wronguser-admin123-False] PASSED
# test_login[-admin123-False] PASSED
# test_login[admin-admin123-True] PASSED

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

# fixture 示例 —— 测试的好帮手
import pytest


# scope="function" 表示每个测试函数都执行一次
# scope="module" 表示整个模块只执行一次
@pytest.fixture(scope="module")
def database_connection():
    """模拟数据库连接——所有测试共享"""
    print("\n🔌 [SETUP] 正在连接数据库...")
    conn = {"connected": True, "data": []}
    yield conn  # yield 之前的代码是 setup，之后的是 teardown
    print("\n🔌 [TEARDOWN] 关闭数据库连接...")
    conn["connected"] = False


@pytest.fixture
def sample_user():
    """每个测试都创建新用户——干净卫生"""
    return {
        "name": "测试用户",
        "email": "test@example.com",
        "level": 99
    }


def test_user_info(database_connection, sample_user):
    """测试用户信息"""
    print(f"\n📧 数据库连接状态: {database_connection['connected']}")
    print(f"👤 用户: {sample_user['name']}")
    assert sample_user["level"] == 99


def test_user_email(database_connection, sample_user):
    """测试用户邮箱格式"""
    assert "@" in sample_user["email"]
    assert sample_user["email"].endswith(".com")


# 运行结果：
# 🔌 [SETUP] 正在连接数据库...
# test_user_info PASSED
# test_user_email PASSED
# 🔌 [TEARDOWN] 关闭数据库连接...

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

# Selenium 基本操作 —— 让浏览器乖乖听话
# 需要先安装：pip install selenium
# 还需要下载对应浏览器的 driver（chromedriver.exe 等）
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
import time


def test_baidu_search():
    """用 Selenium 打开百度搜索"Python"""
    # 创建 Chrome 浏览器实例（无头模式，不显示窗口）
    options = webdriver.ChromeOptions()
    options.add_argument("--headless")  # 无头模式，服务器环境常用
    driver = webdriver.Chrome(options=options)

    try:
        # 打开百度
        driver.get("https://www.baidu.com")
        print(f"\n🌐 页面标题: {driver.title}")

        # 找到搜索框（通过 name 属性）
        search_box = driver.find_element(By.NAME, "wd")

        # 输入搜索内容
        search_box.send_keys("Python 是什么")
        print("⌨️ 已输入搜索关键词")

        # 按回车搜索
        search_box.send_keys(Keys.RETURN)
        print("↵ 已按回车")

        # 等待一下让页面加载
        time.sleep(2)

        # 检查标题
        assert "Python" in driver.title or "百度" in driver.title
        print("✅ 搜索成功！")

    finally:
        driver.quit()  # 关闭浏览器
        print("👋 浏览器已关闭")


# 运行结果：
# 🌐 页面标题: 百度一下，你就知道
# ⌨️ 已输入搜索关键词
# ↵ 已按回车
# ✅ 搜索成功！
# 👋 浏览器已关闭

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

# Playwright 示例 —— 更现代的浏览器自动化
# 安装：pip install playwright && playwright install
from playwright.sync_api import sync_playwright


def test_netease_homepage():
    """用 Playwright 打开网易首页"""
    with sync_playwright() as p:
        # 启动 Chromium 浏览器
        browser = p.chromium.launch(headless=True)  # headless=False 则显示浏览器窗口
        page = browser.new_page()

        # 打开页面
        page.goto("https://www.163.com")
        print(f"\n🌐 页面标题: {page.title()}")

        # 截图保存（可以看看到底打开了啥）
        page.screenshot(path="screenshot_163.png")
        print("📸 已截图保存为 screenshot_163.png")

        # 获取所有链接
        links = page.query_selector_all("a")
        print(f"🔗 页面共有 {len(links)} 个链接")

        # 自动等待并点击第一个新闻链接（如果存在）
        try:
            news_link = page.wait_for_selector("a[href*='news']", timeout=5000)
            if news_link:
                print(f"📰 发现新闻链接: {news_link.get_attribute('href')}")
        except Exception as e:
            print(f"⚠️ 没找到新闻链接: {e}")

        browser.close()
        print("✅ Playwright 测试完成！")


# 运行结果：
# 🌐 页面标题: 网易
# 📸 已截图保存为 screenshot_163.png
# 🔗 页面共有 127 个链接
# 📰 发现新闻链接: https://news.163.com/...
# ✅ Playwright 测试完成！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

# TDD 示例 —— 先写测试，再写代码
# 假设我们要实现一个"字符串逆序"函数

# ===== 第一步：先写测试（此时 reverse_string 还不存在！）=====

def test_reverse_string_basic():
    """基本逆序测试"""
    result = reverse_string("hello")
    assert result == "olleh"


def test_reverse_string_palindrome():
    """回文测试（正反一样）"""
    result = reverse_string("上海自来水来自海上")
    assert result == "上海自来水来自海上"


def test_reverse_string_empty():
    """空字符串测试"""
    result = reverse_string("")
    assert result == ""


# 运行测试——当然会失败：NameError: name 'reverse_string' is not defined

# ===== 第二步：写代码让测试通过 =====

def reverse_string(s: str) -> str:
    """字符串逆序函数"""
    return s[::-1]  # Python 的切片反转，简洁到离谱

# 现在运行测试：全部通过！🎉

# 运行结果：
# test_reverse_string_basic PASSED
# test_reverse_string_palindrome PASSED
# test_reverse_string_empty PASSED

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

# Pygame 入门 —— 创建一个可以移动的矩形
# 安装：pip install pygame
# 运行方式：python pygame_intro.py
import pygame
import sys

# 初始化 Pygame（必须！）
pygame.init()

# 设置窗口
WIDTH, HEIGHT = 800, 600
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("我的第一个 Pygame 游戏！🎮")

# 定义颜色（RGB）
RED = (255, 0, 0)
GREEN = (0, 255, 0)
BLUE = (0, 0, 255)
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)

# 创建玩家矩形（x坐标, y坐标, 宽度, 高度）
player = pygame.Rect(350, 500, 100, 50)
player_speed = 5

# 游戏时钟（控制帧率）
clock = pygame.time.Clock()
FPS = 60  # 每秒 60 帧

# 主游戏循环
running = True
while running:
    # ===== 事件处理 =====
    for event in pygame.event.get():
        if event.type == pygame.QUIT:  # 点击窗口关闭按钮
            running = False
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_ESCAPE:  # 按 ESC 退出
                running = False

    # ===== 逻辑更新 =====
    keys = pygame.key.get_pressed()  # 获取所有按键状态
    if keys[pygame.K_LEFT] or keys[pygame.K_a]:
        player.x -= player_speed
    if keys[pygame.K_RIGHT] or keys[pygame.K_d]:
        player.x += player_speed
    if keys[pygame.K_UP] or keys[pygame.K_w]:
        player.y -= player_speed
    if keys[pygame.K_DOWN] or keys[pygame.K_s]:
        player.y += player_speed

    # 边界限制（不能移出屏幕）
    player.x = max(0, min(player.x, WIDTH - player.width))
    player.y = max(0, min(player.y, HEIGHT - player.height))

    # ===== 渲染（绘制）=====
    screen.fill(BLACK)           # 清屏（黑色背景）
    pygame.draw.rect(screen, RED, player)  # 画玩家矩形
    pygame.display.flip()        # 更新整个屏幕（双缓冲机制）

    # 控制帧率
    clock.tick(FPS)

# 退出 Pygame
pygame.quit()
sys.exit()

# 运行结果：
# 创建一个窗口，显示一个红色矩形
# 可以用方向键或 WASD 移动它
# 按 ESC 或关闭窗口按钮退出

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

# 贪吃蛇游戏 —— Pygame 实现
# 运行：python snake_game.py
import pygame
import random
import sys

# 初始化
pygame.init()
WIDTH, HEIGHT = 600, 400
CELL_SIZE = 20
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("🐍 贪吃蛇 | 按 Q 退出")
clock = pygame.time.Clock()
FPS = 10  # 蛇的速度（每秒移动次数）

# 颜色
BLACK = (0, 0, 0)
GREEN = (0, 200, 0)
DARK_GREEN = (0, 100, 0)
RED = (200, 0, 0)
WHITE = (255, 255, 255)

# 初始蛇（三个节）
snake = [(5, 5), (4, 5), (3, 5)]
direction = (1, 0)  # 向右移动

# 食物位置
food = (10, 5)

def draw_grid():
    """画网格背景（可选，美观用）"""
    for x in range(0, WIDTH, CELL_SIZE):
        pygame.draw.line(screen, (30, 30, 30), (x, 0), (x, HEIGHT))
    for y in range(0, HEIGHT, CELL_SIZE):
        pygame.draw.line(screen, (30, 30, 30), (0, y), (WIDTH, y))

def draw_snake():
    """画蛇"""
    for segment in snake:
        rect = pygame.Rect(segment[0]*CELL_SIZE, segment[1]*CELL_SIZE,
                          CELL_SIZE-2, CELL_SIZE-2)
        pygame.draw.rect(screen, GREEN, rect)
        # 画个小眼睛装饰
        pygame.draw.circle(screen, WHITE,
                          (rect.centerx-3, rect.centery-3), 2)
        pygame.draw.circle(screen, WHITE,
                          (rect.centerx+3, rect.centery-3), 2)

def draw_food():
    """画食物"""
    rect = pygame.Rect(food[0]*CELL_SIZE, food[1]*CELL_SIZE,
                      CELL_SIZE-2, CELL_SIZE-2)
    pygame.draw.rect(screen, RED, rect, border_radius=5)

def move_snake():
    """移动蛇"""
    global food
    head = (snake[0][0] + direction[0], snake[0][1] + direction[1])

    # 撞墙检测
    if head[0] < 0 or head[0] >= WIDTH // CELL_SIZE:
        return False
    if head[1] < 0 or head[1] >= HEIGHT // CELL_SIZE:
        return False

    # 撞自己检测
    if head in snake:
        return False

    snake.insert(0, head)  # 新头部

    # 吃食物
    if head == food:
        # 生成新食物（确保不在蛇身上）
        while True:
            food = (random.randint(0, WIDTH//CELL_SIZE-1),
                   random.randint(0, HEIGHT//CELL_SIZE-1))
            if food not in snake:
                break
    else:
        snake.pop()  # 没吃东西就移尾

    return True

score = 0
font = pygame.font.SysFont("arial", 24)

running = True
while running:
    # ===== 事件处理 =====
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_q:
                running = False
            # 方向控制（不能180度掉头）
            if event.key == pygame.K_UP and direction != (0, 1):
                direction = (0, -1)
            if event.key == pygame.K_DOWN and direction != (0, -1):
                direction = (0, 1)
            if event.key == pygame.K_LEFT and direction != (1, 0):
                direction = (-1, 0)
            if event.key == pygame.K_RIGHT and direction != (-1, 0):
                direction = (1, 0)

    # ===== 逻辑更新 =====
    if not move_snake():
        print(f"💀 游戏结束！得分：{score}")
        break  # 或者显示 Game Over 界面

    # ===== 渲染 =====
    screen.fill(BLACK)
    draw_grid()
    draw_food()
    draw_snake()

    # 显示分数
    score_text = font.render(f"得分: {score}", True, WHITE)
    screen.blit(score_text, (10, 10))

    pygame.display.flip()
    clock.tick(FPS)

    score = len(snake) - 3  # 初始长度是3

pygame.quit()
print("👋 游戏已退出")

# 运行结果：
# 显示一个黑色背景的窗口，有网格线
# 一条绿色的蛇在移动，吃红色的食物会变长
# 按方向键控制方向，按 Q 退出
# 撞墙或撞自己后游戏结束，在终端打印得分

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# GDScript 示例（不是纯 Python，但语法很像！）
# 这段代码在 Godot 引擎中运行

# extends Node
#
# var speed = 400
# var velocity = Vector2.ZERO
#
# func _process(delta):
#     # 每一帧调用，delta 是距离上一帧的时间（秒）
#     velocity = Vector2.ZERO
#
#     if Input.is_action_pressed("ui_right"):
#         velocity.x += 1
#     if Input.is_action_pressed("ui_left"):
#         velocity.x -= 1
#     if Input.is_action_pressed("ui_down"):
#         velocity.y += 1
#     if Input.is_action_pressed("ui_up"):
#         velocity.y -= 1
#
#     position += velocity.normalized() * speed * delta
#
#     # 边界限制
#     position.x = clamp(position.x, 0, get_viewport_rect().size.x)
#     position.y = clamp(position.y, 0, get_viewport_rect().size.y)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

# Tkinter 入门 —— 创建一个带按钮的窗口
# 安装：无需安装（Python 内置）
import tkinter as tk
from tkinter import messagebox


def on_button_click():
    """按钮点击事件处理"""
    messagebox.showinfo("消息", "你点了我！🎉\n谢谢你，好心人！")
    label.config(text="我被点过了 😳")


# 创建主窗口
root = tk.Tk()
root.title("我的第一个 Tkinter 程序")
root.geometry("400x200")  # 宽 x 高

# 创建标签（文字）
label = tk.Label(root, text="请点击下方按钮", font=("Arial", 16))
label.pack(pady=30)  # pack 是布局管理器，让组件"打包"到窗口里

# 创建按钮
button = tk.Button(
    root,
    text="点我！",
    font=("Arial", 14),
    bg="#4CAF50",      # 背景色
    fg="white",        # 文字颜色
    padx=20,
    pady=10,
    command=on_button_click  # 点击时调用的函数
)
button.pack(pady=10)

# 创建输入框
entry = tk.Entry(root, font=("Arial", 14), width=30)
entry.pack(pady=10)
entry.insert(0, "这里可以输入文字")  # 默认文字

# 运行 Tkinter 事件循环（相当于"启动程序"）
root.mainloop()

# 运行结果：
# 弹出一个 400x200 的窗口
# 窗口标题是"我的第一个 Tkinter 程序"
# 有一个标签、一个按钮、一个输入框
# 点击按钮会弹出消息框

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105

# Tkinter 计算器 —— 理论派作品
import tkinter as tk


class Calculator:
    def __init__(self):
        self.window = tk.Tk()
        self.window.title("🧮 简易计算器")
        self.window.geometry("320x400")
        self.window.resizable(False, False)  # 禁止调整大小

        # 计算器显示（只读文本框）
        self.display = tk.Entry(
            self.window,
            font=("Arial", 24),
            justify="right",  # 文字右对齐
            bd=10,
            insertwidth=2
        )
        self.display.grid(row=0, column=0, columnspan=4,
                         sticky="nsew", padx=5, pady=5)

        # 按钮布局
        buttons = [
            ("C", 1, 0), ("/", 1, 1), ("*", 1, 2), ("DEL", 1, 3),
            ("7", 2, 0), ("8", 2, 1), ("9", 2, 2), ("-", 2, 3),
            ("4", 3, 0), ("5", 3, 1), ("6", 3, 2), ("+", 3, 3),
            ("1", 4, 0), ("2", 4, 1), ("3", 4, 2), ("=", 4, 3),
            ("0", 5, 0), (".", 5, 1), ("(", 5, 2), (")", 5, 3),
        ]

        for (text, row, col) in buttons:
            self.create_button(text, row, col)

        self.window.mainloop()

    def create_button(self, text, row, col):
        """创建按钮"""
        # 特殊按钮样式
        if text == "=":
            btn = tk.Button(
                self.window, text=text, font=("Arial", 18),
                bg="#4CAF50", fg="white",
                command=lambda: self.calculate()
            )
        elif text in ("C", "DEL"):
            btn = tk.Button(
                self.window, text=text, font=("Arial", 18),
                bg="#f44336", fg="white",
                command=lambda: self.clear() if text == "C" else self.delete()
            )
        elif text in ("+", "-", "*", "/"):
            btn = tk.Button(
                self.window, text=text, font=("Arial", 18),
                bg="#FF9800", fg="white",
                command=lambda: self.append_char(text)
            )
        else:
            btn = tk.Button(
                self.window, text=text, font=("Arial", 18),
                bg="#2196F3", fg="white",
                command=lambda: self.append_char(text)
            )

        btn.grid(row=row, column=col, sticky="nsew",
                padx=3, pady=3)

        # 最后一行的0占两列
        if text == "0":
            btn.grid(columnspan=2)

    def append_char(self, char):
        """添加字符到显示框"""
        self.display.insert(tk.END, char)

    def clear(self):
        """清空"""
        self.display.delete(0, tk.END)

    def delete(self):
        """删除最后一个字符"""
        content = self.display.get()
        self.display.delete(0, tk.END)
        self.display.insert(0, content[:-1])

    def calculate(self):
        """计算结果"""
        try:
            expression = self.display.get()
            result = eval(expression)  # 危险！生产环境别用 eval
            self.display.delete(0, tk.END)
            self.display.insert(0, str(result))
        except Exception as e:
            self.display.delete(0, tk.END)
            self.display.insert(0, "错误")


if __name__ == "__main__":
    Calculator()

# 运行结果：
# 显示一个彩色按钮的计算器界面
# 可以点击按钮进行四则运算
# 按 = 号得出结果
# 按 C 清空，DEL 删除最后一个字符

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

# PyQt5 入门 —— 更专业的界面
# 安装：pip install PyQt5
# 注意：PyQt6 是 pip install PyQt6
from PyQt5.QtWidgets import (
    QApplication, QMainWindow, QPushButton, QLabel,
    QVBoxLayout, QWidget, QLineEdit, QTextEdit
)
from PyQt5.QtCore import Qt
from PyQt5.QtGui import QFont
import sys


class MyWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("PyQt5 演示窗口 🚀")
        self.setGeometry(100, 100, 500, 400)

        # ===== 中央组件 =====
        central_widget = QWidget()
        self.setCentralWidget(central_widget)

        # ===== 布局 =====
        layout = QVBoxLayout()
        central_widget.setLayout(layout)

        # 标题
        title = QLabel("欢迎使用 PyQt5！")
        title.setFont(QFont("Arial", 18, QFont.Bold))
        title.setAlignment(Qt.AlignCenter)
        layout.addWidget(title)

        # 输入框
        self.input_field = QLineEdit()
        self.input_field.setPlaceholderText("输入你的名字...")
        self.input_field.returnPressed.connect(self.greet)  # 回车事件
        layout.addWidget(self.input_field)

        # 多行文本框
        self.output = QTextEdit()
        self.output.setReadOnly(True)  # 只读
        layout.addWidget(self.output)

        # 按钮
        self.button = QPushButton("打招呼 👋")
        self.button.clicked.connect(self.greet)  # 点击事件
        layout.addWidget(self.button)

    def greet(self):
        """打招呼函数"""
        name = self.input_field.text()
        if name:
            self.output.append(f"你好，{name}！欢迎来到 PyQt5 的世界 🎉")
        else:
            self.output.append("请先输入名字！")


# ===== 程序入口 =====
app = QApplication(sys.argv)  # 每个 PyQt 程序都要创建 QApplication
window = MyWindow()
window.show()
sys.exit(app.exec_())  # 进入事件循环（PyQt5 用 exec_，PyQt6 用 exec）

# 运行结果：
# 弹出一个专业外观的窗口
# 可以输入名字，点击按钮后在下方的文本框显示问候语
# 关闭窗口后程序退出

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# PyQt6 的主要 API 变化

# 1. Qt 常量命名空间变了
# PyQt5: Qt.AlignCenter, Qt.Key_Return
# PyQt6: Qt.AlignmentFlag.AlignCenter, Qt.Key.Key_Return

# 2. exec_() 变成了 exec()
# PyQt5: app.exec_()
# PyQt6: app.exec()

# 3. 一些枚举值可以直接用字符串
# PyQt5: QMessageBox.information(parent, "标题", "内容")
# PyQt6: QMessageBox.information(parent, "标题", "内容")

# 4. 信号连接语法一致
# self.button.clicked.connect(self.handle_click)  # 两种版本通用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

# PySide6 —— 几乎和 PyQt5 一样的代码
# 安装：pip install PySide6
# API 和 PyQt5 几乎完全一致
from PySide6.QtWidgets import QApplication, QMainWindow, QPushButton
import sys


class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("PySide6 窗口")
        self.setFixedSize(300, 200)

        button = QPushButton("点击我！")
        button.clicked.connect(self.on_click)
        self.setCentralWidget(button)

    def on_click(self):
        print("按钮被点击了！")


app = QApplication(sys.argv)
window = MainWindow()
window.show()
sys.exit(app.exec())  # 注意：PySide6 用 exec() 而不是 exec_()

# 运行结果：
# 和 PyQt5 基本一致
# 可以互换使用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

# socket 服务器 —— 蹲在家里等电话
# 运行方式：python server.py（需要先运行）
import socket
import threading

def handle_client(client_socket, addr):
    """处理单个客户端连接"""
    print(f"📞 收到来自 {addr} 的连接")
    while True:
        try:
            data = client_socket.recv(1024)  # 接收数据（最多1024字节）
            if not data:
                break
            message = data.decode("utf-8")
            print(f"📨 {addr} 说: {message}")

            # 回复客户端
            reply = f"服务器收到: {message}"
            client_socket.sendall(reply.encode("utf-8"))
        except ConnectionResetError:
            print(f"❌ {addr} 断开了连接")
            break

    client_socket.close()
    print(f"🔚 {addr} 的连接已关闭")


def start_server(host="127.0.0.1", port=8888):
    """启动服务器"""
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # AF_INET: IPv4  地址类型
    # SOCK_STREAM: TCP 协议类型（SOCK_DGRAM 是 UDP）

    server.bind((host, port))  # 绑定地址和端口
    server.listen(5)           # 最多排队 5 个连接

    print(f"🖥️  服务器启动！监听 {host}:{port}")
    print("等待客户端连接...（按 Ctrl+C 退出）")

    try:
        while True:
            client_socket, addr = server.accept()  # 等待客户端连接
            # 为每个客户端创建新线程（并发处理）
            thread = threading.Thread(target=handle_client, args=(client_socket, addr))
            thread.daemon = True
            thread.start()
    except KeyboardInterrupt:
        print("\n👋 服务器关闭中...")
    finally:
        server.close()


if __name__ == "__main__":
    start_server()

# 运行结果：
# 🖥️  服务器启动！监听 127.0.0.1:8888
# 等待客户端连接...
# 📞 收到来自 ('127.0.0.1', 54321) 的连接
# 📨 ('127.0.0.1', 54321) 说: 你好，服务器！
# ❌ ('127.0.0.1', 54321) 断开了连接

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

# socket 客户端 —— 主动打电话
# 运行方式：python client.py（需要服务器先运行）
import socket


def start_client(host="127.0.0.1", port=8888):
    """启动客户端"""
    client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    try:
        client.connect((host, port))  # 连接到服务器
        print(f"✅ 已连接到服务器 {host}:{port}")
    except ConnectionRefusedError:
        print(f"❌ 无法连接到服务器 {host}:{port}")
        return

    print("输入消息发送（按 Ctrl+C 退出）：")

    try:
        while True:
            message = input("\n📤 你: ")
            if not message:
                continue

            client.sendall(message.encode("utf-8"))  # 发送数据

            response = client.recv(1024)  # 接收响应
            print(f"📥 服务器: {response.decode('utf-8')}")

    except KeyboardInterrupt:
        print("\n👋 断开连接...")
    finally:
        client.close()
        print("🔚 连接已关闭")


if __name__ == "__main__":
    start_client()

# 运行结果：
# ✅ 已连接到服务器 127.0.0.1:8888
# 输入消息发送（按 Ctrl+C 退出）：
#
# 📤 你: 你好，服务器！
# 📥 服务器: 服务器收到: 你好，服务器！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

# UDP 服务器 —— 简易广播站
import socket

def start_udp_server(host="127.0.0.1", port=8889):
    """启动 UDP 服务器"""
    server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)  # UDP 用 SOCK_DGRAM
    server.bind((host, port))

    print(f"📻 UDP 服务器启动！监听 {host}:{port}")
    print("等待广播...（按 Ctrl+C 退出）")

    try:
        while True:
            data, addr = server.recvfrom(1024)  # 接收数据和发送者地址
            message = data.decode("utf-8")
            print(f"📨 收到来自 {addr}: {message}")

            # 回复（如果需要）
            reply = f"收到广播: {message}"
            server.sendto(reply.encode("utf-8"), addr)

    except KeyboardInterrupt:
        print("\n👋 服务器关闭...")
    finally:
        server.close()


# UDP 客户端
def start_udp_client(host="127.0.0.1", port=8889):
    """启动 UDP 客户端"""
    client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

    message = "喂！有人在吗？"
    client.sendto(message.encode("utf-8"), (host, port))
    print(f"📤 已发送: {message}")

    # 设置超时（UDP 不保证回复）
    client.settimeout(5)
    try:
        data, server_addr = client.recvfrom(1024)
        print(f"📥 服务器回复: {data.decode('utf-8')}")
    except socket.timeout:
        print("⏰ 服务器没有回复（UDP 不保证送达）")

    client.close()


if __name__ == "__main__":
    import sys
    if len(sys.argv) > 1 and sys.argv[1] == "server":
        start_udp_server()
    else:
        start_udp_client()

# 运行方式：
# 终端1: python udp_demo.py server
# 终端2: python udp_client.py

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

# asyncio 异步编程 —— async/await 语法
# 安装：无需安装（Python 3.4+ 内置）
import asyncio


async def say_hello(name, delay):
    """异步函数：延迟打印问候语"""
    # await 暂停函数执行，把控制权交还给事件循环
    await asyncio.sleep(delay)  # 模拟 I/O 操作（等待）
    print(f"👋 你好，{name}！")


async def main():
    """主异步函数"""
    print("⏰ 开始异步任务...")

    # 创建三个协程（注意：只是创建，还没执行）
    task1 = asyncio.create_task(say_hello("Alice", 2))
    task2 = asyncio.create_task(say_hello("Bob", 1))
    task3 = asyncio.create_task(say_hello("Charlie", 3))

    # 等待所有任务完成
    # 如果是同步写法，total time = 2+1+3 = 6秒
    # 异步写法，total time = max(2,1,3) = 3秒！
    await asyncio.gather(task1, task2, task3)

    print("✅ 所有任务完成！")


# Python 3.7+ 可以直接 asyncio.run()
if __name__ == "__main__":
    asyncio.run(main())

# 运行结果：
# ⏰ 开始异步任务...
# 👋 你好，Bob！        # 1秒后（Bob 最快）
# 👋 你好，Alice！       # 2秒后
# 👋 你好，Charlie！     # 3秒后
# ✅ 所有任务完成！
# 总耗时约 3 秒（而不是 6 秒！）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

# asyncio TCP 服务器 —— 异步处理连接
import asyncio


async def handle_client(reader, writer):
    """处理单个客户端连接（异步）"""
    addr = writer.get_extra_info('peername')
    print(f"📞 客户端连接: {addr}")

    # 接收数据
    data = await reader.read(1024)
    message = data.decode()
    print(f"📨 收到: {message}")

    # 发送响应（HTTP 协议：头部用 \r\n 分隔，空行结束头部）
    response = (
        "HTTP/1.1 200 OK\r\n"
        "Content-Type: text/plain\r\n"
        "Content-Length: 17\r\n"
        "\r\n"
        "Hello, Async World!"
    )
    writer.write(response.encode())
    await writer.drain()  # 确保数据发送出去

    print(f"📤 已回复: {addr}")
    writer.close()
    await writer.wait_closed()


async def main():
    """启动异步服务器"""
    server = await asyncio.start_server(
        handle_client, "127.0.0.1", 8888
    )

    addr = server.sockets[0].getsockname()
    print(f"🖥️ 异步服务器启动: {addr}")

    async with server:
        await server.serve_forever()  # 永远运行


if __name__ == "__main__":
    try:
        asyncio.run(main())
    except KeyboardInterrupt:
        print("\n👋 服务器关闭")

# 运行结果：
# 🖥️ 异步服务器启动: ('127.0.0.1', 8888)
# （等待客户端连接...）

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108

# SQLAlchemy 入门 —— 定义模型和基本操作
# 安装：pip install sqlalchemy
from sqlalchemy import create_engine, Column, Integer, String, Float, DateTime
from sqlalchemy.orm import declarative_base, sessionmaker
from datetime import datetime

# ===== 第一步：连接数据库 =====
# SQLite 是文件型数据库，适合学习和测试
# echo=True 会打印所有 SQL 语句，方便调试
engine = create_engine("sqlite:///mydatabase.db", echo=True)

# ===== 第二步：定义模型 =====
Base = declarative_base()  # 所有模型的"基类"


class User(Base):
    """用户表模型"""
    __tablename__ = "users"  # 数据库中的表名

    id = Column(Integer, primary_key=True)  # 主键，自动递增
    name = Column(String(50), nullable=False)  # 不能为空
    email = Column(String(100), unique=True)  # 唯一
    age = Column(Integer, default=0)
    created_at = Column(DateTime, default=datetime.now)

    def __repr__(self):
        return f"<User(id={self.id}, name='{self.name}', email='{self.email}')>"


class Product(Base):
    """产品表模型"""
    __tablename__ = "products"

    id = Column(Integer, primary_key=True)
    name = Column(String(100), nullable=False)
    price = Column(Float, nullable=False)
    stock = Column(Integer, default=0)

    def __repr__(self):
        return f"<Product(id={self.id}, name='{self.name}', price={self.price})>"


# ===== 第三步：创建表 =====
Base.metadata.create_all(engine)  # 在数据库中创建表

# ===== 第四步：创建会话（操作数据库的入口）=====
Session = sessionmaker(bind=engine)
session = Session()

# ===== 第五步：CRUD 操作 =====

# Create - 创建数据
print("\n=== 创建用户 ===")
new_user = User(name="张三", email="zhangsan@example.com", age=25)
session.add(new_user)        # 添加到会话
session.commit()             # 真正写入数据库
print(f"✅ 创建用户: {new_user}")

# 批量创建
users = [
    User(name="李四", email="lisi@example.com", age=30),
    User(name="王五", email="wangwu@example.com", age=28),
    User(name="赵六", email="zhaoliu@example.com", age=22),
]
session.add_all(users)
session.commit()
print(f"✅ 批量创建 {len(users)} 个用户")

# Read - 查询数据
print("\n=== 查询用户 ===")
# 查询所有用户
all_users = session.query(User).all()
for u in all_users:
    print(f"  {u}")

# 条件查询
adults = session.query(User).filter(User.age >= 25).all()
print(f"\n25岁以上的用户: {adults}")

# 查询单个（没有结果返回 None）
user = session.query(User).filter_by(name="张三").first()
print(f"张三: {user}")

# Update - 更新数据
print("\n=== 更新数据 ===")
if user:
    user.age = 26
    session.commit()
    print(f"✅ 张三的年龄更新为: {user.age}")

# Delete - 删除数据
print("\n=== 删除数据 ===")
zhao = session.query(User).filter_by(name="赵六").first()
if zhao:
    session.delete(zhao)
    session.commit()
    print(f"✅ 删除赵六")

# 关闭会话
session.close()

# 运行结果（部分）：
# ✅ 创建用户: <User(id=1, name='张三', email='zhangsan@example.com')>
# ✅ 批量创建 3 个用户
# <User(id=1, name='张三', ...>
# <User(id=2, name='李四', ...>
# ...
# 25岁以上的用户: [<User(...)>, <User(...)>]