1 from flask import Flask, flash, get_flashed_messages
 2 
 3 app = Flask(__name__)
 4 app.secret_key = 'asdfasdf'
 5 
 6 @app.route('/get')
 7 def get():
 8     # 从某个地方获取设置过得所有值，并清除
 9     data = get_flashed_messages()
10     print(data)
11     return 'Hello World!'
12 
13 @app.route('/set')
14 def set():
15     # 向某个地方设置一个值
16     flash('阿斯蒂芬')
17     return 'Hello World!'
18 if __name__ == '__main__':
19     app.run()

1 @app.before_request
2 def process_request(*args, **kwargs):
3     if request.path == '/login':
4         return None
5     user = session.get('user_info')
6     if user:
7         return None
8     return redirect('/login')        

 1  from flask import Flask, render_template, request, redirect, session, url_for
 2 app = Flask(__name__)
 3 app.secret_key = 'asdfasdf'
 4 
 5 @app.before_request
 6 def process_request1(*args, **kwargs):
 7     print('process_request1进来了')
 8 
 9 @app.before_request
10 def process_request2(*args, **kwargs):
11     print('process_request2进来了')
12 
13 @app.after_request
14 def process_response1(response):
15     print('process_response1走了')
16     return response
17 
18 @app.after_request
19 def process_response2(response):
20     print('process_response2走了')
21     return response
22 
23 @app.route('/index', methods=['GET'])
24 def index():
25     print('index函数')
26     return 'Index'
27 
28 if __name__ == '__main__':
29     app.run()
30 
31 运行结果：
32     process_request1进来了
33     process_request2进来了
34     index函数
35     process_response2走了
36     process_response1走了

 1 from flask import Flask, render_template, request, redirect, session, url_for
 2 
 3 app = Flask(__name__)
 4 app.secret_key = 'asdfasdf'
 5 
 6 @app.before_request
 7 def process_request1(*args, **kwargs):
 8     print('process_request1进来了')
 9     return '拦截'
10 
11 @app.before_request
12 def process_request2(*args, **kwargs):
13     print('process_request2进来了')
14 
15 @app.after_request
16 def process_response1(response):
17     print('process_response1走了')
18     return response
19 
20 @app.after_request
21 def process_response2(response):
22     print('process_response2走了')
23     return response
24 
25 @app.route('/index', methods=['GET'])
26 def index():
27     print('index函数')
28     return 'Index'
29 
30 if __name__ == '__main__':
31     app.run()

1 @app.errorhandler(404)
2 def error_404(arg):
3     return '404错误了'

 1 @app.template_global()
 2 def sb(a1, a2):
 3     return a1 + a2
 4 
 5 # 在HTNL中使用：{{sb(1,2)}}
 6         
 7 @app.template_filter()
 8 def db(a1, a2, a3):
 9     return a1 + a2 + a3
10 
11 # 在HTNL中使用：{{ 1|db(2,3)}}

1 @app.before_first_request
2 def first(*args, **kwargs):
3     pass

 1 from flask import Flask, request
 2 
 3 app = Flask(__name__)
 4 
 5 @app.route('/')
 6 def index():
 7     return 'Hello World!'
 8 
 9 
10 class Md(object):
11     def __init__(self, old_wsgi_app):
12         self.old_wsgi_app = old_wsgi_app
13     def __call__(self, environ, start_response):
14         print('开始之前')
15         ret = self.old_wsgi_app(environ, start_response)
16         print('结束之后')
17         return ret
18 
19 if __name__ == '__main__':
20     app.wsgi_app = Md(app.wsgi_app)
21     app.run()

 1 import threading
 2 import time
 3 
 4 local_values = threading.local()
 5 
 6 class Foo(object):
 7     def __init__(self):
 8         self.name = 0
 9 
10 local_values = Foo()
11 
12 def func(num):
13      local_values.name = num
14      time.sleep(1)
15      print(local_values.name, threading.current_thread().name)
16 
17 for i in range(20):
18     th = threading.Thread(target=func, args=(i,), name='线程%s' % i)
19     th.start()

 1  import threading
 2 
 3 try:
 4     from greenlet import getcurrent as get_ident  # 协程
 5 except ImportError:
 6     try:
 7         from thread import get_ident
 8     except ImportError:
 9          from _thread import get_ident  # 线程
