day93-排序及random模块及单例

1random模块的使用

random.random()函数是这个模块中最常用的方法了，它会生成一个随机的浮点数，范围是在0.0~1.0之间
random.uniform(a,b)正好弥补了上面函数的不足，它可以设定浮点数的范围，一个是上限，一个是下限。
random.randint(a,b)随机生一个整数int类型，可以指定这个整数的范围，同样有上限和下限值
random.choice(seq)可以从任何序列，比如list列表中，选取一个随机的元素返回，可以用于字符串、列表、元组等
random.shuffle(seq)如果你想将一个序列中的元素，随机打乱的话可以用这个函数方法,会作原地修改。
random.sample(seq,num)可以从指定的序列中，随机的截取指定长度的片断，不作原地修改。

2string模块的使用

ascii_letters生成所有英文字母(包括大小写)
digits生成所有数字
ascii_letters+string.digits生成所有英文字母及数字(a-zA-Z0-9)
random.sample(string.ascii_letters+string.digits,5)从所有字母及数字中随机选出5个字符

3冒泡排序

def sear(list1):
    for i in range(len(list1)):
        for j in range(1, len(list1) - i):
            if list1[j - 1] > list1[j]:
                list1[j - 1], list1[j] = list1[j], list1[j - 1]

4二分查找法

需要先对其排序才能使用二分查找法

def spl(list1, num):
    sear(list1)# 调用二分查找法对其进行排序
    start = 0
    end = len(list1)
    while start != end:
        middle = start + end >> 1
        if num > list1[middle]:
            start = middle
        elif num < list1[middle]:
            end = middle
        else:
            return middle

5选择排序

def xuanze(list1):
    for i in range(len(list1)):
        k = i
        for j in range(k + 1, len(list1)):
            if list1[k] > list1[j]:
                k = j
        if k != i:
            list1[i], list1[k] = list1[k], list1[i]

快速排序

def quik_sort(data):
    """快速排序"""
    if len(data) <= 1:
        return data
    middle = data.pop(0)
    first = []
    curr = [middle]
    third = []
    for val in data:
        if val < middle:
            first.append(val)
        elif val > middle:
            third.append(val)
        elif val == middle:
            curr.append(val)
    return quik_sort(first) + curr + quik_sort(third)

6菲波拉切序列

def feibo(num1, num2, num3):
    start, second = num1, num2
    if num3 < 3:
        list1 = [num1, num2]
        print(num1, num2)
    else:
        list1 = [num1, num2]
        for _ in range(num3 - 2):
            current = start + second
            start = second
            second = current
            list1.append(current)

7求素数

from math import sqrt
def sushu(list1):
    list2 = []
    for num in list1:
        num1 = int(sqrt(num))
        for j in range(2, num1+1):
            if num%j == 0:
                break
        else:
            list2.append(num)
    return list2

8跑马灯效果

def main():
    content='欢迎来到成都'
    while True:
        os.system('cls')
        #清屏
        print(content)
        time.sleep(0.5)
        #每隔0.5秒刷新一次
        content=content[1:]+content[0]

9短除法求最大公约数

def gcd(x,y):
    if x>y:
        return gcd(y,x)
    elif y%x ==0:
        return x
    else:
        return gcd(y%x,x)

10随机走台阶

def walk(n):
    #10级台阶,随机走一级，二级，三级，有多少种走法
    if n<0:
        return 0
    elif n==0:
        return 1
    return walk(n-1)+walk(n-2)+walk(n-3)

11汉落塔

def hanoi(n,a,b,c):
    #汉洛塔
    if n>0:
        hanoi(n-1,a,c,b)
        print(a,'→',b)
        hanoi(n-1,c,b,a)

hanoi(4,A,B,C)

12单例

12.1使用new方法

# 创建单例类(法一:使用__new__方法)
class Singleton:
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls, '_instance'):
            cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
        return cls._instance        
# 继承单例类
class MyClass(Singleton):
    a = 1

12.2共享属性

# 创建单例类(法二:共享属性)
class Brog:
    _state = {}    
    def __new__(cls, *args, **kwargs):
        ob = super(Brog, cls).__new__(cls, *args, **kwargs)
        ob.__dict__ = cls._state
        return ob        
class MyClass2(Brog):
    a = 1

12.3使用装饰器

# 创建单例类(法三:装饰器版本)
def singleton(cls, *args, **kwargs):
    instances = {}    
    def getinstance():
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]    
    return getinstance        
@singleton
class MyClass3:
    a = 2

13回文字符判断

def huiwen(s):
    start = len(s)
    mid = start//2
    for i in range(mid+1):
        if s[i] != s[start-1-i]:
            print('%s不是回文字符'%s)
            break
    else:
        print('%s是回文字符'%s)

14带参装饰器

给装饰器传入一个参数

from functools import wraps
def record(output):
    def decorate(func):
        @wraps(func)
        def wrapper(*args,**kwargs):
            start = time.time()
            result = func(*args,**kwargs)
            end = time.time()
            output(func.__name__,end-start) # 显示函数的名字和执行时间
            return result
        return wrapper
     return decorate

