python之路13：MySQL

数据库介绍
mysql数据库安装使用
python操作mysql

数据库介绍

什么是数据库？

数据库（Database）是按照数据结构来组织、存储和管理数据的仓库，
每个数据库都有一个或多个不同的API用于创建，访问，管理，搜索和复制所保存的数据。
我们也可以将数据存储在文件中，但是在文件中读写数据速度相对较慢。
所以，现在我们使用关系型数据库管理系统（RDBMS）来存储和管理的大数据量。所谓的关系型数据库，是建立在关系模型基础上的数据库，借助于集合代数等数学概念和方法来处理数据库中的数据。
RDBMS即关系数据库管理系统(Relational Database Management System)的特点：
1.数据以表格的形式出现
2.每行为各种记录名称
3.每列为记录名称所对应的数据域
4.许多的行和列组成一张表单
5.若干的表单组成database

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数据库安装使用

安装：

yum -y install mysql-server

启动：

service mysqld start

进入mysql

输入mysql命令

基本操作：

show databases;查看数据库

show global status; 查看全局的运行各种状态

show global variables;查看服务器全局配置

use mysql; 进入mysql db

show tables; 查看表

desc user; 显示数据表的属性，属性类型，主键信息，是否为 NULL，默认值等其他信息

show index from user; 显示user的详细索引信息，包括PRIMARY KEY

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

grant all on testdb.* to root@192.168.199.176 identified by 'root176'; 授权

flush privileges; 刷新

show grants for root@192.168.199.176 ; 显示有哪些权限

drop database testdb; 删除testdb数据库

设置密码：mysqladmin -u root password "root123";

忘记密码：

service mysqld stop

mysqld_safe --user=root --skip-grant-tables

mysql -u root

use mysql

update user set password=password("root456") where user="root";

flush privileges;

python操作mysql

主要有两种方式：

原生模块 pymsql
ORM框架 SQLAchemy

pymysql

pymsql是Python中操作MySQL的模块，其使用方法和MySQLdb几乎相同。

安装：

pip3 install pymysql

数据库操作：

选择testdb数据库

use testdb

创建students表

create table students

(

id int not null auto_increment primary key,

name char(8) not null,

sex char(4) not null,

age tinyint unsigned not null,

tel char(13) null default "-"

);

往students插入信息

insert into students(name,sex,age,tel) values('tester','man',1,'1234214345');

查询表信息

select * from students;

更新表信息

update students set name = 'test' where id =1;

使用操作

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 __author__ = 'BillyLV'
 4 
 5 import pymysql  # 导入pymyql模块
 6 
 7 # 创建连接
 8 conn = pymysql.connect(host='192.168.199.176', user='root', passwd='root76', db='testdb')
 9 # 创建游标
10 cur = conn.cursor()
11 # 执行SQL
12 effect_row = cur.execute('insert into students(name,sex,age,tel) values(%s,%s,%s,%s)', ('tom', 'm', '2', '123456'))
13 # 提交
14 conn.commit()
15 # 关闭游标
16 cur.close()
17 # 关闭连接
18 conn.close()
19 
20 # 打印影响行数
21 print(effect_row)

插入数据

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 __author__ = 'BillyLV'
 4 
 5 import pymysql  # 导入pymyql模块
 6 
 7 # 创建连接
 8 conn = pymysql.connect(host='192.168.199.176', user='root', passwd='root76', db='testdb')
 9 # 创建游标
10 cur = conn.cursor()
11 
12 list1 = [
13      ('tom', 'm', '2', '1'),
14      ('jerry', 'm', '2', '2'),
15      ('bill', 'm', '2', '3'),
16      ('lily', 'f', '2', '4'),
17      ('rain', 'm', '2', '5'),
18      ('alice', 'f', '2', '6'),
19     ]
20 # 执行SQL
21 effect_row = cur.executemany('insert into students(name,sex,age,tel) values(%s,%s,%s,%s)', list1)
22 # 提交
23 conn.commit()
24 # 关闭游标
25 cur.close()
26 # 关闭连接
27 conn.close()
28 
29 # 打印影响行数
30 print(effect_row)

