MySQL

最新推荐文章于 2025-09-05 14:24:44 发布
最新推荐文章于 2025-09-05 14:24:44 发布
阅读量180 收藏 1
点赞数 1
CC 4.0 BY-SA版权
文章标签： 数据库 php 数据结构与算法
原文链接：http://www.cnblogs.com/lin333/p/9803108.html

参考文档：这里   更多mysql，请参考这里

数据库介绍

RDBMS 术语 

在我们开始学习MySQL 数据库前，让我们先了解下RDBMS的一些术语：

  • 数据库: 数据库是一些关联表的集合。.
  • 数据表: 表是数据的矩阵。在一个数据库中的表看起来像一个简单的电子表格。
  • 列: 一列(数据元素) 包含了相同的数据, 例如邮政编码的数据。
  • 行：一行（=元组，或记录）是一组相关的数据，例如一条用户订阅的数据。
  • 冗余：存储两倍数据，冗余可以使系统速度更快。(表的规范化程度越高，表与表之间的关系就越多；查询时可能经常需要在多个表之间进行连接查询；而进行连接操作会降低查询速度。例如，学生的信息存储在student表中，院系信息存储在department表中。通过student表中的dept_id字段与department表建立关联关系。如果要查询一个学生所在系的名称，必须从student表中查找学生所在院系的编号（dept_id），然后根据这个编号去department查找系的名称。如果经常需要进行这个操作时，连接查询会浪费很多的时间。因此可以在student表中增加一个冗余字段dept_name，该字段用来存储学生所在院系的名称。这样就不用每次都进行连接操作了。)
  • 主键：主键是唯一的。一个数据表中只能包含一个主键。你可以使用主键来查询数据。
  • 外键：外键用于关联两个表。
  • 复合键：复合键（组合键）将多个列作为一个索引键，一般用于复合索引。
  • 索引：使用索引可快速访问数据库表中的特定信息。索引是对数据库表中一列或多列的值进行排序的一种结构。类似于书籍的目录。
  • 参照完整性: 参照的完整性要求关系中不允许引用不存在的实体。与实体完整性是关系模型必须满足的完整性约束条件，目的是保证数据的一致性。
Mysql数据库

Mysql是最流行的关系型数据库管理系统，在WEB应用方面MySQL是最好的RDBMS(Relational Database Management System：关系数据库管理系统)应用软件之一。由瑞典MySQL AB公司开发，目前属于Oracle公司。MySQL是一种关联数据库管理系统，关联数据库将数据保存在不同的表中，而不是将所有数据放在一个大仓库内，这样就增加了速度并提高了灵活性。

  • Mysql是开源的，所以你不需要支付额外的费用。
  • Mysql支持大型的数据库。可以处理拥有上千万条记录的大型数据库。
  • MySQL使用标准的SQL数据语言形式。
  • Mysql可以允许于多个系统上，并且支持多种语言。这些编程语言包括C、C++、Python、Java、Perl、PHP、Eiffel、Ruby和Tcl等。
  • Mysql对PHP有很好的支持，PHP是目前最流行的Web开发语言。
  • MySQL支持大型数据库，支持5000万条记录的数据仓库，32位系统表文件最大可支持4GB，64位系统支持最大的表文件为8TB。
  • Mysql是可以定制的，采用了GPL协议，你可以修改源码来开发自己的Mysql系统。

Mysql数据库安装及使用

管理MySQL的命

以下列出了使用Mysql数据库过程中常用的命令：

  • USE 数据库名 :选择要操作的Mysql数据库，使用该命令后所有Mysql命令都只针对该数据库。

  • SHOW DATABASES: 列出 MySQL 数据库管理系统的数据库列表。

  • SHOW TABLES: #显示指定数据库的所有表，使用该命令前需要使用 use命令来选择要操作的数据库。

  • SHOW COLUMNS FROM 数据表: #显示数据表的属性，属性类型，主键信息 ，是否为 NULL，默认值等其他信息。

  • create database testdb charset "utf8"; #创建一个叫testdb的数据库，且让其支持中文 

  • drop database testdb; #删除数据库

  • SHOW INDEX FROM 数据表:显示数据表的详细索引信息，包括PRIMARY KEY（主键）。

 

MySQL 数据类型

MySQL中定义数据字段的类型对你数据库的优化是非常重要的。

MySQL支持多种类型，大致可以分为三类：数值、日期/时间和字符串(字符)类型。

数值类型

MySQL支持所有标准SQL数值数据类型。

这些类型包括严格数值数据类型(INTEGER、SMALLINT、DECIMAL和NUMERIC)，以及近似数值数据类型(FLOAT、REAL和DOUBLE PRECISION)。

关键字INT是INTEGER的同义词，关键字DEC是DECIMAL的同义词。

BIT数据类型保存位字段值，并且支持MyISAM、MEMORY、InnoDB和BDB表。

作为SQL标准的扩展，MySQL也支持整数类型TINYINT、MEDIUMINT和BIGINT。下面的表显示了需要的每个整数类型的存储和范围。

 

类型大小范围（有符号）范围（无符号）用途
TINYINT1 字节(-128，127)(0，255)小整数值
SMALLINT2 字节(-32 768，32 767)(0，65 535)大整数值
MEDIUMINT3 字节(-8 388 608，8 388 607)(0，16 777 215)大整数值
INT或INTEGER4 字节(-2 147 483 648，2 147 483 647)(0，4 294 967 295)大整数值
BIGINT8 字节(-9 233 372 036 854 775 808，9 223 372 036 854 775 807)(0，18 446 744 073 709 551 615)极大整数值
FLOAT4 字节(-3.402 823 466 E+38，1.175 494 351 E-38)，0，(1.175 494 351 E-38，3.402 823 466 351 E+38)0，(1.175 494 351 E-38，3.402 823 466 E+38)单精度
浮点数值
DOUBLE8 字节(1.797 693 134 862 315 7 E+308，2.225 073 858 507 201 4 E-308)，0，(2.225 073 858 507 201 4 E-308，1.797 693 134 862 315 7 E+308)0，(2.225 073 858 507 201 4 E-308，1.797 693 134 862 315 7 E+308)双精度
浮点数值
DECIMAL对DECIMAL(M,D) ，如果M>D，为M+2否则为D+2依赖于M和D的值依赖于M和D的值小数值

 

