计算机技术 on 南国遗梦的小站

Java核心技术卷1知识点

Sat, 20 Dec 2025 19:37:52 +0800

第1章 Java程序设计概述

Java语言的特点

平台无关性：一次编写，到处运行（Write Once, Run Anywhere），通过JVM实现
面向对象：支持封装、继承、多态三大特性
安全性：强类型检查、自动内存管理（垃圾回收）、字节码验证
健壮性：异常处理机制、自动内存管理
多线程：内置对并发编程的支持

Java体系结构

Java虚拟机(JVM)：执行字节码的虚拟计算机，实现平台无关性
Java运行时环境(JRE)：包括JVM和核心类库
Java开发工具包(JDK)：包括JRE和开发工具（编译器、调试器等）

第2章 Java程序设计环境

第一个Java程序

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

编译：javac HelloWorld.java，生成HelloWorld.class字节码文件
运行：java HelloWorld

Java程序结构

源文件命名：必须与公共类名相同，以.java结尾
类定义：使用class关键字，可包含属性和方法
主方法：public static void main(String[] args)，程序入口点

第3章 Java的基本程序设计结构

数据类型

1. 基本数据类型（8种）：

类型	大小	范围	默认值
整数类型
byte	1字节	-128 ~ 127	0
short	2字节	-32768 ~ 32767	0
int	4字节	-2147483648 ~ 2147483647	0
long	8字节	很大	0L
浮点类型
float	4字节	约±3.4×10^38	0.0f
double	8字节	约±1.8×10^308	0.0
字符类型
char	2字节	0 ~ 65535（Unicode）	‘\u0000’
布尔类型
boolean	1位	true/false	false

注：Java是强类型语言，变量必须声明类型后才能使用

2. 引用数据类型：

类、接口、数组、字符串等
默认值为null

变量与常量

变量声明：type identifier [=value];

1
2

int age = 25;
double salary = 5000.0;

常量：使用final关键字修饰，必须初始化且值不可变
1

final double PI = 3.1415926;
类常量：使用static final修饰，属于类而非对象
1

public static final int MAX_SIZE = 100;

运算符与表达式

1. 算术运算符：

+、-、*、/、%（取余）
++（自增）、--（自减）可前置或后置

2. 关系运算符：

>、<、>=、<=、==、!=，结果为boolean类型

3. 逻辑运算符：

&&（逻辑与）、||（逻辑或）、!（逻辑非）
具有短路特性：(a && b)中，若a为false，则b不会计算

4. 位运算符：

&（按位与）、|（按位或）、^（按位异或）、~（按位取反）
<<（左移）、>>（右移）、>>>（无符号右移）

5. 赋值运算符：

=、+=、-=、*=、/=、%=等

6. 字符串连接：

使用+运算符连接字符串和其他类型，会自动转换为字符串

1
2
3

String name = "Alice";
int age = 30;
System.out.println("Name: " + name + ", Age: " + age); // Name: Alice, Age: 30

流程控制结构

1. 条件语句：

if-else：

if (condition) {
    // 条件为true时执行
} else {
    // 条件为false时执行
}

多重条件：

if (condition1) {
    // ...
} else if (condition2) {
    // ...
} else {
    // ...
}

switch-case：支持byte、short、int、char、String和enum类型

switch (expression) {
    case value1:
        // 执行代码
        break;
    case value2:
        // 执行代码
        break;
    default:
        // 所有case都不匹配时执行
}

2. 循环语句：

for循环：

1
2
3

for (initialization; condition; update) {
    // 循环体
}

增强for循环（用于遍历集合或数组）：

1
2
3

for (type element : collection/array) {
    // 操作element
}

while循环：

1
2
3

while (condition) {
    // 循环体
}

do-while循环：

1
2
3

do {
    // 循环体
} while (condition);

数组

1. 数组声明与初始化：

// 静态初始化
int[] numbers = {1, 2, 3, 4, 5};

// 动态初始化
String[] names = new String[5]; // 长度为5的String数组，元素默认null

// 多维数组
int[][] matrix = new int[3][4]; // 3行4列的二维数组

2. 数组特性：

长度固定，一旦创建不可改变
元素类型必须一致
通过索引访问（从0开始）
数组对象有length属性获取长度

3. 数组操作：

遍历数组：

1
2
3

for (int i = 0; i < numbers.length; i++) {
    System.out.println(numbers[i]);
}

或使用增强for循环：

1
2
3

for (int num : numbers) {
    System.out.println(num);
}

第4章对象与类

面向对象编程基础

1. 类与对象：

类：对象的模板，定义属性和方法
对象：类的实例，通过new关键字创建

2. 面向对象三大特性：

封装：将数据和操作封装在类中，通过访问控制限制外部直接访问
继承：子类继承父类的属性和方法，实现代码重用
多态：同一方法在不同对象上表现出不同行为

类的定义与使用

1. 类定义语法：

[访问修饰符] class 类名 [extends 父类] [implements 接口列表] {
    // 成员变量（属性）
    [修饰符] 数据类型 变量名;
    
    // 构造方法
    类名([参数列表]) {
        // 初始化代码
    }
    
    // 成员方法
    [修饰符] 返回类型 方法名([参数列表]) {
        // 方法体
    }
}

2. 成员变量：

实例变量：属于对象，每个对象独立拥有
静态变量（类变量）：使用static修饰，属于类，所有对象共享

3. 方法：

实例方法：可访问实例变量和静态变量
静态方法：使用static修饰，只能访问静态变量，通过类名直接调用

4. 对象创建与使用：

// 创建对象
ClassName objectName = new ClassName();

// 使用对象
objectName.methodName();
objectName.variableName = value;

访问控制

Java提供四种访问控制级别，按可见范围从大到小排列：

修饰符	类内部	同包	子类(不同包)	其他包
public	✓	✓	✓	✓
protected	✓	✓	✓	✗
默认(无修饰符)	✓	✓	✗	✗
private	✓	✗	✗	✗

注：类只能使用public或默认修饰符

构造方法

特点：
- 方法名与类名相同
- 无返回类型（连void也没有）
- 用于对象初始化

1. 默认构造方法：

若类没有显式定义任何构造方法，编译器会自动生成一个无参构造方法
若已定义任何构造方法，则不会自动生成

2. 构造方法重载：

多个构造方法，参数列表不同（参数个数、类型或顺序不同）
调用时根据实参类型和数量匹配相应构造方法

3. 构造方法调用：

使用this([参数])调用同一个类的其他构造方法
必须位于构造方法的第一行

方法详解

1. 方法参数传递：

基本类型参数：传递值的副本，方法内修改不影响原始值
引用类型参数：传递引用的副本（指向同一对象），方法内可修改对象状态，但不能改变引用本身

2. 方法重载：

同一类中，方法名相同但参数列表不同（参数个数、类型或顺序不同）
返回类型不作为重载判断条件

3. 可变参数（Varargs）：

方法参数列表中最后一个参数可以是可变参数，使用...表示

本质是一个数组

public void printNumbers(int... numbers) {
    for (int num : numbers) {
        System.out.println(num);
    }
}

调用：printNumbers(1, 2, 3); 或 printNumbers(new int[]{4, 5, 6});

对象构造过程

分配内存空间
成员变量默认初始化（基本类型为默认值，引用类型为null）
执行实例初始化块（按定义顺序执行）
执行构造方法

类之间的关系

1. 依赖（“uses-a"关系）：

一个类的方法使用另一个类的对象作为参数或局部变量
例：public void processOrder(Customer customer)

2. 聚合（“has-a"关系）：

一个类包含另一个类的对象作为成员变量
例：private Address address;

3. 继承（“is-a"关系）：

一个类继承另一个类的属性和方法
例：public class Manager extends Employee

包

作用：组织类、避免命名冲突、控制访问权限
定义：源文件首行非注释语句package packageName;
命名规则：建议使用域名逆序（如com.example.project）
访问控制：同包类可互相访问，不同包只能访问public类

导入类：

1
2

import packageName.ClassName; // 导入单个类
import packageName.*; // 导入整个包（不包含子包）

静态导入：导入静态成员

1
2

import static java.lang.Math.PI;
import static java.util.Arrays.sort;

文档注释

使用/** ... */格式，用于生成API文档
主要标签：
- @author：作者
- @version：版本
- @param：参数说明
- @return：返回值说明
- @throws：异常说明
通过javadoc命令生成HTML文档

类设计技巧

数据私有：所有字段设为private，提供公共访问方法
对数据初始化：确保所有字段在使用前被初始化
避免过多基本类型：考虑用类替代相关基本类型组合
慎用访问器/更改器：不必要的字段不提供专门访问方法
分解职责过重的类：单一职责原则（SRP）
命名清晰：类名名词，方法名动词短语
优先使用不可变类：如String，提高线程安全性

第1-4章复习重点

Java基础：平台无关性原理、JVM/JRE/JDK区别
数据类型：8种基本类型的范围和默认值、引用类型特点
流程控制：各种循环和条件语句的使用场景
数组：声明、初始化、遍历方法
面向对象基础：类与对象关系、封装特性、访问控制
构造方法：重载、this关键字使用、初始化顺序
方法：参数传递机制、重载原理、可变参数用法

提示：重点练习类的设计，包括成员变量、构造方法和方法的编写，以及对象的创建与使用

第5章继承

类、超类和子类

继承定义：子类通过extends关键字继承父类

`1`	`public class Manager extends Employee { ... }`

子类特性：
- 继承父类非私有成员（字段和方法）
- 可添加新成员
- 可覆盖（override）父类方法
构造方法：子类构造方法必须先调用父类构造方法（super()），且必须位于首行

方法覆盖：

1
2

@Override // 显式标记覆盖，编译时检查
public double getSalary() { ... }

强制类型转换：

1
2

Manager m = (Manager) employee; // 向下转型需显式转换
if (employee instanceof Manager) { ... } // 使用instanceof检查类型

多态

定义：父类引用可以指向子类对象，调用方法时执行实际对象（子类）的方法
“is-a"原则：子类对象可视为父类对象（如"Manager is an Employee”）
动态绑定：运行时根据实际对象类型确定调用的方法
编译与运行时：
- 编译时：检查引用类型是否具有该方法
- 运行时：执行实际对象的方法

final关键字

修饰类：类不可被继承（如String类）
修饰方法：方法不可被覆盖
修饰变量：变量变为常量，只能赋值一次

Object：所有类的超类

默认继承：所有类（除Object本身）都直接或间接继承Object
常用方法：
- equals(Object)：比较对象是否相等（默认比较引用）
- hashCode()：返回对象哈希码（配合equals使用）
- toString()：返回对象字符串表示（建议重写）
- getClass()：返回对象的Class对象（运行时类型信息）

抽象类

定义：包含抽象方法（无实现）的类，必须声明为abstract

1
2
3

public abstract class Shape {
    public abstract double area(); // 抽象方法
}

特点：
- 不能实例化（不能用new创建对象）
- 子类必须实现所有抽象方法（除非子类也是抽象类）
- 可包含具体方法和字段

第6章接口与内部类

接口

定义：

1
2
3

public interface Comparable {
    int compareTo(Object o); // 接口方法默认public abstract
}

特性：
- 所有方法默认public abstract
- 所有字段默认public static final
- 不能实例化，只能被类实现
- 类通过implements实现接口
- 一个类可实现多个接口（解决Java单继承限制）

默认方法

接口中可提供方法的默认实现，用default修饰

1
2
3

public interface Collection {
    default void forEach(Consumer action) { ... }
}

冲突解决规则：
1. 类优先原则：类中方法优先于接口默认方法
2. 接口冲突：一个类实现两个接口，且都有相同默认方法，必须在类中重写该方法

lambda表达式

定义：简洁表示函数式接口（只有一个抽象方法的接口）的实例
基本语法：
1

(参数列表) -> { 方法体 }
简化规则：
- 参数类型可省略（类型推断）
- 单参数时可省略括号
- 方法体只有一条语句可省略花括号和return

示例：

// 传统方式
Comparator<String> comp = new Comparator<String>() {
    public int compare(String s1, String s2) {
        return s1.length() - s2.length();
    }
};

// lambda方式
Comparator<String> comp = (s1, s2) -> s1.length() - s2.length();

方法引用

定义：直接引用已有方法作为lambda表达式

四种形式：

// 对象::实例方法
obj::methodName

// 类::静态方法
ClassName::staticMethodName

// 类::实例方法（第一个参数作为调用者）
ClassName::instanceMethodName

// 数组::构造方法
int[]::new

内部类

定义：在另一个类内部定义的类
类型：
1. 成员内部类：在类内但方法外定义，可直接访问外部类所有成员
2. 静态内部类：用static修饰，只能访问外部类静态成员
3. 局部内部类：在方法内定义，作用域仅限于该方法
4. 匿名内部类：没有名字的内部类，用于创建一次性对象

第7章异常处理

异常分类

Throwable：所有错误和异常的根类
- Error：系统内部错误（如StackOverflowError），应用程序不应捕获
- Exception：程序运行时错误，可分为：
  - 运行时异常（RuntimeException）：非检查异常（如NullPointerException）
  - 检查型异常（Checked Exception）：必须显式处理（捕获或声明抛出）

异常处理机制

抛出异常：

1
2
3

if (value < 0) {
    throw new IllegalArgumentException("Negative value not allowed");
}

捕获异常：

try {
    // 可能抛出异常的代码
} catch (ExceptionType1 e) {
    // 处理ExceptionType1异常
} catch (ExceptionType2 e) {
    // 处理ExceptionType2异常
} finally {
    // 无论是否发生异常都执行的代码（如资源清理）
}

多重捕获（Java 7+）：

`1`	`catch (IOException \| SQLException e) { ... } // 捕获多种异常`

try-with-resources语句

自动关闭资源：适用于实现AutoCloseable接口的资源（如文件流、数据库连接）

1
2
3

try (FileInputStream fis = new FileInputStream("file.txt")) {
    // 使用资源
} // 自动调用fis.close()，即使发生异常

多个资源：

`1`	`try (ResourceA ra = new ResourceA(); ResourceB rb = new ResourceB()) { ... }`

自定义异常

继承Exception（检查型异常）或RuntimeException（非检查型异常）

建议提供两个构造方法：

public class MyException extends Exception {
    public MyException() { super(); }
    public MyException(String message) { super(message); }
}

异常使用最佳实践

只在异常情况下使用异常：异常处理比条件判断慢得多

异常链：捕获异常后包装成更高层异常，保留原始异常信息

1
2
3

try { ... } catch (SQLException e) {
    throw new ServiceException("Database error", e); // 异常链
}

不要捕获Throwable：应捕获具体异常，避免隐藏系统错误
优先传递异常：若当前层无法处理，应将异常向上抛出
finally慎用return：可能覆盖try块中的return值

第8章泛型程序设计

为什么使用泛型

类型安全：编译时检查类型，避免运行时ClassCastException
代码重用：一个类/方法可用于多种类型

消除强制类型转换：

// 非泛型
List list = new ArrayList();
list.add("Hello");
String s = (String) list.get(0); // 需要强制转换

// 泛型
List<String> list = new ArrayList<>();
list.add("Hello");
String s = list.get(0); // 无需强制转换

定义泛型类

语法：

public class Box<T> {
    private T value;
    public T getValue() { return value; }
    public void setValue(T value) { this.value = value; }
}

使用：

1
2

Box<Integer> intBox = new Box<>();
intBox.setValue(10);

泛型方法

可在普通类中定义泛型方法

public static <T> void printArray(T[] array) {
    for (T element : array) {
        System.out.println(element);
    }
}

调用：

1
2

Integer[] intArray = {1, 2, 3};
printArray(intArray); // 自动推断T为Integer

类型变量的限定

限制类型变量必须是某个类的子类或实现某个接口

`1`	`public <T extends Comparable> void sort(T[] array) { ... } // T必须实现Comparable接口`

泛型代码和虚拟机

类型擦除：泛型信息只在编译期存在，运行时被擦除
- 泛型类Box<T>编译后变为原始类Box
- 类型变量被替换为上限（若无上限则为Object）
桥接方法：为保持多态性，编译器生成的特殊方法
泛型数组：不能直接创建泛型数组（new T[]），但可通过强制类型转换实现

泛型的限制与局限性

不能实例化类型变量：new T()不合法
不能创建泛型数组：T[] array = new T[10];不合法
静态上下文中类型变量无效：静态方法/字段不能使用类的类型变量
不能捕获或抛出泛型类的实例：catch (T e)不合法
不能使用基本类型实例化泛型：需使用包装类（如Integer代替int）

通配符（Wildcards）

上界通配符：<? extends Type>表示可以接受该类型或其子类型

`1`	`public void printList(List<? extends Number> list) { ... } // 接受任何Number子类的列表`

下界通配符：<? super Type>表示可以接受该类型或其父类型

`1`	`public void addNumbers(List<? super Integer> list) { ... } // 接受Integer或其父类的列表`

无界通配符：<?>等同于<? extends Object>

`1`	`public void printObjectList(List<?> list) { ... } // 接受任何类型的列表`

泛型最佳实践

使用泛型集合：如List<String>而非原始List
定义泛型方法而非泛型类：若通用性仅限于少数方法
合理使用通配符：提高API灵活性
必要时使用类型检查和强制转换：在泛型信息丢失时
考虑类型安全的容器：如Collections.checkedList()

第4-8章复习重点

面向对象核心：封装、继承、多态的实现与应用场景
继承机制：
- 子类与父类关系及构造顺序
- 方法覆盖与super关键字
- final关键字的使用
接口与lambda：
- 接口特性与默认方法
- lambda表达式简化函数式接口实现
异常处理：
- 检查型与非检查型异常区别
- try-catch-finally与try-with-resources用法
- 自定义异常最佳实践
泛型：
- 类型擦除机制
- 通配符使用（上界、下界）
- 泛型类与方法设计

提示：重点练习类的继承关系设计、接口实现、异常处理策略和泛型集合使用，这些是Java开发的核心技能。

第9章集合

Java集合框架概述

集合特点：
- 大小可变，可存储对象引用（基本类型自动装箱）
- 支持泛型，类型安全
- 主要接口：Collection（单元素集合）和Map（键值对集合）
接口与实现分离：
- 面向接口编程，实现类可互换（如List可用ArrayList或LinkedList）
- 提高代码灵活性和可维护性

Collection接口体系

根接口：Collection<E>

核心方法：add(E e)、iterator()、size()、contains(Object o)
子接口：
- List<E>：有序、可重复，支持索引访问
  - 实现：ArrayList（动态数组，随机访问快）、LinkedList（双向链表，增删快）
- Set<E>：无序、唯一
  - 实现：HashSet（哈希表，性能好）、TreeSet（有序，基于红黑树）、LinkedHashSet（插入顺序）
- Queue<E>：FIFO（先进先出）
  - 实现：LinkedList（也实现Deque）、PriorityQueue（优先级队列）

迭代器

功能：遍历集合元素，支持删除操作

核心方法：

1
2
3

boolean hasNext(); // 是否有下一个元素
E next(); // 返回下一个元素
void remove(); // 删除当前元素（可选操作）

增强for循环：内部使用迭代器，简化遍历
1

for (E element : collection) { ... }
注意：遍历时直接修改集合结构会抛出ConcurrentModificationException，应使用迭代器的remove()方法

Map接口

特点：存储key-value对，key唯一
核心实现：
- HashMap：基于哈希表，性能最佳，无序
- TreeMap：按键排序（自然顺序或定制比较器）
- LinkedHashMap：保持插入顺序，可实现LRU缓存
- Hashtable：线程安全（同步），已过时，推荐使用ConcurrentHashMap

视图操作：

1
2
3

Set<K> keySet(); // 获取所有key的集合
Collection<V> values(); // 获取所有value的集合
Set<Map.Entry<K, V>> entrySet(); // 获取所有键值对

集合工具类

Collections：提供静态方法操作集合
- 排序：sort(List<T> list)（自然顺序）、sort(List<T> list, Comparator<? super T> c)（定制顺序）
- 查找：binarySearch()、max()、min()
- 包装：synchronizedList()（线程安全）、unmodifiableList()（只读）
- 填充：fill(List<T> list, T obj)
- 洗牌：shuffle(List<?> list)

Arrays：数组与集合互转

// 数组转集合（固定大小，不支持增删）
List<String> list = Arrays.asList("a", "b", "c");

// 集合转数组
String[] array = list.toArray(new String[0]);

特殊集合

WeakHashMap：键使用弱引用，当键不再被其他对象强引用时，可被垃圾回收，适用于缓存场景
PriorityQueue：优先队列，元素按自然顺序或定制比较器排序，poll()返回最小元素
EnumSet：专为枚举类型设计的高效Set实现
LinkedHashSet：保持插入顺序的HashSet，遍历时按插入顺序访问

第10章 GUI程序设计

Java GUI工具包简史

AWT（Abstract Window Toolkit）：
- Java最早的GUI工具包（1995年）
- 依赖操作系统原生组件（重量级组件）
- 组件外观受系统影响，功能有限，现已被Swing和JavaFX替代
Swing：
- 完全用Java实现（轻量级组件）
- 跨平台一致外观
- 提供更丰富组件（如表格、树等）
- 包名：javax.swing，是Java SE标准库一部分

基本GUI构建

1. 窗口（JFrame）：

import javax.swing.*;
public class MyFrame extends JFrame {
    public MyFrame() {
        setTitle("My Window");
        setSize(400, 300);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // 关闭窗口时退出程序
        setLocationRelativeTo(null); // 窗口居中
        // 添加组件
        JLabel label = new JLabel("Hello, Swing!");
        add(label);
        setVisible(true); // 必须设置为true才显示
    }
}

2. 容器（Container）：

组件不能独立显示，必须添加到容器中
常用容器：
- JFrame：主窗口
- JPanel：轻量级面板，用于组织和嵌套组件
- JScrollPane：带滚动条的容器，用于显示大内容
- JOptionPane：对话框容器，用于显示消息和获取用户输入

布局管理器

控制容器中组件的排列方式，Swing提供多种布局：

布局管理器	特点	适用场景
FlowLayout	按添加顺序排列，默认居中对齐	简单界面，组件较少
BorderLayout	分为东、西、南、北、中五个区域	主窗口布局，通常中心区域放置主要内容
GridLayout	网格布局，所有组件大小相同	整齐排列的按钮、标签等
GridBagLayout	灵活网格，可设置组件跨越多个单元格，自定义大小	复杂界面，组件大小不一
BoxLayout	水平或垂直排列，可设置间距	工具栏、垂直菜单等

使用示例：

// 设置JFrame使用BorderLayout
setLayout(new BorderLayout());

// 向不同区域添加组件
add(new JButton("Top"), BorderLayout.NORTH);
add(new JButton("Bottom"), BorderLayout.SOUTH);

事件处理机制

1. 事件模型：

事件源：产生事件的组件（如按钮、文本框）
事件：描述发生的事情（如点击、输入）
事件监听器：接收并处理事件的对象，实现特定监听器接口