批量插入数据

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 __author__ = 'BillyLV'
 4 
 5 import pymysql  # 导入pymyql模块
 6 
 7 # 创建连接
 8 conn = pymysql.connect(host='192.168.199.176', user='root', passwd='root76', db='testdb')
 9 # 创建游标
10 cur = conn.cursor()
11 
12 list1 = [
13     'bill',
14     'lily',
15     'rain',
16     'alice',
17     ]
18 # 执行一条SQL
19 effect_row = cur.execute("delete from students where name='test'")
20 # 执行多条SQL
21 effect_row = cur.executemany('delete from students where name=(%s)', list1)
22 
23 # 提交
24 conn.commit()
25 
26 # 打印影响行数
27 print(effect_row)
28 # 打印最后行id
29 print(cur.lastrowid)
30 
31 # 关闭游标
32 cur.close()
33 # 关闭连接
34 conn.close()

删除数据

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 __author__ = 'BillyLV'
 4 
 5 import pymysql  # 导入pymyql模块
 6 
 7 # 创建连接
 8 conn = pymysql.connect(host='192.168.199.176', user='root', passwd='root76', db='testdb')
 9 # 创建游标
10 cur = conn.cursor()
11 
12 # 执行一条SQL
13 effect_row = cur.execute('update students set name=%s where id=2', 'ta')
14 
15 # 提交
16 conn.commit()
17 
18 # 打印影响行数
19 print(effect_row)
20 # 打印最后行id
21 print(cur.lastrowid)
22 
23 # 关闭游标
24 cur.close()
25 # 关闭连接
26 conn.close()

更改数据

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 __author__ = 'BillyLV'
 4 
 5 import pymysql  # 导入pymyql模块
 6 
 7 # 创建连接
 8 conn = pymysql.connect(host='192.168.199.176', user='root', passwd='root76', db='testdb')
 9 # 创建游标
10 cur = conn.cursor()
11 
12 # 执行SQL并返回受影响行数
13 effect_row = cur.execute('select * from students')
14 
15 # 返回下一条数据
16 print(cur.fetchone())
17 # 向下滚动5行，从下一行开始数数
18 cur.scroll(5, mode='absolute')
19 print(cur.fetchone())
20 # 向上滚动3行，从当前行开始数数
21 cur.scroll(-3, mode='relative')
22 print(cur.fetchone())
23 
24 # 返回指定大小条数的数据
25 print(cur.fetchmany(2))
26 # 返回所有数据
27 print(cur.fetchall())
28 
29 # 获取最新自增ID
30 print(cur.lastrowid)
31 # 打印影响行数
32 print(effect_row, 'rows')
33 
34 # 关闭游标
35 cur.close()
36 # 关闭连接
37 conn.close()

查询数据

ORM框架SQLAchemy

ORM介绍

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

orm的优点：

隐藏了数据访问细节，“封闭”的通用数据库交互，ORM的核心。他使得我们的通用数据库交互变得简单易行，并且完全不用考虑该死的SQL语句。快速开发，由此而来。
ORM使我们构造固化数据结构变得简单易行。

缺点：

无可避免的，自动化意味着映射和关联管理，代价是牺牲性能（早期，这是所有不喜欢ORM人的共同点）。现在的各种ORM框架都在尝试使用各种方法来减轻这块（LazyLoad，Cache），效果还是很显著的。

sqlalchemy介绍

SQLAlchemy是一个基于Python实现的ORM框架。该框架建立在 DB API之上，使用关系对象映射进行数据库操作，简言之便是：将类和对象转换成SQL，然后使用数据API执行SQL并获取执行结果。

组成部分：

Engine，框架的引擎
Connection Pooling ，数据库连接池
Dialect，选择连接数据库的DB API种类
Schema/Types，架构和类型
SQL Exprression Language，SQL表达式语言

SQLAlchemy本身无法操作数据库，其必须以来pymsql等第三方插件，Dialect用于和DBAPI进行交流，根据配置文件的不同调用不同的DBAPI，从而实现对DB的操作，如：

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

安装sqlalchemy

pip3 install sqlalchemy -i http://pypi.douban.com/simple --trusted-host pypi.douban.com

