import functools   #装饰器用过的模块
 
def index(a,b):
    return a+b
new_fun=functools.partial(index,666)   #666当作第一个参数
 
#原来的调用
# ret=index(1,2)
#
# print(ret)
ret=new_fun(1)   #偏函数，帮助开发者自动传递参数
print(ret)

class Base(object):
    def func(self):
        print('Base.func')
class Foo(Base):
    def func(self):
        #方式一：根据mro的顺序执行方法  
        # super().func()
        #方式二：主动执行Base类的方法
        # Base.func(self)
        print('Foo.func')
obj=Foo()
obj.func()
print(obj.__mro__)

class Foo(object):
    def __init__(self):
        #self.duoduo={}    直接定于会发现调用__setattr__方法时，还没有生成会报错
        object.__setattr__(self,'duoduo',{})
    def __setattr__(self, key, value):
        print(key,value,self.duoduo)
obj=Foo()
print(obj.duoduo)

class Stack(object):
    def __init__(self):
        self.data=[]
    def push(self,val):
        self.data.append(val)
    def pop(self):
        return self.data.pop()
_stack=Stack()
_stack.push('大娃')
_stack.push('二娃')
print(_stack.pop())
print(_stack.pop())

try:
    from greenlet import getcurrent as get_ident   #获取协程的唯一标记
except:
    from threading import get_ident   #获取线程的唯一标记
 
class Local(object):
    def __init__(self):
        object.__setattr__(self,'storage',{})
    def __setattr__(self, key, value):
        ident=get_ident()
        if ident not in self.storage:
            self.storage[ident]={key,value}
        else:
            self.storage[ident][key]=value
    def __getattr__(self, item):
        ident=get_ident()
        if ident in self.storage:
            return self.storage[ident].get(item)

from flask import globals  #点globals
_request_ctx_stack = LocalStack()  #点LocalStack()
self._local = Local()   #点Local

pip3 install  flask-session

import redis
from flask import Flask
from flask.sessions import SecureCookieSessionInterface
from flask_session import Session
duo=Flask(__name__)
#duo.session_interface=SecureCookieSessionInterface()
#duo.session_interface=RedisSessionInterface()
duo.config['SESSION_TYPE']='redis'
duo.config['SESSION_TYPE']=redis.Redis(host='11.1.11.1',port=6379,password='123456')
Session(duo)

from flask_session import RedisSessionInterface

pip3 install DBUtils

import time
import pymysql
import threading
from DBUtils.PooledDB import PooledDB, SharedDBConnection
POOL = PooledDB(
    creator=pymysql,  # 使用链接数据库的模块
    maxconnections=6,  # 连接池允许的最大连接数，0和None表示不限制连接数
    mincached=2,  # 初始化时，链接池中至少创建的空闲的链接，0表示不创建
    maxcached=5,  # 链接池中最多闲置的链接，0和None不限制
    maxshared=3,  # 链接池中最多共享的链接数量，0和None表示全部共享。
PS: 无用，因为pymysql和MySQLdb等模块的 threadsafety都为1，所有值无论设置为多少，_maxcached永远为0，
所以永远是所有链接都共享。
    blocking=True,  # 连接池中如果没有可用连接后，是否阻塞等待。True，等待；False，不等待然后报错
    maxusage=None,  # 一个链接最多被重复使用的次数，None表示无限制
    setsession=[],  # 开始会话前执行的命令列表。如：["set datestyle to ...", "set time zone ..."]
    ping=0,
    # 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
    host='127.0.0.1',
    port=3306,
    user='root',
    password='123',
    database='db',
    charset='utf8'
)
def func():
    # 检测当前正在运行连接数的是否小于最大链接数，如果不小于则：等待或报raise TooManyConnections异常
    # 否则
    # 则优先去初始化时创建的链接中获取链接 SteadyDBConnection。
    # 然后将SteadyDBConnection对象封装到PooledDedicatedDBConnection中并返回。
    # 如果最开始创建的链接没有链接，则去创建一个SteadyDBConnection对象，再封装到PooledDedicatedDBConnection中并返回。
    # 一旦关闭链接后，连接就返回到连接池让后续线程继续使用。
    conn = POOL.connection()
    cursor = conn.cursor(pymysql.cursors.DictCursor)  #pymsql
    cursor.execute('select * from tb1')
    result = cursor.fetchall()
    conn.close()
func()