def return_add_model_id(self, modelList):
    func = lambda x: modify_idKeys(x) # 闭包
    model_id = self._id
    def modify_idKeys(goods):  
        g = goods.copy()
        for keys, value in goods.items():
            if keys == '_id':
                g[model_id] = value
                # g.pop('_id'),还保留着
                return g
    return list(map(func, modelList))
# 依次执行函数得到结果,并将结果组成一个新的list对象后进行返回
province_list = [{'name': '北京市', 'code': '11'}, \
    {'name':'天津市','code':'12'},{'name':'河北省','code':'13'}]
remove_province_list = ['河北省']
# 函数式编程的filter 不仅可以做判断的依据,而且还可以修改其值
list(filter(lambda x: x.get('name') not in remove_province_list \
    and x.pop('code'), province_list))
# [{'name': '北京市'}, {'name': '天津市'}]
a = list(map(lambda x, y : x*y, [1.2, 3, 5], [2, 4, 6]))
print(a)#[2.4,12,30]
a = reduce(lambda x,y:x+y,a)
print(a)#44.4
def toUpper(item):
  return item.upper()
 
list(map(toUpper, ["hao", "chen", "coolshell"]))
# ['HAO', 'CHEN', 'COOLSHELL']

ErrorHandler :生成指定状态码的错误响应.
RedirectHandler :重定向请求.
StaticFileHandler :处理静态文件请求.
FallbackHandler :使可以在Tornado中混合使用其他HTTP服务器.

# Tornado模板是被Python表达式和控制语句标记的简单文本文件.
# 填充表达式:{{}},控制流语句{% %}{% end %}
# 你也可以在你的控制语句块中间使用{% set foo = 'bar' %}来设置变量.
# template_path参数告诉Tornado在哪里寻找模板文件
# 模板是一个允许你嵌入Python代码片段的HTML文件.
# 在模板中使用参数
{{wood}}
{% for book in books %}
    <li>{{ book }}</li>
{% end %} }}
# 在模板中使用函数
# 渲染模板
self.render('index.html')
# 这段代码告诉Tornado在templates文件夹下找到一个名为index.html的文件,
# 读取其中的内容,并且发送给浏览器.
# 继承模板与重写标签
{% extend base.html%}
{% block body %}重写body block
# 子模板不能在block标签定义内容.

# static_path参数指定了你应用程序放置静态资源(如图像、CSS文件、JavaScript文件等)的目录
<link rel="stylesheet" href="{{ static_url("style.css") }}">

# 为了扩展一个已经存在的模板,你只需要在新的模板文件的顶部放上一句
# {% extends "filename.html" %}.
# 比如,为了在新模板中扩展一个父模板(在这里假设为main.html),你可以这样使用:
{% extends "main.html" %}
# 这就使得新文件继承main.html的所有标签,并且覆写为期望的内容.

{% module xsrf_form_html() %}跨网站攻击

{% set mailLink = "<a href="mailto:contact@burtsbooks.com">Contact Us</a>" %}
{{ mailLink }}'
# 它会在页面源代码中渲染成如下代码:
&lt;a href=&quot;mailto:contact@burtsbooks.com&quot;&gt;Contact Us&lt;/a&gt;
# 此时自动转义被运行了,很明显,这无法让人们联系上Burt.

{% autoescape None %}
{{ mailLink }}
# 这些autoescape块不需要结束标签,并且可以设置xhtml_escape来开启自动转义(默认行为)
# 或None来关闭.
# 然而,在理想的情况下,你希望保持自动转义开启以便继续防护你的网站.
# 因此,你可以使用{% raw %}指令来输出不转义的内容.
{% raw mailLink %}
# 需要特别注意的是,当你使用诸如Tornado的linkify()和xsrf_form_html()函数时
# 自动转义的设置被改变了.所以如果你希望在前面代码的footer中使用linkify()来包含链接
# 你可以使用一个{% raw %}块:
{% block footer %}
<p>
    For more information about our selection, hours or events, please email us at
    <a href="mailto:contact@burtsbooks.com">contact@burtsbooks.com</a>.
</p>
<p class="small">
    Follow us on Facebook at
    {% raw linkify("https://fb.me/burtsbooks", extra_params='ref=website') %}.
    {% apply linkify or 自定义方法%} Application中get_template_namespace
</p>
{% end %}
# 这样,你可以既利用linkify()简记的好处,又可以保持在其他地方自动转义的好处 }}' }}

