新普金娱乐网址


当大学生之若该不拖欠兼职?

数学可怜的1%—-知乎繁荣之私下

Sublime Text3 快捷键汇总

  • 八月 30, 2018
  • 数学
  • 没有评论

外加令人高兴的事体!使用AlignTab自定义快捷键

上面的快捷键都是Sublime
Text默认的快捷键,但是若呢得以填补加你协调的自定义快捷键。以下示例应用 AlignTab插件使用 老三单自定义键绑定 来基于=>
,=,和:进行内容垂直对共同。因为我工作备受最主要采取JavaScript和PHP,这些绑定对于几乎我需要之各一个气象都有因此,但是若可以就此别样你想如果的字符进行垂直对同步。

每当您自己之编辑器实现下面gif的功效,只待安装 AlignTab, ,添加打定义绑定到您的起自然义键绑定文件遇,选择部分代码,并点击CTRL +  + . 或 ; 或 =.

图片 1

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)不能够杀好解决。

结论

如若你望多行代码有了一个转移,通常有一个行使几单按键来贯彻转之方,而未是一个个地修它们。通过连接用方面快捷键的做去执行还的抑只是预见的改变,你得大大提高你编码的进度。

此处是一个略的Gif,包括精选具有匹配项,复制链接的文书,利用基本上行光标粘贴复制的公文,并以欠文件转换为稍写。

图片 2

回滚

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

 

摘一个当选项之下一个匹项: ⌘ + D

(Windows 系统为:ctrl+d)

将光标放在一个单词上,按下⌘+
D,将选这个单词。一直随停⌘且按D多次,将挑选时当选项的下一个配合配项。通过以住⌘,再依D三不良,将选取三只同的文本。

图片 3

选择一个当选项的有匹配项: CTRL + ⌘ + G

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

与方面一样,但它们选择文件被的享有匹配项。小心用此,因为其会挑一个文书中之备匹配项.
.

图片 4

选择与光标关联的上马与了标签:⌘+⇧+ K

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

当时是一个宝物。也许你指望所有属性保持无换,但偏偏是想念选标签。这个快捷键为你这样做,会小心到您得在相同涂鸦操作多只标签。*需要Emmet插件

图片 5

选容器内内容:CTRL + D 

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

万一您将光标放在文本间再依下端的键将选择文本,就如⌘+
D。但是再以下它们,将精选父容器,再按照,将甄选父容器的父容器。*需要Emmet插件

图片 6

选充满号内之情节: ⌘ + ⇧ + Space

(Windows 系统为:ctrl+shift+m

即促进选择括号里的周。同样适用于CSS。

图片 7

高达转换或下移行: CTRL + ⌘ + ↑ 或 ↓

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

图片 8

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

**(Windows
系统为:**ctrl+shift+d**)如果您已入选了文件,它见面复制你的选项着宗。否则,把光标放在行上,会复制整行。

图片 9

增加和减少缩进: ⌘ + [ 或 ]

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

图片 10

推切行或选中项: ⌘ + X

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

分一行到您的推切板,你可贴补到其它地方.

图片 11

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

**(Windows
系统为:**ctrl+shift+v**)这是以一个自家每次都为此底快捷键。在gif中自己显得了寻常胶(⌘+
V)和缩进粘贴两栽意义的对比。注意缩进如何列。

图片 12

因而竹签包裹行要选中项: CTRL + ⇧ + W

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

动标签包裹一行; 开始输入而想采取的价签,你成功了.

图片 13

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

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

图片 14

计算数学表达式: ⌘ + ⇧ + Y

**(Windows
系统为:**ctrl+shift+y**)我没想了我会经常下此,但是诚充分好用

图片 15

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

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

按住  将坐10的涨幅改变数字, 不以停以1为步长.
同时注意到你莫待选择数字, Sublime Text 足够聪明到履新本行最近的数字.

图片 16

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

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

图片 17

注选中项/行: ⌘ + /

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

是于具备语言下还可用, 对行和当选项都可用.

图片 18

大抵针对几近干

开创多对大多关联表

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

 

Sublime Text3 快捷键汇总

 

  在普通使用的编译器中,sublime以其精美且强大的风味得到众多开发者的慈,熟练应用它的快捷键,会协助我们贯彻炫酷的甭管鼠标操作,并且大大提高开发效率。

统计以及分组

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

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

ORM介绍

靶关联映射(Object Relational
Mapping,简称ORM),是一致种次技术,用于落实面向对象编程语言里不同类别系统的数据里的转换。从功能及说,它实际上是创建了一个而当编程语言里采取的——”虚拟对象数据库”。

面向对象是打软件工程核心尺度(如耦合、聚合、封装)的底蕴及进步兴起的,而关系数据库则是自数学理论发展要来之,两模仿理论有鲜明的界别。为了解决这个不般配的气象,对象关系映射技术出现。

靶关联映射(Object Relational
Mapping)提供了概念性的、易于理解的模型化数据的法。ORM方法论基于三单中心标准。简单,以无比基本的形式建模数据。传达性,数据库结构给任何人都能够了解的言语文档化。精确性,基于数据模型创建是规范的布局。典型地,建模者通过搜集来自那些熟悉应用程序但未在行数据建模者开发信息模型。建模者必须能用无技术公司专家可以了解的术语在概念层次上与数据结构进行报道。建模者也非得能坐简单的单元分析信息,对样本数量进行拍卖。ORM专门叫设计吧改善这种联系。

图片 19

连表

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

行使操作

执行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”)])

查询、修改

  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=’Golden’的第一独

  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、原生模块pymsql。

常用的ORM框架

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

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

3、EclipseLink一个但扩大的支持JPA的ORM框架,提供强劲的复苏存功能,缓存支持集群。

4、Apache OJB等等。

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

SQLAlchemy ORM

windows下载安装

  1. pip3 install pymysql

pymsql

pymsql是Python中操作MySQL的模块,其行使方式与MySQLdb几乎相同。

支持中文

sqlalchemy设置编码字符集一定要是于数据库访问的URL上长charset=utf8,否则数据库的连就未是utf8的编码格式。

  1. # 支持中文

  2. engine = create_engine(“mysql+pymysql://root:123456@192.168.31.134/test_db?charset=utf8”,echo=True)

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

ORM的优点

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

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

本篇对于Python操作MySQL主要以有限种植艺术:

差不多外键关联

创立包含多外键的阐发结构。

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

2、ORM框架SQLAchemy。

实现两独说明的外键关联

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

相关文章

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