Python開發【第十一篇】：Python操做MySQL

本篇對於Python操做MySQL主要使用兩種方式：

一、原生模塊pymsql。

二、ORM框架SQLAchemy。

pymsql

pymsql是Python中操做MySQL的模塊，其使用方法和MySQLdb幾乎相同。

windows下載安裝

1. pip3 install pymysql

使用操做

執行SQL

1. __author__ = 'Golden'
2. #!/usr/bin/env python3
3. # -*- coding:utf-8 -*-
4. import pymysql
5.  
6. # 建立鏈接
7. conn = pymysql.connect(host='192.168.31.134',port=3306,user='root',passwd='123456',db='information_schema')
8. # 建立遊標
9. cursor = conn.cursor()
10. # 執行SQL，並返回受影響行數
11. effect_row = cursor.execute("select * from tables")
12. print(effect_row)
13. # 取出一條數據
14. print(cursor.fetchone())
15. # 取出前n條數據
16. print("*********************************************************")
17. print(cursor.fetchmany(5))
18. # 取出全部數據
19. print("*********************************************************")
20. print(cursor.fetchall())
21. # 提交，否則沒法保存新建或修改的數據
22. conn.commit()
23. # 關閉遊標
24. cursor.close()
25. # 關閉鏈接
26. conn.close()

可能報錯：pymysql.err.InternalError: (1130, "Host '192.168.31.1' is not allowed to connect to this MySQL server")

多是由於你的帳號不容許從遠程登陸，只能在localhost登陸。只須要在localhost的那臺電腦登陸mysql，更改對應數據庫裏的"user"表裏的"host"項，把"localhost"改成"%"。

解決辦法：

一、改表法

1. [root@lnmp ~]# mysql -uroot -p123456
2. mysql> use test;
3. Database changed
4. mysql> update user set host = '%' where user = 'root';
5. mysql> select host,user from user;
6. mysql> flush rivileges;

二、受權法

容許用戶user使用密碼password從任何主機鏈接到mysql服務器。

1. mysql> grant all privileges on *.* to 'user'@'%' identified by 'password' with grant option;
2. mysql> flush privileges;

容許用戶user從ip192.168.1.122的主機鏈接到mysql服務器，並使用password做爲密碼。

1. mysql> grant all privileges on *.* to 'user'@'192.168.1.122' identified by 'password' with grant option;
2. mysql> flush privileges;

容許用戶user從ip192.168.1.122的主機鏈接到mysql服務器的test_db數據庫，並使用password做爲密碼。

1. mysql> grant all privileges on test_db.* to 'user'@'192.168.1.122' identified by 'password' with grant option;
2. mysql> flush privileges;

插入數據

1. # 插入數據
2. effect_row = cursor.executemany("inster into table_name(field_name1,field_name2) values(%s,%s)",[("value_1","value_2"),("value_3","value_4")])

SQLAlchemy ORM

ORM介紹

對象關係映射（Object Relational Mapping，簡稱ORM），是一種程序技術，用於實現面向對象編程語言裏不一樣類型系統的數據之間的轉換。從效果上說，它實際上是建立了一個可在編程語言裏使用的——"虛擬對象數據庫"。

面向對象是從軟件工程基本原則（如耦合、聚合、封裝）的基礎上發展起來的，而關係數據庫則是從數學理論發展而來的，兩套理論存在顯著的區別。爲了解決這個不匹配的現象，對象關係映射技術應運而生。

對象關係映射（Object Relational Mapping）提供了概念性的、易於理解的模型化數據的方法。ORM方法論基於三個核心原則。簡單，以最基本的形式建模數據。傳達性，數據庫結構被任何人都能理解的語言文檔化。精確性，基於數據模型建立正確標準化的結構。典型地，建模者經過收集來自那些熟悉應用程序但不熟練數據建模者開發信息模型。建模者必須可以用非技術企業專家能夠理解的術語在概念層次上與數據結構進行通信。建模者也必須能以簡單的單元分析信息，對樣本數據進行處理。ORM專門被設計爲改進這種聯繫。

ORM的優勢

一、隱藏了數據訪問細節，"封閉"的通用數據庫交互，ORM的核心。使得通用數據庫的交互變得簡單易行，而且徹底不用考慮SQL語句。

二、ORM使構造固化數據結構變得簡單易行。

ORM的缺點