日期和时间类型

表示时间值的日期和时间类型为DATETIME、DATE、TIMESTAMP、TIME和YEAR。

每个时间类型有一个有效值范围和一个"零"值，当指定不合法的MySQL不能表示的值时使用"零"值。

TIMESTAMP类型有专有的自动更新特性，将在后面描述。

 

 

类型大小
(字节)		范围格式用途
DATE31000-01-01/9999-12-31YYYY-MM-DD日期值
TIME3'-838:59:59'/'838:59:59'HH:MM:SS时间值或持续时间
YEAR11901/2155YYYY年份值
DATETIME81000-01-01 00:00:00/9999-12-31 23:59:59YYYY-MM-DD HH:MM:SS混合日期和时间值
TIMESTAMP41970-01-01 00:00:00/2037 年某时YYYYMMDD HHMMSS混合日期和时间值，时间戳

　　

字符串类型

字符串类型指CHAR、VARCHAR、BINARY、VARBINARY、BLOB、TEXT、ENUM和SET。该节描述了这些类型如何工作以及如何在查询中使用这些类型。

类型大小用途
CHAR0-255字节定长字符串
VARCHAR0-65535 字节变长字符串
TINYBLOB0-255字节不超过 255 个字符的二进制字符串
TINYTEXT0-255字节短文本字符串
BLOB0-65 535字节二进制形式的长文本数据
TEXT0-65 535字节长文本数据
MEDIUMBLOB0-16 777 215字节二进制形式的中等长度文本数据
MEDIUMTEXT0-16 777 215字节中等长度文本数据
LONGBLOB0-4 294 967 295字节二进制形式的极大文本数据
LONGTEXT0-4 294 967 295字节极大文本数据

CHAR和VARCHAR类型类似，但它们保存和检索的方式不同。它们的最大长度和是否尾部空格被保留等方面也不同。在存储或检索过程中不进行大小写转换。

BINARY和VARBINARY类类似于CHAR和VARCHAR，不同的是它们包含二进制字符串而不要非二进制字符串。也就是说，它们包含字节字符串而不是字符字符串。这说明它们没有字符集，并且排序和比较基于列值字节的数值值。

BLOB是一个二进制大对象，可以容纳可变数量的数据。有4种BLOB类型：TINYBLOB、BLOB、MEDIUMBLOB和LONGBLOB。它们只是可容纳值的最大长度不同。

有4种TEXT类型：TINYTEXT、TEXT、MEDIUMTEXT和LONGTEXT。这些对应4种BLOB类型，有相同的最大长度和存储需求。

 mysql的常用命令

 mysql创建数据表：

用test数据 ，创建一个表叫student，包含stu_id（int类型，不能为空，自动递增） , name（字符类型，不能为空）, age（int类型，不能为空）, register_date（date格式）

复制代码 
#create table table_name(column_name column_type)
use test;#使用test数据库
create table student(stu_id int not null auto_increment,
name char(32) not null,#字符类型，不能为空
age int not null,#int类型，不能为空
register_date date,#register_date（date格式）
primary key(stu_id))#设置主键为stu_id
复制代码

插入数据：


语法： insert into table_name(field1,field2,...fieldN) values (value1,value2,...valueN)

insert into student(name,age,register_date) values("alex li",22,"2018-04-17")

查询数据语法：

  1. select column_name,column_name from table_name [where Clause] [offset m][limit n]
  2. 查询语句中你可以使用一个或者多个表，表之间使用逗号(,)分隔，并使用where语句来设定插叙条件。
  3. select命令可以读取一条或者多条纪录。
  4. 你可以使用星号(*)来代替其他字段，select语句会返回表的所有字段数据。
  5. 你可以通过offset指定select语句开始插叙的数据偏移量。默认情况下偏移量为0.
  6. 你可以使用limit属性来设定返回的纪录数

比如这个SQL ，limit后面跟的是3条数据，offset后面是从第3条开始读取

select * from student limit 3 offset 2;

而这个SQL，limit后面是从第3条开始读，读取1条信息。

select * from student limit 3 ,1;

 

where 子句

语法：select field1,field2,...fieldN from table_name1,table_name2...[where condition1 [and [or]] condition2....]

select * from student where register_date > '2016-03-04'

update 更新语法

UPupdate table_name set fiele1 = new-value1,field2 = new-value2 [where Clause]

upupdate student set age 23 ,name = "Alex Li" where stu_id = 1;


DELETE 语句语法：

delete from table_name [where Clause]

delete from student where stu_id = 5;

MySQL LIKE 子句语法：

select field1,field2,...fieldN table_name1,table_name2... where field1 like condition1 [and[or] filed2 = "somevalue"]

select * from student where name binary like "%Li";
select * from student where name binary like binary "%Li";#只匹配大写

MySQL 排序

SELECT field1, field2,...fieldN table_name1, table_name2...  ORDER BY field1, [field2...] [ASC [DESC]]

select *from student where name like binary "%Li" order by stu_id desc;

GROUP BY 语句

SELECT column_name, function(column_name)

FROM  table_name
WHERE  column_name operator value
GROUP  BY  column_name;

 

 

 

with rollup可以计算总数

coalesce 可以将统计的类别改名，null改为自定义的字符

 

 alter命令

我们需要修改数据表名或者修改数据表字段时，就需要使用到alter命令

增加字段：增加性别字段

alter  table student add sex enum("M","F");

删除字段:

alter table student drop age;

修改字段：

利用modify修改sex字段为非空

alter table student modify sex enum("F","M") not null;

 利用change修改

alter table student change sex gender char(32) not null default "x";

关于外键

外键，一个特殊的索引，用于关键两个表，只能是指定内容

以下两种写法均可

create table study_record (
id int(11) not null auto_increment,
day int(11) not null,
status char(32) not null ,
stu_id int(11) NOT NULL,
primary key (id),
key fk_student_key (stu_id),
constraint fk_student_key foreign key (stu_id) references student (stu_id)
)


