秃顶之路-Day16

Day 16

1.内置函数

# abs 绝对值函数
res=abs(-100)
print(res)
# round 四舍五入（n.5 n为偶数则舍去，n为奇数，则进一）
'''特点：奇进偶不进'''
res=round(4.51) #5
res=round(4.5)  #4
res=round(3.5)  #4
print(res)
# sum 计算一个序列的和
lst=[-100,52,20,90,35]
es=sun(lst)
print(res)

def func(lst):
	total=0
	for i in lst:
		total+=i
	return total
print(func(lst))

lst=[100,-52,20,33,86]
# max 获取一个序列里面的最大值
res=max(lst)
print(res)
# min 获取一个序列里面的最小值
res=min(lst)
# 自定义方法
lst_new=sorted(lst)
print(res)
maxvar=lst_new[-1]
minvar=lst_new[0]
print(maxvar,minvar)

lst=[('八戒'，100),('精华'，88),('虎林',96)]
def func(n):
	return n[-1] #按年龄返回
res=max(lst,key=func)
res=min(lst,key=func)
print(res)
# 改写成lambda表达式
res=max(dic,key=lambda n : abs(dic[n]))
print(res)
# pow 计算某个数值的x次方
'''pow(参数1,参数2,参数3)参数3代表的是取余数'''
res=pow(2,3)
print(res)
res=pow(2,3,3) #2
res=pow(2,3,4) #0
print(res)
# range 产生指定范围数据的可迭代对象
'''range(start,end,step)'''
for i in range(1,11,3):
	print(res)
for i in range(11,0,-3):
	print(res)
# bin 将10进制数据转化为二进制
res=bin(255)
print(res)
# oct 将10进制数据转化为八进制
res=oct(57)
print(res)
# hex 将10进制数据转化成16进制
res=hex(255)
print(res)
# chr 将ascii编码转换为字符
res=chr(97)
print(res)
# ord 将字符转化为ascii编码
res=ord('A')
print(res)
#eval 将字符串当做python代码执行
strvar='print('今天真的好热啊')'
eval(strvar)
#exec 将字符串当作python代码执行（功能更强大）
'''注意点：在于用户交互时，慎用'''
strvar='a=90'
exec(strvar)
print(a)
strvar='''
for i in range(10):
print('你是大傻瓜')
'''
exec(strvar)
# repr 不转义字符输出字符串
strvar='E:\nython31_gx\day17'
print(repr(strvar))
# input 接受输入字符串（永远接收的是字符串）
# hash 生成哈希值
'''相同的两个数据经过哈希算法运算得出的结果一定相同'''
res1=hash('abc')
res2=hash('abc')
print(res1,res2)
'''作用：文件校验，密码加密'''
with open('a1.txt',mode='r+',encoding='utf-8') as fp :
	strvar1=fp.read()
	res1=hash(strvar1)
with open('a2.txt',mode='r+',encoding='utf-8') as fp:
	strvar2=fp.read()
	res2=hash(strvar2)
print(res1==res2)

2.数学模块

import math 
# ceil() 向上取整（对比内置round）
res=math.ceil(4.9)
res=math.ceil(-3.5)
print(res)
# floor() 向下取整操作（对比内置round）
res=math.floor(3.9)
res=math.floor(-3.8)
print(res)
# pow() 计算一个数值的N次方（结果为浮点型）（对比内置pow）
res=math.pow(2,3)
#res=math.pow(2,3,3) error 只有两个参数
print(res) #结果一定是一个小数：8.0
# sqrt() 开平方运算（结果浮点型）
res =math.sqrt(9)
print(res)#结果一定是小数3.0
# fabs() 计算一个数值的绝对值（结果为浮点型）（对比内置abs）
res=math.fabs(-99)
print(res)#99.0
# modf() 将一个数值拆分为整数和小数两部分组成元组
res=math.modf(13.45)
print(res) # (0.49999999993,13.0)
# copysign() 将参数第二个数值的正负号拷贝给第一个（返回一个小数）
res=math.copysign(-13,-1)
print(res) # -13.0 返回一个小数
# 圆周率常数 pi
res=math.pi
print(res)

3.random 随机模块

import random
# random() 获取随机0-1之间的小数（左闭右开）0<= x <= 1
res=random.random()
print(res)
# randrange() 随机获取指定范围内的整数（包含开始值，不包含结束值，间隔值）
#一个参数
res=random.randrange(5) #0~4
#两个参数
res=random.randrange(2,8) #2-7
#三个参数
res=random.randrange(1,10,3) # 1,4,7
print(res)
# randint() 随机产生指定范围内的随机整数（了解）
res=random.randint(3,4)
print(res)
# uniform() 获取指定范围内的小数（左闭右开）
res=random.uniform(1,3)
# return a + (b-a)*self.random()
res=random.uniform(3,1)
print(res)
# choice() 随机获取序列中的值（多选一）
lst=['刘鑫','刘子豪','八戒','大师兄']
res=random.choice(lst)
print(res)
def mychoice(lst):
	num=random.rangrange(len(lst))
	return lst[num]
res=mychoice(lst)
print(res)
# lambda 表达式
func=lambda lst :lst[random.randrange(len(lst))]
print(func(lst))
# sample() 随机获取序列中的值（多选多）[返回列表]
lst=['刘鑫','刘子豪','八戒','大师兄']
res=random.sample(lst,1)
res=random.sample(lst,2)
print(res)
# shuffle 随机打乱序列中的值（直接打乱原序列）
lst=['刘鑫','刘子豪','八戒','大师兄']
random.shuffle(lst)
print(lst)
# 验证码
def yanzhengma():
	#验证码中含有小写字母大写字母，数字
	#小写字母：97~122
	strvar=''
	#随机抽取4次
	for i in range(4):
		s_char=chr(random.randrange(97,123))
		b_char=chr(random.randrange(65,91))
		num=str(random.randrange(10))
		lst=[s_char,b_char,num]
		strvar += random.choice(lst)
	return strvar
res = yanzhengma()
print(res)

4.序列化模块 pickle
把不能够直接储存的数据变得可储存，这个过程叫做序列化
把文件中的数据拿出来，恢复成原来的数据类型，这个过程叫做反序列化
在文件中储存的数据只能是字符串或者是字节流，不能是其他数据类型，如果想储存，需要序列化
pickle模块可以序列化一切数据类型

import pickle
lst=['八戒','大师兄','唐三藏']
#只有字符串可以使用encode和decode转换字节流
# 容器类型可以被序列化
# dumps 把任意对象序列化成一个bytes
res=pickle.dumps(lst)
print(res)
# loads 把任意bytes反序列化成原来的数据
lst=pickle.loads(res)
print(lst,type(lst))
# 函数可以序列化
def func():
	print('我是最帅的')
#序列化
res=pickle.dumps(func)
print(res)
#反序列化
func=pickle.loads(res)
func()
# dump 把对象序列化后写入到file-like object（即文件对象）
lst=['八戒','大师兄','唐三藏']
with open('1.tzt',mode='wb') as fp :
	pickle.dump(lst,fp)
# load 把文件对象中的内容拿出来，反序列化成原来的数据
with open('1.txt',mode='rb') as fp :
	res=pickle.load(fp)
	print(res)
# dunps 和 loads 对文件操作（区分）
lst=['八戒','大师兄','唐三藏']
res=pickle.dumps(lst)
with open('1.txt'mode='wb') as fp :
	fp.write(res)
with open('1.txt',mode='rb') as fp :
	res=fp.read()
	lst=pickle.loads(res)
	print(lst)