Python SQLalchemy的学习与使用

最新推荐文章于 2024-05-31 14:08:21 发布
最新推荐文章于 2024-05-31 14:08:21 发布
阅读量363 收藏 1
点赞数
分类专栏： 数据库
原文链接：https://www.cnblogs.com/wj-1314/p/10627828.html
版权

SQLAlchemy是python中最著名的ORM（Object Relationship Mapping）框架了。

前言：什么是ORM？

　　ORM操作是所有完整软件中后端处理最重要的一部分，主要完成了后端程序和数据库之间的数据同步和持久化的操作。

　　数据库表示一个二维表，包含多行多列。把一个表的内容用python的数据结构表示出来的话，可以用一个list表示多行，list的每一个元素是tuple，表示一行记录，比如，包含id和name的user表：

1

2

3

4

5

[

    ('1', 'james'),

    ('2', 'durant'),

    ('3', 'curry')

]

　　Python的DB-API返回的数据结构就是像上面这样表示的。但是用tuple表示一行很难看出表的结构，如果把一个tuple用class实例来表示，就可以更容易的看出表的结构来：

1

2

3

4

5

6

7

8

9

10

class User(object):

    def __init__(self, id, name):

        self.id = id

        self.name = name

 

[

    User('1', 'james'),

    User('2', 'durant'),

    User('3', 'curry')

]

　　这就是传说中的ORM技术：Object-Relational Mapping ，把关系数据库的表结构映射到对象上。但是由谁来做这个转化呢？所以ORM框架应运而生。目前来说也是描述程序中对象和数据库中数据记录之间的映射关系的统称，是一种进行程序和数据库之间数据持久化的一种编程思想。

　　ORM思想的核心是隐藏了数据访问细节，提供了通用的数据库交互，并且完全不用考虑SQL语句，从而快速开发。

　　一句话解释ORM就是：一种可以把model中的模型和数据库中的一条数据相互转换的工具。

　　举个例子：

 

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

#sql中的表                                                     

 

 #创建表:

     CREATE TABLE employee(                                    

                id INT PRIMARY KEY auto_increment ,                   

                name VARCHAR (20),                                     

                gender BIT default 1,                                 

                birthday DATA ,                                        

                department VARCHAR (20),                               

                salary DECIMAL (8,2) unsigned,                         

              );

 

  #sql中的表纪录                                                 

  #添加一条表纪录:                                                         

      INSERT employee (name,gender,birthday,salary,department)           

             VALUES   ("alex",1,"1985-12-12",8000,"保洁部");              

  #查询一条表纪录:                                                          

      SELECT * FROM employee WHERE age=24;                              

  #更新一条表纪录:                                                          

      UPDATE employee SET birthday="1989-10-24" WHERE id=1;             

  #删除一条表纪录:                                                         

      DELETE FROM employee WHERE name="alex"                            

#python的类

class Employee(models.Model):

     id=models.AutoField(primary_key=True)

     name=models.CharField(max_length=32)

     gender=models.BooleanField()

     birthday=models.DateField()

     department=models.CharField(max_length=32)

     salary=models.DecimalField(max_digits=8,decimal_places=2)

 #python的类对象

      #添加一条表纪录:

          emp=Employee(name="alex",gender=True,birthday="1985-12-12",epartment="保洁部")

          emp.save()

      #查询一条表纪录:

          Employee.objects.filter(age=24)

      #更新一条表纪录:

          Employee.objects.filter(id=1).update(birthday="1989-10-24")

      #删除一条表纪录:

          Employee.objects.filter(name="alex").delete()

　

　　在Python中，最有名的ORM框架是SQLAlchemy。我们来看看其语法。

一，初始化数据库连接

　　SQLAlchemy本身无法操作数据库，其必须通过pymysql等第三方插件。上图中Dialect用于和数据API进行交流，根据配置文件的不同调用不同的数据库API，从而实现对数据库的操作。

