常用的第三方模块1(pip、pip3、虚拟环境_环境隔离、PyMysql、sqlalchemy)

常用的第三方模块（更新ing）

pip、pip3、PyMysql、sqlalchemy

 

1、pip、pip3

常用命令

序号 命令 功能
1 
pip list
 列出已经安装的包，pip list >自定义文件，可以直接将依赖环境写入到指定的requirement.txt文件中
2 
pip install 包名
 安装要安装的包
3 
pip install django==1.1.5 
  安装特定版本，=在python中代表赋值的作用，只有==才是等于的意思
4 
pip freeze > requirement.txt
 导出python环境
5 
pip install –r requirement.txt
 从导出的python环境中安装所需要的包
6 
pip uinstall –r requirement.txt
 卸载导出的文件中，的包
7 
pip list –o
 显示可升级的包
8 
pip install <包名> -d <目录> 
或 pip install -d <目录> -r requirements.txt
 只【下载】不安装

9

 
pip install <包名> -i http://pypi.v2ex.com/simple

更换国内pypi镜像（推荐临时使用这些源），常见的镜像有阿里，华为，清华等

阿里：https://mirrors.aliyun.com/pypi/simple 

豆瓣：http://pypi.douban.com/simple 

中国科学技术大学：http://pypi.mirrors.ustc.edu.cn/simple/ 
     

 

2、虚拟环境

  • 配置和使用虚拟环境，一般会用到virtualenv或virtualenvwrapper模块
  • virtualenv的基本使用 
    • 安装虚拟环境
virtualenv是用来创建虚拟环境的软件工具，我们可以通过pip或者pip3来安装

pip install virtualenv   #windows

pip3 install virtualenv 
创建虚拟环境
创建虚拟环境非常简单，通过以下命令就可以创建了：

创建虚拟环境：
virtualenv [虚拟环境的名字]
创建并指定python解释器版本，如上述不指定python的解释器，会使用系统默认的
virtualenv -p [使用的解释器] [虚拟环境的名字]


进入虚拟环境
　　虚拟环境创建好了以后，那么可以进入到这个虚拟环境中，然后安装一些第三方包，进入虚拟环境在不同的操作系统中有不同的方式，一般分为两种，第一种是Windows，第二种是*nix：

windows进入虚拟环境：进入到虚拟环境的Scripts文件夹中，然后执行activate。

linux进入虚拟环境

source /path/to/virtualenv/bin/activate
一旦你进入到了这个虚拟环境中，你安装包，卸载包都是在这个虚拟环境中，不会影响到外面的环境。

退出虚拟环境
退出虚拟环境很简单，通过一个命令就可以完成

deactivate
创建虚拟环境的时候指定Python解释器
　　在电脑的环境变量中，一般是不会去更改一些环境变量的顺序的。也就是说比如你的Python2/Scripts在Python3/Scripts的前面，那么你不会经常去更改他们的位置。但是这时候我确实是想在创建虚拟环境的时候用Python3这个版本，这时候可以通过-p参数来指定具体的Python解释器：

virtualenv -p C:\Python36\python.exe [virutalenv name]
      View Code

       

  • virtualenvmrapper基本使用

    • 　virtualenvwrapper这个软件包可以让我们管理虚拟环境变得更加简单。不用再跑到某个目录下通过virtualenv来创建虚拟环境，并且激活的时候也要跑到具体的目录下去激活。
      　
    • 　　　 
      安装virtualenvwrapper

linux

pip install virtualenvwrapper
windows

pip install virtualenvwrapper-win
virtualenvwrapper基本使用：
创建虚拟环境
mkvirtualenv my_env
那么会在你当前用户下创建一个Env的文件夹，然后将这个虚拟环境安装到这个目录下。

如果你电脑中安装了python2和python3，并且两个版本中都安装了virtualenvwrapper，那么将会使用环境变量中第一个出现的Python版本来作为这个虚拟环境的Python解释器。

切换到某个虚拟环境
workon my_env
退出当前虚拟环境
deactivate
删除某个虚拟环境
rmvirtualenv my_env
列出所有虚拟环境
lsvirtualenv
进入到虚拟环境所在的目录
cdvirtualenv
修改mkvirtualenv的默认路径：
在我的电脑->右键->属性->高级系统设置->环境变量->系统变量中添加一个参数WORKON_HOME，将这个参数的值设置为你需要的路径。

创建虚拟环境的时候指定Python版本： 
在使用mkvirtualenv的时候，可以指定--python的参数来指定具体的python路径：

mkvirtualenv --python==C:\Python36\python.exe hy_env
      View Code

       

       

