据悉DBUtils实现数据库连接池必发365bifa0000

by admin on 2019年1月4日

在堆砌些文字在此以前,仍旧先以网络上的图片领略和感受下他小海河的迷雾和高椅岭的奇异吧。

必发365bifa0000 1

作为正式宅男,两点一线的生活已是习惯至麻木,因而于心境和人体都未曾常出去走走看看的惯性。
故此鲜有接触这一个世界那么多未知的境界。而本次前往龙岩观光小乌伦古河,很难不将其归纳为两遍苦旅,虽然对于经历甚久的驴友。然则,游历归来,感知更多的是:这一切都是值得的,累并愉悦着的旅行。

情势一:为每一个线程创设一个链接(是按照本地线程来促成的。thread.local),每个线程独立行使自己的数据库链接,该线程关闭不是确实的关闭,本线程再一次调用时,仍然采取的最起初创办的链接,直到线程终止,数据库链接才关闭

必发365bifa0000 2

 

东江湖

用了本地线程之后

因为短暂,故而显得更难能可贵,由此越是青睐!因为共同广大突发意况,游历路线也是一变再变。最终我们的游览路程如下:1号上午3点许乘坐游艇从大黑河水库大坝起身历经1个多钟头住宿的地点(清东农户,吃枇杷,各自玩耍)2号早六点起,乘游艇回到鉴江水库大坝,徒步小乌伦古河。历经近4时辰完毕后乘车前往丽水高椅岭,前后2个多时辰即可稍涉猎高椅岭,2号中午四点许乘车杀回费城,晚11点多归之。行程时间很紧,也为此都很注重。

五、本地线程:保证每个线程都唯有和谐的一份数据,在操作时不会潜移默化别人的,尽管是多线程,自己的值也是互为隔离的

小鸭绿江迷雾~2015/05/02

 

必发365bifa0000 3

def release_local(local):
    local.__release_local__()


class Local(object):
    __slots__ = ('__storage__', '__ident_func__')

    def __init__(self):
        # self.__storage__ = {}
        # self.__ident_func__ = get_ident
        object.__setattr__(self, '__storage__', {})
        object.__setattr__(self, '__ident_func__', get_ident)

    def __release_local__(self):
        self.__storage__.pop(self.__ident_func__(), None)

    def __getattr__(self, name):
        try:
            return self.__storage__[self.__ident_func__()][name]
        except KeyError:
            raise AttributeError(name)

    def __setattr__(self, name, value):
        ident = self.__ident_func__()
        storage = self.__storage__
        try:
            storage[ident][name] = value
        except KeyError:
            storage[ident] = {name: value}

    def __delattr__(self, name):
        try:
            del self.__storage__[self.__ident_func__()][name]
        except KeyError:
            raise AttributeError(name)


class LocalStack(object):
    def __init__(self):
        self._local = Local()

    def __release_local__(self):
        self._local.__release_local__()

    def push(self, obj):
        """Pushes a new item to the stack"""
        rv = getattr(self._local, 'stack', None)
        if rv is None:
            self._local.stack = rv = []
        rv.append(obj)
        return rv

    def pop(self):
        """Removes the topmost item from the stack, will return the
        old value or `None` if the stack was already empty.
        """
        stack = getattr(self._local, 'stack', None)
        if stack is None:
            return None
        elif len(stack) == 1:
            release_local(self._local)
            return stack[-1]
        else:
            return stack.pop()

    @property
    def top(self):
        """The topmost item on the stack.  If the stack is empty,
        `None` is returned.
        """
        try:
            return self._local.stack[-1]
        except (AttributeError, IndexError):
            return None


stc = LocalStack()

stc.push(123)
v = stc.pop()

print(v)

必发365bifa0000 4

app1中:
    import app2
    print('app1', __name__)


app2中:
    print('app2', __name__)

写在码字此前:过一个平凡无趣的人生其实太容易了,你可以不读书,不冒险,不移动,不写作,不外出,不折腾……可是,人生最终悔的事情就是:我本可以。——陈素封

主意二、不补助并发

旅游的本色就是:旅游一贯就是一个人从友好待腻的地点到其旁人待腻的地点!非凡认同这观点。现在的心绪来看说怎么“一个人的生平,一定要有三次说走就走的远足。”,抑或是“要么读书,要么旅行,灵魂和人身,一定要有一个在旅途”,这样的略微是有些矫情的。旅行这事儿的本身,就巴望是没什么关系的;也难以企及到心灵的救赎。其区别也不在于距离的远近。但是旅行那事情,是很有必要去做的。一如读书,不在于是否读过和读完,而在于读有所思品有所获;不同的人不等心态,赏读同一本书,品味同一处景,所精晓的究竟是相形见绌的;亲历的才是上下一心的。

