02tornado输入输出

最新推荐文章于 2020-07-10 21:14:40 发布

533_

最新推荐文章于 2020-07-10 21:14:40 发布

阅读量234

点赞数

分类专栏： tornado

本文链接：https://blog.csdn.net/qq_14993591/article/details/82458942

版权

tornado 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

输出

write可接受对象类型

write 把字符串输出到浏览器

write 并没有直接把数据返回给前端，而是先写到缓存区，函数结束之后才会返回到前端

字符串

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.write("Hello tanzhou")

二进制字符串b

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.write(b'Tornado <br>')

Tornado

字典

user = {
    'name': 'budong',
    'age': 18
}
self.write(user)

{"age": 18, "name": "budong"}

self.write('hello world!!!!')
self.write('<br>')
self.write('hello)





Response Header  ： Content-Type: text/html;

hello world!!!!
hello

如果接受的是字典，会把响应头Response Header 设置为json ，传送的字典当成 JSON格式数据处理

def get(self):
    self.write('hello world!!!!')
    self.write('<br>')
    self.write({'name': 'w', 'age': 18})




输出字典 Response Header

Content-Type: application/json;

hello world!!!!<br>hello<br>{"age": 18, "name": "w"}

Unicode

self.write('<b>Tornado1</b><br>')

Tornado1（加粗的）

json

li = [1, 2, 3, 4]
import json
li = json.dumps(li)
self.write(li)
print(repr(li))
li = json.loads(li)
print(repr(li))

write

[1,2,3,4]

'[1,2,3,4]'
[1,2,3,4]

flush

把缓冲区的内容发送到客户端

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.write('hello<br>')
        time.sleep(3)
        self.write('<b>Tornado</b><br>')

3秒后输出hello Tornado 到屏幕

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.write('hello<br>')
        self.write('<b>Tornado</b><br>')
        time.sleep(3)
        self.write({'name':'wu'})

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.write('hello<br>')
        self.write('<b>Tornado</b><br>')
        self.flush()
        time.sleep(3)
        self.write({'name':'wu'})

先输出hello 3秒后输出Tornado到屏幕

class MainHandler(tornado.web.RequestHandler):
   def get(self, *args, **kwargs):
      self.write('hello <br>')
      self.write(b'Tornado<br>')
      time.sleep(3)
      self.write({'name': 'wu'})

3秒后显示

hello <br>Tornado<br>{"name": "wu"}

class MainHandler(tornado.web.RequestHandler):
    def get(self, *args, **kwargs):
        self.write('hello <br>')
        self.write(b'Tornado<br>')
        self.flush()
        time.sleep(3)
        self.write({'name': 'wu'})

hello 
Tornado
{"name": "wu"}                  （3秒后显示）

缓冲区

write 会先把内容放在缓冲区，
正常情况下，当请求处理完成的时候会自动把缓冲区的内容输出到浏览器，
但是可以调用 flush 方法，这样可以直接把缓冲区的内容输出到浏览器，不用等待请求处理完成

render 返回html

import tornado.ioloop
import tornado.options
import tornado.httpserver
import tornado.web
from tornado.options import define,options

define('port',default=8000,type=int,help='port')

class IndexHandler(tornado.web.RequestHandler):
    def get(self, *args, **kwargs):
        self.render('01in_out.html')



application = tornado.web.Application(
    handlers=[
    (r'/',IndexHandler),
    ],
    template_path = 'template',
    debug = True

)

if __name__ == '__main__':
    tornado.options.parse_command_line()
    http_server = tornado.httpserver.HTTPServer(application)
    http_server.listen(options.port)
    tornado.ioloop.IOLoop.current().start()

去template文件夹下找 01in_out.html 文件 write html

01in_out.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    hello world
</body>
</html>

页面显示 http://127.0.0.1:8000/

hello world

返回 HTML

class IndexHandler(tornado.web.RequestHandler):
    def get(self, *args, **kwargs):
        self.render('01in_out.html')

通过  render  可以返回一个 html 文件

Application

template_path='templates',

想要 Tornado 能够正确的找到 html 文件，需要在 Application 中指定文件的位置

redirect 跳转路由

import tornado.ioloop
import tornado.options
import tornado.httpserver
import tornado.web
from tornado.options import define,options

define('port',default=8000,type=int,help='port')

class TemHandler(tornado.web.RequestHandler):
    def get(self, *args, **kwargs):
        self.write('hello world!!!!')

class RecHandler(tornado.web.RequestHandler):
    def get(self, *args, **kwargs):
        self.redirect(r"/tem")

application = tornado.web.Application(
    handlers=[
    (r'/tem',TemHandler),
    (r'/rec',RecHandler),
    ],
    template_path = 'template',
    debug = True
)

if __name__ == '__main__':
    tornado.options.parse_command_line()
    http_server = tornado.httpserver.HTTPServer(application)
    http_server.listen(options.port)
    tornado.ioloop.IOLoop.current().start()

http://127.0.0.1:8000/rec 自动跳转到 http://127.0.0.1:8000/tem

跳转路由

class RecHandler(tornado.web.RequestHandler):
    def get(self, *args, **kwargs):
        import time
        time.sleep(3)
        self.redirect(r"/tem")

通过  redirect 可以跳转到指定的路由

路由

(r'/rec', RecHandler),

finish()

请求结束后面的语句不会再执行

class TemHandler(tornado.web.RequestHandler):
    def get(self, *args, **kwargs):
        self.write('hello world!!!!')
        self.finish()
        self.write('www')

获取请求信息

self.request

import tornado.ioloop
import tornado.options
import tornado.httpserver
import tornado.web
from tornado.options import define,options

define('port',default=8000,type=int,help='port')


class ReqHandler(tornado.web.RequestHandler):
    def get(self, *args, **kwargs):
        self.write(self.request.remote_ip)

application = tornado.web.Application(
    handlers=[
    (r'/req',ReqHandler),
    ],
    template_path = 'template',
    debug = True
)

if __name__ == '__main__':
    tornado.options.parse_command_line()
    http_server = tornado.httpserver.HTTPServer(application)
    http_server.listen(options.port)
    tornado.ioloop.IOLoop.current().start()

http://127.0.0.1:8000/req

10.0.0.2

method	HTTP请求方法，例如 GET 或 POST
remote_ip	客户端的IP地址，返回值类型为字符串
full_url()	重新构建此请求的完整URL
request_time()	返回此请求执行所花费的时间
uri	请求的完整uri
path	路径部分的uri
query	查询部分的uri
version	请求中指定的HTTP版本，例如“HTTP /1.1”

import tornado.ioloop
import tornado.options
import tornado.httpserver
import tornado.web
from tornado.options import define,options

define('port',default=8000,type=int,help='port')


class ReqHandler(tornado.web.RequestHandler):
    def get(self, *args, **kwargs):
        self.write(self.request.remote_ip)
        self.write('<br>')
        self.write(self.request.full_url())
        self.write('<br>')
        print(self.request.request_time())


application = tornado.web.Application(
    handlers=[
    (r'/req',ReqHandler),
    ],
    template_path = 'template',
    debug = True
)

if __name__ == '__main__':
    tornado.options.parse_command_line()
    http_server = tornado.httpserver.HTTPServer(application)
    http_server.listen(options.port)
    tornado.ioloop.IOLoop.current().start()

页面显示

客户端的IP地址，返回值类型为字符串

重新构建此请求的完整URL

10.0.2.2
http://127.0.0.1:8000/req

终端显示

request_time() 返回此请求执行所花费的时间

0.00052285.。。。。。。。。。。。。。

<class 'str'>  '10.0.2.2'

self.request可以获取到的请求信息

method	HTTP请求方法，例如“GET”或“POST”
uri	请求的完整uri
path	路径部分的uri
query	查询部分的uri
version	请求中指定的HTTP版本，例如“HTTP / 1.1”
headers	`HTTPHeaders`用于请求标题的类似字典的对象。request.headers[“aaa”] 像一个不区分大小写的字典一样使用附加的重复标题的方法。
body	请求主体（如果存在）作为字节串
remote_ip	客户端的IP地址作为字符串。如果`HTTPServer.xheaders`设置，将传递由负载均衡器在`X-Real-Ip`或`X-Forwarded-For`头中提供的真实IP地址。版本3.1更改：`X-Forwarded-For`现在支持列表格式。
protocol	所使用的协议是“http”或“https”。如果`HTTPServer.xheaders` 设置，将通过负载均衡器使用的协议（如果通过`X-Scheme`头部报告）传递。
host	请求的主机名，通常取自`Host`标题
arguments	参数属性中提供GET / POST参数，它将参数名称映射到值列表（以支持单个名称的多个值）。名称是类型`str`，而参数是字节字符串。请注意，这不同于 `RequestHandler.get_argument`，它将参数值作为unicode字符串返回。
query_arguments	与`arguments`格式相同但只包含从查询字符串中提取的参数。版本3.2中的新功能
body_arguments	与`arguments`格式相同但只包含从请求体提取的参数。版本3.2中的新功能。
files	文件属性中可以使用文件上传，它将文件名映射到列表`HTTPFile`。 tornado.httputil.``HTTPFile表示通过表单上传的文件。为了向后兼容，其实例属性也可作为字典键访问。
full_url()	重新构建此请求的完整URL。
request_time()	返回此请求执行所花费的时间。

输入


import tornado.ioloop
import tornado.options
import tornado.httpserver
import tornado.web
from tornado.options import define,options

define('port',default=8000,type=int,help='port')

class IndexHandler(tornado.web.RequestHandler):
    def get(self, *args, **kwargs):
        name = self.get_argument('name','no')
        self.write('hello'+name)
        print(name)

        name = self.get_arguments('name')
        self.write('<br>')
        self.write(','.join(name))
        print(name)


application = tornado.web.Application([
    (r'/',IndexHandler)
])

if __name__ == '__main__':
    tornado.options.parse_command_line()
    http_server = tornado.httpserver.HTTPServer(application)
    http_server.listen(options.port)
    tornado.ioloop.IOLoop.current().start()

http://127.0.0.1:8080/?name=号

hello号 
号

http://127.0.0.1:8080/?name=号&name=你

hello你
号,你

get_argument get_arguments

import tornado.ioloop
import tornado.options
import tornado.httpserver
import tornado.web
from tornado.options import define,options

define('port',default=8000,type=int,help='port')


class GetHandler(tornado.web.RequestHandler):
    def get(self, *args):
        name = self.get_argument('name','no')
        self.write(name)
        self.write('<br>')
        name = self.get_arguments('name')
        print(name)
        self.write('<br>'.join(name))


application = tornado.web.Application(
    handlers=[
        (r'/get',GetHandler),
    ],
    template_path = 'template',
    debug = True
)

if __name__ == '__main__':
    tornado.options.parse_command_line()
    http_server = tornado.httpserver.HTTPServer(application)
    http_server.listen(options.port)
    tornado.ioloop.IOLoop.current().start()

http://127.0.0.1:8000/get

no

终端显示
[]

http://127.0.0.1:8000/get?name=五

五
五

终端显示
['五']

http://127.0.0.1:8000/get?name=五&name=三

三
五
三

终端显示
['五', '三']

获取 URL 数据

get_argument
可以获取 URL (查询字符串)中的参数

获取 body 数据

get_argument
可以获取 body (请求体)中的数据

get_argument
返回的值始终是unicode

import tornado.ioloop
import tornado.options
import tornado.httpserver
import tornado.web
from tornado.options import define,options

define('port',default=8000,type=int,help='port')

class IndexHandler(tornado.web.RequestHandler):
    def get(self, *args, **kwargs):
        self.render('01in_out.html')


class GetHandler(tornado.web.RequestHandler):
    def get(self, *args):
        name = self.get_argument('name','no')   # 可以获取 URL (查询字符串)中的参数
        self.write(name)
        self.write('<br>')
        name = self.get_arguments('name')
        print(name)
        self.write('<br>'.join(name))

    def post(self, *args, **kwargs):
        name = self.get_argument('name','no')   # 可以获取 body (请求体)中的数据
        password = self.get_argument('password','123')
        self.write("name %s <br> password %s " %(name,password))


application = tornado.web.Application(
    handlers=[
    (r'/',IndexHandler),
    (r'/get',GetHandler),
    ],
    template_path = 'template',
    debug = True
)

if __name__ == '__main__':
    tornado.options.parse_command_line()
    http_server = tornado.httpserver.HTTPServer(application)
    http_server.listen(options.port)
    tornado.ioloop.IOLoop.current().start()

01in_out.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    hello world
    <form method="post" action="/get">
        <p>用户名：<input type="text" name="name"></p>
        <p>密&emsp;码：<input type="password" name="password"></p>
        <input type="submit">
    </form>
</body>
</html>

访问 http://127.0.0.1:8000/  
显示 01in_out.html 
01in_out.html  中form表单提交数据 提交到/get路由 
通过路由表 找到GetHandler类  
因通过post方式提交的数据 
所以需添加def post（）处理post请求

get_query_argument

获取查询字符串中参数

对应的也有：get_query_arguments

class GetHandler(tornado.web.RequestHandler):
    def get(self):
        name = self.get_query_argument('name', 'no')
        self.write(name)

http://127.0.0.1:8000/get?name=我
我

import tornado.ioloop
import tornado.options
import tornado.httpserver
import tornado.web
from tornado.options import define, options

import time


define('port', default=8000, type=int, help='port')


class IndexHandler(tornado.web.RequestHandler):
   def get(self, *args, **kwargs):
      self.render('01in_out.html')


class GetHandler(tornado.web.RequestHandler):
   def get(self, *args):
      name = self.get_query_argument('name', 'no')
      self.write(name)

   def post(self, *args, **kwargs):
      name = self.get_argument('name','no')
      password = self.get_argument('password','123')
      self.write("name %s <br> password %s " %(name,password))

      name1 = self.get_query_argument('name','no')
      print(name1)


application = tornado.web.Application(
   handlers=[
      (r'/', IndexHandler),
      (r'/get', GetHandler),
   ],
   template_path='template',
   debug=True
)


if __name__ == '__main__':
   tornado.options.parse_command_line()
   http_server = tornado.httpserver.HTTPServer(application)
   http_server.listen(options.port)
   tornado.ioloop.IOLoop.current().start()

form action=”/get?name=wu”

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    hello world
    <form method="post" action="/get?name=wu">
        <p>用户名：<input type="text" name="name"></p>
        <p>密&emsp;码：<input type="password" name="password"></p>
        <input type="submit">
    </form>
</body>
</html>

访问 http://127.0.0.1:8000/  填数据
转到 http://127.0.0.1:8000/get?name=wu
页面显示 
name 5 
password 5


终端显示
wu

get_body_argument

获取 body 中的参数

对应的也有： get_body_argument

class GetHandler(tornado.web.RequestHandler):
    def get(self):
        name = self.get_query_argument('name', 'no')
        self.write(name)

    def post(self):
        name = self.get_body_argument('name', 'no')
        password = self.get_body_argument('password', '123')
        self.write("name %s <br> password %s " % (name, password))

import tornado.ioloop
import tornado.options
import tornado.httpserver
import tornado.web
from tornado.options import define,options

define('port',default=8000,type=int,help='port')

class IndexHandler(tornado.web.RequestHandler):
    def get(self, *args, **kwargs):
        self.render('01in_out.html')

class GetHandler(tornado.web.RequestHandler):
    def get(self, *args):
        name = self.get_query_argument('name', 'no')
        self.write(name)


    def post(self, *args, **kwargs):
        name = self.get_body_argument('name', 'no')
        password = self.get_body_argument('password', '123')
        self.write("name %s <br> password %s " % (name, password))

application = tornado.web.Application(
    handlers=[
        (r'/',IndexHandler),
        (r'/get',GetHandler),
    ],
    template_path = 'template',
    debug = True
)

if __name__ == '__main__':
    tornado.options.parse_command_line()
    http_server = tornado.httpserver.HTTPServer(application)
    http_server.listen(options.port)
    tornado.ioloop.IOLoop.current().start()

访问 http://127.0.0.1:8000/ 填写form表单 提交数据 转到/get路由

可以访问到form表单中提交的数据

name 2  password 2

url传参

查询字符串风格

class GetHandler(tornado.web.RequestHandler):

    def get(self, *args):
        name = self.get_argument('name','no')
        self.write(name)

路由

r'/get', GetHandler),