2. 常见事件类型：

ActionListener：按钮点击、菜单选择等

1
2

JButton button = new JButton("Click me");
button.addActionListener(e -> System.out.println("Button clicked!"));

ItemListener：复选框、单选按钮状态变化

1
2

JCheckBox checkBox = new JCheckBox("Remember me");
checkBox.addItemListener(e -> System.out.println("Checkbox state: " + e.getStateChange()));

MouseListener：鼠标点击、进入、离开等
KeyListener：键盘按键事件

3. 适配器类：

为监听器接口提供默认实现，只需重写需要的方法

// 使用MouseAdapter简化鼠标事件处理
button.addMouseListener(new MouseAdapter() {
    @Override
    public void mouseClicked(MouseEvent e) {
        System.out.println("Mouse clicked at: " + e.getX() + ", " + e.getY());
    }
});

常用Swing组件

1. 标签（JLabel）：显示文本或图像，不响应用户交互

1
2

JLabel label = new JLabel("Username:");
label.setToolTipText("This is a username label"); // 添加悬停提示

2. 按钮（JButton）：可点击按钮

1
2

JButton button = new JButton("Submit");
button.setMnemonic(KeyEvent.VK_S); // 设置快捷键Alt+S

3. 文本组件：

JTextField：单行文本输入
JPasswordField：密码输入（显示为星号）
JTextArea：多行文本区域（通常配合JScrollPane使用）

4. 选择组件：

JCheckBox：复选框，可选中或取消选中
JRadioButton：单选按钮，需配合ButtonGroup使用（同一组内只能选一个）
JComboBox：下拉列表，可选择预定义选项

5. 对话框：

JOptionPane：简单对话框，用于显示消息、获取用户输入

// 消息对话框
JOptionPane.showMessageDialog(null, "Login successful!");

// 确认对话框
int option = JOptionPane.showConfirmDialog(null, "Do you want to save changes?");

第11章 Swing用户界面组件

Swing高级组件

1. 菜单（Menu）：

// 创建菜单栏
JMenuBar menuBar = new JMenuBar();

// 创建菜单
JMenu fileMenu = new JMenu("File");
fileMenu.setMnemonic(KeyEvent.VK_F); // 设置Alt+F快捷键

// 添加菜单项
JMenuItem openItem = new JMenuItem("Open", KeyEvent.VK_O);
openItem.addActionListener(e -> openFile());

// 添加到菜单和菜单栏
fileMenu.add(openItem);
menuBar.add(fileMenu);

// 将菜单栏设置到窗口
setJMenuBar(menuBar);

2. 工具栏（JToolBar）：

1
2
3

JToolBar toolBar = new JToolBar();
toolBar.add(new JButton(new ImageIcon("open.png"))); // 添加带图标的按钮
add(toolBar, BorderLayout.NORTH);

3. 表格（JTable）：显示和编辑二维数据

// 创建表格模型
Object[][] data = {{"Alice", 25}, {"Bob", 30}};
String[] columnNames = {"Name", "Age"};
DefaultTableModel model = new DefaultTableModel(data, columnNames);

// 创建表格
JTable table = new JTable(model);

// 添加滚动条
JScrollPane scrollPane = new JScrollPane(table);
add(scrollPane);

4. 树（JTree）：显示层次结构数据

// 创建树节点
DefaultMutableTreeNode root = new DefaultMutableTreeNode("Root");
DefaultMutableTreeNode child1 = new DefaultMutableTreeNode("Child 1");
root.add(child1);

// 创建树
JTree tree = new JTree(root);

// 添加滚动条
add(new JScrollPane(tree));

布局管理进阶

1. GridBagLayout详解：

最灵活的布局管理器，支持组件跨越多个单元格

通过GridBagConstraints设置组件位置、大小、对齐方式等

// 设置窗口使用GridBagLayout
setLayout(new GridBagLayout());
GridBagConstraints gbc = new GridBagConstraints();

// 添加组件到(0,0)位置，默认大小
gbc.gridx = 0;
gbc.gridy = 0;
add(new JLabel("Username:"), gbc);

// 添加组件到(1,0)位置，横向填充
gbc.gridx = 1;
gbc.gridy = 0;
gbc.fill = GridBagConstraints.HORIZONTAL; // 水平方向填充
add(new JTextField(20), gbc);

2. BoxLayout与Box组件：

垂直或水平排列组件，自动处理间距

// 垂直排列组件
JPanel panel = new JPanel();
panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS));
panel.add(new JButton("Button 1"));
panel.add(Box.createVerticalStrut(10)); // 添加垂直间距
panel.add(new JButton("Button 2"));

Swing特性与最佳实践

1. 组件边框（Border）：

// 创建带标题的边框
JLabel label = new JLabel("Content");
label.setBorder(BorderFactory.createTitledBorder("Title"));

// 创建空边框（用于间距）
panel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10)); // 上右下左间距

2. 图标（Icon）：

使用ImageIcon加载图片，支持多种格式（如PNG、JPG）

`1`	`JButton button = new JButton(new ImageIcon("icon.png"));`

3. 工具提示（ToolTip）：

`1`	`component.setToolTipText("This is a tooltip"); // 鼠标悬停显示提示`

4. Swing应用程序结构最佳实践：

在事件调度线程（Event Dispatch Thread, EDT）中创建和更新UI
1

SwingUtilities.invokeLater(() -> new MyFrame());
主窗口设置合适的关闭操作：setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
合理使用布局管理器，避免绝对定位
使用面板（JPanel）组织相关组件，实现界面模块化

第12章并发

线程基础

1. 线程与进程：

进程：独立执行的程序，拥有自己的内存空间
线程：进程内的执行单元，共享进程内存，提高程序并发性

2. 创建线程的方式：

// 方式1：继承Thread类
class MyThread extends Thread {
  @Override
  public void run() {
      System.out.println("Thread running");
  }
}
new MyThread().start(); // 启动线程

// 方式2：实现Runnable接口
Runnable task = () -> System.out.println("Runnable task running");
new Thread(task).start();

// 方式3：使用Callable和Future（有返回值）
Callable<Integer> task = () -> {
  // 执行任务
  return 42; // 返回结果
};
Future<Integer> future = Executors.newSingleThreadExecutor().submit(task);

3. 线程状态（6种）：

`1`	`Thread.State state = thread.getState(); // 获取线程状态`

状态	描述
NEW	线程已创建但未启动（调用start()前）
RUNNABLE	线程可运行（正在执行或等待CPU时间片）
BLOCKED	线程阻塞等待监视器锁（synchronized）
WAITING	线程无限等待（如调用Object.wait()）
TIMED_WAITING	线程等待指定时间（如Thread.sleep()）
TERMINATED	线程执行完毕或异常终止

线程属性与控制

1. 线程优先级：

1
2
3

thread.setPriority(Thread.MAX_PRIORITY); // 设置最高优先级（10）
thread.setPriority(Thread.MIN_PRIORITY); // 设置最低优先级（1）
thread.setPriority(Thread.NORM_PRIORITY); // 设置默认优先级（5）

优先级只是建议，不保证执行顺序，不同操作系统实现不同

2. 线程名称：

1
2

thread.setName("MyWorkerThread");
System.out.println(thread.getName()); // 输出线程名

3. 守护线程（Daemon Thread）：

`1`	`thread.setDaemon(true); // 设置为守护线程`

为其他线程服务的线程（如垃圾回收线程）
当所有非守护线程结束时，JVM会自动终止守护线程

4. 线程中断：

1
2

thread.interrupt(); // 中断线程
boolean isInterrupted = thread.isInterrupted(); // 检查是否被中断

协作式中断：线程需自行检查中断状态并处理
不推荐使用stop()、suspend()、resume()等已废弃方法

同步机制

1. 竞态条件（Race Condition）：

多个线程同时访问共享资源且执行顺序不确定，导致结果不可预测
例：多个线程同时修改同一个计数器，可能导致计数丢失

2. synchronized关键字：

// 方法级同步（锁当前对象）
public synchronized void increment() {
  count++;
}

// 代码块同步（锁指定对象）
public void increment() {
  synchronized (lockObject) {
      count++;
  }
}

保证同一时间只有一个线程执行同步代码
可重入：同一线程可多次获取同一把锁

3. 锁对象（Lock）（Java 5+）：

private Lock lock = new ReentrantLock();

public void increment() {
  lock.lock(); // 获取锁
  try {
      count++;
  } finally {
      lock.unlock(); // 释放锁（确保finally中调用）
  }
}

ReentrantLock：可重入锁，功能类似synchronized，但更灵活
ReentrantReadWriteLock：读写锁，允许多个读线程同时访问，写线程独占

4. 条件对象（Condition）：

private Lock lock = new ReentrantLock();
private Condition condition = lock.newCondition();

public void await() throws InterruptedException {
  lock.lock();
  try {
      condition.await(); // 等待条件满足
  } finally {
      lock.unlock();
  }
}

public void signal() {
  lock.lock();
  try {
      condition.signal(); // 唤醒一个等待线程
      condition.signalAll(); // 唤醒所有等待线程
  } finally {
      lock.unlock();
  }
}

配合锁使用，实现更精细的线程间通信

5. volatile关键字：

`1`	`private volatile boolean flag; // 保证可见性和禁止指令重排`

确保变量在多个线程间的可见性（一个线程修改后，其他线程立即可见）
不保证原子性，适用于状态标记等简单场景，不适用于复合操作

线程安全集合

**并发包（Java.util.concurrent）**提供线程安全的集合：

集合类	特点	适用场景
`ConcurrentHashMap`	高效线程安全哈希表，分段锁机制	高并发读写，替代Hashtable
`CopyOnWriteArrayList`	写时复制，适合读多写少场景	事件监听、日志记录等
`ConcurrentLinkedQueue`	线程安全的链式队列，无锁实现	多线程间安全传递数据
`BlockingQueue`	阻塞队列，提供put()和take()等阻塞方法	生产者-消费者模型
`ConcurrentSkipListMap`	线程安全的有序Map，基于跳表实现	高并发下的有序数据访问

使用示例：

// 使用ConcurrentHashMap
Map<String, Integer> map = new ConcurrentHashMap<>();
map.put("key", 1);
int value = map.get("key");

任务与线程池

1. 执行器框架（Executor Framework）：

// 创建固定大小线程池
ExecutorService executor = Executors.newFixedThreadPool(5);

// 提交Runnable任务
executor.execute(() -> System.out.println("Task executed by thread pool"));

// 提交Callable任务（有返回值）
Future<String> future = executor.submit(() -> {
  // 执行任务
  return "Result";
});

// 关闭线程池
executor.shutdown(); // 等待现有任务完成后关闭
executor.shutdownNow(); // 立即关闭，尝试取消正在执行的任务

2. 线程池类型：

newFixedThreadPool(int nThreads)：固定大小线程池，重用固定数量线程
newCachedThreadPool()：缓存线程池，按需创建线程，空闲线程会被回收
newSingleThreadExecutor()：单线程执行器，保证任务按顺序执行
newScheduledThreadPool(int corePoolSize)：定时线程池，支持任务定时或周期性执行

3. 控制任务组：

// 提交多个任务并等待所有完成
List<Future<?>> futures = executor.invokeAll(tasks);

// 提交多个任务，返回第一个完成的任务结果
String result = executor.invokeAny(tasks);

异步计算

1. Future与Callable：

// 提交Callable任务
Future<Integer> future = executor.submit(() -> {
  // 模拟耗时操作
  Thread.sleep(1000);
  return 42;
});

// 检查任务是否完成
boolean isDone = future.isDone();

// 获取结果（会阻塞直到任务完成）
int result = future.get();

// 获取结果（最多等待1秒）
int result = future.get(1, TimeUnit.SECONDS);

2. CompletableFuture（Java 8+）：

支持异步操作的链式调用和组合，无需显式线程管理

1
2
3

CompletableFuture.supplyAsync(() -> "Hello") // 异步执行任务
    .thenApply(s -> s + " World") // 处理结果
    .thenAccept(System.out::println); // 消费最终结果（无返回）

3. 异步计算最佳实践：

避免在UI线程执行耗时操作，使用线程池或CompletableFuture
使用CompletableFuture处理多个异步任务的组合
对长时间运行任务提供取消机制
正确处理异常（使用exceptionally()或handle()）

第9-12章复习重点

集合框架：
- Collection与Map接口体系结构
- 常用实现类特点与适用场景（如ArrayList vs LinkedList，HashMap vs TreeMap）
- 迭代器使用与注意事项
- Collections工具类方法
GUI编程：
- Swing组件层次结构（容器与组件关系）
- 布局管理器（FlowLayout、BorderLayout、GridBagLayout）使用
- 事件处理机制（监听器、适配器）
- 常用组件（JButton、JLabel、JTextField等）使用
并发编程：
- 线程创建方式（Thread、Runnable、Callable）
- 线程同步机制（synchronized、Lock、Condition、volatile）
- 线程池使用（Executor框架）
- 线程安全集合与异步计算（Future、CompletableFuture）

提示：重点练习集合的实际应用、GUI布局设计和并发程序调试，这些是Java开发的核心技能，也是面试高频考点。

全局阈值二值化

Tue, 02 Dec 2025 20:52:12 +0800

128阈值

在灰度图像中，像素值范围是0到255（共 256 个离散级）。把灰度图二值化时常见的简单规则是：

若像素值 $I(x,y)\geq T$，则置为 255（白）
否则置为0（黑）

当T=128时，即将灰度中点作为阈值：所有亮度 $\ge 128$ 的像素判为“亮”，小于的则判为”暗。

关于图片适用性的判别，则可以用似然比检验法进行确认（只不过需要知道前景和后景的分布）：

假设图像像素由前景和背景组成，每个部分的像素值服从高斯分布（正态分布）。设图像有 N 个像素，像素值为 $x_{i} (i=1,2,…,N)$ 。我们需要比较两个假设：

零假设（$H_{0}$）：阈值 T=128是合理的，即图像二值化使用固定阈值128。
备择假设（$H_{1}$）：阈值 T 是任意的，即存在一个最优阈值 $T^*$ 能更好地拟合图像数据。

似然比检验通过比较在 $H_{0}$ 和 $H_{1}$ 下的最大似然值来评估 $H_{0}$ 是否被拒绝。

假设前景和背景的像素值分别服从高斯分布：

背景像素 ($x_{i} \leq T $) 服从 $ N(\mu_{b},\sigma_{b}^{2})$
前景像素 ($ x_{i}>T $) 服从 $ N(\mu_{f},\sigma_{f}^{2}) $

则似然函数(给定阈值T)为:

$$ L(\mu_{b},\sigma_{b}^{2},\mu_{f},\sigma_{f}^{2},T)=\prod_{x_{i}\leq T}\frac{1}{\sqrt{2\pi\sigma_{b}^{2}}}\exp\left(-\frac{(x_{i}-\mu_{b})^{2}}{2\sigma_{b}^{2}}\right)\times\prod_{x_{i}>T}\frac{1}{\sqrt{2\pi\sigma_{f}^{2}}}\exp\left(-\frac{(x_{i}-\mu_{f})^{2}}{2\sigma_{f}^{2}}\right) $$

分别计算 $L_{0} 和 L_{1} $，似然比定义为：

$$ \Lambda=\frac{L_{0}}{L_{1}} $$

检验统计量为 $ \lambda=-2\ln\Lambda $，在$ H_{0} $下，$ \lambda $ 近似服从自由度为1的卡方分布（因为$ H_{1} $比$ H_{0} $多一个自由参数T）。

选择显著性水平$ \alpha $（通常为0.05），对应的卡方临界值为 $ \chi^{2}_{1,1-\alpha} $（例如，$ \alpha=0.05 $时，临界值为3.841）。
如果$ \lambda>\chi^{2}{1,1-\alpha} $，则拒绝$ H{0} $，表示阈值128不合理；否则不拒绝$ H_{0} $，表示128阈值可接受。

均值阈值

核心思想：使用图像所有像素灰度值的平均值作为阈值。

设图像有N个像素，第 $i$ 个像素的灰度值为 $p_i$ ，则平均阈值 $T$ 计算为：

$$ T = \frac{1}{N} \sum_{i=1}^{N} p_i $$

代码示例：

import cv2
import numpy as np
import matplotlib.pyplot as plt

def mean_thresholding(image):
    """
    平均阈值二值化
    """
    # 计算平均阈值
    mean_value = np.mean(image)
    
    # 应用阈值
    _, binary_image = cv2.threshold(image, mean_value, 255, cv2.THRESH_BINARY)
    
    return binary_image, mean_value

# 读取图像
image = cv2.imread('document.jpg', cv2.IMREAD_GRAYSCALE)

# 应用平均阈值
binary_result, threshold_value = mean_thresholding(image)

print(f"计算得到的平均阈值: {threshold_value}")

# 显示结果
plt.figure(figsize=(12, 4))

plt.subplot(1, 3, 1)
plt.imshow(image, cmap='gray')
plt.title('原图')
plt.axis('off')

plt.subplot(1, 3, 2)
plt.hist(image.ravel(), 256, [0, 256])
plt.axvline(threshold_value, color='r', linestyle='--', label=f'阈值 = {threshold_value:.2f}')
plt.title('灰度直方图')
plt.legend()

plt.subplot(1, 3, 3)
plt.imshow(binary_result, cmap='gray')
plt.title('平均阈值二值化结果')
plt.axis('off')

plt.tight_layout()
plt.show()

OSTU大津法

核心准则：最优阈值 ($ T^*$) 是使两类像素的 “类间方差” 最大的阈值。

背后逻辑：类间方差越大，说明前景与背景的灰度差异越显著，分割效果越好；反之，类间方差越小，两类灰度重叠越严重，分割效果越差。

关键前提：总方差 = 类内方差 + 类间方差（总方差不随阈值 t 变化），因此 “最大化类间方差” 等价于 “最小化类内方差”，二者是完全等价的优化目标。

假设输入图像为单通道灰度图，灰度级范围为 $[0, L-1]$ （通常 $L=256$ ，即8位图像），定义：

$n_i$ ：灰度值为 $i$ 的像素个数；
总像素数 $N = \sum_{i=0}^{L-1} n_i$ ；
灰度级 $i$ 的概率 $p_i = \frac{n_i}{N}$ ，满足 $\sum_{i=0}^{L-1} p_i = 1$ （所有灰度的概率和为1）。

对于任意候选阈值 $t$ （ $0 \leq t \leq L-2$ ），将像素分为 $C_0$ （0~~t）和 $C_1$ （t+1~~L-1），定义以下关键统计量：

（1）两类的概率（权重）

背景类 $C_0$ 的概率： $\omega_0(t) = \sum_{i=0}^t p_i$ （所有灰度≤t的像素占比）；
前景类 $C_1$ 的概率： $\omega_1(t) = \sum_{i=t+1}^{L-1} p_i = 1 - \omega_0(t)$ （所有灰度>t的像素占比）。

（2）两类的均值（灰度中心）

背景类 $C_0$ 的均值： $\mu_0(t) = \frac{1}{\omega_0(t)} \sum_{i=0}^t i \cdot p_i$ （仅当 $\omega_0(t) \neq 0$ ，否则均值无意义）；
前景类 $C_1$ 的均值： $\mu_1(t) = \frac{1}{\omega_1(t)} \sum_{i=t+1}^{L-1} i \cdot p_i$ （仅当 $\omega_1(t) \neq 0$ ）；
全局均值（整幅图像的灰度均值）： $\mu = \sum_{i=0}^{L-1} i \cdot p_i = \omega_0(t) \cdot \mu_0(t) + \omega_1(t) \cdot \mu_1(t)$ （加权平均，权重为两类概率）。

类间方差的定义是：两类均值与全局均值的加权平方和，权重为两类概率：

$$ \sigma_b^2(t) = \omega_0(t) \cdot (\mu_0(t) - \mu)^2 + \omega_1(t) \cdot (\mu_1(t) - \mu)^2 $$

简化有：

$$ \boxed{\sigma_b^2(t) = \omega_0(t) \cdot \omega_1(t) \cdot (\mu_0(t) - \mu_1(t))^2} $$

大津算法的具体实现步骤如下（以8位图像 $L=256$ 为例）：

步骤1：计算灰度概率分布

遍历图像所有像素，统计每个灰度级 $i$ （0~255）的像素数 $n_i$ ，并计算概率 $p_i = \frac{n_i}{N}$ （ $N$ 为总像素数）。

步骤2：遍历所有候选阈值

遍历 $t \in [0, 254]$ （阈值需将灰度级分为非空两类，故 $t$ 不取255），对每个 $t$ 执行以下计算：

步骤3：计算两类的概率与均值

背景概率 $\omega_0(t) = \sum_{i=0}^t p_i$ ；
前景概率 $\omega_1(t) = 1 - \omega_0(t)$ ；
背景均值 $\mu_0(t) = \frac{1}{\omega_0(t)} \sum_{i=0}^t i \cdot p_i$ （若 $\omega_0(t) = 0$ ，跳过该 $t$ ）；
前景均值 $\mu_1(t) = \frac{1}{\omega_1(t)} \sum_{i=t+1}^{255} i \cdot p_i$ （若 $\omega_1(t) = 0$ ，跳过该 $t$ ）。

步骤4：计算类间方差

用简化公式计算 $\sigma_b^2(t) = \omega_0(t) \cdot \omega_1(t) \cdot (\mu_0(t) - \mu_1(t))^2$ 。

步骤5：寻找最优阈值

记录所有 $t$ 对应的 $\sigma_b^2(t)$ ，找到使 $\sigma_b^2(t)$ 最大的阈值 $t^*$ （若有多个 $t$ 对应最大方差，取任意一个即可）。

步骤6：二值化分割

将图像中灰度值 $\leq t^$ 的像素设为背景（通常为0），灰度值 $> t^$ 的像素设为前景（通常为255），或根据需求反转（前景为0，背景为255）。

示例验证（简化场景）

为直观理解，假设一幅图像的灰度级仅为 $[0,1,2,3]$ ，统计信息如下：

灰度级 $i$	0	1	2	3
像素数 $n_i$	10	20	30	40
概率 $p_i$	0.1	0.2	0.3	0.4

总像素数 $N=100$ ，全局均值 $\mu = 0 \times 0.1 + 1 \times 0.2 + 2 \times 0.3 + 3 \times 0.4 = 2.0$ 。

遍历候选阈值 $t=0,1,2$ ：

当 $t=0$ 时：

$\omega_0 = 0.1$ ， $\mu_0 = 0$ ；
$\omega_1 = 0.9$ ， $\mu_1 = \frac{1 \times 0.2 + 2 \times 0.3 + 3 \times 0.4}{0.9} = \frac{2.0}{0.9} \approx 2.222$ ；
$\sigma_b^2 = 0.1 \times 0.9 \times (0 - 2.222)^2 \approx 0.444$ 。

当 $t=1$ 时：