import time
import threading
def long_io(callback):
    """将耗时的操作交给另一线程来处理"""
    def fun(cb): # 回调函数作为参数
        """耗时操作"""
        print( "开始执行IO操作")
        time.sleep(5)
        print("完成IO操作,并执行回调函数")
        cb("io result")  # 执行回调函数
    threading._start_new_thread(fun, (callback,))  # 开启线程执行耗时操作
def on_finish(ret):
    """回调函数"""
    print( "开始执行回调函数on_finish")
    print( "ret: %s" % ret)
    print( "完成执行回调函数on_finish")
# 可读性差,要结合多个函数
def req_a():
    """将req_q逻辑拆分了"""
    print( "开始处理请求req_a" )
    long_io(on_finish)
    print( "离开处理请求req_a")
def req_b():
    print( "开始处理请求req_b")
    time.sleep(2) # 添加此句来突出显示程序执行的过程
    print( "完成处理请求req_b")
def main():
    req_a()
    req_b()
    while 1: # 添加此句防止程序退出,保证线程可以执行完
        pass
if __name__ == '__main__':
    main()
# 开始处理请求req_a
# 离开处理请求req_a
# 开始处理请求req_b
# 开始执行IO操作
# 完成处理请求req_b
# 完成IO操作,并执行回调函数
# 开始执行回调函数on_finish
# ret: io result
# 完成执行回调函数on_finish

import time
import threading
gen = None # 全局生成器,供long_io使用
def long_io():
    def fun():
        print("开始执行IO操作")
        global gen
        time.sleep(5)
        try:
            print("完成IO操作,并send结果唤醒挂起程序继续执行")
            gen.send("io result")  # 使用send返回结果并唤醒程序继续执行
        except StopIteration: # 捕获生成器完成迭代,防止程序退出
            pass
    threading._start_new_thread(fun, ())
def req_a():
    """将req_q逻辑组织在一起"""
    print("开始处理请求req_a")
    ret = yield long_io()
    print("ret: %s" % ret)
    print("完成处理请求req_a")
def req_b():
    print("开始处理请求req_b")
    time.sleep(2)
    print( "完成处理请求req_b")
def main():
    global gen
    gen = req_a() # 得到生成器,不能像同步一样去输写
    next(gen) # 开启生成器req_a的执行
    req_b()
    while 1:
        pass
if __name__ == '__main__':
    main()
# 开始处理请求req_a
# 开始处理请求req_b
# 开始执行IO操作
# 完成处理请求req_b
# 完成IO操作,并send结果唤醒挂起程序继续执行
# ret: io result
# 完成处理请求req_a

import time
import threading
gen = None # 全局生成器,供long_io使用
def gen_coroutine(f):
    def wrapper(*args, **kwargs):
        global gen
        gen = f()
        next(gen)
    return wrapper
def long_io():
    def fun():
        print("开始执行IO操作")
        global gen
        time.sleep(5)
        try:
            print("完成IO操作,并send结果唤醒挂起程序继续执行")
            gen.send("io result")  # 使用send返回结果并唤醒程序继续执行
        except StopIteration: # 捕获生成器完成迭代,防止程序退出
            pass
    threading._start_new_thread(fun, ())
@gen_coroutine
def req_a():
    print("开始处理请求req_a")
    ret = yield long_io()
    print("ret: %s" % ret)
    print("完成处理请求req_a")
def req_b():
    print("开始处理请求req_b")
    time.sleep(2)
    print( "完成处理请求req_b")
def main():
    req_a()
    req_b()
    while 1:
        pass
if __name__ == '__main__':
    main()

import time
import threading
def gen_coroutine(f):
    def wrapper(*args, **kwargs):
        gen_f = f()  # gen_f为生成器对象(req_a的代码,以及上下文)
        r = next(gen_f)  # 相当于调用long_io()
        # r是long_io的生成器对象(long_io代码,以及上下文)
        def fun(g):
            ret = next(g) # 执行生成器long_io
            try:
                gen_f.send(ret) # 将结果返回给req_a并使其继续执行
            except StopIteration:
                pass
        threading._start_new_thread(fun, (r,))
        # tornado中是交给IOLoop进行管理
    return wrapper
def long_io():
    print("开始执行IO操作")
    time.sleep(5)
    print("完成IO操作,yield回操作结果")
    yield "io result"
@gen_coroutine
def req_a():
    print("开始处理请求req_a")
    ret = yield long_io()
    print("ret: %s" % ret)
    print("完成处理请求req_a")
def req_b():
    print("开始处理请求req_b")
    time.sleep(2)
    print( "完成处理请求req_b")
def main():
    req_a()
    req_b()
    while 1:
        pass