一、自動化意味着映射和關聯管理，代價是犧牲性能。如今各類ORM框架都在嘗試使用各類方法（如LazyLoad、Cache）來減輕性能的影響，效果比較顯著。

二、面向對象的查詢語言（OQL）做爲一種數據庫與對象之間的過渡，雖然隱藏了數據層面的業務抽象，但並不能徹底的屏蔽掉數據庫層的設計，而且無疑將增長學習成本。

三、對於複雜查詢，ORM仍然力不從心。雖然能夠實現，可是不值得。視圖能夠解決大部分calculated column、case、group、having、order by、exists，可是查詢條件a and b and not c and (d or e)不能很好解決。

經常使用的ORM框架

一、Hibernate全自動須要hql語句。

二、iBatis半自動本身寫sql語句，可操做性強，小巧。

三、EclipseLink一個可擴展的支持JPA的ORM框架，提供強大的緩存功能，緩存支持集羣。

四、Apache OJB等等。

五、在Python中最著名的ORM框架是SQLAlchemy。

SQLAlchemy安裝

SQLAlchemy的理念是，SQL數據庫的量級和性能重要於對象集合，而對象集合的抽象又重要與表和行。

Dialect用於和數據API進行交流，根據配置文件的不一樣調用不一樣的數據庫API，從而實現對數據庫的操做。

1. MySQL-Python
2.     mysql+mysqldb://<user>:<password>@<host>[:<port>]/<dbname>
3.  
4. pymysql
5.     mysql+pymysql://<username>:<password>@<host>/<dbname>[?<options>]
6.  
7. MySQL-Connector
8.     mysql+mysqlconnector://<user>:<password>@<host>[:<port>]/<dbname>
9.  
10. cx_Oracle
11.     oracle+cx_oracle://user:pass@host:port/dbname[?key=value&key=value...]
12.  
13. 更多詳見：http://docs.sqlalchemy.org/en/latest/dialects/index.html

安裝sqlalchemy

1. pip3 install sqlalchemy

SQLAlchemy基本使用

建立一個表。

SQL實現：

1. CREATE TABLE USER(
2.    ID INTEGER NOT NULL AUTO_INCREMENT,
3.    NAME VARCHAR(32),
4.    PASSWORD VARCHAR(64),
5.    PRIMARY KET (ID)
6. )

ORM實現：

1. __author__ = 'Golden'
2. #!/usr/bin/env python3
3. # -*- coding:utf-8 -*-
4.  
5. import sqlalchemy
6.  
7. from sqlalchemy import create_engine
8. from sqlalchemy.ext.declarative import declarative_base
9. from sqlalchemy import Column,Integer,String
10.  
11. # echo=True打印信息
12. engine = create_engine("mysql+pymysql://root:123456@192.168.31.134/test_db",
13.                        encoding='utf-8',echo=True)
14.  
15. # 生成orm基類
16. Base = declarative_base()
17.  
18. class User(Base):
19.     # 表名
20.     __tablename__ = 'USER'
21.     # 定義字段ID，並設置爲主鍵
22.     ID = Column(Integer,primary_key=True)
23.     NAME = Column(String(32))
24.     PASSWORD = Column(String(64))
25. # 建立表結構
26. Base.metadata.create_all(engine)

除了上面的建立表以外，還有一種建立表的方式。

1. __author__ = 'Golden'
2. #!/usr/bin/env python3
3. # -*- coding:utf-8 -*-
4.  
5. import sqlalchemy
6.  
7. from sqlalchemy import create_engine,Table,MetaData,Column,Integer,String,ForeignKey
8. from sqlalchemy.orm import mapper
9.  
10. engine = create_engine("mysql+pymysql://root:123456@192.168.31.134/test_db",
11.                        encoding='utf-8',echo=True)
12. metadata = MetaData()
13.  
14. user = Table('USER_TABLE',metadata,
15.              Column('ID',Integer,primary_key=True),
16.              Column('NAME',String(50)),
17.              Column('FULLNAME',String(50)),
18.              Column('PASSWORD',String(12))
19.              )
20.  
21.  
22. class User(object):
23.     def __init__(self,name,fullname,password):
24.         self.name = name
25.         self.fullname = fullname
26.         self.password = password
27.  
28. mapper(User,user)
29.  
30. # 建立表結構
31. metadata.create_all(engine)

