Python数据库编程教程:第 7 章 高级查询技巧(多表关联与子查询)
liuian 2025-10-14 01:02 25 浏览
在实际数据库开发中，单表查询无法满足复杂业务需求（如查询 “用户下单记录” 需关联 “用户表” 和 “订单表”）。本章基于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>
相关推荐
-
- 驱动网卡（怎么从新驱动网卡）
-
网卡一般是指为电脑主机提供有线无线网络功能的适配器。而网卡驱动指的就是电脑连接识别这些网卡型号的桥梁。网卡只有打上了网卡驱动才能正常使用。并不是说所有的网卡一插到电脑上面就能进行数据传输了，他都需要里面芯片组的驱动文件才能支持他进行数据传输...
-
2026-01-30 00:37 liuian
- win10更新助手装系统（微软win10更新助手）
-
1、点击首页“系统升级”的按钮，给出弹框，告诉用户需要上传IMEI码才能使用升级服务。同时给出同意和取消按钮。华为手机助手2、点击同意，则进入到“系统升级”功能华为手机助手华为手机助手3、在检测界面，...
- windows11专业版密钥最新（windows11专业版激活码永久）
-
Windows11专业版的正版密钥，我们是对windows的激活所必备的工具。该密钥我们可以通过微软商城或者通过计算机的硬件供应商去购买获得。获得了windows11专业版的正版密钥后，我...
-
- 手机删过的软件恢复（手机删除过的软件怎么恢复）
-
操作步骤：1、首先，我们需要先打开手机。然后在许多图标中找到带有[文件管理]文本的图标，然后单击“文件管理”进入页面。2、进入页面后，我们将在顶部看到一行文本：手机，最新信息，文档，视频，图片，音乐，收藏，最后是我们正在寻找的[更多]，单击...
-
2026-01-29 23:55 liuian
- 一键ghost手动备份系统步骤（一键ghost 备份）
-
步骤1、首先把装有一键GHOST装系统的U盘插在电脑上，然后打开电脑马上按F2或DEL键入BIOS界面，然后就选择BOOT打USDHDD模式选择好，然后按F10键保存，电脑就会马上重启。 步骤...
- 怎么创建局域网（怎么创建局域网打游戏）
-
1、购买路由器一台。进入路由器把dhcp功能打开 2、购买一台交换机。从路由器lan端口拉出一条网线查到交换机的任意一个端口上。 3、两台以上电脑。从交换机任意端口拉出网线插到电脑上（电脑设置...
- 精灵驱动器官方下载（精灵驱动手机版下载）
-
是的。驱动精灵是一款集驱动管理和硬件检测于一体的、专业级的驱动管理和维护工具。驱动精灵为用户提供驱动备份、恢复、安装、删除、在线更新等实用功能。1、全新驱动精灵2012引擎，大幅提升硬件和驱动辨识能力...
- 一键还原系统步骤（一键还原系统有哪些）
-
1、首先需要下载安装一下Windows一键还原程序，在安装程序窗口中，点击“下一步”，弹出“用户许可协议”窗口，选择“我同意该许可协议的条款”，并点击“下一步”。 2、在弹出的“准备安装”窗口中，可...
- 电脑加速器哪个好（电脑加速器哪款好）
-
我认为pp加速器最好用，飞速土豆太懒，急速酷六根本不工作。pp加速器什么网页都加速，太任劳任怨了！以上是个人观点，具体性能请自己试。ps：我家电脑性能很好。迅游加速盒子是可以加速电脑的。因为有过之...
- 任何u盘都可以做启动盘吗（u盘必须做成启动盘才能装系统吗）
-
是的，需要注意，U盘的大小要在4G以上，最好是8G以上，因为启动盘里面需要装系统，内存小的话，不能用来安装系统。内存卡或者U盘或者移动硬盘都可以用来做启动盘安装系统。普通的U盘就可以，不过最好U盘...
- u盘怎么恢复文件（u盘文件恢复的方法）
-
开360安全卫士，点击上面的“功能大全”。点击文件恢复然后点击“数据”下的“文件恢复”功能。选择驱动接着选择需要恢复的驱动，选择接入的U盘。点击开始扫描选好就点击中间的“开始扫描”，开始扫描U盘数据。...
- 系统虚拟内存太低怎么办（系统虚拟内存占用过高什么原因）
-
1.检查系统虚拟内存使用情况，如果发现有大量的空闲内存，可以尝试释放一些不必要的进程，以释放内存空间。2.如果系统虚拟内存使用率较高，可以尝试增加系统虚拟内存的大小，以便更多的应用程序可以使用更多...
-
- 剪贴板权限设置方法（剪贴板访问权限）
-
1、首先打开iphone手机，触碰并按住单词或图像直到显示选择选项。2、其次，然后选取“拷贝”或“剪贴板”。3、勾选需要的“权限”，最后选择开启，即可完成苹果剪贴板权限设置。仅参考1.打开苹果手机设置按钮,点击【通用】。2.点击【键盘】,再...
-
2026-01-29 21:37 liuian
- 平板系统重装大师（平板重装win系统）
-
如果你的平板开不了机，但可以连接上电脑，那就能好办，楼主下载安装个平板刷机王到你的个人电脑上，然后连接你的平板，平板刷机王会自动识别你的平板，平板刷机王上有你平板的我刷机包，楼主点击下载一个，下载完成...
- 联想官网售后服务网点（联想官网售后服务热线）
-
联想3c服务中心是联想旗下的官方售后，是基于互联网O2O模式开发的全新服务平台。可以为终端用户提供多品牌手机、电脑以及其他3C类产品的维修、保养和保险服务。根据客户需求层次，联想服务针对个人及家庭客户...
- 一周热门
-
-
用什么工具在Win中查看8G大的log文件?
-
如何在 Windows 10 或 11 上通过命令行安装 Node.js 和 NPM
-
如何修改图片拍摄日期?快速修改图片拍摄日期的6种方法
-
5步搞定动态考勤表!标记节假日、调休日?Excel自动变色!
-
RK3588-HDMIRX（瑞芯微rk3588芯片手册）
-
用纯Python轻松构建Web UI:Remi 动态更新，实时刷新界面内容
-
tplink无线路由器桥接教程（tplink路由器如何进行无线桥接）
-
R语言 | CNS绘图第1款——linkET万物皆可连
-
都说Feign是RPC，没有侵入性，为什么我的代码越来越像 C++
-
windows11专业版密钥最新（windows11专业版激活码永久）
-
- 最近发表
- 标签列表
-
- 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)