url

http://127.0.0.1:8000/get?name=budong

REST风格

按参数位置传值

(r'/usr/(.+)/([0-9]+)',UsrHandler),

import tornado.ioloop
import tornado.options
import tornado.httpserver
import tornado.web
from tornado.options import define,options

define('port',default=8000,type=int,help='port')


class UsrHandler(tornado.web.RequestHandler):
    def get(self, name,age):
        self.write('name:%s <br> age:%s'%(name,age))


application = tornado.web.Application(
    handlers=[
        (r'/usr/(.+)/([0-9]+)',UsrHandler),
    ],
    template_path = 'template',
    debug = True
)

if __name__ == '__main__':
    tornado.options.parse_command_line()
    http_server = tornado.httpserver.HTTPServer(application)
    http_server.listen(options.port)
    tornado.ioloop.IOLoop.current().start()

http://127.0.0.1:8000/usr/五/15

name:五 
age:15

按参数名字传值

 (r'/stu/(?P<age>[0-9]+)/(?P<name>.+)', StuHandler)

import tornado.ioloop
import tornado.options
import tornado.httpserver
import tornado.web
from tornado.options import define,options

define('port',default=8000,type=int,help='port')


class StuHandler(tornado.web.RequestHandler):
    def get(self, name,age):
        self.write('name:%s <br> age:%s'%(name,age))


application = tornado.web.Application(
    handlers=[
        (r'/stu/(?P<age>[0-9]+)/(?P<name>.+)', StuHandler),
    ],
    template_path = 'template',
    debug = True
)

if __name__ == '__main__':
    tornado.options.parse_command_line()
    http_server = tornado.httpserver.HTTPServer(application)
    http_server.listen(options.port)
    tornado.ioloop.IOLoop.current().start()

http://127.0.0.1:8000/stu/15/五 

name:五 
age:15

路由

(r'/usr/(.+)/([0-9]+)',UsrHandler),
(r'/stu/(?P<age>[0-9]+)/(?P<name>.+)', StuHandler),



url
http://127.0.0.1:8000/usr/五/15
http://127.0.0.1:8000/stu/15/五

get和post的区别是:

get就是获取服务器数据的意思，

post是类似于提交数据，往服务器提交数据。

533_

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
02tornado输入输出

输出write可接受对象类型字符串二进制字符串b字典Unicodejsonflush缓冲区render 返回htmlredirect 跳转路由finish()获取请求信息self.requestself.request可以获取到的请求信息输入get_argument get_arguments获取 URL 数据获取 body 数据ge...
复制链接

扫一扫