第一種方式建立的表是基於第二種方式的再封裝。

使用ORM建立一條數據。

1. __author__ = 'Golden'
2. #!/usr/bin/env python3
3. # -*- coding:utf-8 -*-
4.  
5. import sqlalchemy
6. from sqlalchemy import create_engine,Column,Integer,String
7. from sqlalchemy.orm import sessionmaker
8. from sqlalchemy.ext.declarative import declarative_base
9.  
10. engine = create_engine("mysql+pymysql://root:123456@192.168.31.134/test_db",
11.                        encoding='utf-8',echo=True)
12. Base = declarative_base()
13.  
14. class User(Base):
15.     __tablename__ = 'USER'
16.     ID = Column(Integer,primary_key=True)
17.     NAME = Column(String(32))
18.     PASSWORD = Column(String(64))
19.  
20. Base.metadata.create_all(engine)
21. # 建立與數據庫的會話session class，注意這裏返回給session的是一個class，不是實例
22. Session_class = sessionmaker(bind=engine)
23. # 生成session實例
24. Session = Session_class()
25. # 生成要建立的數據對象
26. user_obj = User(NAME="Golden",PASSWORD="123456")
27. # 此時尚未建立對象
28. print(user_obj.NAME,user_obj.ID)
29. # 把須要建立的數據對象添加到session
30. Session.add(user_obj)
31. # 此時尚未建立對象
32. print(user_obj.NAME,user_obj.ID)
33. # 建立數據，統一提交
34. Session.commit()

查詢、修改

1. __author__ = 'Golden'
2. #!/usr/bin/env python3
3. # -*- coding:utf-8 -*-
4.  
5. import sqlalchemy
6. from sqlalchemy import create_engine,Column,Integer,String
7. from sqlalchemy.ext.declarative import declarative_base
8. from sqlalchemy.orm import sessionmaker
9. engine = create_engine("mysql+pymysql://root:123456@192.168.31.134/test_db",
10.                        encoding='utf-8',echo=False)
11. Base = declarative_base()
12. class User(Base):
13.     __tablename__ = 'USER'
14.     ID = Column(Integer,primary_key=True)
15.     NAME = Column(String(32))
16.     PASSWORD = Column(String(64))
17.  
18.     def __repr__(self):
19.         return "<NAME : %s | PASSWORD : %s>" %(self.NAME,self.PASSWORD)
20.  
21. Session_class = sessionmaker(bind=engine)
22. Session = Session_class()
23. # first 查出NAME='Golden'的第一個
24. my_user = Session.query(User).filter_by(NAME='Golden').first()
25. print(my_user.NAME,my_user.PASSWORD)
26. # NAME='Golden'
27. data = Session.query(User).filter_by(NAME='Golden').all()
28. print(data[0].PASSWORD)
29. #all 查出全部
30. data_2 = Session.query(User).filter_by().all()
31. print(data_2)
32. data_3 = Session.query(User).filter(User.ID == 1).all()
33. print(data_3)
34. data_4 = Session.query(User).filter_by(ID=1).all()
35. print(data_4)
36. # 多條件查詢
37. data_5 = Session.query(User).filter(User.ID > 1).filter(User.ID < 4).all()
38. print(data_5)
39. data_6 = Session.query(User).filter().first()
40. print(data_6)
41. # 修改
42. data_6.NAME = 'zhangsan'
43. data_6.PASSWORD = '110'
44. # 提交
45. Session.commit()

回滾

1. __author__ = 'Golden'
2. #!/usr/bin/env python3
3. # -*- coding:utf-8 -*-
4.  
5. import sqlalchemy
6. from sqlalchemy import create_engine,Column,Integer,String
7. from sqlalchemy.ext.declarative import declarative_base
8. from sqlalchemy.orm import sessionmaker
9.  
10. engine = create_engine("mysql+pymysql://root:123456@192.168.31.134/test_db",
11.                        encoding='utf-8',echo=False)
12. Base = declarative_base()
13.  
14. class User(Base):
15.     __tablename__ = 'USER'
16.     ID = Column(Integer,primary_key=True)
17.     NAME = Column(String(32))
18.     PASSWORD = Column(String(64))
19.  
20.     def __repr__(self):
21.         return "<ID : %s | NAME : %s | PASSWORD : %s>" %(self.ID,self.NAME,self.PASSWORD)
22.  
23. Session_class = sessionmaker(bind=engine)
24. Session = Session_class()
25.  
26. my_user = Session.query(User).filter_by(ID=1).first()
27. my_user.NAME = 'Mark'
28.  
29. fake_user = User(NAME='Merry',PASSWORD='999999')
30. Session.add(fake_user)
31. # 查看剛剛添加和修改的數據
32. print(Session.query(User).filter(User.NAME.in_(['Merry','Mark'])).all())
33. # rollback
34. Session.rollback()
35. # 再次查詢
36. print(Session.query(User).filter(User.NAME.in_(['Merry','Mark'])).all())

