python学习笔记-tornado框架

标签：__ python self random 笔记 tornado str def

一、简单介绍tornado

tornado学习概要

1、基本操作
-路由系统
-视图函数
2、自定义开源组件
session
Form表单验证
3、自定义异步非阻塞web框架

1、简单示例

import tornado.ioloop
import tornado.web

class MainHandle(tornado.web.RequestHandler):
    def get(self):
        self.write("hello,world")

application=tornado.web.Application([
    (r"/index",MainHandle),
])

if __name__=="__main__":
    application.listen(8888)
    tornado.ioloop.IOLoop.instance().start()

结果：

二、tornado基本操作

1、使用render

2、配置模板路径

配置setting

3、redirect

4、基于cookie的登录验证

设置cookie

获取cookie

5、使用加密cookie

加密cookie依赖配置文件cookie_secret

获取和设置加密cookie

self.get_secure_cookie("xxx")
self.set_secure_cookie("xxx","000")

在setting里配置

浏览器访问，cookie

6、基本方法整理

get_argument 从get和post里都去取
get_query_argument 从get里面取
get_body_argument 从post里去取

self.get_argument()
self.get_arguments()
self.get_cookie()
self.set_cookie()
self.get_secure_cookie() 
self.set_secure_cookie()
v=self.request.files['asd']

三、模板引擎（更接近python）

1、基本场景

{% for i in range(10) %}
{% end %}

模板原理：用的字符串拼接的方式

2、UIMethod,UIModule 类似于Django的simple_tag的功能，在模板中自定制方法

　　UIMethod 内容

　　UIModule css,js 内容（可以返回这些内容）

2.1、示例

uimothod示例

>定义，创建py文件

#uimethods.py
def tab(self):  #这里的self是request对象
    return 'UIMethod'

>注册

> 使用

>结果

uimodule示例

>定义，创建py文件uimodules.py

from tornado.web import UIModule

class Custom(UIModule):
    def render(self,*args,**kwargs):
        return 'modules'

>注册和应用同上

2.2、uimethod,uimodule还可以传参数

2.3、uimethod默认会转义，uimodule默认不转义

UIMethod含HTML标签时，前端显示的字符串，是因为<>符号进行了转义

UIMethod

UImodule

前端效果

>UImethod有标签语句时，设置不转义，输出标签而不是字符串，有2中方法，如下

方法一：前端写法实现

{% raw tab() %}

效果

方法二：在setting里设置实现

效果

>uimodule不转义，可以自己设置转义,如下

modules.py

from tornado.web import UIModule
from tornado import escape

class Custom(UIModule):
    def render(self,*args,**kwargs):
        v=escape.xhtml_escape('<del>modules</del>')
        return v

前端

效果

2.4、uimodule可以引入css,js

from tornado.web import UIModule
from tornado import escape

class Custom(UIModule):
    #引入css文件，（从静态文件中引入的，要先配置静态文件夹）
    def css_files(self):
        return "commons.css"
    #嵌入css
    def embedded_css(self):
        return ".c1{display:none}"
    #引入js
    def javascript_files(self):
        return "commons.js"
    #嵌入js语句
    def embedded_javascript(self):
        return "function f1(){alert(123)}"
    def render(self,*args,**kwargs):
        v=escape.xhtml_escape('<del>modules</del>')
        return v

配置的静态文件

查看网页，引入了css,js

四、tornado自定义session

1、继承的回顾

super不仅仅找父类，按照深度优先或广度优先找的

class C:
    def f1(self):
        print('C')
        super(C,self).f1()#从c的父类中找，没找到按照广度从B中找，执行B的f1
class A(C):
    def f1(self):
        print('A')
        super(A,self).f1()
class B:
    def f1(self):
        print("B")
class Foo(A,B):
    pass

obj=Foo()
obj.f1()

执行obj.f1(),输出是A，C，B

指定要执行的方法，写法

class A(C):
    def f1(self):
        print("A")
        B.f1(self)

2、自定义session的原理

》tornando，源码逻辑，是先实例化再执行的post或get，自己的没有写init一定是继承的父类实现了这个方法
查看源码是init中预留了initialize方法，直接写方法并进行继承就可以实现自定制，（根据深度广度优先Foo写在前面）

另一种写法：

python有这两种写法，因为pytho支持多继承，java不支持就只有一种写法

》

obj['asdf']=123 #自动调用执行了obj对象中的__setitem__方法

def __setitem__(self,key,value):
    pass

obj['asdf'] #__getitem__(self,key)
del obj["asdf"] #__delitem__(self,key)

#自定义session要实现的步骤
1、生成随机字符串
2、写入用户cookie
3、后台存储

3、自定义session

示例1

import tornado.ioloop
import tornado.web

import time
import hashlib

container={}

class Bar(object):
    def __init__(self,handler):
        self.handler=handler
    def create_random_str(self):
        v=str(time.time())
        m=hashlib.md5()
        m.update(bytes(v,encoding="utf-8"))
        return m.hexdigest()

    def __setitem__(self, key, value):
        # 1、生成随机字符串
        # 2、写入用户cookie
        # 3、后台存储
        random_str=self.create_random_str()
        self.handler.set_cookie("session_id",random_str)
        if random_str in container:
            container[random_str][key]=value
        else:
            container[random_str]={}
            container[random_str][key]=value

    def __getitem__(self, item):
        pass
    def __delitem__(self, key):
        pass

