Python模块

Python标准库

一、sys模块

定义

sys模块主要负责与Python解释器进行交互，用来获取操作系统和编译器的一些配置、环境设置以及操作。

常用方法

sys.argv	获取命令行参数列表，第一个参数是程序本身
sys.exit(n)	退出 Python 程序，exit(0) 表示正常退出。当参数非 0 时,会引发一个 SystemExit 异常，可以在程序中捕获该异常
sys.version	获取 Python 解释程器的版本信息
sys.maxsize	最大的 Int 值，在 64 位操作系统上是 263-1
sys.path	返回模块的搜索路径，初始化时使用 PYTHONPATH 环境变量的值
sys.platform	返回操作系统平台名称
sys.stdin	输入相关
sys.stdout	输出相关
sys.stderr	错误相关
len()	获取长度
sys.path.insert(index,字符)	指定下标插入数据
sys.path = []	删除所有路径
sys.getfilesystemencoding()	获取文件系统使用编码方式，默认是 UTF-8
sys.modules	以字典的形式返回所有当前 Python 环境中已经导入的模块
sys.builtin_module_names	返回一个列表，包含所有已经编译到 Python 解释器里的模块的名字
sys.modules.keys()	返回所有已将导入模块的key
sys.flags	命令行标识状态信息列表
sys.getrefcount(object)	返回对象的引用数量
sys. getrecursionlimit()	返回 Python 最大递归深度，默认为 1000
sys.getsizeof(object[, default])	返回对象的大小
sys.getswitchinterval()	返回线程切换时间间隔，默认为0.005秒
sys.setswitchinterval(interval)	设置线程切换的时间间隔，单位为秒
sys. getwindowsversion()	返回当前 Windows 系统的版本信息
sys.hash_info	返回 Python 默认的哈希方法的参数
sys.implementation	当前正在运行的 Python 解释器的具体实现，如 CPython
sys.thread_info	当前线程信息

代码

先导入模块

import sys

#argv第一个参数必须是文件的信息/程序信息
argv 获取命令行的参数
argv 的第一个参数/下标的是0的参数，
一定会是我们运行文件的信息

print(sys.argv)
print(sys.argv[3])

sys.exit() 0是正常退出，1是不正常退出，无论是不是1都不会报错

for i in [1,2,3,4,5]:
    if i == 2:
        sys.exit(1)
    print(i) #1

#sys.version python版本号

print(sys.version) #3.7.6 (tags/v3.7.6:43364a7ae0, Dec 19 2019, 00:42:30) [MSC v.1916 64 bit (AMD64)]

#maxsize int数值可以最大是263-1

print(sys.maxsize) #9223372036854775807

#sys.path.insert(index,文件名字) 添加路径

sys.path.insert(0,"temp")
print(sys.path)

#sys.modules 获取我们导入的模块信息,返回一个字典

