MySQL 子查询

于 2025-08-20 11:33:09 发布
阅读量461 收藏 16
点赞数 13
CC 4.0 BY-SA版权
分类专栏： # Mysql 文章标签： mysql 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/json_ligege/article/details/150549773

MySQL支持将一个查询语句嵌套在另一个查询语句中，嵌套在另一个查询语句中的SQL语句就是子查询语句。

目录

数据表

商品表

新增商品数据

商品分类表

新增商品分类数据

MySQL 子查询

ANY子查询

ALL子查询

EXISTS子查询

NOT EXISTS子查询

IN子查询

NOT IN子查询

子查询作为结果字段

总结

数据表

准备示例数据表及数据

商品表

创建商品表，创建SQL如下：

CREATE TABLE `t_goods` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `t_category_id` int(11) DEFAULT NULL,
  `t_category` varchar(30) DEFAULT NULL,
  `t_name` varchar(50) DEFAULT NULL,
  `t_price` decimal(10,2) DEFAULT NULL,
  `t_stock` int(11) DEFAULT NULL,
  `t_upper_time` datetime DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `foreign_category` (`t_category_id`)
)

新增商品数据

新增商品表测试数据，SQL如下：

INSERT INTO `t_goods` (`id`, `t_category_id`, `t_category`, `t_name`, `t_price`, `t_stock`, `t_upper_time`) VALUES (1, 1, '女装/女士精品', 'T恤', 39.90, 1000, '2025-08-14 00:00:00');
INSERT INTO `t_goods` (`id`, `t_category_id`, `t_category`, `t_name`, `t_price`, `t_stock`, `t_upper_time`) VALUES (2, 1, '女装/女士精品', '连衣裙', 79.90, 2500, '2025-08-14 00:00:00');
INSERT INTO `t_goods` (`id`, `t_category_id`, `t_category`, `t_name`, `t_price`, `t_stock`, `t_upper_time`) VALUES (3, 1, '女装/女士精品', '卫衣', 89.90, 1500, '2025-08-14 00:00:00');
INSERT INTO `t_goods` (`id`, `t_category_id`, `t_category`, `t_name`, `t_price`, `t_stock`, `t_upper_time`) VALUES (4, 1, '女装/女士精品', '牛仔裤', 89.90, 3500, '2025-08-14 00:00:00');
INSERT INTO `t_goods` (`id`, `t_category_id`, `t_category`, `t_name`, `t_price`, `t_stock`, `t_upper_time`) VALUES (5, 1, '女装/女士精品', '百褶裙', 29.90, 500, '2025-08-14 00:00:00');
INSERT INTO `t_goods` (`id`, `t_category_id`, `t_category`, `t_name`, `t_price`, `t_stock`, `t_upper_time`) VALUES (6, 1, '女装/女士精品', '呢绒外套', 399.90, 1200, '2025-08-14 00:00:00');
INSERT INTO `t_goods` (`id`, `t_category_id`, `t_category`, `t_name`, `t_price`, `t_stock`, `t_upper_time`) VALUES (7, 2, '户外运动', '自行车', 399.90, 1000, '2025-08-14 00:00:00');
INSERT INTO `t_goods` (`id`, `t_category_id`, `t_category`, `t_name`, `t_price`, `t_stock`, `t_upper_time`) VALUES (8, 2, '户外运动', '山地自行车', 1399.90, 2500, '2025-08-14 00:00:00');
INSERT INTO `t_goods` (`id`, `t_category_id`, `t_category`, `t_name`, `t_price`, `t_stock`, `t_upper_time`) VALUES (9, 2, '户外运动', '登山杖', 59.90, 1500, '2025-08-14 00:00:00');
INSERT INTO `t_goods` (`id`, `t_category_id`, `t_category`, `t_name`, `t_price`, `t_stock`, `t_upper_time`) VALUES (10, 2, '户外运动', '骑行装备', 399.90, 3500, '2025-08-14 00:00:00');
INSERT INTO `t_goods` (`id`, `t_category_id`, `t_category`, `t_name`, `t_price`, `t_stock`, `t_upper_time`) VALUES (11, 2, '户外运动', '运动外套', 799.90, 500, '2025-08-14 00:00:00');
INSERT INTO `t_goods` (`id`, `t_category_id`, `t_category`, `t_name`, `t_price`, `t_stock`, `t_upper_time`) VALUES (12, 2, '户外运动', '滑板', 499.90, 1200, '2025-08-14 00:00:00');
INSERT INTO `t_goods` (`id`, `t_category_id`, `t_category`, `t_name`, `t_price`, `t_stock`, `t_upper_time`) VALUES (13, 5, '水果', '葡萄', 49.90, 1000, '2025-08-14 00:00:00');
INSERT INTO `t_goods` (`id`, `t_category_id`, `t_category`, `t_name`, `t_price`, `t_stock`, `t_upper_time`) VALUES (14, 5, '水果', '香蕉', 39.90, 1000, '2025-08-14 00:00:00');