sqlalchemy基本使用

步骤一：

使用 Engine/ConnectionPooling/Dialect 进行数据库操作，Engine使用ConnectionPooling连接数据库，然后再通过Dialect执行SQL语句。

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 __author__ = 'BillyLV'
 4 
 5 from sqlalchemy import create_engine
 6 
 7 engine = create_engine(
 8     "mysql+pymysql://root:root76@192.168.199.176:3306/testdb?charset=utf8",
 9     max_overflow=5,  # 超过连接池大小外最多创建的连接
10     pool_size=10,  # 连接池大小
11     pool_timeout=6,  # 池中没有线程最多等待的时间，否则报错
12     pool_recycle=-1  # 多久之后对线程池中的线程进行一次连接的回收（重置）
13 )
14 
15 engine.execute("CREATE TABLE user (id INTEGER NOT NULL AUTO_INCREMENT,name VARCHAR(32),password VARCHAR(64),
16 PRIMARY KEY (id))")
17 
18 engine.execute(
19     "insert into user(name,password) values('jack','jackpwd')"
20 )
21 
22 result = engine.execute('select * from user')
23 print(result.fetchall())

create&insert table

步骤二：

使用 Schema Type/SQL Expression Language/Engine/ConnectionPooling/Dialect 进行数据库操作。Engine使用Schema Type创建一个特定的结构对象，之后通过SQL Expression Language将该对象转换成SQL语句，然后通过 ConnectionPooling 连接数据库，再然后通过 Dialect 执行SQL，并获取结果。

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 __author__ = 'BillyLV'
 4 
 5 from sqlalchemy import create_engine, Table, Column, Integer, String, MetaData, ForeignKey, select
 6 
 7 metadata = MetaData()
 8 
 9 user = Table('user', metadata,
10     Column('id', Integer, primary_key=True),
11     Column('name', String(20)),
12 )
13 
14 color = Table('color', metadata,
15     Column('id', Integer, primary_key=True),
16     Column('name', String(20)),
17 )
18 
19 engine = create_engine("mysql+pymysql://root:root76@192.168.199.176:3306/testdb?charset=utf8", max_overflow=5)
20 conn = engine.connect()
21 
22 # insert
23 sql = user.insert().values(id=8, name='h')
24 conn.execute(sql)
25 
26 # update
27 sql = user.update().values(fullname=user.c.name)
28 sql = user.update().where(user.c.name == 'cc').values(name='ab')
29 conn.execute(sql)
30 
31 # delete
32 sql = user.delete().where(user.c.id > 3)
33 conn.execute(sql)
34 
35 # select
36 # select_sql = select([user, ])
37 # select_sql = select([user.c.id, user.c.name])
38 # select_sql = select([user.c.name, color.c.name]).where(user.c.id==color.c.id)
39 # select_sql = select([user.c.name]).order_by(user.c.name)
40 select_sql = select([user]).group_by(user.c.id)
41 result = conn.execute(select_sql)
42 output = result.fetchall()
43 print(output)
44 conn.close()

增删改查

步骤三：

使用 ORM/Schema Type/SQL Expression Language/Engine/ConnectionPooling/Dialect 所有组件对数据进行操作。根据类创建对象，对象转换成SQL，执行SQL。

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 __author__ = 'BillyLV'
 4 
 5 import sqlalchemy
 6 from sqlalchemy import create_engine
 7 from sqlalchemy.ext.declarative import declarative_base
 8 from sqlalchemy import Column, Integer, String
 9 from sqlalchemy.orm import sessionmaker