if __name__ == '__main__':
    main()

class MainHandler(tornado.web.RequestHandler):
    @tornado.web.asynchronous
    def get(self):
        http = tornado.httpclient.AsyncHTTPClient()
        http.fetch("http://friendfeed-api.com/v2/feed/bret",
                   callback=self.on_response)
    def on_response(self, response):
        if response.error: raise tornado.web.HTTPError(500)
        json = tornado.escape.json_decode(response.body)
        self.write("Fetched " + str(len(json["entries"])) + " entries "
                   "from the FriendFeed API")
        self.finish()

class MainHandler(tornado.web.RequestHandler):
    @tornado.gen.coroutine
    def get(self):
        http = tornado.httpclient.AsyncHTTPClient()
        response = yield http.fetch("http://friendfeed-api.com/v2/feed/bret")
        json = tornado.escape.json_decode(response.body)
        self.write("Fetched " + str(len(json["entries"])) + " entries "
                   "from the FriendFeed API")

import json
import sys
import tornado.httpserver
import tornado.ioloop
import tornado.options
import tornado.gen
import tornado.httpclient
from tornado.options import define, options
import tornado.web
import os.path
define("port", default=8080, type=int)
class MainHandler(tornado.web.RequestHandler):
    #并行协程
    @tornado.gen.coroutine
    def get(self):
        ips = ["14.130.112.24",
            "15.130.112.24",
            "16.130.112.24",
            "17.130.112.24"]
        # 直到get_ip_info有返回了,才重新唤醒
        rep1, rep2 = yield [self.get_ip_info(ips[0]), self.get_ip_info(ips[1])]
        rep34_dict = yield dict(rep3=self.get_ip_info(ips[2]), rep4=self.get_ip_info(ips[3]))
        self.write_response(ips[0], rep1)
        self.write_response(ips[1], rep2)
        self.write_response(ips[2], rep34_dict['rep3'])
        self.write_response(ips[3], rep34_dict['rep4'])
    def write_response(self, ip, response):
        self.write(ip)
        self.write(":<br/>")
        if 1 == response["ret"]:
            self.write(u"国家:%s 省份: %s 城市: %s<br/>" % (response["country"], response["province"], response["city"]))
        else:
            self.write("查询IP信息错误<br/>")
    @tornado.gen.coroutine
    def get_ip_info(self, ip):
        http = tornado.httpclient.AsyncHTTPClient()
        response = yield http.fetch("http://int.dpool.sina.com.cn/iplookup/iplookup.php?format=json&ip=" + ip)
        if response.error:
            rep = {"ret:0"}
        else:
            rep = json.loads(response.body)
        # raise tornado.gen.Return(rep)  # 此处需要注意python2
        return rep
# Web应用App
class Application(tornado.web.Application):
    def __init__(self):
        settings = dict(
            template_path=os.path.join(os.path.dirname(__file__), "templates"),
            static_path=os.path.join(os.path.dirname(__file__), "media"),
            xsrf_cookies=False,
            cookie_secret="bZJc2sWbQLKos6GkHn/VB9oXwQt8S0R0kRvJ5/xJ89E=",
            login_url="/a/user/login",
            debug=True,
        )
        # self.db = torndb.Connection(
        #     host = 'localhost',
        #     database = 'test',
        #     user = 'root',
        #     password = 'root',
        # )
        super(Application, self).__init__([(r'/',MainHandler)], **settings)
def main():
    tornado.options.parse_command_line()
    # tornado.options.parse_config_file("https8010.conf")
    ssl_options = {
        "certfile": os.path.join(os.path.abspath("."), "213976088220462.pem"),#crt
        "keyfile": os.path.join(os.path.abspath("."), "213976088220462.key"),  # server.key
    }
    # http_server = tornado.httpserver.HTTPServer(Application(),ssl_options=ssl_options,xheaders=True)#ssl_options=ssl_options
    # 创建http(socket)服务器实例
    print(sys.getrecursionlimit())
    print(options.port)
    # http_server.listen(options.port)
    Application().listen(options.port)
    io = tornado.ioloop.IOLoop.current()# 异步网络库IOLoop
    # 返回当前线程的IOLoop实例
    io.start()
    # 启动IOLoop实例的I/O循环,同时服务器监听被打开
    # app = Application()
    # app.listen(options.port) 对http_server的简写方式
    # 其listen(端口)方法用来创建一个http服务器实例,并绑定到给定端口(注意:此时服务器并未开启监听)
if __name__ == "__main__":
    main()

def func(name):
    def inner_func(age): # 闭包
        # name为自由变量
        print( 'name:', name, 'age:', age)
    return inner_func