$\omega_0 = 0.1 + 0.2 = 0.3$ ， $\mu_0 = \frac{0 \times 0.1 + 1 \times 0.2}{0.3} \approx 0.667$ ；
$\omega_1 = 0.3 + 0.4 = 0.7$ ， $\mu_1 = \frac{2 \times 0.3 + 3 \times 0.4}{0.7} = \frac{1.8}{0.7} \approx 2.571$ ；
$\sigma_b^2 = 0.3 \times 0.7 \times (0.667 - 2.571)^2 \approx 0.760$ 。

当 $t=2$ 时：

$\omega_0 = 0.1 + 0.2 + 0.3 = 0.6$ ， $\mu_0 = \frac{0 \times 0.1 + 1 \times 0.2 + 2 \times 0.3}{0.6} \approx 1.333$ ；
$\omega_1 = 0.4$ ， $\mu_1 = 3$ ；
$\sigma_b^2 = 0.6 \times 0.4 \times (1.333 - 3)^2 \approx 0.667$ 。

最优阈值：

类间方差最大值为 $\approx 0.760$ ，对应 $t^*=1$ 。因此，最优分割为：灰度01（背景）、灰度23（前景），分割效果最优。

示例代码：

import cv2
import numpy as np
import matplotlib.pyplot as plt

def otsu_threshold_manual(gray_img):
    """
    手动实现大津算法，返回最优阈值和二值化图像
    :param gray_img: 输入灰度图（shape: (H, W)，值范围0-255）
    :return: (optimal_thresh, binary_img)
    """
    # 步骤1：计算灰度概率分布（灰度直方图）
    H, W = gray_img.shape
    total_pixels = H * W  # 总像素数 N
    hist, _ = np.histogram(gray_img.flatten(), bins=256, range=[0, 256])  # 统计每个灰度级的像素数 n_i
    p = hist / total_pixels  # 灰度级概率 p_i = n_i / N

    # 步骤2：遍历所有候选阈值 t（0~254，避免某一类为空）
    max_var = 0.0  # 最大类间方差
    optimal_thresh = 0  # 最优阈值

    for t in range(0, 255):
        # 步骤3：计算两类的概率 ω0、ω1
        omega0 = np.sum(p[:t+1])  # C0：0~t 的概率和
        omega1 = 1 - omega0       # C1：t+1~255 的概率和（ω0+ω1=1）

        # 跳过空类（避免除以零）
        if omega0 == 0 or omega1 == 0:
            continue

        # 步骤4：计算两类的均值 μ0、μ1
        # μ0 = sum(i*p_i for i=0~t) / omega0
        mu0 = np.sum(np.arange(t+1) * p[:t+1]) / omega0
        # μ1 = sum(i*p_i for i=t+1~255) / omega1
        mu1 = np.sum(np.arange(t+1, 256) * p[t+1:]) / omega1

        # 步骤5：计算类间方差（使用简化公式）
        between_var = omega0 * omega1 * (mu0 - mu1) ** 2

        # 更新最大方差和最优阈值
        if between_var > max_var:
            max_var = between_var
            optimal_thresh = t

    # 步骤6：根据最优阈值二值化
    binary_img = np.where(gray_img <= optimal_thresh, 0, 255).astype(np.uint8)  # 0=背景，255=前景
    # 若需反转前景背景，改为：np.where(gray_img <= optimal_thresh, 255, 0)

    return optimal_thresh, binary_img

# ---------------------- 主流程 ----------------------
# 1. 读取图像并转为灰度图
img_path = "test_image.jpg"  # 替换为你的图像路径
img = cv2.imread(img_path)
if img is None:
    print("Error: 无法读取图像，请检查路径是否正确！")
    exit()
gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# 2. 手动调用大津算法
manual_thresh, manual_binary = otsu_threshold_manual(gray_img)

# 3. 对比 OpenCV 结果（验证正确性）
cv2_thresh, cv2_binary = cv2.threshold(gray_img, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)

# 4. 显示结果
plt.figure(figsize=(15, 5))

# 原图
plt.subplot(1, 4, 1)
plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
plt.title("原图")
plt.axis("off")

# 灰度图
plt.subplot(1, 4, 2)
plt.imshow(gray_img, cmap="gray")
plt.title("灰度图")
plt.axis("off")

# 手动实现二值化
plt.subplot(1, 4, 3)
plt.imshow(manual_binary, cmap="gray")
plt.title(f"手动实现大津二值化\n阈值={manual_thresh}")
plt.axis("off")

# OpenCV 实现二值化（对比）
plt.subplot(1, 4, 4)
plt.imshow(cv2_binary, cmap="gray")
plt.title(f"OpenCV 大津二值化\n阈值={cv2_thresh:.0f}")
plt.axis("off")

plt.tight_layout()
plt.show()

# 输出阈值对比（验证手动实现正确性）
print(f"手动实现最优阈值：{manual_thresh}")
print(f"OpenCV 最优阈值：{cv2_thresh:.0f}")
print(f"两者阈值是否一致：{manual_thresh == int(cv2_thresh)}")

# 保存结果（可选）
cv2.imwrite("manual_otsu_binary.jpg", manual_binary)
print("手动实现二值化结果已保存！")

Numpy使用手册

Wed, 05 Nov 2025 12:47:28 +0800

创建数组

从列表创建

# 一维数组
arr1d = np.array([1, 2, 3, 4, 5])
print(arr1d)  # [1 2 3 4 5]

# 二维数组
arr2d = np.array([[1, 2, 3], [4, 5, 6]])
print(arr2d)
# [[1 2 3]
#  [4 5 6]]

# 三维数组
arr3d = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
print(arr3d)

特殊数组创建

# 全零数组
zeros = np.zeros((3, 4))
print(zeros)

# 全一数组
ones = np.ones((2, 3))
print(ones)

# 单位矩阵
identity = np.eye(3)
print(identity)

# 等差数列
lin_arr = np.linspace(0, 10, 5)  # 从0到10，5个等间距数
print(lin_arr)  # [ 0.   2.5  5.   7.5 10. ]

# 等差数列（指定步长）
arange_arr = np.arange(0, 10, 2)  # 从0到10，步长为2
print(arange_arr)  # [0 2 4 6 8]

# 随机数组
random_arr = np.random.random((2, 3))  # 0-1之间的随机数
print(random_arr)

数组属性

arr = np.array([[1, 2, 3], [4, 5, 6]])

print("数组:", arr)
print("维度:", arr.ndim)        # 2
print("形状:", arr.shape)       # (2, 3)
print("元素总数:", arr.size)    # 6
print("数据类型:", arr.dtype)   # int64
print("元素大小(字节):", arr.itemsize)  # 8

数组索引与切片

一维数组

arr = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

print(arr[2])        # 2
print(arr[2:5])      # [2 3 4]
print(arr[:5])       # [0 1 2 3 4]
print(arr[5:])       # [5 6 7 8 9]
print(arr[::2])      # [0 2 4 6 8] 步长为2
print(arr[::-1])     # [9 8 7 6 5 4 3 2 1 0] 反转

多维数组

arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

print(arr[0, 1])     # 2
print(arr[1, :])     # [4 5 6] 第二行
print(arr[:, 1])     # [2 5 8] 第二列
print(arr[0:2, 1:3]) # [[2 3] [5 6]] 子数组

布尔索引

arr = np.array([1, 2, 3, 4, 5, 6])

# 选择大于3的元素
mask = arr > 3
print(mask)          # [False False False True True True]
print(arr[mask])     # [4 5 6]

# 直接使用条件
print(arr[arr % 2 == 0])  # [2 4 6] 偶数

数组操作

形状操作

arr = np.arange(12)
print("原始数组:", arr)

# 重塑形状
reshaped = arr.reshape(3, 4)
print("重塑后:\n", reshaped)

# 展平
flattened = reshaped.flatten()
print("展平:", flattened)

# 转置
transposed = reshaped.T
print("转置:\n", transposed)

数组拼接

a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])

# 垂直拼接
v_stack = np.vstack((a, b))
print("垂直拼接:\n", v_stack)

# 水平拼接
h_stack = np.hstack((a, b))
print("水平拼接:\n", h_stack)

数组分割

arr = np.arange(12).reshape(3, 4)
print("原始数组:\n", arr)

# 水平分割
h_split = np.hsplit(arr, 2)
print("水平分割:")
for part in h_split:
    print(part)

# 垂直分割
v_split = np.vsplit(arr, 3)
print("垂直分割:")
for part in v_split:
    print(part)

数学运算

基本运算

a = np.array([1, 2, 3, 4])
b = np.array([5, 6, 7, 8])

print("a + b =", a + b)  # [ 6  8 10 12]
print("a - b =", a - b)  # [-4 -4 -4 -4]
print("a * b =", a * b)  # [ 5 12 21 32]
print("a / b =", a / b)  # [0.2 0.333 0.429 0.5]
print("a ** 2 =", a ** 2)  # [ 1  4  9 16]

通用函数

arr = np.array([0, np.pi/2, np.pi])

print("sin:", np.sin(arr))      # [0. 1. 0.]
print("cos:", np.cos(arr))      # [1. 0. -1.]
print("exp:", np.exp(arr))      # 指数函数
print("log:", np.log(arr + 1))  # 自然对数
print("sqrt:", np.sqrt(arr))    # 平方根

统计函数

arr = np.array([[1, 2, 3], [4, 5, 6]])

print("数组:\n", arr)
print("总和:", np.sum(arr))           # 21
print("平均值:", np.mean(arr))        # 3.5
print("标准差:", np.std(arr))         # 1.7078
print("方差:", np.var(arr))           # 2.9167
print("最小值:", np.min(arr))         # 1
print("最大值:", np.max(arr))         # 6
print("沿轴0求和:", np.sum(arr, axis=0))  # [5 7 9]
print("沿轴1求和:", np.sum(arr, axis=1))  # [6 15]

线性代数

# 矩阵乘法
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])

dot_product = np.dot(a, b)
print("矩阵乘法:\n", dot_product)

# 行列式
det = np.linalg.det(a)
print("行列式:", det)

# 逆矩阵
inv = np.linalg.inv(a)
print("逆矩阵:\n", inv)

# 特征值和特征向量
eigenvalues, eigenvectors = np.linalg.eig(a)
print("特征值:", eigenvalues)
print("特征向量:\n", eigenvectors)

随机数生成

# 设置随机种子（保证结果可重现）
np.random.seed(42)

# 均匀分布
uniform = np.random.rand(3, 3)  # 0-1均匀分布
print("均匀分布:\n", uniform)

# 正态分布
normal = np.random.randn(3, 3)  # 标准正态分布
print("正态分布:\n", normal)

# 整数随机数
integers = np.random.randint(0, 10, (2, 3))  # 0-10的整数
print("整数随机数:\n", integers)

# 随机排列
arr = np.arange(10)
np.random.shuffle(arr)
print("随机排列:", arr)

数组保存与读取

# 创建示例数组
arr = np.arange(12).reshape(3, 4)

# 保存为文本文件
np.savetxt('array.txt', arr)

# 从文本文件读取
loaded = np.loadtxt('array.txt')
print("从文件读取:\n", loaded)

# 保存为二进制文件
np.save('array.npy', arr)

# 从二进制文件读取
loaded_binary = np.load('array.npy')
print("从二进制文件读取:\n", loaded_binary)

# 保存为压缩的二进制文件
np.savez('array_compressed.npz', my_array=arr)

# 从压缩文件读取
loaded_compressed = np.load('array_compressed.npz')
print("从压缩文件读取:\n", loaded_compressed['my_array'])

实用技巧

广播机制

# 数组与标量的运算（广播）
arr = np.array([[1, 2, 3], [4, 5, 6]])
result = arr + 10  # 每个元素加10
print("广播加法:\n", result)

# 不同形状数组的运算
a = np.array([[1], [2], [3]])  # 形状 (3, 1)
b = np.array([4, 5, 6])        # 形状 (3,)
result = a + b  # 广播为 (3, 3)
print("形状广播:\n", result)

条件运算

arr = np.array([1, 2, 3, 4, 5])

# where函数
result = np.where(arr > 3, arr, 0)  # 大于3的保留，其他设为0
print("条件运算:", result)  # [0 0 0 4 5]

# 布尔运算
mask = (arr > 2) & (arr < 5)  # 2 < arr < 5
print("布尔掩码:", mask)      # [False False True True False]

SQLite3

Sat, 11 Oct 2025 15:16:24 +0800

打开数据库

使用SQLite3创建数据的连接，当数据库文件存在则连接对象直接打开数据库文件，不存在则自动创建数据库文件。连接对象可以是硬盘上面的数据库文件，也可以是建立在内存（memory）中的，在内存中的数据库执行完任何操作后，都不需要提交事务的(commit)

SQLite3的connect方法返回con对象，即数据库连接对象，提供如下方法：

方法	描述
.cursor()	创建一个游标对象
.commit()	处理事务提交
.rollback()	处理事务回滚
.close()	关闭一个数据库连接

创建数据库

在硬盘上建立数据库

`1`	`con=sqlite3.connect("E:\Test.db")`

路径中单斜杠和双斜杠不做区分，且数据库的名称不区分大小写，即E:\Test.db 与 E:\\Test.db 与 E:\TEST.db 均相同。但需要注意的是： E:\test.db 会报错，因为编译器会识别到 \t 为制表符，因此认为路径不对。

`1`	`con=sqlite3.connect("Test.db")`

不加全路径则在项目文件下创建数据库

在内存上创建数据库

`1`	`con=sqlite3.connect("memory")`

两者差别

追求极致速度和临时性就选内存数据库；需要数据持久保存、大容量或共享访问则选文件数据库。

混合模式可以兼顾两者优点：你可以将整个文件数据库附加 (ATTACH) 到内存数据库中进行高速操作，处理完成后再将结果写回磁盘文件。这适合“热数据”需要内存加速，而“冷数据”需要持久化的复杂场景

创建游标

游标对象是数据库管理系统提供的一种数据访问机制，它就像一个指向查询结果集的指针，允许你逐行处理数据，而不是一次性操作整个结果集

方法	描述
.execute()	用来执行SQL语句
.executemany()	批量执行同一条SQL语句
.close()	用来关闭游标
.fetchone()	从查询结果中获取下一行数据
.fetchmany()	从结果中取出多条记录
.fetchall()	取出所有剩余记录
.scroll()	用于游标滚动

执行SQL语句

创建表

`1`	`cur.execute("CREATE TABLE IF NOT EXISTS test(id INTEGER PRIMARY KEY,name TEXT,age INTEGER)")`

新增数据

方法一

1
2

data = "5,'leon',22"
cur.execute('INSERT INTO test VALUES (%s)'%data)

方法二

`1`	`cur.execute("INSERT INTO test values(?,?,?)",(6,"zgq",20))`

方法三

`1`	`cur.executemany('INSERT INTO test VALUES (?,?,?)',[(3,'name3',19),(4,'name4',26)])`

更新数据

方法一

`1`	`cur.execute("UPDATE test SET name=? WHERE id=?",("nihao",1))`

方法二

`1`	`cur.execute("UPDATE test SET name='haha' WHERE id=1")`

删除数据

方法一

`1`	`n=cur.execute("DELETE FROM test WHERE id=?",(1,))`

方法二

`1`	`n=cur.execute("DELETE FROM test WHERE id=1")`

返回的n为被删除的对象

查询数据

`1`	`cur.execute("SELECT * FROM test")`

查询结果存储在游标对象cur中，可以使用对象的方法进行访问，例如遍历或使用.fetchone()等方法

删除表

`1`	`cur.execute("DROP TABLE Test ")`

事务回滚或提交

提交

`1`	`con.commit()`

回滚

`1`	`con.rollback()`

关闭数据库和游标

1
2

cur.close()
con.close()

一定要先关闭游标，再关闭数据库连接，否则会报错

案例

import sqlite3

# 连接到内存数据库并创建游标对象
conn = sqlite3.connect(':memory:')
cursor = conn.cursor()

print("=== 1. 使用 .execute() 创建表并插入单条数据 ===\n")

# .execute(): 执行一条SQL语句来创建表
create_table_sql = """
CREATE IF NOT EXISTS EXISTS users (
    id INTEGER PRIMARY KEY,
    name TEXT NOT NULL,
    age INTEGER
)
"""
cursor.execute(create_table_sql)

# .execute(): 执行一条INSERT语句插入单条数据
insert_sql = "INSERT INTO users (name, age) VALUES (?, ?)"
cursor.execute(insert_sql, ('Alice', 25))
print(f"插入单条数据，受影响的行数: {cursor.rowcount}")

print("\n=== 2. 使用 .executemany() 批量插入数据 ===\n")

# .executemany(): 执行同一条SQL语句，但传入多组参数
users_data = [
    ('Bob', 30),
    ('Charlie', 35),
    ('Diana', 28),
    ('Evan', 40)
]
cursor.executemany(insert_sql, users_data)
print(f"批量插入数据，受影响的行数: {cursor.rowcount}")

# 提交事务，使插入的数据生效
conn.commit()

print("\n=== 3. 使用 .fetch*() 系列方法查询数据 ===\n")

# .execute(): 执行查询语句
cursor.execute("SELECT * FROM users ORDER BY id")

print("--- 使用 .fetchone() 逐条获取 ---")
# .fetchone(): 获取结果集中的下一行
first_row = cursor.fetchone()
print(f"第一条记录: {first_row}")

second_row = cursor.fetchone()
print(f"第二条记录: {second_row}")

print("\n--- 使用 .fetchmany() 获取指定数量的记录 ---")
# .fetchmany(size): 获取指定数量的行
# 注意：此时游标指向第三条记录
next_few_rows = cursor.fetchmany(2) # 获取接下来的2条记录
print(f"接下来的两条记录: {next_few_rows}")

print("\n--- 使用 .fetchall() 获取所有剩余记录 ---")
# .fetchall(): 获取结果集中所有剩余的行
remaining_rows = cursor.fetchall()
print(f"所有剩余记录: {remaining_rows}")

# 再次执行查询，让游标回到结果集开头
cursor.execute("SELECT * FROM users ORDER BY id")
all_rows = cursor.fetchall()
print(f"\n--- 使用 .fetchall() 获取全部记录 ---")
print(f"全部记录: {all_rows}")

print("\n=== 4. 使用 .scroll() 滚动游标 ===\n")

# 为了演示.scroll()，我们重新执行查询
cursor.execute("SELECT * FROM users ORDER BY id")

# .scroll(value, mode='relative'): 相对当前位置移动游标
cursor.fetchone() # 先读取第一条，游标到第二条
print(f"读取第一条后，当前游标位置在第二条")

# 相对移动：从当前位置向后移动2条记录
cursor.scroll(2, mode='relative')
row_after_scroll = cursor.fetchone()
print(f"相对当前位置向后滚动2条后，读取的记录是: {row_after_scroll}") # 应该是第5条

# .scroll(value, mode='absolute'): 移动到结果集的绝对位置
cursor.scroll(0, mode='absolute') # 滚动到开头（第0条，但索引从0开始）
first_row_again = cursor.fetchone()
print(f"绝对滚动到开头后，读取的记录是: {first_row_again}") # 应该是第1条

print("\n=== 5. 使用 .close() 关闭游标 ===\n")

# .close(): 关闭游标，释放资源
print(f"关闭前，游标状态: {not cursor.closed}") # False 表示未关闭
cursor.close()
print(f"关闭后，游标状态: {cursor.closed}") # True 表示已关闭

# 关闭数据库连接
conn.close()

=== 1. 使用 .execute() 创建表并插入单条数据 ===

插入单条数据，受影响的行数: 1

=== 2. 使用 .executemany() 批量插入数据 ===

批量插入数据，受影响的行数: 4

=== 3. 使用 .fetch*() 系列方法查询数据 ===

--- 使用 .fetchone() 逐条获取 ---
第一条记录: (1, 'Alice', 25)
第二条记录: (2, 'Bob', 30)

--- 使用 .fetchmany() 获取指定数量的记录 ---
接下来的两条记录: [(3, 'Charlie', 35), (4, 'Diana', 28)]

--- 使用 .fetchall() 获取所有剩余记录 ---
所有剩余记录: [(5, 'Evan', 40)]

--- 使用 .fetchall() 获取全部记录 ---
全部记录: [(1, 'Alice', 25), (2, 'Bob', 30), (3, 'Charlie', 35), (4, 'Diana', 28), (5, 'Evan', 40)]

=== 4. 使用 .scroll() 滚动游标 ===

读取第一条后，当前游标位置在第二条
相对当前位置向后滚动2条后，读取的记录是: (5, 'Evan', 40)
绝对滚动到开头后，读取的记录是: (1, 'Alice', 25)

=== 5. 使用 .close() 关闭游标 ===

关闭前，游标状态: True
关闭后，游标状态: False

滤波器

Sun, 14 Sep 2025 01:14:13 +0800

滤波器的本质

其本质是一种特殊的函数，即在图像的局部区域用提供的明确计算方法对区内的像素值进行计算，用最后的计算结果替代该局部区域的中心值。

$$ V=G(X,W) $$

其中X是矩阵（局部区域），W是向量（计算权重）

滤波器的几种大类型

线性滤波器：即对矩阵直接加权求和，G(X,W)=X·W
非线性滤波器：不满足线性滤波器要求的，即为非线性滤波器，典型的有最大值/最小值/均值
自适应滤波器：线性滤波中的W在滑动过程中固定不变，自适应滤波的W则是在滑动过程中会随着窗口内像素的性质和结构发生变化。但计算代价更高更难优化加速

图像滤波器

1.平滑滤波器

均值滤波、中值滤波、高斯滤波的基本原理都是滑动窗口，以指定的计算方式得到其中的值

1.1高斯滤波

高斯滤波器使图像平滑，用于去除噪声。主要计算方法是将中心像素的周围像素按照高斯分布加权平均进行平滑化，这种二维权值通常被称为卷积核或滤波器。

$$ f(x,y)=\frac{1}{2Π\sigma ^{2} } e^{-\frac{x^{2}+y^{2} }{2\sigma ^{2} } } $$

1.2中值滤波

中值滤波是取滑动窗口中像素的最大值

$$ \begin{pmatrix} 1& 2 & 3\\ 4& 5&6 \\ 7& {\color{Red} 8} &7 \end{pmatrix} $$

1.3均值滤波

取滑动窗口中的均值，该滤波器对减少图像中的随机噪声有效

2.边缘检测滤波器

边缘检测目的是标识数字图像中亮度变化明显的点，提取图像中的线条，该种检测常在灰度图中进行

2.1 Prewitt滤波器

该滤波器的设计思想是真正的边界点在水平方向和垂直方向上的相邻点应该也同样为边界点，因此以更大的边缘检测滤波器，考虑周围更多的点会使得边缘检测更准确。算子模板有：

$$ G_{X}= \begin{pmatrix} -1& 0 & 1\\ -1& 0&1 \\ -1& 0 &1 \end{pmatrix},G_{Y}=\begin{pmatrix} -1 & -1 &-1\\ 0& 0 &0\\ 1&1&1 \end{pmatrix} $$