print(sys.modules)`

#sys.modules.keys() 只获取导入模块的名字

print(sys.modules.keys())

import sys

#path 获取路径，返回一个list

print(sys.path)

#sys.path.insert(index,文件名字) 添加路径

sys.path.insert(0,"temp")
print(sys.path)

#sys.modules.keys() 只获取导入模块的名字

print(sys.modules.keys())

导入模块不一定是内建模块，也有可能是我们自己封装的模块

#获取内建模块的名字

a = sys.builtin_module_names
print(a)

利用函数查看内建模块

import sys
def func(hh):
    if hh in sys.builtin_module_names:  #查找内建模块是否存在
        print("是内建")
    else:
        print("不是内建")
func("path")

二、os模块

定义

os模块用于访问操作系统相关功能的模块，提供了一种可移植的使用操作系统功能的方法。使用os模块中提供的接口，可以实现跨平台访问

常用方法

方法或变量	用途
os.mkdir(‘dirname’)	生成单级目录，相当于shell中mkdir dirname
os.makedirs(‘dirname1/dirname2’)	可生成多层递归目录
os.rmdir(‘dirname’)	删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.removedirs(‘dirname1’)	若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.listdir(‘dirname’)	列出指定目录下的所有文件和子目录，包括隐藏文件并以列表方式打印
os.remove()	删除一个文件
os.rename(“oldname”,“newname”)	重命名文件/目录
os.path.abspath(path)	返回path规范化的绝对路径 os.path.split(path) 将path分割成目录和文件名二元组返回
os.path.dirname(path)	返回path的目录
os.path.exists(path)	如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path)	如果path是绝对路径，返回True
os.path.isfile(path)	如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(path)	如果path是一个存在的目录，则返回True。否则返回False
os.path.join(path1[,path2[, …]])	将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path)	返回path所指向的文件或者目录的最后访问时间
os.path.getmtime(path)	返回path所指向的文件或者目录的最后修改时间
os.path.getsize(path)	返回path的大小
os.getcwd()	获取当前工作目录，即当前python脚本工作的目录路径
os.chdir(“dirname”)	改变当前脚本工作目录；相当于shell下cd
os.curdir	返回当前目录: (’.’)
os.pardir	获取当前目录的父目录字符串名：(’…’)
os.stat(‘path/filename’)	获取文件/目录信息

代码

这里以小编的电脑文件，做编写,每执行一遍，对执行结果进行观察是否成功,没有文件自行去创建

导入os模块

import os

#os,getcwd() 获取当前目录
绝对路径：从头开始，全部路径，从盘开始
半路径：从中间开始

print(os.getcwd()) #C:\Users\wyh

#切换进入到哪个目录下

print(os.chdir("C:\\Users\\wyh\\Desktop\\python文档"))

#创建一个单级别文件夹,使用双斜杠\

os.mkdir("C:\\Users\\wyh\\Desktop\\python文档\\temp")
os.mkdir("temp")

#删除空文件夹

os.rmdir("C:\\Users\\wyh\\Desktop\\python文档\\temp")

#创建多层文件夹

os.makedirs("C:\\Users\\wyh\\Desktop\\python文档\\wechaa\\wechat")

#删除多级空目录

os.removedirs("C:\\Users\\wyh\\Desktop\\python文档\\wechaa\\wechat")

#创建多层递归目录

os.makedirs("C:\\Users\\wyh\\Desktop\\python文档\\test\\")

os.rename(old,new)将old文件重命名为new

os.rename("C:\\Users\\wyh\\Desktop\\python文档\\test\\temp.py","C:\\Users\\wyh\\Desktop\\python文档\\test\\temp.txt")

列出指定目录下的所有文件及文件

print(os.listdir("C:\\Users\\wyh\\Desktop\\python文档\\test"))

删除空的文件夹

os.removedirs("C:\\Users\\wyh\\Desktop\\python文档\\test\\temp.txt")

#os.path.dirname() 获取路径的父目录(上一级目录)

a = os.path .dirname("C:\\Users\\wyh\\Desktop\\python文档\\secondcury.py")
print(a) #C:\Users\wyh\Desktop\python文档

#os.path.join() 将多个路经进行拼接

b = os.path.join("D:","python","p.py")
print(b) #D:python\p.py

#列出指定目录下的所有文件及文件夹，包括隐藏文件，并返回一个list
只显示文件/文件夹的名字

print(os.listdir("C:\\Users\\wyh\\Desktop\\python文档"))

将path分割成目录和文件名，并返回一个元组

print(os.path.split('C:\\Users\\wyh\\Desktop\\python文档\\test.py))

判断path(文件或文件夹)是否存在

print(os.path.exists('C:\\Users\\wyh\\Desktop\\python文档\\test.py'))

#判断path是否是文件,True False

print(os.path.isfile('C:\\Users\\wyh\\Desktop\\python文档\\test.py'))#True

判断path是否是目录，True False

print(os.path.isdir('C:\\Users\\wyh\\Desktop\\python文档\\test.py')) #False

三、正则表达式：re模块

定义

普通字符和元字符构成的字符串，描述一类字符串规则

用途

测试字符串内的模式。——例如，可以测试输入字符串，以查看字符串内是否出现电话号码模式或信用卡号码模式。这称为数据验证。
替换文本。——可以使用正则表达式来识别文档中的特定文本，完全删除该文本或者用其他文本替换它。
基于模式匹配从字符串中提取子字符串。——可以查找文档内或输入域内特定的文本。

3.1元字符

有特殊含义的元字符

表达式	匹配
.	小数点可以匹配除了换行符\n以外的任意一个字符
|	逻辑或操作符 ,或
[]	匹配字符集中的一个字符
[^]	对字符集求反，也就是上面的反操作。尖号必须在方括号里的最前面
-	定义[]里的一个字符区间，例如[a-z]
\	对紧跟其后的一个字符进行转义
()	对表达式进行分组，将圆括号内的内容当做一个整体，并获得匹配的值

代码

导入模块

import re

#匹配a或者c |

a = re.findall("a|c","abcdefg")
print(a) #['a', 'c']

#匹配列表中的任意任意一个字符 []

a = re.findall("[acbe]","abcdefg")
print(a) #['a', 'b', 'e', 'c']

除了a和c其余都要 [^ac]

a = re.findall("[^ac]","abcdefg")
print(a) #['d', 'f', 'g', 'v', 's']

#a-c 意思是匹配abc三个字符 [a-c]

a = re.findall("[a-c]","abcdefg")
print(a) #['a', 'c']

#意思是把adf作为一个整体进行输出 ()

a = re.findall("(adf)","abcdefg")
print(a) #['adf']

#去掉小数点的特殊含义，他就是一个小数点

a = re.findall("\.","abc.defg")
print(a) #['.']

3.2转义字符

一些无法书写或者具有特殊功能的字符，采用在前面加斜杠""进行转义的方法

表达式	匹配
\r, \n	匹配回车和换行符
\t	匹配制表符
\\	匹配斜杠\
\^	匹配^符号
\$	匹配$符号
\.	匹配小数点.

3.3预定义匹配字符

正则表达式中的一些表示方法，可以同时匹配某个预定义字符集中的任意一个字符。

表达式	匹配
\d	任意一个数字，0~9中的任意一个
\w	任意一个字母或数字或下划线，也就是AZ,az,0~9,_ 中的任意一个
\s	空格、制表符、换页符等空白字符的其中任意一个
\D	\d的反集，也就是非数字的任意一个字符，等同于[^\d]
\W	\w的反集，也就是[^\w]
\S	\s的反集，也就是[^\s]

代码

#匹配出0-9的数字

a = re.findall("\d","a1b2c3")
print(a) #['1', '2', '3']

#\D \d的反集，也就是非数字的任意一个字符，等同于`[^\d]，除数字以外的

a = re.findall("\D","abc 123")
print(a)  #['a', 'b', 'c', ' ']

#任意一个字母或数字或下划线，也就是A_Z,az,0~9,_ 中的任意一个

a = re.findall("\w","w23y14h5-")
print(a)  #['w', '2', '3', 'y', '1', '4', 'h', '5', '-']

#\W \w的反集，也就是[^\w] ，除字母以外的

a = re.findall("\W","abcwyh 13q4_")
print(a)  #['_']

#匹配空格

a = re.findall("\s","abc 123")
print(a)  #[' ']

\S \s的反集，也就是[^\s],除空格以外

a = re.findall("\S","abc 123")
print(a)  #['a', 'b', 'c', '1', '2', '3']

3.4重复匹配

前面的表达式，无论是只能匹配一种字符的表达式，还是可以匹配多种字符其中任意一个的表达式，都只能匹配一次。

表达式	匹配
{n}	表达式重复n次，比如\d{2}相当于\d\d,a{3}相当于aaa
{m,n}	表达式至少重复m次，最多重复n次。比如ab{1,3}可以匹配ab或abb或abbb
{m,}	表达式至少重复m次，比如\w\d{2,}可以匹配a12,_1111,M123等等
?	匹配表达式0次或者1次，相当于{0,1}，比如a[cd]?可以匹配a,ac,ad
+	表达式至少出现1次，相当于{1,}，比如a+b可以匹配ab,aab,aaab等等
*	表达式出现0次到任意次，相当于{0,}，比如\^*b可以匹配b,^^^b等等

代码

#{n} 重复n次
#{n,m} n到m次
#？ 匹配0或者1次
#^ 开头
#$结尾

import re
a = re.findall("l{2}","yellow")
print(a) #['ll']
#{n,m} n到m次
b = re.findall("l{2,5}","I like yellow,allows,leterllo")
print(b)
#？ 匹配0或者1次
c = re.findall("l?","I like yellow,allows,leterllo")
print(c)#['', '', 'l', '', '', '', '', '', '', 'l', 'l', '', '', '', '', 'l', 'l', '', '', '', '', 'l', '', '', '', '', 'l', 'l', '', '']

