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
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() #读取所有