10 
11 engine = create_engine("mysql+pymysql://root:root76@192.168.199.176:3306/testdb?charset=utf8", encoding='utf-8',
12                        echo=True, max_overflow=5)
13 
14 Base = declarative_base()  # 生成orm基类
15 
16 
17 class User(Base):
18     __tablename__ = 'user'  # 表名
19     id = Column(Integer, primary_key=True)
20     name = Column(String(32))
21     password = Column(String(64))
22 
23 
24 Base.metadata.create_all(engine)  # 创建表结构
25 
26 Session_class = sessionmaker(bind=engine)  # 创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例
27 Session = Session_class()  # 生成session实例
28 
29 user_obj = User(name="bill", password="123456")  # 生成你要创建的数据对象
30 print(user_obj.name, user_obj.id)  # 此时还没创建对象呢，不信你打印一下id发现还是None
31 
32 Session.add(user_obj)  # 把要创建的数据对象添加到这个session里， 一会统一创建
33 print(user_obj.name, user_obj.id)  # 此时也依然还没创建
34 
35 Session.commit()  # 现此才统一提交，创建数据
36 print(user_obj.name, user_obj.id)

create&insert

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 __author__ = 'BillyLV'
 4 
 5 import sqlalchemy
 6 from sqlalchemy import create_engine
 7 from sqlalchemy.ext.declarative import declarative_base
 8 from sqlalchemy import Column, Integer, String
 9 from sqlalchemy.orm import sessionmaker
10 
11 engine = create_engine("mysql+pymysql://root:root76@192.168.199.176:3306/testdb?charset=utf8", encoding='utf-8',
12                        echo=True, max_overflow=5)
13 
14 Base = declarative_base()  # 生成orm基类
15 
16 
17 class User(Base):
18     __tablename__ = 'user'  # 表名
19     id = Column(Integer, primary_key=True)
20     name = Column(String(32))
21     password = Column(String(64))
22 
23 
24 Base.metadata.create_all(engine)  # 创建表结构
25 
26 Session_class = sessionmaker(bind=engine)  # 创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例
27 Session = Session_class()  # 生成session实例
28 
29 user_obj = User(name="li", password="12345678")  # 生成你要创建的数据对象
30 print(user_obj.name, user_obj.id)  # 此时还没创建对象呢，不信你打印一下id发现还是None
31 
32 Session.add(user_obj)  # 把要创建的数据对象添加到这个session里， 一会统一创建
33 print(user_obj.name, user_obj.id)  # 此时也依然还没创建
34 
35 my_user = Session.query(User).filter_by(name="bill").first()  # 查询user表name为bill的第一条数据
36 print(my_user.id, my_user.name, my_user.password)  # 打印user表name为bill的id、name、password字段

select

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 __author__ = 'BillyLV'
 4 
 5 import sqlalchemy
 6 from sqlalchemy import create_engine
 7 from sqlalchemy.ext.declarative import declarative_base
 8 from sqlalchemy import Column, Integer, String
 9 from sqlalchemy.orm import sessionmaker
10 
11 engine = create_engine("mysql+pymysql://root:root76@192.168.199.176:3306/testdb?charset=utf8", encoding='utf-8',
12                        echo=True, max_overflow=5)
13 
14 Base = declarative_base()  # 生成orm基类
15 
16 
17 class User(Base):
18     __tablename__ = 'user'  # 表名
19     id = Column(Integer, primary_key=True)
20     name = Column(String(32))
21     password = Column(String(64))
22 
23 
24 Base.metadata.create_all(engine)  # 创建表结构
25 
26 Session_class = sessionmaker(bind=engine)  # 创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例
27 Session = Session_class()  # 生成session实例
28 
29 user_obj = User(name="li", password="12345678")  # 生成你要创建的数据对象
30 print(user_obj.name, user_obj.id)  # 此时还没创建对象呢，不信你打印一下id发现还是None
31 
32 Session.add(user_obj)  # 把要创建的数据对象添加到这个session里， 一会统一创建
33 print(user_obj.name, user_obj.id)  # 此时也依然还没创建
34 
35 # my_user = Session.query(User).filter_by(name="bill").first()  # 查询user表name为bill的第一条数据
36 # print(my_user.id, my_user.name, my_user.password)  # 打印user表name为bill的id、name、password字段
37 
38 # 修改，把user表name为bill的第一条数据的name改为alex
39 my_user = Session.query(User).filter_by(name="bill").first()
40 my_user.name = "alex"
41 Session.commit()  # 提交修改
42 print(my_user.id, my_user.name, my_user.password)

