python-模块_内置方法_数学模块_随机模块_pickle模块

python 模块学习

1. 内置方法

abs 绝对值函数

res = abs(-100)
print(res)

round 四舍五入 ( n.5 n为偶数则舍去 n.5 n为奇数则进一 )

​ 特点: 奇进偶不进

res = round(4.51) # 5
res = round(4.5)  # 4
res = round(3.5)  # 4
print(res)

sum 计算一个序列的和

lst = [-200,56,78,34]
res = sum(lst)
print(res)

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

max 获取一个序列里边的最大值

lst = [-66,21,14,98]
res = max(lst)
print(res)

# 自定义方法
lst_new = sorted(lst)
print(lst_new)
maxval = lst_new[-1]
minval = lst_new[0]
print(maxval,minval)

# 常规写法
lst = [("小米",18),("小明",21),("小花",16),("小天",28)]
def func(n):
	print(n)    
	return n[-1] # 按照年龄返回
res = max(lst,key=func)
res = min(lst,key=func)
print(res)

# 改写成 lambda 表达式
res = max(lst,key = lambda n : n[-1])
print(res)

# 常规写法
dic = {"小明":-28,"小鹿":18,"小芳":24,"小兰":-15}
def func(n):
	print(n)
	return abs(dic[n])
res = max(dic,key=func)
print(res)

# 改写成 lambda 表达式
res = max(dic,key = lambda n : abs(dic[n]))
print(res)

min 获取一个序列里边的最小值

lst = [-66,21,14,98]
res = min(lst)
print(res)

pow 计算某个数值的x次方

​ pow 语法结构: 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 语法结构: range(strat,end,step)

for i in range(1,11,2):
	print(i) # 1 3 5 7 9 ...
for i in range(11,0,-2):
	print(i) # 11 9 7 5 3 1 ...

bin 将10进制数据转化为二进制

res = bin(255)
print(res) # 1111 1111

oct 将10进制数据转化为八进制

res = oct(87)
print(res)

hex 将10进制数据转化为十六进制

res = hex(255)
print(res)

chr 将ASCII编码转换为字符

res = chr(97)
print(res) # a

ord 将字符转换为ASCII编码

res = ord("A")
print(res)

eval 将字符串当作python代码执行

strvar = "print('上海的雨下的真是持久,衣服就干不了')"
eval(strvar)
'''strvar = "a = 88" error 不能执行'''

exec 将字符串当作python代码执行 (功能强大)

​ 注意点: 在与用户交互的时候,慎用

strvar = "a = 88"
exec(strvar)
print(a) # 88

strvar = """
for i in range(100):
	print("你这个大傻瓜")
"""
exec(strvar)

repr 不转义字符输出字符串

strvar = "E:\nython31_gx\day17"
print(repr(strvar))

# repr <=> r
strvar = r"E:\nython31_gx\day17"
print(strvar)

input 接受输入字符串 (永远接受的是字符串)

name = input("请输入你的爱情宣言")
print(name)

hash 生成哈希值

​ 特点: 相同的两个数据经过哈希算法运算得出的结果一定相同

res1 = hash("abc")
res2 = hash("abc")
print(res1,res2)

"""
哈希算法的用途:
	1. 文件校验
	2. 密码加密
"""

# 文件校验: 用 hash 校验两个文件内容是否一样
with open("ceshi1",mode="r+",encoding="utf-8") as fp:
	strvar1 = fp.read()
	res1 = hash(strvar1)
with open("ceshi2",mode="r+",encoding="utf-8") as fp:
	strvar2 = fp.read()
	res2 = hash(strvar2)
print(res1 == res2)    

2. 数学模块 math

import math => 导入数学模块

ceil() 向上取整操作 (对比内置round)

import math

res = math.ceil(4.9)  # 5
res = math.ceil(-3.5) # -3
print(res)

floor() 向下取整操作 (对比内置round)

import math

res = math.floor(4.5)  # 4
res = math.floor(-3.5) # -4
print(res)

pow() 计算一个数值的N次方 (结果为浮点数) (对比内置pow)

import math

res = math.pow(2,3)
print(res) # 8.0
"""res = math.pow(2,3,3) error 只能有两个参数"""

sqrt() 开平方运算 (结果为浮点数)

import math