#^ 开头
d = re.findall("^156","156666131871")
print(d)#['156']
#$结尾
e = re.findall("1$","156666131871")
print(e)#['1']

3.5位置匹配

对匹配出现的位置有要求,进行字符匹配

表达式	匹配
^	在字符串开始的地方匹配，符号本身不匹配任何字符
$	在字符串结束的地方匹配，符号本身不匹配任何字符
\b	匹配一个单词边界，也就是单词和空格之间的位置，符号本身不匹配任何字符
\B	匹配非单词边界，即左右两边都是\w范围或者左右两边都不是\w范围时的字符缝隙

代码

#1是否在开头
a = re.findall("^1","1566932")
print(a) #['1']

#2是否在末尾
a = re.findall("6$","1566932")
print(a) #['2']

小练习

import re

#用户密码
pwd = input("请输入密码")
p = re.findall("^\w{8,10}",pwd)
print(p)

#电子邮箱

emial = input("请输入邮箱")
#电子邮箱格式
e  = re.findall("^[\w]+@[\w]+\.[a-z]",emial) #字母数字混合,结尾字母
#qq邮箱格式
e  = re.findall("^\d{10}@[q]{2}\.[c][o][m]",emial) #qq邮箱com

print(e)

#电话号码
num = input("请输入电话号码")
n  = re.findall("^1\[3-9]\d{9}",num) #电话号码11位
print(n)

四、re模块

定义

re模块是python独有的匹配字符串的模块，该模块中提供的很多功能是基于正则表达式实现的

常用方法

方法	描述	返回值
compile(pattern)	根据包含正则表达式的字符串创建模式对象	re对象
search(pattern, string)	在字符串中查找 。第一个匹配到的对象或者None	返回一个match对象
match(pattern, string)	在字符串的开始处匹配模式。 在字符串开头匹配到的对象或者None	返回一个match对象
findall(pattern, string,flags)	列出字符串中模式的所有匹配项	所有匹配到的字符串列表
finditer(pattern, string,flags)	将所有匹配到的项生成一个迭代器	所有匹配到的字符串组合成的迭代器
match.group(index)	将match对象拆分成字符串。不写index默认是0	返回match object中的字符串/元组
match.groups()	将match对象转换成元组	返回由所有分组匹配到的字符串组成的tuple。
match.start(index)	没有参数时，返回匹配到的字符串的起始位置。指定参数（整数）时，返回该分组匹配到的字符串的起始位置	返回int类型
match.end(index)	没有参数时，返回匹配到的字符串的结束位置。指定参数（整数）时，返回该分组匹配到的字符串的结束位置。	返回int类型
match.span(index)	返回一个二元tuple表示匹配到的字符串的范围，即(start, end)	返回元组
split(pattern, string)	根据模式的匹配项来分割字符串	分割后的字符串列表
sub(repl, string,count=0)	将字符串中所有的pat的匹配项用repl替换	完成替换后的新字符串
subn(pat,repl, string)	在替换字符串后，同时报告替换的次数	完成替换后的新字符串及替换次数
escape（string）	将字符串中所有特殊正则表达式字符串转义	转义后的字符串
purge(pattern)	清空正则表达式
template(pattern)	编译一个匹配模板	模式对象
fullmatch(pattern, string)	match方法的全字符串匹配版本	类似match的返回值

代码

import re #导入模块正则

查询模块

#compile(pattern) 根据包含正则表达式的字符串创建模式对象 re对象

r = re.compile("[0-9]")
print(r) #返回一个编译正则的re对象

#search(pattern, string) 在字符串中查找 第一个匹配到的对象或者None
#扫描整个字符串，并返回它找到的第一个匹配（Match object）

r = re.compile("[0-9]")
a = r.search("123abc456")
print(a) #<re.Match object; span=(0, 1), match='1'>

#findall(pattern, string,flags) 列出字符串中模式的所有匹配项 所有匹配到的字符串列表

import re 
b = re.compile(r"[a-w]",re.I)
a = b.findall("ADbcG")
print(a) #['A', 'D', 'b', 'c', 'G']
#---------------------------------
r = re.compile("[0-9]")
a = r.findall("123abc4567")
print(a) #['1', '2', '3', '4', '5', '6', '7']

finditer(pattern, string,flags) 将所有匹配到的项生成一个迭代器 返回一个迭代器

r = re.compile("[0-9]")
a = r.finditer("123abc456")
print(a) #<callable_iterator object at 0x0000020C599BFA88>
print(list(a))


"""
[<re.Match object; span=(0, 1), match='1'>, 
<re.Match object; span=(1, 2), match='2'>, 
<re.Match object; span=(2, 3), match='3'>, 
<re.Match object; span=(6, 7), match='4'>, 
<re.Match object; span=(7, 8), match='5'>, 
<re.Match object; span=(8, 9), match='6'>]
"""

match相关方法

#match.group(index)将match对象拆分成字符串。不写index默认是0返回match object中的字符串

注意

分组编号从1开始，从左往右，每遇到一个左括号，分组编号+1。 组0总是存在的，它就是整个表达式。
没有参数时，group1默认为0，这时返回整个匹配到的字符串。

“”"

#空格不要忘了
r = re.compile(r"(\w+) (\w+)")
a = r.match("I love you")
print(a)  #<re.Match object; span=(0, 6), match='I love'>
print(a.group()) #I love   默认是0
print(a.group(1)) #I
print(a.group(2)) #love
print(a.group(3)) #报错

#指定多个参数的时候，就返回一个元组

print(a.group(1,2)) #('I', 'love')

r = re.compile(r"(\w+) (\w+)")
a = r.match("I love you")
print(a.groups()) #('I', 'love')

#match.start(index)没有参数时，返回匹配到的字符串的起始位置。指定参数（整数）时，返回该分组匹配到的字符串的起始位置

r = re.compile(r"(\w+) (\w+)")
a = r.match("I love you") 
print(a.start()) #0  
print(a.start(2)) #2  第二个单词的起始位置是2，下标从0开始

#match.end(index)没有参数时，返回匹配到的字符串的结束位置。指定参数（整数）时，返回该分组匹配到的字符串的结束位置

r = re.compile(r"(\w+) (\w+)")
a = r.match("I love you") 
print(a.end()) #6
print(a.end(2)) #6
print(a.end(1))  #1

match.span(index)返回元组

