当你发现自己的才华撑不起野心时,就请安静下来学习吧。

Personal site

↑点击传送

Flask

初识flask

介绍

Flask诞生于2010年,是Armin ronacher(人名)用 Python 语言基于 Werkzeug(wo ke zou ge) 工具箱编写的轻量级Web开发框架。
Flask 本身相当于一个内核,其他几乎所有的功能都要用到扩展(邮件扩展Flask-Mail,用户认证Flask-Login,数据库Flask-SQLAlchemy),都需要用第三方的扩展来实现。比如可以用 Flask 扩展加入ORM、窗体验证工具,文件上传、身份验证等。Flask 没有默认使用的数据库,你可以选择 MySQL,也可以用 NoSQL。

其 WSGI 工具箱采用 Werkzeug(路由模块),模板引擎则使用 Jinja2。这两个也是 Flask 框架的核心。

官网: http://flask.pocoo.org/
官方文档: http://docs.jinkan.org/docs/flask/
        
Flask常用的扩展包:
    Flask-SQLalchemy:操作数据库,ORM;
    Flask-script:终端脚本工具,脚手架;
    Flask-migrate:管理迁移数据库;
    Flask-Session:Session存储方式指定;
    Flask-WTF:表单;
    Flask-Mail:邮件;
    Flask-Bable:提供国际化和本地化支持,翻译;
    Flask-Login:认证用户状态;
    Flask-OpenID:认证, OAuth;
    Flask-RESTful:开发REST API的工具;
    Flask JSON-RPC: 开发rpc远程服务[过程]调用
    Flask-Bootstrap:集成前端Twitter Bootstrap框架
    Flask-Moment:本地化日期和时间
    Flask-Admin:简单而可扩展的管理接口的框架

创建虚拟环境

#安装依赖
	pip3 install virtualenv
    pip3 install virtualenvwrapper
    
#建立软连接(相当于windows快捷方式)
	ln -s /usr/local/python3/bin/virtualenv /usr/bin/virtualenv
    
#配置虚拟环境,填入下面内容,填入内容后按esc,:wq保存并退出,
	vim ~/.bash_profile
    
    填入内容,看图1
    	VIRTUALENVWRAPPER_PYTHON=/usr/local/python3/bin/python3
		source /usr/local/python3/bin/virtualenvwrapper.sh
        
#查看下修改好的neir
	cat ~/.bash_profile
#更新配置文件内容
	source ~/.bash_profile
    
#虚拟环境默认的根目录 
	cd ~/.virtualenvs  
  
#创建虚拟环境
    1 创建虚拟环境到配置的WORKON_HOME路径下
        mkvirtualenv -p python3 自定义的虚拟环境名称(比如:luffy)	使用的是python3
        mkvirtualenv -p python2 自定义的虚拟环境名称(比如:luffy)	使用的是python2
    2 查看已有的虚拟环境
        workon
    3 使用虚拟环境
        workon 已有的虚拟环境名称(比如:luffy)
    4 进入、退出该虚拟环境的Python环境
        python、exit()
    5 为虚拟环境安装模块
        pip install 模块名称(比如:django==2.2)
    6 退出当前虚拟环境
        deactivate
    7 删除虚拟环境(删除当前虚拟环境要先退出)
        rmvirtualenv 自定义的虚拟环境名称(比如:luffy)
        

快速入门

#安装flask
    workon flask
    pip install flask

#pycharm创建flask项目,flask_first,看下图步骤

#app.py
    from flask import Flask, request
    app = Flask(__name__)

    @app.route('/')
    def hello_world():
        print(request.path)  # /
        return 'Hello World!'

    @app.route('/hello')
    def hello():
        print(request.path)  # /hello
        return 'hello'

    if __name__ == '__main__':
        app.run()
    # 请求来了,会执行 app(request),会触发谁?触发__call__方法

图1

image-20200826194305510

图2

image-20200826194406711

登录,显示用户信息

#登录成功之后可以访问index页面

#App2.py
    from flask import Flask, render_template, request, redirect, session, url_for
    app = Flask(__name__)
    app.debug = True
    app.secret_key = 'sdfsdfsdfsdf'

    USERS = {
        1: {'name': '张三', 'age': 18, 'gender': '男', 'text': "道路千万条"},
        2: {'name': '李四', 'age': 28, 'gender': '男', 'text': "安全第一条"},
        3: {'name': '王五', 'age': 18, 'gender': '女', 'text': "行车不规范"},
    }

    @app.route('/detail/<int:nid>', methods=['GET'])
    def detail(nid):
        user = session.get('user_info')
        if not user:
            return redirect('/login')

        info = USERS.get(nid)
        return render_template('detail.html', info=info)

    @app.route('/index', methods=['GET'])
    def index():
        user = session.get('user_info')
        if not user:
            # return redirect('/login')
            url = url_for('l1')
            return redirect(url)
        return render_template('index.html', user_dict=USERS)

    @app.route('/login', methods=['GET', 'POST'], endpoint='l1')
    def login():
        if request.method == "GET":
            return render_template('login.html')
        else:
            # request.query_string
            user = request.form.get('user')
            pwd = request.form.get('pwd')
            if user == 'joab' and pwd == '123':
                session['user_info'] = user
                return redirect('http://www.baidu.com')
            return render_template('login.html', error='用户名或密码错误')


    if __name__ == '__main__':
        app.run()

#login.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <h1>用户登录</h1>
    <form method="post">
        <input type="text" name="user">
        <input type="text" name="pwd">
        <input type="submit" value="登录">{{error}}
    </form>
</body>
</html>

#index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <h1>用户列表</h1>
    <table>
        {% for k,v in user_dict.items() %}
        <tr>
            <td>{{k}}</td>
            <td>{{v.name}}</td>
            <td>{{v['name']}}</td>
            <td>{{v.get('name')}}</td>
            <td><a href="/detail/{{k}}">查看详细</a></td>
        </tr>
        {% endfor %}
    </table>
</body>
</html>

#templates\detail.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <h1>详细信息 {{info.name}}</h1>
    <div>
        {{info.text}}
    </div>
</body>
</html>

总结

1 三板斧
	return 字符串		#直接返回字符串
	return render_template('index.html')	#返回html页面
	return redirect('/login')		#重定向

2 路由写法,(路径,支持的请求方式,别名)别名不写默认是函数名	#@app.route('/login',methods=['GET','POST'],endpoint='l1')

3 模板语言渲染
	-同django的dtl,但是比dtl强大,支持加括号执行,字典支持中括号取值和get取值
    如:
        {% for k,v in user_dict.items() %}
        <tr>
            <td>{{k}}</td>
            <td>{{v.name}}</td>
            <td>{{v['name']}}</td>
            <td>{{v.get('name')}}</td>
            <td><a href="/detail/{{k}}">查看详细</a></td>
        </tr>
        {% endfor %}
    
4 分组(就是django中的有名分组)
    @app.route('/detail/<int:nid>',methods=['GET'])
    def detail(nid):
        
5 反向解析
	-url_for('别名'),设置别名,重定向到该url
    
    列子:
        @app.route('/index', methods=['GET'])
        def index():
            user = session.get('user_info')
            if not user:
                # return redirect('/login')
                url = url_for('l1')
                return redirect(url)
            return render_template('index.html', user_dict=USERS)
        
6 获取前端传递过来的数据
	# get 请求
		request.query_string
        
  	# post请求
      user = request.form.get('user')
      pwd = request.form.get('pwd')

配置文件

#方式1
    app.config['DEBUG'] = True
    PS: 由于Config对象本质上是字典,所以还可以使用		app.config.update(...)	
    
#方式2
    #通过py文件配置
    app.config.from_pyfile("python文件名称")
    如:
    settings.py
    DEBUG = True
    