　　使用sqlalchemy进行数据库操作，首先我们需要建立一个指定数据库的链接引擎对象，而建立引擎对象的方式被封装在了sqlalchemy.create_engine函数中，通过指定的数据库连接信息即可创建。

　　create_engine()用来初始化数据库连接。SQLAlchemy用一个字符串表示连接信息：

1

'数据库类型+数据库驱动名称://用户名:口令@机器地址:端口号/数据库名'

　　你只需要根据需要替换掉用户名，口令等信息即可。举个例子：

1

2

3

# 初始化数据库链接

 

engine = create_engine('mysql+mysqlconnector://root:123456@localhost:3306/test')

　　我使用了mysql数据库，数据库连接框架用的是mysqlconnector，用户名为root，密码是123456，端口号是localhost（127.0.0.1），端口号是3306（mysql服务器默认端口号），test是数据库的名字。

二，创建user模型及其数据库建表操作

2.1，安装SQLAlchemy

　　如果没有安装SQLAlchemy请先安装，这个不是python自带的。

1

pip  install sqlalchemy

2.2，数据库建表

　　在test数据库中，创建user表，SQL如下：

1

create table user (id varchar(20) primary key, name varchar(20))

　　创建表，表名为user，表中有两个字段。一个是id，varchar类型，最多支持20个字符，设置为主键，另一个是name，varchar类型，最多支持20个字符。

（PS：主键时唯一的，当你重复插入时会报错，并终止插入操作）。

　　插入数据，如下：

1

2

3

4

5

insert into user(id,name) values('1001','james');

 

insert into user(id,name) values('1002','durant');

 

insert into user(id,name) values('1003','curry');

　　

　　更改表名

1

alter table origin_name rename to new_name;

　　

2.3，创建user模型

　　在model.py中创建 一个User类，用来和User表中的字段进行关联。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

# load module

from sqlalchemy import Column, String, create_engine

from sqlalchemy.orm import sessionmaker

from sqlalchemy.ext.declarative import declarative_base

 

# 创建对象的基类

Base = declarative_base()

 

# 定义User对象

class User(Base):

    # 表的名字

    __tablename__ = 'user'

 

    # 表的结构

    id = Column(String(20), primary_key=True)

    name = Column(String(20))

　　这段代码的意思，User类的字段名和表中完全一致，而且字段的属性也一样，以id字段为例，表中id的属性是Varchar(20)，primary key，模型中String(20)，primary_key=True。我们可以清晰的看到varchar在程序中对应String，primary_key对应程序中的primary_key属性，而且是一个bool类型。

（PS：这里的String是sqlAlchemy中的一个类，这样类似的类我们还会用到Column）

2.4，Column类的学习

　　构建函数为

1

Column.__init__(self, name, type_, *args, **kwargs)

　　name  列名

　　type_ 类型 ，更多类型SQLAlchemy.types

　　下面是*args参数定义

  • Constraint（约束）
  • ForeignKey（外键）
  • ColumnDefault（默认）
  • Sequenceobjects（序列）定义

　　下面是**kwargs参数定义

  • primary_key 如果为True，则是主键
  • nullable 是否可谓Null，默认是True
  • default 默认值，默认是None
  • index 是否是索引，默认是True
  • unique 是否唯一键，默认是False
  • onupdate 指定一个更新时候的值，这个操作是定义在SQLAlchemy中，不是在数据库里的，当更新一条数据时设置，大部分用于update Time这类字段
  • autoincrement 设置为整型自动增长，只有没有默认值，并且是Integer类型，默认是True
  • quote 如果列名是关键字，则强制转义，默认False

　　

三，CRUD（Create Read Update Delete，增查改删）

　　在SQLAlchemy中，增删改查操作是通过一个session对象（DBSession是由sessionmaker创建的）来完成的。

3.1，初始化DBSession，连接会话

　　我们的程序中的对象要使用sqlalchemy的管理，实现对象的ORM操作，就需要按照框架指定的方式进行类型的创建操作，SQLAlchemy封装了基础类的声明操作和字段属性的定义限制方式，开发人员要做的事情就是引入需要的模块并在创建对象的时候使用他们即可。