r = re.compile(r"(\w+) (\w+)")
a = r.match("I love you") 
print(a.span()) #(0, 6)
print(a.span(1)) #(0, 1)
print(a.span(2)) #(2, 6)

拆分

#split(pattern, string) 根据模式的匹配项来分割字符串 分割后的字符串列表
匹配到大写的字母就拆分

pattern = re.compile(r"[A-Z]+")
m = pattern.split("abcDefgHijkLmnoPqrs")
print(m) #['abc', 'efg', 'ijk', 'mno', 'qrs']

替换

sub(repl, string,count=0) 将字符串中所有的pat的匹配项用repl替换 |完成替换后的新字符串
repl可以是一个字符串，也可以是一个函数。 count用于指定最多替换次数，不指定时全部替换。

r = re.compile(r"like", re.I)
#s1 = r.sub(r"love", "I like you, do you like me?")  #I love you, do you love me?
#最多替换1次，所以把一个like替换了
s1 = r.sub(r"love", "I like you, do you like me?",count=1)
print(s1) #I love you, do you like me?

#subn(repl, string) | 在替换字符串后，同时报告替换的次数 | 完成替换后的新字符串及替换次数 |
#同sub()，只不过返回值是一个二元tuple，即(sub函数返回值，替换次数)。

r = re.compile(r"like", re.I)

s1 = r.subn(r"love", "I like you, do you like me?")
print(s1) #('I love you, do you love me?', 2)

s2 = r.subn(r"love", "I like you, do you like me?",count=1)
print(s2) #('I love you, do you like me?', 1)

字符补充

Python中字符串前面加上 r 表示原生字符串

与大多数编程语言相同，`正则表达式里使用"\"作为转义字符`，这就可能造成反斜杠困扰。
假如你需要匹配文本中的字符"\"，那么使用编程语言表示的正则表达式里将需要4个反斜杠"\\"：
前两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。

小练习

