Python数据库编程教程:第 7 章 高级查询技巧(多表关联与子查询)
liuian 2025-10-14 01:02 6 浏览
在实际数据库开发中，单表查询无法满足复杂业务需求（如查询 “用户下单记录” 需关联 “用户表” 和 “订单表”）。本章基于python_db数据库，新增orders（订单表）和products（商品表），系统讲解 Python 实现多表关联查询（内连接、左连接、右连接）、子查询（相关子查询、非相关子查询）及视图操作的方法，通过规整案例帮助你掌握复杂数据提取的核心技能。
7.1 多表查询的基础准备
多表查询的前提是数据表间存在关联关系（通过外键实现）。本节先创建orders和products表，并插入测试数据，为后续查询做准备。
7.1.1 数据表设计（关联关系）
表名 | 作用 | 关联字段 | 关联表 |
users | 存储用户信息 | id（主键） | - |
products | 存储商品信息 | id（主键） | - |
orders | 存储用户订单信息 | user_id（外键） | users.id |
orders | 存储用户订单信息 | product_id（外键） | products.id |
7.1.2 创建关联表并插入数据
import mysql.connectorfrom mysql.connector import Error
from datetime import date
def create_related_tables():
"""创建products（商品表）和orders（订单表），并插入测试数据"""
connection = None
try:
connection = mysql.connector.connect(
host='localhost',
user='root',
password='your_password',
database='python_db'
)
connection.autocommit = False
cursor = connection.cursor()
# 1. 创建products表（商品表）
create_products = """
CREATE TABLE IF NOT EXISTS products (
id INT AUTO_INCREMENT PRIMARY KEY,
name VARCHAR(100) NOT NULL,
price DECIMAL(10,2) NOT NULL,
stock INT NOT NULL DEFAULT 0,
category VARCHAR(50)
)
"""
cursor.execute(create_products)
# 2. 创建orders表（订单表），通过外键关联users和products
create_orders = """
CREATE TABLE IF NOT EXISTS orders (
id INT AUTO_INCREMENT PRIMARY KEY,
user_id INT NOT NULL,
product_id INT NOT NULL,
order_date DATE NOT NULL,
quantity INT NOT NULL DEFAULT 1,
total_amount DECIMAL(10,2) NOT NULL,
-- 外键约束：user_id关联users表的id
FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
-- 外键约束：product_id关联products表的id
FOREIGN KEY (product_id) REFERENCES products(id) ON DELETE CASCADE
)
"""
cursor.execute(create_orders)
# 3. 向products表插入测试数据
insert_products = """
INSERT IGNORE INTO products (name, price, stock, category)
VALUES (%s, %s, %s, %s)
"""
products_data = [
("Python编程教程", 59.90, 100, "图书"),
("机械键盘", 299.00, 50, "数码"),
("无线鼠标", 89.50, 80, "数码"),
("数据结构与算法", 45.80, 70, "图书")
]
cursor.executemany(insert_products, products_data)
# 4. 向orders表插入测试数据（关联已存在的users和products）
insert_orders = """
INSERT IGNORE INTO orders (user_id, product_id, order_date, quantity, total_amount)
VALUES (%s, %s, %s, %s, %s)
"""
orders_data = [
(1, 1, date(2025, 8, 26), 2, 119.80), # 用户1（张三更新）买2本Python教程
(1, 3, date(2025, 8, 27), 1, 89.50), # 用户1买1个无线鼠标
(2, 2, date(2025, 8, 26), 1, 299.00), # 用户2（李四）买1个机械键盘
(3, 4, date(2025, 8, 28), 3, 137.40) # 用户3（王五）买3本数据结构
]
cursor.executemany(insert_orders, orders_data)
connection.commit()
print("关联表（products、orders）创建成功，测试数据插入完成")
# 验证表结构
print("\n=== 验证表结构 ===")
cursor.execute("DESCRIBE products")
print("products表结构：")
field_names = [f[0] for f in cursor.description]
print("|".join([f"{name:<15}" for name in field_names]))
print("-" * (15 * len(field_names) + len(field_names) - 1))
for row in cursor.fetchall():
print("|".join([f"{str(val):<15}" for val in row]))
cursor.execute("DESCRIBE orders")
print("\norders表结构：")
field_names = [f[0] for f in cursor.description]
print("|".join([f"{name:<15}" for name in field_names]))
print("-" * (15 * len(field_names) + len(field_names) - 1))
for row in cursor.fetchall():
print("|".join([f"{str(val):<15}" for val in row]))
except Error as e:
print(f"创建关联表出错：{e}")
if connection:
connection.rollback()
finally:
if connection and connection.is_connected():
cursor.close()
connection.close()
print("\nMySQL连接已关闭")
if __name__ == "__main__":
create_related_tables()
运行结果（规整对齐）
关联表（products、orders）创建成功，测试数据插入完成=== 验证表结构 ===
products表结构：
Field |Type |Null |Key |Default |Extra
---------------------------------------------------------------------------------------------------
id |int |NO |PRI |None |auto_increment
name |varchar(100) |NO | |None |
price |decimal(10,2) |NO | |None |
stock |int |NO | |0 |
category |varchar(50) |YES | |None |
orders表结构：
Field |Type |Null |Key |Default |Extra
---------------------------------------------------------------------------------------------------
id |int |NO |PRI |None |auto_increment
user_id |int |NO |MUL |None |
product_id |int |NO |MUL |None |
order_date |date |NO | |None |
quantity |int |NO | |1 |
total_amount |decimal(10,2) |NO | |None |
MySQL连接已关闭
7.2 多表关联查询（JOIN 子句）
多表关联查询通过JOIN子句将多个表按关联字段拼接，提取跨表的组合数据，常用类型包括内连接、左连接、右连接。
7.2.1 内连接（INNER JOIN）
- 作用：只返回两个表中符合关联条件的记录（交集），无匹配的记录会被过滤。
- 语法：
SELECT 字段 FROM 表1
INNER JOIN 表2
ON 表1.关联字段 = 表2.关联字段
[WHERE 条件];
案例：查询用户的订单详情（关联 users、orders、products）
需求：获取用户姓名、订单日期、商品名称、购买数量、订单总金额。
def inner_join_demo():connection = None
try:
connection = mysql.connector.connect(
host='localhost',
user='root',
password='your_password',
database='python_db'
)
cursor = connection.cursor()
# 内连接查询：users + orders + products
inner_query = """
SELECT
u.name AS user_name,
o.order_date,
p.name AS product_name,
o.quantity,
o.total_amount
FROM users u
INNER JOIN orders o ON u.id = o.user_id
INNER JOIN products p ON o.product_id = p.id
ORDER BY o.order_date DESC
"""
cursor.execute(inner_query)
result = cursor.fetchall()
total_count = cursor.rowcount
# 打印结果
print(f"=== 内连接查询结果（共{total_count}条记录）===")
field_names = [f[0] for f in cursor.description] # 字段名：user_name、order_date等
print("|".join([f"{name:<15}" for name in field_names]))
print("-" * (15 * len(field_names) + len(field_names) - 1))
for row in result:
# 格式化日期和金额（保留2位小数）
formatted_row = list(row)
formatted_row[1] = str(formatted_row[1]) # 日期转字符串
formatted_row[4] = f"{formatted_row[4]:.2f}" # 金额保留2位小数
print("|".join([f"{str(val):<15}" for val in formatted_row]))
except Error as e:
print(f"内连接查询出错：{e}")
finally:
if connection and connection.is_connected():
cursor.close()
connection.close()
if __name__ == "__main__":
inner_join_demo()
运行结果（规整对齐）
=== 内连接查询结果（共4条记录）===user_name |order_date |product_name |quantity |total_amount
---------------------------------------------------------------------------------------------------
王五 |2025-08-28 |数据结构与算法 |3 |137.40
张三更新 |2025-08-27 |无线鼠标 |1 |89.50
张三更新 |2025-08-26 |Python编程教程 |2 |119.80
李四 |2025-08-26 |机械键盘 |1 |299.00
7.2.2 左连接（LEFT JOIN）
- 作用：返回左表（JOIN左侧的表）的所有记录，即使右表无匹配记录（无匹配时右表字段为NULL）。
- 语法：
SELECT 字段 FROM 左表
LEFT JOIN 右表
ON 左表.关联字段 = 右表.关联字段
[WHERE 条件];
案例：查询所有用户的订单情况（含无订单用户）
需求：获取所有用户姓名、邮箱，以及他们的订单日期（无订单用户显示 “无订单”）。
def left_join_demo():connection = None
try:
connection = mysql.connector.connect(
host='localhost',
user='root',
password='your_password',
database='python_db'
)
cursor = connection.cursor()
# 左连接查询：users（左表）LEFT JOIN orders（右表）
left_query = """
SELECT
u.name AS user_name,
u.email,
IF(o.order_date IS NULL, '无订单', o.order_date) AS order_date
FROM users u
LEFT JOIN orders o ON u.id = o.user_id
ORDER BY u.id ASC
"""
cursor.execute(left_query)
result = cursor.fetchall()
total_count = cursor.rowcount
print(f"=== 左连接查询结果（共{total_count}条记录）===")
field_names = [f[0] for f in cursor.description]
print("|".join([f"{name:<20}" for name in field_names]))
print("-" * (20 * len(field_names) + len(field_names) - 1))
for row in result:
print("|".join([f"{str(val):<20}" for val in row]))
except Error as e:
print(f"左连接查询出错：{e}")
finally:
if connection and connection.is_connected():
cursor.close()
connection.close()
if __name__ == "__main__":
left_join_demo()
运行结果（规整对齐）
=== 左连接查询结果（共5条记录）==="user_name |email |order_date
--------------------------------------------------------------------------
张三更新 |zhangsan@new-example.com|2025-08-26
张三更新 |zhangsan@new-example.com|2025-08-27
李四 |lisi@new-example.com|2025-08-26
王五 |wangwu@new-example.com|2025-08-28
赵六 |zhaoliu@new-example.com|无订单
7.2.3 右连接（RIGHT JOIN）
- 作用：与左连接相反，返回右表的所有记录，即使左表无匹配记录（无匹配时左表字段为NULL）。
- 语法：
SELECT 字段 FROM 左表
RIGHT JOIN 右表
ON 左表.关联字段 = 右表.关联字段
[WHERE 条件];
案例：查询所有商品的被购买情况（含未售出商品）
需求：获取所有商品名称、价格，以及购买该商品的用户名（未售出商品显示 “未售出”）。
def right_join_demo():connection = None
try:
connection = mysql.connector.connect(
host='localhost',
user='root',
password='your_password',
database='python_db'
)
cursor = connection.cursor()
# 右连接查询：users（左表）RIGHT JOIN products（右表），通过orders关联
right_query = """
SELECT
IF(u.name IS NULL, '未售出', u.name) AS buyer_name,
p.name AS product_name,
p.price
FROM users u
RIGHT JOIN orders o ON u.id = o.user_id
RIGHT JOIN products p ON o.product_id = p.id
ORDER BY p.id ASC
"""
cursor.execute(right_query)
result = cursor.fetchall()
total_count = cursor.rowcount
print(f"=== 右连接查询结果（共{total_count}条记录）===")
field_names = [f[0] for f in cursor.description]
print("|".join([f"{name:<15}" for name in field_names]))
print("-" * (15 * len(field_names) + len(field_names) - 1))
for row in result:
formatted_row = list(row)
formatted_row[2] = f"{formatted_row[2]:.2f}" # 价格保留2位小数
print("|".join([f"{str(val):<15}" for val in formatted_row]))
except Error as e:
print(f"右连接查询出错：{e}")
finally:
if connection and connection.is_connected():
cursor.close()
connection.close()
if __name__ == "__main__":
right_join_demo()
运行结果（规整对齐）
=== 右连接查询结果（共4条记录）===buyer_name |product_name |price
---------------------------------------------
张三更新 |Python编程教程 |59.90
李四 |机械键盘 |299.00
张三更新 |无线鼠标 |89.50
王五 |数据结构与算法 |45.80
7.2.4 三种连接方式对比
连接类型 | 核心逻辑 | 适用场景 | 数据范围（以 users 和 orders 为例） |
内连接（INNER JOIN） | 取两表匹配记录的交集 | 需同时获取两表关联数据（如 “有订单的用户”） | 仅返回有订单的用户记录，无订单用户和无用户的订单（不存在）均过滤 |
左连接（LEFT JOIN） | 取左表所有记录，右表匹配补充 | 需展示左表完整数据 + 右表关联数据（如 “所有用户及订单”） | 返回所有用户记录，有订单的显示订单信息，无订单的订单字段为 “无订单” |
右连接（RIGHT JOIN） | 取右表所有记录，左表匹配补充 | 需展示右表完整数据 + 左表关联数据（如 “所有商品及购买用户”） | 返回所有商品记录，有购买的显示用户信息，未售出的用户字段为 “未售出” |
7.3 子查询（嵌套查询）
子查询是指在一个查询语句中嵌套另一个查询语句，外层查询称为 “主查询”，内层查询称为 “子查询”。子查询可作为主查询的条件、字段或数据源，适用于复杂条件筛选（如 “查询购买过‘图书’类商品的用户”）。
7.3.1 子查询的分类
根据子查询与主查询的依赖关系，分为两类：
- 非相关子查询：子查询可独立执行，结果不依赖主查询（先执行子查询，再将结果作为主查询条件）。
- 相关子查询：子查询的执行依赖主查询的字段值（主查询每执行一条记录，子查询执行一次，类似循环）。
7.3.2 非相关子查询案例
案例 1：查询购买过 “图书” 类商品的用户信息
需求：先查询 “图书” 类商品的product_id（子查询），再查询购买过这些商品的用户（主查询）。
def non_correlated_subquery_demo1():connection = None
try:
connection = mysql.connector.connect(
host='localhost',
user='root',
password='your_password',
database='python_db'
)
cursor = connection.cursor()
# 非相关子查询：先查图书类商品的product_id，再查购买过这些商品的用户
query = """
SELECT DISTINCT u.name AS user_name, u.email, u.balance
FROM users u
INNER JOIN orders o ON u.id = o.user_id
WHERE o.product_id IN (
-- 子查询：查询图书类商品的ID
SELECT id FROM products WHERE category = %s
)
ORDER BY u.id ASC
"""
cursor.execute(query, ("图书",))
result = cursor.fetchall()
total_count = cursor.rowcount
print(f"=== 非相关子查询结果（购买过图书的用户，共{total_count}条）===")
field_names = [f[0] for f in cursor.description]
print("|".join([f"{name:<20}" for name in field_names]))
print("-" * (20 * len(field_names) + len(field_names) - 1))
for row in result:
formatted_row = list(row)
formatted_row[2] = f"{formatted_row[2]:.2f}" # 余额保留2位小数
print("|".join([f"{str(val):<20}" for val in formatted_row]))
except Error as e:
print(f"非相关子查询出错：{e}")
finally:
if connection and connection.is_connected():
cursor.close()
connection.close()
if __name__ == "__main__":
non_correlated_subquery_demo1()
运行结果（规整对齐）
=== 非相关子查询结果（购买过图书的用户，共2条）===user_name |email |balance
--------------------------------------------------------------------------
张三更新 |zhangsan@new-example.com|900.00
王五 |wangwu@new-example.com|1000.00
案例 2：查询订单总金额大于平均订单金额的订单详情
需求：先计算所有订单的平均总金额（子查询），再查询总金额超过该平均值的订单（主查询）。
def non_correlated_subquery_demo2():connection = None
try:
connection = mysql.connector.connect(
host='localhost',
user='root',
password='your_password',
database='python_db'
)
cursor = connection.cursor()
# 非相关子查询：先查平均订单金额，再查超过平均值的订单
query = """
SELECT
o.id AS order_id,
u.name AS user_name,
p.name AS product_name,
o.total_amount
FROM orders o
INNER JOIN users u ON o.user_id = u.id
INNER JOIN products p ON o.product_id = p.id
WHERE o.total_amount > (
-- 子查询：计算所有订单的平均总金额
SELECT AVG(total_amount) FROM orders
)
ORDER BY o.total_amount DESC
"""
cursor.execute(query)
result = cursor.fetchall()
total_count = cursor.rowcount
# 先获取平均订单金额（用于结果说明）
cursor.execute("SELECT AVG(total_amount) FROM orders")
avg_amount = cursor.fetchone()[0]
print(f"=== 非相关子查询结果（订单金额>平均金额{avg_amount:.2f}元，共{total_count}条）===")
field_names = [f[0] for f in cursor.description]
print("|".join([f"{name:<15}" for name in field_names]))
print("-" * (15 * len(field_names) + len(field_names) - 1))
for row in result:
formatted_row = list(row)
formatted_row[3] = f"{formatted_row[3]:.2f}" # 金额保留2位小数
print("|".join([f"{str(val):<15}" for val in formatted_row]))
except Error as e:
print(f"非相关子查询出错：{e}")
finally:
if connection and connection.is_connected():
cursor.close()
connection.close()
if __name__ == "__main__":
non_correlated_subquery_demo2()
运行结果（规整对齐）
=== 非相关子查询结果（订单金额>平均金额161.42元，共1条）===order_id |user_name |product_name |total_amount
---------------------------------------------------------------------------------------------------
2 |李四 |机械键盘 |299.00
7.3.3 相关子查询案例
案例：查询每个用户的最新订单
需求：对每个用户（主查询），查询其订单日期最大的订单（子查询依赖主查询的user_id）。
def correlated_subquery_demo():connection = None
try:
connection = mysql.connector.connect(
host='localhost',
user='root',
password='your_password',
database='python_db'
)
cursor = connection.cursor()
# 相关子查询：主查询遍历每个用户，子查询查该用户的最新订单
query = """
SELECT
u.name AS user_name,
o.order_date AS latest_order_date,
p.name AS latest_product,
o.total_amount
FROM users u
INNER JOIN orders o ON u.id = o.user_id
INNER JOIN products p ON o.product_id = p.id
WHERE o.order_date = (
-- 子查询：依赖主查询的u.id，查该用户的最大订单日期
SELECT MAX(order_date) FROM orders WHERE user_id = u.id
)
ORDER BY u.id ASC
"""
cursor.execute(query)
result = cursor.fetchall()
total_count = cursor.rowcount
print(f"=== 相关子查询结果（每个用户的最新订单，共{total_count}条）===")
field_names = [f[0] for f in cursor.description]
print("|".join([f"{name:<20}" for name in field_names]))
print("-" * (20 * len(field_names) + len(field_names) - 1))
for row in result:
formatted_row = list(row)
formatted_row[1] = str(formatted_row[1]) # 日期转字符串
formatted_row[3] = f"{formatted_row[3]:.2f}" # 金额保留2位小数
print("|".join([f"{str(val):<20}" for val in formatted_row]))
except Error as e:
print(f"相关子查询出错：{e}")
finally:
if connection and connection.is_connected():
cursor.close()
connection.close()
if __name__ == "__main__":
correlated_subquery_demo()
运行结果（规整对齐）
=== 相关子查询结果（每个用户的最新订单，共3条）===user_name |latest_order_date |latest_product |total_amount
----------------------------------------------------------------------------------------------------------
张三更新 |2025-08-27 |无线鼠标 |89.50
李四 |2025-08-26 |机械键盘 |299.00
王五 |2025-08-28 |数据结构与算法 |137.40
7.4 视图操作（VIEW）
视图是基于查询结果创建的虚拟表，它不存储实际数据，仅保存查询语句。视图可简化复杂查询（如将多表关联查询封装为视图，后续直接查询视图即可），同时能控制数据访问权限（如只展示部分字段，隐藏敏感信息）。
7.4.1 视图的核心作用
- 简化查询：将复杂的多表关联、子查询封装为视图，后续查询无需重复编写复杂 SQL。
- 数据安全：可只暴露非敏感字段（如视图中不包含用户的balance字段）。
- 数据一致性：多个业务场景使用同一视图，确保查询逻辑一致。
7.4.2 创建视图（CREATE VIEW）
案例：创建 “用户订单详情视图”（封装多表关联查询）
def create_view_demo():connection = None
try:
connection = mysql.connector.connect(
host='localhost',
user='root',
password='your_password',
database='python_db'
)
cursor = connection.cursor()
# 创建视图：用户订单详情（包含用户姓名、订单ID、商品名称、订单金额等）
create_view_query = """
CREATE VIEW user_order_detail AS
SELECT
u.id AS user_id,
u.name AS user_name,
o.id AS order_id,
o.order_date,
p.name AS product_name,
o.quantity,
o.total_amount,
p.category AS product_category
FROM users u
INNER JOIN orders o ON u.id = o.user_id
INNER JOIN products p ON o.product_id = p.id
"""
# 若视图已存在，先删除再创建（可选）
cursor.execute("DROP VIEW IF EXISTS user_order_detail")
cursor.execute(create_view_query)
connection.commit()
print("视图'user_order_detail'创建成功")
# 验证视图：查询视图数据（与查询普通表一致）
print("\n=== 验证视图数据（前3条）===")
cursor.execute("SELECT * FROM user_order_detail LIMIT 3")
result = cursor.fetchall()
field_names = [f[0] for f in cursor.description]
print("|".join([f"{name:<15}" for name in field_names]))
print("-" * (15 * len(field_names) + len(field_names) - 1))
for row in result:
formatted_row = list(row)
formatted_row[3] = str(formatted_row[3]) # 日期转字符串
formatted_row[6] = f"{formatted_row[6]:.2f}" # 金额保留2位小数
print("|".join([f"{str(val):<15}" for val in formatted_row]))
except Error as e:
print(f"创建视图出错：{e}")
if connection:
connection.rollback()
finally:
if connection and connection.is_connected():
cursor.close()
connection.close()
if __name__ == "__main__":
create_view_demo()
运行结果（规整对齐）
视图'user_order_detail'创建成功=== 验证视图数据（前3条）===
user_id |user_name |order_id |order_date |product_name |quantity |total_amount |product_category
---------------------------------------------------------------------------------------------------------------------------------------
1 |张三更新 |1 |2025-08-26 |Python编程教程 |2 |119.80 |图书
1 |张三更新 |2 |2025-08-27 |无线鼠标 |1 |89.50 |数码
2 |李四 |3 |2025-08-26 |机械键盘 |1 |299.00 |数码
7.4.3 查询视图与修改视图
1. 查询视图（与普通表一致）
def query_view_demo():"""查询视图：筛选图书类商品的订单"""
connection = None
try:
connection = mysql.connector.connect(
host='localhost',
user='root',
password='your_password',
database='python_db'
)
cursor = connection.cursor()
# 查询视图：筛选图书类商品的订单
query = "SELECT user_name, order_date, product_name, total_amount FROM user_order_detail WHERE product_category = %s"
cursor.execute(query, ("图书",))
result = cursor.fetchall()
total_count = cursor.rowcount
print(f"=== 视图查询结果（图书类商品订单，共{total_count}条）===")
field_names = [f[0] for f in cursor.description]
print("|".join([f"{name:<20}" for name in field_names]))
print("-" * (20 * len(field_names) + len(field_names) - 1))
for row in result:
formatted_row = list(row)
formatted_row[1] = str(formatted_row[1])
formatted_row[3] = f"{formatted_row[3]:.2f}"
print("|".join([f"{str(val):<20}" for val in formatted_row]))
except Error as e:
print(f"查询视图出错：{e}")
finally:
if connection and connection.is_connected():
cursor.close()
connection.close()
# 执行视图查询
# query_view_demo()
2. 修改视图（ALTER VIEW）
def alter_view_demo():"""修改视图：新增用户邮箱字段"""
connection = None
try:
connection = mysql.connector.connect(
host='localhost',
user='root',
password='your_password',
database='python_db'
)
cursor = connection.cursor()
# 修改视图：新增u.email字段
alter_view_query = """
ALTER VIEW user_order_detail AS
SELECT
u.id AS user_id,
u.name AS user_name,
u.email AS user_email, -- 新增邮箱字段
o.id AS order_id,
o.order_date,
p.name AS product_name,
o.quantity,
o.total_amount,
p.category AS product_category
FROM users u
INNER JOIN orders o ON u.id = o.user_id
INNER JOIN products p ON o.product_id = p.id
"""
cursor.execute(alter_view_query)
connection.commit()
print("视图'user_order_detail'修改成功（新增user_email字段）")
# 验证修改结果
cursor.execute("SELECT user_name, user_email, product_name FROM user_order_detail LIMIT 2")
result = cursor.fetchall()
field_names = [f[0] for f in cursor.description]
print("\n=== 验证修改后的视图 ===")
print("|".join([f"{name:<20}" for name in field_names]))
print("-" * (20 * len(field_names) + len(field_names) - 1))
for row in result:
print("|".join([</doubaocanvas>
相关推荐
- Spring Boot + Vue.js 实现前后端分离(附源码)
-
作者：梁小生0101链接：juejin.im/post/5c622fb5e51d457f9f2c2381SpringBoot+Vue.js前后端涉及基本概念介绍，搭建记录，本文会列举出用到环...
- C#一步一步实现自己的插件框架(四)，从此告别代码紧耦合
-
初学者写程序一般就是拖控件,双击,然后写上执行的代码,这样在窗口中就有很多事件代码,如果要实现各按钮的状态,那得在很多地方修改代码,极为复杂.通过参考CSHARPDEVELOP的代码就说明和网上各位...
- 基于UI组件的Vue可视化布局、快速生成.vue代码
-
一、项目简介基于UI组件的Vue可视化布局、快速生成.vue代码二、实现功能通用（文本、链接、换行、div、图片）支持elementUI支持iViewUI（button、icon、radio、sel...
- 【开源资讯】ViewUI 4.2.0(原 iView)发布，企业级 UI 组件库
-
简介iView作者Aresn于2019年创办了北京视图更新科技有限公司，开始自由、全职地维护iView及其相关的软件。ViewUI即为原先的iView，从2019年10月起...
- Python GUI 编程入门教程 第25章:记账本应用升级—类别统计与图表
-
25.1项目目标在第24章的月份筛选功能基础上，新增：类别输入：记录时选择支出/收入类别，例如：餐饮、交通、购物、工资、理财等类别统计：计算选定月份的各类别总额类别图表：生成饼图，展示各类别所占...
- Python GUI 编程入门教程 第8章:文件处理、数据库操作与网络通信
-
8.1文件操作：处理本地文件与文件对话框在Tkinter应用中，文件操作是常见的需求。Tkinter提供了简单的文件对话框来帮助用户选择文件，并能通过Python内建的文件处理模块来读取和写入文件。...
- 手把手教你用Python做个可视化的“剪刀石头布”小游戏
-
/1前言/最近在学习PyQt5可视化界面，这是一个内容非常丰富的gui库，相对于tkinter库，功能更加强大，界面更加美观，操作也不难。于是我开始小试牛刀，用PyQt5做个可视化的“剪刀石头布”...
- 掌握基础技能快速用Python设计界面
-
我们在设计软件界面的时候，应该掌握一定的基础知识，不能我们看起来非常费解也很累。到后面设计界面的时候，很多基础知识不可能如你开始学的时候讲的那样仔细。熟练掌握Python的基本语法，如变量、数据类型...
- Python GUI 编程入门教程 第22章:综合实战项目——记账本应用
-
22.1项目目标我们要开发一个带数据库的记账本，主要功能：添加收支记录（日期、类别、金额、备注）显示所有记录（表格形式）支持删除记录自动保存到SQLite数据库统计总收支22.2项目结构budge...
- Python GUI 编程入门教程 第10章:高级布局与界面美化
-
10.1高级布局管理：使用grid和placeTkinter提供了三种常用的布局管理方式：pack、grid和place。在本章中，我们重点介绍grid和place，这两种布局方式相较于pack更加...
- 别再手动复制粘贴了!Python一招搞定取PDF内容，效率提升10倍!
-
别再手动复制粘贴了！Python一招搞定取PDF内容，效率提升10倍！还在为PDF内容提取头疼？100页的文档要折腾一下午？今天教你用Python几行代码搞定，10秒钟解决战斗，办公室小白也能轻松学会...
- DearPyGui:GUI 性能秒杀 PyQt，揭秘 GPU 加速的 DearPyGui
-
什么是DearPyGui？嘿，最近我发现了一个超有意思的PythonGUI框架——DearPyGui。名字有点拗口，但它可不是随便起的。它基于C++和GPU渲染，性能吊打传统的Tki...
- Python GUI 编程入门教程 第7章:事件绑定、动画效果与外部交互
-
7.1事件绑定：响应用户操作在Tkinter中，事件绑定允许你为控件添加响应函数，以处理用户的输入事件，如鼠标点击、键盘输入等。事件可以是各种形式的交互，如点击按钮、键盘按键等。7.1.1绑定鼠标...
- Python GUI 编程入门教程 第21章:综合实战项目——记事本应用
-
21.1项目目标我们要实现一个简易版的记事本，具备以下功能：新建、打开、保存文件复制、粘贴、剪切、全选设置字体大小查找文字显示应用信息界面大致效果如下：+----------------------...
- Python GUI 编程入门教程 第14章:构建复杂图形界面
-
14.1界面布局管理在Tkinter中，界面控件的排列是通过布局管理器来实现的。Tkinter提供了三种布局管理器：pack、grid和place，每种布局管理器都有其独特的用途和优势。14.1.1...
- 一周热门
- 最近发表
-
- Spring Boot + Vue.js 实现前后端分离(附源码)
- C#一步一步实现自己的插件框架(四)，从此告别代码紧耦合
- 基于UI组件的Vue可视化布局、快速生成.vue代码
- 【开源资讯】ViewUI 4.2.0(原 iView)发布，企业级 UI 组件库
- Python GUI 编程入门教程 第25章:记账本应用升级—类别统计与图表
- Python GUI 编程入门教程 第8章:文件处理、数据库操作与网络通信
- 手把手教你用Python做个可视化的“剪刀石头布”小游戏
- 掌握基础技能快速用Python设计界面
- Python GUI 编程入门教程 第22章:综合实战项目——记账本应用
- Python GUI 编程入门教程 第10章:高级布局与界面美化
- 标签列表
-
- python判断字典是否为空 (50)
- crontab每周一执行 (48)
- aes和des区别 (43)
- bash脚本和shell脚本的区别 (35)
- canvas库 (33)
- dataframe筛选满足条件的行 (35)
- gitlab日志 (33)
- lua xpcall (36)
- blob转json (33)
- python判断是否在列表中 (34)
- python html转pdf (36)
- 安装指定版本npm (37)
- idea搜索jar包内容 (33)
- css鼠标悬停出现隐藏的文字 (34)
- linux nacos启动命令 (33)
- gitlab 日志 (36)
- adb pull (37)
- python判断元素在不在列表里 (34)
- python 字典删除元素 (34)
- vscode切换git分支 (35)
- python bytes转16进制 (35)
- grep前后几行 (34)
- hashmap转list (35)
- c++ 字符串查找 (35)
- mysql刷新权限 (34)