因为装饰器实质是就是一个函数，是一个被修饰过函数，他与原来未被修饰的函数是两个不同的函数对象。所以，这个装饰器丢失了原来函数对象的一些属性，比如：__name__，__doc__等属性。使用wraps语法糖可以保留这些属性.
示例：https://blog.csdn.net/weixin_42262081/article/details/119774190
普通装饰器

import time
import functools

def log(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        """我是 wrapper 的注释"""
        time1 = time.time()
        res = func(*args, **kwargs)
        time2 = time.time()
        print("函数名：{}".format(func.__name__))
        print("入参 args ：{}".format(args))
        print("入参 kwargs ：{}".format(kwargs))
        print("返回值：{}".format(res))
        print("函数执行耗时：{:.8f}".format(time2 - time1))
        return res
    return wrapper

14.1多个装饰器执行顺序

@singleton
@log
def add(a,b):
    return a + b

如图当一个函数有多个装饰器时，则先执行最里层log的外层代码，然后执行singleton的外层代码。然后执行singleton的内层代码，然后执行add函数，然后执行log的内层代码。

14.2 不带参类装饰器

import time 
class Timer:
    def __init__(self,func) -> None:
        self.func = func

    @functools.wraps
    def __call__(self, *args, **kwargs):
        start = time.time()
        ret = self.func(*args, **kwargs)
        print(f'Time:{time.time()-start}')
        return ret
    
@Timer
def add(a,b):
    time.sleep(1)
    return a+b

print(add(2,3))

类装饰器中使用init函数初始化，将被装饰函数传递给类(init方法类似于函数装饰器中的最外层函数用于传递被装饰函数)。然后在call方法中进行逻辑处理(call相当于函数装饰器中的最内层函数，用于调用被装饰函数)。调用函数add(2,3)相当于调用Timer(add)(2,3)所以类装饰器必须实现call方法。

14.3带参类装饰器

import time 

class Timer:
    def __init__(self,prefix) -> None:
        self.prefix = prefix

    def __call__(self, func):
        @functools.wraps
        def wrapper(*args,**kwargs):
            start = time.time()
            ret = func(*args, **kwargs)
            print(f'{self.prefix}:{time.time()-start}')
            return ret
        return wrapper
     
@Timer(prefix = 'curr_time:')
def add(a,b):
    time.sleep(1)
    return a+b
# 等价于： add = Timer(prefix = 'curr_time:')(add)
print(add(2,3))

等价于： add(2,3) = Timer(prefix = 'curr_time:')(add)(2,3)

15快速排序

def quickly_sort(list1):
if len(list1) < 2:
    return list1
else:
    pivot = list1[0]
    small_list = [i for i in list1[1:] if i <= pivot]
    big_list = [i for i in list1[1:] if i > pivot]
    final_list = quickly_sort(small_list) + [pivot] + quickly_sort(big_list)
    return final_list

16数据库1+N查询

orm模型中1+n查询解决方法
1.数据库反范式设计,说直白点,就是把表合并,设计成冗余表,这可能会带来两个问题：表中存在大量的重复数据项；表中出现大量的空项,整个表格变成一个稀疏矩阵(sparse matrix)
2.加缓存把整个列表页加上缓存. 这样无论是继续执行1+N次查询,还是用inner join 1次查询搞定,都可以.：更新缓存需要成本,增加了代码复杂度；某些场景要求数据实时性,无法使用缓存
3.把N+1次查询变成2次查询：简单说先执行 select *,category_id from article limited 0,N；然后遍历结果列表,取出所有的category_id,去掉重复项，再执行一次 select name from category where id in (category id list)
性能优化
把子查询/join查询分成两次,是高并发网站数据库调优中非常有效的常见做法,虽然会花费更多的cpu时间,但是避免了系统的死锁,提高了并发响应能力；数据库本身处理不了高并发,因为我们只能保证单个数据项的操作是原子的,而数据库的查询是以列表为基本单元,这是个天然矛盾,无解；数据库设计范式不在web framework能力范围内,所以django的ORM 只支持后面两种做法
Article.ojbects.select_related() 这就是inner join
Article.objects.prefetch_related('category') 这是2次查询

17django中使用原生sql

一：extra:结果集修改器，一种提供额外查询参数的机制
二：raw:执行原始sql并返回模型实例
三：直接执行自定义Sql
extra方法
Book.objects.filter(publisher__name='广东人员出版社',price__gt=50)
Book.objects.filter(publisher__name='广东人员出版社').extra(where=['price>50'])
Book.objects.extra(select={'count':'select count(*) from hello_Book'})
使用raw
Book.objects.raw('select * from hello_Book')
Book.objects.raw("insert into hello_author(name) values('测试')")
自定义sql
from django.db import connection
cursor=connection.cursor()
cursor.execute("insert into hello_author(name) values('郭敬明')")#插入
cursor.execute('update hello_author set name='abc' where name='bcd'')# 更新
cursor.execute('delete from hello_author where name='abc'')#删除
cursor.execute('select * from hello_author')# 查询
raw=cursor.fetchone() #返回结果行游标直读向前，读取一条
cursor.fetchall() #读取所有