flask 数据库连接池

博客参详地址

 

先预留出来

 

# class Foo(object):
#     name='hello'

#     def func(self,y):
#         return y+1
# 通过type来创建类
Foo = type('Foo', (object,), {'name': 'hello', 'func': lambda self, y: y + 1})
# 使用元类来创建类,一句话代码如上所示,type括号里面的第一个参数是所要创建的类名用字符串的格式,
# 紧接着的后一个参数是该类所需要继承的父类,用元祖的格式,
# 最后一个参数是一个大括号,里面的键值对是我们所创建的类的静态属性以及动态属性,也叫方法,PS:大括号里面的值可以为空,为空就是如下代码:
# class Base(object):
#     pass
hq = Foo()

# print(hq.name)

"""
class Foo(object):
    __metaclass__ = type  # 在python2中我们的类要继承的类用__metaclass__写到类下面静态属性的位置,

    name = 'peter'

    def func(self, z):
        return z + 2


hw = Foo()


class Foo1(object, metaclass=type):
    name = 'john'

    def func(self, a):
        return a + 3


ss = Foo1()
"""

"""
class SheType(type):
    def __init__(self, *args, **kwargs):
        print('hello from outside')
        super(SheType, self).__init__(*args, **kwargs)
        print('hello from')


class Foo2(object, metaclass=SheType):
    name = 'judy'

    def func(self, q):
        return q * 2
qq=Foo2()
print(qq.name)
"""

"""
class Fo1(object):
    name = 'peter'

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def func(self):
        ...
"""

# print(Fo1.__dict__)  # 这里得出的是键值对
# print(2,dir(Fo1))  # 这里得出的都是我们的key,


# ========================
"""
# 创建类的方法
class SheType(type):
    def __init__(self, *args, **kwargs):
        print('hello from outside')
        super(SheType, self).__init__(*args, **kwargs)
        print('hello from')


class Foo2(object, metaclass=SheType):

    def func(self, q):
        return q * 2


class Bar(Foo2):
    
    # 这里是type的派生类,我们按照继承顺序一直向上找到源头,type,
    # 只要是能找到type的类,就是我们的type的派生类,
    # 就会执行我们的type里面的init方法,除非被子类所覆盖
    
    ...

qq=Foo2()
"""

"""
class SheType(type):
    def __init__(self, *args, **kwargs):
        print('hello from outside')
        super(SheType, self).__init__(*args, **kwargs)
        print('hello from')


Base = SheType('Base', (object,), {})


class Foo2(object, metaclass=SheType):
    def func(self, q):
        return q * 2

"""

"""
# ===========已函数的方式继承type类=======
class SheType(type):
    def __init__(self, *args, **kwargs):
        print('hello from outside')
        super(SheType, self).__init__(*args, **kwargs)
        print('hello from')


def with_metaclass(arg):  # 这里的函数名with_metaclass是我们的wtforms源码里面就写好的,就是这样用的,我们一般就使用默认的即可
    return SheType('Base', (object,), {})  # Base = SheType('Base', (object,), {})


class Foo2(with_metaclass(object)):  # 我们这里把object传参过去,让该函数接收,
    addr = 'peking'

    def func(self, q):
        return q * 2
"""


class MyType(type):
    def __init__(self, *args, **kwargs):
        super(MyType, self).__init__(*args, **kwargs)


class Foo(object, metaclass=MyType):
    ...

 

import datetime

v = datetime.datetime.now()
h = datetime.timedelta(days=20)
new_d = v + h
# print(new_d)

from redis import Redis

conn = Redis(host='127.0.0.1')
v = conn.keys()
# print(v)

元类创建类方法涉及到继承:

class MyType(type):
    def __call__(self, *args, **kwargs):
        ...


class Foo(object,metaclass=MyType):
    def __init__(self):
        # self.__age='89'
        ...

    def __new__(cls, *args, **kwargs):
        ...


he = Foo()
# w=he._Foo__age
# print(w)

 

import pymysql
conn=pymysql.connect(host='127.0.0.1',port=3306,user='root',password='123',db='book_list')
cursor=conn.cursor(cursor=pymysql.cursors.DictCursor)
cursor.execute("select id,name from userinfo where pwd=%(pwd)s and name=%(name)s",{'pwd':'1234','name':'peter'})
# 从数据库里取出来的所有数据都是字符串,我们都需要记上引号进行处理,我们的数据类型是用于存入的时候,但是我们取出来的话就都是字符串的类型,
obj=cursor.fetchone()
conn.commit()
cursor.close()
conn.close()
print(obj)

 

import time
import pymysql
import threading
from DBUtils.PooledDB import PooledDB,SharedDBConnection
POOL=PooledDB(
    creator=pymysql,  # 使用链接数据库的模块
    maxconnections=6,  # 连接池允许的最大连接数,0还有None表示不限制连接数
    mincached=2,  # 初始化时,连接池中至少创建的空闲的链接,0表示不创建,
    maxcached=4,  # 连接池中最多闲置的链接,0和None表示不限制,
    maxshared=3,  # 连接池中最多共享的连接数量,0和None表示共享所有,PS:基本不用这个参数,
    # 因为pymysql和MySQLdb等模块的threadsafety都是1,所以无论设置这个值为多少,maxcached永远为0,也就是所有链接共享
    blocking=True, # 连接池中如果没有可用的链接,是否阻塞等待,
    maxusage=None, # 一个连接最多被重复使用的次数,None表示无限次
    setsession=[], # 开始会话前执行的命令列表,如['set datestyle to,''', 'set time zone...']
    ping=0, #pingMySQL服务端,检查是否服务可用, # 如: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='book_list',
    charset='utf8'
)

def func():
    conn=POOL.connection()
    cursor=conn.cursor(cursor=pymysql.cursors.DictCursor)
    cursor.execute('select name from userinfo')
    ret=cursor.fetchall()
    cursor.close()
    conn.close()
    return ret
res=func()
print(res)

 

class Foo():
    """
    只要我们的类里面有这个iter方法就可以使用yield,它就是一个迭代器
    """
    def __iter__(self):
        yield 321
        yield 23
        yield 9

j=Foo()
for i in j:
    print(i)  # 迭代器利用for循环取值