商品分类表

创建商品分类表，创建SQL如下：

CREATE TABLE `t_goods_category` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `t_category` varchar(30) DEFAULT NULL,
  PRIMARY KEY (`id`)
)

新增商品分类数据

新增商品分类表测试数据，SQL如下：

INSERT INTO `t_goods_category` (`id`, `t_category`) VALUES (1, '女装/女士精品');
INSERT INTO `t_goods_category` (`id`, `t_category`) VALUES (2, '户外运动');
INSERT INTO `t_goods_category` (`id`, `t_category`) VALUES (3, '男装');
INSERT INTO `t_goods_category` (`id`, `t_category`) VALUES (4, '童装');
INSERT INTO `t_goods_category` (`id`, `t_category`) VALUES (5, '水果');

MySQL 子查询

子查询语句可以添加到SELECT、UPDATE和DELETE语句中，常用的操作符包括ANY、SOME、ALL、EXISTS、NOT EXISTS、IN和NOT IN等。

ANY子查询

ANY关键字表示如果与子查询返回的任何值相匹配，则返回TRUE，否则返回FALSE。

例：查询t_goods数据表中t_category_id字段值大于t_goods_category数据表中任意一个id字段值的数据。

mysql> SELECT id, t_category_id, t_category, t_name, t_price FROM t_goods WHERE t_category_id > ANY (SELECT id FROM t_goods_category); 
+----+---------------+------------+------------+---------+
| id | t_category_id | t_category | t_name     | t_price |
+----+---------------+------------+------------+---------+
|  7 |             2 | 户外运动   | 自行车     | 399.90  |
|  8 |             2 | 户外运动   | 山地自行车 | 1399.90 |
|  9 |             2 | 户外运动   | 登山杖     | 59.90   |
| 10 |             2 | 户外运动   | 骑行装备   | 399.90  |
| 11 |             2 | 户外运动   | 运动外套   | 799.90  |
| 12 |             2 | 户外运动   | 滑板       | 499.90  |
| 13 |             5 | 水果       | 葡萄       | 49.90   |
| 14 |             5 | 水果       | 香蕉       | 39.90   |
+----+---------------+------------+------------+---------+
8 rows in set (0.04 sec)

mysql> SELECT id, t_category_id, t_category, t_name, t_price FROM t_goods WHERE t_category_id > SOME (SELECT id FROM t_goods_category); 
+----+---------------+------------+------------+---------+
| id | t_category_id | t_category | t_name     | t_price |
+----+---------------+------------+------------+---------+
|  7 |             2 | 户外运动   | 自行车     | 399.90  |
|  8 |             2 | 户外运动   | 山地自行车 | 1399.90 |
|  9 |             2 | 户外运动   | 登山杖     | 59.90   |
| 10 |             2 | 户外运动   | 骑行装备   | 399.90  |
| 11 |             2 | 户外运动   | 运动外套   | 799.90  |
| 12 |             2 | 户外运动   | 滑板       | 499.90  |
| 13 |             5 | 水果       | 葡萄       | 49.90   |
| 14 |             5 | 水果       | 香蕉       | 39.90   |
+----+---------------+------------+------------+---------+
8 rows in set (0.04 sec)

注意：SOME子查询的作用与ANY子查询的作用相同，不再赘述。