import re
"""
#complie() 用户密码
pwd = input("请输入密码")
p = re.compile("^\w{8,10}") 
a =re.findall(p,pwd)
print(a)

#匹配身份证
id = input("请输入身份证号")
#i= re.compile("^\d{17}[\dX]$") 
i= re.compile("^\d{10}[0(1-9) | 1(0-2)]{2}[0 | 1 | 2 | 3]\d\d{3}[\dX]$") 
b =re.findall(i,id)
print(b)

五、datetime模块

定义

python中的datetime模块提供了操作日期和时间功能

类名	描述
datetime.date	日期类
datetime.time	时间类
datetime.datetime	日期与时间类
datetime.timedelta	表示两个date、time、datetime实例之间的时间差
datetime.tzinfo	时区相关信息对象的抽象基类。
datetime.timezone	Python3.2中新增的功能，实现tzinfo抽象基类的类，表示与UTC的固定偏移量

两个属性

常量	功能说明	返回值 描述
datetime.MAXYEAR	返回能表示的最大年份	9999
datetime.MINYEAR	返回能表示的最小年份	1

#导包
import datetime
#最小年份
print(datetime.MINYEAR) #1
#最大年份
print(datetime.MAXYEAR) #9999

5.1 datetime.date类

class datetime.date(year, month, day)
datetime模块下的日期类(date)，只能处理年月日这种日期时间，不能处理时分秒
代码

#导包
from datetime import date

#创建一个日期对象
date01 = date(year=2021, month=12, day=22)
print(date01.year) #2021
print(date01.month) #12
print(date01.day) #22

常用方法

类方法/属性名称	描述
date.max	date对象所能表示的最大日期：9999-12-31
date.min	date对象所能表示的最小日期：00001-01-01
date.resoluation	date对象表示的日期的最小单位：天
date.today()	返回一个表示当前本地日期的date对象
date.fromtimestamp(timestamp)	根据给定的时间戳，返回一个date对象
d.year	年
d.month	月
d.day	日
d.replace(year[, month[, day]])	生成并返回一个新的日期对象，原日期对象不变
d.timetuple()	返回日期对应的time.struct_time对象
d.toordinal()	返回日期是是自0001-01-01开始的第多少天
d.weekday()	返回日期是星期几，[0, 6]，0表示星期一
d.isoweekday()	返回日期是星期几，[1, 7], 1表示星期一
d.isocalendar()	返回一个元组，格式为：(year, weekday, isoweekday)
d.isoformat()	返回‘YYYY-MM-DD’格式的日期字符串
d.strftime(format)	返回指定格式的日期字符串，与time模块的strftime(format, struct_time)功能相同

代码块

import time
from datetime import date

print(date.max)  # 9999-12-31
print(date.min)  # 0001-01-01 
print(date.resolution)  # 1 day, 0:00:00
print(date.today())  # 2020-03-17  
print(date.fromtimestamp(time.time()))  # 2020-03-17
d = date.today()  
print(d.year)  # 2020
print(d.month)  # 3
print(d.day)  # 17
print(d.replace(2019))  # 2019-03-17
print(d.replace(2019, 5))  # 2019-05-17
print(d.replace(2019, 5, 21))  # 2019-05-21
print(d.timetuple())  # time.struct_time(tm_year=2020, tm_mon=3, tm_mday=17, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=1, tm_yday=77, tm_isdst=-1)
print(d.toordinal())  # 737501
print(d.weekday())  # 1
print(d.isoweekday())  # 2
print(d.isocalendar())  # (2020, 12, 2)
print(d.isoformat())  # 2020-03-17
print(d.ctime())  # Tue Mar 17 00:00:00 2020
print(d.strftime('%Y/%m/%d'))  # 2020/03/17

5.2 datetime.time类

class datetime.time(hour, [minute[, second, [microsecond[, tzinfo]]]])

datetime模块下的时间类，只能处理时分秒

from datetime import time
a = time(11,59,59)
print(a) #11:59:59

常用方法

类方法/属性名称	描述
time.max	time类所能表示的最大时间：time(23, 59, 59, 999999)
time.min	time类所能表示的最小时间：time(0, 0, 0, 0)
time.resolution	时间的最小单位，即两个不同时间的最小差值：1微秒
t.hour	时
t.minute	分
t.second	秒
t.microsecond	微秒
t.tzinfo	返回传递给time构造方法的tzinfo对象，如果该参数未给出，则返回None
t.replace(hour[, minute[, second[, microsecond[, tzinfo]]]])	生成并返回一个新的时间对象，原时间对象不变
t.isoformat()	返回一个‘HH:MM:SS.%f’格式的时间字符串
t.strftime()	返回指定格式的时间字符串，与time模块的strftime(format, struct_time)功能相同

代码块

from datetime import time #导包datetime

print(time.max)  # 23:59:59.999999
print(time.min)  # 00:00:00
print(time.resolution)  # 0:00:00.000001
t = time(12, 15, 40, 6666)
print(t.hour)   # 12
print(t.minute)  # 15
print(t.second)  # 40
print(t.microsecond)  # 6666
print(t.replace(21))  # 21:15:40.006666
print(t.isoformat())  # 12:15:40.006666
print(t.strftime('%H%M%S'))  # 121540
print(t.strftime('%H%M%S.%f'))  # 121540.006666

5.3 datetime.datetime类

class datetime.datetime(year, month, day, hour=0, minute=0, second=0, microsecond=0, tzinfo=None)

一定要注意这是datetime模块下的datetime类，千万不要搞混了！datetime模块下的日期时间类，你可以理解为datetime.time和datetime.date的组合类

from datetime import datetime #导包datetime.datetime
a = datetime(year=2021, month=12, day=3, hour=10, minute=59, second=59)
print(a) #2021-12-03 10:59:59

常用方法

类方法**/**属性名称	描述
datetime.today()	返回一个表示当前本期日期时间的datetime对象
datetime.now([tz])	返回指定时区日期时间的datetime对象，如果不指定tz参数则结果同上
datetime.utcnow()	返回当前utc日期时间的datetime对象
datetime.fromtimestamp(timestamp[, tz])	根据指定的时间戳创建一个datetime对象
datetime.utcfromtimestamp(timestamp)	根据指定的时间戳创建一个datetime对象
datetime.combine(date, time)	把指定的date和time对象整合成一个datetime对象
datetime.strptime(date_str, format)	将时间字符串转换为datetime对象
dt.year, dt.month, dt.day	年、月、日
dt.hour, dt.minute, dt.second	时、分、秒
dt.microsecond, dt.tzinfo	微秒、时区信息
dt.date()	获取datetime对象对应的date对象
dt.time()	获取datetime对象对应的time对象，tzinfo为None
dt.timetz()	获取datetime对象对应的time对象，tzinfo与datetime对象的tzinfo相同
dt.replace()	生成并返回一个新的datetime对象，如果所有参数都没有指定，则返回一个与原datetime对象相同的对象
dt.timetuple()	返回datetime对象对应的tuple（不包括tzinfo）
dt.utctimetuple()	返回datetime对象对应的utc时间的tuple（不包括tzinfo）
dt.timestamp()	返回datetime对象对应的时间戳，Python 3.3才新增的
dt.toordinal()	同date对象
dt.weekday()	同date对象
dt.isocalendar()	同date对象
dt.isoformat([sep])	返回一个‘%Y-%m-%d’字符串
dt.ctime()	等价于time模块的time.ctime(time.mktime(d.timetuple()))
dt.strftime(format)	返回指定格式的时间字符串

代码块

from datetime import datetimeimport time
print(datetime.today())  # 2020-03-17 20:53:47.968485
print(datetime.now())  # 2020-03-17 20:53:47.969486
print(datetime.now(timezone.utc))  # 2020-03-17 12:53:47.970481+00:00
print(datetime.utcnow())  # 2020-03-17 12:53:47.972511
print(datetime.fromtimestamp(time.time())) 
 # 2020-03-17 20:53:48.031319
print(datetime.utcfromtimestamp(time.time()))  
# 2020-03-17 20:53:48.031319
print(datetime.combine(datetime(2018, 5, 21).date(), datetime(2018, 5, 21).time()))  # 2018-05-21 00:00:00
print(datetime.strptime('2017/08/27 10:23', '%Y/%m/%d %H:%M'))  
# 2017-08-27 10:23:00
dt = datetime.now()  
print(dt)   # 2020-03-17 20:47:23.388322   
print(dt.second)  # 23
print(dt.timestamp())  # 1584449243.388322
print(dt.date())  # 2020-03-17
print(dt.time())  # 20:47:23.388322
print(dt.timetz())  # 20:47:23.388322
print(dt.replace(2019))  # 2019-03-17 20:47:23.388322
print(dt.timetuple())  
# time.struct_time(tm_year=2020, tm_mon=3, tm_mday=17, tm_hour=20, tm_min=47, tm_sec=23, tm_wday=1, tm_yday=77, tm_isdst=-1)
print(dt.utctimetuple())  
# time.struct_time(tm_year=2020, tm_mon=3, tm_mday=17, tm_hour=20, tm_min=47, tm_sec=23, tm_wday=1, tm_yday=77, tm_isdst=0)
print(dt.toordinal())  # 737501
print(dt.weekday())  # 1
print(dt.isocalendar())  # (2020, 12, 2)
print(dt.isoformat())  # 2020-03-17T20:47:23.388322
print(dt.isoformat(sep='/'))  # 2020-03-17/20:47:23.388322
print(dt.isoformat(sep=' '))  # 2020-03-17 20:47:23.388322
print(dt.ctime())  # Tue Mar 17 20:47:23 2020
print(dt.strftime('%Y%m%d %H:%M:%S.%f'))  # 20200317 20:47:23.388322

5.4 datetime.timedelta类

class datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, hours=0, weeks=0)

timedelta对象表示两个不同时间之间的差值。可以对datetime.date, datetime.time和datetime.datetime对象做算术运算

常用方法

类方法**/**属性名称	描述
timedelta.min	timedelta(-999999999)
timedelta.max	timedelta(days=999999999, hours=23, minutes=59, seconds=59, microseconds=999999)
timedelta.resolution	timedelta(microseconds=1)
td.days	天 [-999999999, 999999999]
td.seconds	秒[0, 86399]
td.microseconds	微秒[0, 999999]
td.total_seconds()	时间差中包含的总秒数，等价于: td / timedelta(seconds=1)

代码块

import datetime
#一年有多少秒
print(datetime.timedelta(365).total_seconds())   #31536000.0
#获取现在时间
dt = datetime.datetime.now()

"""
print(dt) #2021-10-04 17:22:31.928545
print(dt + datetime.timedelta(3))    # 3天后 2021-10-07 17:23:33.130410
print(dt + datetime.timedelta(-3))   # 3天前 2021-10-01 17:23:33.130410
print(dt + datetime.timedelta(hours=3))  # 3小时后 2021-10-04 20:24:30.536769
print(dt + datetime.timedelta(hours=-3))  # 3小时前 2021-10-04 14:24:30.536769
print(dt + datetime.timedelta(hours=3, seconds=30))  # 3小时30秒后 2021-10-04 20:25:55.309684