#方式3
    app.config.from_object('settings.TestingConfig')
    
    class Config(object):
        DEBUG = False
        TESTING = False
        DATABASE_URI = 'sqlite://:memory:'

    class ProductionConfig(Config):
        DATABASE_URI = 'mysql://user@localhost/foo'

    class DevelopmentConfig(Config):
        DEBUG = True

    class TestingConfig(Config):
        TESTING = True

路由系统

#基本使用
	@app.route('/detail/<int:nid>',methods=['GET'],endpoint='detail')
    
#转换器
    DEFAULT_CONVERTERS = {
        'default':          UnicodeConverter,
        'string':           UnicodeConverter,
        'any':              AnyConverter,
        'path':             PathConverter,
        'int':              IntegerConverter,
        'float':            FloatConverter,
        'uuid':             UUIDConverter,
    }
    
#路由本质
    1 本质就是:app.add_url_rule()
    2 endpoint:如果不写默认是函数名,endpoint不能重名
    

#@app.route和app.add_url_rule参数:
    rule, URL规则
    
    view_func, 视图函数名称
    
    defaults = None, 默认值, 当URL中无参数,函数需要参数时,使用defaults = {'k': 'v'},为函数提供参数
    
    endpoint = None, 名称,用于反向生成URL,即: url_for('名称')
    
    methods = None, 允许的请求方式,如:["GET", "POST"]
    
    #对URL最后的 / 符号是否严格要求,默认严格,False,就是不严格
    
        @app.route('/index', strict_slashes=False)
        #访问http://www.xx.com/index/ 或http://www.xx.com/index均可
        @app.route('/index', strict_slashes=True)
        #仅访问http://www.xx.com/index
        
    #重定向到指定地址
    	@app.route('/index/<int:nid>', redirect_to='/home/<nid>')

CBV(前后端分离开发)

from flask import Flask,request,render_template,redirect
from flask import views
app=Flask(__name__)

class IndexView(views.View):
    methods = ['GET']
    decorators = [auth, ]
    def dispatch_request(self):
		print('Index')
        return 'Index!'


def auth(func):
    def inner(*args, **kwargs):
        print('before')
        result = func(*args, **kwargs)
        print('after')
        return result
    return inner

class IndexView(views.MethodView):
    methods = ['GET']  # 指定请求方式
    # 登录认证装饰器加在哪?
    decorators = [auth, ]  #加多个就是从上往下的效果
    def get(self):
        return "我是get请求"
    def post(self):
       return '我是post请求'

# 注册路由
app.add_url_rule('/index',view_func=IndexView.as_view('index'))	# IndexView.as_view('index'),必须传name

if __name__ == '__main__':
    app.run()
    
    
# views.View用的比较少

# 继承views.MethodView,只需要写get,post,delete方法

# 如果加装饰器decorators = [auth, ],加多个就是从上往下的效果

# 允许的请求方法methods = ['GET'] 

HTTP请求

配置文件

# SECRET_KEY:如果使用session,必须配置

# SESSION_COOKIE_NAME:cookie名字

# 数据库地址,端口号,也要放到配置文件中,但是不是内置的参数

# flask内置session如何实现?
	-通过SECRET_KEY加密以后,当做cookie返回给浏览器
    -下次发送请求,携带cookie过来,反解,再放到session中
    

flask-resful跟drf挺像的,可以看看

路由支持正则

#写类,继承BaseConverter

#注册:app.url_map.converters['regex'] = RegexConverter

#使用:@app.route('/index/<regex("\d+"):nid>')  正则表达式会当作第二个参数传递到类中

from flask import Flask, views, url_for
from werkzeug.routing import BaseConverter
app = Flask(import_name=__name__)

class RegexConverter(BaseConverter):
    """
    自定义URL匹配正则表达式
    """
    def __init__(self, map, regex):
        super(RegexConverter, self).__init__(map)
        self.regex = regex

    def to_python(self, value):
        """
        路由匹配时,匹配成功后传递给视图函数中参数的值
        """
        return int(value)

    def to_url(self, value):
        """
        使用url_for反向生成URL时,传递的参数经过该方法处理,返回的值用于生成URL中的参数
        """
        val = super(RegexConverter, self).to_url(value)
        return val
    
# 添加到flask中

    app.url_map.converters['regex'] = RegexConverter
    @app.route('/index/<regex("\d+"):nid>')
    def index(nid):
        print(url_for('index', nid='888'))
        return 'Index'

    if __name__ == '__main__':
        app.run()

模板

# 同django的dtl,但是比dtl强大,支持加括号执行,字典支持中括号取值和get取值
    如:
        {% for k,v in user_dict.items() %}
        <tr>
            <td>{{k}}</td>
            <td>{{v.name}}</td>
            <td>{{v['name']}}</td>
            <td>{{v.get('name')}}</td>
            <td><a href="/detail/{{k}}">查看详细</a></td>
        </tr>
        {% endfor %}

# 模板有没有处理xss攻击,在页面显示标签,内部怎么实现的?
	-1 模板层   要渲染的字符串|safe	# 前端使用 要渲染的字符串|safe 渲染出input框
    -2 后端:Markup('<input type="text">')		#使用Markup()前端可以渲染出input框
    
# Markup等价django的mark_safe ,

# extends,include一模一样

视图函数和视图类

request对象的属性和方法

request.method  #提交的方法

request.args  #get请求提及的数据

request.form   #post请求提交的数据

request.values  #post和get提交的数据总和

request.cookies  #客户端所带的cookie

request.headers  #请求头

request.path     #不带域名,请求路径

request.full_path  #不带域名,带参数的请求路径

request.url           #带域名带参数的请求路径

request.base_url		#带域名请求路径

request.url_root      #域名

request.host_url		#域名

request.host			#127.0.0.1:5000
    
request.files		#文件

响应对象的方法

return "字符串"

return render_template('html模板路径',**{})

return redirect('/index.html')

return jsonify({'k1':'v1'})	#对着django,JsonResponse

#添加/更新cookie
    aa='hello world'
    res=make_response(aa)
    res.set_cookie('xxx','lqz')
    
# 往响应头中放东西
    res.headers['X-Something'] = 'A value'
    print(type(res))
    from  flask.wrappers import Response
    return res

response = make_response(render_template('index.html'))		#response是flask.wrappers.Response类型

response.delete_cookie('key')	#删除cookie

response.set_cookie('key', 'value')		#添加/更新cookie

response.headers['X-Something'] = 'A value'		# 往响应头中放东西	

return response		#记得返回响应对象

return 'hello'	#返回字符串

补充知识

varchr :65535个字节的数据
    utf8:中文占2个字节,varchar(300)
    utf8mb4:中文占3个字节,varchar(300)
    
# 快速导出requestment.txt
	pip3 install pipreqs
    
# pipreqs ./ --encoding=utf-8

闪现

#应用场景,把前端上个页面报错信息,下个页面get_flashed_message()展示出来
    -设置:flash('aaa')
        
    -取值:get_flashed_message()
    
    -设置:flash('lqz',category='error1')
    
    -取值:res=get_flashed_messages(category_filter=['error1'])
    
    -假设在a页面操作出错,跳转到b页面,在b页面显示a页面的错误信息

session的使用

# 全局导入

# 视图函数中 session['key']=value

# 删除:session.pop('key')

# 取:session['key']

# open_session

# save_session

请求扩展(像django中间件)

#类似于django的中间件,请求来了,请求走了,什么操作

#请求来了就会触发,类似于django的process_request,如果有多个,顺序是从上往下
    @app.before_request
    def before(*args,**kwargs):
        if request.path=='/login':
            return None
        else:
            name=session.get('user')
            if not name:
                return redirect('/login')
            else:
                return None
            
#请求走了就会触发,类似于django的process_response,如果有多个,顺序是从下往上执行
    @app.after_request
    def after(response):
        print('我走了')
        return response