10 
11 
12 class local(object):
13     def __init__(self):
14         self.storage = {}
15         self.get_ident = get_ident
16     
17     def set(self, k, v):
18          ident = self.get_ident()
19          origin = self.storage.get(ident)
20          if not origin:
21             origin = {k:v}
22          else:
23             origin[k] = v
24           self.storage[ident] = origin
25      
26     def get(self, k):
27            ident = self.get_ident()
28            origin = self.storage.get(ident)
29            if not origin:
30                return None
31            return origin.get(k, None)
32 
33 local_values = local()
34 
35 def task(num):
36     local_values.set('name', num)
37     import time
38     time.sleep(1)
39   print(local_values.get('name'),threading.current_thread().name)
40 
41 for i in range(20):
42     th = threading.Thread(target=task, args=(i,), name='线程%s' % i)
43     th.start()    

1 import functools
2 
3 def func(a1, a2):
4     print(a1, a2)
5 
6 new_func = functools.partial(func, 666)
7 new_func(999)

 1 class Foo(object):
 2     def __init__(self, num):
 3         self.num = num
 4     
 5     def __add__(self, other):
 6         data = self.num + other.num
 7         return Foo(data)
 8 
 9 obj1 = Foo(1)
10 obj2 = Foo(2)
11 v = obj1 + obj2

 1 class Foo(object):
 2     def __init__(self):
 3         self.name = 'alex'
 4         self.__age = 18
 5     
 6     def get_age(self):
 7          return self.__age
 8 
 9 obj = Foo()
10 print(obj.name)
11 # 强制获取私有字段
12 print(obj._Foo__age)
13 print(obj.get_age())

1 from itertools import chain
2 
3 v1 = [11, 22, 33]
4 v2 = [44, 55, 66]
5 new = chain(v1, v2)
6 for item in new:
7     print(item)

 1 from itertools import chain
 2 
 3 def f1(x):
 4     return x + 1
 5 
 6 func1_list = [f1, lambda x:x-1]
 7 
 8 def f2(x):
 9     return x + 10
10 
11 new_fun_list = chain([f2], func1_list)
12 
13 for func in new_fun_list:
14     print(func)

 1 import pymysql
 2 CONN = pymysql.connect(host='127.0.0.1',
 3                                        port=3306,
 4                                        user='root',
 5                                        password='123',
 6                                        database='pooldb',
 7                                        charset='utf8')
 8 cursor = CONN.cursor()
 9 cursor.execute('select * from tb1')
10 result = cursor.fetchall()
11 cursor.close()
12 print(result)

 1 import time
 2 import pymysql
 3 from DBUtils.PooledDB import PooledDB
 4 
 5 POOL = PooledDB(
 6     creator=pymysql,  # 使用链接数据库的模块
 7     maxconnections=6,  # 连接池允许的最大连接数，0和None表示不限制连接数
 8     mincached=2,  # 初始化时，链接池中至少创建的空闲的链接，0表示不创建
 9     maxcached=5,  # 链接池中最多闲置的链接，0和None不限制
10     maxshared=3,  # 链接池中最多共享的链接数量，0和None表示全部共享。PS: 无用，因为pymysql和MySQLdb等模块的 threadsafety都为1，所有值无论设置为多少，_maxcached永远为0，所以永远是所有链接都共享。
11     blocking=True,  # 连接池中如果没有可用连接后，是否阻塞等待。True，等待；False，不等待然后报错
12     maxusage=None,  # 一个链接最多被重复使用的次数，None表示无限制
13     setsession=[],  # 开始会话前执行的命令列表。如：["set datestyle to ...", "set time zone ..."]
14     ping=0,
15     # ping MySQL服务端，检查是否服务可用。# 如：0 = None = never, 1 = default = whenever it is requested, 2 = when a cursor is created, 4 = when a query is executed, 7 = always
16     host='127.0.0.1',
17     port=3306,
18     user='root',
19     password='123',
20     database='pooldb',
21     charset='utf8'
22 )
23 
24 class SQLHelper(object):
25 @staticmethod
26 def fetch_one(sql, args):
27     conn = POOL.connection()
28     cursor = conn.cursor()
29     cursor.execute(sql, args)
30     result = cursor.fetchone()
31     conn.close()
32     return result
33     
34 @staticmethod
35 def fetch_all(sql, args):
36     conn = POOL.connection()
37     cursor = conn.cursor()
38     cursor.execute(sql, args)
39     result = cursor.fetchall()
40     conn.close()
41     return result
42 
43 result = SQLHelper.fetch_one('select * from tb1 where id > %s', [1,])
44 print(result)

 1  class Foo:
 2     def __init__(self):
 3        self.age = 23
 4        self.name = 'xiaoming'
 5 
 6 class Bar:
 7     def __init__(self):
 8         self.xx = 123
 9 
10 # 把类再封装到一个对象里面
11 class Base:
12     def __init__(self):
13         self.f = Foo()
14         self.x = Bar()

 __new__
__init__
__call__
__str__
__setattr__
__getattr__
__setitem__
__enter__
__exit__
__add__