　　基础类封装在sqlalchemy.ext.declarative_base模块中，字段属性的定义封装在SQLAlchemy模块中，通过sqlalchemy.Column定义属性，通过封装的Integer，String，Float等定义属性的限制。

　　首先我们需要创建DBSession，在此基础上就可以进行增删改查操作了。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

# load module

from sqlalchemy import Column, String, create_engine

from sqlalchemy.orm import sessionmaker

from sqlalchemy.ext.declarative import declarative_base

 

# 创建对象的基类

Base = declarative_base()

 

# 定义User对象

class User(Base):

    # 表的名字

    __tablename__ = 'user'

 

    # 表的结构

    id = Column(String(20), primary_key=True)

    name = Column(String(20))

 

# 初始化数据库连接

engine = create_engine('mysql+mysqlconnector://root:password@localhost:3306/test')

 

# 创建DBSession类型

DBSession = sessionmaker(bind=engine)

　　上面的代码完成SQLAlchemy的初始化和具体每个表的class定义。如果有多个表，就继续定义其他class。

　　注意：如果在创建会话的时候还没有指定数据库引擎，可以通过如下的方式完成会话：

1

2

3

4

Session = sessionmaker()

..

Session.configure(bind=engine)

session = Session()

　　完整代码如下：

1

2

3

4

5

6

7

8

9

10

11

12

def MySQLConnect(connection_info:str, id, status):

    engine = create_engine(connection_info)

    DBSession = sessionmaker(bind=engine)

    session = DBSession()

    traininfo = session.query(TrainInfo).filter(TrainInfo.id == id).one()

    if traininfo is None:

        info = TrainInfo(id=id, status=status)

        session.add(info)

    else:

        traininfo.status = '1'

    session.commit()

    session.close()

　　

3.2，添加操作

　　程序中存在一个对象Object数据，通过ORM核心模块进行增加的函数定义将对象保存在数据库的操作过程，就是增加操作。比如注册操作中，通过用户输入的账号密码等信息创建了一个独立的对象，通过add()函数将对象增加保存到数据库中，数据库中就存在用户这个对象数据了。

　　下面，我们看看如何向数据库表中添加一行记录。

　　由于有ORM，我们向数据库表中添加一行记录，可以视为添加一个User对象：

1

2

3

4

5

6

7

8

9

10

# 创建session对象

session = DBSession()

# 创建新的User对象

new_user = User(id='1001', name='james')

# 添加到session

session.add(new_user)

# 提交即保存到数据库

session.commit()

# 关闭session

session.close()

　　可见，关键是获取session，然后把对象添加到session，最后提交并关闭。DBSession对象可视为当前数据库连接。

3.3，查询操作

　　查询时通过Session的query()方法创建一个查询对象，这个函数的参数可以是任何类或者类的描述的集合。查询出来的数据是一个对象，直接通过对象的属性调用。

　　如何从数据库表中查询数据呢？有了ORM，查询出来的可以不再是tuple，而是User对象。SQLAlchemy提供的查询接口如下：

1

2

3

4

5

6

7

8

9

# 创建session

session = DBSession()

# 创建Query查询，filter是where条件，最后调用one()返回唯一行，如果调用all()则返回所有行

user = session.query(User).filter(User.id=='1001').one()

# 打印类型和对象的name属性

print('type:', type(user))

print('name:', user.name)

# 关闭Session:

session.close()

　　可见，ORM就是把数据库表的行与相应的对象建立关联，互相转换。

　　由于关系数据库的多个表还可以用外键实现一对多，多对多等关联，相应的，ORM框架也可以提供两个对象之间的一对多，多对多等功能。

　　例如，如果一个User拥有多个Book，就可以定义一对多关系如下：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

class User(Base):

    __tablename__ = 'user'

 

    id = Column(String(20), primary_key=True)

    name = Column(String(20))

    # 一对多:

    books = relationship('Book')

 