統計和分組

1. __author__ = 'Golden'
2. #!/usr/bin/env python3
3. # -*- coding:utf-8 -*-
4.  
5. import sqlalchemy
6. from sqlalchemy import create_engine,Column,Integer,String,func
7. from sqlalchemy.ext.declarative import declarative_base
8. from sqlalchemy.orm import sessionmaker
9.  
10. engine = create_engine("mysql+pymysql://root:123456@192.168.31.134/test_db",
11.                        encoding='utf-8',echo=False)
12.  
13. Base = declarative_base()
14.  
15.  
16. class User(Base):
17.     __tablename__ = 'USER'
18.     ID = Column(Integer,primary_key=True)
19.     NAME = Column(String(32))
20.     PASSWORD = Column(String(64))
21.  
22.     def __repr__(self):
23.         return "<ID : %s | NAME : %s | PASSWORD : %s>" %(self.ID,self.NAME,self.PASSWORD)
24.  
25. Session_class = sessionmaker(bind=engine)
26. Session = Session_class()
27. # 統計ha開頭的NAME個數
28. print(Session.query(User).filter(User.NAME.like("ha%")).count())
29. # 分組
30. print(Session.query(User.NAME,func.count(User.NAME)).group_by(User.NAME).all())

連表

1. __author__ = 'Golden'
2. #!/usr/bin/env python3
3. # -*- coding:utf-8 -*-
4.  
5. import sqlalchemy
6. from sqlalchemy import create_engine,Column,Integer,String,DATE
7. from sqlalchemy.orm import sessionmaker
8. from sqlalchemy.ext.declarative import declarative_base
9.  
10. engine = create_engine("mysql+pymysql://root:123456@192.168.31.134/test_db",
11.                        encoding='utf-8',echo=True)
12. Base = declarative_base()
13.  
14. class User(Base):
15.     __tablename__ = 'USER'
16.     ID = Column(Integer,primary_key=True)
17.     NAME = Column(String(32))
18.     PASSWORD = Column(String(64))
19.  
20.     def __repr__(self):
21.         return "<ID :%s | NAME : %s | PASSWORD : %s>" %(self.ID,self.NAME,self.PASSWORD)
22.  
23.  
24. class Student(Base):
25.     __tablename__ = 'STUDENT'
26.     ID = Column(Integer,primary_key=True)
27.     NAME = Column(String(32),nullable=False)
28.     REGISTER_DATE = Column(DATE,nullable=False)
29.     GENDER = Column(String(32),nullable=False)
30.  
31.     def __repr__(self):
32.         return "<NAME : %s | PASSWORD : %s>" %(self.NAME,self.REGISTER_DATE)
33.  
34. Base.metadata.create_all(engine)
35. Session_class = sessionmaker(bind=engine)
36. Session = Session_class()
37.  
38. # 外聯
39. print(Session.query(User,Student).filter(User.ID == Student.ID).all())
40. # 兩個表必須有外鍵關聯才能使用 Can't find any foreign key relationships between 'A' and 'B'
41. print(Session.query(User).join(Student).all())
42. print(Session.query(User).join(Student,isouter=True).all())
43. Session.commit()

實現兩個表的外鍵關聯