#3 before_first_request 项目启动起来第一次会走,以后都不会走了,也可以配多个(项目启动初始化的一些操作)
    @app.before_first_request
    def first():
        print('我的第一次')
    
# 4 每次视图函数执行完了都会走它,# 用来记录出错日志
    @app.teardown_request  # 用来记录出错日志
    def ter(e):
        print(e)
        print('我是teardown_request ')

# 5 errorhandler绑定错误的状态码,只要码匹配,就走它
    @app.errorhandler(404)
    def error_404(arg):
        return render_template('error.html',message='404错误')

# 6 全局标签
    @app.template_global()
    def sb(a1, a2):
        return a1 + a2
    在模板中使用:{{ sb(3,4) }}

# 7 全局过滤器
    @app.template_filter()
    def db(a1, a2, a3):
        return a1 + a2 + a3
    在模板中使用:{{ 1|db(2,3)}}


1 重点掌握before_request和after_request

2 注意有多个的情况,执行顺序,请求来的时候,顺序是从上往下,走的时候是顺序是从下往上

3 before_request请求拦截后(也就是有return值),response所有都执行

中间件(跟django中间件完全一样)

from flask import Flask
app = Flask(__name__)
@app.route('/')
def index():
    return 'Hello World!'

# 模拟中间件
class Md(object):
    def __init__(self,old_wsgi_app):
        self.old_wsgi_app = old_wsgi_app

    def __call__(self,  environ, start_response):
        print('开始之前')
        ret = self.old_wsgi_app(environ, start_response)
        print('结束之后')
        return ret

if __name__ == '__main__':
    #1我们发现当执行app.run方法的时候,最终执行run_simple,最后执行app(),也就是在执行app.__call__方法	
    #2 在__call__里面,执行的是self.wsgi_app().那我们希望在执行他本身的wsgi之前做点事情。
    #3 所以我们先用Md类中__init__,保存之前的wsgi,然后我们用将app.wsgi转化成Md的对象。
    #4 那执行新的的app.wsgi_app,就是执行Md的__call__方法。
    #把原来的wsgi_app替换为自定义的,
    
    app.wsgi_app = Md(app.wsgi_app)
    app.run()

猴子补丁

'''什么是猴子补丁?
只是一个概念,不属于任何包和模块
利用了python一切皆对象的理念,在程序运行过程中,动态修改方法
概念'''
class Monkey():
    def play(self):
        print('猴子在玩')


class Dog():
    def play(self):
        print('狗子在玩')

m=Monkey()
# m.play()
m.play=Dog().play

m.play()

'''有什么用?
这里有一个比较实用的例子,
很多用到import json,
后来发现ujson性能更高,
如果觉得把每个文件的import json改成import ujson as json成本较高,
或者说想测试一下ujson替换是否符合预期, 只需要在入口加上:

只需要在程序入口'''

import json
import ujson

def monkey_patch_json():
    json.__name__ = 'ujson'
    json.dumps = ujson.dumps
    json.loads = ujson.loads
monkey_patch_json()

aa=json.dumps({'name':'lqz','age':19})
print(aa)



#协程:单线程下实现并发
from gevent import monkey;monkey.patch_all()
import gevent
import time
def eat():
    print('eat food 1')
    time.sleep(2)
    print('eat food 2')

def play():
    print('play 1')
    time.sleep(1)
    print('play 2')

g1=gevent.spawn(eat)
g2=gevent.spawn(play)
gevent.joinall([g1,g2])
print('主')

蓝图

1 没有蓝图之前前,都是单文件

2 有了蓝图可以分文件,分app,之前的请求扩展还是一样用,只是在当前蓝图对象管理下的有效

3 蓝图使用
	#第一步在app中注册蓝图,括号里是一个蓝图对象
    app.register_blueprint(user.us)
	# 第二步,在不同文件中注册路由时,直接使用蓝图对象注册,不用使用app了,避免了循环导入的问题
    @account.route('/login.html', methods=['GET', "POST"])
    
4 中小型项目目录划分
	项目名字
    	-pro_flask文件夹
        -__init__.py
    	-templates
        	-login.html
        -statics
        	-code.png
        -views
        	-blog.py
        	-account.py
        	-user.py
        -run.py
        
5 大型项目
    项目名
    	-pro_flask文件夹
        	-__init__.py
            -web
            	-__init__.py
            	-static
                -views.py
                -templates
    		-admin
                -templates
                -static
                -views.py
                -__init__.py
        -run.py
 

threading.local

###############1 不用local,多线程写同一个数据,会导致错乱
    from threading import Thread
    import time
    lqz = -1
    def task(arg):
        global lqz
        lqz = arg
        time.sleep(2)
        print(lqz)

    for i in range(10):
        t = Thread(target=task,args=(i,))
        t.start()


################2 使用local对象,多线程写同一数据不会错乱,因为每个线程操作自己的数据
    from threading import Thread
    from threading import local
    import time
    from threading import get_ident
    # 特殊的对象
    lqz = local()
    # {'线程id':{value:1},'线程id':{value:2}....}
    def task(arg):
        lqz.value = arg
        time.sleep(2)
        print(lqz.value)
    for i in range(10):
        t = Thread(target=task,args=(i,))
        t.start()


#######3自己写一个类似local的东西,函数版本
    from threading import get_ident,Thread
    import time
    storage = {}
    #{'线程id':{value:1},'线程id':{value:2}....}
    def set(k,v):
        ident = get_ident()
        if ident in storage:
            storage[ident][k] = v
        else:
            storage[ident] = {k:v}
    def get(k):
        ident = get_ident()
        return storage[ident][k]
    def task(arg):
        set('val',arg)
        v = get('val')
        print(v)

    for i in range(10):
        t = Thread(target=task,args=(i,))
        t.start()



#######4自己写一个类似local的东西,面向对象版本
    from threading import get_ident,Thread
    import time
    class Local(object):
        storage = {}
        def set(self, k, v):
            ident = get_ident()
            if ident in Local.storage:
                Local.storage[ident][k] = v
            else:
                Local.storage[ident] = {k: v}
        def get(self, k):
            ident = get_ident()
            return Local.storage[ident][k]
    obj = Local()
    def task(arg):
        obj.set('val',arg)
        time.sleep(1)
        v = obj.get('val')

        print(v)
    for i in range(10):
        t = Thread(target=task,args=(i,))
        t.start()

# #######5自己写一个类似local的东西,面向对象支持 . 取值赋值
    from threading import get_ident,Thread
    import time
    class Local(object):
        storage = {}
        def __setattr__(self, k, v):
            ident = get_ident()
            if ident in Local.storage:
                Local.storage[ident][k] = v
            else:
                Local.storage[ident] = {k: v}
        def __getattr__(self, k):
            ident = get_ident()
            return Local.storage[ident][k]
    obj = Local()

    def task(arg):
        obj.val = arg
        time.sleep(1)
        print(obj.val)
    for i in range(10):
        t = Thread(target=task,args=(i,))
        t.start()


#######6  每次实例化得到一个local对象,用自己的字典存储
    from threading import get_ident,Thread
    import time
    class Local(object):
        def __init__(self):
           object.__setattr__(self,'storage',{})
           #  self.storage={}  # 这种方式不能用
        def __setattr__(self, k, v):
            ident = get_ident()
            if ident in self.storage:
                self.storage[ident][k] = v
            else:
                self.storage[ident] = {k: v}
        def __getattr__(self, k):
            ident = get_ident()
            return self.storage[ident][k]
    obj = Local()
    def task(arg):
        obj.val = arg
        time.sleep(1)
        print(obj.val)
    for i in range(10):
        t = Thread(target=task,args=(i,))
        t.start()