res = math.sqrt(9)
print(res) # 3.0

fabs() 计算一个数值的绝对值 (结果为浮点数) (对比内置abs)

import math

res = math.fabs(-66)
print(res) # 66.0

modf() 讲一个数值拆分为整数和小数两部分组成元组

import math

res = math.modf(3.14)
print(res) # (0.14000000000000012, 3.0)

copysign() 将参数第二个数值的正负号拷贝给第一个 (返回一个小数)

import math

res = math.copysign(14,-2)  # -14.0
res = math.copysign(-14,-1) # -14.0
print(res) 

fsum() 将一个容器数据中的数据进行求和运算 (结果为浮点数) (对比内置sum)

import math

lst = [1,2,3,4,5,6]
res = math.fsum(lst)
print(res) # 21.0

圆周率常数 pi

import math

res = math.pi
print(res) # 3.141592653589793

3. 随机模块 random

import random => 导入随机模块

random() 随机获取0-1之间的小数 (左闭右开) 0 <= x < 1

import random

res = random.random()
print(res)

randrange() 随机获取指定范围内的整数 (开始值,结束值,间隔值)

import random

# 一个参数
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() 随机获取指定范围内的随机整数

import random

res = random.randint(1,4) # 1~4
print(res)
"""
res = random.randint(2) error
res = random.randint(1,10,3) error
"""

uniform() 随机获取指定范围内的小数 (左闭右开)

import random

res = random.uniform(1,5) # 1 <= x < 5 
res = random.uniform(5,1) # 1 < x <= 5
print(res)

"""
通过分析源码,了解 uniform 的功能
return a + (b-a) * self.random()
a = 5 , b = 1
5 + (1-5) * x = 0 => 5
5 + (1-5) * x = 1 => 1
1 < x <= 5
"""

choice() 随机获取序列中的值(多选一)

import random

lst = ["花花","草草","青青","红红","灰灰"]
res = random.choice(lst)
print(res)

# 自定义方法
def mychoice(lst):
	num = random.randrange(len(lst))
	return lst[num]
res = mychoice(lst)
print(res)

# lambda 表达式
func = lambda lst : lst[random.randrange(len(lst))]
print(func(lst))

sample() 随机获取序列中的值(多选多) [返回列表]

import random

lst = ["花花","草草","青青","红红","灰灰"]
res = random.sample(lst,1)
res = random.sample(lst,2)
res = random.sample(lst,3)
print(res)

shuffle() 随机打乱序列中的值 (直接打乱原序列)

import random

lst = ["小明","大黄","小强","小黑","大个"]
random.shuffle(lst)
print(lst)

# 练习 => 验证码: 验证码中含有小写字母,大写字母,数字 
def yanzhengma():
	# 定义一个空变量接收验证码
	strvar = ""
	# 随机抽取4次    
	for i in range(4):
		# 小写字母: 97~122
		s_char = chr(random.randrange(97,123))
		# 大写字母: 65~90
		b_char = chr(random.randrange(65,90))
		# 数字: 0~9
		num = str(random.randrange(10))
		lst = [s_char,b_char,num]
		strvar += random.choice(lst)
	return strvar
res = yanzhengma()
print(res)

4. 序列化模块 pickle

序列化模块:

​ import pickle => 导入 pickle 模块

​ 序列化: 把不能够直接存储的数据变得可存储,这个过程叫做序列化

​ 反序列化: 把文件中的数据拿出来,恢复成原来的数据类型,这个过程叫做反序列化

​ 特点: 在文件中存储的数据只能是字符串 或者是 字节流,不能是其他数据类型

​ 如果想要存储,需要序列化

​ pickle 模块可以序列化一切数据类型

其他语言:

​ 比如 php serialize => 序列化

​ unserialize => 反序列化

1. dumps 和 loads

​ dumps: 把任意对象序列化成一个bytes

​ loads: 把任意bytes反序列化成原来数据

import pickle

lst = ["大黄","小明","大个","小强"]

# 错误案例
"""
with open("ceshi1.txt",mode="w+",encoding="utf-8") as fp:
	fp.write(lst)

# 只有字符串可以使用 encode 和 decode 转换字节流
lst.encode() error
"""

# 1.容器类型数据可以被序列化
lst = ["大黄","小明","大个","小强"]

