Python18Python

缪雪峰python笔记

2017-08-26  本文已影响201人  neo已经被使用 
1.Python内置了一个WSGI（Web Server Gateway Interface）服务器：wsgiref模块，效率比较低，仅供开发和测试使用
    # server.py
    # 从wsgiref模块导入:
    from wsgiref.simple_server import make_server
    # 导入我们自己编写的application函数:
    from hello import application
    # 创建一个服务器，IP地址为空，端口是8000，处理函数是application:
    httpd = make_server('', 8000, application)
    print('Serving HTTP on port 8000...')
    # 开始监听HTTP请求:
    httpd.serve_forever()

    # hello.py
    def application(environ, start_response):
        start_response('200 OK', [('Content-Type', 'text/html')])
        return [b'<h1>Hello, web!</h1>']
  运行server.py来启动WSGI服务器
2.Web框架-Flask。每个请求对于一个方法
from flask import Flask
from flask import request

app = Flask(__name__)

@app.route('/', methods=['GET', 'POST'])
def home():
    return '<h1>Home</h1>'

@app.route('/signin', methods=['GET'])
def signin_form():
    return '''<form action="/signin" method="post">
              <p><input name="username"></p>
              <p><input name="password" type="password"></p>
              <p><button type="submit">Sign In</button></p>
              </form>'''

@app.route('/signin', methods=['POST'])
def signin():
    # 需要从request对象读取表单内容：
    if request.form['username']=='admin' and request.form['password']=='password':
        return '<h3>Hello, admin!</h3>'
    return '<h3>Bad username or password.</h3>'

if __name__ == '__main__':
    app.run()
3. 使用模板
  在Jinja2模板中：
    {{ name }}：需要替换的变量
    {% ... %}：指令

1.异步IO模型需要一个消息循环，在消息循环中，主线程不断地重复“读取消息-处理消息”过程
  当遇到IO操作时，代码只负责发出IO请求，不等待IO结果，然后直接结束本轮消息处理，进入下一轮消息处理过程。
  当IO操作完成后，将收到一条“IO完成”的消息，处理该消息时就可以直接获取IO操作结果
2.协程：一个线程执行，效率高（子程序切换不是线程切换、不需要锁）
  协程通过generator实现（包含yield关键字的方法就是一个generator，不知道这样理解对不对）
    def consumer():#generator
        r = ''
        while True:
            n = yield r
            if not n:
                return
            print('[CONSUMER] Consuming %s...' % n)
            r = '200 OK'

    def produce(c):#参数是一个generator
        c.send(None)
        n = 0
        while n < 5:
            n = n + 1
            print('[PRODUCER] Producing %s...' % n)
            x = c.send(n)
            print('[PRODUCER] Consumer return: %s' % x)
        c.close()

    c = consumer()#把generator赋值给变量c
    produce(c)
  执行过程：
      1.首先调用c.send(None)启动生成器（generator）；
      2.然后，一旦生产了东西，通过c.send(n)切换到consumer执行；
      3.consumer通过yield拿到消息，处理，又通过yield把结果传回（就是给consumer()的r赋值）；
      4.produce拿到consumer处理的结果（上面的x），继续生产下一条消息；
      5.produce决定不生产了，通过c.close()关闭consumer，整个过程结束
3. asyncio内置了对异步IO的支持（消息循环）
    import asyncio
    @asyncio.coroutine#标记为coroutine
    def hello():
        print("Hello world!")
        # 异步调用asyncio.sleep(1):
        r = yield from asyncio.sleep(1)#执行到这里会直接中断并去执行EventLoop中其他可以执行的coroutine
                                       #过了1秒返回一个None（r = None），CPU再来执行后面的代码
        print("Hello again!")
    # 获取EventLoop:
    loop = asyncio.get_event_loop()
    # 执行coroutine
    loop.run_until_complete(hello())#把协程放到消息队列里执行,如果有多个使用wait：asyncio.wait([hello(),A(),B()])
    loop.close()#记得关闭循环
4.Python 3.5开始
    @asyncio.coroutine = async
    yield from = await
5. aiohttp则是基于asyncio实现的HTTP框架
    import asyncio

    from aiohttp import web

    async def index(request):
        await asyncio.sleep(0.5)
        return web.Response(body=b'<h1>Index</h1>')

    async def hello(request):
        await asyncio.sleep(0.5)
        text = '<h1>hello, %s!</h1>' % request.match_info['name']
        return web.Response(body=text.encode('utf-8'))

    async def init(loop):
        app = web.Application(loop=loop)
        app.router.add_route('GET', '/', index)
        app.router.add_route('GET', '/hello/{name}', hello)
        srv = await loop.create_server(app.make_handler(), '127.0.0.1', 8000)
        print('Server started at http://127.0.0.1:8000...')
        return srv

    loop = asyncio.get_event_loop()
    loop.run_until_complete(init(loop))
    loop.run_forever()

1.with关键字的用法：
      with expression as variable:
          with block
  该代码快的执行过程是： 1.先执行expression，然后执行该表达式返回的对象实例的__enter__函数，然后将该函数的返回值赋给as后面的变量。(注意，是将__enter__函数的返回值(返回expression的值)赋给变量) 
                     2.然后执行with block代码块，不论成功，错误，异常，在with block执行结束后，会执行第一步中的实例的__exit__函数。)
2.
上一篇 下一篇

猜你喜欢

热点阅读