ALL子查询

ALL关键字表示如果同时满足所有子查询的条件，则返回TRUE，否则返回FALSE。

例：查询t_goods数据表中t_category_id字段值大于t_goods_category数据表中所有id字段值的数据。

mysql> SELECT id, t_category_id, t_category, t_name, t_price FROM t_goods  WHERE t_category_id > ALL (SELECT id FROM t_goods_category);
Empty set

mysql> SELECT id, t_category_id, t_category, t_name, t_price FROM t_goods  WHERE t_category_id > ALL (SELECT id FROM t_goods_category where id < 5);
+----+---------------+------------+--------+---------+
| id | t_category_id | t_category | t_name | t_price |
+----+---------------+------------+--------+---------+
| 13 |             5 | 水果       | 葡萄   | 49.90   |
| 14 |             5 | 水果       | 香蕉   | 39.90   |
+----+---------------+------------+--------+---------+
2 rows in set (0.05 sec)

EXISTS子查询

EXISTS关键字表示如果存在某种条件，则返回TRUE，否则返回FALSE。

例：查询t_goods_category数据表中是否存在id为2的数据，如果存在，则查询t_goods数据表中t_category_id为2的数据。

mysql> SELECT id, t_category_id, t_category, t_name, t_price FROM t_goods WHERE EXISTS (SELECT t_category FROM t_goods_category WHERE id = 2) AND t_category_id = 2;
+----+---------------+------------+------------+---------+
| id | t_category_id | t_category | t_name     | t_price |
+----+---------------+------------+------------+---------+
|  7 |             2 | 户外运动   | 自行车     | 399.90  |
|  8 |             2 | 户外运动   | 山地自行车 | 1399.90 |
|  9 |             2 | 户外运动   | 登山杖     | 59.90   |
| 10 |             2 | 户外运动   | 骑行装备   | 399.90  |
| 11 |             2 | 户外运动   | 运动外套   | 799.90  |
| 12 |             2 | 户外运动   | 滑板       | 499.90  |
+----+---------------+------------+------------+---------+
6 rows in set (0.04 sec)

NOT EXISTS子查询

NOT EXISTS关键字表示如果不存在某种条件，则返回TRUE，否则返回FALSE。

例：查询t_goods_category数据表中是否不存在id为6的数据，如果不存在，则查询t_goods数据表中t_category_id为1的数据。

mysql> SELECT id, t_category_id, t_category, t_name, t_price FROM t_goods WHERE NOT EXISTS ( SELECT t_category FROM t_goods_category WHERE id = 6 ) AND t_category_id = 1;
+----+---------------+---------------+----------+---------+
| id | t_category_id | t_category    | t_name   | t_price |
+----+---------------+---------------+----------+---------+
|  1 |             1 | 女装/女士精品 | T恤      | 39.90   |
|  2 |             1 | 女装/女士精品 | 连衣裙   | 79.90   |
|  3 |             1 | 女装/女士精品 | 卫衣     | 89.90   |
|  4 |             1 | 女装/女士精品 | 牛仔裤   | 89.90   |
|  5 |             1 | 女装/女士精品 | 百褶裙   | 29.90   |
|  6 |             1 | 女装/女士精品 | 呢绒外套 | 399.90  |
+----+---------------+---------------+----------+---------+
6 rows in set (0.04 sec)

IN子查询

IN关键字表示如果比较的数据在IN列表中，则返回TRUE，否则返回FALSE。

例：查询t_goods_category数据表中名称为“户外运动”的id数据，并根据查询出的id数据查询t_goods数据表中的数据。

mysql> SELECT id, t_category_id, t_category, t_name, t_price FROM t_goods  WHERE t_category_id IN ( SELECT id FROM t_goods_category WHERE t_category = '户外运动');
+----+---------------+------------+------------+---------+
| id | t_category_id | t_category | t_name     | t_price |
+----+---------------+------------+------------+---------+
|  7 |             2 | 户外运动   | 自行车     | 399.90  |
|  8 |             2 | 户外运动   | 山地自行车 | 1399.90 |
|  9 |             2 | 户外运动   | 登山杖     | 59.90   |
| 10 |             2 | 户外运动   | 骑行装备   | 399.90  |
| 11 |             2 | 户外运动   | 运动外套   | 799.90  |
| 12 |             2 | 户外运动   | 滑板       | 499.90  |
+----+---------------+------------+------------+---------+
6 rows in set (0.05 sec)