bb = func('the5fire')
bb(26)
# name: the5fire age: 26

def counter(start=0):
    def incr():
        nonlocal start
        start += 1
        return start
    return incr
c1 = counter(5) 
print(c1()) # 6
print(c1()) # 7
c2 = counter(50)
print(c2()) # 51
print(c2()) # 52
print(c1()) # 8
print(c1()) # 9

class Itcast(object):
    def __init__(self,subject1):
        self.subject1 = subject1
        self.subject2 = 'cpp'
    #属性访问时拦截器,只要访问属性就必须先调用此方法(包括方法(方法也是对象))
    # 所以此方法中,不能包含访问属性的语句:比如self.subject1
    def __getattribute__(self,obj):
        print("====1>%s"%obj)
        if obj == 'subject1':
            print('log subject1')
            return 'redirect python'
        else:   
            temp = object.__getattribute__(self,obj)
            print("====2>%s"%str(temp))
            return temp
    
    def show(self):
        print('this is Itcast')
s = Itcast("python")
print(s.subject1)
print(s.subject2)
#1. 先获取show属性对应的结果,,,,应该是一个方法
#2. 再调用方法show()
s.show()
# import types
# p1.eat = types.MethodType(eat, p1)
# ====1>subject1
# log subject1
# redirect python
# ====1>subject2
# ====2>cpp
# cpp
# ====1>show
# ====2><bound method Itcast.show of <__main__.Itcast object at 0x0>>
# this is Itcast

class Person(object):
    def __init__(self, newName, newAge):
        self.name = newName
        self.age = newAge
        # 	__slots__	=	("name",	"age")
        # 为了达到限制的⽬的,Python允许在定义class的时候
        # 定义⼀个特殊的 __slots__变量,来限制该class实例能添加的属性
@staticmethod
def test();
    pass
@classmethod
def testclass(cls):
    pass
laowang = Person("老王", 10000)
print(laowang.name)
print(laowang.age)
# 可以添加其它属性和方法,即使在类只没有定义
laowang.addr = "北京...."
print(laowang.addr)
#　给对象和类添加属性
laozhao = Person("老赵", 18)
#print(laozhao.addr)
Person.num = 100
print(laowang.num)
print(laozhao.num)
#　添加静态方法
Persion.test = test
Persion.testclass = testclass

# 添加方法
class Person(object):
    def __init__(self, newName, newAge):
        self.name = newName
        self.age = newAge
    def eat(self):
        print("-----%s正在吃----"%self.name)
def run(self):
    print("-----%s正在跑----"%self.name)
p1 = Person("p1", 10)
p1.eat()
p1.run = run
# p1.run()#虽然p1对象中 run属性已经指向了函数,但是这句代码还不正确
        #因为run属性指向的函数 是后来添加的,p1.run()的时候,并没有把p1当做第
        #1个参数,导致了第10行的函数调用的时候, 出现缺少参数的问题
import types
p1.run = types.MethodType(run, p1)
p1.run()

a = [1,2,3]
b = [1,2,3]
a == b  # True
a is b # Flase
c = copy.deepcopy(a)#　深拷贝
a == c  # True
a is c # Flase
id(a) # 指向a的内存地址
d = a #　id(d)和id(a)值相等 浅拷贝
a is d #　True

import os
ret = os.fork()#　创建一个新进程,父子进程都从这里开始
# 父进程的返回值会大于0(子进程ID),而子进程的返回值为0
print(ret)
# 父进程返回的是子进程ID,子进程中返回的是0
if ret>0:
    print("---父进程--%d-"%os.getpid())
else:
    print("---子进程---%d-%d-"%(os.getpid(),os.getppid()))
print("----over---")
# 13854
# ---父进程--13748-
# ----over---
# 0
# ---子进程---13846-13748-
# ----over---

import os
import time
#父进程
ret = os.fork()
if ret==0:
    #子进程
    print("--1--")
else:
    #父进程
    print("--2--")
#父子进程
ret = os.fork()
if ret==0:
    #孙子
    #儿子
    print("--11--")
else:
    #儿子
    #父进程
    print("--22--")
# --2--
# --22--
# --11--
# --1--
# --11--
# --22--

from multiprocessing import Process
import time
# 用Process创建的子进程,会保证所有的子进程运行完成
def test():
    for _ in range(5):
        print("---test---")
        time.sleep(1)