CREATE TABLE `study_record` (
  `id` int(11) NOT NULL auto_increment,
  `day` int(11) NOT NULL,
  `status` char(32) NOT NULL,    
  `stu_id` int(11) NOT NULL,
  primary key (`id`),
  key `fk_student_key` (`stu_id`),
  CONSTRAINT `fk_student_key` FOREIGN KEY (`stu_id`) REFERENCES `student` (`stu_id`)
)

 

此时，如果student 对应的stu_id 不存在，study_record也无法插入，这叫外键约束

同样道理，如果有student表中跟这个study_record表有关联的数据，你是不能删除student表中与其关联的纪录

mysql null值处理

我们已经知道MySQL使用 SQL SELECT 命令及 WHERE 子句来读取数据表中的数据,但是当提供的查询条件字段为 NULL 时，该命令可能就无法正常工作。
为了处理这种情况，mysql提供了三大运算符：
is null：当列的值是null，此运算符返回True。
is not null：当列的值部位null，运算符返回True
<=>：比较操作符（不同于=运算符），当比较的两个值都未null时返回True。

关于null的条件比较运算是比较特殊的，你不能使用=null或！=null在列中查找null值

在mysql中，null值与任何其他值的比较（即使是null）永远返回false，即null = null返回false。
mysql中处理null使用is null 和is not null运算符。

mysql连接（left join,right join,inner join,full join）

这里介绍使用join在两个或多个表中查询数据。
join按照功能大致分为如下三类：
inner join（内连接，或等值连接）：获取两个表中字段匹配关系的纪录。
left join（左连接）：获取左表所有纪录，即使右表没有对应匹配的纪录。
right join（右连接）：与left join相反，用于获取右表所有纪录，即使左表没有对应匹配的纪录。

insert into A(a)values(1);
insert into A(a)values(2);
insert into A(a)values(3);
insert into A(a)values(4);

insert into B(b)values(3);
insert into B(b)values(4);
insert into B(b)values(5);
insert into B(b)values(6);

inner join:(显示两个表的交集)
select * from A inner join B on A.a = B.b; #（一般写这个）     可以写成：     select A.*,B.* from A,B where A.a = B.b;

 left join:(差集)

 select * from A left join B on A.a = B.b;

 

 right join：

 select * from A  right join B on A.a = B.b;

full join：并集(mysql 不直接支持这个)

select * from A full join B on A.a = B.b;#(mysql 不直接支持这个)

mysql支持的写法：

select * from  A left join B on A.a = B.b union select * from A right join B on A.a = B.b;

事务

mysql事务主要用于处理操作量大，复杂度高的数据。比如说，在人员管理系统中，你删除一个人员，你即需要删除人员的基本资料，也要删除和该人员相关的信息，比如信箱、文章等等，这样，这些数据库操作语句就构成了一个事务！
在mysql中只有使用了Innodb数据库引擎的数据库或表才支持事务,mysql默认就使用了这个数据引擎的；
事务处理可以用来维护数据库的完整性，包子成批的sql语句要么全部执行，要么全部不执行；
事务用来管理insert，update，delete语句；

一般来说，事务是必须满足4个条件（ACID）：Atomicity（原子性）、Consistency（稳定性）、Isolation（隔离性）、Durability（可靠性）

  1. 事务的原子性：一组事务，要么成功，要么撤回；
  2. 稳定性：有非法数据（外键约束之类），事务撤回；
  3. 隔离性：事务独立运行。一个事务处理后的结果，影响了其他事务，那么其他事务会撤回。事务的100%隔离，需要牺牲速度。
  4. 可靠性：软、硬件奔溃后，InNoDB数据表驱动会利用日志文件重构修改。可靠性和高速度不可兼得，innodb_flush_log_at_trx_commit选项决定什么时候把事务保存到日志里。

在mysql控制台使用事务来操作

begin;
insert into student (name,age,register_date) values("dashuaige",18,"2018-04-04");
rollback;#回滚，这样数据是不会写入的
如果是数据没有问题，就输入commit提交命令就行。

索引

mysql索引的建立对于mysql的高效运行是很重要的，索引可以大大提高mysql的检索速度。
索引分单列索引和组合索引。单列索引，即一个索引只包含单个列，一个表可以有多个单列索引，单这不是组合索引。
组合索引：即一个索包含多个列。（两个合在一起变成唯一的）

创建索引时，你需要确保该索引是应用在sql查询语句的条件（一般作为where子句的条件）。

实际上，索引也是一张表，该表保存了主键和索引字段，并指向实体表的纪录。

缺点：索引会降低更新表的速度，如对表进行insert、update、delete，因为更新表时，mysql不仅仅要保存数据，还要保存一下索引文件，所以速度变慢。同时，还要保存一下索引文件，建立索引占用次品空间的索引文件。

普通索引

主键就是默认索引。

查询索引：show index from student;

创建索引：

语法：create index indexname on mytable (username(length));#length为索引的长度

eg:

create index index_name on student (name(32));

修改表结构

alter mytable add index [indexname] on (username(length))

创建表的时候直接指定

create table mytable(

id int not null,

username varchar(16) not null,

index [indexname] (username(length))

);

删除索引

语法：

drop index [indexname] on mytable;

eg:

drop index index_name on student;

唯一索引

唯一索引：索引列的值必须唯一，但是允许有空值。如果是组合索引，则列值的组合必须唯一。

eg:主键就是唯一索引

创建索引

创建索引

create unique index indexname on mytable(username(length))

修改表结构：

alter mytable add unique [indexname] on (username(length))

创建表的时候直接指定：

create table mytable(\

id int not null,

username varchar(16) not null,

unique [indexname] (username(length))

);

 python 操作mysql

参考：点这里

数据库安装

pip3 install pymysql

使用 pymysql

 例子：

import pymysql
# 创建连接,相当于建立一个socket
conn = pymysql.connect(host = 'localhost',port = 3306,user = 'root',password = 'Choice123',db = 'my_db')
# 创建游标，相当于光标，真真正正建立了一个实例
cursor = conn.cursor()

# 执行SQL，并返回执行行数
effect_row = cursor.execute("select * from student")
print(effect_row)
# 一条条取
print(cursor.fetchone())
print(cursor.fetchone())
print(''.center(60,"="))
# 获取前几条数据
print(cursor.fetchmany(3))