######7支持线程和协程
    try:
        from greenlet import getcurrent as get_ident
    except Exception as e:
        from threading import get_ident
    from threading import Thread
    import time
    class Local(object):
        def __init__(self):
            object.__setattr__(self,'storage',{})
        def __setattr__(self, k, v):
            ident = get_ident()
            if ident in self.storage:
    #             self.storage[ident][k] = v
    #         else:
    #             self.storage[ident] = {k: v}
        def __getattr__(self, k):
            ident = get_ident()
            return self.storage[ident][k]
    obj = Local()
    def task(arg):
        obj.val = arg
        # obj.xxx = arg

        print(obj.val)
    for i in range(10):
        t = Thread(target=task,args=(i,))
        t.start()

请求上下文执行流程

请求上下文执行流程(ctx):
		-0 flask项目一启动,有6个全局变量
			-_request_ctx_stack:LocalStack对象
			-_app_ctx_stack :LocalStack对象
			-request : LocalProxy对象
			-session : LocalProxy对象
		-1 请求来了 app.__call__()---->内部执行:self.wsgi_app(environ, start_response)
		-2 wsgi_app()
			-2.1 执行:ctx = self.request_context(environ):返回一个RequestContext对象,并且封装了request(当次请求的request对象),session
			-2.2 执行: ctx.push():RequestContext对象的push方法
				-2.2.1 push方法中中间位置有:_request_ctx_stack.push(self),self是ctx对象
				-2.2.2 去_request_ctx_stack对象的类中找push方法(LocalStack中找push方法)
				-2.2.3 push方法源码:
				    def push(self, obj):
						#通过反射找self._local,在init实例化的时候生成的:self._local = Local()
						#Local()flask封装的支持线程和协程的local对象
						# 一开始取不到stack,返回None
						rv = getattr(self._local, "stack", None)
						if rv is None:
							#走到这,self._local.stack=[],rv=self._local.stack
							self._local.stack = rv = []
						# 把ctx放到了列表中
						#self._local={'线程id1':{'stack':[ctx,]},'线程id2':{'stack':[ctx,]},'线程id3':{'stack':[ctx,]}}
						rv.append(obj)
						return rv
		-3 如果在视图函数中使用request对象,比如:print(request)
			-3.1 会调用request对象的__str__方法,request类是:LocalProxy
			-3.2 LocalProxy中的__str__方法:lambda x: str(x._get_current_object())
				-3.2.1 内部执行self._get_current_object()
				-3.2.2 _get_current_object()方法的源码如下:
				    def _get_current_object(self):
						if not hasattr(self.__local, "__release_local__"):
							#self.__local()  在init的时候,实例化的,在init中:object.__setattr__(self, "_LocalProxy__local", local)
							# 用了隐藏属性
							#self.__local 实例化该类的时候传入的local(偏函数的内存地址:partial(_lookup_req_object, "request"))
							#加括号返回,就会执行偏函数,也就是执行_lookup_req_object,不需要传参数了
							#这个地方的返回值就是request对象(当此请求的request,没有乱)
							return self.__local()
						try:
							return getattr(self.__local, self.__name__)
						except AttributeError:
							raise RuntimeError("no object bound to %s" % self.__name__)
				-3.2.3 _lookup_req_object函数源码如下:
					def _lookup_req_object(name):
						#name是'request'字符串
						#top方法是把第二步中放入的ctx取出来,因为都在一个线程内,当前取到的就是当次请求的ctx对象
						top = _request_ctx_stack.top
						if top is None:
							raise RuntimeError(_request_ctx_err_msg)
						#通过反射,去ctx中把request对象返回
						return getattr(top, name)
				-3.2.4 所以:print(request) 实质上是在打印当此请求的request对象的__str__
		-4 如果在视图函数中使用request对象,比如:print(request.method):实质上是取到当次请求的reuquest对象的method属性
		
		-5 最终,请求结束执行: ctx.auto_pop(error),把ctx移除掉
		
	其他的东西:
		-session:
			-请求来了opensession
				-ctx.push()---->也就是RequestContext类的push方法的最后的地方:
					if self.session is None:
						#self是ctx,ctx中有个app就是flask对象,   self.app.session_interface也就是它:SecureCookieSessionInterface()
						session_interface = self.app.session_interface
						self.session = session_interface.open_session(self.app, self.request)
						if self.session is None:
							#经过上面还是None的话,生成了个空session
							self.session = session_interface.make_null_session(self.app)
			-请求走了savesession
				-response = self.full_dispatch_request() 方法内部:执行了before_first_request,before_request,视图函数,after_request,savesession
				-self.full_dispatch_request()---->执行:self.finalize_request(rv)-----》self.process_response(response)----》最后:self.session_interface.save_session(self, ctx.session, response)
		-请求扩展相关
			before_first_request,before_request,after_request依次执行
		-flask有一个请求上下文,一个应用上下文
			-ctx:
				-是:RequestContext对象:封装了request和session
				-调用了:_request_ctx_stack.push(self)就是把:ctx放到了那个位置
			-app_ctx:
				-是:AppContext(self) 对象:封装了当前的app和g
				-调用 _app_ctx_stack.push(self) 就是把:app_ctx放到了那个位置
	-g是个什么鬼?
		专门用来存储用户信息的g对象,g的全称的为global 
		g对象在一次请求中的所有的代码的地方,都是可以使用的 
		
		
	-代理模式
		-request和session就是代理对象,用的就是代理模式

G对象是什么

#1 g是一个全局变量,在当前请求中可以放值,取值

#2 session对象是可以跨request的,只要session还未失效,不同的request的请求会获取到同一个session,但是g对象不是,g对象不需要管过期时间,请求一次就g对象就改变了一次,或者重新赋值了一次

flask-session

# 1 替换flask内置的session,支持存到redis,存到数据库

#2 flask-session如何使用
	方式一:
conn=redis.Redis(host='127.0.0.1',port=6379)
app.session_interface=RedisSessionInterface(conn,'lqz',permanent=False)
    方式二:
# from redis import Redis
# from flask.ext.session import Session
# app.config['SESSION_TYPE'] = 'redis'
#
# app.config['SESSION_KEY_PREFIX'] = 'lqz'
#
# app.config['SESSION_REDIS'] = Redis(host='127.0.0.1',port='6379')
# # 本质跟上面一样
# # 类似的用法在flask中很常见 函数(app)
# Session(app)


# 问题1
	-关闭浏览器cookie失效
    		app.session_interface=RedisSessionInterface(conn,key_prefix='lqz',permanent=False)
# 问题2 
	-cookie默认超时时间是多少?如何设置超时时间
    'PERMANENT_SESSION_LIFETIME':           timedelta(days=31),#这个配置文件控制

数据库连接池

#pip install DBUtils

import pymysql

from DBUtils.PooledDB import PooledDB
import time
from threading import Thread
POOL = PooledDB(
    creator=pymysql,  # 使用链接数据库的模块
    maxconnections=6,  # 连接池允许的最大连接数,0和None表示不限制连接数
    mincached=2,  # 初始化时,链接池中至少创建的空闲的链接,0表示不创建
    maxcached=5,  # 链接池中最多闲置的链接,0和None不限制
    maxshared=3,  # 链接池中最多共享的链接数量,0和None表示全部共享。PS: 无用,因为pymysql和MySQLdb等模块的 threadsafety都为1,所有值无论设置为多少,_maxcached永远为0,所以永远是所有链接都共享。
    blocking=True,  # 连接池中如果没有可用连接后,是否阻塞等待。True,等待;False,不等待然后报错
    maxusage=None,  # 一个链接最多被重复使用的次数,None表示无限制
    setsession=[],  # 开始会话前执行的命令列表。
    ping=0,
    # ping MySQL服务端,检查是否服务可用。
    host='127.0.0.1',
    port=3306,
    user='root',
    password='123',
    database='flask',
    charset='utf8'
)