class Book(Base):

    __tablename__ = 'book'

 

    id = Column(String(20), primary_key=True)

    name = Column(String(20))

    # “多”的一方的book表是通过外键关联到user表的:

    user_id = Column(String(20), ForeignKey('user.id'))

　　当我们查询一个User对象时，该对象的books属性将返回一个包含若干个Book对象的list .

 3.4，更新操作

　　程序中存在的一个对象Object数据，有自己的id编号（可以使程序中自行赋值定义，更多的操作是从数据库中查询出来存在的一个对象），通过ORM核心模块进行修改函数的定义将对象改变的数据更新到数据库中已经存在的记录中的过程，就是更新操作。比如用户更改登录密码操作时，根据程序中查询得到的一个用户{id编号，账号，密码}，在程序中通过改变其密码属性数据，然后通过update()函数将改变的数据更新保存到数据库中，数据库原来的数据就发生了新的改变。

　　更新操作要多一步，就是要先根据筛选条件拿到要更改的对象，然后给对象赋值，再次提交（commit）即可。

1

2

3

4

5

6

7

8

9

10

# 创建session对象

session = DBSession()

# 查找需要更新的字段id

user_result = session.query(User).filter_by(id='1001').first()

# 更新字段名称

user_result.name = 'durant'

# 提交即保存到数据库

session.commit()

# 关闭session

session.close()

　　

3.5，删除操作

　　程序中存在的一个对象或者已知的id编号，通过主键编号或者对象的任意属性进行数据库中数据记录的删除的操作过程称为删除操作。如管理员删除某个会员账号的操作，通过获取要删除会员的账号，然后通过delete()函数将要删除的会员信息告知数据库执行删除操作，数据库中的某条存在的数据记录就被删除掉了。

1

2

3

4

5

6

7

8

9

10

# 创建session对象

session = DBSession()

# 查找需要删除的字段id

user_result = session.query(User).filter_by(id='1001').first()

# 删除字段内容

session.delete(user_result)

# 提交即保存到数据库

session.commit()

# 关闭session

session.close()

　　

3.6，代码整合

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

# 导入依赖

from sqlalchemy import Column, String, create_engine

from sqlalchemy.orm import sessionmaker

from sqlalchemy.ext.declarative import declarative_base

 

# 创建对象的基类

Base = declarative_base()

 

# 定义User对象

class User(Base):

    # 表的名字

    __tablename__ = 'user'

 

    # 表的结构

    id = Column(String(20), primary_key=True)

    name = Column(String(20))

 

 

# 初始化数据库链接

engine = create_engine('mysql+mysqlconnector://root:123456@localhost:3306/test')

 

# 创建DBSession类型

DBSession = sessionmaker(bind=engine)

 

 

# 添加

# 创建Session对象

session = DBSession()

# 创建User对象

new_user = User(id='1001', name='james')

# 添加到session

session.add(new_user)

# 提交

session.commit()

# 关闭session

session.close()

 

 

# 查询

# 创建session

session = DBSession()

# 利用session创建查询，query(对象类).filter(条件).one()/all()

user = session.query(User).filter(User.id=='1001').one()

print('type:{0}'.format(type(user)))

print('name:{0}'.format(user.name))

# 关闭session

session.close()

 

 

# 更新

session = DBSession()

user_result = session.query(User).filter_by(id='1001').first()

user_result.name = "durant"

session.commit()

session.close()

 

 

# 删除

session = DBSession()

user_willdel = session.query(User).filter_by(id='1001').first()

session.delete(user_willdel)

session.commit()

session.close()

　　

四，查询对象Query

　　Session是sqlalchemy和数据库交互的桥梁，Session提供了一个Query对象实现数据库中数据的查询操作。

4.1，常规查询query

　　直接指定类型进行查询

1

2

3

user_list = session.query(User)

for user in user_list:

    print(user.name)

　　

4.2，指定排序查询

　　通过类型的属性指定排序方式

1

2

3

4

5

6

7

8

# 默认顺序

user_list = session.query(User).order_by(User.id)

 

# 指定倒序