1. __author__ = 'Golden'
2. #!/usr/bin/env python3
3. # -*- coding:utf-8 -*-
4. import sqlalchemy
5. from sqlalchemy import create_engine,Column,Integer,String,DATE,ForeignKey
6. from sqlalchemy.orm import sessionmaker,relationship
7. from sqlalchemy.ext.declarative import declarative_base
8.  
9. engine = create_engine("mysql+pymysql://root:123456@192.168.31.134/test_db",
10.                        encoding='utf-8',echo=False)
11. Base = declarative_base()
12.  
13. class Student(Base):
14.     __tablename__ = 'student'
15.     id = Column(Integer,primary_key=True)
16.     name = Column(String(32),nullable=False)
17.     register_date = Column(DATE,nullable=False)
18.  
19.     def __repr__(self):
20.         return "<name : %s | register_date : %s>"%(self.name,self.register_date)
21.  
22.  
23. class StudyRecord(Base):
24.     __tablename__ = "study_record"
25.     id = Column(Integer,primary_key=True)
26.     day = Column(Integer,nullable=False)
27.     status = Column(String(32),nullable=False)
28.     # 建立外鍵
29.     stu_id = Column(Integer,ForeignKey("student.id"))
30.     #
31.     student = relationship("Student",backref="my_study_record")
32.  
33.     def __repr__(self):
34.        return "<%s day :%s | status : %s>"%(self.student.name,self.day,self.status)
35. # 建立表結構
36. Base.metadata.create_all(engine)
37. # 建立與數據庫的會話session
38. Session_class = sessionmaker(bind=engine)
39. # 生成session實例
40. session = Session_class()
41.  
42. """添加數據
43. s1 = Student(name="Golden",register_date="2017-12-24")
44. s2 = Student(name="Jack",register_date="2017-11-13")
45. s3 = Student(name="Rain",register_date="2017-10-11")
46. s4 = Student(name="Eric",register_date="2017-07-07")
47.  
48. study_obj1 = StudyRecord(day=1,status="Yes",stu_id=1)
49. study_obj2 = StudyRecord(day=2,status="No",stu_id=1)
50. study_obj3 = StudyRecord(day=3,status="Yes",stu_id=1)
51. study_obj4 = StudyRecord(day=1,status="Yes",stu_id=2)
52.  
53. # 一次性所有建立
54. session.add_all([s1,s2,s3,s4,study_obj1,study_obj2,study_obj3,study_obj4])
55. """
56. stu_obj = session.query(Student).filter(Student.name == "Golden").first()
57. print(stu_obj)
58. print(stu_obj.my_study_record)
59. # 提交
60. session.commit()

多外鍵關聯

建立包含多外鍵的表結構。

1. __author__ = 'Golden'
2. #!/usr/bin/env python3
3. # -*- coding:utf-8 -*-
4.  
5. from sqlalchemy.orm import relationship
6. from sqlalchemy import create_engine,Column,Integer,String,DATE,ForeignKey
7. from sqlalchemy.ext.declarative import declarative_base
8.  
9. Base = declarative_base()
10.  
11. class Customer(Base):
12.     __tablename__ = 'customer'
13.     id = Column(Integer,primary_key=True)
14.     name = Column(String(64))
15.  
16.     billing_address_id = Column(Integer,ForeignKey("address.id"))
17.     shipping_address_id = Column(Integer,ForeignKey("address.id"))
18.  
19.     billing_address = relationship("Address",foreign_keys=[billing_address_id])
20.     shipping_address = relationship("Address",foreign_keys=[shipping_address_id])
21.  
22. class Address(Base):
23.     __tablename__ = 'address'
24.     id = Column(Integer,primary_key=True)
25.     street = Column(String(64))
26.     city = Column(String(64))
27.     state = Column(String(64))
28.  
29.     def __repr__(self):
30.         return self.street
31.  
32. engine = create_engine("mysql+pymysql://root:123456@192.168.31.134/test_db",
33.                        encoding='utf-8',echo=False)
34. # 建立表結構
35. # Base.metadata.create_all(engine)

插入數據和查詢。

1. __author__ = 'Golden'
2. #!/usr/bin/env python3
3. # -*- coding:utf-8 -*-
4.  
5. import os,sys
6. path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
7. sys.path.append(path)
8. from day11 import orm_many_fk
9. from sqlalchemy.orm import sessionmaker
10.  
11. Session_class = sessionmaker(bind=orm_many_fk.engine)
12. session = Session_class()
13.  
14. # 建立數據
15. # addr1 = orm_many_fk.Address(street="zhongshanroad",city="qiaokou",state='hankou')
16. # addr2 = orm_many_fk.Address(street="dongyiroad",city="hongshan",state="wuchang")
17. # addr3 = orm_many_fk.Address(street="guangshanroad",city="gaoxin",state="guanggu")
18. #
19. # session.add_all([addr1,addr2,addr3])
20. # c1 = orm_many_fk.Customer(name="Golden",billing_address=addr1,shipping_address=addr3)
21. # c2 = orm_many_fk.Customer(name="Jack",billing_address=addr2,shipping_address=addr2)
22. #
23. # session.add_all([c1,c2])
24.  
25. # 查詢數據
26. obj = session.query(orm_many_fk.Customer).filter(orm_many_fk.Customer.name=="Golden").first()
27. print(obj.name,obj.billing_address,obj.shipping_address)
28.  
29. session.commit()

