目录
回顾
1.蓝图
第一步：导入
第二步：实例化的得到的对象，可以指定static和templates
第三步：app中注册蓝图，注册蓝图时，可以指定前缀
第四步：使用蓝图，注册路由，注册请求扩展
2.g对象
当次请求的全局对象，在当次请求中可以放值和取值
跟session的区别是：
g对象是当次请求
session是多次请求
3.flask中使用mysql数据库
pymysql，在一个视图函数中，创建一个连接对象，操作，操作完就关闭连接
连接对象不要用单例，可能会出现数据错乱问题
4.数据库连接池
dbutils
使用步骤：
1.第一步：导入，实例化得到一个对象，pool
2.第二步：pool做成单例，以模块导入、
3.第三步：从pool中拿到一个连接 pool.connection()
4.第四步：使用连接获得游标，使用游标操作数据库
django中没有数据库连接池，可以使用第三方
请求上下文分析(源码：request原理)
导出项目的依赖 pipreqs
之前 pip freeze > requirments.txt 把当前解释器环境下的所有第三方依赖都导出来
使用第三方模块，更精准的导出依赖，pipreqs
第一步：安装 pip install pipreqs
第二步：使用命令，导出项目依赖， pipreqs ./
windows由于编码问题会出错：pipreqs ./ --encoding=utf8
mac、linux中没有问题
第三步：就会在项目根路径下生成：requirements.txt
函数和方法
isinstance 判断一个对象，是不是一个类的对象
issubclass 判断一个类，是不是另一个类的子类
class Foo(object):
def fetch(self):
pass
@classmethod
def test(cls):
pass
@staticmethod
def test1():
pass
a=Foo()
print(isinstance(a,Foo))
print(isinstance('a',Foo))
class Foo2(Foo):
pass
class Foo3():
pass
print(issubclass(Foo2,Foo))
print(issubclass(Foo3,Foo))
如何区分是方法还是函数？
只要会自动传值，就是方法；函数，有几个值就要传几个值，否则报错
函数：就是普通的函数，有几个参数就要传几个参数
方法：绑定给对象的方法，绑定给类的方法，绑定给谁的，由谁来调用，会自动把自身传入
例如：
类的绑定方法，对象可以来调用，会自动把类传入
对象的绑定方法，类可以来调用嘛？
类可以调用，但是它就是变成了普通函数，有几个值，就要传几个值，没有自动传值了
MethodType 检查一个对象，是不是方法
FunctionType 检查一个对象，是不是函数
from type import MethodType, FunctionType
class Foo(object):
def fetch(self):
pass
@classmethod
def test(cls):
pass
@staticmethod
def test1():
pass
def add():
pass
# 类来调用对象的绑定方法，
print(isinstance(Foo.fetch, MethodType)) # False 类来调用对象的绑定方法，该方法就变成了普通函数
obj = Foo()
print(isinstance(obj.fetch, MethodType)) # True 对象来调用自己的绑定方法，fetch就是方法
print(isinstance(Foo.fetch, FunctionType)) # True 类来调用对象的绑定方法，该方法就变成了普通函数
print(isinstance(add, FunctionType)) # True 就是个普通函数
print(isinstance(add, MethodType)) # False 就是个普通函数
print(isinstance(Foo.test, MethodType)) # True test 是绑定给类的方法，类来调用，就是方法
print(isinstance(obj.test, MethodType)) # True 对象调用类的绑定方法，还是方法
print(isinstance(Foo.test1, MethodType)) # False 是普通函数
print(isinstance(obj.test1, MethodType)) # False 是普通函数
print(isinstance(obj.test1, FunctionType)) # True，静态方法，就是普通函数，对象和类都可以调用，有几个值就传几个值
threading.local对象
数据错乱
使用互斥锁解决安全并发问题，并行变串行保证了数据安全
用local对象不会出现并发安全问题，
local 对象是在threading里的
并发编程是，多个线程操作同一个变量，会出现并发安全问题，咱们需要加锁
使用local对象，多线程操作时，不需要加锁，不会出现数据错乱threading.local
其他语言中也有这个东西ThreadLocal，java中面试会被经常问到，而python没有人问
本质原理：
多个线程修改同一个数据，复制多份变量给每个线程用，为每个线程开辟空间进行数据存储。
每个线程操作自己的那部分数据
偏函数
可以提前传值
from functools import partial
def add(a,b,c):
return a+b+c
# print(add(1,3,6)) # 少传了报错
现在只有一个参数，后的两参数，需要过一会才知道
借助于偏函数，先提前给他把第一个参数传入，后面知道了后面两参数，再传后面俩
add = partial(add,2)
print(add(3,4))
flask整个生命执行流程(1.1.4版本为例)
# 请求来了---》app()----->Flask.__call__--->self.wsgi_app(environ, start_response)
def wsgi_app(self, environ, start_response):
# environ:http请求拆成了字典
# ctx对象：RequestContext类的对象，对象里有：当次的requets对象，app对象，session对象
ctx = self.request_context(environ)
error = None
try:
try:
#ctx RequestContext类 push方法
ctx.push()
# 匹配成路由后，执行视图函数
response = self.full_dispatch_request()
except Exception as e:
error = e
response = self.handle_exception(e)
except:
error = sys.exc_info()[1]
raise
return response(environ, start_response)
finally:
if self.should_ignore_error(error):
error = None
ctx.auto_pop(error)
# RequestContext :ctx.push
def push(self):
# _request_ctx_stack = LocalStack() ---》push(ctx对象)--》ctx:request，session，app
_request_ctx_stack.push(self)
#session相关的
if self.session is None:
session_interface = self.app.session_interface
self.session = session_interface.open_session(self.app, self.request)
if self.session is None:
self.session = session_interface.make_null_session(self.app)
# 路由匹配相关的
if self.url_adapter is not None:
self.match_request()
# LocalStack() push --->obj 是ctx对象
def push(self, obj):
#self._local _local 就是咱们刚刚自己写的Local的对象---》LocalStack的init初始化的_local---》self._local = Local()---》Local对象可以根据线程协程区分数据
rv = getattr(self._local, "stack", None)
# 一开始没有值
if rv is None:
rv = []
self._local.stack = rv # self._local.stack 根据不同线程用的是自己的数据
rv.append(obj) # self._local.stack.append(obj)
# {'线程id号'：{stack：[ctx]},'线程id号2'：{stack：[ctx]}}
return rv
# 再往后执行，就会进入到路由匹配，执行视图函数
# request = LocalProxy(partial(_lookup_req_object, "request"))
# LocalProxy 代理类---》method---》代理类去当前线程的stack取出ctx，取出当时放进去的request
视图函数中：print(request.method)
# print(request) 执行LocalProxy类的__str__方法
# request.method 执行LocalProxy类的__getattr__
def __getattr__(self, name): #name 是method
# self._get_current_object() 就是当次请求的request
return getattr(self._get_current_object(), name)
# LocalProxy类的方法_get_current_object
def _get_current_object(self):
if not hasattr(self.__local, "__release_local__"):
return self.__local()
try:
return getattr(self.__local, self.__name__)
except AttributeError:
raise RuntimeError("no object bound to %s" % self.__name__)
# self.__local 是在 LocalProxy 类实例化的时候传入的local
# 在这里实例化的：request = LocalProxy(partial(_lookup_req_object, "request"))
# local 是 partial(_lookup_req_object, "request")
#_lookup_req_object ，name=request
def _lookup_req_object(name):
top = _request_ctx_stack.top # 取出了ctx，是当前线程的ctx
if top is None:
raise RuntimeError(_request_ctx_err_msg)
return getattr(top, name) #从ctx中反射出request，当次请求的request
wtforms(了解)
Django中有forms组件：生成前端模板，校验数据，渲染错误信息
flask中使用第三方的问题forms，实现Django的forms一样的功能
第一步：导入，定义一个类，继承forms
第二步：模板中，for循环生成模板
第三步：视图函数中，使用form校验数据
py代码
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()
html代码
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<h1>登录</h1>
<form method="post" novalidate>
<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>
补充
进程：进程是资源分配的最小单位，一个应用程序运行，至少会开启一个进程
线程：线程是cpu调度的最小单位，CPU执行的的最小单位
协程：单线程下实现并发，代码层面遇到IO，自己切换
environ就是http请求的字典对象
