flask入门

一、Flask简介
Flask是一个使用 Python 编写的轻量级 Web 应用框架。其 WSGI 工具箱采用 Werkzeug ，模板引擎则使用 Jinja2 。Flask使用 BSD 授权。Flask也被称为 “microframework” ，因为它使用简单的核心，用 extension 增加其他功能。Flask没有默认使用的数据库、窗体验证工具。
二、Flask作用
Flask有很多拓展功能可以使用，可以自由的决定设计的目标，Flask会一直提供一个非常简约而优秀的胶合层。可以自由地使用SQLAlchemy执行高级模式，或者使用其他数据库工具，亦可引入非关系数据模型，甚至还可以利用用于Python网络接口WSGI的非框架工具。
三、有关操作
1.栈Stack：
flask中的请求数据存放是利用列表构造的栈来存储的，每次pop都从最后pop出栈。，特点是后进先出，用栈的好处就是当取出栈中最后一个元素处理时，之前所存入的元素已经准备就绪，不会发生混乱情况。具体代码及解释如下：

class Stack():
    def __init__(self,size):
        self.size=size
        self.stack=[]####用列表表示栈，遵循后进先出原则
        self.top=-1###从栈顶取元素
    def push(self,x):###向栈中添加元素
        if self.isfull():###判断栈是否已经满
            raise exception("stack is full")
        else:
            self.stack.append(x)###将x元素加入到栈里边
            self.top=self.top+1   #["a"] self.top= 0 ["a","b"] self.top=1
    def pop(self):###从栈中取出元素
        if self.isempty():###判断栈是否是空
            raise exception("stack is empty")
        else:
            self.top=self.top-1
            self.stack.pop()###从栈顶取出元素  pop():默认取出一个元素
    def isfull(self):
        return self.top+1 == self.size###栈的大小
    def isempty(self):
        return self.top == '-1'
    def showStack(self):
        print(self.stack)
s=Stack(10)##栈的大小为10
for i in range(6):
    s.push(i)###向栈中添加元素i(0-5)
print(s.showStack())
for i in range(3):####依次从栈顶取出3栈顶个元素
    s.pop()
print(s.showStack())

运行结果

[0, 1, 2, 3, 4, 5]
None
[0, 1, 2]
None

2.队列Queue(代入)
和栈相同，只不过遵循先进先出的原则，具体代码如下：

class Queue():
    def __init__(self,size):
        self.size=size
        self.putnum =-1
        self.getnum =-1
        self.queue=[]
    def put(self,element):
        if self.isfull():
            raise exception("queue is full")
        else:
            self.queue.append(element)
            self.putnum=self.putnum+1
    def get(self):
        if self.isempty():
            raise exception("queue is empty")
        else:
            self.queue.pop(0)
            self.getnum=self.getnum+1
    def isfull(self):
        return self.putnum-self.getnum+1 == self.size
    def isempty(self):
        return self.putnum == self.getnum
    def showQueue(self):
        print(self.queue)
q=Queue(10)
for i in range(6):
    q.put(i)
q.showQueue()
for i in range(3):
    q.get()
q.showQueue()

运行结果

[0, 1, 2, 3, 4, 5]
[3, 4, 5]

3.本地代理，上下文，将上下文压入栈，ctx初始化时设置了两个重要属性request，session。用偏函数将对象属性设定，提取对象属性值，将一些属性加入本地栈中，可以在栈中直接访问，提取对象元素，实现代码如下：

from functools import partial
class HttpRequest(object):
    def __init__(self):
        self.method = "GET"###创建对象属性"get"
        self.body = b"name=abc@age=123"
    def __getitem__(self, item):
        return  self.__dict__[item]
class RequesttContext(object):
    def __init__(self):
        self.request = HttpRequest()
        self.session = {"login":True,"is_super":False}
    def __getitem__(self, item):###传入参数item，后续可以不传入
        return self.__dict__[item]
reqcxt=RequesttContext()###上下文
def func(args):
    return getattr(reqcxt,args)
re_func = partial(func,'request')###等价于re_func():HttpRequest()，返回值就是HttpRequest()
se_func = partial(func,'session')  ###等价于se_func():{"login":True,"is_super":False}，返回字典
class LocalProxy(object):
    def __init__(self,local):
        self._local = local
    def _get_current_object(self):
        print(self._local,self._local())
        return self._local()
    def __getitem__(self, item):
        return getattr(self._get_current_object(),item)
request = LocalProxy(re_func)###等价于request1 = HttpRequest()###直接在本地代理中提取出request，相当于一个接口，返回re_func
ret = request['method']
print(ret)
session = LocalProxy(se_func) #local={"login":True,"is_super":False}
print(session._get_current_object())

运行结果

functools.partial(<function func at 0x7f0a05574e18>, 'request') <__main__.HttpRequest object at 0x7f0a036568d0>
GET
functools.partial(<function func at 0x7f0a05574e18>, 'session') {'login': True, 'is_super': False}
{'login': True, 'is_super': False}

4.本地线程
4.1

import time
import threading
class A:
    pass
local = A()
def func(n):
    local.val = n
    time.sleep(1)
    print(local.val)
for i in range(10):
    t = threading.Thread(target=func,args=(i,))
    t.start()

运行结果

9
9
9
9
9
9
9
9
9
9

原因分析:在多线程中，同一个进程中的多个线程是共享一个内存地址的，多个线程操作数据时，就会造成数据的不安全，需要线程私有化，实现代码如下
4.2线程私有化

import time
import threading
class A:
    pass
 local = threading.local()###线程私有化
def func(n):
    local.val = n
    time.sleep(1)
    print(local.val)
for i in range(10):
    t = threading.Thread(target=func,args=(i,))
    t.start()  

运行结果

0
1
2
3
5
7
4
6
9
8

5.栈的存取
栈的隔离技术(一个线程对应一个栈)

from threading import current_thread as getcurrent
class Local(object):
def __init__(self):
    object.__setattr__(self,"_storage",{})
def __setattr__(self, key, value):
    ident = getcurrent()###定制粒度更细的
    if ident in self._storage:
        self._storage[ident][key] = value
    else:
        self._storage[ident] = {key:value}
def __getattr__(self, item):
    ident = getcurrent()
    return self._storage[ident][item]
class LocalStack(object):
    def __init__(self):
        self.local = Local()
    def push(self,item):
        self.local.stack = []
        self.local.stack.append(item)
    def pop(self):
        return self.local.stack.pop()
    def top(self):
        return self.local.stack[-1]
_local_stack = LocalStack()
_local_stack.push(55)###向栈中加入元素
print(_local_stack.top())###取出栈顶元素

6.简易版Flask框架

from wsgiref.simple_server import make_server
ViewFunctions = {}
def wapper(name):
    def _wapper(f):
        ViewFunctions[name] = f
        return f
    return _wapper
@wapper("/wang")
def home():
    return [b'<h1>Hello, web!</h1>']
@wapper("/favicon.ico")
def pic():
    return [b'<h1>pic!</h1>']
print(ViewFunctions)
class Flask:
    def __init__(self):
        self.view_functions = {}
    def __call__(self,environ, start_response):
        key = environ['PATH_INFO']
        print(key)
        start_response('200 OK', [('Content-Type', 'text/html')])
        return ViewFunctions[key]()
application = Flask()
httpd = make_server('', 8000, application)
#开始监听http请求
httpd.serve_forever()