多對多關聯

建立多對多關聯表

1. __author__ = 'Golden'
2. #!/usr/bin/env python3
3. # -*- coding:utf-8 -*-
4.  
5. from sqlalchemy import Table,Column,Integer,String,DATE,ForeignKey,create_engine
6. from sqlalchemy.orm import relationship,sessionmaker
7. from sqlalchemy.ext.declarative import declarative_base
8.  
9. engine = create_engine("mysql+pymysql://root:123456@192.168.31.134/test_db",
10.                        encoding='utf-8',echo=False)
11.  
12. Base = declarative_base()
13.  
14. book_m2m_author = Table('book_m2m_author',Base.metadata,
15.                         Column('book_id',Integer,ForeignKey('books.id')),
16.                         Column('author_id',Integer,ForeignKey('authors.id')))
17.  
18. class Book(Base):
19.     __tablename__ = 'books'
20.     id = Column(Integer,primary_key=True)
21.     name = Column(String(64))
22.     pub_date = Column(DATE)
23.     authors = relationship('Author',secondary=book_m2m_author,backref='books')
24.  
25.     def __repr__(self):
26.         return self.name
27.  
28.  
29. class Author(Base):
30.     __tablename__ = 'authors'
31.     id = Column(Integer,primary_key=True)
32.     name = Column(String(32))
33.  
34.     def __repr__(self):
35.         return self.name
36.  
37. Base.metadata.create_all(engine)
38. Session_class = sessionmaker(bind=engine)
39. session = Session_class()

 

插入數據和查詢

1. __author__ = 'Golden'
2. #!/usr/bin/env python3
3. # -*- coding:utf-8 -*-
4.  
5. import os,sys
6. path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
7. sys.path.append(path)
8. from day11 import orm_m2m
9. from sqlalchemy.orm import sessionmaker
10.  
11. Session_class = sessionmaker(bind=orm_m2m.engine)
12. session = Session_class()
13.  
14. # 建立數據
15. # b1 = orm_m2m.Book(name="Python")
16. # b2 = orm_m2m.Book(name="JAVA")
17. # b3 = orm_m2m.Book(name="C++")
18. # b4 = orm_m2m.Book(name="c#")
19. #
20. # a1 = orm_m2m.Author(name="Golden")
21. # a2 = orm_m2m.Author(name="Jack")
22. # a3 = orm_m2m.Author(name="Rain")
23. #
24. # b1.authors = [a1,a2]
25. # b2.authors = [a1,a2,a3]
26. #
27. # session.add_all([b1,b2,b3,b4,a1,a2,a3])
28. # session.commit()
29.  
30. print("經過書表查詢關聯的做者".center(50,"*"))
31. book_obj = session.query(orm_m2m.Book).filter_by(name="JAVA").first()
32. print(book_obj.name,book_obj.authors)
33. print("經過做者表查詢關聯的書".center(50,"*"))
34. author_obj = session.query(orm_m2m.Author).filter_by(name="Golden").first()
35. print(author_obj.name,author_obj.books)
36.  
37. # 多對多刪除，刪除數據時不用管book_m2m_author,sqlalchemy會自動刪除對應的數據
38. # 經過書刪除做者
39. book_obj.authors.remove(author_obj)
40.  
41. # 直接刪除做者
42. author_obj2 = session.query(orm_m2m.Author).filter_by(name="Jack").first()
43. session.delete(author_obj2)
44. session.commit()

 

支持中文

sqlalchemy設置編碼字符集必定要在數據庫訪問的URL上增長charset=utf8，不然數據庫的鏈接就不是utf8的編碼格式。

1. # 支持中文
2. engine = create_engine("mysql+pymysql://root:123456@192.168.31.134/test_db?charset=utf8",echo=True)