计算方法是卷积。

2.2 Sobel滤波器

Sobel算子在Prewitt算子的基础上增加了权重的概念，认为相邻点的距离远近对当前像素点的影响是不同的，距离越近的像素点对应当前像素的影响越大，从而实现图像锐化并突出边缘轮廓。算子模板：

$$ G_{X}= \begin{pmatrix} -1& 0 &1\\ -2& 0 &2 \\ -1& 0 &1 \end{pmatrix},G_{Y}=\begin{pmatrix} -1 & -2 &-1\\ 0 & 0 &0\\ 1 & 2 & 1 \end{pmatrix} $$

2.3 Laplacian滤波器

前面两种是一阶微分，而Laplacian滤波器则是二阶微分滤波器。其推导过程为：一阶差分：

$$ \begin{aligned} I_{x}(x,y) &= I(x+1,y) - I(x,y), \\ I_{y}(x,y) &= I(x,y+1) - I(x,y). \end{aligned} $$

二阶差分：

$$ \begin{aligned} I_{xx}(x,y) &= I(x+2,y) - 2I(x+1,y) + I(x,y) \\ &= I(x+1,y) - 2I(x,y) + I(x-1,y), \\ I_{yy}(x,y) &= I(x,y+1) - 2I(x,y) + I(x,y-1). \end{aligned} $$

因此拉普拉斯算子为：

$$ \nabla^2 I(x,y) = I_{xx}(x,y) + I_{yy}(x,y). $$

其卷积核为（四邻域模板）：

$$ \begin{pmatrix} 0 & \;1 & 0 \\ 1 & -4 & 1 \\ 0 & \;1 & 0 \end{pmatrix} $$

八邻域模板为：

$$ \begin{pmatrix} 1 & 1 & 1 \\ 1 & -8 & 1 \\ 1 & 1 & 1 \end{pmatrix} $$

算法基本流程为:

判断图像中心像素灰度值与它周围其他像素的灰度值，如果中心像素的灰度更高，则提升中心像素的灰度；反之降低中心像素的灰度，从而实现图像锐化操作;
在算法实现过程中，Laplacian算子通过对邻域中心像素的四方向或八方向求梯度，再将梯度相加起来判断中心像素灰度与邻域内其他像素灰度的关系；
最后通过梯度运算的结果对像素灰度进行调整。

基本规律：

当邻域内像素灰度相同时，模板的卷积运算结果为0；
当中心像素灰度高于邻域内其他像素的平均灰度时，模板的卷积运算结果为正数；
当中心像素的灰度低于邻域内其他像素的平均灰度时，模板的卷积为负数。对卷积运算的结果用适当的衰弱因子处理并加在原中心像素上，就可以实现图像的锐化处理。

2.4MAX-MIN滤波器

MAX-MIN滤波器是一种常见的边缘检测滤波器，其使用网格内像素的最大值和最小值的差值对网格内像素重新赋值。

PyQt5

Fri, 22 Aug 2025 20:41:39 +0800

PyQt5能干什么

PyQt5的主要作用是创建UI界面，同时支持鼠标以及键盘的交互，不仅提供界面控件，还提供网络、数据库、多媒体等应用开发功能，具体来说：

UI控件（Widgets）：

最基础也是最重要的，提供大量开箱即用的的UI元素，可以像搭积木一样构建界面

基础控件：按钮（QPushButton）、标签（QLabel）、文本框（QLineEdit）、文本域（QTextEdit）、组合框（QComboBox）、列表（QListWidget）、表格（QTableWidget）等。
布局管理器：水平布局（QHBoxLayout）、垂直布局（QVBoxLayout）、网格布局（QGridLayout）等，用于自动排列和调整控件大小，确保窗口缩放时界面依然美观。
高级容器：选项卡（QTabWidget）、分组框（QGroupBox）、滚动区域（QScrollArea）、堆叠窗口（QStackedWidget）、停靠窗口（QDockWidget）等，用于组织复杂的界面结构。
主窗口框架：QMainWindow 类提供了标准应用程序主窗口的功能，包括菜单栏（QMenuBar）、工具栏（QToolBar）、状态栏（QStatusBar）和中心部件。

图形与视图框架：

处理大量的、交互式的2D图形对象，适合开发绘图软件、数据可视化、游戏编辑器。核心组件有：QGraphicsScene（场景，管理所有图形项）、QGraphicsView（视图，用于显示场景）、QGraphicsItem（图形项，如矩形、椭圆、自定义图形）

多媒体功能

音频播放：使用 QMediaPlayer 和 QAudioOutput 播放音频文件。
视频播放：使用 QMediaPlayer 和 QVideoWidget 播放视频文件。
摄像头访问：使用 QCamera 来捕获实时摄像头画面。

网络功能

HTTP/HTTPS 请求：通过 QNetworkAccessManager 进行网络通信，支持 GET、POST 等操作，比 Python 标准的 urllib 更强大、更易用。
TCP/UDP 通信：提供了 QTcpSocket, QTcpServer, QUdpSocket 等类，用于开发低层的网络应用，如聊天程序、自定义协议客户端/服务器。
WebSocket：支持现代 WebSocket 协议。

数据库连接

通过 QtSql 模块提供了统一的接口来操作各种数据库，如 SQLite、MySQL、PostgreSQL、ODBC 等。
内置了非常方便的模型/视图类（如 QSqlTableModel），可以轻松地将数据库中的表与UI控件（如 QTableView）绑定，实现数据的自动显示和编辑。

多线程（QThread）

桌面应用的UI主线程必须保持响应，否则会“卡住”。PyQt5 提供了 QThread 类，可以轻松地将耗时的操作（如下载文件、复杂计算）放到子线程中运行，并通过信号（Signal）与槽（Slot） 机制与主线程通信，更新UI进度，保证程序的流畅性

样式与主题（QSS - Qt Style Sheets）

类似于 Web 开发中的 CSS，你可以使用 QSS 来极大地美化应用程序的界面，可以轻松地自定义控件的外观、颜色、字体、边框、背景等，从而打造出独一无二的、现代化的UI风格，而无需修改代码逻辑

基本控件介绍

QMainWindow：

主窗口类（主界面），可以包含菜单栏、工具栏、状态栏、中心窗口等各种窗口部件，其中中心窗口是最重要的，可以是任何Qt窗口部件，常用成员函数：

setCentralWidget():设置中心窗口部件
setMenuBar():设置菜单栏
addToolBar():添加工具栏
statusBar():获取状态栏
show():显示主窗口

Qwidget:

是Qt框架中所有用户界面的基类，包括窗口、对话框、按钮、标签、文本框等，此外还提供一些基本的用户界面功能，例如绘制、事件处理、布局等。

QWidget提供了一些常用的属性和方法，例如size()、pos()、setWindowTitle()等，以便于管理和操作界面部件。

在创建自定义用户界面部件时，我们可以从QWidget派生出我们自己的部件类，并通过重载其成员函数来实现自定义行为。例如，我们可以通过重载QWidget的paintEvent()函数来绘制自己的部件，或者通过重载其mousePressEvent()函数来处理鼠标点击事件

QMain Window、Qwidget、QDialog的区别：

QDialog: 是对话窗口的基类，没有菜单栏、工具栏、状态栏。 QMainWindow：可以包含菜单栏、工具栏、状态栏和标题栏，是最常见的形式。 QWidget: 不确定窗口的用途，就使用Qwidget。

Spacers控件

用于布局的空白控件，在布局中创建空白区域来分隔其它控件，空白区域的大小由其内部设置size_policy控制。

该控件有两种类型：水平（QSpacerItem）和垂直（QSpacerItem），可以使用QHBoxLayout或QVBoxLayout将Spacer控件添加到布局中。在添加Spacer控件时，您可以指定其最小大小、最大大小和首选大小，以及其大小策略

Qlabel控件

显示文本或图像的控件，它通常被用于显示静态文本信息，可以通过设置其文本、字体、颜色、对齐方式等属性来自定义标签的样式和布局。可以将QLabel放置在主窗口、对话框或其他控件上，以便在应用程序中提供帮助文本、说明、状态消息等。

方法：

setText(text): 设置文本内容
setPixmap(pixmap): 设置图像内容
setAlignment(alignment): 设置文本或图像的对齐方式
setWordWrap( on): 当文本过长时是否自动换行
setFixedSize(width, height): 设置控件的固定大小
setStyleSheet(styleSheet): 设置控件的样式表

属性：

text(): 返回控件的文本内容
pixmap(): 返回控件的图像内容
alignment(): 返回控件的对齐方式
wordWrap(): 返回控件是否自动换行
font(): 返回控件的字体
color(): 返回控件的颜色

常用信号：

linkActivated:当控件中包含超链接时，用户单击链接时触发此信号。
linkHovered:当用户将鼠标悬停在超链接上时，触发此信号。
linkPressed:当用户按下并释放鼠标按钮时，同时鼠标位于超链接上时，触发此信号。

综合案例

import sys
from PyQt5.QtWidgets import (QApplication, QWidget, QLabel, QVBoxLayout, QLineEdit, 
                             QPushButton, QHBoxLayout, QFrame)
from PyQt5.QtCore import Qt, QTimer, pyqtSignal
from PyQt5.QtGui import QFont, QPalette, QColor, QPixmap, QLinearGradient, QBrush

# 自定义可点击QLabel（支持点击信号）
class ClickableLabel(QLabel):
    clicked = pyqtSignal()  # 自定义点击信号

    def __init__(self, text="", parent=None):
        super().__init__(text, parent)
        self.setCursor(Qt.PointingHandCursor)  # 设置手型光标

    def mousePressEvent(self, event):
        if event.button() == Qt.LeftButton:
            self.clicked.emit()  # 发射信号
        super().mousePressEvent(event)

class IntegratedDemo(QWidget):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("QLabel功能集成示例")
        self.setGeometry(300, 300, 600, 500)
        self.initUI()
        
    def initUI(self):
        main_layout = QVBoxLayout()
        
        # ===== 1. 基础属性展示 =====
        frame1 = QFrame()
        frame1.setFrameShape(QFrame.Box)
        layout1 = QVBoxLayout()
        
        label_base = QLabel("基础属性示例：自定义字体/颜色/对齐")
        label_base.setFont(QFont("微软雅黑", 12, QFont.Bold))
        label_base.setStyleSheet("color: #FF0000; background-color: #FFFFCC;")
        label_base.setAlignment(Qt.AlignCenter)
        label_base.setFixedHeight(40)
        
        layout1.addWidget(label_base)
        frame1.setLayout(layout1)
        main_layout.addWidget(frame1)
        
        # ===== 2. 交互功能区域 =====
        frame2 = QFrame()
        frame2.setFrameShape(QFrame.Box)
        layout2 = QVBoxLayout()
        
        # 超链接交互
        link_label = QLabel('<a href="https://www.qt.io">访问Qt官网（悬停提示）</a>')
        link_label.setToolTip("点击打开Qt官方网站")
        link_label.linkHovered.connect(lambda link: print(f"链接悬停: {link}"))
        link_label.linkActivated.connect(self.open_link)
        
        # 自定义点击标签
        click_label = ClickableLabel("✨ 点我切换颜色（可点击标签）")
        click_label.setStyleSheet("border: 2px solid #9999FF; padding: 10px;")
        click_label.clicked.connect(self.toggle_label_color)
        
        layout2.addWidget(QLabel("交互功能区域："))
        layout2.addWidget(link_label)
        layout2.addWidget(click_label)
        frame2.setLayout(layout2)
        main_layout.addWidget(frame2)
        
        # ===== 3. 实时同步区域 =====
        frame3 = QFrame()
        frame3.setFrameShape(QFrame.Box)
        layout3 = QVBoxLayout()
        
        self.sync_lineedit = QLineEdit()
        self.sync_label = QLabel("同步显示文本")
        
        # 实时连接信号与槽
        self.sync_lineedit.textChanged.connect(self.sync_label.setText)
        
        layout3.addWidget(QLabel("实时同步：输入即更新"))
        layout3.addWidget(self.sync_lineedit)
        layout3.addWidget(self.sync_label)
        frame3.setLayout(layout3)
        main_layout.addWidget(frame3)
        
        # ===== 4. 动态效果区域 =====
        frame4 = QFrame()
        frame4.setFrameShape(QFrame.Box)
        layout4 = QVBoxLayout()
        
        # 充电进度效果
        self.charge_label = QLabel()
        self.charge_label.setFixedHeight(30)
        self.charge_label.setText("充电中: 0%")
        self.charge_label.setAlignment(Qt.AlignCenter)
        
        # 点击变色效果
        self.color_label = QLabel("点击下方按钮变色")
        self.color_label.setAlignment(Qt.AlignCenter)
        self.color_label.setFixedHeight(50)
        
        # 控制按钮
        btn_toggle = QPushButton("启动充电动画")
        btn_toggle.clicked.connect(self.toggle_charge_animation)
        btn_color = QPushButton("随机颜色")
        btn_color.clicked.connect(self.change_random_color)
        
        btn_layout = QHBoxLayout()
        btn_layout.addWidget(btn_toggle)
        btn_layout.addWidget(btn_color)
        
        layout4.addWidget(QLabel("动态效果区域："))
        layout4.addWidget(self.charge_label)
        layout4.addWidget(self.color_label)
        layout4.addLayout(btn_layout)
        frame4.setLayout(layout4)
        main_layout.addWidget(frame4)
        
        self.setLayout(main_layout)
        
        # 充电动画控制
        self.charge_timer = QTimer()
        self.charge_timer.timeout.connect(self.update_charge)
        self.charge_percent = 0
        self.is_charging = False

    # ===== 功能实现方法 =====
    def open_link(self, url):
        print(f"打开链接: {url}")  # 实际应用中可用QDesktopServices打开[1](@ref)
    
    def toggle_label_color(self):
        current_color = self.sender().palette().color(QPalette.Window)
        new_color = QColor("#FFCCFF") if current_color != QColor("#FFCCFF") else QColor("#CCFFFF")
        self.sender().setStyleSheet(f"background-color: {new_color.name()};")
        print("标签点击事件触发")
    
    def toggle_charge_animation(self):
        if not self.is_charging:
            self.charge_timer.start(200)  # 每200ms更新
            self.is_charging = True
        else:
            self.charge_timer.stop()
            self.is_charging = False
    
    def update_charge(self):
        self.charge_percent = (self.charge_percent + 5) % 105
        if self.charge_percent > 100:
            self.charge_label.setText("充电完成!")
            self.charge_timer.stop()
            self.is_charging = False
            return
        
        # 创建渐变进度条
        gradient = QLinearGradient(0, 0, self.charge_label.width(), 0)
        gradient.setColorAt(0, "#00FF00")
        gradient.setColorAt(self.charge_percent/100, "#00FF00")
        gradient.setColorAt(min(1.0, self.charge_percent/100 + 0.01), "#CCCCCC")
        
        # 应用渐变背景
        palette = self.charge_label.palette()
        palette.setBrush(QPalette.Window, QBrush(gradient))
        self.charge_label.setPalette(palette)
        self.charge_label.setText(f"充电中: {self.charge_percent}%")
    
    def change_random_color(self):
        color = QColor(randint(0,255), randint(0,255), randint(0,255))
        self.color_label.setStyleSheet(f"background-color: {color.name()}; color: white;")

if __name__ == "__main__":
    from random import randint
    app = QApplication(sys.argv)
    window = IntegratedDemo()
    window.show()
    sys.exit(app.exec_())

QLineEdit控件

该控件用于接收用户输入的单行文本编辑，允许输入和编辑文本信息；同时也可以限定输入内容的形式比如只允许输入数字、字母或特定字符，或者限定输入内容长度；可以使用信号和槽机制来处理用户输入的文本，以便在应用程序中执行特定的操作或验证用户输入的有效性。

方法：

setAlignment(alignment)：设置文本的对齐方式，alignment可以是Qt.AlignLeft、Qt.AlignRight、Qt.AlignCenter等值之一
setPlaceholderText(text)：设置控件的占位符文本，当控件没有内容时显示的文本
setReadOnly(readOnly)：设置控件是否为只读模式
setValidator(validator)：设置控件的输入验证器，用于限制用户输入的内容
textChanged.connect(slot)：文本改变时的信号，连接到相应的槽函数

属性：

text()：获取或设置控件的文本内容
setText(text)：设置控件的文本内容
clear()：清空控件的文本内容

综合案例

import sys
from PyQt5.QtWidgets import (QApplication, QWidget, QVBoxLayout, QLineEdit, QLabel, 
                            QPushButton, QHBoxLayout, QFormLayout, QCompleter)
from PyQt5.QtGui import QIntValidator, QDoubleValidator, QRegularExpressionValidator, QFont, QIcon
from PyQt5.QtCore import Qt, QRegularExpression

class LineEditDemo(QWidget):
    def __init__(self):
        super().__init__()
        self.initUI()
        
    def initUI(self):
        self.setWindowTitle("QLineEdit 综合功能演示")
        self.setGeometry(300, 300, 600, 450)
        layout = QVBoxLayout()
        
        # ===== 1. 基础功能区域 =====
        base_layout = QFormLayout()
        
        # 基础文本输入（实时反馈）
        self.basic_edit = QLineEdit()
        self.basic_edit.setPlaceholderText("输入实时显示在右侧")
        self.basic_label = QLabel("等待输入...")
        self.basic_edit.textChanged.connect(lambda: self.basic_label.setText(self.basic_edit.text()))
        base_layout.addRow("基础输入:", self.basic_edit)
        base_layout.addRow("实时反馈:", self.basic_label)
        
        # 整数验证（范围限制）
        self.int_edit = QLineEdit()
        self.int_edit.setValidator(QIntValidator(1, 100))  # 限制1-100整数
        self.int_edit.setPlaceholderText("输入1-100的整数")
        base_layout.addRow("整数验证:", self.int_edit)
        
        # 浮点数验证（格式限制）
        self.float_edit = QLineEdit()
        float_validator = QDoubleValidator(0.0, 100.0, 2)  # 范围0-100，2位小数
        float_validator.setNotation(QDoubleValidator.StandardNotation)
        self.float_edit.setValidator(float_validator)
        self.float_edit.setPlaceholderText("0.00-100.00")
        base_layout.addRow("浮点数验证:", self.float_edit)
        
        layout.addLayout(base_layout)
        
        # ===== 2. 高级功能区域 =====
        adv_layout = QFormLayout()
        
        # 正则表达式验证（邮箱格式）
        self.email_edit = QLineEdit()
        email_regex = QRegularExpression("^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$")
        self.email_edit.setValidator(QRegularExpressionValidator(email_regex))
        self.email_edit.setPlaceholderText("example@domain.com")
        adv_layout.addRow("邮箱验证:", self.email_edit)
        
        # 输入掩码（电话号码）
        self.phone_edit = QLineEdit()
        self.phone_edit.setInputMask("999-9999-9999;#")  # 格式: 138-8888-8888
        adv_layout.addRow("电话掩码:", self.phone_edit)
        
        # 密码输入（显示切换）
        self.pwd_layout = QHBoxLayout()
        self.pwd_edit = QLineEdit()
        self.pwd_edit.setEchoMode(QLineEdit.Password)
        self.toggle_btn = QPushButton("显示")
        self.toggle_btn.setCheckable(True)
        self.toggle_btn.toggled.connect(self.toggle_pwd_visibility)
        self.pwd_layout.addWidget(self.pwd_edit)
        self.pwd_layout.addWidget(self.toggle_btn)
        adv_layout.addRow("密码输入:", self.pwd_layout)
        
        # 自动补全
        self.auto_edit = QLineEdit()
        completer = QCompleter(["Python", "Java", "C++", "JavaScript"])
        self.auto_edit.setCompleter(completer)
        self.auto_edit.setPlaceholderText("输入编程语言")
        adv_layout.addRow("自动补全:", self.auto_edit)
        
        layout.addLayout(adv_layout)
        
        # ===== 3. 交互反馈区域 =====
        feedback_layout = QHBoxLayout()
        
        # 清除按钮
        self.clear_edit = QLineEdit()
        self.clear_edit.setClearButtonEnabled(True)  # 启用内置清除按钮
        self.clear_edit.setPlaceholderText("输入后点击右侧X清除")
        feedback_layout.addWidget(QLabel("清除按钮:"))
        feedback_layout.addWidget(self.clear_edit)
        
        # 样式反馈
        self.style_edit = QLineEdit()
        self.style_edit.setPlaceholderText("输入'error'触发红色边框")
        self.style_edit.textChanged.connect(self.update_style)
        feedback_layout.addWidget(QLabel("动态样式:"))
        feedback_layout.addWidget(self.style_edit)
        
        layout.addLayout(feedback_layout)
        
        # ===== 4. 自定义操作按钮 =====
        action_layout = QHBoxLayout()
        self.action_edit = QLineEdit()
        self.action_edit.setPlaceholderText("右侧按钮可转为大写")
        
        # 添加自定义动作按钮
        upper_btn = QPushButton("⇧")
        upper_btn.clicked.connect(lambda: self.action_edit.setText(self.action_edit.text().upper()))
        action_layout.addWidget(QLabel("动作按钮:"))
        action_layout.addWidget(self.action_edit)
        action_layout.addWidget(upper_btn)
        
        layout.addLayout(action_layout)
        self.setLayout(layout)

    # ===== 功能实现方法 =====
    def toggle_pwd_visibility(self, checked):
        """切换密码显示/隐藏"""
        if checked:
            self.pwd_edit.setEchoMode(QLineEdit.Normal)
            self.toggle_btn.setText("隐藏")
        else:
            self.pwd_edit.setEchoMode(QLineEdit.Password)
            self.toggle_btn.setText("显示")

    def update_style(self, text):
        """根据输入内容动态更新样式"""
        if "error" in text.lower():
            self.style_edit.setStyleSheet("border: 2px solid red;")
        else:
            self.style_edit.setStyleSheet("")

if __name__ == '__main__':
    app = QApplication(sys.argv)
    demo = LineEditDemo()
    demo.show()
    sys.exit(app.exec_())

QTextEdit

该控件可以用于显示和编辑富文本的多行文本编辑控件。它可以用于创建编辑器、日记、HTML文本查看器等。可以在文本中插入多媒体内容，如图像、超链接、HTML表格等，并且可以在文本中使用样式来设置字体、颜色、背景、对齐等。QTextEdit还支持拼写检查、撤销/重做、自动缩进、文本选择等基本编辑功能

综合案例

import sys
from PyQt5.QtWidgets import (QApplication, QMainWindow, QTextEdit, QAction, QFileDialog, 
                            QToolBar, QStatusBar, QMessageBox, QColorDialog, QFontDialog)
from PyQt5.QtGui import QTextCursor, QTextCharFormat, QFont, QTextBlockFormat, QIcon, QPixmap
from PyQt5.QtCore import Qt