def func():
    # 检测当前正在运行连接数的是否小于最大链接数,如果不小于则:等待或报raise TooManyConnections异常
    # 否则
    # 则优先去初始化时创建的链接中获取链接 SteadyDBConnection。
    # 然后将SteadyDBConnection对象封装到PooledDedicatedDBConnection中并返回。
    # 如果最开始创建的链接没有链接,则去创建一个SteadyDBConnection对象,再封装到PooledDedicatedDBConnection中并返回。
    # 一旦关闭链接后,连接就返回到连接池让后续线程继续使用。
    conn = POOL.connection()

    # print(th, '链接被拿走了', conn1._con)
    # print(th, '池子里目前有', pool._idle_cache, '\r\n')

    cursor = conn.cursor()
    cursor.execute('select * from boy')
    result = cursor.fetchall()
    time.sleep(2)
    print(result)
    conn.close()

if __name__ == '__main__':
    for i in range(10):
        t=Thread(target=func)
        t.start()



import pymysql
from settings import Config
class SQLHelper(object):

    @staticmethod
    def open(cursor):
        POOL = Config.PYMYSQL_POOL
        conn = POOL.connection()
        cursor = conn.cursor(cursor=cursor)
        return conn,cursor

    @staticmethod
    def close(conn,cursor):
        conn.commit()
        cursor.close()
        conn.close()

    @classmethod
    def fetch_one(cls,sql,args,cursor =pymysql.cursors.DictCursor):
        conn,cursor = cls.open(cursor)
        cursor.execute(sql, args)
        obj = cursor.fetchone()
        cls.close(conn,cursor)
        return obj

    @classmethod
    def fetch_all(cls,sql, args,cursor =pymysql.cursors.DictCursor):
        conn, cursor = cls.open(cursor)
        cursor.execute(sql, args)
        obj = cursor.fetchall()
        cls.close(conn, cursor)
        return obj
    @classmethod
    def execute(cls,sql, args,cursor =pymysql.cursors.DictCursor):
        conn, cursor = cls.open(cursor)
        cursor.execute(sql, args)
        cls.close(conn, cursor)

wtforms(forms组件)

1 校验数据
2 渲染标签
详见代码

#pip3 install wtforms
from flask import Flask, render_template, request, redirect
from wtforms import Form
from wtforms.fields import simple
from wtforms import validators
from wtforms import widgets

app = Flask(__name__, template_folder='templates')

app.debug = True


class LoginForm(Form):
    # 字段(内部包含正则表达式)
    name = simple.StringField(
        label='用户名',
        validators=[
            validators.DataRequired(message='用户名不能为空.'),
            validators.Length(min=6, max=18, message='用户名长度必须大于%(min)d且小于%(max)d')
        ],
        widget=widgets.TextInput(), # 页面上显示的插件
        render_kw={'class': 'form-control'}

    )
    # 字段(内部包含正则表达式)
    pwd = simple.PasswordField(
        label='密码',
        validators=[
            validators.DataRequired(message='密码不能为空.'),
            validators.Length(min=8, message='用户名长度必须大于%(min)d'),
            validators.Regexp(regex="^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[$@$!%*?&])[A-Za-z\d$@$!%*?&]{8,}",
                              message='密码至少8个字符,至少1个大写字母,1个小写字母,1个数字和1个特殊字符')

        ],
        widget=widgets.PasswordInput(),
        render_kw={'class': 'form-control'}
    )



@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'GET':
        form = LoginForm()
        return render_template('login.html', form=form)
    else:
        form = LoginForm(formdata=request.form)
        if form.validate():
            print('用户提交数据通过格式验证,提交的值为:', form.data)
        else:
            print(form.errors)
        return render_template('login.html', form=form)

if __name__ == '__main__':
    app.run()

#login.html
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
    <h1>登录</h1>
    <form method="post">
        <p>{{form.name.label}} {{form.name}} {{form.name.errors[0] }}</p>

        <p>{{form.pwd.label}} {{form.pwd}} {{form.pwd.errors[0] }}</p>
        <input type="submit" value="提交">
    </form>
    </body>
    </html>

    
#使用2
from flask import Flask, render_template, request, redirect
from wtforms import Form
from wtforms.fields import core
from wtforms.fields import html5
from wtforms.fields import simple
from wtforms import validators
from wtforms import widgets

app = Flask(__name__, template_folder='templates')
app.debug = True



class RegisterForm(Form):
    name = simple.StringField(
        label='用户名',
        validators=[
            validators.DataRequired()
        ],
        widget=widgets.TextInput(),
        render_kw={'class': 'form-control'},
        default='alex'
    )

    pwd = simple.PasswordField(
        label='密码',
        validators=[
            validators.DataRequired(message='密码不能为空.')
        ],
        widget=widgets.PasswordInput(),
        render_kw={'class': 'form-control'}
    )

    pwd_confirm = simple.PasswordField(
        label='重复密码',
        validators=[
            validators.DataRequired(message='重复密码不能为空.'),
            validators.EqualTo('pwd', message="两次密码输入不一致")
        ],
        widget=widgets.PasswordInput(),
        render_kw={'class': 'form-control'}
    )

    email = html5.EmailField(
        label='邮箱',
        validators=[
            validators.DataRequired(message='邮箱不能为空.'),
            validators.Email(message='邮箱格式错误')
        ],
        widget=widgets.TextInput(input_type='email'),
        render_kw={'class': 'form-control'}
    )

    gender = core.RadioField(
        label='性别',
        choices=(
            (1, '男'),
            (2, '女'),
        ),
        coerce=int # “1” “2”
     )
    city = core.SelectField(
        label='城市',
        choices=(
            ('bj', '北京'),
            ('sh', '上海'),
        )
    )

    hobby = core.SelectMultipleField(
        label='爱好',
        choices=(
            (1, '篮球'),
            (2, '足球'),
        ),
        coerce=int
    )

    favor = core.SelectMultipleField(
        label='喜好',
        choices=(
            (1, '篮球'),
            (2, '足球'),
        ),
        widget=widgets.ListWidget(prefix_label=False),
        option_widget=widgets.CheckboxInput(),
        coerce=int,
        default=[1, 2]
    )

    def __init__(self, *args, **kwargs):
        super(RegisterForm, self).__init__(*args, **kwargs)
        self.favor.choices = ((1, '篮球'), (2, '足球'), (3, '羽毛球'))

    def validate_pwd_confirm(self, field):
        """
        自定义pwd_confirm字段规则,例:与pwd字段是否一致
        :param field:
        :return:
        """
        # 最开始初始化时,self.data中已经有所有的值

        if field.data != self.data['pwd']:
            # raise validators.ValidationError("密码不一致") # 继续后续验证
            raise validators.StopValidation("密码不一致")  # 不再继续后续验证


@app.route('/register', methods=['GET', 'POST'])
def register():
    if request.method == 'GET':
        form = RegisterForm(data={'gender': 2,'hobby':[1,]}) # initial
        return render_template('register.html', form=form)
    else:
        form = RegisterForm(formdata=request.form)
        if form.validate():
            print('用户提交数据通过格式验证,提交的值为:', form.data)
        else:
            print(form.errors)
        return render_template('register.html', form=form)



if __name__ == '__main__':
    app.run()

#login.html
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
    <h1>用户注册</h1>
    <form method="post" novalidate style="padding:0  50px">
        {% for field in form %}
        <p>{{field.label}}: {{field}} {{field.errors[0] }}</p>
        {% endfor %}
        <input type="submit" value="提交">
    </form>
    </body>
    </html>

信号

1 semaphore跟线程的它没有半毛钱关系

2 signal翻译过来的,flask的signal

3 信号是同步操作