print(''.center(60,"="))
# 取全部
print(cursor.fetchall())
pymysql1 
import pymysql
# 创建连接,相当于建立一个socket
conn = pymysql.connect(host = 'localhost',port = 3306,user = 'root',password = 'Choice123',db = 'my_db')
# 创建游标，相当于光标，真真正正建立了一个实例
cursor = conn.cursor()

data = [
    ("N1","10","2015-05-22"),
    ("N2", "11", "2015-04-22"),
    ("N3", "12", "2015-06-22")
]
cursor.executemany("insert into student (name,age,register_date) VALUES (%s,%s,%s)",data)

# 因为默认启动了事务，所以需要commit上去，数据库才有数据
conn.commit()
# 关闭游标
cursor.close()
# 关闭连接
conn.close()
pymysql2

 

 为了避免写死原生SQL语句，所以介绍ORM

ORM

参考这里

 ORM英文全称object relational mapping，就是对象映射关系程序，简单来说我们类似python这种面向对象的程序来说一切皆对象，但是我们使用的数据库却都是关系型的，为了保证一致的使用习惯，通过ORM将编程语言的对象模型和数据库的关系模型建立映射关系，这样我们在使用功能编程语言对数据库进行操作的时候可以直接使用编程语言的对象模型进行操作就可以了，而不用直接使用SQL语言。

ORM的优点：

  1. 隐藏了数据访问细节，“封闭”的通用数据库交互，ORM的核心。他是的我们的通用数据库交互变得简单，并且完全不用考虑该死的SQL语句。
  2. ORM使我们构造固话数据结构变得简单易行

缺点：

无可避免的，自动化意味着映射何关联管理，代价是牺牲性能。

sqlalchemy

在python中，最有名的ORM框架是SSQLAlchemy。

Dialect用于和数据API进行交流，根据配置文件的不同调用不同的数据库API，从而实现对数据库的操作，如：

MySQL-Python
    mysql+mysqldb://<user>:<password>@<host>[:<port>]/<dbname>
   
pymysql
    mysql+pymysql://<username>:<password>@<host>/<dbname>[?<options>]
   
MySQL-Connector
    mysql+mysqlconnector://<user>:<password>@<host>[:<port>]/<dbname>
   
cx_Oracle
    oracle+cx_oracle://user:pass@host:port/dbname[?key=value&key=value...]
   
更多详见：http://docs.sqlalchemy.org/en/latest/dialects/index.html
mysql_conn

 

安装

命令安装：pip3 install sqlalchemy

import sqlalchemy

from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column,Integer,String

# API接口为mysql与pymysql mysql用户名root 密码Choice123 主机是localhost 数据my_db,类型为utf-8，echo=True，执行这段代码的时候，会打印过程
engine = create_engine("mysql+pymysql://root:Choice123@localhost/my_db",encoding = "utf-8",echo = True)

# 生成ORM基类
Base = declarative_base()

class User(Base):
    # 表名
    __tablename__ = 'user'
    id = Column(Integer,primary_key=True)
    name = Column(String(32))
    password = Column(String(64))

# 创建表结构，调用Base类下的metadata方法，调用接口engine，这里是通过父亲调用儿子，生成子类的东西
Base.metadata.create_all(engine)
Base基类

 

 

import sqlalchemy

from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column,Integer,String
from sqlalchemy.orm import sessionmaker
# API接口为mysql与pymysql mysql用户名root 密码Choice123 主机是localhost 数据my_db,类型为utf-8，echo=True，执行这段代码的时候，会打印过程
engine = create_engine("mysql+pymysql://root:Choice123@localhost/my_db",encoding = "utf-8",echo = True)

# 生成ORM基类
Base = declarative_base()

class User(Base):
    # 表名
    __tablename__ = 'user'
    id = Column(Integer,primary_key=True)
    name = Column(String(32))
    password = Column(String(64))

# 创建表结构，调用Base类下的metadata方法，调用接口engine，这里是通过父亲调用儿子，生成子类的东西
Base.metadata.create_all(engine)

# 创建于数据库的会话session class，类似SQL里面的游标，但是这里返回给session的是个类，不是实例，所以下面需要实例化
Session_class = sessionmaker(bind=engine)
#生成session实例，这里相当于cursor
Session = Session_class()

# 生成你要创建的数据对象
user_obj = User(name= "alex",password = "alex1234")
# 此时还没创建对象，只是类里生成了数据，所以数据库的id是没有的
print(user_obj.name,user_obj.password)
# 把要创建的数据对象添加到session里，一会会统一创建，这里还是没有创建在数据库里面，所以id也是没有的
Session.add(user_obj)

# 这里统一提交，在数据库创建数据
Session.commit()
创建表结构与添加数据

 

 

查询
修改
回滚
统计

 

分组统计需要导入：

from sqlalchemy import func
import sqlalchemy

from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column,Integer,String
from sqlalchemy.orm import sessionmaker

# API接口为mysql与pymysql mysql用户名root 密码Choice123 主机是localhost 数据my_db,类型为utf-8，echo=True，执行这段代码的时候，会打印过程
engine = create_engine("mysql+pymysql://root:Choice123@localhost/my_db",encoding = "utf-8")

# 生成ORM基类
Base = declarative_base()

class User(Base):
    # 表名
    __tablename__ = 'user'
    id = Column(Integer,primary_key=True)
    name = Column(String(32))
    password = Column(String(64))

    # 通过这个函数，就能将搜索出来的数据分出来：[<1 name:alex>, <2 name:alex>, <3 name:alex>, <4 name:alex>, <5 name:alex>, <6 name:alex>, <7 name:alex>, <8 name:alex>]
    def __repr__(self):
        return  "<%s name:%s>" %(self.id,self.name)

# 创建表结构，调用Base类下的metadata方法，调用接口engine，这里是通过父亲调用儿子，生成子类的东西
Base.metadata.create_all(engine)

# 创建于数据库的会话session class，类似SQL里面的游标，但是这里返回给session的是个类，不是实例，所以下面需要实例化
Session_class = sessionmaker(bind=engine)
#生成session实例，这里相当于cursor
Session = Session_class()

from sqlalchemy import func
# func.count(User.name)是统计name的数量
print(Session.query(User.name,func.count(User.name)).group_by(User.name).all())
# [('alex', 7), ('gui', 1), ('Jack Liu', 1)]
分组统计 
import sqlalchemy