# dumps 把任意对象序列化成一个bytes
res = pickle.dumps(lst)
print(res)

# loads 把任意bytes反序列化成原来数据
lst = pickle.loads(res)
print(lst,type(lst))

# 2.函数可以序列化
def func():
	print("文哥最帅!")
# 序列化
res = pickle.dumps(func)
print(res)

# 反序列化
func = pickle.loads(res)
print(func)
func()

# 3.迭代器可以序列化
it = iter(range(10))
# 序列化
res = pickle.dumps(it)
print(res)

# 反序列化
it = pickle.loads(res)
print(it)
for i in it:
	print(i)	

2. dump 和 load

​ dump: 把对象序列化后写入到file-like Object (即文件对象)

​ load: 把file-like Object (即文件对象) 中的内容拿出来,反序列化成原来数据

lst = ["小明","小胡","小杨","小楚"]

# dump 把对象序列化后写入到file-like Object (即文件对象)
with open("111.txt",mode="wb") as fp:
	# dump (数据,文件对象)
	pickle.dump(lst,fp)

# load 把file-like Object (即文件对象) 中的内容拿出来,反序列化成原来数据
with open("111.txt",mode="rb") as fp:
	res = pickle.load(fp)
	print(res,type(res))

# dumps 和 loads 对文件操作 (与 dump 和 load 的区别)
lst = ["小明","小胡","小杨","小楚"]

res = pickle.dumps(lst)
with open("222.txt",mode="wb") as fp:
	fp.write(res)

with open("222.txt",mode="rb") as fp:
	res = fp.read()
	print(res)
	lst = pickle.loads(res)
	print(lst,type(lst))

5. 练习

练习 1

# 分析下面的代码
def func():
    return [lambda x : i*x for i in range(4)]

res = [m(2) for m in func()]
print(res)

# 代码解析
# 判断 return 后面的推导式中 lambda 表达式的结构

# 情况一 [lambda x :      i*x for i in range(4)]
def func(x):
    return i*x for i in range(4)
func(10) # 运行代码报错 此结构错误

# 加上中括号变成推导式
def func(x):
    return [i*x for i in range(4)]

res = func(10)
print(res) # [0, 10, 20, 30]

# 情况二 [lambda x : i*x      for i in range(4)]
def func():
    return [lambda x : i*x for i in range(4)]
# 常规写法
def func():
    lst = []
    for i in range(4):
        def func2(x):
            return i*x
        lst.append(func2)
    return lst

lst = func()
print(lst)
"""
代码结果:
[
<function func.<locals>.func2 at 0x000001A89C33F620>,
<function func.<locals>.func2 at 0x000001A89C33F6A8>, 
<function func.<locals>.func2 at 0x000001A89C33F730>, 
<function func.<locals>.func2 at 0x000001A89C33F7B8>
]
出现了4个相同的 func2 函数

1. 在定义函数的时候,不会去执行函数当中的代码块,只有在调用函数的时候,才执行
2. i 这个变量被闭包函数 func2 使用,生命周期被延长了,暂时不释放,当调用时,i此刻为3,直接调用
"""
# 在遍历列表的时候,分别拿出4个函数,进行调用 m(2)
for i in range(4):
    print(i)

# for 循环遍历结束时 i = 3
print(i)

res = [m(2) for m in func()]
print(res) # [6,6,6,6]

练习 2

# 分析下面的代码
def add(a,b):            # 普通求和函数
    return a + b
def test():              # 生成器函数
    for i in range(4):
        yield i
        
g = test()
for n in [2,10]:
    # 生成器表达式
    g = (add(n,i) for i in g)

print(list(g))    

# 代码解析
# 1.等循环结束之后,在打印n,结果是10
for n in [2,10]:
    print(n) # 2 10
   
print(n) # 10

# 2.循环里面定义了2次生成器
# 第一次
g = (add(n,i) for i in g) # g = (0,1,2,3) n = 10
g = (10,11,12,13)

# 第二次
g = (add(n,i) for i in g) # g = (10,11,12,13) n = 10
g = (20,21,22,23)

print(list(g)) # [20,21,22,23]

"""
定义生成器的时候,里面的代码是不执行的
只有在调用生成器的时候,里面的代码才执行
调用方法: for / next / for + next / list
"""