3、PyMysql

简介：

 

基本使用流程及常用操作：

  1. 确定数据库用户、登录主机权限及密码等基本信息。
  2. 创建数据库链接，获取操作句柄。 eg:  conn_db = pymysql.connect(host='localhost',port=3310,user='woider',passwd='3243',db='python',charset='utf8')
  3. 创建游标，eg：cursor =  conn_db.cursor()
  4. sql执行语句预编， eg： sql = " 增删改查原生sql语句"
  5. sql语句执行，可以是字符串形式的原生sql语句，也可以是执行的预编的sql语句，eg： effect_r = cursor.execute( )
  6. 确认执行操作，eg : conn_db.commit() 
  7. 关闭游标， eg：cursor.close()
  8. 关闭链接， eg:  conn_db.close()

 

 

 

4、sqlalchemy

 

基本使用流程及常用操作：

  1.  导入sqlalchemy模块及其常用的子模块，例如，create_engine,Column,Foreign_key……；从sqlalchemy.ext.declarative 中导入基类declarative_base；从sqlalchemy.orm 中导入sessionmaker,relationship……
  2. 创建数据库引擎，  eg：  engine_db = create_engine("mysql+pymysql://用户名:密码@登录主机地址",encoding = 'utf8')
    • sqlalchemy 作为orm工具，不直接链接数据库，可以利用不同的工具包链接并工作于msql，orecal，SqlServer，SQLLITE等数据库
      • mysql，mariadb，使用pymysql，mysqldb等，
      • 使用cx_oracle,链接oracle数据库
    • 详细的引擎配置，可参考 https://docs.sqlalchemy.org/en/20/dialects/index.html
    • 常用参数
      • max_overflow 设置最大连接数
  3. 实例化数据表基类    eg： Base = declarative_base()
  4. 创建表结构，以类的形式，继承数据表基类Base
  5. 通过数据表基类，完成所有继承自Base的数据表的创建， eg：Base.metadata.create_all(engine_db)
  6. 初始化定义会话，绑定数据引擎   eg：Session_class = sessionmaker(bind=engine_db)
  7. 实例化会话，eg：session = Session_class()
  8. 通过建立的会话，对数据库中的数据表进行增删改查等基本操作
    • 创建新增数据，session.add；session.add_all ，执行语句后，需要用session.commit()确认操作
    • 查询数据记录，session.query(数据表名).filter_by(筛选过滤条件).all()      筛选器除了filter_by()还有filter()，   all()是显示方式，类似的还有first（）   
    • 删除数据记录，session.delete(数据记录)     数据记录可以通过查询、筛选获取
    • 修改数据记录，通过筛选拿到数据记录后，直接通过字段名修改
    • 数据回滚，session.rollback()
    • 数据查询结果的计数，count（）
    • 数据查询结果的分组，group_by()     session.query(func.count(User.name),User.name).group_by(User.name).all()
    • 连表查询，基本连表查询    eg：   session.query(User,User_test).filter(User.id ==User_test.cid).all()
    • 通过relationship建立关系，实现两个表对象之间可以互相调用

 基本操作的例子