from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column,Integer,String
from sqlalchemy.orm import sessionmaker

# API接口为mysql与pymysql mysql用户名root 密码Choice123 主机是localhost 数据my_db,类型为utf-8，echo=True，执行这段代码的时候，会打印过程
engine = create_engine("mysql+pymysql://root:Choice123@localhost/my_db",encoding = "utf-8")

# 生成ORM基类
Base = declarative_base()

class User(Base):
# 表名
__tablename__ = 'user'
id = Column(Integer,primary_key=True)
name = Column(String(32))
password = Column(String(64))

# 通过这个函数，就能将搜索出来的数据分出来：[<1 name:alex>, <2 name:alex>, <3 name:alex>, <4 name:alex>, <5 name:alex>, <6 name:alex>, <7 name:alex>, <8 name:alex>]
def __repr__(self):
return "<%s name:%s>" %(self.id,self.name)

# 创建表结构，调用Base类下的metadata方法，调用接口engine，这里是通过父亲调用儿子，生成子类的东西
Base.metadata.create_all(engine)

# 创建于数据库的会话session class，类似SQL里面的游标，但是这里返回给session的是个类，不是实例，所以下面需要实例化
Session_class = sessionmaker(bind=engine)
#生成session实例，这里相当于cursor
Session = Session_class()

data = Session.query(User).filter(User.id == 2).one()
print("要删除的数据：",data)
Session.delete(data)
Session.commit()
删除

 

 连表

import sqlalchemy

from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column,Integer,String
from sqlalchemy.orm import sessionmaker

# API接口为mysql与pymysql mysql用户名root 密码Choice123 主机是localhost 数据my_db,类型为utf-8，echo=True，执行这段代码的时候，会打印过程
engine = create_engine("mysql+pymysql://root:Choice123@localhost/my_db",encoding = "utf-8")

# 生成ORM基类
Base = declarative_base()

class User(Base):
# 表名
__tablename__ = 'user'
id = Column(Integer,primary_key=True)
name = Column(String(32))
password = Column(String(64))

# 通过这个函数，就能将搜索出来的数据分出来：[<1 name:alex>, <2 name:alex>, <3 name:alex>, <4 name:alex>, <5 name:alex>, <6 name:alex>, <7 name:alex>, <8 name:alex>]
def __repr__(self):
return "<%s name:%s>" %(self.id,self.name)

class Student(Base):
__tablename__ = 'student'
stu_id = Column(Integer,primary_key=True)
name = Column(String(32))
age = Column(Integer)


# 通过这个函数，就能将搜索出来的数据分出来：[<1 name:alex>, <2 name:alex>, <3 name:alex>, <4 name:alex>, <5 name:alex>, <6 name:alex>, <7 name:alex>, <8 name:alex>]
def __repr__(self):
return "<%s name:%s>" % (self.stu_id, self.name)


# 创建表结构，调用Base类下的metadata方法，调用接口engine，这里是通过父亲调用儿子，生成子类的东西
Base.metadata.create_all(engine)

# 创建于数据库的会话session class，类似SQL里面的游标，但是这里返回给session的是个类，不是实例，所以下面需要实例化
Session_class = sessionmaker(bind=engine)
#生成session实例，这里相当于cursor
Session = Session_class()

 

print(Session.query(User).filter(User.id == Student.stu_id).all())
连表

 

关联外键

 

先删除原来的数据库以免原来的数据影响

drop database my_db;

创建新的数据库，编码为utf8

create database my_db character set utf8;

之后就能执行下面代码

import sqlalchemy

from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column,Integer,String,DATE,ForeignKey
from sqlalchemy.orm import sessionmaker

# API接口为mysql与pymysql mysql用户名root 密码Choice123 主机是localhost 数据my_db,类型为utf-8，echo=True，执行这段代码的时候，会打印过程
engine = create_engine("mysql+pymysql://root:Choice123@localhost/my_db",encoding = "utf-8")

# 生成ORM基类
Base = declarative_base()


class Student(Base):
    __tablename__ = 'student'
    stu_id = Column(Integer,primary_key=True)
    name = Column(String(32),nullable=False)
    age = Column(Integer)
    register_date = Column(DATE,nullable=False)


    # 通过这个函数，就能将搜索出来的数据分出来：[<1 name:alex>, <2 name:alex>, <3 name:alex>, <4 name:alex>, <5 name:alex>, <6 name:alex>, <7 name:alex>, <8 name:alex>]
    def __repr__(self):
        return "<%s name:%s>" % (self.stu_id, self.name)

class StudyRecord(Base):
    # 表名
    __tablename__ = 'study_record'
    id = Column(Integer, primary_key=True)
    day = Column(Integer, nullable=False)
    status = Column(String(32), nullable=False)
    # 建立外键关系
    stu_id = Column(Integer, ForeignKey('student.stu_id'))

    # 通过这个函数，就能将搜索出来的数据分出来：[<1 name:alex>, <2 name:alex>, <3 name:alex>, <4 name:alex>, <5 name:alex>, <6 name:alex>, <7 name:alex>, <8 name:alex>]
    def __repr__(self):
        return "<%s day:%s>" % (self.id, self.day)

# 创建表结构，调用Base类下的metadata方法，调用接口engine，这里是通过父亲调用儿子，生成子类的东西
Base.metadata.create_all(engine)

# 创建于数据库的会话session class，类似SQL里面的游标，但是这里返回给session的是个类，不是实例，所以下面需要实例化
Session_class = sessionmaker(bind=engine)
#生成session实例，这里相当于cursor
Session = Session_class()



s1 = Student(name = "Alex",register_date = "2014-05-21")
s2 = Student(name = "Jack",register_date = "2014-03-21")
s3 = Student(name = "Rain",register_date = "2014-04-21")
s4 = Student(name = "Eric",register_date = "2013-01-21")

study_r1 = StudyRecord(day = 1,status = "Yes",stu_id = 1)
study_r2 = StudyRecord(day = 2,status = "NO",stu_id = 1)
study_r3 = StudyRecord(day = 3,status = "Yes",stu_id = 1)
study_r4 = StudyRecord(day = 1,status = "Yes",stu_id = 2)