user_list = session.query(User).order_by(-User.id)

 

# 多个字段

user_list = session.query(User).order_by(-User.id, User.name)

　　

4.3，指定列查询

　　指定查询数据对象的属性，查询目标数据

1

2

3

user_list = session.query(User, User.name).all()

for u in user_list:

    print(u.User, u.name)

　　

4.4，指定列属性别名

　　对于名词较长的字段属性，可以指定名称在使用时简化操作

1

2

3

4

user_list = session.query(User.name.label('n')).all()

 

for user in user_list:

    print(user.n)

　　

4.5，指定类型别名

　　对于类型名称较长的情况，同样可以指定别名进行处理

1

2

3

4

5

6

7

from sqlalchemy.orm import aliased

 

user_alias = aliased(User, name=’u_alias’)

 

user_list = session.query(u_alias, u_alias.name).all()

for u in user_list:

    print(u.u_alias, u.name)

　　

4.6，切片查询

　　对于经常用于分页操作单额切片查询，在使用过程中直接使用python内置的切片即可。

1

user_list = session.query(User).all()[1:3]

　　

五，条件筛选filter

　　上面主要对数据查询对象query有一个比较直观的感受和操作，在实际使用过程中经常用到条件查询，主要通过filter 和 filter_by 进行操作，下面重点学习最为频繁的filter条件筛选函数。　　

5.1，等值条件——equals / not equals

1

2

3

4

5

# equals    相等判断

session.query(User).filter(User.id == 1)

 

# not equals   不等判断

session.query(User).filter(User.name != ‘james’)

　　

5.2，模糊条件——like

1

session.query(User).filter(User.name.like(‘%james%’))

　　

5.3，范围条件——in / not in

1

2

3

4

5

6

7

8

9

10

# IN

session.query(User).filter(User.id.in_([1,2,3,4]))

 

session.query(User).filter(User.name.in_([

     session.query(User.name).filter(User.id.in_[1,2,3,4])

]))

 

 

# NOT IN

session.query(User).filter(~User.id.in_([1,2,3]))

　　

5.4，空值条件——is null / is not null

1

2

3

4

5

6

7

# IS NULL

session.query(User).filter(User.name == None)

session.query(User).filter(User.name.is_(None)) # pep8

 

# IS NOT NULL

session.query(User).filter(User.name != None)

session.query(User).filter(User.name.isnot(None)) # pep8

　　

5.5，并且条件——and

1

2

3

4

5

from sqlalchemy import and_

 

session.query(User).filter(User.name=’james’).filter(User.age=12)

session.query(User).filter(User.name=’james, User.age=12)

session.query(User).filter(and_(User.name=’james’, User.age=12))

　　

5.6，或者条件——or

1

2

from sqlalchemy import or_

session.query(User).filter(or_(User.name=’james’, User.name=’durant’))

　　

5.7，SQL语句查询

　　某些特殊的情况下，我们也可能在自己的程序中直接使用sql语句进行操作。

1

2

3

4

5

from sqlalchemy import text

 

session.query(User).from_statement(

text(‘select * from users where name=:name and age=:age’))

.params(name=’james’, age=32).all()

　　

5.8，filter() 和 filter_by()的区别

　　首先看一个例子：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

# load module

from sqlalchemy import Column, String, create_engine

from sqlalchemy.orm import sessionmaker

from sqlalchemy.ext.declarative import declarative_base

from sqlalchemy import create_engine

import warnings

 

warnings.filterwarnings('ignore')

 

# 创建对象的基类

Base = declarative_base()

 

# 定义User对象

class User(Base):

    # 表的名字

    __tablename__ = 'user'

 

    # 表的结构

    id = Column(String(20), primary_key=True)

    name = Column(String(20))

 

engine = create_engine('mysql+pymysql://root:wangjian@localhost:3306/sqlalchemy')

 

DBSession = sessionmaker(bind=engine)

session = DBSession()

 

res1 = session.query(User).filter(User.id == 1001)

res2 = session.query(User).filter_by(id = 1001)

 

