flask学习笔记2

• 内容回顾

1 你怎么看面相对象？

　a 三大特性：封装，继承，多态

　　封装：1 对处理同一类问题的函数进行封装  (模块封装，类封装)

　　　　　2 对数据进行封装：多个形参封装到类中；对形参进行加工。

　　继承：多个类中有相同的代码，减少代码的冗余

　　多态：多种形态

class C1(object):
    def send(self):
        pass
class C2(object):
    def send(self):
        pass
#把C1和C2的两个类的实例当做形参传入
def f1(arg):
    arg.send()
#只要能有send方法执行  就是多态，不管对象是实例化的什么类

b:常用的双下划线的方法

　　__init__ #类加括号 实例化对象时执行

__call__	#对象加括号时执行
__str__		#把实例变成一个str时候
__dict__	#是用来存储对象属性的一个字典，其键为属性名，值为属性的值
__enter__	#with语句是提供一个有效的机制，让代码更简练，同时在异常产生时，清理工作更简单
__exit__	#处理with后的关闭操作，处理异常
__del__		#析构函数
__new__		#__new__方法接受的参数虽然也是和__init__一样，但__init__是在类实例创建之后调用，而 __new__方法正是创建这个类实例的方法
__name__	#类的名字
__setattr__	#obj.name = value 
__setitem__	#obj['name']
__doc__		#"""this is XXX"""  注释部分

 

#!/usr/bin/env python

class Sample:
    def __enter__(self):
        print "In __enter__()"
        return "Foo"

    def __exit__(self, type, value, trace):
        print "In __exit__()"
def get_sample():
    return Sample()
with get_sample() as sample:
    print "sample:", sample

　　

c:metaclass 类是由type创建的

　　

#创建类的两种方式
class Myobj(object):
    def __init__(self):
        pass
#创建类的方式2
Myobj2=type('Myobj2',(object,),{})
print(Myobj)
print(Myobj2)



#####################
class MyType(type):
    def __init__(self,*args,**kwargs):
        print('this is  mytype init.')
        super(MyType,self).__init__(*args,**kwargs)
#metaclass 默认为type
class Foo(metaclass=MyType):
    pass

2 根据字符串导入模块

import importlib
importlib.import_module()

3装饰器 被装饰装饰的函数，它的函数名会发生改变，保留被装饰的函数的函数名的方法

#测试装饰器
import functools
def outer(func):
    @functools.wraps(func)
    def inner(*args,**kwargs):
        return func(*args,**kwargs)
    return inner
@outer
def index(args):
    print('this is index')
@outer
def login(args):
    print('this is login.')
print(index.__name__)
print(login.__name__)

flask 把session设置放到redis缓存中

　　pip3 install flask-session

　　pip3 install redis

from flask import Flask,session

app = Flask(__name__)
app.secret_key = "adfasdf"


# 将session放置到redis中
from flask.ext.session import Session
from redis import Redis
app.config['SESSION_TYPE'] = 'redis'
app.config['SESSION_REDIS'] = Redis(host='192.168.0.94',port='6379',password='xxxx')
Session(app)

# app.session_interface = SecureCookieSessionInterface()() # open_session(self, request)
# app.session_interface = RedisSessionInterface() # open_session(self, request)


@app.route('/login')
def login():
    # {sid: 'sefw3rsdfsdf','user_info':xxxxxx }
    session['user_info'] = 'xxxxx'
    return 'login'

@app.route('/index')
def index():
    print(session['user_info'])
    return 'index'



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

flask blueprint

　　目录结构

　 

　　1 创建一个和项目名称一样的package

　　2 manage.py  为启动项目的run() 方法

　　3  __init__.py 中实例化Flask对象，引入并注册实例化blueprint的对象。

　　4  views为blueprint的实例对象目录

　　5 templates 为模板目录

　　6 static为静态文件目录

　　

from mypro_flask import myapp
if __name__ == '__main__':
    myapp.run()

from flask import Flask
from mypro_flask.views import account
from mypro_flask.views import user
myapp=Flask(__name__,)
myapp.secret_key='sakula123aasdsad'

myapp.register_blueprint(account.ac)
myapp.register_blueprint(user.u)

from flask import Blueprint
u=Blueprint('u',__name__,url_prefix='/xx')
@u.route('/index')
def user():
    return 'this is index page.'

from flask import Blueprint,render_template,request,redirect,session
import functools
ac=Blueprint('ac',__name__)

@ac.route('/login',)
def login():
   return render_template('login.html')

flask 闪现

 