NOT IN子查询

NOT IN关键字表示如果比较的数据不在IN列表中，则返回TRUE，否则返回FALSE。

例：查询t_goods_category数据表中名称为“女装/女士精品”的id数据，并查询t_goods数据表中不在id列表中的数据。

mysql> SELECT id, t_category_id, t_category, t_name, t_price  FROM t_goods WHERE t_category_id NOT IN (  SELECT id FROM t_goods_category  WHERE t_category = '户外运动' );
+----+---------------+---------------+----------+---------+
| id | t_category_id | t_category    | t_name   | t_price |
+----+---------------+---------------+----------+---------+
|  1 |             1 | 女装/女士精品 | T恤      | 39.90   |
|  2 |             1 | 女装/女士精品 | 连衣裙   | 79.90   |
|  3 |             1 | 女装/女士精品 | 卫衣     | 89.90   |
|  4 |             1 | 女装/女士精品 | 牛仔裤   | 89.90   |
|  5 |             1 | 女装/女士精品 | 百褶裙   | 29.90   |
|  6 |             1 | 女装/女士精品 | 呢绒外套 | 399.90  |
| 13 |             5 | 水果          | 葡萄     | 49.90   |
| 14 |             5 | 水果          | 香蕉     | 39.90   |
+----+---------------+---------------+----------+---------+
8 rows in set (0.05 sec)

子查询作为结果字段

MySQL支持使用子查询的结果数据作为最终查询结果的某一列数据。

例：查询t_goods_category数据表中的数据，并统计每个商品类别下的商品数量。

mysql> SELECT category.id, category.t_category, (SELECT COUNT(*) FROM t_goods goods WHERE goods.t_category_id = category.id) AS goods_count FROM t_goods_category category;
+----+---------------+-------------+
| id | t_category    | goods_count |
+----+---------------+-------------+
|  1 | 女装/女士精品 |           6 |
|  2 | 户外运动      |           6 |
|  3 | 男装          |           0 |
|  4 | 童装          |           0 |
|  5 | 水果          |           2 |
+----+---------------+-------------+
5 rows in set (0.05 sec)

可以看到，使用子查询统计t_goods_category数据表中每个商品类别下的商品数量，并作为最终结果的goods_count字段的数据进行输出。

总结

简单介绍了MySQL中常用子查询和子查询用法及相应示例。

