新普金娱乐网址


作为硕士的你该不该全职?

国内参数优化软件:1stOpt – First Optimizationg数学

Python开发【第十一篇】:Python操作MySQL

  • 十二月 30, 2018
  • 数学
  • 没有评论

Sublime Text3 神速键汇总

 

  在平时行使的编译器中,sublime以它精美且强大的特点得到众多开发者的疼爱,熟稔使用它的快速键,会匡助我们落实炫酷的无鼠标操作,并且大大提高开发效用。

本篇对于Python操作MySQL紧要行使二种艺术:

 

挑选一个入选项的下一个匹配项: ⌘ + D

(Windows 系统为:ctrl+d)

把光标放在一个单词上,按下⌘+
D,将精选这些单词。从来按住⌘且按D多次,将接纳当前选中项的下一个匹配项。通过按住⌘,再按D一回,将采纳五个一律的文件。

图片 1

慎选一个中选项的装有匹配项: CTRL + ⌘ + G

**(Windows 系统为:alt+f3)**

和下面一样,但它采用文件中的所有匹配项。小心使用这些,因为它能接纳一个文书中的所有匹配项.
.

图片 2

选料与光标关联的开头和停止标签:⌘+⇧+ K

(Windows 系统为:ctrl+shift+’)

这是一个宝物。也许你指望保有属性保持不变,但只是想拔取标签。这么些快速键为您如此做,会注意到你可以在四次操作四个标签。*需要Emmet插件

图片 3

分选容器内内容:CTRL + D 

(Windows 系统为:ctrl+shift+a)

只要您把光标放在文本间再按下方面的键将接纳文本,就像⌘+
D。不过再一次按下它,将接纳父容器,再按,将选择父容器的父容器。*需要Emmet插件

图片 4

慎选括号内的情节: ⌘ + ⇧ + Space