4 如何使用(内置的)
	######### 内置信号的使用
    ##第一步写一个函数(触发某些动作)
    # 往信号中注册函数
    def func(*args,**kwargs):
        print(args[0])  # 当前app对象
        print('触发信号',args,kwargs)
    # 第二步:函数跟内置信号绑定
    signals.request_started.connect(func)
    
5 自定义信号的使用
	# 自定义信号
    # #第一步:定义一个信号
    # xxxxx = _signals.signal('xxxxx')
    # # 第二步:定义一个函数
    # def func3(*args,**kwargs):
    #     import time
    #     time.sleep(1)
    #     print('触发信号',args,kwargs)
    # #第三步:信号跟函数绑定
    # xxxxx.connect(func3)

    #第四步:触发信号
    xxxxx.send(1,k='2')

多app应用(了解)

### 多个app实例(启用)
from werkzeug.wsgi import DispatcherMiddleware
from werkzeug.serving import run_simple
from flask import Flask, current_app
app1 = Flask('app01')
app2 = Flask('app02')

@app1.route('/index')
def index():
    return "app01"

@app2.route('/index2')
def index2():
    return "app2"

# http://www.oldboyedu.com/index
# http://www.oldboyedu.com/sec/index2
dm = DispatcherMiddleware(app1, {
    '/sec': app2,
})

if __name__ == "__main__":
    run_simple('localhost', 5000, dm)
    # 请求来了,会执行dm()--->__call__

flask-script(制定命令)

1 模拟出类似django的启动方式:python manage.py runserver

2 pip install flask-script

3 把excel的数据导入数据库,定制个命令,去执行(openpyxl)
	python manage.py insertdb -f xxx.excl -t aa
    
4 使用
	-方式一:python manage.py runserver
    from flask import Flask
    from flask_script import Manager
    app = Flask(__name__)
    manager=Manager(app)
    if __name__ == '__main__':
        manager.run()
    -方式二:自定制命令
        @manager.command
        def custom(arg):
            print(arg)
        @manager.option('-n', '--name', dest='name')
        @manager.option('-u', '--url', dest='url')
        def cmd(name, url):
            print(name, url)
            
5 创建超级用户

6 现在有一万条excel用户,批量导入到数据库中
	-navicate直接支持
    -脚本
    -flask-script

sqlalchemy

概念

1 sqlachemy:第三方orm框架(对象关系映射)
	-go 中gorm,xorm
    -python中:django orm,sqlachemy,peewee
    -老刘带你手写的:https://www.cnblogs.com/liuqingzheng/articles/9006025.html
        
2 django orm,只能在django中用,不能单独用

3 使用 pip install sqlachemy

4 SQLAlchemy本身无法操作数据库,其必须以来pymsql等第三方插件

5 补充:django orm反向生成models
	-python manage.py inspectdb > app/models.py

基本使用(原生sql)

import time
import threading
import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.engine.base import Engine

# 第一步生成一个engine对象
engine = create_engine(
    "mysql+pymysql://root:123@127.0.0.1:3306/flask?charset=utf8",
    max_overflow=0,  # 超过连接池大小外最多创建的连接
    pool_size=5,  # 连接池大小
    pool_timeout=30,  # 池中没有线程最多等待的时间,否则报错
    pool_recycle=-1  # 多久之后对线程池中的线程进行一次连接的回收(重置)
)

# 第二步:创建连接(执行原生sql)
conn = engine.raw_connection()

# 第三步:获取游标对象
cursor = conn.cursor()

# 第四步:具体操作
cursor.execute('select * from boy')

res=cursor.fetchall()
print(res)

# 比pymysql优势在,有数据库连接池

orm使用

# 创建一个个类(继承谁?字段怎么写)
import datetime
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base

# 字段和字段属性
from sqlalchemy import Column, Integer, String, Text, ForeignKey, DateTime, UniqueConstraint, Index

# 制造了一个类,作为所有模型类的基类
Base = declarative_base()

class User(Base):
    __tablename__ = 'users'  # 数据库表名称(固定写法),如果不写,默认以类名小写作为表的名字
    id = Column(Integer, primary_key=True)  # id 主键
    # mysql中主键自动建索引:聚簇索引
    # 其他建建的索引叫:辅助索引
    name = Column(String(32), index=True, nullable=False)  # name列,索引,不可为空
    # email = Column(String(32), unique=True)  # 唯一
    # #datetime.datetime.now不能加括号,加了括号,以后永远是当前时间
    # ctime = Column(DateTime, default=datetime.datetime.now) # default默认值
    # extra = Column(Text, nullable=True)

    #类似于djagno的 Meta
    # __table_args__ = (
    #     UniqueConstraint('id', 'name', name='uix_id_name'), #联合唯一
    #     Index('ix_id_name', 'name', 'email'), #索引
    # )



# 创建表
def create_table():
    # 创建engine对象
    engine = create_engine(
        "mysql+pymysql://root:123@127.0.0.1:3306/aaa?charset=utf8",
        max_overflow=0,  # 超过连接池大小外最多创建的连接
        pool_size=5,  # 连接池大小
        pool_timeout=30,  # 池中没有线程最多等待的时间,否则报错
        pool_recycle=-1  # 多久之后对线程池中的线程进行一次连接的回收(重置)
    )
    # 通过engine对象创建表
    Base.metadata.create_all(engine)

# 删除表
def drop_table():
    # 创建engine对象
    engine = create_engine(
        "mysql+pymysql://root:123@127.0.0.1:3306/aaa?charset=utf8",
        max_overflow=0,  # 超过连接池大小外最多创建的连接
        pool_size=5,  # 连接池大小
        pool_timeout=30,  # 池中没有线程最多等待的时间,否则报错
        pool_recycle=-1  # 多久之后对线程池中的线程进行一次连接的回收(重置)
    )
    # 通过engine对象删除所有表
    Base.metadata.drop_all(engine)

if __name__ == '__main__':
    # create_table()
    drop_table()

# 创建库?手动创建库
# 问题,sqlachemy支持修改字段吗?不支持

线程安全

#基于scoped_session实现线程安全
from sqlalchemy.orm import sessionmaker
from sqlalchemy import create_engine
from models import User  # pycharm报错,不会影响我们
from sqlalchemy.orm import scoped_session

# 1 制作engine
engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/aaa", max_overflow=0, pool_size=5)

# 2 制造一个 session 类(会话)
Session = sessionmaker(bind=engine)    # 得到一个类

# 3 得到一个session对象(线程安全的session)
#现在的session已经不是session对象了
#为什么线程安全,还是用的local
session = scoped_session(Session)

# session=Session()

# 4 创建一个对象
obj1 = User(name="2008")

# 5 把对象通过add放入
session.add(obj1)
# session.aaa()

# 6 提交
session.commit()
session.close()


# 类不继承Session类,但是有该类的所有方法(通过反射,一个个放进去)

# scoped_session.add------->instrument(name)--->do函数内存地址---》现在假设我要这么用:session.add()--->do()
# scoped_session.close----->instrument(name)--->do函数内存地址

基本的增删查改

from sqlalchemy.orm import sessionmaker
from sqlalchemy import create_engine
from models import User,Person,Hobby
from sqlalchemy.orm import scoped_session
from sqlalchemy.sql import text
engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/aaa", max_overflow=0, pool_size=5)

Session = sessionmaker(bind=engine)
# session = scoped_session(Session)
session=Session()

####1 新增多个对象
# obj=User(name='xxx')
# obj2=User(name='yyyy')
# obj3=User(name='zzz')
#新增同样对象
# session.add_all([obj,obj2,obj3])
#新增不同对象
# session.add_all([Person(name='lqz'),Hobby()])

####2 简单删除(查到删除)
# res=session.query(User).filter_by(name='2008').delete()
# res=session.query(User).filter(User.id>=2).delete()
# # 影响1行
# print(res)