# 统一增加
Session.add_all([s1,s2,s3,s4,study_r1,study_r2,study_r3,study_r4])
# 统一提交
Session.commit()
创建表以及生成数据

 

 多外键关联

from sqlalchemy import  Integer,ForeignKey,String,Column
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import  relationship
from sqlalchemy import create_engine

# API接口为mysql与pymysql mysql用户名root 密码Choice123 主机是localhost 数据my_db,类型为utf-8，echo=True，执行这段代码的时候，会打印过程
engine = create_engine("mysql+pymysql://root:Choice123@localhost/my_db",encoding = "utf-8")

# 生成ORM基类
Base = declarative_base()

class Address(Base):
    __tablename__ = "address"
    id = Column(Integer,primary_key=True)
    street = Column(String(64))
    city = Column(String(64))
    state = Column(String(64))

    # 通过这个函数，就能将搜索出来的数据分出来：Alex <orm_many_fk.Address object at 0x03229530> <orm_many_fk.Address object at 0x03229730>转换为：Alex tiantongyuan wudaokou
    def __repr__(self):
        return self.street

class Customer(Base):
    __tablename__ = "customer"
    id = Column(Integer,primary_key=True)
    name = Column(String(64))

    # 账单地址以及送货地址都关联了地址
    billing_address_id = Column(Integer,ForeignKey("address.id"))
    shipping_address_id = Column(Integer,ForeignKey("address.id"))


    # 可以通过billing_address以及shipping_address查询Address类的信息,内容放在内存
    billing_address = relationship("Address",foreign_keys = [billing_address_id])
    shipping_address = relationship("Address",foreign_keys = [shipping_address_id])



# 创建表结构，调用Base类下的metadata方法，调用接口engine，这里是通过父亲调用儿子，生成子类的东西
Base.metadata.create_all(engine)
orm_many_fk.py 
import orm_many_fk
from sqlalchemy.orm import sessionmaker

# 创建于数据库的会话session class，类似SQL里面的游标，但是这里返回给session的是个类，不是实例，所以下面需要实例化
Session_class = sessionmaker(bind=orm_many_fk.engine)
#生成session实例，这里相当于cursor
session = Session_class()

# 第一次需要这段代码创建数据
# addr1 = orm_many_fk.Address(street = "tiantongyuan",city = "ChangPing",state = "BJ")
# addr2 = orm_many_fk.Address(street = "wudaokou",city = "Haidian",state = "BJ")
# addr3 = orm_many_fk.Address(street = "Yanjiao",city = "LangFang",state = "HB")
#
# session.add_all([addr1,addr2,addr3])
# c1 = orm_many_fk.Customer(name = "Alex",billing_address = addr1,shipping_address = addr2)
# c2 = orm_many_fk.Customer(name = "Jack",billing_address = addr3,shipping_address = addr3)
#
# session.add_all([c1,c2])
# session.commit()

obj = session.query(orm_many_fk.Customer).filter(orm_many_fk.Customer.name == "alex").first()
print(obj.name,obj.billing_address,obj.shipping_address)
orm_api

 

多对多关联

#一本书可以有多个作者，一个作者又可以出版多本书


from sqlalchemy import Table, Column, Integer,String,DATE, ForeignKey
from sqlalchemy.orm import relationship
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker


Base = declarative_base()

# 第三张表用这个创建，因为这个表不需要用ORM更新
book_m2m_author = Table('book_m2m_author', Base.metadata,
Column('book_id',Integer,ForeignKey('books.id')),
Column('author_id',Integer,ForeignKey('authors.id')),
)

# 这种方式创建
class Book(Base):
__tablename__ = 'books'
id = Column(Integer,primary_key=True)
name = Column(String(64))
pub_date = Column(DATE)
#
# authors关联第三张表,不是真实的字段，通过secondary查询第三张表数据，Author通过backrep决定books反过来查询这张表Book
authors = relationship('Author',secondary=book_m2m_author,backref='books')

def __repr__(self):
return self.name

class Author(Base):
__tablename__ = 'authors'
id = Column(Integer, primary_key=True)
name = Column(String(32))

def __repr__(self):
return self.name


# API接口为mysql与pymysql mysql用户名root 密码Choice123 主机是localhost 数据my_db,类型为utf-8，echo=True，执行这段代码的时候，会打印过程
engine = create_engine("mysql+pymysql://root:Choice123@localhost/my_db",encoding = "utf-8")
# 创建表结构，调用Base类下的metadata方法，调用接口engine，这里是通过父亲调用儿子，生成子类的东西
Base.metadata.create_all(engine)
orm_m2m 
import orm_m2m
from sqlalchemy.orm import sessionmaker

# 创建于数据库的会话session class，类似SQL里面的游标，但是这里返回给session的是个类，不是实例，所以下面需要实例化
Session_class = sessionmaker(bind=orm_m2m.engine)
#生成session实例，这里相当于cursor
session = Session_class()

# 第一次需要这段代码创建数据
b1 = orm_m2m.Book(name = "learn python with Alex",pub_date = "2015-05-05")
b2 = orm_m2m.Book(name = "learn Zhangbility with Alex",pub_date = "2015-09-05")
b3 = orm_m2m.Book(name = "learn hook up girls with Alex",pub_date = "2014-10-05")

a1 = orm_m2m.Author(name = "Alex")
a2 = orm_m2m.Author(name = "Jack")
a3 = orm_m2m.Author(name = "Rain")

# 建立第三张表的关联关系
b1.authors = [a1,a3]
b3.authors = [a1,a2,a3]

session.add_all([b1,b2,b3,a1,a2,a3])
session.commit()

 

# obj = session.query(orm_m2m.Customer).filter(orm_m2m.Customer.name == "alex").first()
# print(obj.name,obj.billing_address,obj.shipping_address)
orm_m2m_api
orm_m2m_api查询

 

 

 

多对多删除

删除数据时不用管boo_m2m_authors　， sqlalchemy会自动帮你把对应的数据删除

author_obj =s.query(Author).filter_by(name="Jack").first()
book_obj = s.query(Book).filter_by(name="跟Alex学把妹").first()
book_obj.authors.remove(author_obj) #从一本书里删除一个作者
s.commit()
通过书删除作者 
import orm_m2m
from sqlalchemy.orm import sessionmaker