"""

dt2 = dt + datetime.timedelta(hours=10)
print(dt2 - dt)  # 10:00:00
td = dt2 - dt
print(td.seconds)  # 36000

六、pprint模块

定义

pprint模块包含一个“美观打印器(PrettyPrinter)”，用于产生美观的数据结构视图。格式化程序生成可以由解释器正确解析的数据结构，并且容易使人阅读

Printing

使用 pprint 模块的最简单方法是调用 pprint() 方法：

定义

pprint模块包含一个“美观打印器(PrettyPrinter)”，用于产生美观的数据结构视图。格式化程序生成可以由解释器正确解析的数据结构，并且容易使人阅读

pprint.pprint(object,stream=None,indent=1, width=80,
depth=None)

indent — 缩进，width — 一行最大宽度， depth —
打印的深度，这个主要是针对一些可递归的对象，如果超出指定depth，其余的用"…"代替。

         eg: a=[1,2,[3,4,],5]  a的深度就是2; b=[1,2,[3,4,[5,6]],7,8] b的深度就是3

stream —指输出流对象，如果stream=None，那么输出流对象默认是sys.stdout

代码

from pprint import pprint#导包
data = [("大数据一班",{"张三":18,"李四":20}),
("大数据二班",{"张三":18,"李四":20}),
("大数据三班",{"张三":18,"李四":20}),
("大数据四班",{"张三":18,"李四":20})]

#这种是打印一行
print(data)
pprint(data)
"""
[('大数据一班', {'张三': 18, '李四': 20}),
 ('大数据二班', {'张三': 18, '李四': 20}),
 ('大数据三班', {'张三': 18, '李四': 20}),
 ('大数据四班', {'张三': 18, '李四': 20})]