class Foo(dict):
    def __init__(self,val):
        # dict.__init__(self, val)#继承父类方式一
        # super().__init__(val)  #继承父类方式二
        super(Foo,self).__init__(val)#继承父类方式三
obj = Foo({"xxx":123})
print(obj)

过一个平淡无奇无趣的人生其实太容易了,你可以不读书,不冒险,不活动,不写作,不外出,不折腾……不过,人生最终悔的工作就是:我本可以(陈素封)。

 

高椅岭

  1. Flask内部贯彻

    #!/usr/bin/env python
    # –– coding:utf-8 –

    from greenlet import getcurrent as get_ident

必发365bifa0000 5

- 重写了__setitem__方法
- 继承dict

原文首贴链接http://jeffjade.com/2015/05/03/2015-05-03-tour-chenzhou/

class Foo(object):
    def __setitem__(self, key, value):
        print(key,value)

obj = Foo()
obj["xxx"] = 123   #给对象赋值就会去执行__setitem__方法

气象之于观景的严重性,在步行小和田河之时体会的更深。小闽江其长有十多海里,其美著称于小长江晨雾。我们一行起身也晚(早8点多),加上有过路线的调整等,晨雾于我们那时只是奢望了。行至一半,这出云就来大雨的急转直下给自身门造成了重重劳神。一度以为行程会由此而更是延迟,然则美好有时候就在转角处,什么人又说的可以吗?10多分钟以后,雨停了,而这雨的存在甚至是还给我们一个观赏迷雾的良机,这个失而复得的撼动和兴奋,言语难以形容;但见:雾起于江,随风绵延,宛若一条玉带在山沟中飘摇,似驾祥云,好如仙境;更兼江水倒影着长空,咋看真如乾坤倒置,美不胜收。那一个年纪的我们在随心所欲感受着美好的还要,肯定不会少了定格(拍照)和享受(发盆友圈)这美好了,本人自然也是这般,亲自产出不少华丽须臾间,定格在手机和记念里,随意挑了两张贴出如下(批注:手机配备~One plusX9077)。

必发365bifa0000 6

高椅岭

import threading
import time

class Foo(object):
    def __init__(self):
        self.name = None
local_values = Foo()

def func(num):
    time.sleep(2)
    local_values.name = num
    print(local_values.name,threading.current_thread().name)

for i in range(5):
    th = threading.Thread(target=func, args=(i,), name='线程%s' % i)
    th.start()

必发365bifa0000 7

#!usr/bin/env python
# -*- coding:utf-8 -*-
import pymysql
from  flask import Flask
from threading import RLock

app = Flask(__name__)
CONN = pymysql.connect(host="127.0.0.1",port=3306,user='root',password='123', database='pooldb',charset='utf8')
# 方式二:放在全局,如果是单线程,这样就可以,但是如果是多线程,就得加把锁。这样就成串行的了
#        不支持并发,也不好。所有我们选择用数据库连接池
@app.route('/index')
def index():
    with RLock:
        cursor = CONN.cursor()
        cursor.execute("select * from td where id=%s", [5, ])
        result = cursor.fetchall()  # 获取数据
        cursor.close()
        print(result)
        return  "执行成功"
if __name__ == '__main__':
    app.run(debug=True)

凡事景语皆情语!所以欣赏风光的时候心绪很重大。要了然那一个心态是一种会传染的存在。感谢一同出行的豪门,将心怀保持的这么好,尽管在遇见如下面那般碰到之后。

1 线程1
0 线程0
2 线程2
3 线程3
4 线程4

这里风景的美,在于山水,更在乎人。汉水湖到底碧绿,湖边间歇零星着些养鱼网拉起的池;偶尔也能看出四只木制舟船上的二伯垂钓湖间。两岸皆山,山脚充斥着各色的果林;果林再上去就是人民人家,大多也是现在大楼建筑。1号晚,我们歇脚的农家,是一栋两层大楼,带着一个不很大的小院;院子里有两株枇杷,一到此大家就将主人公的这个个枇杷吃了个够,这香甜,啧啧!这里风景娟秀,养育的人无论大小更是勤劳热情,温婉宽厚,雅致可人。我们一行小年青,显得倒失了稳健和礼仁。之后在高椅岭当下一家食堂就餐也是一个认证:因高椅岭从不着力开发,这里的铺面很少。而此店菜肴味道尚可,价格公道,分量也足,店主也是蛮好说话。景美,在于物景,更在于人心。