#### 3 修改
# res=session.query(User).filter_by(id=1).update({User.name:'ccc'})
# res=session.query(User).filter_by(id=1).update({'name':'ccc'})

# session.query(User).filter(User.id > 0).update({User.name: User.name + "099"}, synchronize_session=False) # 如果要把它转成字符串相加
# session.query(User).filter(User.id > 0).update({"age": User.age + 1}, synchronize_session="evaluate")  ## 如果要把它转成数字相加


####4 基本查询操作

# res=session.query(User).all()
# print(type(res))
# res=session.query(User).first()
# print(res)

#filter传的是表达式,filter_by传的是参数
# res=session.query(User).filter(User.id==1).all()
# res=session.query(User).filter(User.id>=1).all()
# res=session.query(User).filter(User.id<1).all()

# res=session.query(User).filter_by(name='ccc099').all()


#了解
# res = session.query(User).from_statement(text("SELECT * FROM users where name=:name")).params(name='ccc099').all()
# print(res)


session.commit()
# 并没有真正关闭连接,而是放回池中
session.close()

高级操作

from sqlalchemy.orm import sessionmaker
from sqlalchemy import create_engine
from models import User,Person,Hobby
from sqlalchemy.sql import text
engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/aaa", max_overflow=0, pool_size=5)
Session = sessionmaker(bind=engine)
session=Session()


# 1 查询名字为lqz的所有user对象
# ret = session.query(User).filter_by(name='ccc099').all()

# 2 表达式,and条件连接
# ret = session.query(User).filter(User.id > 1, User.name == 'egon').all()
# 查找id在1和10之间,并且name=egon的对象
# ret = session.query(User).filter(User.id.between(1, 10), User.name == 'egon').all()

# in条件(class_,因为这是关键字,不能直接用)
# ret = session.query(User).filter(User.id.in_([1,3,4])).all()

# 取反 ~
ret = session.query(User).filter(~User.id.in_([1,3,4])).all()

#二次筛选
# select *
# ret = session.query(User).filter(User.id.in_(session.query(User.id).filter_by(name='egon'))).all()
# # select name,id 。。。。
# ret = session.query(User.id,User.name).filter(User.id.in_(session.query(User.id).filter_by(name='egon'))).all()

'''
SELECT users.id AS users_id, users.name AS users_name 
FROM users 
WHERE users.id IN (SELECT users.id AS users_id 
FROM users 
WHERE users.name = %(name_1)s)

'''


#
from sqlalchemy import and_, or_
#or_包裹的都是or条件,and_包裹的都是and条件
#查询id>3并且name=egon的人
# ret = session.query(User).filter(and_(User.id > 3, User.name == 'egon')).all()

# 查询id大于2或者name=ccc099的数据
# ret = session.query(User).filter(or_(User.id > 2, User.name == 'ccc099')).all()
# ret = session.query(User).filter(
#     or_(
#         User.id < 2,
#         and_(User.name == 'egon', User.id > 3),
#         User.extra != ""
#     )).all()
# print(ret)

'''
select *from user where id<2 or (name=egon and id >3) or extra !=''
'''


# 通配符,以e开头,不以e开头
# ret = session.query(User).filter(User.name.like('e%')).all()
# ret = session.query(User).filter(~User.name.like('e%')).all()

# 限制,用于分页,区间 limit
# 前闭后开区间,1能取到,3取不到
ret = session.query(User)[1:3]

'''
select * from users limit 1,2;
'''


# 排序,根据name降序排列(从大到小)
# ret = session.query(User).order_by(User.name.desc()).all()
# ret = session.query(User).order_by(User.name.asc()).all()
#第一个条件降序排序后,再按第二个条件升序排
# ret = session.query(User).order_by(User.id.asc(),User.name.desc()).all()
# ret = session.query(User).order_by(User.name.desc(),User.id.asc()).all()


# 分组
from sqlalchemy.sql import func

# ret = session.query(User).group_by(User.name).all()
#分组之后取最大id,id之和,最小id
# sql 分组之后,要查询的字段只能有分组字段和聚合函数
# ret = session.query(
#     func.max(User.id),
#     func.sum(User.id),
#     func.min(User.id),
#     User.name).group_by(User.name).all()
# '''
# select max(id),sum(id),min(id) from user group by name;
#
# '''
# for obj in ret:
#     print(obj[0],'----',obj[1],'-----',obj[2],'-----',obj[3])
# print(ret)

#haviing筛选
# ret = session.query(
#     func.max(User.id),
#     func.sum(User.id),
#     func.min(User.id)).group_by(User.name).having(func.min(User.id) >2).all()

'''
select max(id),sum(id),min(id) from user group by name having min(id)>2;

'''
print(ret)
session.commit()

session.close()

多表操作

from sqlalchemy.orm import sessionmaker
from sqlalchemy import create_engine
from models import User,Person,Hobby,Boy,Girl,Boy2Girl
from sqlalchemy.sql import text
engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/aaa", max_overflow=0, pool_size=5)
Session = sessionmaker(bind=engine)
session=Session()



###  1 一对多插入数据
# obj=Hobby(caption='足球')
# session.add(obj)
# p=Person(name='张三',hobby_id=2)
# session.add(p)

### 2 方式二(默认情况传对象有问题)
###### Person表中要加 hobby = relationship('Hobby', backref='pers')
# p=Person(name='李四',hobby=Hobby(caption='美女'))
# 等同于
# p=Person(name='李四2')
# p.hobby=Hobby(caption='美女2')
# session.add(p)

## 3 方式三,通过反向操作
# hb = Hobby(caption='人妖')
# hb.pers = [Person(name='文飞'), Person(name='博雅')]
# session.add(hb)


#### 4 查询(查询:基于连表的查询,基于对象的跨表查询)
### 4.1 基于对象的跨表查询(子查询,两次查询)
# 正查
# p=session.query(Person).filter_by(name='张三').first()
# print(p)
# print(p.hobby.caption)
# 反查
# h=session.query(Hobby).filter_by(caption='人妖').first()
# print(h.pers)

### 4.2 基于连表的跨表查(查一次)
# 默认根据外键连表
# isouter=True 左外连,表示Person left join Hobby,没有右连接,反过来即可
# 不写 inner join
# person_list=session.query(Person,Hobby).join(Hobby,isouter=True).all()
# print(person_list)
# print(person_list)
# for row in person_list:
#     print(row[0].name,row[1].caption)

# '''
# select * from person left join hobby on person.hobby_id=hobby.id
# '''
#
# ret = session.query(Person, Hobby).filter(Person.hobby_id == Hobby.id)
# print(ret)
# '''
# select * from user,hobby where user.id=favor.nid;
#
# '''


#join表,默认是inner join
# ret = session.query(Person).join(Hobby)
# # ret = session.query(Hobby).join(Person,isouter=True)
# '''
# SELECT *
# FROM person INNER JOIN hobby ON hobby.id = person.hobby_id
# '''
# print(ret)


# 指定连表字段(从来没用过)
# ret = session.query(Person).join(Hobby,Person.nid==Hobby.id, isouter=True)
# # ret = session.query(Person).join(Hobby,Person.hobby_id==Hobby.id, isouter=True).all()
# print(ret)
'''
SELECT *
FROM person LEFT OUTER JOIN hobby ON person.nid = hobby.id

'''

# print(ret)




# 组合(了解)UNION 操作符用于合并两个或多个 SELECT 语句的结果集
# union和union all的区别?
# q1 = session.query(User.name).filter(User.id > 2)  # 6条数据
# q2 = session.query(User.name).filter(User.id < 8) # 2条数据