if __name__ == '__main__':
    p = Process(target=test)
    p.start() #让这个进程开始执行test函数里的代码
    # p.join()# 堵塞住进程,保证先完成子进程的代码
    p.join(1) # 表示主进程愿意等待子进程完成的时间,到了这个时间之后,
    # 不管子进程有没有完成自己的代码,父进程都会去执行了
    for _ in range(3):
        print("---main---")
        time.sleep(1)
# ---test---
# ---main---
# ---main------test---
# ---test---
# 
# ---main------test---
# 
# ---test---

from multiprocessing import Pool
import os
import time
def worker(num):
    for i in range(2):
        print("===pid=%d==num=%d="%(os.getpid(), num))
        time.sleep(1)
if __name__ == '__main__':
    # 进程池中对最多保存3个进程
    pool = Pool(3)
    for i in range(5):
        print("---%d---"%i)
        # 向进程池中添加任务
        # 注意:如果添加的任务数量超过了　进程池中进程的个数的话,那么不会导致添加不进入
        # 添加到进程中的任务　如果还没有被执行的话,那么此时　他们会等待进程池中的
        # 进程完成一个任务之后,会自动的去用刚刚的那个进程　完成当前的新任务
        pool.apply_async(worker, (i,))# 非阻塞子进程,使用进程池的所有进程
        #　pool.apply 主进程使用进程池中的一个进程,
        # 要等到这个进程工作完成之后才运行另一个进程,也就失去了多进程的意义
    pool.close()#关闭进程池,相当于不能够再次添加新任务了
    pool.join()# 主进程 创建/添加任务后,主进程默认不会等待进程池中的任务执行完后才结束
                # 而是当主进程的任务做完之后立马结束,如果这个地方没join,会导致
                # 进程池中的任务不会执行
# ---0---
# ---1---
# ---2---
# ---3---
# ---4---
# ===pid=15225==num=1=
# ===pid=15224==num=2=
# ===pid=15223==num=0=
# ===pid=15225==num=1====pid=15224==num=2====pid=15223==num=0=
# 
# 
# ===pid=15224==num=3====pid=15223==num=4=
# 
# ===pid=15223==num=4====pid=15224==num=3=

#修改import中的Queue为Manager
import	os
from multiprocessing import	Manager,Pool
def	writer(q):
    print("writer启动(%s),⽗进程为(%s)"%(os.getpid(),os.getppid()))
    for	i in "dongGe":
        q.put(i)
        
def	reader(q):
    print("reader启动(%s),⽗进程为(%s)"%(os.getpid(),os.getppid()))
    for	i in range(q.qsize()):
        print("reader从Queue获取到消息:%s"%q.get(True))
        
if	__name__=="__main__":
    print("(%s)	start"%os.getpid())
    q=Manager().Queue()	# 使⽤Manager中的Queue来初始化
    po=Pool()
    
    # 使⽤阻塞模式创建进程
    # 这样就不需要在reader中使⽤死循环了,可以让writer完全执⾏完成后,再⽤reader去读取
    po.apply(writer, (q,))
    po.apply(reader, (q,))
    
    po.close()
    po.join()
    print("(%s)	End" % os.getpid())
# (13748)start
# (13748)End
# writer启动(15731),⽗进程为(13748)
# reader启动(15733),⽗进程为(13748)
# reader从Queue获取到消息:d
# reader从Queue获取到消息:o
# reader从Queue获取到消息:n
# reader从Queue获取到消息:g
# reader从Queue获取到消息:G
# reader从Queue获取到消息:e

#使⽤元类创建出⼀个对象,这个对象称为"类"
MyClass	= MetaClass()	
#使⽤"类"来创建出实例对象
MyObject=MyClass()	
Animal = type("Animal",(),{})
a = Animal()

class Person():
    #　如下的打印说明:只要你使⽤关键字class
    # Python解释器在执⾏的时候就会创建⼀个对象
    print('iiii')
    pass
p = Person
#　type()查看对象是由哪个类创建出来的
# 打印元类:说明类对象是由元类创建的
print(type(p))
#　打印对象
print(100) # 类型在python在其实就是类,100就是由Int类创建的对象
print("femn".__class__)
print(p) # 类也是对象,才能打印出来
print(type(p()))
print(type(100))
# 实例对象是calss创建的,class类也是对象,那这个对象是由type()创建的,
#　type(类名,	由⽗类名称组成的元组(针对继承的情况,可以为空),包含属 性的字典(名称和值))
Person2 = type("Person2",(),{})
print(type(Person2()))
# iiii
# <class 'type'>
# 100
#　<class 'str'>
# <class '__main__.Person'>
# <class '__main__.Person'>
# <class 'int'>
# <class '__main__.Person2'>