小知识:

对于高椅岭这一个“一个被上帝遗忘的地点,一个美得一塌糊涂的地点”,其地貌颇奇特,旖旎甚壮观。品味她就不需要着意关注什么日期去揭开她雅观的面罩。因外表原因没怎么经过人工的叨扰(只是在很惊险出加了护栏)
保持了原味的野性十足;当然,倘有朝阳落日,夕月星光的装点,她的野性十足美就更显示妩媚无暇。因时光压缩的紧极了,在此时逗留的时刻很短,只是看了个大致;整个人都在脚不驻歇,手不停拍,争求从各个角度跟她合影。手机也能照出单反相机的效果说的就是这种地方。更多关于她的裸照可参见那两篇作品北海高椅岭01

河源高椅岭02
,其盛美可见一斑.

方式三:继承dict,重写__init__主意的时候,记得要持续父类的__init__方法

本次出行依旧跟随 卡拉奇野人户外
这个很和气且活力四射的集体共同。(15年)6月30日晚8点自布拉迪斯拉发启程,一路渐行渐停,等抵达目的地已经是10月1号早晨。本来五六钟头的路途,因为外出的小日子缘起于五一小长假,也因五一致使大家的行程用时多了两倍。至于原因肯定:“堵”(因人多,也因有车祸),我大天朝最不缺的就是素质有待提升的人嘛。祸患总是不单行的,托运我们的巴士也闹闹脾气:不在喷吐冷气。这样的气候碰上这样的事情,坚强的咱们心态都还好。至少没留下泪水,当然或许是肢体里的水都从汗腺喷涌而出了(这样描绘有点过头,没办法就是有些体胖的自身惧热啊)。一杯水,假如赠送在给热渴交迫时候的你,那一个它的价值无形就被升级若干翻番吧。正因为这么的阅历,也为事后的出境游欢喜的心气加分不少了。

一、设置配置文件的三种模式

必发365bifa0000 8

class Foo(dict):
    pass

obj = Foo()
obj["xxx"] = 123
print(obj)

小东江

import threading
import time
# 本地线程对象
local_values = threading.local()
def func(num):

    """
    # 第一个线程进来,本地线程对象会为他创建一个
    # 第二个线程进来,本地线程对象会为他创建一个
    {
        线程1的唯一标识:{name:1},
        线程2的唯一标识:{name:2},
    }
    :param num:
    :return:
    """
    local_values.name = num # 4
    # 线程停下来了
    time.sleep(2)
    # 第二个线程: local_values.name,去local_values中根据自己的唯一标识作为key,获取value中name对应的值
    print(local_values.name, threading.current_thread().name)


for i in range(5):
    th = threading.Thread(target=func, args=(i,), name='线程%s' % i)
    th.start()

小闽江迷雾~2015/05/02

必发365bifa0000 9

小东江

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='pooldb',
    charset='utf8'
)


def func():
    # 检测当前正在运行连接数的是否小于最大链接数,如果不小于则:等待或报raise TooManyConnections异常
    # 否则
    # 则优先去初始化时创建的链接中获取链接 SteadyDBConnection。
    # 然后将SteadyDBConnection对象封装到PooledDedicatedDBConnection中并返回。
    # 如果最开始创建的链接没有链接,则去创建一个SteadyDBConnection对象,再封装到PooledDedicatedDBConnection中并返回。
    # 一旦关闭链接后,连接就返回到连接池让后续线程继续使用。

    # PooledDedicatedDBConnection
    conn = POOL.connection()

    # print(th, '链接被拿走了', conn1._con)
    # print(th, '池子里目前有', pool._idle_cache, '\r\n')

    cursor = conn.cursor()
    cursor.execute('select * from tb1')
    result = cursor.fetchall()
    conn.close()





    conn = POOL.connection()

    # print(th, '链接被拿走了', conn1._con)
    # print(th, '池子里目前有', pool._idle_cache, '\r\n')

    cursor = conn.cursor()
    cursor.execute('select * from tb1')
    result = cursor.fetchall()
    conn.close()