"""

七、Formatting

格式化数据结构

代码块

#日志
import logging
from pprint import pformat

data = [
    ("一班",{"张三":18}),
    ("二班",{"李四":24}),
    ("三班",{"王五":19}),
    ("四班",{"赵六":20}),
    ("五班",{"钱七":32}),
    ("六班",{"周九":8}),
]
'''
.basicConfig(参数) 把数据添加到日志记录器中
'''
logging.basicConfig(
    level=logging.DEBUG,
    #对字符串进行格式化，%占位符
    format= "%(levelname)-8s %(message)s"
    # %(levelname)-8s --->代表debug
    # %(message)--->已经记录的信息，在这里代表date
)
#log日志的输出语句，取决于日志级别
logging.debug("对data进行格式化")
#对data进行格式化
a = pformat(data)
#splitlines() 按照行('\r','\r\n','\n')分隔，返回一个包含各行作为元素的列表
for line in a.splitlines():
    logging.debug(line.rstrip())
    #python rstrip() 删除 string 字符串末尾的指定字符(默认为空格)
"""
DEBUG Logging pformatted data
DEBUG [("一班",{"张三":18}),
DEBUG  ("二班",{"李四":24}),
DEBUG  ("三班",{"王五":19}),
DEBUG  ("四班",{"赵六":20}),
DEBUG  ("五班",{"钱七":32}),
DEBUG  ("六班",{"周九":8}),]
"""

小练习

#把下面的报错加上error
data = ["FAILED: Execution Error, return code 1 from org.apache.hadoop.hive.ql.exec.DDLTask. MetaException(message:org.apache.hadoop.hbase.client.RetriesExhaustedException: Can't get the locations",
	"at org.apache.hadoop.hbase.client.RpcRetryingCallerWithReadReplicas.getRegionLocations(RpcRetryingCallerWithReadReplicas.java:312)",
	"at org.apache.hadoop.hbase.client.ScannerCallableWithReplicas.call(ScannerCallableWithReplicas.java:153)",
	"at org.apache.hadoop.hbase.client.ScannerCallableWithReplicas.call(ScannerCallableWithReplicas.java:61)",
	"at org.apache.hadoop.hbase.client.RpcRetryingCaller.callWithoutRetries(RpcRetryingCaller.java:200)",
	"at org.apache.hadoop.hbase.client.ClientScanner.call(ClientScanner.java:320)",
	"at org.apache.hadoop.hbase.client.ClientScanner.nextScanner(ClientScanner.java:295)",
	"at org.apache.hadoop.hbase.client.ClientScanner.initializeScannerInConstruction(ClientScanner.java:160)",
	"at org.apache.hadoop.hbase.client.ClientScanner.<init>(ClientScanner.java:155)",
	"at org.apache.hadoop.hbase.client.HTable.getScanner(HTable.java:811)",
	"at org.apache.hadoop.hbase.MetaTableAccessor.fullScan(MetaTableAccessor.java:602)",
	"at org.apache.hadoop.hbase.MetaTableAccessor.tableExists(MetaTableAccessor.java:366)",
	"at org.apache.hadoop.hbase.client.HBaseAdmin.tableExists(HBaseAdmin.java:303)",
	"at org.apache.hadoop.hbase.client.HBaseAdmin.tableExists(HBaseAdmin.java:313)"]

logging.basicConfig(
    level=logging.ERROR,
    #对字符串进行格式化，%占位符
    format= "%(levelname)-8s %(message)s"
    # %(levelname)-8s --->代表error
    # %(message)--->已经记录的信息，在这里代表date
)
#log日志的输出语句，取决于日志级别
logging.error("对data进行格式化")
#对data进行格式化
a = pformat(data)
#splitlines() 按照行('\r','\r\n','\n')分隔，返回一个包含各行作为元素的列表
for line in a.splitlines():
    logging.error(line.rstrip())
    #python rstrip() 删除 string 字符

八、pickle模块

定义

pickle模块只能在python中使用，python中几乎所有的数据类型（列表，字典，集合，类等）都可以用pickle来序列化。

序列化方法

方法	功能
pickle.dump(obj, file)	将Python数据转换并保存到pickle格式的文件内
pickle.dumps(obj)	将Python数据转换为pickle格式的bytes字串
pickle.load(file)	从pickle格式的文件中读取数据并转换为python的类型
pickle.loads(bytes_object)	将pickle格式的bytes字串转换为python的类型

dumps()与loads()

dump(数据类型,文件对象) 把python转成二进制写入文件 load(文件对象) 把文件中的数据读取成二进制转成python

import pickle as p  #起别名
s = "hello python"
b = p.dumps(s)  #把字符串转换成二进制
print(b) #b'\x80\x04\x95\x10\x00\x00\x00\x00\x00\x00\x00\x8c\x0chello python\x94.'

c = p.loads(s)
print(c) #hello python

dump()与load()

dump(数据类型,文件对象) 把python转成二进制写入文件 load(文件对象) 把文件中的数据读取成二进制转成python

“”"

import pickle as p

list01 = ["小明","翠花","王五","张三"]
#因为只能是二进制的，所以文件要声明成b 。要写进去所以是w
#open("f.txt","x") #创建一个文件
f1 = open("f.txt","wb")
p.dump(list01,f1) #文件是个二进制文件，打不开

f1 = open("f.txt","rb")#r代表的是读
a = p.load(f1)
print(a) #['小明', '翠花', '王五', '张三']

九、文件的读取和写入

9.1 打开模式

语法

变量名 = open(文件名，打开模式)

文件的打开模式	描述
‘r’	只读模式，默认值，如果文件不存在，返回FileNotFoundError
‘w’	覆盖写模式，文件不存在则创建，存在则完全覆盖
‘x’	创建写模式，文件不存在则创建，存在则返回FileExistsError
‘a’	追加写模式，文件不存在则创建，存在则在文件最后追加内容
‘b’	二进制文件模式
‘t’	文本文件模式，默认值
‘+’	与r/w/x/a一同使用，在原功能基础上增加同时读写功能

代码

#在路径下面创建text.py文件
f =  open("text.txt","x")

#在桌面上创建test。windows下面\有转义的意思
open("C:\\Users\\wyh\\Desktop\\test.txt","x")
#想要打开的文件进行什么操作，就使用是什么模式
f =  open("text.txt","r")
#关闭文件
f.close()
#必须关闭文件，因为每次操作都是保存在内存中，并没有真正保存到文件中

9.2 读文件

常用方法

操作方法	描述
.read()	读入全部内容
.readline(size=-1)	读入一行内容，如果给出参数，读入该行前size长度
.readlines(hint=-1)	读入文件所有行，以每行为元素形成列表 如果给出参数，读入前hint行

代码

#首先我们要打开一个文件，需要有一个文件的对象
f = open("test.txt","r")

# f.read()      | 读入全部内容
r1=f.read()
print(r1)
’‘’
复兴的中国，
伟大的人民
‘’‘
# f.readline(size)  | 读入一行内容，如果给出参数，读入该行前size长度  
r2 = f.readline()   
print(r2)  #复兴的中国
r3 = f.readline(2)   
print(r3)  #复兴 

# f.readlines(hint=-1) | 读入文件所有行，以每行为元素形成列表 如果给出参数，读入前hint行 
r4 = f.readlines()
print(r4) #['复兴的中国\n', '伟大的人民\n']

#第四种
for i in f.readlines():
    print(i)

9.3 写文件

常用方法

操作方法	描述
.write(s)	向文件写入一个字符串或字节流
.writelines(lines)	将一个元素全为字符串的列表写入文件
.seek(offset)	改变当前文件操作指针的位置，offset含义如下： 0 – 文件开头； 1 – 当前位置； 2 – 文件结尾

#首先我们要打开一个文件，需要有一个文件的对象
f = open(“test.txt”,“w”)

代码

#  <f>.write(s)      向文件写入一个字符串或字节流    
s = "少年强则国强"
f.write(s)

# <f>.writelines(lines)    将一个元素全为字符串的列表写入文件  
l = ["馒头","大米","窝窝头"]
f.writelines(l)

#  <f>.seek(offset)    改变当前文件操作指针的位置，offset含义如下：  0  – 文件开头；  1  – 当前位置；  2  – 文件结尾   
f.seek(2)#末尾添加
f.write("腐朽的世界")


#第二种读文件
#但是这里的文本必须是英文，编码格式必须是UTF-8
#首先我们要打开一个文件，需要有一个文件的对象
f = open("test.txt","r+")

#这里的指针是指第一行的从几到几
#下标是从0开始的
f.seek(4)
r1 = f.readline()
print(r1)

9.4 删除文件

导入系统模块os模块
使用remove删除

import os
os.remove("test.txt")

9.5 with语句

语法

with open(文件名) as 别名

代码

f =  open("f.txt","rb")
a = f.readline()
print(a)
#打开一个文件，每一次都需要关闭文件
f.close()

with语句

#with语句
#和上面是一样的，只是不需要去关闭流
with open("f.txt","rb") as f:
    a = f.readline()
    print(a)

9.6读写JSON数据：json模块

定义

Json是一种轻量级的数据交换格式。Json源自JavaScript语言，易于人类的阅读和编写，同时也易于机器解析和生成，是目前应用最广泛的数据交换格式。

Python内置类型转换JSON类型对照表

Python	JSON
dict	object
list,tuple	array
str	string
int,float,Enums	number
True	true
False	false
None	null

常用方法

方法	功能
json.dump(obj,fp)	将python数据类型转换并保存到json格式的文件内
json.dumps(obj)	将python数据类型转换为json格式的字符串
json.load(fp)	从json格式的文件中读取数据并转换为python的类型
json.loads(s)	将json格式的字符串转换为python的类型

代码

'''
json模块
dump(python数据) 把python数据中转换为json数据
loads(json) 把json数据转换为python数据
'''
import json
"""
list01 = ["tom",{"jack":18},("hello","python")]
json01 = json.dumps(list01)
print(json01) #["tom", {"jack": 18}, ["hello", "python"]]

s = "\"foo\bar" #\b回退
print(s) #"foar
json02 = json.dumps(s)
print(json02) #"\"foo\bar"

s01 = json.loads(json02)
print(s01) #"foar

'''
data = {
    "大数据一班":[{"tom":18,"lihua":20,"jane":10}],
    "大数据二班":[{"tom":18,"lihua":20,"jane":10}],
    "大数据三班":[{"tom":18,"lihua":20,"jane":10}],
    "大数据四班":[{"tom":18,"lihua":20,"jane":10}],
    "大数据五班":[{"tom":18,"lihua":20,"jane":10}],
    "大数据六班":[{"tom":18,"lihua":20,"jane":10}]
}
'''
#dump和load