class Foo(object):
    def initialize(self):
        #self是MainHandle对象
        self.session=Bar(self)
        super(Foo,self).initialize()

class MainHandle(Foo,tornado.web.RequestHandler):
    def get(self):
        self.session["xx"]="addf"
        self.session["aaa"]='BBBB'
        self.write("Hello,world")

application=tornado.web.Application([
    (r"/index",MainHandle),])

if __name__=="__main__":
    application.listen(8888)
    tornado.ioloop.IOLoop.instance().start()

实例2，根据不同用户，对session进行处理

import tornado.ioloop
import tornado.web

import time
import hashlib

container={}

class Bar(object):
    def __init__(self,handler):
        self.handler=handler
        self.random_str=None
        #x先去请求获取session_id,如果没有，新用户
        client_random_str=self.handler.get_cookie("session_id")

        if not client_random_str:
            #新用户
            self.random_str = self.create_random_str()
            container[self.random_str]={}
        else:
            if client_random_str in container:
                #老用户
                self.random_str=client_random_str
            else:
                #非法用户
                self.random_str=self.create_random_str()
                container[self.random_str] = {}

        self.handler.set_cookie("session_id",self.random_str)
    def create_random_str(self):
        v=str(time.time())
        m=hashlib.md5()
        m.update(bytes(v,encoding="utf-8"))
        return m.hexdigest()

    def __setitem__(self, key, value):
        container[self.random_str][key]=value

    def __getitem__(self, key):
        return container[self.random_str].get(key)
    def __delitem__(self, key):
        del container[self.random_str][key]
    def clear(self):
        del container[self.random_str]

class Foo(object):
    def initialize(self):
        #实例去调时，这里self是MainHandle对象
        self.session=Bar(self)
        super(Foo,self).initialize()

class HomeHandle(Foo,tornado.web.RequestHandler):
    def get(self):
        user=self.session['uuuu']
        if not user:
            self.redirect("http://www.baidu.com")
        else:
            self.write("Hello,world,%s"%user)

class LoginHandle(Foo,tornado.web.RequestHandler):
    def get(self):
        self.session["uuuu"]="root"
        self.redirect('/home')


application=tornado.web.Application([
    (r"/login",LoginHandle),
    (r"/home",HomeHandle),
])

if __name__=="__main__":
    application.listen(8888)
    tornado.ioloop.IOLoop.instance().start()

自定义session二

实例3，增加过期时间，扩展session存储到不同的介质的方法封装

》语句in，执行in逻辑时候，相当于调用了__contains__方法

class Foo:
    def __contains__(self,item):
        print(item)
        return True
obj=Foo()

v="x" in obj   #执行结果是打印x

》session封装

import tornado.web

import time
import hashlib

#保存到缓存
class Cache(object):
    def __init__(self):
        self.container={}
    def __contains__(self, item):
        return item in self.container
    def initial(self,random_str):
        self.container[random_str] = {}
    def open(self):
        pass
    def close(self):
        pass
    def get(self,random_str,key):
        return self.container[random_str][key]
    def set(self,random_str,key,value):
        self.container[random_str][key]=value
    def delete(self,random_str,key):
        del self.container[random_str][key]
    def clear(self,random_str):
        del self.container[random_str]
#保存到文件
class File(object):
    pass

P=Cache
class Session(object):
    def __init__(self,handler):
        self.handler=handler
        self.random_str=None
        self.ppp=P()
        self.ppp.open()
        #x先去请求获取session_id,如果没有，新用户
        client_random_str=self.handler.get_cookie("session_id")

        if not client_random_str:
            #新用户
            self.random_str = self.create_random_str()
            self.ppp.initial(self.random_str)
        else:
            if client_random_str in self.ppp:
                #老用户
                self.random_str=client_random_str
            else:
                #非法用户
                self.random_str=self.create_random_str()
                self.ppp.initial(self.random_str)
        ctime=time.time()
        self.handler.set_cookie("session_id",self.random_str,expires=ctime+1800)
        self.ppp.close()
    def create_random_str(self):
        v=str(time.time())
        m=hashlib.md5()
        m.update(bytes(v,encoding="utf-8"))
        return m.hexdigest()

    def __setitem__(self, key, value):
        self.ppp.open()
        self.ppp.set(self.random_str,key,value)
        self.ppp.close()
    def __getitem__(self,key):
        self.ppp.open()
        v= self.ppp.get(self.random_str,key)
        self.ppp.close()
        return v
    def __delitem__(self, key):
        self.ppp.delete(self.random_str,key)
    def clear(self):
        self.ppp.open()
        self.ppp.clear(self.random_str)
        self.ppp.close()
class Foo(object):
    def initialize(self):
        #实例去调时，这里self是MainHandle对象
        self.session=Session(self)
        super(Foo,self).initialize()

class HomeHandle(Foo,tornado.web.RequestHandler):
    def get(self):
        user=self.session['uuuu']
        if not user:
            self.redirect("http://www.baidu.com")
        else:
            self.write("Hello,world,%s"%user)

class LoginHandle(Foo,tornado.web.RequestHandler):
    def get(self):
        self.session["uuuu"]="root"
        self.redirect('/home')


application=tornado.web.Application([
    (r"/login",LoginHandle),
    (r"/home",HomeHandle),
])

if __name__=="__main__":
    application.listen(8888)
    tornado.ioloop.IOLoop.instance().start()

自定义session三

标签：__,python,self,random,笔记,tornado,str,def
From： https://www.cnblogs.com/steven223-z/p/17884249.html