# 创建于数据库的会话session class，类似SQL里面的游标，但是这里返回给session的是个类，不是实例，所以下面需要实例化
Session_class = sessionmaker(bind=orm_m2m.engine)
#生成session实例，这里相当于cursor
session = Session_class()


# author_obj = session.query(orm_m2m.Author).filter(orm_m2m.Author.name == "alex").first()
# print(author_obj.name,author_obj.books)
#
# book_obj = session.query(orm_m2m.Book).filter(orm_m2m.Book.id == 2).first()
# book_obj.authors.remove(author_obj)
#
# session.commit()

author_obj = session.query(orm_m2m.Author).filter(orm_m2m.Author.name == "alex").first()
print(author_obj.name,author_obj.books)
session.delete(author_obj)
session.commit()
直接删除作者

若需要写入中文，需要将引擎这样写：

# API接口为mysql与pymysql mysql用户名root 密码Choice123 主机是localhost 数据my_db,类型为utf-8，echo=True，执行这段代码的时候，会打印过程
engine = create_engine("mysql+pymysql://root:Choice123@localhost/my_db?charset=utf8",encoding = "utf-8")
#一本书可以有多个作者，一个作者又可以出版多本书


from sqlalchemy import Table, Column, Integer,String,DATE, ForeignKey
from sqlalchemy.orm import relationship
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker


Base = declarative_base()

# 第三张表用这个创建，因为这个表不需要用ORM更新
book_m2m_author = Table('book_m2m_author', Base.metadata,
                        Column('book_id',Integer,ForeignKey('books.id')),
                        Column('author_id',Integer,ForeignKey('authors.id')),
                        )

# 这种方式创建
class Book(Base):
    __tablename__ = 'books'
    id = Column(Integer,primary_key=True)
    name = Column(String(64))
    pub_date = Column(DATE)
    #
    # authors关联第三张表,不是真实的字段，通过secondary查询第三张表数据，Author通过backrep决定books反过来查询这张表Book
    authors = relationship('Author',secondary=book_m2m_author,backref='books')

    def __repr__(self):
        return self.name

class Author(Base):
    __tablename__ = 'authors'
    id = Column(Integer, primary_key=True)
    name = Column(String(32))

    def __repr__(self):
        return self.name


# API接口为mysql与pymysql mysql用户名root 密码Choice123 主机是localhost 数据my_db,类型为utf-8，echo=True，执行这段代码的时候，会打印过程
engine = create_engine("mysql+pymysql://root:Choice123@localhost/my_db?charset=utf8",encoding = "utf-8")
# 创建表结构，调用Base类下的metadata方法，调用接口engine，这里是通过父亲调用儿子，生成子类的东西
Base.metadata.create_all(engine)
orm_m2m 
import orm_m2m
from sqlalchemy.orm import sessionmaker

# 创建于数据库的会话session class，类似SQL里面的游标，但是这里返回给session的是个类，不是实例，所以下面需要实例化
Session_class = sessionmaker(bind=orm_m2m.engine)
#生成session实例，这里相当于cursor
session = Session_class()

# b1 = orm_m2m.Book(name = "learn python with Alex",pub_date = "2015-05-05")
b1 = orm_m2m.Book(name = "中文书本名称",pub_date = "2018-05-05")
session.add(b1)

session.commit()
数据库写入中文

转载于:https://www.cnblogs.com/lin333/p/9803108.html