for i in res1:

    print(i.id, i.name)

 

for i in res2:

    print(i.id, i.name)

　　结果如下：

1

2

1001 james

1001 james

　　所以，从例子可以看出，filter可以像写SQL的where条件那样写 < , > 等条件，但引用列名时，需要通过类名，属性名的方式。 filter_by可以使用python的正常参数传递条件，指定列名时，不需要额外指定类名，参数名对应类中的属性名，不能用 < ,  > 等条件。

　　filter不支持组合查询，只能连续调用filter变相实现，filter_by的参数是 **kwargs，直接支持组合查询。

1

2

3

4

5

6

7

8

filter_res = {'id':1002, 'name':'durant'}

res = session.query(User).filter_by(**filter_res)

for i in res:

    print(i.id, i.name)

 

 

结果：

1002 durant

　　

六，查询结果

6.1，all()函数返回查询列表

　　返回一个列表，可以通过遍历列表获取每个对象。

1

session.query(User).all()

　　

6.2，filter()函数返回单项数据的列表生成器

1

session.query(User).filter(..)

　　

6.3，one() / one_or_none() / scalar() 返回单独的一个数据对象

　　one()返回且仅返回一个查询结果，当结果数量不足或者多余一个时会报错。

1

session.query(User).filter(..).one()/one_or_none()/scalar()

　　

6.4，first() 返回一个单项结果

　　返回至多一个结果，而且以单项形式，而不是只有一个元素的tuple形式返回。

1

session.query(User).filter(User.id > 1001).first()

　　

七，遇到的问题及其解决方法

7.1  sqlalchemy查询中，如果没有符合条件的结果，会返回一个空的对象，如何判断这个对象是空的？

1

2

3

4

5

6

7