# q1 = session.query(User.id,User.name).filter(User.id > 2)  # 6条数据
# q2 = session.query(User.id,User.name).filter(User.id < 8) # 2条数据
# ret = q1.union_all(q2).all()
# ret1 = q1.union(q2).all()
# print(ret)
# print(ret1)
#
# q1 = session.query(User.name).filter(User.id > 2)
# q2 = session.query(Hobby.caption).filter(Hobby.nid < 2)
# ret = q1.union_all(q2).all()







#### 多对多

# session.add_all([
#     Boy(hostname='霍建华'),
#     Boy(hostname='胡歌'),
#     Girl(name='刘亦菲'),
#     Girl(name='林心如'),
# ])
# session.add_all([
#     Boy2Girl(girl_id=1, boy_id=1),
#     Boy2Girl(girl_id=2, boy_id=1)
# ])


##### 要有girls = relationship('Girl', secondary='boy2girl', backref='boys')
# girl = Girl(name='张娜拉')
# girl.boys = [Boy(hostname='张铁林'),Boy(hostname='费玉清')]
# session.add(girl)

# boy=Boy(hostname='蔡徐坤')
# boy.girls=[Girl(name='谢娜'),Girl(name='巧碧螺')]
# session.add(boy)
# session.commit()


# 基于对象的跨表查

# girl=session.query(Girl).filter_by(id=3).first()
# print(girl.boys)

#### 基于连表的跨表查询

# 查询蔡徐坤约过的所有妹子
'''
select girl.name from girl,boy,Boy2Girl where boy.id=Boy2Girl.boy_id and girl.id=Boy2Girl.girl_id where boy.name='蔡徐坤'

'''
# ret=session.query(Girl.name).filter(Boy.id==Boy2Girl.boy_id,Girl.id==Boy2Girl.girl_id,Boy.hostname=='蔡徐坤').all()

'''
select girl.name from girl inner join Boy2Girl on girl.id=Boy2Girl.girl_id inner join boy on boy.id=Boy2Girl.boy_id where boy.hostname='蔡徐坤'

'''
# ret=session.query(Girl.name).join(Boy2Girl).join(Boy).filter(Boy.hostname=='蔡徐坤').all()
ret=session.query(Girl.name).join(Boy2Girl).join(Boy).filter_by(hostname='蔡徐坤').all()
print(ret)


### 执行原生sql(用的最多的)
### django中orm如何执行原生sql
#
# cursor = session.execute('insert into users(name) values(:value)',params={"value":'xxx'})
# print(cursor.lastrowid)
# session.commit()

session.close()

models.py



# 创建一个个类(继承谁?字段怎么写)
import datetime
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
# 字段和字段属性
from sqlalchemy import Column, Integer, String, Text, ForeignKey, DateTime, UniqueConstraint, Index
from sqlalchemy.orm import relationship
# 制造了一个类,作为所有模型类的基类
Base = declarative_base()

class User(Base):
    __tablename__ = 'users'  # 数据库表名称(固定写法),如果不写,默认以类名小写作为表的名字
    id = Column(Integer, primary_key=True)  # id 主键
    # mysql中主键自动建索引:聚簇索引
    # 其他建建的索引叫:辅助索引
    name = Column(String(32), index=True, nullable=False)  # name列,索引,不可为空
    # email = Column(String(32), unique=True)  # 唯一
    # #datetime.datetime.now不能加括号,加了括号,以后永远是当前时间
    # ctime = Column(DateTime, default=datetime.datetime.now) # default默认值
    # extra = Column(Text, nullable=True)

    #类似于djagno的 Meta
    # __table_args__ = (
    #     UniqueConstraint('id', 'name', name='uix_id_name'), #联合唯一
    #     Index('ix_id_name', 'name', 'email'), #索引
    # )
    def __str__(self):
        return self.name
    def __repr__(self):
        # python是强类型语言
        return self.name+str(self.id)




# 一对多关系

# 一个Hobby可以有很多人喜欢
# 一个人只能由一个Hobby
class Hobby(Base):
    __tablename__ = 'hobby'
    id = Column(Integer, primary_key=True)
    caption = Column(String(50), default='篮球')


class Person(Base):
    __tablename__ = 'person'
    nid = Column(Integer, primary_key=True)
    name = Column(String(32), index=True, nullable=True)
    # hobby指的是tablename而不是类名,uselist=False
    # 一对多的关系,关联字段写在多的一方
    hobby_id = Column(Integer, ForeignKey("hobby.id"))  # 默认可以为空

    # 跟数据库无关,不会新增字段,只用于快速链表操作
    # 类名,backref用于反向查询
    hobby = relationship('Hobby', backref='pers')


# 多对多关系
# 实实在在存在的表
class Boy2Girl(Base):
    __tablename__ = 'boy2girl'
    id = Column(Integer, primary_key=True, autoincrement=True) # autoincrement自增,默认是True
    girl_id = Column(Integer, ForeignKey('girl.id'))
    boy_id = Column(Integer, ForeignKey('boy.id'))



class Girl(Base):
    __tablename__ = 'girl'
    id = Column(Integer, primary_key=True)
    name = Column(String(64), unique=True, nullable=False)


class Boy(Base):
    __tablename__ = 'boy'

    id = Column(Integer, primary_key=True, autoincrement=True)
    hostname = Column(String(64), unique=True, nullable=False)

    # 与生成表结构无关,仅用于查询方便,放在哪个单表中都可以
    # secondary 通过哪个表建关联,跟django中的through一模一样
    girls = relationship('Girl', secondary='boy2girl', backref='boys')

# 创建表
def create_table():
    # 创建engine对象
    engine = create_engine(
        "mysql+pymysql://root:123@127.0.0.1:3306/aaa?charset=utf8",
        max_overflow=0,  # 超过连接池大小外最多创建的连接
        pool_size=5,  # 连接池大小
        pool_timeout=30,  # 池中没有线程最多等待的时间,否则报错
        pool_recycle=-1  # 多久之后对线程池中的线程进行一次连接的回收(重置)
    )
    # 通过engine对象创建表
    Base.metadata.create_all(engine)

# 删除表
def drop_table():
    # 创建engine对象
    engine = create_engine(
        "mysql+pymysql://root:123@127.0.0.1:3306/aaa?charset=utf8",
        max_overflow=0,  # 超过连接池大小外最多创建的连接
        pool_size=5,  # 连接池大小
        pool_timeout=30,  # 池中没有线程最多等待的时间,否则报错
        pool_recycle=-1  # 多久之后对线程池中的线程进行一次连接的回收(重置)
    )
    # 通过engine对象删除所有表
    Base.metadata.drop_all(engine)

if __name__ == '__main__':
    create_table()  # 原来已经存在user表,再执行一次不会有问题
    # drop_table()

# 创建库?手动创建库
# 问题,sqlachemy支持修改字段吗?不支持

Flask-SQLAlchemy

1 Flask-SQLAlchemy

2 flask-migrate
    -python3 manage.py db init 初始化:只执行一次
    -python3 manage.py db migrate 等同于 makemigartions
    -python3 manage.py db upgrade 等同于migrate
    
3 看代码

4 Flask-SQLAlchemy如何使用
	1 from flask_sqlalchemy import SQLAlchemy
	2 db = SQLAlchemy()
    3 db.init_app(app)
    4 以后在视图函数中使用
    	-db.session 就是咱们讲的session
        
5 flask-migrate的使用(表创建,字段修改)
	1 from flask_migrate import Migrate,MigrateCommand
    2 Migrate(app,db)
	3 manager.add_command('db', MigrateCommand)
    
6 直接使用
    -python3 manage.py db init 初始化:只执行一次,创建migrations文件夹
    -python3 manage.py db migrate 等同于 makemigartions
    -python3 manage.py db upgrade 等同于migrate
	
posted @ 2020-10-15 18:03  Joab-0429  阅读(190)  评论(0编辑  收藏  举报