func()

但是然对于一些景象本身,其时令季节,天气情况是这个首要的。江西铜仁大渡河这里,就是这样的一流。她好如是一个长相娟秀,性格刁蛮的妙龄女孩儿;只有在这样相当的每一日方能感受到他至美的繁荣。刚到这里就感受了下那里天空耀着太阳而扬尘撒撒的雨,忽而也就停了,阳光仍然,后来也会总有多么大片的乌云来粗热闹,时而将天空构成一幅水墨,一会儿就好如神佛降临(阳光透过乌云倾泻下来这感觉)。湖水甚是碧绿,乘着游艇,感受这里湖风清爽亲吻着皮肤,仰看云舒伴云卷,平观淡雾秀青山,俯瞰绿水荡波澜,这感觉简直是,美翻了;从前的疲惫烦热也由此而消隐无踪。如此美景,不敢独留,贴出一张之如下,与君共享(批注:手机油画未做其他处理~一加X9077)。;

必发365bifa0000 10

必发365bifa0000 11

from flask import Flask
#导入accout 和order
from fcrm.views import accout
from fcrm.views import order
app = Flask(__name__)
print(app.root_path)  #根目录

app.register_blueprint(accout.accout)  #吧蓝图注册到app里面,accout.accout是创建的蓝图对象
app.register_blueprint(order.order)

设想你能得瑟到100岁不老眼昏花复发性风湿病手抖,从前日启幕每个月正经读好(消化)一本书,还不包括各类始料未及各个不可以按计划完成任务的意况,那辈子也只剩余几百本书可读了。倘若你能得瑟到100岁腿脚还灵便坚贞不屈每年去一个国度,都溜达不完这世界上一半的地方。一百年太长,嗯,连五年都不佳意思说,就一年呢,一年后的前些天,你想要成为何的人?世界太大,生命太短,何人知道过完这辈子,要在轮回里变草变树折腾多长时间才有可能再次来到这世界来再走一圈。患失患得,瞻前顾后,无病呻吟,都是因为你读书太少,还不够忙,还活得不够美观。若你挑选了远方,一定会专注风雨兼程。告诉自己,你还有稍稍时间。好好和友爱情商研究,然后不顾一切地去吃苦吧。苦是你的粮食。不要问,不要等,不要犹豫,不要回头。(引自Here)

导入来拿。能够不要导入,。直接导入一个current_app,这些就是眼下的app对象,用current_app.config就能查看到了目前app的具备的部署文件

accout.py

order.py

依据DButils实现的数据库连接池有二种情势:

    - BDUtils数据库链接池  
                - 模式一:基于threaing.local实现为每一个线程创建一个连接,关闭是
                  伪关闭,当前线程可以重复
                - 模式二:连接池原理
                        - 可以设置连接池中最大连接数    9
                        - 默认启动时,连接池中创建连接  5

                        - 如果有三个线程来数据库中获取连接:
                            - 如果三个同时来的,一人给一个链接
                            - 如果一个一个来,有时间间隔,用一个链接就可以为三个线程提供服务
                                - 说不准
                                    有可能:1个链接就可以为三个线程提供服务
                                    有可能:2个链接就可以为三个线程提供服务
                                    有可能:3个链接就可以为三个线程提供服务
                         PS、:maxshared在使用pymysql中均无用。链接数据库的模块:只有threadsafety>1的时候才有用

 必发365bifa0000 12

==========方式一:============
 app.config['SESSION_COOKIE_NAME'] = 'session_lvning'  #这种方式要把所有的配置都放在一个文件夹里面,看起来会比较乱,所以选择下面的方式
==========方式二:==============
app.config.from_pyfile('settings.py')  #找到配置文件路径,创建一个模块,打开文件,并获取所有的内容,再将配置文件中的所有值,都封装到上一步创建的配置文件模板中

print(app.config.get("CCC"))

=========方式三:对象的方式============
 import os 
 os.environ['FLAKS-SETTINGS'] = 'settings.py'
 app.config.from_envvar('FLAKS-SETTINGS') 

===============方式四(推荐):字符串的方式,方便操作,不用去改配置,直接改变字符串就行了 ==============
app.config.from_object('settings.DevConfig')

----------settings.DevConfig----------

from app import app
class BaseConfig(object):
    NNN = 123  #注意是大写
    SESSION_COOKIE_NAME = "session_sss"