MYSQL 子查询
norang的博客
03-07 5512
十六、子查询 如果在一个查询语句中出现了另一个查询，称为子查询。因此子查询按照查询出现的位置分为外部查询和子查询。 1、查询的结果集分为几种情况 （1）返回标量值 select sum(quanlity) from t_orderitem （2）返回值列表 select cust_id from t_customers （3）返回虚拟表 select * from t_cu
mysql子查询与连表查询的效率比较及优化
04-23
### MySQL 子查询与连表查询的效率比较及优化 #### 一、子查询与连表查询概述 在SQL查询语言中，子查询与连表查询是两种非常重要的查询技术，广泛应用于各种复杂的业务场景中。为了更好地理解这两种查询方式的特点...
MySQL子查询
热门推荐
qq_44111805的博客
05-10 4万+
一、子查询定义 子查询指一个查询语句嵌套在另一个查询语句内部的查询，这个特性从MySQL 4.1开始引入。 SQL 中子查询的使用大大增强了 SELECT 查询的能力，因为很多时候查询需要从结果集中获取数据，或者需要从同一个表中先计算得出一个数据结果，然后与这个数据结果（可能是某个标量，也可能是某个集合）进行比较。 二、子查询的基本使用 1、子查询（内查询）在主查询之前一次执行完成。 2、子查询的结果被主查询（外查询）使用。 3、注意事项： （1）子查询要包含在括号内 （2）将子查询放在比较条件的右侧 （
MYSQL子查询
weixin_75253589的博客
11-07 2158
子查询内容
MySQL子查询概述
橘猫吃不胖的博客
01-31 1656
MySQL子查询概述1 为什么会使用子查询2 什么是子查询3 子查询的具体使用3.1 WHERE子句后使用子查询3.2 FROM子句后使用子查询4 总结 1 为什么会使用子查询 虽然可以通过连接查询来实现多表查询数据记录，但不建议使用，因为连接查询的性能很差。例如，我们要查询部门表dept和雇员表employee中的数据记录，一般可能会写成： SELECT * FROM dept t1, employee t2 　　　　　　 WHERE t1.deptno = t2.deptno; 对于这条S
mysql 子查询效率_mysql利用子查询效率怎么样
weixin_36367702的博客
01-20 1371
mysql子查询效率：利用子查询【SELECT id,`name` FROM customer where id IN(select DISTINCT(customerid) from searchaccount】效率是10倍级的影响。mysql利用子查询后的效率影响仅仅是利用id:explainSELECT * from customer where id in(1,2,3,4,5,6,7,8,...
mysql 优化子查询_MySQL子查询的优化
weixin_28689809的博客
02-07 2165
一、MySQL子查询的位置当一个查询是另一个查询的子部分是，称之为子查询(查询语句中嵌套含有查询语句)。子查询也是使用频率比较高的一种查询类型。因此，优化一、MySQL子查询的位置当一个查询是另一个查询的子部分是，，称之为子查询(查询语句中嵌套含有查询语句)。子查询也是使用频率比较高的一种查询类型。因此，优化子查询，对于整个系统的性能也有直接的影响。从查询出现在SQL语句的位置来看，它可以出现在目...
mysql子查询删除
qq_41606547的博客
04-02 1898
正确例子： delete from `bbs_reply` where parent_id in (select e.reply_id from (select * from `bbs_reply` where parent_id=#{id} and reply_type=1) e) and reply_type=2 报错1： 这是因...
mysql 子查询 group by_mysql 子查询 group by的使用
weixin_28858247的博客
02-18 2988
1 group by表示排序，后面查询出来的是每一组的第一条数据，where后面表示提出条件之类的，如果对排序需要有条件筛选，应该在属性名后接having +条件 。而不能使用where2 聚合函数sum() count() avg() max() min()GROUP BY 是分组查询,把符合条件的同一类分在一组 一般 GROUP BY 是和聚合函数配合使用的。例如查询出来每门课的分数都大于...
mysql子查询
whereismatrix的专栏
12-08 1673
mysql子查询: where子查询、from子查询、exists子查询
Mysql子查询IN中使用LIMIT应用示例
12-15
但是，MySQL并不支持在`IN`、`ALL`、`ANY`或`SOME`子查询中直接使用`LIMIT`，导致了错误。 为了解决这个问题，开发者采取了另一种策略，即创建一个临时子查询来获取所需的`aid`值： ```sql WHERE mapply.aid IN ...
mysql子查询的用法
04-05
MySQL子查询是数据库查询中的一个重要概念，它允许在SQL语句内部嵌套其他查询，用于检索、比较或操作数据。子查询可以理解为一个独立的查询结果，它被用作外部查询的一部分，提供了灵活的数据处理能力。在本篇文章中...
MySQL子查询用法实例分析
12-15
MySQL子查询是数据库查询中的一个重要概念，它在处理复杂的数据查询时非常有用。子查询，顾名思义，就是在一个SQL语句中嵌套另一个SQL查询，用于获取数据或者作为外部查询的一部分来过滤数据。在本例中，我们讨论的...
MySQL大数据表增加字段、索引实现
json_li的博客
11-16 2万+
最近遇到的一个问题，需要在一张1800万数据量的表中添加加一个字段并添加索引，但是直接添加会导致mysql崩溃或者锁表时间太长影响用户操作，所以需要利用其他的方法进行添加，这篇文章主要给大家介绍了MySQL中大数据表增加字段，增加索引的实现过程，需要的朋友可以参考借鉴。 普通的添加字段sql ALTER TABLE `table_name` ADD COLUMN `num` in
session如何加入mysql库
json_li的博客
07-15 4791
我们知道，session是一种会话技术，用来实现跨脚本共享数据或者检测跟踪用户状态。 session的工作原理 （1）当一个session第一次被启用时，一个唯一的标识被存储于本地的cookie中。 （2）首先使用session_start()函数，PHP从session仓库中加载已经存储的session变量。 （3）当执行PHP脚本时，通过使用session_register()函数
Python Mysql增删改查操作
json_li的博客
11-23 2579
PyMySQL 是在 Python3.x 版本中用于连接 MySQL 服务器的一个库，Python2 中则使用 mysqldb。本文我们为大家介绍 Python3 使用PyMySQL连接数据库，并实现简单的增删改查。在使用 PyMySQL 之前，我们需要确保 PyMySQL 已安装。
mysql数据表对自增id重新排序
json_li的博客
10-18 1953
最近做到的项目要用到让数据库的表，自增重新从1开始； 于是从网上找了两个简单的方法分享给大家： 　　方法一：如果曾经的数据都不需要的话，可以直接清空所有数据，并将自增字段恢复从1开始计数 　　truncate table 表名 　　方法二：dbcc checkident ('table_name', reseed, new_reseed_value) 当前值设置为 new_reseed
mysql 子查询
最新发布
07-01
### MySQL 子查询的使用方法和示例 MySQL 中的子查询（Subquery）是指嵌套在另一个 SQL 查询语句中的查询。它通常用于实现更复杂的逻辑，帮助主查询引用从子查询中计算出的结果。根据返回结果的不同形式，子查询可以分为标量子查询、多行子查询、多列子查询以及相关子查询。 #### 标量子查询 标量子查询返回单个值，可以作为表达式的一部分用于主查询的条件判断或计算。例如，假设有一个 `orders` 表记录订单信息，一个 `products` 表记录产品信息，可以通过子查询获取某个产品的平均价格，并在主查询中使用： ```sql SELECT order_id, product_id, price FROM orders WHERE price > (SELECT AVG(price) FROM products WHERE product_type = 'Electronics'); ``` 此查询会筛选出价格高于电子产品平均价格的所有订单[^1]。 #### 多行子查询 多行子查询返回多个值，通常与 `IN`, `NOT IN`, `ANY`, 或 `ALL` 等操作符一起使用。例如，查找所有销售量高于特定产品类别的产品： ```sql SELECT product_id, name FROM products WHERE sales > ANY(SELECT sales FROM products WHERE category = 'Books'); ``` 这将选择出销售量大于任意一本书籍销量的产品[^1]。 #### 多列子查询 多列子查询返回多个列的数据，通常用于匹配多个字段。例如，查找具有特定属性组合的记录： ```sql SELECT customer_id, order_date FROM orders WHERE (customer_id, order_date) IN ( SELECT customer_id, MAX(order_date) FROM orders GROUP BY customer_id ); ``` 这段代码会选择每个客户的最新订单日期对应的记录[^1]。 #### 相关子查询 相关子查询是依赖于外部查询值的子查询。它对于每一行数据都会执行一次子查询。例如，找出每个部门工资最高的员工： ```sql SELECT e.name, e.salary, e.department_id FROM employees e WHERE e.salary = ( SELECT MAX(salary) FROM employees WHERE department_id = e.department_id ); ``` 在这个例子中，内部查询依赖于外部查询中的 `department_id` 来确定每个部门的最大工资。 #### EXISTS 子查询 `EXISTS` 子查询用于测试子查询是否至少会返回一行数据。这种类型的查询经常用来检查是否存在满足特定条件的记录。例如，验证是否存在未完成的订单： ```sql SELECT customer_id, name FROM customers WHERE EXISTS ( SELECT 1 FROM orders WHERE status != 'Completed' AND customer_id = customers.customer_id ); ``` 如果客户有未完成的订单，则该客户的信息会被选中[^3]。 通过这些不同类型的子查询，开发者可以根据具体需求设计出灵活且强大的查询逻辑。合理利用子查询不仅可以简化复杂的数据检索任务，还能提高数据库查询的整体效率[^2]。 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

JSON_L

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值