【Prometheus】MySQL主从搭建，以及如何通过prometheus监控MySQL运行状态
景天科技苑
02-11 7万+
要使用Prometheus 监控 MySQL，则需要 MySQL 服务器上部署对应的mysqld_exporter。 如果需要监控多个MySQL实例，则需要在每个MySQL实例上都部署一个mysqld_exporter， 因为每个 mysqld_exporter 只能连接并抓取一个MySQL 的指标数据。
Python菜鸟之路：sqlalchemy/paramiko进阶
weixin_33712987的博客
08-01 420
前言：ORM中的两种创建方式 　　数据库优先：指的是先创建数据库，包括表和字段的建立，然后根据数据库生成ORM的代码，它是先创建数据库，再创建相关程序代码 　　代码优先：就是先写代码，然后根据代码去生成数据库结构。 　　代码优先创建数据库的本质：拿到类-->转换成table对象， 然后根据table对象生成sql语句--> 生成数据库表结构 SQLalchemy联表操作 ...
MYSQL数据库简单的状态检查（show status）
zhibin的程序日记
04-27 4133
show processlist可以检查mysql当前sql语句的执行情况，而show status就可以检查mysql当前的状态 命令：show status（PS：可以通过like来过滤一些不必要的信息） 这个命令返回的信息相当之多，一共返回了291行信息（不用版本可能会有所差异哈），我选择了几个比较重点的来进行分析。 1.慢查询 mysql> show status like
Python操作MySQL -即pymysql/SQLAlchemy用法
AI人工智能的学习之路
11-07 1907
# -*- coding: utf-8 -*- """ Created on Tue Nov 7 12:38:21 2017 @author: lizheng """ import pymysql import pandas as pd """ 使用sqlalchemy结合pymysql 方式读取数据库 # =========================================
mysql（一）
pmt123456的博客
04-25 930
一、存储引擎        插件式存储引擎，包括MyISAM，InnoDB，BDB，MEMORY,MERGE,EXAMPLE,NDB cluster,ARCHIVE,CSV,BLACKHOLE，FEDERATED，其中InnoDB和BDB提供安全事务表，其他的存储引擎都是非安全事务表。 a、查看默认的存储引擎 show variables like 'default_storage_engi
MySQL安装教程（详细版）
m0_71422677的博客
02-20 41万+
MySQL免费安装教程、如何验证MySQL是否安装成功？怎么关掉MySQL服务？MySQL 端口问题如何解决？MySQL如何开机自启OR手动自启？安装MySQL时Starting the server 安装失败怎么解决？
2024 年 MySQL 8.0 安装 配置 教程 最简易（保姆级）
热门推荐
mobeiCanyue
12-09 73万+
首先去官网下一个MySQL MySQL :: Download MySQL Installer 这里没有看到64位的安装包, 不要着急, 这只是一个安装器, 安装包里有64位的MySQL Server8.0 这时候如果直接安装你会发现: 默认装到 C:\Program Files\MySQL , 而且不给你路径选择 我们知道, 如果是msi安装包安装, 会安装到C盘且没有路径选择. 如果是压缩包安装, 就是在命令行里调试, 可以解压安装到指定的路径. 但是, 命令行安装有致命...
【MySQL】MySQL超详细安装配置教程(保姆级)
2402_85428625的博客
03-24 4万+
什么是数据库存储数据用文件就可以了，为什么还要弄个数据库?文件的安全性问题文件不利于数据查询和管理文件不利于存储海量数据文件在程序中控制不方便磁盘内存为了解决上述问题，专家们设计出更加利于管理数据的软件——数据库，它能更有效的管理数据。数据库可以提供远程服务，即通过远程连接来使用数据库，因此也称为数据库服务器。
[新人向]MySQL和Navicat下载、安装及使用详细教程
weixin_46336128的博客
06-02 13万+
MySQL和Navicat下载和安装详细教程 因为这些软件的安装很多都是纯英文，作为新手安装真的需要摸索好久，包括我自己，所以Pipi酱就把自己的经验分享给大家~ MySQL的安装教程 一、下载安装包链接： 1.下载MySQL：https://dev.mysql.com/downloads/windows/installer/8.0.html 这里我们直接下载第一个（24.4M），下载到任意目录即可。 2、安装MySQL 二、安装 1、这里我们安装点击Yes 2、选择Custom，然后Next 3、
登录MySQL方式
小柚子的博客
06-16 6540
如果我们输入命令之后，提示不是合法的命令，这是需要去配置环境变量。计算机右击，点击属性，选择高级系统设置（也可以直接搜索）或者使用快捷键ctrl+c（只适合用于root用户）找到path，双击，编辑，添加即可。MySQL 客户端输入命令即可。从命令端（cmd）进入。找到安装目录，复制一下。
Java Web酒店管理系统源码 +mysql 数据库
03-19
数据库管理系统软件：MySQL 5.0。 java开发包：JDK 5.0以上。 Web服务器：Tomcat 6.0。 本系统采用MVC架构模式开发，具体技术如下。 AJAX框架：使用ExtJS技术开发 显示层：使用JSP技术开发 数据访问层：使用...
linux mysql 定时备份
java小白白之没有最白的博客
07-25 7万+
加入以下内容（/xp/server/mysql/bin/mysqldump是你的mysqldump备份命令，一般如果是正常安装的，可以直接用全局命令mysqldump，不用带前面的路径）4、编写crontab。5、查看是否添加成功。
如何解决MySQL 的深度分页问题？
2401_85373732的博客
01-10 32万+
本文分析了 MySQL 的深度分页问题及其解决方案。对于 MySQL 中的深度分页，我们可以通过合理的优化策略来提高查询效率。具体选用什么方案，需要根据具体场景进行分析，但核心在于理解数据库的工作原理，利用索引、优化查询策略、使用标记分页、分区表、缓存结果等优化技术。通过这些方法，可以显著提升分页查询的性能，改善用户体验。
MySQL安装配置教程（超级详细、保姆级）
Soloversion的博客
03-26 43万+
一、 下载MySQL Mysql官网下载地址https://downloads.mysql.com/archives/installer/ 1. 选择想要安装的版本，本篇文章选择的是5.7.31版本，下面的那个文件，点击Download下载 二、 安装MySQL 1. 选择设置类型 双击运行mysql-installer-community-5.7.31.0.msi 这里选择是自定义安装，所以直接选择“Custom”，点击“Next” “Developer Default”是开发者默认
【开题答辩全过程】以 基于SSM的电竞设备商城设计与开发为例，包含答辩的问题和答案
shiji7553的博客
09-03 591
这是一篇关于计算机专业毕业设计答辩的摘要。文中介绍了一位14年经验的资深毕设内行人，擅长Java、PHP、微信小程序、Python、Golang、安卓Android等多种开发语言，项目涉及大数据、深度学习、网站、小程序、安卓系统、算法等。该内行人还提供项目定制开发、代码讲解、答辩教学、文档编写、降重技巧等服务。 在答辩过程中，学生详细介绍了其基于SSM框架开发的电竞设备商城系统，包括用户角色划分、功能模块设计、技术选型依据（Java/SSM/HTML/CSS/MySQL/B-S架构）以及安全措施（MD5加盐
MySQL8.0 新特性随笔
qq_44784918的博客
09-02 491
MySQL 8.0相比5.7版本有多项重要改进：新增索引跳跃扫描、降序索引和函数索引功能；取消了group by隐式排序；支持隐藏索引和DDL原子操作；优化了buffer pool自适应参数和死锁检查机制；将undo log移出系统表空间；新增窗口函数支持。这些改变提升了索引使用效率、SQL执行性能和系统稳定性，使MySQL能更好地利用硬件资源并简化开发运维工作。
怎么快速构建一个deep search模型呢
最新发布
qq_57565004的博客
09-05 696
本文提出了一种快速构建具备深度信息检索能力的智能体系统（DeepSearch）的方法。该方法采用分阶段开发策略：首先基于RAG架构搭建基础检索链路，再通过LangChain框架整合大语言模型和搜索引擎API，赋予系统自主规划与迭代搜索能力，最终实现多源信息整合和结构化报告生成。技术选型上强调利用开源工具（如LangChain、ChromaDB）和预训练模型，通过"思考-检索-整合-迭代"的智能体工作流，高效构建可验证原型的核心功能。
Java-面试八股文-Mysql篇
2302_81048526的博客
08-29 2204
隔离级别脏读不可重复读幻读性能读未提交(RU)✅✅✅高读已提交(RC)❌✅✅较高可重复读(RR)❌❌✅(InnoDB 可避免)中串行化❌❌❌低特性悲观锁乐观锁思想假设一定会冲突假设大部分不会冲突实现for update、数据库排他锁、Java同步锁版本号 / 时间戳机制并发性能低高适用场景写多、冲突频繁读多写少、冲突少函数运算要避免，隐式转换要小心不等、OR、前模糊，索引基本挂掉联合索引最左前缀，范围之后不再用区分度低索引没用，优化器说了算对比项。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值