file01 = open("hh.txt","w")
with open("test.txt","w") as file01:
    json.dump(data,file01)

with open("test.txt","r") as file02:
    a = json.load(file02)
    print(a)

十、数学：math模块

定义

math模块是python中的数学函数模块，进行一些数学计算功能

基本函数

函数	用法	例子
ceil(x)	向上取整操作，返回类型：int	ceil(3.2) 输出：4
floor(x)	向下取整操作，返回类型：int	floor(3.2) 输出：3
pow(x,y)	计算一个数x的y次方;返回类型：float，该操作相当于**运算但是结果为浮点	pow(2,3) 输出：8.0
sqrt(x)	开平方，返回类型：float	sqrt(4) 输出：2.0
fabs(x)	对一个数值获取其绝对值操作	fabs(-1) 输出：1
copysign(x,y)	返回一个符号为y值为x的数值，返回类型：float	copysign(2, -4)输出：-2.0; copysign(2, 4)输出：2.0
factorial(x)	返回一个整形数值的阶乘	factorial(3)输出：6
fmod(x,y)	取模运算，返回类型：float	fmod(4,2)输出：0.0 fmod(4,5)输出：4.0 fmod(4,3)输出：1.0
fsum([])	返回迭代器中值的精确浮点和，返回类型：float	fsum([1.1,2.23]) 输出：3.33 fsum([2.4,4.3]) 输出：6.699999999999999
gcd(a, b)	返回a、b的最大公约数，返回类型：int	gcd(2,4) 输出：2
isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0)	判断两个数是否接近，返回类型：True/False	isclose(0.99,1,rel_tol=0.2) 输出：True isclose(0.9999999999,0.999999999991) 输出：True math.isclose(0.99,0) 输出：False
modf(x)	返回x的小数部分和整数部分。两个结果都带有x的符号，并且都是浮点数	modf(2.4) 输出：(0.3999999999999999, 2.0)
trunc	取整，返回类型：int	trunc(44.3333)输出：44

import math

a = math.ceil(3.2) #向上取整
a = math.floor(3.2) #向下取整
a = math.pow(3,2) #3的2次方
a = math.sqrt(4) #开平方
a = math.fabs(-1) #绝对值 
a = math.copysign(4, -2) #符号是符号，值是数值
a = math.factorial(4) #阶乘  4*3*2*1
a = math.fmod(4,2) #取余
a = math.fsum([2,3])   #迭代器的和
print(a)

常数

常数名称	使用说明
pi	π = 3.141592 …****，可用精度
e	e = 2.718281 …，达到可用的精度
tau	τ = 6.283185 …，可达到精度
inf	无穷大
nan	非数字

代码

mianji = math.pi*pow(4,2) 
print(mianji) #50.26548245743669
a = round(mianji,2) 
print(a) #50.27

对数和三角函数

函数	用法	例子
log(n)	e****为底数	log(5) 输出结果： 1.6094379124341003
log(n, basic)	其他数为底数	log(2, 5)输出结果： 0.43067655807339306
log2(n)	2为底数	log2(5)输出结果： 2.321928094887362
log10(n)	10为底数	log10(2) 输出结果 0.3010299956639812
sin(x)	正弦函数	sin(5) 输出结果： -0.9589242746631385
cos(x)	余弦函数	cos(5) 输出结果： 0.28366218546322625
tan(x)	正切函数	tan(5) 输出结果： -3.380515006246586

代码

import math

a = math.log(5)
b = math.log(2,5)
c = math.log2(5)
d = math.log10(2)
e = math.sin(5)
f = math.cos(5)
g = math.tan(5)
print(a)#1.6094379124341003
print(b)#0.43067655807339306
print(c)#2.321928094887362
print(d)#0.3010299956639812
print(e)#-0.9589242746631385
print(f)#0.28366218546322625
print(g)#-3.380515006246586

十一、random模块（随机数）

定义

random模块用于生成伪随机数。分布概率随机产生的，其结果是不可预测的

常用方法

方法	使用说明
random.random()	随机生成一个0-1之间的浮点数
random.randint(start,stop)	随机生成一个start,stop之间的整数
random.randrange(start,stop,step)	随机生成一个start,stop之间的整数
random.choice(sequence)	从一个序列中随机选择一个元素
random.shuffle(sequence)	随机打乱列表的顺序,原列表发生变化
random.sample(population,k)	从集合中随机抽取K个不重复的元素形成新的序列，返回的是一个新的序列，不会破坏原有序列。

代码

#导包
import random
#random.random() 随机生成一个浮点数
print(ra.random()) #0.7025318415790162
'''
random.randint(start,stop)随机生成一个start.stop 之间的整数
随机产生start-stop之间的整数，包括start和stop
'''
for i in range(10):
    b = random.randint(2,9)
    #print(b)
for i in range(10):
    c = random.randrange(1,10,2)
   # print(c)

'''
random.choice(sequence) 从一个序列中随机选择一个元素
序列类型：list tuple set dict
'''
list01 = ["张三","李四","王五","赵六"]
for i in range(10):
    a = random.choice(list01)
    #print(a)

tuple01 = ("张三","李四","王五","赵六")
for i in range(10):
    a = random.choice(list01)
    #print(a)


s01 = "hello"
a = random.choice(s01)
#print(a)

''' 
random.shuffle(sequence) 随机打乱列表的顺序,原列表发生变化
list tuple
string；字符有序的排列一起
'''
list02 = [2,5,8,0,3]
random.shuffle(list02)
#print(list02) #[5, 8, 0, 3, 2]
'''
random.sample(population,k) 从序列中随机抽取k个元素，返回一个新元素
#字典不可以
'''
list03 = [5674764747,5743,64636475687,7654]
random.sample(list03,2)
print(list03)

小练习

红包随机

'''
#红包的个数
#红包的金额
from random import random


def hbsj(num,money):
    list01 = []
    num01 = num #num01 = 4
    for i in range(num):
        num01 -= 1 #3 2 1 0
        if num01 >0: #3 2 1
            m = random.randint(1,money)
        else:
            m = money #最总剩下的钱数都给最后一个人
        money -= m #m是领走的钱，我们的总钱数money要减去领走的钱m
        list01.append(m/100)