from flask import flash,Flask,session,get_flashed_messages
app=Flask(__name__)
app.secret_key='aa123'
@app.route('/login')
def login():
    session['lover']='sakula'
    flash('this is flash1.',category='k1')
    flash('this si flash2',category='k2')
    return 'login'
@app.route('/index')
def index():
    data=get_flashed_messages(category_filter=['k1'])
    data2=get_flashed_messages(category_filter=('k2'))
    print(data)
    print(data2)
    #print(session.get('lover'))
    #print(session.pop('lover'))
    return 'index'
if __name__ == '__main__':
    app.run()

flask  中间件？

 

 flask 上下文管理

　　a:threading.local 作用：可以为每个线程创建一个独立的空间，让它存放数据

　　

import time
import threading

def f1(arg):
    obj1=threading.local()
    obj1.value=arg
    time.sleep(2)
    print(obj1.value)
for i in range(10):
    t=threading.Thread(target=f1,args=(i,))
    t.start()

　　b:偏函数   flask中多处应用偏函数

　　　

import functools

def func(a1,a2,a3):
    return a1 + a2 + a3

f1 = functools.partial(func,111)
print(f1(22,33))

# ###########################
import functools
class RequestContext(object):
    def __init__(self):
        self.request = "xxxxx"
        self.session = "iusdkfjlskdf"

obj = RequestContext()
# obj.request
# obj.session



def get_data(name):
    return getattr(obj,name)

request_proxy = functools.partial(get_data,'request')
session_proxy = functools.partial(get_data,'session')

request = request_proxy()
print(request)

session = session_proxy()
print(session)

　　c:flask中的__setattr__,__getattr__,threading.get_ident 即线程的唯一标识的应用

　　

__setattr__和object.__setattr__(self,'__storage__',{})
from threading import get_ident

class Local(object):
    def __init__(self):
        object.__setattr__(self,'__storage__',{})

    def __setattr__(self, key, value):
        ident = get_ident()
        try:
            self.__storage__[ident][key] = value
        except KeyError as e:
            self.__storage__[ident] = {key:value}
    def __getattr__(self, item):
        ident = get_ident()
        return self.__storage__[ident][item]

obj = Local()
obj.stack = []

　　d: 1 flask中管理上下文的的push() 中的 __setattr__,__getattr__的利用代理，往字典中的列表注入数据

from threading import get_ident

class Local(object):
    """
    存数据
    """
    def __init__(self):
        object.__setattr__(self,'__storage__',{})
    def __setattr__(self, key, value):
        ident = get_ident()
        try:
            self.__storage__[ident][key] = value
        except KeyError as e:
            self.__storage__[ident] = {key:value}
    def __getattr__(self, item):
        ident = get_ident()
        try:
            return self.self.__storage__[ident][item]
        except Exception as e:
            return None

class LocalStack(object):
    def __init__(self):
        self._local = Local()

    def push(self,data):
        stack = self._local.stack
        if not stack:
            self._local.stack = []
        self._local.stack.append(data)


stack1 = LocalStack()
stack2 = LocalStack()


stack1.push('x1')
stack2.push('xxxx')


"""
local1 = {
    "sdfsdfsdf": { stack: ['x1',]  }
}

local2 = {
    "sdfsdfsdf": { stack: ['xxxxxx',]  }
}
"""

　　d:  2 flask中管理上下文的的push() 中的 __setattr__,__getattr__的利用代理，往字典中的列表注入数据(数据被封装到对象中)

from threading import get_ident

class Local(object):
    """
    存数据
    """
    def __init__(self):
        object.__setattr__(self,'__storage__',{})
    def __setattr__(self, key, value):
        ident = get_ident()
        try:
            self.__storage__[ident][key] = value
        except KeyError as e:
            self.__storage__[ident] = {key:value}
    def __getattr__(self, item):
        ident = get_ident()
        try:
            return self.self.__storage__[ident][item]
        except Exception as e:
            return None

class LocalStack(object):
    def __init__(self):
        self._local = Local()

    def push(self,data):
        stack = self._local.stack
        if not stack:
            self._local.stack = []
        self._local.stack.append(data)


stack1 = LocalStack()
stack2 = LocalStack()

"""
local1 = {
    
}

local2 = {

}
"""

class RequestContext(object):
    def __init__(self):
        self.request = '666'
        self.session = '999'

ctx = RequestContext()
stack1.push(ctx)
"""
local1 = {
    'adfasdfasdf': { stack: [ctx(request,session) ]  }
}

local2 = {

}
"""


stack2.push('app')

"""
local1 = {
    'adfasdfasdf': { stack: [ctx(request,session) ]  }
}

local2 = {
    'adfasdfasdf': { stack: ["app" ]  }
}
"""