class TestConfig(BaseConfig):
    DB = "127.0.0.1"

class DevConfig(BaseConfig):
    DB = "52.5.7.5"

class ProConfig(BaseConfig):
    DB = "55.4.22.4"

__init__.py(只要一导入fcrm就会执行__init__.py文件)

        - 本地线程:是Flask自己创建的一个线程(猜想:内部是不是基于本地线程做的?)
           vals = threading.local()
           def task(arg):
                vals.name = num
            - 每个线程进来都是打印的自己的,只有自己的才能修改,
            - 通过他就能保证每一个线程里面有一个数据库链接,通过他就能创建出数据库链接池的第一种模式
        - 上下文原理
            -  类似于本地线程
        - 猜想:内部是不是基于本地线程做的?不是,是一个特殊的字典
import fcrm
if __name__ == '__main__':
    fcrm.app.run()

2、对象通过索引设置值的二种方法

@app.route('/index',methods=["GET","POST"])
def index():
    print(current_app.config)   #当前的app的所有配置
    session["xx"] = "fdvbn"
    return "index"

flask中是不曾ORM的,假设在flask里面连接数据库有两种形式

总计:假诺遭遇obj[“xxx”] = xx 
, 

现在app1是主程序,运行结果截图

那么大家用pymysql来做。

    PS:假诺最大链接数有10个,其实也就是一个列表,当你pop一个,人家会在append一个,链接池的保有的链接都是比照排队的如此的法门来链接的。

 

 

注: 情势一:倘使线程相比多如故会成立很多一连,格局二更常用 

a、类似于本地线程
            创建Local类:
            {
                线程或协程唯一标识: { 'stack':[request],'xxx':[session,] },
                线程或协程唯一标识: { 'stack':[] },
                线程或协程唯一标识: { 'stack':[] },
                线程或协程唯一标识: { 'stack':[] },
            }
        b、上下文管理的本质
            每一个线程都会创建一个上面那样的结构,
            当请求进来之后,将请求相关数据添加到列表里面[request,],以后如果使用时,就去读取
            列表中的数据,请求完成之后,将request从列表中移除
        c、关系
            local = 小华={
                线程或协程唯一标识: { 'stack':[] },
                线程或协程唯一标识: { 'stack':[] },
                线程或协程唯一标识: { 'stack':[] },
                线程或协程唯一标识: { 'stack':[] },
            }
            stack = 强哥 = {
                push
                pop
                top
            }
            存取东西时都要基于强哥来做
        d、最近看过一些flask源码,flask还是django有些区别
            - Flask和Django区别?
                - 请求相关数据传递的方式
                    - django:是通过传request参数实现的
                    - Flask:基于local对象和,localstark对象来完成的
                             当请求刚进来的时候就给放进来了,完了top取值就行了,取完之后pop走就行了

                    问题:多个请求过来会不会混淆
                        -答: 不会,因为,不仅是线程的,还是协程,每一个协程都是有唯一标识的:
                            from greenlent import getcurrentt as get_ident  #这个就是来获取唯一标识的        

必发365bifa0000 13

示例:

#!usr/bin/env python
# -*- coding:utf-8 -*-
from flask import Flask
app = Flask(__name__)
from DBUtils.PersistentDB import PersistentDB
import pymysql
POOL = PersistentDB(
    creator=pymysql,  # 使用链接数据库的模块
    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
    closeable=False,
    # 如果为False时, conn.close() 实际上被忽略,供下次使用,再线程关闭时,才会自动关闭链接。如果为True时, conn.close()则关闭链接,那么再次调用pool.connection时就会报错,因为已经真的关闭了连接(pool.steady_connection()可以获取一个新的链接)
    threadlocal=None,  # 本线程独享值得对象,用于保存链接对象,如果链接对象被重置
    host='127.0.0.1',
    port=3306,
    user='root',
    password='123',
    database='pooldb',
    charset='utf8'
)

@app.route('/func')
def func():

  conn = POOL.connection()
  cursor = conn.cursor()
  cursor.execute('select * from tb1')
  result = cursor.fetchall()
  cursor.close()
  conn.close() # 不是真的关闭,而是假的关闭。 conn = pymysql.connect()   conn.close()

  conn = POOL.connection()
  cursor = conn.cursor()
  cursor.execute('select * from tb1')
  result = cursor.fetchall()
  cursor.close()
  conn.close()

if __name__ == '__main__': app.run(debug=True)

3、测试__name__方法

 