users = session.query(user).filter(user.id == '234).all()#users为object列表

if(len(user) == 0):

    print "数据库中没有id为234的用户‘’

else:

    print "数据库中包含id为234的用户“

#然后视情况看是可能有多个返回值，还是只有一个返回值，（当id为主键时只可能返回一个object数据）

users1 = users[0]

　　解决问题的代码：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

from sqlalchemy import Column, String, create_engine, Integer

from sqlalchemy.orm import sessionmaker

from sqlalchemy.ext.declarative import declarative_base

 

warnings.filterwarnings("ignore")

 

Base = declarative_base()

 

class TrainInfo(Base):

    __tablename__ = 'phm'

 

    phmid = Column(String(20), primary_key=True)

    status = Column(Integer, default=0)

 

 

def MySQLConnect(connection_info:str, phmid, status):

    engine = create_engine(connection_info)

    DBSession = sessionmaker(bind=engine)

    session = DBSession()

    traininfo = session.query(TrainInfo).filter(TrainInfo.phmid == phmid).one()

    if traininfo is None:

        info =TrainInfo(phmid=phmid, status=status)

        session.add(info)

    else:

 

        traininfo.status = '1'

    session.commit()

    session.close()

　　

八，扩展知识

8.1 Python双下划线开头的函数和变量

python 用下划线作为变量前缀和后缀指定特殊变量。

  • __XXX 不能用 ‘ from module  import * ’ 导入
  • __XXX__  系统定义名称
  • __XXX     类中的私有变量名
  • 核心风格：避免用下划线作为变量名的开始。

　　因为下划线对解释器有特殊的意义，而且是内建标识符所使用的符号，我们建议程序员避免使用下划线作为变量名的开始。一般来说，变量名__XXX 被看做是“私有”的，在模块或类外不可以使用。当变量是私有的时候，用_XXX来表示变量是很好地习惯。因为变量名__XXX___对python来说有特殊含义，对于普通的变量应当避免这种命名风格。

　　“单下划线”开始的成员变量叫做保护变量，意思是只有类对象和子类对象自己能访问到这些变量；

　　“双下划线”开始的是私有成员，意思是只有类对象自己能访问，连子类对象也不能访问到这个数据。

　　以单下划线开头（__foo）的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用“from  XXX  import * ”而导入；

　　以双下划线开头的（__foo）代表类的私有成员；

　　以双下划线开头和结尾的（__foo__）代表python里特殊方法专用的标识，如__init__() 代表类的构造函数。

8.2 if __name__  == ''__main__''

　　所有的python模块都是对象并且有几个有用的属性，你可以使用这些属性方便的测试你所书写的模块。

　　模块是对象，并且所有的模块都有一个内置属性__name__。一个模块的__name__的值要你您如何应用模块。如果import模块，那么__name__的值通常为模块的文件名，不带路径或者文件扩展名。但是我们也可以像一个标准的程序一样直接运行模块，在这种情况下__name__的值将会是一个特别的缺省值：__main__。

 

参考文献：https://www.jianshu.com/p/20593da77c04

Gordennizaicunzai
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Python】sqlalchemy
染柒的博客
05-13 353
创建数据库 from sqlalchemy import create_engine, Column, String, Integer from sqlalchemy.ext.declarative import declarative_base # 创建Base类 Base = declarative_base() class Test(Base): __tablename__ = 'user' # 表名 id = Column(Integer, primary_key=True
python学习--SQLAlchemy
listener_的博客
06-29 1812
ORM ORM，对象关系映射，对象和关系之间的映射，使用面向对象的方式来操作数据库 关系模型和Python对象之间的映射 table => class ，表映射为类 row => object ，行映射为实例 column => property ，字段映射为属性 SQLAlchemy 安装 $ pip install sqlalchemy 文档 官方文档 h...
python-sqlalchemy
08-02
官网版本sqlalchemy
python Sqlalchemy
qq_27953479的博客
09-20 339
SQLAlchemy 是python中，通过ORM操作数据库的框架。它简化了应用程序开发人员在原生SQL上的操作，使开发人员将主要精力都放在程序逻辑上，从而提高开发效率。它提供了一整套著名的企业级持久性模式，设计用于高效和高性能的数据库访问。
Python 之SQLAlchemy使用详细说明
最新发布
lIujunXHU的博客
05-31 1421
ORM（Object-Relational Mapping）模型，即对象关系映射，是一种程序设计技术，用于实现面向对象编程语言里不同类型系统的数据之间的转换。在面向对象的编程语言中，如Java、Python等，数据通常被组织成复杂的对象关系。简单来说就是ORM模型把面向对象编程与操作数据库之间建立了映射。设置开发者操作数据库无需维护和编写SQL语句，而是基于面对对象的方式操作数据库。数据库中的表>编程语言中的类，表中的字段>类中的属性，表之间的关系>类之间的关系。
Python之sqlalchemy
qq_32154655的博客
05-11 189
Python之sqlalchemy一、把表写成类，进行数据处理#!/usr/bin/env python# -*- coding:utf8 -*-# @Time     : 2018/5/11 9:48# @Author   : hantong# @File     : 20180510_mysql_sqlalchemy.py'''表  studentid, name, age, sex, gra...
【python】sqlalchemy
游码客的博客
01-10 1669
SQLAlchemy 安装 pip install SQLAlchemy 查看版本号 import sqlalchemy print(sqlalchemy.__version__) 建立连接Engine from sqlalchemy import create_engine engine = create_engine( 'mysql+pymysql://121.4.154.189:3306/wss_demmo?charset=utf8&user=root&password=W
Python学习（SQLAlchemy篇）
qq_25934043的博客
12-06 192
安装SQLAlchemy模块并验证: pip install SQLAlchemy pip install pymysql import sqlalchemy sqlalchemy.__version__ import pymysql pymysql.__version__ 连接数据库之前必须将数据库环境搭配好 这里我直接使用WampServer,并创建zsq管理员，一切准备好后开始连接数据...
Python SQLAlchemy库的使用方法
12-16
SQLAlchemy的核心优势在于它能够将数据库操作抽象化，使得开发人员可以使用Python代码而不是SQL语句来操作数据，提高了代码的可读性和可维护性。 SQLAlchemy提供了两种主要的使用模式：SQL表达式语言（SQLAlchemy ...
Python SQLAlchemy入门教程(基本用法)
09-18
文档提到了在Python 2.7版本下使用的SQLAlchemy 1.1.6版本的具体内容，这也是学习SQLAlchemy之前需要考虑的技术前提。 在标签中，“Python”，“SQLAlchemy”，和“Python入门教程”这些标签为读者提供了关于本文档...
Python ORM框架SQLAlchemy学习笔记之数据添加和事务回滚介绍
01-20
1. 添加一个新对象 前面介绍了映射到实体表的映射类User，如果我们想将其持久化(Persist)，...因为SQLAlchemy采取的是Lazyload策略，也就是说现在这个对象被标记为Pending准备状态，但没有执行任何可能导致数据库变化
Python SQLAlchemy基本操作和常用技巧（包含大量实例,非常好）
12-24
首先说下，由于最新的 0.8 版还是开发版本，因此我使用的是 0.79 版，API 也许会有些不同。因为我是搭配 MySQL InnoDB 使用，所以使用其他数据库的也不能完全照搬本文。 接着就从安装开始介绍吧，以 Debian/Ubuntu 为例（请确保有管理员权限）：1.MySQL复制代码 代码如下:apt-get install mysql-serverapt-get install mysql-clientapt-get install libmysqlclient15-dev2.python-mysqldb复制代码 代码如下:apt-get install python-mysqld
python sqlalchemy 使用手册 英文版
08-18
本手册是一份关于Python编程语言中SQLAlchemy ORM库的使用指南。SQLAlchemy是一个用于Python编程语言的数据库工具包，它提供了一系列工具来处理关系数据库，并提供了一个完整的SQL表达语言。本手册涵盖了SQLAlchemy...
Python ORM框架SQLAlchemy学习笔记之关系映射实例
01-20
昨天简单介绍了SQLAlchemy的使用，但是没有能够涉及其最精彩的ORM部分，今天我将简单说明一下，当然主要还是讲解官方文档的内容，由于是学习笔记，有可能存在精简或者自己理解的部分，不做权威依据。 当我们开始使用...
Python-Sqlalchemy(ORM数据库框架)
weixin_45203607的博客
10-19 3242
内存中的对象之间存在关联和继承关系，而在数据库中，关系数据无法直接表达多对多关联和继承关系。创建好了Engine的同时，Pool和Dialect也已经创建好了，但是此时并没有真正与数据库连接，等到执行具体的语句.connect()等时才会连接到数据库。会话就和打电话一样,打一次电话就是一个会话,就相当于和数据库交互一次就是一个会话,一个会话可以运行多个或单个语句,会话结束必须关闭。sqlalchemy中使用session用于创建程序和数据库之间的会话，所有对象的载入和保存都需要通过session对象。
Python SQLAlchemy
朝着梦想 渐行前进
10-14 1612
下面是一些学习链接 一篇比较简单的博客讲解 http://gashero.yeax.com/?p=6#id13 官方文档 http://www.sqlalchemy.org/docs/ 还有本书叫做Essential SQLAlchemy
python sqlalchemy_python之sqlalchemy
weixin_39707478的博客
11-30 182
ORM:ORM框架的作用就是把数据库表的一行记录与一个对象互相做自动转换。 正确使用ORM的前提是了解关系数据库的原理。 ORM就是把数据库表的行与相应的对象建立关联，互相转换。 由于关系数据库的多个表还可以用外键实现一对多、多对多等关联，相应地， ORM框架也可以提供两个对象之间的一对多、多对多等功能。一 单表操作（不涉及一对多，多对多）#coding:utf8import sqlalchemy...
Python SQLAlchemy ORM与SQL Expression Language教程
SQLAlchemy是Python中的一个强大的数据库工具包，提供了多种方式来与数据库交互。它的核心组件包括Object-Relational Mapper (ORM) 和 SQL Expression Language。ORM使得开发者能够用面向对象的方式来处理数据库操作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值