class RichTextEditor(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("QTextEdit 综合案例 - 富文本编辑器")
        self.setGeometry(300, 200, 900, 600)
        self.file_path = None
        self.init_ui()
        
    def init_ui(self):
        # ===== 1. 核心控件：QTextEdit =====
        self.text_edit = QTextEdit()
        self.text_edit.setAcceptRichText(True)  # 启用富文本支持
        self.text_edit.setPlaceholderText("输入内容或使用工具栏进行操作...")
        self.setCentralWidget(self.text_edit)
        
        # ===== 2. 菜单栏 =====
        self.create_menus()
        
        # ===== 3. 工具栏 =====
        toolbar = QToolBar("格式工具栏")
        self.addToolBar(toolbar)
        
        # 文本样式动作 - 使用文本代替图标
        bold_action = QAction("B", self)  # 使用文本代替图标
        bold_action.setToolTip("加粗")
        bold_action.triggered.connect(lambda: self.set_text_format("bold"))
        toolbar.addAction(bold_action)
        
        italic_action = QAction("I", self)
        italic_action.setToolTip("斜体")
        italic_action.triggered.connect(lambda: self.set_text_format("italic"))
        toolbar.addAction(italic_action)
        
        underline_action = QAction("U", self)
        underline_action.setToolTip("下划线")
        underline_action.triggered.connect(lambda: self.set_text_format("underline"))
        toolbar.addAction(underline_action)
        
        toolbar.addSeparator()
        
        # 字体选择
        font_action = QAction("字体", self)
        font_action.triggered.connect(self.choose_font)
        toolbar.addAction(font_action)
        
        # 颜色选择
        color_action = QAction("颜色", self)
        color_action.triggered.connect(self.choose_color)
        toolbar.addAction(color_action)
        
        toolbar.addSeparator()
        
        # 段落对齐
        align_left = QAction("左对齐", self)
        align_left.triggered.connect(lambda: self.set_alignment(Qt.AlignLeft))
        toolbar.addAction(align_left)
        
        align_center = QAction("居中", self)
        align_center.triggered.connect(lambda: self.set_alignment(Qt.AlignCenter))
        toolbar.addAction(align_center)
        
        align_right = QAction("右对齐", self)
        align_right.triggered.connect(lambda: self.set_alignment(Qt.AlignRight))
        toolbar.addAction(align_right)
        
        toolbar.addSeparator()
        
        # 插入功能
        insert_image = QAction("插入图片", self)
        insert_image.triggered.connect(self.insert_image)
        toolbar.addAction(insert_image)
        
        insert_link = QAction("插入链接", self)
        insert_link.triggered.connect(self.insert_link)
        toolbar.addAction(insert_link)
        
        # ===== 4. 状态栏 =====
        self.status_bar = QStatusBar()
        self.setStatusBar(self.status_bar)
        self.text_edit.textChanged.connect(self.update_status_bar)
        
        # ===== 5. 信号连接 =====
        self.text_edit.cursorPositionChanged.connect(self.cursor_position_changed)
        self.text_edit.selectionChanged.connect(self.selection_changed)
        
    def create_menus(self):
        menubar = self.menuBar()
        
        # 文件菜单
        file_menu = menubar.addMenu("文件")
        
        new_action = QAction("新建", self)
        new_action.setShortcut("Ctrl+N")
        new_action.triggered.connect(self.new_file)
        file_menu.addAction(new_action)
        
        open_action = QAction("打开", self)
        open_action.setShortcut("Ctrl+O")
        open_action.triggered.connect(self.open_file)
        file_menu.addAction(open_action)
        
        save_action = QAction("保存", self)
        save_action.setShortcut("Ctrl+S")
        save_action.triggered.connect(self.save_file)
        file_menu.addAction(save_action)
        
        save_as_action = QAction("另存为", self)
        save_as_action.triggered.connect(self.save_file_as)
        file_menu.addAction(save_as_action)
        
        file_menu.addSeparator()
        
        exit_action = QAction("退出", self)
        exit_action.setShortcut("Ctrl+Q")
        exit_action.triggered.connect(self.close)
        file_menu.addAction(exit_action)
        
        # 编辑菜单
        edit_menu = menubar.addMenu("编辑")
        
        undo_action = QAction("撤销", self)
        undo_action.setShortcut("Ctrl+Z")
        undo_action.triggered.connect(self.text_edit.undo)
        edit_menu.addAction(undo_action)
        
        redo_action = QAction("重做", self)
        redo_action.setShortcut("Ctrl+Y")
        redo_action.triggered.connect(self.text_edit.redo)
        edit_menu.addAction(redo_action)
        
        edit_menu.addSeparator()
        
        cut_action = QAction("剪切", self)
        cut_action.setShortcut("Ctrl+X")
        cut_action.triggered.connect(self.text_edit.cut)
        edit_menu.addAction(cut_action)
        
        copy_action = QAction("复制", self)
        copy_action.setShortcut("Ctrl+C")
        copy_action.triggered.connect(self.text_edit.copy)
        edit_menu.addAction(copy_action)
        
        paste_action = QAction("粘贴", self)
        paste_action.setShortcut("Ctrl+V")
        paste_action.triggered.connect(self.text_edit.paste)
        edit_menu.addAction(paste_action)
        
        # 视图菜单
        view_menu = menubar.addMenu("视图")
        
        readonly_action = QAction("只读模式", self, checkable=True)
        readonly_action.toggled.connect(self.toggle_readonly)
        view_menu.addAction(readonly_action)
        
        # 大文件优化功能
        large_file_action = QAction("加载大文件(分页)", self)
        large_file_action.triggered.connect(self.load_large_file)
        view_menu.addAction(large_file_action)

    # ===== 功能实现方法 =====
    def set_text_format(self, style):
        """设置文本格式（加粗/斜体/下划线）"""
        cursor = self.text_edit.textCursor()
        if not cursor.hasSelection():
            # 如果没有选择文本，则对即将输入的文本应用格式
            format = QTextCharFormat()
            if style == "bold":
                format.setFontWeight(QFont.Bold if not self.text_edit.fontWeight() == QFont.Bold else QFont.Normal)
            elif style == "italic":
                format.setFontItalic(not self.text_edit.fontItalic())
            elif style == "underline":
                format.setFontUnderline(not self.text_edit.fontUnderline())
                
            self.text_edit.setCurrentCharFormat(format)
            return
            
        fmt = QTextCharFormat()
        if style == "bold":
            fmt.setFontWeight(QFont.Bold if not cursor.charFormat().font().bold() else QFont.Normal)
        elif style == "italic":
            fmt.setFontItalic(not cursor.charFormat().fontItalic())
        elif style == "underline":
            fmt.setFontUnderline(not cursor.charFormat().fontUnderline())
        cursor.mergeCharFormat(fmt)

    def choose_font(self):
        """选择字体"""
        font, ok = QFontDialog.getFont(self.text_edit.font(), self)
        if ok:
            self.text_edit.setCurrentFont(font)

    def choose_color(self):
        """选择颜色"""
        color = QColorDialog.getColor()
        if color.isValid():
            self.text_edit.setTextColor(color)

    def set_alignment(self, alignment):
        """设置段落对齐方式"""
        cursor = self.text_edit.textCursor()
        block_fmt = QTextBlockFormat()
        block_fmt.setAlignment(alignment)
        cursor.mergeBlockFormat(block_fmt)

    def insert_image(self):
        """插入图片到光标位置"""
        file_path, _ = QFileDialog.getOpenFileName(
            self, "选择图片", "", "图片文件 (*.png *.jpg *.jpeg *.bmp *.gif)"
        )
        if file_path:
            cursor = self.text_edit.textCursor()
            # 使用QPixmap加载图片并插入
            pixmap = QPixmap(file_path)
            if not pixmap.isNull():
                # 缩放图片以适应编辑器宽度
                pixmap = pixmap.scaledToWidth(300, Qt.SmoothTransformation)
                cursor.insertImage(pixmap.toImage())

    def insert_link(self):
        """插入超链接"""
        from PyQt5.QtWidgets import QInputDialog
        
        text, ok = QInputDialog.getText(self, "插入链接", "请输入链接URL:")
        if ok and text:
            cursor = self.text_edit.textCursor()
            # 如果选择了文本，使用选中文本作为链接文本，否则使用URL
            if cursor.hasSelection():
                link_text = cursor.selectedText()
            else:
                link_text = text
                
            cursor.insertHtml(f'<a href="{text}">{link_text}</a>')

    def new_file(self):
        """新建文件"""
        if self.check_unsaved_changes():
            self.text_edit.clear()
            self.file_path = None
            self.setWindowTitle("QTextEdit 综合案例 - 富文本编辑器")

    def open_file(self):
        """打开文件"""
        if not self.check_unsaved_changes():
            return
            
        path, _ = QFileDialog.getOpenFileName(
            self, "打开文件", "", 
            "文本文件 (*.txt);;HTML文件 (*.html *.htm);;所有文件 (*)"
        )
        if path:
            try:
                with open(path, 'r', encoding='utf-8') as f:
                    if path.endswith(('.html', '.htm')):
                        self.text_edit.setHtml(f.read())
                    else:
                        self.text_edit.setPlainText(f.read())
                self.file_path = path
                self.setWindowTitle(f"QTextEdit 综合案例 - {path}")
            except Exception as e:
                QMessageBox.critical(self, "打开错误", f"打开文件时出错:\n{str(e)}")

    def save_file(self):
        """保存文件"""
        if self.file_path:
            self._save_to_file(self.file_path)
        else:
            self.save_file_as()

    def save_file_as(self):
        """另存为文件"""
        path, _ = QFileDialog.getSaveFileName(
            self, "保存文件", "", 
            "文本文件 (*.txt);;HTML文件 (*.html);;所有文件 (*)"
        )
        if path:
            self._save_to_file(path)
            self.file_path = path
            self.setWindowTitle(f"QTextEdit 综合案例 - {path}")

    def _save_to_file(self, path):
        """实际保存操作"""
        try:
            with open(path, 'w', encoding='utf-8') as f:
                if path.endswith('.html'):
                    f.write(self.text_edit.toHtml())
                else:
                    f.write(self.text_edit.toPlainText())
            self.text_edit.document().setModified(False)
            self.status_bar.showMessage(f"文件已保存: {path}", 3000)
        except Exception as e:
            QMessageBox.critical(self, "保存错误", f"保存文件时出错:\n{str(e)}")

    def toggle_readonly(self, state):
        """切换只读模式"""
        self.text_edit.setReadOnly(state)
        self.status_bar.showMessage(f"只读模式: {'开启' if state else '关闭'}", 2000)

    def update_status_bar(self):
        """更新状态栏统计信息"""
        text = self.text_edit.toPlainText()
        char_count = len(text)
        word_count = len(text.split())
        line_count = self.text_edit.document().blockCount()
        self.status_bar.showMessage(f"字符: {char_count} | 单词: {word_count} | 行数: {line_count}")

    def cursor_position_changed(self):
        """光标位置变化时显示行列号"""
        cursor = self.text_edit.textCursor()
        line = cursor.blockNumber() + 1
        col = cursor.columnNumber() + 1
        self.status_bar.showMessage(f"行: {line}, 列: {col}", 2000)

    def selection_changed(self):
        """文本选中时显示选中信息"""
        cursor = self.text_edit.textCursor()
        if cursor.hasSelection():
            selected = cursor.selectedText()
            self.status_bar.showMessage(f"已选: {len(selected)} 字符", 2000)

    def load_large_file(self):
        """大文件分页加载优化"""
        path, _ = QFileDialog.getOpenFileName(self, "打开大文件", "", "文本文件 (*.txt)")
        if not path:
            return
            
        # 大文件优化：只加载最后100行
        try:
            with open(path, 'r', encoding='utf-8', errors='ignore') as f:
                lines = []
                # 高效读取最后100行
                for line in f:
                    lines.append(line)
                    if len(lines) > 100:
                        lines.pop(0)
                
                self.text_edit.setPlainText(''.join(lines))
            self.status_bar.showMessage(f"已加载大文件最后100行: {path}", 5000)
        except Exception as e:
            QMessageBox.critical(self, "文件错误", f"读取文件失败:\n{str(e)}")

    def check_unsaved_changes(self):
        """检查未保存的更改"""
        if self.text_edit.document().isModified():
            reply = QMessageBox.question(self, "未保存更改", 
                                        "当前文档有未保存的更改。是否保存？",
                                        QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel)
            if reply == QMessageBox.Save:
                self.save_file()
                return True
            elif reply == QMessageBox.Cancel:
                return False
        return True

if __name__ == '__main__':
    app = QApplication(sys.argv)
    editor = RichTextEditor()
    editor.show()
    sys.exit(app.exec_())

QDialog

该控件是常用的对话窗口，为QWidget的子类，例如询问用户是否需要保存文件，输入数据或显示一些信息，可以设置对话框的标题、大小、位置等属性，也可以添加各种控件，例如标签、按钮、文本框等，可以捕获对话框关闭事件和其他事件，可以返回一些数据或响应用户的操作。

方法：

exec_()：将对话框设置为模态并运行对话框的事件循环，直到对话框被关闭。此方法通常用于从对话框中获取一些数据或响应用户的操作。
show()：显示对话框，但不将其设置为模态。此方法通常用于显示一些信息或提供一些选项。
done(int result)：设置对话框的返回值，并关闭对话框。此方法通常在用户进行某些操作后调用，以便通知调用方对话框的结果。
accept()：设置对话框的返回值为QDialog.Accepted，并关闭对话框。此方法通常在用户确认某些操作后调用，以便通知调用方对话框的结果。
ect()：设置对话框的返回值为QDialog.Rejected，并关闭对话框。此方法通常在用户取消某些操作后调用，以便通知调用方对话框的结果。
setButtonLayout(list)：设置对话框底部的按钮布局。参数list应该是一个QDialogButtonBox中定义的一组按钮类型，例如QDialogButtonBox.Ok | QDialogButtonBox.Cancel
open()：将对话框设置为模态并运行对话框的事件循环，直到对话框被关闭。此方法与exec_()方法类似，但可以方便地打开多个对话框

除了上述方法外，QDialog还提供了一些其他方法，例如resize()、move()、close()、setVisible()等，这些方法与QWidget类似，用于设置对话框的大小、位置、可见性等

属性：

windowTitle：对话框的标题
windowIcon：对话框的图标
sizeGripEnabled：是否显示调整大小的手柄，默认为False
layout：对话框的布局管理器，用于控制对话框内部控件的位置和大小
modal：是否将对话框设置为模态，即禁止用户与其他窗口交互，直到对话框被关闭，默认为True。
result：对话框的返回值，通常用于表示用户的操作或输入。如果对话框是通过exec_()方法调用的，则返回值是对话框的退出码（通常是QDialog.Accepted或QDialog.Rejected）；如果对话框是通过show()方法调用的，则返回值始终是None
sizeHint：对话框的推荐大小。
acceptMode：对话框的接受模式，可以是QFileDialog.AcceptOpen（打开文件）、QFileDialog.AcceptSave（保存文件）或QFileDialog.AcceptSave（选择文件夹）
rejectAction：当用户按下Esc键或者点击“取消”按钮时，对话框执行的操作。默认情况下，对话框将执行reject()方法并关闭

信号：

finished(int result)：当对话框关闭并且返回值已经设置时发出。参数result表示对话框的返回值
accepted()：当用户确认某些操作并调用accept()方法时发出
rejected()：当用户取消某些操作并调用reject()方法时发出
resizeEvent(event)：当对话框的大小改变时发出。可以重写此方法来执行一些特定的操作

几种类型

普通对话框(QDialog)：最基本的对话框类型，用于显示消息、获取输入、提供选项等。它可以通过设置各种属性和使用布局管理器来控制对话框的大小、位置和内容
文件对话框(QFileDialog)：用于选择文件或文件夹的对话框。可以使用QFileDialog的静态方法创建各种类型的文件对话框，例如打开文件对话框、保存文件对话框、选择文件夹对话框等。
字体对话框(QFontDialog)：用于选择字体和字号的对话框。可以使用QFontDialog的静态方法创建字体对话框。
颜色对话框(QColorDialog)：用于选择颜色的对话框。可以使用QColorDialog的静态方法创建颜色对话框。
输入对话框(QInputDialog)：用于获取用户输入的对话框。可以使用QInputDialog的静态方法创建各种类型的输入对话框，例如文本输入对话框、整数输入对话框、浮点数输入对话框等。
消息框(QMessageBox)：用于显示消息和提供选项的对话框。可以使用QMessageBox的静态方法创建各种类型的消息框，例如信息框、警告框、错误框、询问框等.
鼠标指针对话框(QCursor)：用于显示不同类型的鼠标指针。可以使用QCursor的静态方法创建各种类型的鼠标指针对话框，例如箭头、十字形、等待指针等。

综合案例

import sys
import os
from PyQt5.QtWidgets import (QApplication, QDialog, QVBoxLayout, QHBoxLayout, 
                             QTextEdit, QPushButton, QMenuBar, QMenu, QAction, 
                             QFileDialog, QFontDialog, QInputDialog, QMessageBox)
from PyQt5.QtGui import QTextCursor, QCursor
from PyQt5.QtCore import Qt

class TextEditor(QDialog):
    def __init__(self):
        super().__init__()
        self.current_file = None
        self.init_ui()
        
    def init_ui(self):
        # 设置窗口属性
        self.setWindowTitle('简易文本编辑器 - PyQt5对话框示例')
        self.setGeometry(100, 100, 800, 600)
        
        # 创建主布局
        main_layout = QVBoxLayout()
        
        # 创建菜单栏
        menubar = QMenuBar()
        file_menu = QMenu('文件', self)
        edit_menu = QMenu('编辑', self)
        format_menu = QMenu('格式', self)
        help_menu = QMenu('帮助', self)
        
        # 添加文件菜单动作
        new_action = QAction('新建', self)
        new_action.triggered.connect(self.new_file)
        open_action = QAction('打开', self)
        open_action.triggered.connect(self.open_file)
        save_action = QAction('保存', self)
        save_action.triggered.connect(self.save_file)
        save_as_action = QAction('另存为', self)
        save_as_action.triggered.connect(self.save_as_file)
        exit_action = QAction('退出', self)
        exit_action.triggered.connect(self.close)
        
        file_menu.addAction(new_action)
        file_menu.addAction(open_action)
        file_menu.addAction(save_action)
        file_menu.addAction(save_as_action)
        file_menu.addSeparator()
        file_menu.addAction(exit_action)
        
        # 添加编辑菜单动作
        find_action = QAction('查找', self)
        find_action.triggered.connect(self.find_text)
        replace_action = QAction('替换', self)
        replace_action.triggered.connect(self.replace_text)
        
        edit_menu.addAction(find_action)
        edit_menu.addAction(replace_action)
        
        # 添加格式菜单动作
        font_action = QAction('字体', self)
        font_action.triggered.connect(self.change_font)
        
        format_menu.addAction(font_action)
        
        # 添加帮助菜单动作
        about_action = QAction('关于', self)
        about_action.triggered.connect(self.show_about)
        
        help_menu.addAction(about_action)
        
        # 将菜单添加到菜单栏
        menubar.addMenu(file_menu)
        menubar.addMenu(edit_menu)
        menubar.addMenu(format_menu)
        menubar.addMenu(help_menu)
        
        # 创建文本编辑区域
        self.text_edit = QTextEdit()
        
        # 创建底部按钮
        button_layout = QHBoxLayout()
        
        clear_btn = QPushButton('清空内容')
        clear_btn.clicked.connect(self.clear_text)
        
        status_btn = QPushButton('统计字数')
        status_btn.clicked.connect(self.count_words)
        
        button_layout.addWidget(clear_btn)
        button_layout.addWidget(status_btn)
        button_layout.addStretch()
        
        # 将组件添加到主布局
        main_layout.setMenuBar(menubar)
        main_layout.addWidget(self.text_edit)
        main_layout.addLayout(button_layout)
        
        self.setLayout(main_layout)
    
    def new_file(self):
        # 使用消息对话框确认是否保存当前文件 [7](@ref)
        if self.text_edit.document().isModified():
            reply = QMessageBox.question(self, '确认', 
                                       '当前文档已修改，是否保存？',
                                       QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel)
            
            if reply == QMessageBox.Save:
                self.save_file()
            elif reply == QMessageBox.Cancel:
                return
        
        self.text_edit.clear()
        self.current_file = None
        self.setWindowTitle('新建文件 - 简易文本编辑器')
    
    def open_file(self):
        # 使用文件对话框选择文件 [1](@ref)
        file_path, _ = QFileDialog.getOpenFileName(self, '打开文件', '', 
                                                 '文本文件 (*.txt);;所有文件 (*)')
        
        if file_path:
            try:
                with open(file_path, 'r', encoding='utf-8') as f:
                    self.text_edit.setText(f.read())
                self.current_file = file_path
                self.setWindowTitle(f'{os.path.basename(file_path)} - 简易文本编辑器')
            except Exception as e:
                QMessageBox.critical(self, '错误', f'无法打开文件: {str(e)}')
    
    def save_file(self):
        if self.current_file:
            try:
                with open(self.current_file, 'w', encoding='utf-8') as f:
                    f.write(self.text_edit.toPlainText())
                self.text_edit.document().setModified(False)
                QMessageBox.information(self, '成功', '文件已保存！')
            except Exception as e:
                QMessageBox.critical(self, '错误', f'无法保存文件: {str(e)}')
        else:
            self.save_as_file()
    
    def save_as_file(self):
        # 使用文件对话框选择保存路径 [1](@ref)
        file_path, _ = QFileDialog.getSaveFileName(self, '另存为', '', 
                                                 '文本文件 (*.txt);;所有文件 (*)')
        
        if file_path:
            try:
                with open(file_path, 'w', encoding='utf-8') as f:
                    f.write(self.text_edit.toPlainText())
                self.current_file = file_path
                self.setWindowTitle(f'{os.path.basename(file_path)} - 简易文本编辑器')
                self.text_edit.document().setModified(False)
                QMessageBox.information(self, '成功', '文件已保存！')
            except Exception as e:
                QMessageBox.critical(self, '错误', f'无法保存文件: {str(e)}')
    
    def find_text(self):
        # 使用输入对话框获取查找内容 [2](@ref)
        text, ok = QInputDialog.getText(self, '查找', '输入要查找的内容:')
        
        if ok and text:
            # 使用QCursor改变光标状态
            QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
            content = self.text_edit.toPlainText()
            if text in content:
                # 定位到找到的文本
                cursor = self.text_edit.textCursor()
                cursor.movePosition(QTextCursor.Start)
                self.text_edit.setTextCursor(cursor)
                
                # 高亮所有匹配项
                self.text_edit.moveCursor(QTextCursor.Start)
                format = self.text_edit.textCursor().charFormat()
                format.setBackground(Qt.yellow)
                
                while self.text_edit.find(text):
                    self.text_edit.textCursor().setCharFormat(format)
                
                QMessageBox.information(self, '查找', f'找到 "{text}"！')
            else:
                QMessageBox.information(self, '查找', f'未找到 "{text}"')
            
            QApplication.restoreOverrideCursor()
    
    def replace_text(self):
        # 使用输入对话框获取替换内容 [2](@ref)
        find_text, ok1 = QInputDialog.getText(self, '替换', '输入要查找的内容:')
        
        if ok1 and find_text:
            replace_text, ok2 = QInputDialog.getText(self, '替换', '输入替换内容:')
            
            if ok2:
                content = self.text_edit.toPlainText()
                if find_text in content:
                    new_content = content.replace(find_text, replace_text)
                    self.text_edit.setPlainText(new_content)
                    QMessageBox.information(self, '替换', '替换完成！')
                else:
                    QMessageBox.information(self, '替换', f'未找到 "{find_text}"')
    
    def change_font(self):
        # 使用字体对话框选择字体 [8](@ref)
        current_font = self.text_edit.currentFont()
        font, ok = QFontDialog.getFont(current_font, self, '选择字体')
        
        if ok:
            self.text_edit.setCurrentFont(font)
    
    def clear_text(self):
        # 使用消息对话框确认清空操作 [7](@ref)
        reply = QMessageBox.question(self, '确认', 
                                   '确定要清空所有内容吗？',
                                   QMessageBox.Yes | QMessageBox.No)
        
        if reply == QMessageBox.Yes:
            self.text_edit.clear()
    
    def count_words(self):
        text = self.text_edit.toPlainText()
        char_count = len(text)
        word_count = len(text.split())
        line_count = text.count('\n') + 1 if text else 0
        
        # 使用消息对话框显示统计结果 [7](@ref)
        QMessageBox.information(self, '统计信息', 
                              f'字符数: {char_count}\n单词数: {word_count}\n行数: {line_count}')
    
    def show_about(self):
        # 使用消息对话框显示关于信息 [7](@ref)
        QMessageBox.about(self, '关于', 
                         '简易文本编辑器\n\n'
                         '演示PyQt5各种对话框的使用:\n'
                         '- QFileDialog: 文件打开和保存\n'
                         '- QFontDialog: 字体选择\n'
                         '- QInputDialog: 文本输入\n'
                         '- QMessageBox: 消息提示\n'
                         '- QCursor: 光标控制')
    
    def closeEvent(self, event):
        # 重写关闭事件，确认是否保存 [7](@ref)
        if self.text_edit.document().isModified():
            reply = QMessageBox.question(self, '确认退出', 
                                       '文档已修改，是否保存？',
                                       QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel)
            
            if reply == QMessageBox.Save:
                self.save_file()
                event.accept()
            elif reply == QMessageBox.Discard:
                event.accept()
            else:
                event.ignore()
        else:
            event.accept()


if __name__ == '__main__':
    app = QApplication(sys.argv)
    editor = TextEditor()
    editor.show()
    sys.exit(app.exec_())

容器

常见的PyQt容器有：

QMainWindow：主窗口容器，通常包含菜单栏、工具栏、状态栏等
QWidget：基本的用户界面元素容器，可以作为其他容器的子容器
QGroupBox：分组框容器，可以将相关的组件放到一个分组框中，使它们更易于组织和查看
QTabWidget：选项卡容器，可以在多个选项卡中放置不同的组件，让用户轻松地在它们之间切换
QStackedWidget：堆栈容器，可以在同一位置上堆叠多个组件，只显示其中的一个，让用户可以轻松地在它们之间切换
QScrollArea：滚动区域容器，当容器中的组件太大，无法在当前视图中完全显示时，可以使用滚动区域容器
QSplitter：拆分器容器，可以将容器水平或垂直拆分为两个或更多子容器，让用户可以自由地调整它们的大小
QToolBar：工具栏容器，可以在主窗口或其他容器中放置多个工具栏，让用户可以快速访问常用功能

QGroupBox使用示例：

import sys
from PyQt5.QtWidgets import (QApplication, QDialog, QVBoxLayout, QHBoxLayout,
                             QGroupBox, QRadioButton, QCheckBox, QPushButton,
                             QLineEdit, QLabel, QComboBox)

class GroupBoxExample(QDialog):
    def __init__(self):
        super().__init__()
        self.setWindowTitle('QGroupBox 示例')
        self.setGeometry(300, 300, 400, 300)
        self.init_ui()
        
    def init_ui(self):
        main_layout = QVBoxLayout()
        
        # 创建第一个分组框 - 单选按钮组
        radio_group = QGroupBox("用户类型")
        radio_layout = QVBoxLayout()
        
        self.student_radio = QRadioButton("学生")
        self.teacher_radio = QRadioButton("教师")
        self.admin_radio = QRadioButton("管理员")
        
        self.student_radio.setChecked(True)
        
        radio_layout.addWidget(self.student_radio)
        radio_layout.addWidget(self.teacher_radio)
        radio_layout.addWidget(self.admin_radio)
        radio_group.setLayout(radio_layout)
        
        # 创建第二个分组框 - 复选框组
        checkbox_group = QGroupBox("兴趣爱好")
        checkbox_layout = QVBoxLayout()
        
        self.reading_check = QCheckBox("阅读")
        self.sports_check = QCheckBox("运动")
        self.music_check = QCheckBox("音乐")
        self.travel_check = QCheckBox("旅行")
        
        checkbox_layout.addWidget(self.reading_check)
        checkbox_layout.addWidget(self.sports_check)
        checkbox_layout.addWidget(self.music_check)
        checkbox_layout.addWidget(self.travel_check)
        checkbox_group.setLayout(checkbox_layout)
        
        # 创建第三个分组框 - 表单输入
        form_group = QGroupBox("个人信息")
        form_layout = QVBoxLayout()
        
        name_layout = QHBoxLayout()
        name_layout.addWidget(QLabel("姓名:"))
        self.name_input = QLineEdit()
        name_layout.addWidget(self.name_input)
        form_layout.addLayout(name_layout)
        
        age_layout = QHBoxLayout()
        age_layout.addWidget(QLabel("年龄:"))
        self.age_combo = QComboBox()
        self.age_combo.addItems([str(i) for i in range(18, 66)])
        age_layout.addWidget(self.age_combo)
        form_layout.addLayout(age_layout)
        
        form_group.setLayout(form_layout)
        
        # 提交按钮
        submit_btn = QPushButton("提交信息")
        submit_btn.clicked.connect(self.show_info)
        
        # 添加到主布局
        main_layout.addWidget(radio_group)
        main_layout.addWidget(checkbox_group)
        main_layout.addWidget(form_group)
        main_layout.addWidget(submit_btn)
        
        self.setLayout(main_layout)
    
    def show_info(self):
        # 获取用户类型
        user_type = "学生" if self.student_radio.isChecked() else \
                   "教师" if self.teacher_radio.isChecked() else "管理员"
        
        # 获取兴趣爱好
        hobbies = []
        if self.reading_check.isChecked(): hobbies.append("阅读")
        if self.sports_check.isChecked(): hobbies.append("运动")
        if self.music_check.isChecked(): hobbies.append("音乐")
        if self.travel_check.isChecked(): hobbies.append("旅行")
        
        # 获取个人信息
        name = self.name_input.text() or "未填写"
        age = self.age_combo.currentText()
        
        # 显示结果
        print(f"用户类型: {user_type}")
        print(f"姓名: {name}, 年龄: {age}")
        print(f"兴趣爱好: {', '.join(hobbies) if hobbies else '无'}")
        print("-" * 30)


if __name__ == '__main__':
    app = QApplication(sys.argv)
    window = GroupBoxExample()
    window.show()
    sys.exit(app.exec_())

QTabWidget使用示例：

import sys
from PyQt5.QtWidgets import (QApplication, QMainWindow, QTabWidget, QWidget, 
                             QVBoxLayout, QLabel, QPushButton, QLineEdit,
                             QListWidget, QTextEdit, QHBoxLayout)

class TabWidgetExample(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle('QTabWidget 示例')
        self.setGeometry(100, 100, 600, 400)
        self.init_ui()
        
    def init_ui(self):
        # 创建主窗口的中心部件
        central_widget = QWidget()
        self.setCentralWidget(central_widget)
        
        # 创建主布局
        main_layout = QVBoxLayout(central_widget)
        
        # 创建标签页部件
        self.tab_widget = QTabWidget()
        
        # 创建三个标签页
        self.create_tab1()
        self.create_tab2()
        self.create_tab3()
        
        # 将标签页添加到主布局
        main_layout.addWidget(self.tab_widget)
        
        # 添加状态标签
        self.status_label = QLabel("当前标签: 信息页")
        main_layout.addWidget(self.status_label)
        
        # 连接标签切换信号
        self.tab_widget.currentChanged.connect(self.tab_changed)
    
    def create_tab1(self):
        """创建第一个标签页 - 信息页"""
        tab1 = QWidget()
        layout = QVBoxLayout(tab1)
        
        # 添加一些控件
        layout.addWidget(QLabel("欢迎使用标签页示例程序"))
        layout.addWidget(QLabel("这是第一个标签页"))
        
        # 添加输入框
        self.name_input = QLineEdit()
        self.name_input.setPlaceholderText("请输入您的姓名")
        layout.addWidget(self.name_input)
        
        # 添加按钮
        greet_btn = QPushButton("打招呼")
        greet_btn.clicked.connect(self.greet_user)
        layout.addWidget(greet_btn)
        
        # 添加结果标签
        self.greet_label = QLabel("")
        layout.addWidget(self.greet_label)
        
        layout.addStretch()
        self.tab_widget.addTab(tab1, "信息页")
    
    def create_tab2(self):
        """创建第二个标签页 - 列表页"""
        tab2 = QWidget()
        layout = QVBoxLayout(tab2)
        
        # 添加列表控件
        layout.addWidget(QLabel("项目列表:"))
        self.list_widget = QListWidget()
        self.list_widget.addItems(["项目1", "项目2", "项目3", "项目4"])
        layout.addWidget(self.list_widget)
        
        # 添加按钮布局
        btn_layout = QHBoxLayout()
        
        add_btn = QPushButton("添加项目")
        add_btn.clicked.connect(self.add_item)
        btn_layout.addWidget(add_btn)
        
        remove_btn = QPushButton("删除项目")
        remove_btn.clicked.connect(self.remove_item)
        btn_layout.addWidget(remove_btn)
        
        layout.addLayout(btn_layout)
        layout.addStretch()
        self.tab_widget.addTab(tab2, "列表页")
    
    def create_tab3(self):
        """创建第三个标签页 - 编辑页"""
        tab3 = QWidget()
        layout = QVBoxLayout(tab3)
        
        # 添加文本编辑控件
        layout.addWidget(QLabel("编辑区域:"))
        self.text_edit = QTextEdit()
        self.text_edit.setPlaceholderText("在此输入文本...")
        layout.addWidget(self.text_edit)
        
        # 添加按钮
        clear_btn = QPushButton("清空内容")
        clear_btn.clicked.connect(self.clear_text)
        layout.addWidget(clear_btn)
        
        layout.addStretch()
        self.tab_widget.addTab(tab3, "编辑页")
    
    def greet_user(self):
        """打招呼按钮的槽函数"""
        name = self.name_input.text().strip()
        if name:
            self.greet_label.setText(f"你好, {name}!")
        else:
            self.greet_label.setText("请输入您的姓名")
    
    def add_item(self):
        """添加项目按钮的槽函数"""
        self.list_widget.addItem(f"项目{self.list_widget.count() + 1}")
    
    def remove_item(self):
        """删除项目按钮的槽函数"""
        current_row = self.list_widget.currentRow()
        if current_row >= 0:
            self.list_widget.takeItem(current_row)
    
    def clear_text(self):
        """清空文本按钮的槽函数"""
        self.text_edit.clear()
    
    def tab_changed(self, index):
        """标签切换时的槽函数"""
        tab_name = self.tab_widget.tabText(index)
        self.status_label.setText(f"当前标签: {tab_name}")


if __name__ == '__main__':
    app = QApplication(sys.argv)
    window = TabWidgetExample()
    window.show()
    sys.exit(app.exec_())

QStackedWidget使用示例：

import sys
from PyQt5.QtWidgets import (QApplication, QMainWindow, QStackedWidget, QWidget,
                             QVBoxLayout, QLabel, QPushButton, QLineEdit,
                             QListWidget, QTextEdit, QHBoxLayout, QGroupBox)


class StackedWidgetExample(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle('QStackedWidget 示例')
        self.setGeometry(100, 100, 600, 400)
        self.init_ui()

    def init_ui(self):
        # 创建主窗口的中心部件
        central_widget = QWidget()
        self.setCentralWidget(central_widget)

        # 创建主布局
        main_layout = QVBoxLayout(central_widget)

        # 创建堆叠窗口部件
        self.stacked_widget = QStackedWidget()

        # 创建三个页面
        self.create_page1()
        self.create_page2()
        self.create_page3()

        # 将堆叠窗口添加到主布局
        main_layout.addWidget(self.stacked_widget)

        # 创建导航按钮
        nav_layout = QHBoxLayout()

        prev_btn = QPushButton("上一页")
        prev_btn.clicked.connect(self.prev_page)
        nav_layout.addWidget(prev_btn)

        next_btn = QPushButton("下一页")
        next_btn.clicked.connect(self.next_page)
        nav_layout.addWidget(next_btn)

        main_layout.addLayout(nav_layout)

        # 添加状态标签
        self.status_label = QLabel("当前页面: 1/3")
        main_layout.addWidget(self.status_label)

    def create_page1(self):
        """创建第一个页面 - 信息页"""
        page1 = QWidget()
        layout = QVBoxLayout(page1)

        # 添加分组框
        group_box = QGroupBox("用户信息")
        group_layout = QVBoxLayout()

        # 添加输入框
        self.name_input = QLineEdit()
        self.name_input.setPlaceholderText("请输入您的姓名")
        group_layout.addWidget(self.name_input)

        # 添加按钮
        greet_btn = QPushButton("打招呼")
        greet_btn.clicked.connect(self.greet_user)
        group_layout.addWidget(greet_btn)

        # 添加结果标签
        self.greet_label = QLabel("")
        group_layout.addWidget(self.greet_label)

        group_box.setLayout(group_layout)
        layout.addWidget(group_box)
        layout.addStretch()

        self.stacked_widget.addWidget(page1)

    def create_page2(self):
        """创建第二个页面 - 列表页"""
        page2 = QWidget()
        layout = QVBoxLayout(page2)

        # 添加分组框
        group_box = QGroupBox("项目列表")
        group_layout = QVBoxLayout()

        # 添加列表控件
        self.list_widget = QListWidget()
        self.list_widget.addItems(["项目1", "项目2", "项目3", "项目4"])
        group_layout.addWidget(self.list_widget)

        # 添加按钮布局
        btn_layout = QHBoxLayout()

        add_btn = QPushButton("添加项目")
        add_btn.clicked.connect(self.add_item)
        btn_layout.addWidget(add_btn)

        remove_btn = QPushButton("删除项目")
        remove_btn.clicked.connect(self.remove_item)
        btn_layout.addWidget(remove_btn)

        group_layout.addLayout(btn_layout)
        group_box.setLayout(group_layout)
        layout.addWidget(group_box)
        layout.addStretch()

        self.stacked_widget.addWidget(page2)

    def create_page3(self):
        """创建第三个页面 - 编辑页"""
        page3 = QWidget()
        layout = QVBoxLayout(page3)

        # 添加分组框
        group_box = QGroupBox("文本编辑")
        group_layout = QVBoxLayout()

        # 添加文本编辑控件
        self.text_edit = QTextEdit()
        self.text_edit.setPlaceholderText("在此输入文本...")
        group_layout.addWidget(self.text_edit)

        # 添加按钮
        clear_btn = QPushButton("清空内容")
        clear_btn.clicked.connect(self.clear_text)
        group_layout.addWidget(clear_btn)

        group_box.setLayout(group_layout)
        layout.addWidget(group_box)
        layout.addStretch()

        self.stacked_widget.addWidget(page3)

    def greet_user(self):
        """打招呼按钮的槽函数"""
        name = self.name_input.text().strip()
        if name:
            self.greet_label.setText(f"你好, {name}!")
        else:
            self.greet_label.setText("请输入您的姓名")

    def add_item(self):
        """添加项目按钮的槽函数"""
        self.list_widget.addItem(f"项目{self.list_widget.count() + 1}")

    def remove_item(self):
        """删除项目按钮的槽函数"""
        current_row = self.list_widget.currentRow()
        if current_row >= 0:
            self.list_widget.takeItem(current_row)

    def clear_text(self):
        """清空文本按钮的槽函数"""
        self.text_edit.clear()

    def prev_page(self):
        """上一页按钮的槽函数"""
        current_index = self.stacked_widget.currentIndex()
        if current_index > 0:
            self.stacked_widget.setCurrentIndex(current_index - 1)
            self.update_status()

    def next_page(self):
        """下一页按钮的槽函数"""
        current_index = self.stacked_widget.currentIndex()
        if current_index < self.stacked_widget.count() - 1:
            self.stacked_widget.setCurrentIndex(current_index + 1)
            self.update_status()

    def update_status(self):
        """更新状态标签"""
        current_index = self.stacked_widget.currentIndex() + 1
        total_pages = self.stacked_widget.count()
        self.status_label.setText(f"当前页面: {current_index}/{total_pages}")


if __name__ == '__main__':
    app = QApplication(sys.argv)
    window = StackedWidgetExample()
    window.show()
    sys.exit(app.exec_())

QSplitters使用示例：

import sys
from PyQt5.QtWidgets import (QApplication, QMainWindow, QSplitter, QWidget, 
                             QVBoxLayout, QHBoxLayout, QLabel, QTextEdit, 
                             QListWidget, QTreeWidget, QTreeWidgetItem)

class SplitterExample(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle('QSplitter 示例')
        self.setGeometry(100, 100, 800, 600)
        self.init_ui()
        
    def init_ui(self):
        # 创建主窗口的中心部件
        central_widget = QWidget()
        self.setCentralWidget(central_widget)
        
        # 创建主布局
        main_layout = QVBoxLayout(central_widget)
        
        # 创建水平分割器
        horizontal_splitter = QSplitter()
        horizontal_splitter.setOrientation(0)  # 0 表示水平方向
        
        # 创建左侧区域 - 文本编辑区
        left_widget = QWidget()
        left_layout = QVBoxLayout(left_widget)
        left_layout.addWidget(QLabel("文本编辑区"))
        self.text_edit = QTextEdit()
        self.text_edit.setPlaceholderText("在此输入文本...")
        left_layout.addWidget(self.text_edit)
        horizontal_splitter.addWidget(left_widget)
        
        # 创建垂直分割器（嵌套在水平分割器中）
        vertical_splitter = QSplitter()
        vertical_splitter.setOrientation(1)  # 1 表示垂直方向
        
        # 创建右上区域 - 列表区
        top_right_widget = QWidget()
        top_right_layout = QVBoxLayout(top_right_widget)
        top_right_layout.addWidget(QLabel("项目列表"))
        self.list_widget = QListWidget()
        self.list_widget.addItems(["项目1", "项目2", "项目3", "项目4"])
        top_right_layout.addWidget(self.list_widget)
        vertical_splitter.addWidget(top_right_widget)
        
        # 创建右下区域 - 树形结构区
        bottom_right_widget = QWidget()
        bottom_right_layout = QVBoxLayout(bottom_right_widget)
        bottom_right_layout.addWidget(QLabel("树形结构"))
        self.tree_widget = QTreeWidget()
        self.tree_widget.setHeaderLabels(["名称", "类型"])
        
        # 添加树形结构数据
        root = QTreeWidgetItem(self.tree_widget)
        root.setText(0, "根节点")
        
        child1 = QTreeWidgetItem(root)
        child1.setText(0, "子节点1")
        child1.setText(1, "文件夹")
        
        child2 = QTreeWidgetItem(root)
        child2.setText(0, "子节点2")
        child2.setText(1, "文件")
        
        self.tree_widget.expandAll()
        bottom_right_layout.addWidget(self.tree_widget)
        vertical_splitter.addWidget(bottom_right_widget)
        
        # 将垂直分割器添加到水平分割器
        horizontal_splitter.addWidget(vertical_splitter)
        
        # 设置初始比例
        horizontal_splitter.setSizes([300, 500])
        vertical_splitter.setSizes([200, 300])
        
        # 添加分割器到主布局
        main_layout.addWidget(horizontal_splitter)
        
        # 添加状态标签
        self.status_label = QLabel("拖动分隔条调整各区域大小")
        main_layout.addWidget(self.status_label)
        
        # 连接信号
        horizontal_splitter.splitterMoved.connect(self.update_status)
        vertical_splitter.splitterMoved.connect(self.update_status)
    
    def update_status(self, pos, index):
        """更新状态标签"""
        self.status_label.setText(f"当前分隔条位置: {pos}")


if __name__ == '__main__':
    app = QApplication(sys.argv)
    window = SplitterExample()
    window.show()
    sys.exit(app.exec_())

布局管理器

QFormLayout

用于构建图形用户界面（GUI）中表单的布局管理器。它可以在表单中自动地安排各种控件（例如文本框、复选框、下拉框等）的位置和大小，以便它们以最优化的方式显示在表单上。

简化表单的设计和排版工作，以及提高表单的可读性和易用性
根据表单中控件的类型和数量，自动地生成最佳的布局
提供了一些常用的功能，例如表单边距、控件间距、对齐方式、自动换行等

QGridLayout

用于将控件以网格的形式排列在窗口中。每个单元格可以包含一个控件，且所有单元格大小相等。控件可以跨越多个行和列，这是通过指定控件的位置以及它在行和列中所占的单元格数量来实现的。重要特点：

创建GridLayout对象：可以通过将QWidget作为参数传递给QGridLayout构造函数来创建一个GridLayout对象。然后可以使用addWidget()方法将控件添加到布局中
指定控件的位置：可以使用addWidget()方法的第二个和第三个参数来指定控件的位置。例如，addWidget(button, 0, 0)将button添加到第0行和第0列的单元格中
控件的大小和跨度：可以使用addWidget()方法的第四个和第五个参数来指定控件在行和列中所占的单元格数量。例如，addWidget(label, 0, 0, 1, 2)将label添加到第0行和第0列的单元格中，并让它跨越第0列和第1列的两个单元格
添加空白单元格：可以使用addSpacing()方法添加空白的单元格，从而调整控件之间的距离
对齐方式：可以使用setAlignment()方法设置控件在单元格中的对齐方式。可以指定水平和垂直方向的对齐方式，也可以将对齐方式设置为水平和垂直方向的组合
自动调整大小：可以使用setColumnStretch()和setRowStretch()方法来设置单元格的大小。可以使用addStretch()方法添加一个伸缩项，以便在窗口大小改变时自动调整大小

信号与槽以及关联控件

信号与槽的介绍

信号是用于在对象之间传递信息的一种机制。一个信号表示了一个事件或状态的变化，当这个事件或状态变化时，信号被发射（emit）。可以将信号连接到一个或多个槽函数中，当信号被发射时，连接的槽函数会被调用执行。槽函数则是用于接收和处理信号的函数。

常用**connect()**方法来将信号连接到槽函数中，该方法的基本语法为：

`1`	`sender.signal.connect(receiver.slot)`

sender表示发送信号的对象，signal表示信号的名称，connect()方法将信号signal连接到receiver对象的槽函数slot中。槽函数可以是任何可调用的Python函数

高级的信号与槽机制：

使用自定义信号：可以定义自己的信号，并将其连接到槽函数中。自定义信号可以通过QObject类的signal()方法定义，并使用emit()方法发射信号
使用Lambda表达式：可以使用Lambda表达式作为槽函数，Lambda表达式可以简洁地表示一个函数
使用信号参数：PyQt5中的信号可以带有参数，参数可以在信号发射时被传递给槽函数
一个信号连接多个槽函数：可以将一个信号连接到多个槽函数中，所有的槽函数都会在信号被发射时被调用执行

QPushButton

Qt中常用的按钮控件，可以用于在GUI中创建各种类型的按钮，如普通按钮、复选框按钮、单选框按钮等。

其构造函数为：

1
2
3

QPushButton(parent=None)            #创建一个无标签的按钮
QPushButton(str, parent=None)		#创建一个有标签的按钮
QPushButton(QIcon, str, parent=None)#创建一个既有图标又有标签的按钮

可以调用的方法有：

setText()方法设置按钮的文本标签
setIcon()方法设置按钮的图标
setEnabled()用于设置按钮是否可用
setFlat()用于设置按钮是否平面
setCheckable()用于设置按钮是否可选中等

还可以通过信号与槽机制来响应用户的点击事件。当用户单击按钮时，会发出clicked()信号，可以通过连接这个信号来执行特定的操作。

import sys
from PyQt5.QtWidgets import QApplication, QMainWindow, QPushButton, QLabel, QHBoxLayout, QVBoxLayout, QWidget
from PyQt5.QtGui import QIcon
from PyQt5.QtCore import Qt

class MyMainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.initUI()

    def initUI(self):
        self.setWindowTitle('QPushButton Demo')
        self.setGeometry(300, 300, 400, 300)

        # 创建一个QPushButton并设置文本标签和图标
        btn = QPushButton('Click me!', self)
        btn.setIcon(QIcon('icon.png'))

        # 连接按钮的clicked信号到槽函数onBtnClicked
        btn.clicked.connect(self.onBtnClicked)

        # 创建一个QLabel用于显示按钮状态
        self.label = QLabel('Button not clicked', self)

        # 创建水平布局和垂直布局，并将按钮和标签添加到布局中
        hbox = QHBoxLayout()
        hbox.addStretch(1)
        hbox.addWidget(btn)
        hbox.addStretch(1)

        vbox = QVBoxLayout()
        vbox.addStretch(1)
        vbox.addLayout(hbox)
        vbox.addStretch(1)
        vbox.addWidget(self.label, alignment=Qt.AlignCenter)

        # 创建一个QWidget，并将垂直布局添加到QWidget中
        widget = QWidget()
        widget.setLayout(vbox)
        self.setCentralWidget(widget)

    def onBtnClicked(self):
        self.label.setText('Button clicked')

if __name__ == '__main__':
    app = QApplication(sys.argv)
    win = MyMainWindow()
    win.show()
    sys.exit(app.exec_())

QRadioButton

一个单选按钮控件，可以用于从多个互斥的选项中选择一个选项。与QCheckBox不同，QRadioButton只允许选择一个选项。

基本属性和方法：

setText()设置按钮的文本
isChecked()检查按钮是否被选中
setChecked()设置按钮的选中状态
toggled()每当按钮的选中状态发生变化时，都会发出toggled()信号

import sys
from PyQt5.QtWidgets import QApplication, QMainWindow, QRadioButton


class MyMainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.initUI()

    def initUI(self):
        self.setWindowTitle('QRadioButton Demo')
        self.setGeometry(300, 300, 400, 300)

        # 创建两个单选框按钮
        rb1 = QRadioButton('Option 1', self)
        rb1.move(50, 50)
        rb1.setChecked(True)

        rb2 = QRadioButton('Option 2', self)
        rb2.move(50, 80)

        # 绑定toggled()信号
        rb1.toggled.connect(self.onToggled)
        rb2.toggled.connect(self.onToggled)

    def onToggled(self, checked):
        sender = self.sender()
        if checked:
            print(sender.text() + ' is checked')


if __name__ == '__main__':
    app = QApplication(sys.argv)
    win = MyMainWindow()
    win.show()
    sys.exit(app.exec_())

QcheckBox

一个复选框控件，可以用于从多个选项中选择一个或多个选项。与QRadioButton不同，QCheckBox允许选择多个选项。

基本属性和方法：

setText()：设置复选框的文本。
isChecked()：检查复选框是否被选中。
setChecked()：设置复选框的选中状态。
stateChanged()：每当复选框的选中状态发生变化时，都会发出stateChanged()信号

import sys
from PyQt5.QtWidgets import QApplication, QMainWindow, QCheckBox

class MyMainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.initUI()

    def initUI(self):
        self.setWindowTitle('QCheckBox Demo')
        self.setGeometry(300, 300, 400, 300)

        # 创建两个复选框
        cb1 = QCheckBox('Option 1', self)
        cb1.move(50, 50)

        cb2 = QCheckBox('Option 2', self)
        cb2.move(50, 80)

        # 绑定stateChanged()信号
        cb1.stateChanged.connect(self.onStateChanged)
        cb2.stateChanged.connect(self.onStateChanged)

    def onStateChanged(self, state):
        sender = self.sender()
        if state == 2:
            print(sender.text() + ' is checked')
        else:
            print(sender.text() + ' is unchecked')

if __name__ == '__main__':
    app = QApplication(sys.argv)
    win = MyMainWindow()
    win.show()
    sys.exit(app.exec_())

QComboBox

下拉列表控件，允许用户从预定义的一组选项中选择一个或多个选项。它通常用于表示枚举类型的值或选择一组预定义的选项。

基本属性和方法：

addItem()：添加一个项到下拉列表中。
addItems()：添加多个项到下拉列表中。
setCurrentIndex()：设置当前选中的项的索引。
currentText()：返回当前选中的项的文本。
currentIndexChanged()：每当当前选中的项发生变化时，都会发出currentIndexChanged()信号。

import sys
from PyQt5.QtWidgets import (QApplication, QMainWindow, QComboBox,
                             QPushButton, QVBoxLayout, QWidget, QLabel)


class ComboBoxDemo(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle('QComboBox 演示')
        self.setGeometry(300, 300, 400, 300)
        self.initUI()

    def initUI(self):
        # 创建中心部件和布局
        central_widget = QWidget()
        self.setCentralWidget(central_widget)
        layout = QVBoxLayout(central_widget)

        # 创建标签显示当前选择
        self.status_label = QLabel("当前选择: 无")
        layout.addWidget(self.status_label)

        # 创建下拉列表并添加选项
        self.combo_box = QComboBox()
        self.combo_box.addItem('选项 1')
        self.combo_box.addItem('选项 2')
        self.combo_box.addItem('选项 3')
        self.combo_box.addItem('选项 4')
        self.combo_box.addItem('选项 5')

        # 绑定信号
        self.combo_box.currentIndexChanged.connect(self.on_index_changed)
        layout.addWidget(self.combo_box)

        # 创建按钮用于设置当前索引
        self.create_set_index_buttons(layout)

        # 添加随机选择按钮
        random_btn = QPushButton("随机选择")
        random_btn.clicked.connect(self.set_random_index)
        layout.addWidget(random_btn)

        # 添加重置按钮
        reset_btn = QPushButton("重置选择")
        reset_btn.clicked.connect(self.reset_selection)
        layout.addWidget(reset_btn)

        # 初始化状态
        self.update_status()

    def create_set_index_buttons(self, layout):
        """创建设置索引的按钮"""
        # 水平布局用于放置按钮
        button_layout = QVBoxLayout()

        # 为每个选项创建设置按钮
        for i in range(self.combo_box.count()):
            btn = QPushButton(f"设置为选项 {i + 1}")
            # 使用lambda函数传递索引值
            btn.clicked.connect(lambda checked, idx=i: self.set_current_index(idx))
            button_layout.addWidget(btn)

        layout.addLayout(button_layout)

    def set_current_index(self, index):
        """设置当前选中的索引"""
        self.combo_box.setCurrentIndex(index)

    def set_random_index(self):
        """随机选择一个索引"""
        import random
        count = self.combo_box.count()
        if count > 0:
            random_index = random.randint(0, count - 1)
            self.combo_box.setCurrentIndex(random_index)

    def reset_selection(self):
        """重置选择（设置为无选择）"""
        self.combo_box.setCurrentIndex(-1)

    def on_index_changed(self, index):
        """当下拉列表选择改变时调用"""
        self.update_status()

    def update_status(self):
        """更新状态标签"""
        index = self.combo_box.currentIndex()
        text = self.combo_box.currentText()

        if index == -1:
            self.status_label.setText("当前选择: 无")
        else:
            self.status_label.setText(f"当前选择: 选项 {index + 1} ({text})")


if __name__ == '__main__':
    app = QApplication(sys.argv)
    win = ComboBoxDemo()
    win.show()
    sys.exit(app.exec_())

独立组件

滑块控件

图形用户界面中常见的一种控件，也称为滑杆、拖动条、进度条等，用于调节数值类型的参数。用户通过拖动滑块的滑块块（Thumb）来改变滑块的值，滑块的范围和步长可以通过设置属性进行控制。在PyQt5中，QSlider是用于创建滑块控件的类。

常用的属性和方法：

value()：获取当前滑块的值。
setValue(value)：设置当前滑块的值。
minimum()：获取滑块的最小值。
setMinimum(value)：设置滑块的最小值。
maximum()：获取滑块的最大值。
setMaximum(value)：设置滑块的最大值。
singleStep()：获取滑块的步长。
setSingleStep(value)：设置滑块的步长。
sliderMoved.connect(slot)：将slot函数连接到滑块拖动事件。
valueChanged.connect(slot)：将slot函数连接到滑块值改变事件。在使用QS

import sys
from PyQt5.QtWidgets import QApplication, QWidget, QLabel, QSlider, QHBoxLayout, QVBoxLayout, QPushButton
from PyQt5.QtCore import Qt


class SliderDemo(QWidget):
    def __init__(self):
        super().__init__()
        self.initUI()

    def initUI(self):
        # 创建一个水平布局和垂直布局
        hlayout = QHBoxLayout()
        vlayout = QVBoxLayout()

        # 创建一个标签和滑块控件，并添加到水平布局中
        self.label = QLabel('Value: 0')
        self.slider = QSlider(Qt.Horizontal)
        self.slider.valueChanged[int].connect(self.onSliderValueChanged)
        hlayout.addWidget(self.label)
        hlayout.addWidget(self.slider)

        # 创建一个重置按钮，并添加到垂直布局中
        reset_btn = QPushButton('Reset')
        reset_btn.clicked.connect(self.onResetBtnClicked)
        vlayout.addLayout(hlayout)
        vlayout.addWidget(reset_btn)

        # 设置窗口的布局
        self.setLayout(vlayout)

        # 设置窗口的标题和大小
        self.setWindowTitle('Slider Demo')
        self.resize(300, 200)

    def onSliderValueChanged(self, value):
        # 当滑块的值改变时更新标签的文本
        self.label.setText(f'Value: {value}')

    def onResetBtnClicked(self):
        # 重置滑块的值为0，并更新标签的文本
        self.slider.setValue(0)
        self.label.setText('Value: 0')


if __name__ == '__main__':
    app = QApplication(sys.argv)
    demo = SliderDemo()
    demo.show()
    sys.exit(app.exec_())

树控件

一种常见的用户界面控件，它可以用来展示层次化的数据结构，例如文件系统、目录结构、组织结构等等。树控件通常由多个节点（Node）组成，每个节点都可以包含多个子节点。在PyQt5中，树控件是通过QTreeWidget类来实现的。

操作树控件方法：

添加节点：可以通过QTreeWidget.addTopLevelItem()方法或QTreeWidgetItem.addChild()方法来添加节点。
删除节点：可以通过QTreeWidget.takeTopLevelItem()方法或QTreeWidgetItem.removeChild()方法来删除节点。
获取节点：可以通过QTreeWidget.topLevelItem()方法或QTreeWidgetItem.child()方法来获取节点。
设置节点属性：可以通过QTreeWidgetItem.setText()、QTreeWidgetItem.setIcon()等方法来设置节点的文本、图标等属性。
选择节点：可以通过QTreeWidget.currentItem()方法获取当前选中的节点，也可以通过QTreeWidgetItem.setSelected


import sys
from PyQt5.QtWidgets import QApplication, QMainWindow, QTreeWidget, QTreeWidgetItem

class OrganizationChart(QMainWindow):
    def __init__(self):
        super().__init__()

        self.setWindowTitle("组织结构图")
        self.resize(500, 400)

        self.treeWidget = QTreeWidget()
        self.treeWidget.setHeaderLabels(["姓名", "职位", "部门"])

        self.populateTreeWidget()

        self.setCentralWidget(self.treeWidget)

    def populateTreeWidget(self):
        # 创建根节点
        root = QTreeWidgetItem(self.treeWidget, ["总经理", "总经理", ""])

        # 创建部门节点1
        department1 = QTreeWidgetItem(root, ["市场部", "部门经理", ""])
        employee1 = QTreeWidgetItem(department1, ["张三", "销售经理", "市场部"])
        employee2 = QTreeWidgetItem(department1, ["李四", "市场专员", "市场部"])

        # 创建部门节点2
        department2 = QTreeWidgetItem(root, ["技术部", "部门经理", ""])
        employee3 = QTreeWidgetItem(department2, ["王五", "技术总监", "技术部"])
        employee4 = QTreeWidgetItem(department2, ["赵六", "开发工程师", "技术部"])

        # 展开根节点
        self.treeWidget.expandItem(root)

if __name__ == "__main__":
    app = QApplication(sys.argv)

    organizationChart = OrganizationChart()
    organizationChart.show()

    sys.exit(app.exec_())

停靠控件

一种常用的界面布局控件，它允许用户在主窗口中创建可停靠的面板或工具栏，以便对应用程序进行灵活的布局和组织。停靠控件提供了一种便捷的方式来管理和切换应用程序的功能模块，使用户可以根据自己的需求动态调整界面布局。在 PyQt 中，停靠控件由QDockWidget类实现。它可以与 QMainWindow 或 QMainWindows 的派生类一起使用，使得应用程序的主窗口可以容纳多个停靠控件，并支持拖动、停靠和浮动等操作。

实现步骤：

创建停靠控件对象：使用 QDockWidget 类创建一个停靠控件对象，并将需要承载的内容设置为其子部件。
设置停靠属性：可以设置停靠控件的标题、图标、位置等属性，以及允许的停靠区域和停靠方式。
将停靠控件添加到主窗口：使用 QMainWindow 或 QMainWindows 的派生类将停靠控件添加到主窗口中的合适位置，通常使用 addDockWidget() 方法来完成。

import sys
from PyQt5.QtWidgets import QApplication, QMainWindow, QDockWidget, QTextEdit, QAction, QFileDialog, QMessageBox, QVBoxLayout, QWidget, QLabel, QPushButton, QTreeWidget, QTreeWidgetItem

class NotePad(QMainWindow):
    def __init__(self):
        super().__init__()

        self.initUI()

    def initUI(self):
        self.setWindowTitle("NotePad")
        self.setGeometry(100, 100, 800, 600)

        # 创建文本编辑区域
        self.textEdit = QTextEdit()
        self.setCentralWidget(self.textEdit)

        # 创建停靠控件
        dock = QDockWidget("File Actions", self)
        dock.setAllowedAreas(Qt.LeftDockWidgetArea)

        # 创建停靠控件中的内容，包括打开文件按钮和保存文件按钮
        openButton = QPushButton("Open File")
        openButton.clicked.connect(self.openFile)

        saveButton = QPushButton("Save File")
        saveButton.clicked.connect(self.saveFile)

        layout = QVBoxLayout()
        layout.addWidget(openButton)
        layout.addWidget(saveButton)

        widget = QWidget()
        widget.setLayout(layout)
        dock.setWidget(widget)

        # 将停靠控件添加到主窗口的左侧停靠区域
        self.addDockWidget(Qt.LeftDockWidgetArea, dock)

        # 创建菜单和动作
        self.createActions()
        self.createMenus()

        # 创建侧边栏
        self.createSidebar()

        self.show()

    def createActions(self):
        self.openAction = QAction("Open File", self)
        self.openAction.triggered.connect(self.openFile)

        self.saveAction = QAction("Save File", self)
        self.saveAction.triggered.connect(self.saveFile)

    def createMenus(self):
        self.fileMenu = self.menuBar().addMenu("File")
        self.fileMenu.addAction(self.openAction)
        self.fileMenu.addAction(self.saveAction)

    def createSidebar(self):
        # 创建侧边栏
        sidebarDock = QDockWidget("Notes", self)
        sidebarDock.setAllowedAreas(Qt.LeftDockWidgetArea)

        # 创建树控件
        treeWidget = QTreeWidget()
        treeWidget.setHeaderLabels(["Notes"])

        # 添加示例笔记
        root = QTreeWidgetItem(treeWidget)
        root.setText(0, "Notebook")

        note1 = QTreeWidgetItem(root)
        note1.setText(0, "Note 1")

        note2 = QTreeWidgetItem(root)
        note2.setText(0, "Note 2")

        # 将树控件添加到侧边栏
        sidebarDock.setWidget(treeWidget)
        self.addDockWidget(Qt.LeftDockWidgetArea, sidebarDock)

    def openFile(self):
        fileName, _ = QFileDialog.getOpenFileName(self, "Open File")
        if fileName:
            try:
                with open(fileName, 'r') as file:
                    content = file.read()
                self.textEdit.setPlainText(content)
            except Exception as e:
                QMessageBox.critical(self, "Error", str(e))

    def saveFile(self):
        fileName, _ = QFileDialog.getSaveFileName(self, "Save File")
        if fileName:
            try:
                with open(fileName, 'w') as file:
                    content = self.textEdit.toPlainText()
                    file.write(content)
                QMessageBox.information(self, "Success", "File saved successfully.")
            except Exception as e:
                QMessageBox.critical(self, "Error", str(e))

if __name__ == '__main__':
    app = QApplication(sys.argv)
    notepad = NotePad()
    sys.exit(app.exec_())

BeautifulSoup

Tue, 05 Aug 2025 15:27:58 +0800

BeautifulSoup

简介

BeautifulSoup 是一个可以把 HTML 或 XML 文档“变成结构化树”，方便你用Python 来查找、遍历、提取内容的工具。

解析器

解析器	使用方法	优势	劣势
Python标准库	BeautifulSoup(markup, ‘html.parser’)	python内置的标准库，执行速度适中	Python3.2.2之前的版本容错能力差
lxml HTML解析器	BeautifulSoup(markup, ’lxml')	速度快、文档容错能力强	需要安装C语言库
lxml XML解析器	BeautifulSoup(markup ‘xml’)	速度快，唯一支持XML的解析器	需要安装C语言库
html5lib	BeautifulSoup(markup, ‘html5lib’)	最好的容错性、以浏览器的方式解析文档、生成HTML5格式的文档	速度慢，不依赖外部拓展

具体使用代码展示如下：

from bs4 import BeautifulSoup

soup = BeautifulSoup('<p>Hello world</p>', 'lxml')
print(soup.p)

基本用法

当传入不标准的HTML字符串，BeautifulSoup可以自动更正格式。

soup.prettify(): 用于将 HTML 或 XML 文档格式化输出为带缩进的字符串,即会把原始网页内容重新排版，输出一个带有层级缩进的漂亮 HTML 字符串，例：

from bs4 import BeautifulSoup

html = '<html><head><title>Test</title></head><body><h1>Hi</h1><p>Hello</p></body></html>'
soup = BeautifulSoup(html, 'html.parser')

pretty_html = soup.prettify()
print(pretty_html)

输出：

<html>
 <head>
  <title>
   Test
  </title>
 </head>
 <body>
  <h1>
   Hi
  </h1>
  <p>
   Hello
  </p>
 </body>
</html>

.title：获取title标签

html_doc="""
<html><head><title>The Dormouse's story</title></head>
<body>
<p class="title"><b>The Dormouse's story</b></p>

<p class="story">Once upon a time there were three little sisters; and their names were
<a href="http://example.com/elsie" class="sister" id="link1">Elsie</a>,
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and
<a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>;
and they lived at the bottom of a well.</p>

<p class="story">...</p>
""""
# 创建beautifulsoup对象 解析器为lxml
soup = BeautifulSoup(html_doc, 'lxml')
print(soup.title)
#output-><title>The Dormouse's story</title>

.name：返回的是当前节点的“标签名称”

soup = BeautifulSoup(html_doc, 'lxml')
print(soup.title.name)
print(soup.name)
#output->title
#[document]

.string/.text：获取标签中的文字内容

soup = BeautifulSoup(html_doc, 'lxml')
print(soup.title.string)
print(soup.title.text)
#output->The Dormouse's story
#The Dormouse's story

.p：访问HTML中第一个

标签

1
2
3

soup = BeautifulSoup(html_doc, 'lxml')
print(soup.p)
#output-><p class="title"><b>The Dormouse's story</b></p>

.find_all()：查找文档中所有符合条件的标签元素，返回一个列表

用法	示例	说明
查找所有某种标签	soup.find_all(‘p’)	找出所有 `<p>`
根据 class 属性	soup.find_all(‘p’, class_=‘story’)	class 要用 `class_` 表示
查找多个标签	soup.find_all([‘p’, ‘a’])	所有 `<p>` 和 `<a>` 标签
查找包含特定字符串的标签	soup.find_all(string=‘Hello’)	内容匹配为 ‘Hello’ 的标签
使用属性字典	soup.find_all(‘a’, {‘id’: ’link1’})	属性筛选
限制返回数量	soup.find_all(‘p’, limit=2)	最多返回 2 个 `<p>` 标签

'''
基本语法：
soup.find_all(name=None, attrs={}, recursive=True, string=None, limit=None, **kwargs)
'''

.find()：获取第一次匹配条件的元素

1
2
3

soup = BeautifulSoup(html_doc, 'lxml')
print(soup.find(id="link1"))
#output-><a class="sister" href="https://example.com/elsie" id="link1">Elsie</a>

.parent：获取父级标签

soup = BeautifulSoup(html_doc, 'lxml')
print(soup.title)
print(soup.title.parnt)
#output-><title>The Dormouse's story</title>
#<head><title>The Dormouse's story</title></head>

.p[‘class’]：获取某个 <p> 标签的 class 属性的值

1
2
3

soup = BeautifulSoup(html_doc, 'lxml')
print(soup.p["class"])
#output->['title']

.get_text()：获取文档中所有文字内容

soup = BeautifulSoup(html_doc, 'lxml')
print(soup.get_text())
'''
output->
The Dormouse's story

The Dormouse's story
Once upon a time there were three little sisters; and their names were
Elsie,
Lacie and
Tillie;
and they lived at the bottom of a well.
...
'''

.get()：用于安全地获取某个属性的值

'''
tag.get('属性名') 相当于 tag['属性名']，但如果属性不存在，不会报错，而是返回 None
'''
a_tags = soup.find_all('a')
for a_tag in a_tags:
    print(a_tag.get("href"))
#output->https://example.com/elsie
#https://example.com/lacie
#https://example.com/tillie

BeautifulSoup的对象种类

主要有四种主要类型：Tag，NavigableString，BeautifulSoup，Comment。

Tag：该对象与HTML或XML原生文档中的标签相同，该对象可以包含其他标签，文本内容和属性。

soup = BeautifulSoup(html_doc, 'lxml')
tag = soup.title
print(type(tag))
#output-><class 'bs4.element.Tag'>

NavigableString：标签中的文本内容，是一个不可变字符串，可以由Tag对象的.string获取

soup = BeautifulSoup(html_doc, 'lxml')
tag = soup.title
print(type(tag.string))
#output-> <class 'bs4.element.NavigableString'>

BeautifulSoup：整个文档的根对象，即整个文档的根内容，可以被视为一个特殊的Tag对象，但没有名称和属性，其提供对整个文档的遍历，搜索和修改
1 2 3

soup = BeautifulSoup(html_doc, 'lxml') print(type(soup)) #output-> <class 'bs4.BeautifulSoup'>

Comment：对象是一个特殊类型的NavigableString对象,表示HTML和XML中的注释部分

# <b><!--This is a comment--></b>
soup = BeautifulSoup(html_doc, 'lxml')
print(type(soup.b.string))
#output-> <class 'bs4.element.NavigableString'>

BeautifulSoup遍历文档树

BeautifulSoup提供很多方法来遍历解析后的文档树

导航父节点：.parent和.parents。其中.parent可以获取当前节点的上一级父节点，.parents可以遍历获取当前节点的所有父辈节点

soup = BeautifulSoup(html_doc, 'lxml')
title_tag = soup.title
print(title_tag.parent)
#<head><title>The Dormouse's story</title></head>

soup = BeautifulSoup(html_doc, 'lxml')
body_tag = soup.body
for parent in body_tag.parents:
    print(parent)
#<html><head><title>The Dormouse's story</title></head>
#<body>
#<p class="title"><b>The Dormouse's story</b></p>
#<p class="story">Once upon a time there were three little sisters; and their names were
#<a class="sister" href="https://example.com/elsie" id="link1">Elsie</a>,
#....

导航子节点：.contents可以获取当前节点的所有子节点；.children可以遍历当前节点的所有子节点，返回一个list。字符串没有这两个属性。这两个仅包含tag直接子结点，字符串”The Dormouse’s story”是<head>标签的子孙结点

soup = BeautifulSoup(html_doc, 'lxml')
head_contents = soup.head.contents
print(head_contents)
#output-> [<title>The Dormouse's story</title>]

soup = BeautifulSoup(html_doc, 'lxml')
body_children = soup.body.children

for child in body_children:
    print(child)
#output-><p class="title"><b>The Dormouse's story</b></p>
#<a class="sister" href="https://example.com/elsie" id="link1">Elsie</a>,
#<a class="sister" href="https://example.com/tillie" id="link3">Tillie</a>;
#and they lived at the bottom of a well.</p>
#.....

.descendants：可以遍历当前节点的所有后代节点（层遍历）

1
2
3

soup = BeautifulSoup(html_doc, 'lxml')
for descendant in soup.descendants:
    print(descendant)

节点内容：.string，.strings，.stripped_strings。.string如果如果tag只有一个NavigableString类型子节点,那么这个tag可以使用.string得到其子节点。但若tag中包含了多个子节点,tag就无法确定string方法应该调用哪一个字节的内容,则会输出None

soup = BeautifulSoup(html_doc, 'lxml')
print(soup.head.string)
#The Dormouse's story
print(soup.title.string)
#The Dormouse's story

1
2
3

soup = BeautifulSoup(html_doc, 'lxml')
print(soup.body.string)
#None

.strings可以遍历获取标签中的所有文本内容，.stripped_strings可以去除多余的空白字符

soup = BeautifulSoup(html_doc, 'lxml')
for string in soup.strings:
    print(string)
#The Dormouse's story
......

#The Dormouse's story

BeautifulSoup搜索文档树

find_all()：搜索当前tag的所有tag子节点

soup = BeautifulSoup(html_doc, 'lxml')
print(soup.find_all("title"))  # 查找所有的title标签
print(soup.find_all("p", "title"))  # 查找p标签中class为title的标签

print(soup.find_all("a"))  # 查找所有的a标签

print(soup.find_all(id="link2"))  # 查找id为link2的标签
#[<title>The Dormouse's story</title>]
#[<p class="title"><b>The Dormouse's story</b></p>]
#[<a class="sister" href="https://example.com/elsie" id="link1">Elsie</a>, <a class="sister" href="https://example.com/lacie" id="link2">Lacie</a>, <a class="sister" href="https://example.com/tillie" id="link3">Tillie</a>]
#[<a class="sister" href="https://example.com/lacie" id="link2">Lacie</a>]

find_parent()：只返回最接近的父标签

soup = BeautifulSoup(html_doc, 'lxml')
a_string = soup.find(string='Lacie')
print(a_string.find_parent())  # 查找父节点
#<a class="sister" href="https://example.com/lacie" id="link2">Lacie</a>

find_parents()：返回所有符合条件的祖先标签，按从近到远的顺序排列

soup = BeautifulSoup(html_doc, 'lxml')
a_string = soup.find(string='Lacie')
print(a_string.find_parents())  # 查找父节点
#[<a class="sister" href="https://example.com/lacie" id="link2">Lacie</a>, <p class="story">Once upon a time there were three little sisters; and their names were
#<a class="sister" href="https://example.com/elsie" id="link1">Elsie</a>,
#<a class="sister" href="https://example.com/lacie" id="link2">Lacie</a> and
#and they lived at the bottom of a well.</p>, <body>....]

BeautifulSoup的CSS选择器

我们在写CSS时,标签名不加任何修饰,类名前加点,id名前加#,BeautifulSoup中也可以使用类似的方法来筛选元素。BeautifulSoup中的select()方法允许使用CSS选择器来查找HTML文档元素,其返回一个包含所有匹配元素的列表类似于find_all()方法。

通过标签名查找：

1
2
3

soup = BeautifulSoup(html_doc, 'lxml')
print(soup.select('b'))
#[<b>The Dormouse's story</b>, <b><!--This is a comment--></b>]

通过类名查找：

1
2
3

soup = BeautifulSoup(html_doc, 'lxml')
print(soup.select('.title'))
#[<p class="title"><b>The Dormouse's story</b></p>]

id名查找：

1
2
3

soup = BeautifulSoup(html_doc, 'lxml')
print(soup.select('#link1'))
#[<a class="sister" href="https://example.com/elsie" id="link1">Elsie</a>]

组合查找：组合查找即与写class时一致,标签名与类名id名进行组合的原理一样

1
2
3

soup = BeautifulSoup(html_doc, 'lxml')
print(soup.select('p #link1'))
#[<a class="sister" href="https://example.com/elsie" id="link1">Elsie</a>]

属性查找：选择具有特定属性或属性值的标签

简单属性选择器：

1
2
3

soup = BeautifulSoup(html_doc, 'lxml')
print(soup.select("a[href='https://example.com/elsie']"))  # 选择a标签中href属性为https://example.com/elsie的标签
#[<a class="sister" href="https://example.com/elsie" id="link1">Elsie</a>]

属性值选择器


'''
精确匹配:[attribute="value"]
部分匹配
包含特定值:[attribute~="value"] 选择属性值包含特定单词的标签。
以特定值开头:[attribute^="value"] 选择属性值以特定字符串开头的标签
以特定值结尾:[attribute$="value"] 选择属性值以特定字符串结尾的标签。
包含特定子字符串:[attribute*="value"] 选择属性值包含特定子字符串的标签
'''

soup = BeautifulSoup(html_doc, 'lxml')
print(soup.select('a[href^="https://example.com"]'))  # 选择href以https://example.com开头的a标签
#[<a class="sister" href="https://example.com/elsie" id="link1">Elsie</a>, <a class="sister" href="https://example.com/lacie" id="link2">Lacie</a>, <a class="sister" href="https://example.com/tillie" id="link3">Tillie</a>]

Urllib3

Tue, 05 Aug 2025 12:10:50 +0800

Urllib3

特点：

连接池管理：在客户端和服务器之间复用已有连接，避免每次请求都重新建立新连接，核心是PoolManager,内部维护一个或多个ConnectionPool；
线程安全：适合在多线程环境下进行并发请求；
重试机制：请求失败自动重试；
SSL/TLS验证：建立 HTTPS 连接时，客户端校验服务器提供的数字证书是否可信，并通过 TLS 协议完成数据加密通道的协商；
代理支持：在客户端（你）访问目标网站时，通过一个中间服务器（代理服务器）中转请求和响应，而不是直接访问目标网站；
文件上传：支持 multipart 文件上传；
编码处理：自动处理响应内容的编码问题；

核心类与方法：

PoolManager：最核心类，负责管理连接池和所有请求。

http = urllib3.PoolManager(
	num_pools = 50,          #连接池数量
    maxsize = 10,            #每个连接池最大连接数
    block = True,            #连接池满时是否阻塞等待
    timeout = 30.0,	         #请求超时时间
    retries = 3,  			 #默认重试次数
    headers={'User-Agent':''}
)

GET请求：

response = http.request(
	'GET',
    'http://',
    fields = {'arg':'value'} #查询参数
)

POST请求：

#表单数据
response = http.request(
	'POST',
    'http://',
    fields = {'field':'value'}
)

#JSON数据
import json
response = http.request(
	'POST',
    'http://',
    body = json.dumps({'key':'value'}).encode('utf-8'),
    headers = {'Content-Type':'application/json'}
)

PUT/DELETE请求：

#PUT请求
response = http.request(
	'PUT',
    'http://',
    body = b 'data to put'
)

#DELETE请求
response = http.request(
	'DELETE',
    'http://'
)

文件上传：

with open('example.txt','rb') as f:
    file_data = f.read()

response = http.request(
	'POST',
    'http://',
    fields = {
        'filefield':('example.txt',file_data,'text/plain'),
        'description':'File upload example'
    }
)

响应处理与重要属性

响应对象属性：

response = http.request('GET','http://exmaple.com')

#状态码
print(response.status)
#响应头
print(reponse.headers)
#响应体
print(response.data)
print(response.data.decode('utf-8'))#解码为字符串
#重新定向历史
print(response.redirect_location)
#消耗时间
print(response.elapsed)

响应内容处理：

#JSON响应处理
import json
json_response = json.loads(response.data.decode('utf-8'))

#流式响应处理
response = http.request(
	'GET',
    'http://exmaple.com/largefile',
    preload_content=False
)

try:
    for chunk in response.stream(1024):#每次读1024字节
        process_chunk(chunk)
finally:
     response.release_conn()#释放连接

高级特性与配置

重试机制：

from urllib3.util.retry import Retry

retry_strategy = Retry(
	total = 3, 			#重试总次数
    backoff_factor = 1, #重试间隔增长因子
    status_forcelist = [500,502,503,504]#指定哪些状态码会触发自动重试
)
http = urllib3.PoolManager(retries = retry_strategy)

超时设置：

#全局超时
http = urllib3.PoolManager(timeout=2.0)

#单个请求超时 
response = http.request(
    'GET',
    'http://example.com',
    timeout=5.0 
)

#分别设置连接和读取超时 
response = http.request(
    'GET',
    'http://example.com',
    timeout=urllib3.Timeout(connect=2.0, read=10.0)
)

SSL/TLS配置：

#禁用证书验证(不推荐生产环境使用)
http = urllib3.PoolManager(
    cert_reqs='CERT_NONE',#不校验证书有效性
    assert_hostname=False #不检查证书是否匹配域名
)


#自定义CA证书 
http = urllib3.PoolManager(
    cert_reqs='CERT_REQUIRED',
    ca_certs='/path/to/certificate.pem')#自定义CA

#客户端证书认证 
http = urllib3.PoolManager(
    #证书文件路径
    cert_file='/path/to/client_cert.pem',
    #证书对应私钥文件路径
    key_file='/path/to/client_key.pem')

代理配置：


#HTTP代理 
http = urllib3.ProxyManager(
    #代理服务器地址
    'http://proxy.example.com:8080/',
    #身份认证信息
    proxy_headers={'Proxy-Authorization': 'Basic ...'})

#SOCKS代理(需要安装PySocks)
pip install pysocks 

from urllib3.contrib.socks import SOCKSProxyManager 
proxy = SOCKSProxyManager(
    'socks5://user:password@127.0.0.1:1080/'
)

性能优化技巧

连接池调优：

#根据应用场景调整连接池参数 
http = urllib3.PoolManager(
    num_pools=10,      # 适合大多数应用 
    maxsize=10,        # 每个连接池最大连接数 
    block=True,        # 连接池满时阻塞而非创建新连接 
    timeout=60.0       # 适当延长超时时间 
)

连接重用：

#使用上下文管理器确保连接正确释放 
with http.request('GET', 'http://example.com', preload_content=False) as response:
    process_response(response)
#连接自动返回到连接池

批处理请求（使用线程池并发发起请求，并收集响应对象）：

from concurrent.futures import ThreadPoolExecutor 

urls = ['http://example.com/1',
        'http://example.com/2',
        'http://example.com/3']

def fetch(url):
    return http.request('GET', url)

with ThreadPoolExecutor(max_workers=5) as executor:
    results = list(executor.map(fetch, urls))

6.常见的应用场景

Web API调用：

import json 
from urllib.parse import urlencode 

base_url = "https://api.example.com/v1"

def get_user(user_id):
    response = http.request(
        'GET',
        f"{base_url}/users/{user_id}",
        headers={'Authorization': 'Bearer token123'}
    )
    return json.loads(response.data.decode('utf-8'))

def search_users(query, limit=10):
    params = {'q': query, 'limit': limit}
    response = http.request(
        'GET',
        f"{base_url}/users/search?{urlencode(params)}"
    )
    return json.loads(response.data.decode('utf-8'))

网页抓取：

from bs4 import BeautifulSoup 

def scrape_website(url):
    response = http.request('GET', url)
    if response.status == 200:
        soup = BeautifulSoup(response.data, 'html.parser')
        # 提取数据...
        return {
            'title': soup.title.string,
            #遍历所有的a标签，并提取其中的href属性
            'links': [a['href'] for a in soup.find_all('a')]
        }
    return None

文件下载：

def download_file(url, save_path):
    with http.request('GET', url, preload_content=False) as response:
        if response.status == 200:
            with open(save_path, 'wb') as f:
                for chunk in response.stream(1024):
                    f.write(chunk)
            return True 
    return False

微服务通信：

import json 

def call_service(service_url, method, payload=None):
    headers = {
        'Content-Type': 'application/json',
        'X-Request-ID': 'unique-id-123'
    }

    body = json.dumps(payload).encode('utf-8') if payload else None 

    response = http.request(
        method.upper(),
        service_url,
        headers=headers,
        body=body 
    )

    if response.status >= 400:
        raise Exception(f"Service error: {response.status}")

    return json.loads(response.data.decode('utf-8'))

常见问题

异常处理：

import urllib3.exceptions 

try:
    response = http.request('GET', 'http://example.com')
except urllib3.exceptions.HTTPError as e:
    print(f"HTTP错误: {e}")
except urllib3.exceptions.SSLError as e:
    print(f"SSL错误: {e}")
except urllib3.exceptions.TimeoutError as e:
    print(f"请求超时: {e}")
except urllib3.exceptions.RequestError as e:
    print(f"请求错误: {e}")
except Exception as e:
    print(f"其他错误: {e}")

调试技巧：

#启用调试日志 
import logging 
logging.basicConfig(level=logging.DEBUG)

#或者只启用urllib3的调试日志 
logger = logging.getLogger('urllib3')
logger.setLevel(logging.DEBUG)

#查看连接池状态 
print(http.connection_pool_kw)
print(http.pools)

与request库的对比

更底层的控制：直接访问连接池和底层配置
更小的内存占用：没有 requests 的额外抽象层
更早的错误检测：在请求发送前就能检测到某些问题
更灵活的流处理：对大型文件或流式API更友好
大多数情况用request，精细控制或高性能用urllib3

一些问题

Q	当我向https://www.xiaohongshu.com/发起请求失败时，urllib3会自动重新定向到https://www.xiaohongshu.com/explore，这是为什么，程序为什么会知道https://www.xiaohongshu.com/explore是正确的
A	不是urllib3“知道正确地址”，重新定向是服务端的行为，当向https://www.xiaohongshu.com/发起请求后，小红书的服务器会返回一个HTTP 301或302响应，将正确的网址返回给客户端，同时urllib会默认自动跟随重定向。

Q	JSON响应处理和流式响应处理的区别
A	对于JSON响应处理，response.data一次性读取全部内容，再将其解析为Python对象；流式响应处理，不会把整个响应体加载进内存。JSON响应处理适用于REST API、结构化数据；流式响应处理适用于下载大文件、音视频流等场景

Q	线程与并发的关系
A	线程是并发的一种实现方式，但并发并不限于线程，线程像“工人”，并发像“工人排班的调度方式”，一个线程处理一个任务，多个线程合作是实现

Q	PoolManager和ProxyManager的区别
A	ProxyManager是继承自PoolManager，专门用来处理从代理服务器发出的请求，其重写了PoolManager的部分方法，确保所有的请求都从预定的代理进行，并且它能根据目标的URL的方案和代理类型，智能的选择使用HTTP转发或HTTP CONNECT通道

一些测试代码

一些库导入

import urllib3
import threading
import time
from urllib3.exceptions import EmptyPoolError
import json
import logging
logging.basicConfig(level=logging.DEBUG)

测试连接复用：

# 创建连接池，最大连接数设置为 1（便于观察复用）
http = urllib3.HTTPConnectionPool("httpbin.org", maxsize=1)

# 第一次请求
print("第1次请求")
r1 = http.request("GET", "/get")
print("响应状态码:", r1.status)

# 暂停 1 秒
time.sleep(1)
# 第二次请求
print("\n第2次请求")
r2 = http.request("GET", "/get")
print("响应状态码:", r2.status)

'''
#通过如下方式，检查底层 socket 是否复用
print("连接池中连接数量:", len(http.pool))
for conn in http.pool:
    print("连接对象:", conn)
'''

'''
#测试“不复用的情况”，可以设置 retries=0，并且让服务器关闭连接
r = http.request("GET", "/get", headers={"Connection": "close"})
'''

测试限制连接数+阻塞模式:

# 设置连接池为 maxsize=1，block=False
http = urllib3.HTTPConnectionPool("httpbin.org", maxsize=1, block=False)

# 请求函数：保持连接占用一段时间
def make_request(name):
    print(f"[{name}] 准备发送请求")
    try:
        r = http.request("GET", "/delay/5", preload_content=False, timeout=10.0)
        print(f"[{name}] 已发送请求，延迟读取内容")
        time.sleep(6)  # 保持连接被占用
        r.release_conn()  # 主动释放连接
        print(f"[{name}] 释放连接")
    except EmptyPoolError as e:
        print(f"[{name}] 连接池耗尽异常: {e}")
    except Exception as e:
        print(f"[{name}] 其他异常: {e}")

# 第一个线程：占住唯一连接
t1 = threading.Thread(target=make_request, args=("线程1",))
# 第二个线程：争抢连接
t2 = threading.Thread(target=make_request, args=("线程2",))

t1.start()
time.sleep(0.2)  # 保证线程1先占住连接
t2.start()

t1.join()
t2.join()
'''
连接池已满且不允许阻塞新的请求时，新的连接请求将会被丢弃。这意味着连接池无法处理所有的请求，可能会导致一些请求失败或被延迟处理。
所以在触发连接池已满的情况下不会报错且能正常运行，但在DEBUG日志下会有警告。
'''

验证连接池（num_pool）作用:

'num_pool控制的是最多允许缓存多少个不同主机的连接池，每一个host:port组合会对应一个connectionpool实例，当请求的host数超过num_pools时，旧的连接池将会被清理(LRU策略)'
# 创建连接池管理器，最多2个主机连接池
http = urllib3.PoolManager(num_pools=2, maxsize=1)

hosts = [
    "http://httpbin.org/get",
    "https://www.xiaohongshu.com/explore",
    "http://baidu.com"  # 任意有效网址也可
]

def fetch(url):
    try:
        r = http.request("GET", url)
        print(f"访问 {url} 状态码: {r.status}")
    except Exception as e:
        print(f"访问 {url} 出错: {e}")

# 访问3个不同host，超出num_pools限制
for i in range(2):
    for url in hosts:
        fetch(url)
        time.sleep(0.5)
'''
可以观察到每次发送请求前都得先建立连接，这是因为只能允许存在两个连接池，当继续往里添加连接池时，会把旧的清理，使得再次连接时需要重新建立连接
'''

计算机技术 on 南国遗梦的小站

Java核心技术卷1知识点

第1章 Java程序设计概述

Java语言的特点

Java体系结构

第2章 Java程序设计环境

第一个Java程序

Java程序结构

第3章 Java的基本程序设计结构

数据类型

变量与常量

运算符与表达式

流程控制结构

数组

第4章 对象与类

面向对象编程基础

类的定义与使用

访问控制

构造方法

方法详解

对象构造过程

类之间的关系

包

文档注释

类设计技巧

第1-4章复习重点

第5章 继承

类、超类和子类

多态

final关键字

Object：所有类的超类

抽象类

第6章 接口与内部类

接口

默认方法

lambda表达式

方法引用

内部类

第7章 异常处理

异常分类

异常处理机制

try-with-resources语句

自定义异常

异常使用最佳实践

第8章 泛型程序设计

为什么使用泛型

定义泛型类

泛型方法

类型变量的限定

泛型代码和虚拟机

泛型的限制与局限性

通配符（Wildcards）

泛型最佳实践

第4-8章复习重点

第9章 集合

Java集合框架概述

Collection接口体系

迭代器

Map接口

集合工具类

特殊集合

第10章 GUI程序设计

Java GUI工具包简史

基本GUI构建

布局管理器

事件处理机制

常用Swing组件

第11章 Swing用户界面组件

Swing高级组件

布局管理进阶

Swing特性与最佳实践

第12章 并发

线程基础

线程属性与控制

同步机制

线程安全集合

任务与线程池

异步计算

第9-12章复习重点

全局阈值二值化

第4章对象与类

第5章继承

第6章接口与内部类

第7章异常处理

第8章泛型程序设计

第9章集合

第12章并发