二、蓝图(flask中多py文件拆分都要用到蓝图)

行使蓝图时索要小心的

一:pymysql
二:SQLAlchemy
        是python 操作数据库的一个库。能够进行 orm 映射官方文档 sqlchemy
        SQLAlchemy“采用简单的Python语言,为高效和高性能的数据库访问设计,实现了完整的企业级持久模型”。SQLAlchemy的理念是,SQL数据库的量级和性能重要于对象集合;而对象集合的抽象又重要于表和行。
from flask import Flask,current_app

没用线程在此之前

要想在视图函数中取得配置文件的值,都是因此app.config来拿。不过假若视图函数和Flask成立的目的app不在一个模块。就得

1、子类继承父类的两种艺术

manage.py

flask是什么样做的吗?

必发365bifa0000 14

flask的request和session设置方法比较新颖,即便没有这种方法,那么就不得不通过参数的传递。

主意一、每趟操作都要链接数据库,链接次数过多

     链接池里所有的链接都能重复使用,共享的, 即实现了出现,又制止了链接次数太多

打印结果:

何以要运用数据库连接池呢?不用连接池有怎样不好的地点吧?

#!usr/bin/env python
# -*- coding:utf-8 -*-
import pymysql
from  flask import Flask

app = Flask(__name__)

# 方式一:这种方式每次请求,反复创建数据库链接,多次链接数据库会非常耗时
#        解决办法:放在全局,单例模式
@app.route('/index')
def index():
    # 链接数据库
    conn = pymysql.connect(host="127.0.0.1",port=3306,user='root',password='123', database='pooldb',charset='utf8')
    cursor = conn.cursor()
    cursor.execute("select * from td where id=%s", [5, ])
    result = cursor.fetchall()  # 获取数据
    cursor.close()
    conn.close()  # 关闭链接
    print(result)
    return  "执行成功"

if __name__ == '__main__':
    app.run(debug=True)
class Dog(Animal): #子类  派生类
    def __init__(self,name,breed, life_value,aggr):
        # Animal.__init__(self,name,breed, life_value,aggr)#让子类执行父类的方法 就是父类名.方法名(参数),连self都得传
        super().__init__(name,life_value,aggr) #super关键字  ,都不用传self了,在新式类里的
        # super(Dog,self).__init__(name,life_value,aggr)  #上面super是简写
        self.breed = breed
    def bite(self,person):   #狗的派生方法
        person.life_value -= self.aggr
    def eat(self):  #父类方法的重写
        super().eat()
        print('dog is eating')

方式二:继承dict

1 线程1
2 线程2
0 线程0
4 线程4
3 线程3

三、数据库连接池

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from functools import partial
from flask.globals import LocalStack, LocalProxy

ls = LocalStack()


class RequestContext(object):
    def __init__(self, environ):
        self.request = environ


def _lookup_req_object(name):
    top = ls.top
    if top is None:
        raise RuntimeError(ls)
    return getattr(top, name)


session = LocalProxy(partial(_lookup_req_object, 'request'))

ls.push(RequestContext('c1')) # 当请求进来时,放入
print(session) # 视图函数使用
print(session) # 视图函数使用
ls.pop() # 请求结束pop


ls.push(RequestContext('c2'))
print(session)

ls.push(RequestContext('c3'))
print(session)

大型:

from flask import Blueprint
order = Blueprint("order",__name__)

@order.route('/order')
def register():   #注意视图函数的名字不能和蓝图对象的名字一样
    return "order
from flask import  Blueprint,render_template
accout = Blueprint("accout",__name__)

@accout.route('/accout')
def xx():
    return "accout"

@accout.route("/login")
def login():
    return render_template("login.html")

导入一个DButils模块

方式一:重写__setitem__方法

措施三:由于地点二种方案都不健全,所以得把措施一和格局二联机一下(既让缩短链接次数,也能襄助并发)所有了主意三,需要

小结:倘使是在温馨的模块中运行,__name__就是__main__,假使是从其余文件中导入进来的,就不是__name__了

六、上下文管理

模式二:创立一个链接池,为拥有线程提供连接,使用时来举办获取,使用完毕后在放回到连接池。

 

小中型:

 链接池原理

倘若代码异常多,要拓展归类。不同的功力放在不同的文件,吧相关的视图函数也放进去。蓝图也就是对flask的目录结构举办分红(应用于小,中型的顺序),

打印结果:

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图