update

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 __author__ = 'BillyLV'
 4 
 5 import sqlalchemy
 6 from sqlalchemy import create_engine
 7 from sqlalchemy.ext.declarative import declarative_base
 8 from sqlalchemy import Column, Integer, String
 9 from sqlalchemy.orm import sessionmaker
10 
11 # 设置utf8编码字符集
12 engine = create_engine("mysql+pymysql://root:root76@192.168.199.176:3306/testdb?charset=utf8", encoding='utf-8',
13                        echo=True, max_overflow=5)
14 
15 Base = declarative_base()  # 生成orm基类
16 
17 
18 class User(Base):
19     __tablename__ = 'user'  # 表名
20     id = Column(Integer, primary_key=True)
21     name = Column(String(32))
22     password = Column(String(64))
23 
24     def __repr__(self):
25         return "<User(name='%s',  password='%s')>" % (
26             self.name, self.password)
27 
28 
29 Base.metadata.create_all(engine)  # 寻找Base的所有子类，按照子类的结构在数据库中生成对应的数据表信息
30 
31 Session_class = sessionmaker(bind=engine)  # 创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例
32 Session = Session_class()  # 生成session实例
33 
34 user_obj = User(name="li", password="12345678")  # 生成你要创建的数据对象
35 print(user_obj.name, user_obj.id)  # 此时还没创建对象呢，不信你打印一下id发现还是None
36 
37 Session.add(user_obj)  # 把要创建的数据对象添加到这个session里， 一会统一创建
38 print(user_obj.name, user_obj.id)  # 此时也依然还没创建
39 
40 my_user = Session.query(User).filter_by(name="li").first()  # 查询user表name为bill的第一条数据
41 # print(my_user.id, my_user.name, my_user.password)  # 打印user表name为bill的id、name、password字段
42 print(Session.query(User.name, User.id).all())  # 获取所有数据
43 
44 # 修改，把user表name为bill的第一条数据的name改为alex
45 # my_user = Session.query(User).filter_by(name="bill").first()
46 # my_user.name = "alex"
47 # Session.commit()  # 提交修改
48 # print(my_user.id, my_user.name, my_user.password)
49 
50 # 删除
51 Session.query(User).filter(User.id < 90).delete()
52 Session.commit()
53 print(Session.query(User.name, User.id).all())  # 获取所有数据

delete

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 __author__ = 'BillyLV'
 4 
 5 from sqlalchemy.ext.declarative import declarative_base
 6 from sqlalchemy import Column, Integer, String
 7 from sqlalchemy.orm import sessionmaker
 8 from sqlalchemy import create_engine
 9 
10 engine = create_engine("mysql+pymysql://root:root76@192.168.199.176:3306/testdb?charset=utf8", encoding='utf-8',
11                        echo=True, max_overflow=5)
12 
13 Base = declarative_base()
14 
15 
16 class User(Base):
17     __tablename__ = 'users'
18     id = Column(Integer, primary_key=True)
19     name = Column(String(50))
20 
21     def __repr__(self):
22         return "<User(name='%s',  id='%s')>" % (
23             self.name, self.id)
24 
25 
26 # 寻找Base的所有子类，按照子类的结构在数据库中生成对应的数据表信息
27 Base.metadata.create_all(engine)
28 
29 Session = sessionmaker(bind=engine)
30 session = Session()
31 
32 # ########## 增 ##########
33 u = User(id=11, name='a')
34 session.add(u)
35 session.add_all([
36     User(id=22, name='b'),
37     User(id=33, name='c')
38 ])
39 session.commit()
40 
41 # ########## 删除 ##########
42 session.query(User).filter(User.id > 8).delete()
43 session.commit()
44 
45 # ########## 修改 ##########
46 session.query(User).filter(User.id > 3).update({'name': 'B'})
47 session.commit()
48 # ########## 查 ##########
49 res = session.query(User.name.label('name_label')).all()
50 print(res)
51 
52 res = session.query(User).order_by(User.id).all()
53 print(res)
54 
55 res = session.query(User).order_by(User.id)[1:3]
56 print(res)
57 session.commit()

增删改查

参考：

http://www.cnblogs.com/alex3714

http://www.cnblogs.com/wupeiqi

internet＆python books

PS:如侵权，联我删。