例子1

  1 import sqlalchemy
  2 
  3 
  4 """_______________创建表结构，如果没有这个表则新建，有的话，只是完成打开对应的表_______________________"""
  5 
  6 
  7 from sqlalchemy import create_engine
  8 from sqlalchemy.ext.declarative import declarative_base
  9 from sqlalchemy import Column,Integer,String
 10 engine = create_engine("mysql+pymysql://guest04:pwd04@localhost/yourdb",encoding='utf8') #链接数据库，创建引擎  加上 echo =True   逐步打印
 11 Base = declarative_base()      #生成orm基类
 12 class User(Base):
 13  # 表结构，初始化定义
 14     __tablename__='user'
 15     id=Column(Integer,primary_key=True)
 16     name=Column(String(32))
 17     password=Column(String(64))
 18 
 19     def __repr__(self):           # 创建查找结果的返回格式
 20         return "<%s name:%s>"%(self.id,self.name)
 21 
 22 
 23 class User_test(Base):
 24     __tablename__ = 'user_test'
 25     cid = Column(Integer,primary_key=True)
 26     cname = Column(String(32))
 27     teacher_id = Column(Integer)
 28 
 29     def __repr__(self):           # 创建查找结果的返回格式
 30         return "<%s name:%s>"%(self.cid,self.cname)
 31 
 32 
 33 
 34 
 35 
 36 Base.metadata.create_all(engine)  # 生成完成初始化的表
 37 
 38 
 39 
 40 """________________操作表结构，具体动作_____________________"""
 41 
 42 
 43 # 1 创建数据
 44 
 45 # from sqlalchemy.orm import sessionmaker
 46 # Session_class = sessionmaker(bind=engine)  #创建与数据库的会话类session class ，生成的是个类
 47 # session = Session_class()      #实例化会话
 48 #
 49 #
 50 #
 51 # user_obj = User(name="aaabbbccc",password="123456")
 52 # print(user_obj.name,user_obj.id)   #当前还没完成对象的创建，所以打印的时候为id空Null。实际效果类似于在navicat中，在字段列中添加了内容，但是还没有点下面的对勾，没有确认添加
 53 #
 54 # session.add(user_obj) #把要创建的额数据对象，添加到session会话对象中，稍后统一创建，可以添加多条
 55 # print(user_obj.name,user_obj.id)   #此时依然没完成对象的创建，所以打印的时候为空Null
 56 #
 57 # session.commit()     #完成确认添加，此时在打印的时候，已经完成了最终的创建，id生成
 58 
 59 
 60 
 61 
 62 # 2 查询数据
 63 # from sqlalchemy.orm import sessionmaker
 64 # Session_class = sessionmaker(bind=engine)  #创建与数据库的会话类session class ，生成的是个类
 65 # session = Session_class()
 66 #
 67 # data_check = session.query(User).filter_by().all()   # filter()和filter_by() 参数格式不同。可以用多条件查询                  all() 把查询内容做成一个列表， 类似的，还有first（）
 68 # print(data_check)
 69 
 70 # 3 修改数据
 71 # from sqlalchemy.orm import sessionmaker
 72 # Session_class = sessionmaker(bind=engine)  #创建与数据库的会话类session class ，生成的是个类
 73 # session = Session_class()
 74 #
 75 # data_check = session.query(User).filter(User.id>1).filter(User.id<5).first()  #拿到了1<id<5 的第一个记录，
 76 # print(data_check)
 77 # data_check.name = "change_tomy"            #对name进行修改，可以多字段修改
 78 # data_check.password = "changed"
 79 # session.commit()                           #确认修改内容
 80 
 81 # 4 删除数据
 82 # from sqlalchemy.orm import sessionmaker
 83 # Session_class = sessionmaker(bind=engine)  #创建与数据库的会话类session class ，生成的是个类
 84 # session = Session_class()
 85 # data_del = session.query(User).filter(User.name.like("change%")).first()
 86 # print(data_del)
 87 # session.delete(del)              #或者直接用 session.query(User).filter(User.name.like("change%")).first().delete()
 88 #
 89 # session.commit()
 90 
 91 
 92 
 93 #5 回滚
 94 # from sqlalchemy.orm import sessionmaker
 95 # Session_class = sessionmaker(bind=engine)  #创建与数据库的会话类session class ，生成的是个类
 96 # session = Session_class()
 97 #
 98 # my_user = session.query(User).filter_by(id=1).first()
 99 # my_user.name = "cc_changed"
100 #
101 # fake_user = User(name = "Rain",password ="666")
102 # session.add(fake_user)
103 # print(session.query(User).filter(User.name.in_(['cc_changed','Rain'])).all())    #session完成了修改
104 #
105 # session.rollback()
106 # print(session.query(User).filter(User.name.in_(['cc_changed','Rain'])).all())
107 
108 # 6 统计
109 # from sqlalchemy.orm import sessionmaker
110 # Session_class = sessionmaker(bind=engine)  #创建与数据库的会话类session class ，生成的是个类
111 # session = Session_class()
112 #
113 # data_count = session.query(User).filter(User.name.like("aaab%")).count()
114 # print(data_count)
115 
116 # 7 分组
117 # from sqlalchemy.orm import sessionmaker
118 # from sqlalchemy import func
119 # Session_class = sessionmaker(bind=engine)  #创建与数据库的会话类session class ，生成的是个类
120 # session = Session_class()
121 #
122 #
123 # print(session.query(func.count(User.name),User.name).group_by(User.name).all())
124 
125 #8 连表查询1
126 
127 # from sqlalchemy.orm import sessionmaker
128 # Session_class = sessionmaker(bind=engine)
129 # session = Session_class()
130 #
131 # ret = session.query(User,User_test).filter(User.id ==User_test.cid).all()
132 #
133 #
134 # print(ret)
View Code

