小例子汇总

1. 发红包

import random
def red_pack(money,num):
    ret = random.sample(range(1,money*100),num-1)
    ret.sort()
    ret.insert(0,0)
    ret.append(money*100)
    print(ret)
    for i in range(len(ret)-1):
        yield (ret[i+1] - ret[i])/100



ret = red_pack(200,5)
for i in ret:
    print(i)

2.校验两个大文件的一致性

import hashlib
import os

def file_md5(path):
    size = os.path.getsize(path)
    md5 = hashlib.md5()
    with open(path,mode='rb') as f:
        while size>1024:
            content = f.read(1024)
            md5.update(content)
            size -=1024
        else:
            content = f.read(size)
            md5.update(content)
            size = 0
    return md5.hexdigest()
if __name__ == '__main__':
    path1 = r'a.txt'
    path2 = r'aa.txt'
    print(file_md5(path1)== file_md5(path2))

3.计算文件夹内文件大小总和

import os
def dir_size(path):
    ret = os.walk(path)
    sum_size = 0
    for base_path,dir_lst,file_lst in ret:
        for file_name in file_lst:
            size = os.path.getsize(os.path.join(base_path,file_name))
            sum_size += size
    return sum_size
ret = dir_size(r'../test')
print(ret,'B')

4.单例模式

应用场景:数据库连接池

普通单例模式:

class Singleton(object):
    instance = None
    def __new__(cls, *args, **kwargs):
        if not cls.instance:
            cls.instance = object.__new__(cls)
        return cls.instance

obj1 = Singleton()
obj2 = Singleton()

带锁单例模式:

from threading import Lock
class Singleton:
    __instance = None
    lock = Lock()
    def __new__(cls, *args, **kwargs):
        with cls.lock:
            if not cls.__instance:
                cls.__instance = super().__new__(cls)
        return cls.__instance
    def __init__(self,name,age):
        self.name = name
        self.age = age

def func():
    a = Singleton('alex', 84)
    print(a)

from threading import Thread
for i in range(10):
    t = Thread(target=func)
    t.start()

代码的设计模式共有25种，设计模式其实是代码无关的。其目的是基于OOP的思想，不同应用场景应用不同的设计模式，从而达到简化代码、利于扩展、提示性能等目的。本文简述Python实现的单例模式场景。

简而言之，单例模式的应用场景是所有实例对象封装的数据都相同的场景。在这样的场景下应用单例模式可以减少重复创建对象，从而节约内存。

例如，在数据库并发连接场景中，每次连接所用到的ip、端口，用户名、密码等相同，由于每次单独连接数据库耗时较长，所以通常会如下图，先创建个连接池，该连接池已与数据库创建好链接，其他用户想访问数据时先连接到此连接池，由连接池分配链接，从而节约时间。 此处连接池分配连接ID可简化为下述代码：

class ConnectionPool:
    __instance = None
    def __init__(self):
        self.addr = '127.0.0.1'
        self.port = 8008
        self.name = 'sql'
        self.conn_list = [1,2,3,4,5,6,7,8,9,10]
    def get_connection(self):
        r = random.randrange(1, 11)
        return r
P =  ConnectionPool
P.get_connection()

 

由上述简化的代码可知，每次有客户端连接时，都会创建新的对象，以调用其get_connection方法。在这种重复创建对象，且对象中封装的数据相同时，即可利用单例模式，节约内存提升性能。

单例模式示例：

class ConnectionPool:
    __instance = None
    def __init__(self):
        self.addr = '127.0.0.1'
        self.port = 8008
        self.name = 'sql'
        self.conn_list = [1,2,3,4,5,6,7,8,9,10]
    @staticmethod
    def get_instance():
        if ConnectionPool.__instance:
            return ConnectionPool.__instance
        else:
            ConnectionPool.__instance == ConnectionPool()
            return ConnectionPool.__instance
    def get_connection(self):
        r = random.randrange(1, 11)
        return r

以上示例，通过一个私有变量，一个静态方法 get_instance()实现了一次创建对象，多次连接。

 

总结下：

1. 单例只有一个实例
2. 静态方法、静态字段
3. 所有封装数据都一样时用单例模式