(Windows 系统为:ctrl+shift+m

这促进选拔括号之间的上上下下。同样适用于CSS。

图片 5

迈入或下移行: CTRL + ⌘ + ↑ 或 ↓

(Windows 系统为:**ctrl+shift+**↑ 或 **)**

图片 6

复制行或选中项: ⌘ + ⇧ + D

**(Windows
系统为:**ctrl+shift+d**)即便您早就入选了文本,它会复制你的选中项。否则,把光标放在行上,会复制整行。

图片 7

追加和压缩缩进: ⌘ + [ 或 ]

**(Windows
系统为:**ctrl+**[ 或 ]**

图片 8

剪切行或选中项: ⌘ + X

**(Windows
系统为:**ctrl+x**

划分一行到你的剪切板,你可以贴补到任何地方.

图片 9

粘贴并维持缩进: ⇧ + ⌘ + V

**(Windows
系统为:**ctrl+shift+v**)这是又一个自己老是都用的连忙键。在gif中本人出示了一般性粘贴(⌘+
V)和缩进粘贴二种效用的相比较。注意缩进咋样排列。

图片 10

用竹签包裹行或选中项: CTRL + ⇧ + W

**(Windows
系统为:**alt+shift+w**

动用标签包裹一行; 先河输入你想选取的标签,你成功了.

图片 11

移除未密闭的容器元素: ⌘ + ‘

**(Windows
系统为:**ctrl+shift+;**)这会移除与你的光标相关的父标签。对消除标记很有救助。

图片 12

测算数学表明式: ⌘ + ⇧ + Y

**(Windows
系统为:**ctrl+shift+y**)我未曾想过我会经常应用这些,但是真的很好用

图片 13

递增和递减: ⇧ + OPTION + ↑ or ↓, OPTION + ↑ or ↓

**(Windows
系统为:**alt+shift+**↑ 或 ↓,**ctrl+ ** 或 **

按住  将以10的宽窄改变数字, 不按住以1为步长.
同时注意到您不需要采取数字, Sublime Text 丰盛聪明到改进本行近年来的数字.

图片 14

大写和题诗: ⌘ + K then U, ⌘ + K then L

**(Windows
系统为:**ctrl+k+u,ctrl+k+l**

图片 15

诠释选中项/行: ⌘ + /

**(Windows
系统为:**ctrl+/**

这一个在富有语言下都可用, 对行和当选项都可用.

图片 16

1、原生模块pymsql。

外加让人心花怒放的业务!使用AlignTab自定义快速键

地方的急迅键都是Sublime
Text默认的急迅键,不过你也可以添加你协调的自定义赶快键。以下示例应用 AlignTab插件使用 多少个自定义键绑定 来基于=>
,=,和:举办内容垂直对齐。因为自身工作中着重选择JavaScript和PHP,那一个绑定对于几乎我需要的每一个情状都有用,然而你可以用此外你想要的字符举办垂直对齐。

在您自己的编辑器实现下面gif的效率,只需安装 AlignTab, ,添加自定义绑定到您的自定义键绑定文件中,采用部分代码,并点击CTRL +  + . 或 ; 或 =.

图片 17

2、ORM框架SQLAchemy。

结论

假诺您看来多行代码暴发了一个改变,平常有一个用到多少个按键来兑现转移的不二法门,而不是一个个地编辑它们。通过连续使用方面快速键的组合去实施重复的或可预见的更动,你可以大大提升你编码的快慢。

此处是一个简单易行的Gif,包括精选具有匹配项,复制链接的文件,利用多行光标粘贴复制的文书,并将该文件转换为小写。

图片 18

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’)

  1. # 创设游标

  2. cursor = conn.cursor()

  3. # 执行SQL,并赶回受影响行数

  4. effect_row = cursor.execute(“select * from tables”)

  5. print(effect_row)

  6. # 取出一条数据

  7. print(cursor.fetchone())

  8. # 取出前n条数据

  9. print(“*********************************************************”)

  1. print(cursor.fetchmany(5))

  2. # 取出具有数据

  3. print(“*********************************************************”)

  1. print(cursor.fetchall())

  2. # 提交,不然无法保存新建或修改的多寡

  1. conn.commit()

  2. # 关闭游标

  3. cursor.close()

  4. # 关闭连接

  5. 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、改表法

  1. [root@lnmp ~]# mysql -uroot -p123456
  1. mysql> use test;

  2. Database changed

  3. mysql> update user set host = ‘%’ where user = ‘root’;

  1. mysql> select host,user from user;
  1. mysql> flush rivileges;

2、授权法

同意用户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专门被规划为立异这种关系。

图片 19

ORM的优点

1、隐藏了数码访问细节,”封闭”的通用数据库交互,ORM的基本。使得通用数据库的相互变得简单易行,并且完全不用考虑SQL语句。

2、ORM使协会固化数据结构变得简单易行。

ORM的缺点

1、自动化意味着映射和涉及管理,代价是牺牲性能。现在各样ORM框架都在尝试采纳各个措施(如LazyLoad、Cache)来减轻性能的熏陶,效果相比较显然。

2、面向对象的查询语言(OQL)作为一种数据库与对象之间的连通,即使隐藏了多少层面的业务抽象,但并无法完全的屏蔽掉数据库层的统筹,并且确实将大增学习成本。

3、对于复杂查询,ORM仍旧不能。固然可以实现,不过不值得。视图可以缓解大部分calculated
column、case、group、having、order by、exists,然则查询条件a and b and
not c and (d or e)不可能很好解决。

常用的ORM框架

1、Hibernate全自动需要hql语句。

2、iBatis半自动自己写sql语句,可操作性强,小巧。

3、EclipseLink一个可扩大的支撑JPA的ORM框架,提供强劲的缓存效用,缓存协理集群。

4、Apache OJB等等。

5、在Python中最知名的ORM框架是SQLAlchemy。

SQLAlchemy安装

SQLAlchemy的视角是,SQL数据库的量级和属性重要于对象集合,而目的集合的抽象又重要与表和行。

图片 20

Dialect用于和数目API举行互换,遵照安排文件的不比调用不同的数据库API,从而实现对数据库的操作。

  1. MySQL-Python

  2.     mysql+mysqldb://<user>:<password>@<host>[:<port>]/<dbname>

  1.  

  2. pymysql

  3.     mysql+pymysql://<username>:<password>@<host>/<dbname>[?<options>]

  1.  

  2. MySQL-Connector

  3.     mysql+mysqlconnector://<user>:<password>@<host>[:<port>]/<dbname>

  1.  

  2. cx_Oracle

  3.     oracle+cx_oracle://user:pass@host:port/dbname[?key=value&key=value…]

  1.  

  2. 更多详见: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,

  1.    NAME VARCHAR(32),

  2.    PASSWORD VARCHAR(64),

  3.    PRIMARY KET (ID)

  4. )

ORM实现:

  1. __author__ = ‘Golden’

  2. #!/usr/bin/env python3

  3. # -*- coding:utf-8 -*-

  4.  

  5. import sqlalchemy

  6.  

  7. from sqlalchemy import create_engine

  1. from sqlalchemy.ext.declarative import
    declarative_base

  2. from sqlalchemy import
    Column,Integer,String

  3.  

  4. # echo=True打印信息

  5. engine = create_engine(“mysql+pymysql://root:123456@192.168.31.134/test_db”,

  1.                        encoding=’utf-8′,echo=True)
  1.  

  2. # 生成orm基类

  3. Base = declarative_base()

  4.  

  5. class
    User(Base):

  6.     # 表名

  7.     __tablename__ = ‘USER’

  8.     # 定义字段ID,并安装为主键

  9.     ID =
    Column(Integer,primary_key=True)

  10.     NAME = Column(String(32))

  11.     PASSWORD = Column(String(64))

  1. # 成立表结构

  2. 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

  1. from sqlalchemy.orm import mapper
  1.  

  2. engine = create_engine(“mysql+pymysql://root:123456@192.168.31.134/test_db”,

  1.                        encoding=’utf-8′,echo=True)
  1. metadata = MetaData()

  2.  

  3. user = Table(‘USER_TABLE’,metadata,

  1.              Column(‘ID’,Integer,primary_key=True),
  1.              Column(‘NAME’,String(50)),
  1.              Column(‘FULLNAME’,String(50)),
  1.              Column(‘PASSWORD’,String(12))
  1.              )

  2.  

  3.  

  4. class
    User(object):

  5.     def
    __init__(self,name,fullname,password):

  6.         self.name = name

  7.         self.fullname = fullname

  1.         self.password = password
  1.  

  2. mapper(User,user)

  3.  

  4. # 成立表结构

  5. 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

  1. from sqlalchemy.ext.declarative import
    declarative_base

  2.  

  3. engine = create_engine(“mysql+pymysql://root:123456@192.168.31.134/test_db”,

  1.                        encoding=’utf-8′,echo=True)
  1. Base = declarative_base()

  2.  

  3. class
    User(Base):

  4.     __tablename__ = ‘USER’

  5.     ID =
    Column(Integer,primary_key=True)

  6.     NAME = Column(String(32))

  7.     PASSWORD = Column(String(64))

  1.  

  2. Base.metadata.create_all(engine)

  1. # 创设与数据库的会话session class,注意这里重返给session的是一个class,不是实例
  1. Session_class =
    sessionmaker(bind=engine)

  2. # 生成session实例

  3. Session = Session_class()

  4. # 生成要创设的数据对象

  5. user_obj = User(NAME=”Golden”,PASSWORD=”123456″)

  6. # 此时还尚无成立对象

  7. print(user_obj.NAME,user_obj.ID)

  1. # 把需要创建的数码对象添加到session
  1. Session.add(user_obj)

  2. # 此时还未曾成立对象

  3. print(user_obj.NAME,user_obj.ID)

  1. # 成立数量,统一提交

  2. 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

  1. engine = create_engine(“mysql+pymysql://root:123456@192.168.31.134/test_db”,
  1.                        encoding=’utf-8′,echo=False)
  1. Base = declarative_base()

  2. class
    User(Base):

  3.     __tablename__ = ‘USER’

  4.     ID =
    Column(Integer,primary_key=True)

  5.     NAME = Column(String(32))

  6.     PASSWORD = Column(String(64))

  1.  

  2.     def __repr__(self):

  3.         return “<NAME : %s | PASSWORD : %s>”
    %(self.NAME,self.PASSWORD)

  4.  

  5. Session_class =
    sessionmaker(bind=engine)

  6. Session = Session_class()

  7. # first 查出NAME=’高尔德(Gold)en’的率先个

  1. my_user =
    Session.query(User).filter_by(NAME=’Golden’).first()

  2. print(my_user.NAME,my_user.PASSWORD)

  1. # NAME=’Golden’

  2. data =
    Session.query(User).filter_by(NAME=’Golden’).all()

  3. print(data[0].PASSWORD)

  4. #all 查出所有

  5. data_2 =
    Session.query(User).filter_by().all()

  6. print(data_2)

  7. data_3 =
    Session.query(User).filter(User.ID == 1).all()

  8. print(data_3)

  9. data_4 =
    Session.query(User).filter_by(ID=1).all()

  10. print(data_4)

  11. # 多尺度查询

  12. data_5 =
    Session.query(User).filter(User.ID > 1).filter(User.ID <
    4).all()

  13. print(data_5)

  14. data_6 =
    Session.query(User).filter().first()

  15. print(data_6)

  16. # 修改

  17. data_6.NAME = ‘zhangsan’

  18. data_6.PASSWORD = ‘110’

  19. # 提交

  20. 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

  1.  

  2. engine = create_engine(“mysql+pymysql://root:123456@192.168.31.134/test_db”,

  1.                        encoding=’utf-8′,echo=False)
  1. Base = declarative_base()

  2.  

  3. class
    User(Base):

  4.     __tablename__ = ‘USER’

  5.     ID =
    Column(Integer,primary_key=True)

  6.     NAME = Column(String(32))

  7.     PASSWORD = Column(String(64))

  1.  

  2.     def __repr__(self):

  3.         return “<ID : %s | NAME : %s | PASSWORD :
    %s>” %(self.ID,self.NAME,self.PASSWORD)

  4.  

  5. Session_class =
    sessionmaker(bind=engine)

  6. Session = Session_class()

  7.  

  8. my_user =
    Session.query(User).filter_by(ID=1).first()

  9. my_user.NAME = ‘Mark’

  10.  

  11. fake_user =
    User(NAME=’Merry’,PASSWORD=’999999′)

  12. Session.add(fake_user)

  13. # 查看刚刚添加和修改的数据

  14. print(Session.query(User).filter(User.NAME.in_([‘Merry’,’Mark’])).all())

  1. # rollback

  2. Session.rollback()

  3. # 又一次查询

  4. 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

  1.  

  2. engine = create_engine(“mysql+pymysql://root:123456@192.168.31.134/test_db”,

  1.                        encoding=’utf-8′,echo=False)
  1.  

  2. Base = declarative_base()

  3.  

  4.  

  5. class
    User(Base):

  6.     __tablename__ = ‘USER’

  7.     ID =
    Column(Integer,primary_key=True)

  8.     NAME = Column(String(32))

  9.     PASSWORD = Column(String(64))

  1.  

  2.     def __repr__(self):

  3.         return “<ID : %s | NAME : %s | PASSWORD :
    %s>” %(self.ID,self.NAME,self.PASSWORD)

  4.  

  5. Session_class =
    sessionmaker(bind=engine)

  6. Session = Session_class()

  7. # 统计ha开头的NAME个数

  8. print(Session.query(User).filter(User.NAME.like(“ha%”)).count())

  9. # 分组

  10. 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

  1. from sqlalchemy.ext.declarative import
    declarative_base

  2.  

  3. engine = create_engine(“mysql+pymysql://root:123456@192.168.31.134/test_db”,

  1.                        encoding=’utf-8′,echo=True)
  1. Base = declarative_base()

  2.  

  3. class
    User(Base):

  4.     __tablename__ = ‘USER’

  5.     ID =
    Column(Integer,primary_key=True)

  6.     NAME = Column(String(32))

  7.     PASSWORD = Column(String(64))

  1.  

  2.     def __repr__(self):

  3.         return “<ID :%s | NAME : %s | PASSWORD :
    %s>” %(self.ID,self.NAME,self.PASSWORD)

  4.  

  5.  

  6. class
    Student(Base):

  7.     __tablename__ = ‘STUDENT’

  1.     ID =
    Column(Integer,primary_key=True)

  2.     NAME =
    Column(String(32),nullable=False)

  3.     REGISTER_DATE =
    Column(DATE,nullable=False)

  4.     GENDER =
    Column(String(32),nullable=False)

  5.  

  6.     def __repr__(self):

  7.         return “<NAME : %s | PASSWORD : %s>”
    %(self.NAME,self.REGISTER_DATE)

  8.  

  9. Base.metadata.create_all(engine)

  1. Session_class =
    sessionmaker(bind=engine)

  2. Session = Session_class()

  3.  

  4. # 外联

  5. print(Session.query(User,Student).filter(User.ID
    == Student.ID).all())

  6. # 六个表必须有外键关联才能使用 Can’t
    find any foreign key relationships between ‘A’ and ‘B’

  7. print(Session.query(User).join(Student).all())

  1. print(Session.query(User).join(Student,isouter=True).all())
  1. 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”,

  1.                        encoding=’utf-8′,echo=False)
  1. Base = declarative_base()

  2.  

  3. class
    Student(Base):

  4.     __tablename__ = ‘student’

  1.     id =
    Column(Integer,primary_key=True)

  2.     name =
    Column(String(32),nullable=False)

  3.     register_date =
    Column(DATE,nullable=False)

  4.  

  5.     def __repr__(self):

  6.         return “<name : %s | register_date :
    %s>”%(self.name,self.register_date)

  7.  

  8.  

  9. class
    StudyRecord(Base):

  10.     __tablename__ = “study_record”

  11.     id =
    Column(Integer,primary_key=True)

  12.     day =
    Column(Integer,nullable=False)

  13.     status =
    Column(String(32),nullable=False)

  14.     # 创立外键

  15.     stu_id =
    Column(Integer,ForeignKey(“student.id”))

  16.     #

  17.     student = relationship(“Student”,backref=”my_study_record”)

  18.  

  19.     def __repr__(self):

  20.        return “<%s day :%s | status :
    %s>”%(self.student.name,self.day,self.status)

  21. # 创立表结构

  22. Base.metadata.create_all(engine)

  1. # 创设与数据库的会话session

  2. Session_class =
    sessionmaker(bind=engine)

  3. # 生成session实例

  4. session = Session_class()

  5.  

  6. “””添加数据

  7. s1 = Student(name=”Golden”,register_date=”2017-12-24″)

  8. s2 = Student(name=”Jack”,register_date=”2017-11-13″)

  9. s3 = Student(name=”Rain”,register_date=”2017-10-11″)

  10. s4 = Student(name=”Eric”,register_date=”2017-07-07″)

  11.  

  12. study_obj1 =
    StudyRecord(day=1,status=”Yes”,stu_id=1)

  13. study_obj2 =
    StudyRecord(day=2,status=”No”,stu_id=1)

  14. study_obj3 =
    StudyRecord(day=3,status=”Yes”,stu_id=1)

  15. study_obj4 =
    StudyRecord(day=1,status=”Yes”,stu_id=2)

  16.  

  17. # 三回性全体创设

  18. session.add_all([s1,s2,s3,s4,study_obj1,study_obj2,study_obj3,study_obj4])

  1. “””

  2. stu_obj =
    session.query(Student).filter(Student.name == “Golden”).first()

  3. print(stu_obj)

  4. print(stu_obj.my_study_record)

  1. # 提交

  2. session.commit()

多外键关联

创办包含多外键的表结构。

  1. __author__ = ‘Golden’

  2. #!/usr/bin/env python3

  3. # -*- coding:utf-8 -*-

  4.  

  5. from sqlalchemy.orm import relationship

  1. from sqlalchemy import
    create_engine,Column,Integer,String,DATE,ForeignKey

  2. from sqlalchemy.ext.declarative import
    declarative_base

  3.  

  4. Base = declarative_base()

  5.  

  6. class
    Customer(Base):

  7.     __tablename__ = ‘customer’

  1.     id =
    Column(Integer,primary_key=True)

  2.     name = Column(String(64))

  3.  

  4.     billing_address_id =
    Column(Integer,ForeignKey(“address.id”))

  5.     shipping_address_id =
    Column(Integer,ForeignKey(“address.id”))

  6.  

  7.     billing_address =
    relationship(“Address”,foreign_keys=[billing_address_id])

  1.     shipping_address =
    relationship(“Address”,foreign_keys=[shipping_address_id])
  1.  

  2. class
    Address(Base):

  3.     __tablename__ = ‘address’

  1.     id =
    Column(Integer,primary_key=True)

  2.     street = Column(String(64))

  3.     city = Column(String(64))

  4.     state = Column(String(64))

  5.  

  6.     def __repr__(self):

  7.         return self.street

  8.  

  9. engine = create_engine(“mysql+pymysql://root:123456@192.168.31.134/test_db”,

  1.                        encoding=’utf-8′,echo=False)
  1. # 创立表结构

  2. # 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__)))

  1. sys.path.append(path)

  2. from day11 import orm_many_fk

  3. from sqlalchemy.orm import sessionmaker

  1.  

  2. Session_class =
    sessionmaker(bind=orm_many_fk.engine)

  3. session = Session_class()

  4.  

  5. # 创制数据

  6. # addr1 =
    orm_many_fk.Address(street=”zhongshanroad”,city=”qiaokou”,state=’hankou’)

  7. # addr2 =
    orm_many_fk.Address(street=”dongyiroad”,city=”hongshan”,state=”wuchang”)

  8. # addr3 =
    orm_many_fk.Address(street=”guangshanroad”,city=”gaoxin”,state=”guanggu”)

  9. #

  10. #
    session.add_all([addr1,addr2,addr3])

  11. # c1 =
    orm_many_fk.Customer(name=”Golden”,billing_address=addr1,shipping_address=addr3)

  1. # c2 =
    orm_many_fk.Customer(name=”Jack”,billing_address=addr2,shipping_address=addr2)
  1. #

  2. # session.add_all([c1,c2])

  3.  

  4. # 查询数据

  5. obj =
    session.query(orm_many_fk.Customer).filter(orm_many_fk.Customer.name==”Golden”).first()

  6. print(obj.name,obj.billing_address,obj.shipping_address)

  1.  

  2. 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”,

  1.                        encoding=’utf-8′,echo=False)
  1.  

  2. Base = declarative_base()

  3.  

  4. book_m2m_author =
    Table(‘book_m2m_author’,Base.metadata,

  5.                         Column(‘book_id’,Integer,ForeignKey(‘books.id’)),

  1.                         Column(‘author_id’,Integer,ForeignKey(‘authors.id’)))
  1.  

  2. class
    Book(Base):

  3.     __tablename__ = ‘books’

  4.     id =
    Column(Integer,primary_key=True)

  5.     name = Column(String(64))

  6.     pub_date = Column(DATE)

  7.     authors =
    relationship(‘Author’,secondary=book_m2m_author,backref=’books’)

  1.  

  2.     def __repr__(self):

  3.         return self.name

  4.  

  5.  

  6. class
    Author(Base):

  7.     __tablename__ = ‘authors’

  1.     id =
    Column(Integer,primary_key=True)

  2.     name = Column(String(32))

  3.  

  4.     def __repr__(self):

  5.         return self.name

  6.  

  7. Base.metadata.create_all(engine)

  1. Session_class =
    sessionmaker(bind=engine)

  2. 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__)))

  1. sys.path.append(path)

  2. from day11 import orm_m2m

  3. from sqlalchemy.orm import sessionmaker

  1.  

  2. Session_class =
    sessionmaker(bind=orm_m2m.engine)

  3. session = Session_class()

  4.  

  5. # 创立数据

  6. # b1 = orm_m2m.Book(name=”Python”)

  7. # b2 = orm_m2m.Book(name=”JAVA”)

  8. # b3 = orm_m2m.Book(name=”C++”)

  9. # b4 = orm_m2m.Book(name=”c#”)

  10. #

  11. # a1 = orm_m2m.Author(name=”Golden”)

  12. # a2 = orm_m2m.Author(name=”Jack”)

  13. # a3 = orm_m2m.Author(name=”Rain”)

  14. #

  15. # b1.authors = [a1,a2]

  16. # b2.authors = [a1,a2,a3]

  17. #

  18. #
    session.add_all([b1,b2,b3,b4,a1,a2,a3])

  19. # session.commit()

  20.  

  21. print(“通过书表查询关联的撰稿人”.center(50,”*”))

  22. book_obj =
    session.query(orm_m2m.Book).filter_by(name=”JAVA”).first()

  23. print(book_obj.name,book_obj.authors)

  1. print(“通过作者表查询关联的书”.center(50,”*”))

  2. author_obj =
    session.query(orm_m2m.Author).filter_by(name=”Golden”).first()

  3. print(author_obj.name,author_obj.books)

  1.  

  2. #
    多对多删除,删除数据时毫无管book_m2m_author,sqlalchemy会自动删除相应的数量

  1. # 通过书删除作者

  2. book_obj.authors.remove(author_obj)

  1.  

  2. # 直接删除作者

  3. author_obj2 =
    session.query(orm_m2m.Author).filter_by(name=”Jack”).first()

  4. session.delete(author_obj2)

  5. 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)

相关文章

No Comments, Be The First!
近期评论
    分类目录
    功能
    网站地图xml地图