例子2

 1 import sqlalchemy
 2 from sqlalchemy import create_engine
 3 from sqlalchemy.ext.declarative import declarative_base
 4 from sqlalchemy import Column,Integer,String,DATE,ForeignKey
 5 from sqlalchemy.orm import sessionmaker,relationship
 6 
 7 
 8 engine = create_engine("mysql+pymysql://guest04:pwd04@localhost/yourdb",encoding = 'utf8')
 9 Base = declarative_base()
10 
11 class StudentOrm(Base):
12     __tablename__ = 'student_orm'
13     id = Column(Integer,primary_key= True)
14     name = Column(String(32),nullable=False)
15     register_date = Column(DATE,nullable= False)
16 
17     def __repr__(self):
18         return "<%s  name:%s>"%(self.id,self.name)
19 
20 class StudentRecord(Base):
21     __tablename__ = "student_record"
22     id = Column(Integer,primary_key=True)
23     day = Column(DATE,nullable=False)
24     status = Column(String(32),nullable=False)
25     stu_id = Column(Integer,ForeignKey("student_orm.id"))
26 
27     student_orm = relationship("StudentOrm",backref="my_student_record")   #  创建双向映射关系
28 
29     def __repr__(self):
30         return "<%s  day:%s status:%s>"%(self.student_orm.name,self.day,self.status)
31 
32 Base.metadata.create_all(engine)
33 
34 Session_class = sessionmaker(bind=engine)
35 session = Session_class()
36 
37 
38 ##_________创建数据表内容__________
39 # s1 = StudentOrm(name='zhangsan',register_date = "2011-01-11")
40 # s2 = StudentOrm(name='lisi',register_date = "2011-02-12")
41 # s3 = StudentOrm(name='wangwu',register_date = "2011-02-13")
42 #
43 #
44 # study_obj1 = StudentRecord(day = "2011-03-01",status = "Y",stu_id = 1)
45 # study_obj2 = StudentRecord(day = "2011-03-01",status = "N",stu_id = 2)
46 # study_obj3 = StudentRecord(day = "2011-03-01",status = "Y",stu_id = 3)
47 # study_obj4 = StudentRecord(day = "2011-03-02",status = "Y",stu_id = 1)
48 # study_obj5 = StudentRecord(day = "2011-03-02",status = "N",stu_id = 3)
49 # study_obj6 = StudentRecord(day = "2011-03-02",status = "N",stu_id = 2)
50 #
51 # session.add_all([s1,s2,s3,study_obj1,study_obj2,study_obj3,study_obj4,study_obj5,study_obj6])
52 #
53 # session.commit()
54 
55 ##———连表查询—————
56 # stu_obj = session.query(StudentOrm,StudentRecord).filter(StudentOrm.id==StudentRecord.stu_id).all()
57 # print(stu_obj)
58 
59 
60 ##———relation建立表之间的调用查询关系—————
61 # stu_obj = session.query(StudentOrm).filter(StudentOrm.name=="zhangsan").first()    # 从student_orm 中查到zhangsan ,再到student_record 表中查找上课记录
62 # print(stu_obj.my_student_record)
View Code
 1 import sqlalchemy
 2 from sqlalchemy.ext.declarative import declarative_base
 3 from sqlalchemy import create_engine
 4 from sqlalchemy import Column,Integer,String,Date,ForeignKey
 5 from sqlalchemy.orm import sessionmaker,relationship
 6 
 7 engin = create_engine("mysql+pymysql://guest04:pwd04@localhost/yourdb",encoding = 'utf-8')
 8 Base = declarative_base()
 9 
10 class Addr(Base):
11     __tablename__="addresses"
12     id = Column(Integer,primary_key=True)
13     province = Column(String(32),nullable = False)
14     city = Column(String(32),nullable=False)
15     def __repr__(self):
16         return "<province:%s ,city:%s>"%(self.province,self.city)
17 
18 
19 class Customer(Base):
20     __tablename__="customer"
21     cid = Column(Integer,primary_key=True)
22     name = Column(String(32),nullable = False)
23     billcheck_addr_id = Column(Integer,ForeignKey("addresses.id"))    #建立账单地址外键
24     mailing_addr_id = Column(Integer,ForeignKey("addresses.id"))     #建立邮寄地址外键
25     billcheck_addr = relationship("Addr",foreign_keys=[billcheck_addr_id]) #建立关系，将映射的字段标记，在多外键的情况下区分是哪个字段调用
26     mailing_addr = relationship("Addr",foreign_keys=[mailing_addr_id]) #建立关系，将映射的字段标记，在多外键的情况下区分是哪个字段调用
27     def __repr__(self):
28         return "cid:%s name:%s"%(self.cid,self.name)
29 
30 Base.metadata.create_all(engin)
31 
32 Session_class = sessionmaker(bind=engin)
33 session = Session_class()
34 
35 ##_____________添加数据记录_______________
36 
37 # addr_obj1 = Addr(province="beijing",city = "chaoyang")
38 # addr_obj2 = Addr(province="jiangsu",city = "nanjing")
39 # addr_obj3 = Addr(province="shandong",city = "qingdao")
40 # addr_obj4 = Addr(province="zhejiang",city = "hangzhou")
41 #
42 # cust_obj1 = Customer(name="zhangsan",billcheck_addr_id = 1,mailing_addr_id = 1)
43 # cust_obj2 = Customer(name="lisi",billcheck_addr_id = 3,mailing_addr_id = 1)
44 # cust_obj3 = Customer(name="wangwu",billcheck_addr_id = 1,mailing_addr_id = 2)
45 # cust_obj4 = Customer(name="zhaoliu",billcheck_addr_id = 3,mailing_addr_id = 3)
46 # cust_obj5 = Customer(name="sunqi",billcheck_addr_id = 2,mailing_addr_id = 4)
47 #
48 # session.add_all([addr_obj1,addr_obj2,addr_obj3,addr_obj4,cust_obj1,cust_obj2,cust_obj3,cust_obj4,cust_obj5])
49 # session.commit()
50 
51 
52 
53 
54 check_obj = session.query(Customer).filter(Customer.name == "lisi").first()
55 print(check_obj.name,check_obj.billcheck_addr.province,check_obj.mailing_addr.province)
View Code
 1 import sqlalchemy
 2 from sqlalchemy.engine import create_engine
 3 from sqlalchemy import Column,Integer,String,Date,ForeignKey,Table
 4 from sqlalchemy.ext.declarative import declarative_base
 5 from sqlalchemy.orm import sessionmaker,session,relationship
 6 
 7 engine = create_engine("mysql+pymysql://guest04:pwd04@localhost/yourdb",encoding = 'utf-8')
 8 Base = declarative_base()
 9 
10 book_m2m_author = Table(
11     ###   这张关系表，是mysql自动维护的，不需要人为操作，所以，可以不用class类创建的形式
12     "book_m2m_author",Base.metadata,
13     Column('book_id',Integer,ForeignKey("books.b_id")),
14     Column("author_id",Integer,ForeignKey("authors.a_id"))
15 )
16 
17 class Books(Base):
18     __tablename__='books'
19     b_id = Column(Integer,primary_key = True)
20     book_name = Column(String(32),nullable =False)
21     authors = relationship("Authors",secondary = book_m2m_author,backref = "books")
22     def __repr__(self):
23         return self.book_name
24 
25 class Authors(Base):
26     __tablename__='authors'
27     a_id = Column(Integer,primary_key=True)
28     a_name = Column(String(32),nullable=False)
29     def __repr__(self):
30         return self.a_name
31 
32 Base.metadata.create_all(engine)
33 
34 
35 Session_class = sessionmaker(bind=engine)
36 session = Session_class()
37 
38 #—————————创建数据—————————————
39 
40 # au_obj1 = Authors(a_name = "zhangsan")
41 # au_obj2 = Authors(a_name = "lisi")
42 # au_obj3 = Authors(a_name = "wangwu")
43 # au_obj4 = Authors(a_name = "zhaoliu")
44 #
45 # book_obj1=Books(book_name = "sss1")
46 # book_obj2=Books(book_name = "sss2")
47 # book_obj3=Books(book_name = "sss3")
48 #
49 #
50 # ##_______创建关联关系，在book_m2m_author中记录
51 #
52 # book_obj1.authors=[au_obj1,au_obj4]
53 # book_obj2.authors=[au_obj1,au_obj2]
54 # book_obj3.authors=[au_obj2,au_obj4,au_obj3]
55 #
56 #
57 # session.add_all([au_obj3,au_obj1,au_obj4,au_obj2,book_obj3,book_obj2,book_obj1])
58 # session.commit()
59 
60 
61 ##——————————每名作者有多本书，通过作者查书名——————————————
62 au_1 = session.query(Authors).filter(Authors.a_name == "zhangsan").first()
63 print(au_1,au_1.books)
64 
65 ##______一本书对应多名作者，通过书名查找作者_________
66 book_1 = session.query(Books).filter(Books.book_name =="sss1").first()
67 print(book_1,book_1.authors)
View Code

 

posted @ 2019-05-17 17:04  林山风火  阅读(29)  评论(0)    收藏  举报