python学习之路day05（迭代器和生成器）

1.迭代器

# ### 迭代器
"""能被next调用,并不断返回下一个值的对象"""
"""
特征:迭代器会生成惰性序列,它通过计算把值依次的返回,一边循环一边计算而不是一次性得到所有数据
优点:需要数据的时候,一次取一个,可以大大节省内存空间.而不是一股脑的把所有数据放进内存.
"""
# 1.可迭代对象
"""
如果一个数据类型其中的成员包含了__iter__方法,这个数据类型就是可迭代对象
dir 这个函数可以获取该数据类型的成员结构
"""
setvar = {1,2,"a","b"}
print(setvar)
for i in setvar:
print(i)

res = dir(setvar)
print(res)

# 2.迭代器
"""
for循环在迭代数据的时候,内部先转化成迭代器,然后通过next方法来进行调用,形成迭代效果

可迭代对象 -> 迭代器 从不可被直接调用 -> 可被直接调用的过程

变成迭代器:
(1) iter (2) __iter__()
遍历迭代器:
(1) next (2)__next__()
判断迭代器:
(1)该数据含有__iter__ 和 __next__ 两个方法,
就说该数据类型是迭代器
(2)from collections import Iterator,Iterable

如果是一个迭代器,一个是一个可迭代对象
如果是一个可迭代对象,不一定是迭代器.
"""
# 变成迭代器
res1 = iter(setvar)
print(res1) #iterator
res2 = setvar.__iter__()
print(res2)

# 遍历迭代器
res = next(res2)
res = next(res2)
res = next(res2)
print(res)

lst = dir(res2)
print(lst)
# 判断可迭代对象
print("__iter__" in dir(setvar))
# 判断迭代器 方法一
print("__iter__" in dir(res2) and "__next__" in dir(res2))

# 判断迭代器 方法二
# from 从哪里.. collections模块 import 引入 Iterator迭代器 Iterable可迭代对象
from collections import Iterator,Iterable
listvar = [1,2,3,4,5]
# listvar 是否是一个迭代器
res = isinstance(listvar,Iterator)
print(res) # False
# listvar 是否是一个可迭代对象
res = isinstance(listvar,Iterable)
print(res) # True

# 判断range的可迭代属性
res = isinstance(range(10) , Iterator)
print(res)
res = isinstance(range(10) , Iterable)
print(res)

# 遍历range对象
for i in range(10):
print(i)
# 能被next调用的,一定是一个迭代器
# next(range(10)) error

# 变成迭代器
it = iter(range(10))
print(it)
# 判断类型:isinstance
print(isinstance(it,Iterator))

# 调用range转换的迭代器
"""如果在调用时,超出了原有的数据个数,直接越界报错.
next在调用数据的时,是单向不可逆的.(一条路走到黑,一次性)
"""
# 遍历方法一
res = next(it)
res = next(it)
res = next(it)
res = next(it)
res = next(it)
res = next(it)
res = next(it)
res = next(it)
res = next(it)
res = next(it)
# res = next(it) error 越界报错
print(res)

print("<====>")
# 重置迭代器
it = iter(range(10))
# 遍历方法二,通过for和next 配合调用
for i in range(3):
res = next(it)
print(res)

# 遍历方法三,也可以通过for 一次性遍历所有迭代器中数据
print("<====>")
for i in it:
print(i)
# next(it) error
"""
用法1:isinstance(要判断的数据,数据类型) 返回True或者返回False
用法2:isinstance(要判断的数据,(数据类型1,数据类型2,数据类型3.....) ) 如果有一个条件满足,就返回真
int float bool complex str list tuple dict set
"""
"""
lst = [1,2,3]
res = isinstance(lst,list)
res = isinstance(lst,tuple)
# 有一个数据类型满足条件,就返回真
res = isinstance(lst, (list,tuple,set,str) )
print(res)
"""

3.高阶函数:能够把函数当成参数传递的就是高阶函数
"""
map reduce sorted filter
"""
（一）map
"""
map(func,iterable)
功能:把iterable里面的数据,一个一个扔到func函数中进行处理,把处理的结果放到迭代器中,最终返回迭代器
参数:
(1)func :内置函数 或 自定义函数
(2)iterable: 可迭代对象 容器类型数据,range对象,迭代器
返回值:
迭代器
"""
# 例子1: ["1","2","3","4"] => [1,2,3,4]
lst = ["1","2","3","4"]
lst2 = []
for i in lst:
res = int(i)
# print(res,type(res))
lst2.append(res)
print(lst2)

from collections import Iterator,Iterable
it = map(int,lst)
print( isinstance(it,Iterator) )
# (1)可使用next进行调用
res = next(it)
res = next(it)
res = next(it)
res = next(it)
print(res)

# (2)可使用for进行调用
it = map(int,lst)
for i in it:
print(i)

# (3) for 配合 next 进行调用迭代器
it = map(int,lst)
for i in range(2):
res = next(it)
print(res)

# (4) 使用list瞬间强转成列表.
it = map(int,lst) # 重置迭代器
lst = list(it)
print(lst)

# 例子2 [1,2,3,4] [3,6,9,12]
lst = [1,2,3,4]
lst2 = []
for i in lst:
res = i*3
lst2.append(res)
print(lst2)

"""
第一次把lst中的1拿出来,扔到func当中进行处理,返回3,放到迭代器中
第二次把lst中的2拿出来,扔到func当中进行处理,返回6,放到迭代器中
第三次把lst中的3拿出来,扔到func当中进行处理,返回9,放到迭代器中
第四次把lst中的4拿出来,扔到func当中进行处理,返回12,放到迭代器中
到此iterable中的数据已经没有,终止函数,返回迭代器.
"""
def func(n):
return n * 3
it = map(func,lst)
print(list(it))

# 例子3 {97:"a",98:"b",99:"c"} ["a","b","c"] => [97,98,99]
# dic = {"a":97,"b":98,"c":99}
dic = {97:"a",98:"b",99:"c"}
dic2 = {}
res = dic.items()
print(isinstance(res,Iterator)) # False
print(isinstance(res,Iterable)) # True
# 反转字典中的键值对
for k,v in res:
print(k,v)
dic2[v] = k
print(dic2)

# 同过字典的键,获取值,插入到新列表中.
lst = ["a","b","c"]
lst2 = []
for i in lst:
res = dic2[i]
lst2.append(res)
print(lst2)

# map自定义函数,需要一个参数,必须写一个返回值
def func(n):
dic = {97:"a",98:"b",99:"c"}
# 反转字典中的键值对
for k,v in dic.items():
print(k,v)
dic2[v] = k
print(dic2) #{'a': 97, 'b': 98, 'c': 99}
return dic2[n]

（二）reduce
"""
reduce(func,iterable)
功能:计算
先从iterable拿出2个数据,放到func中进行计算,得到的结果和iterable中的第三个元素,
在扔到func中做计算,依次类推,最终返回计算结果
参数:(1)func 内置函数 或 自定义函数
(2)iterable 可迭代对象 (容器类型数据,range对象,迭代器)
返回值: 计算出来的最终结果
"""
# 方法一
# lst = [5,4,8,8] => 5488
lst = [5,4,8,8]
strvar = ''
for i in lst:
strvar += str(i)
print(strvar,type(strvar))
print(int(strvar))

# 方法二
"""
5 * 10 + 4 = 54
54 * 10 + 8 = 548
548 * 10 + 8 = 5488
"""
it = iter(lst)
res1 = next(it) # 5
res2 = next(it) # 4
res = res1 * 10 + res2
print(res)

for i in it:
res = res * 10 + i
print(res,type(res))

# 使用reduce 进行改写
print("<============>")
"""
首先把5和4扔到func当中 5* 10 + 4 = 54
然后把54和iterable中的8,这两个参数扔到func中,
54 * 10 + 8 = 548
然后把548和iterable中的最后一个8两个参数扔到func中,
548 * 10 + 8 = 5488
计算完毕返回6=5488 结束.
"""
from functools import reduce
lst = [5,4,8,8]
def func(x,y):
return x*10 + y
res = reduce(func,lst)
print(res,type(res))

# "789" => 789 在不使用int强转的前提下完成
"""
"789" => [7,8,9]
list("789") = > ['7','8','9']
list("789") = > [7,8,9]
map(int,"789") error 不让用int
"""
strvar = "789"
def func1(n):
dic = {"0":0,"1":1,"2":2,"3":3,"4":4,"5":5,"6":6,"7":7,"8":8,"9":9}
return dic[n]

def func2(x,y):
return x*10 + y

it = map(func1,strvar)
# print(list(it))
# 开始计算
res = reduce(func2,it)
print(res,type(res))

# error
# res = reduce(func2,strvar)
# print(res)

it = map(func,["a","b","c"])
print(list(it))

(三)sorted
"""
sorted(iterable,reverse=False,key=函数)
功能：
 排序
参数：
 iterable 可迭代对象（容器类型 range对象 迭代器）
 reverse  控制正序或倒叙
 key:可自定义排序规则
返回值：
"""
#默认从小到大排序
lst=[0,-90,31,88]
res=sorted(lst)
print(res)

#从大到小排序
lst=[0,-90,31,88]
res=sorted(lst，reverse=True)
print(res)

#按照绝对值排序(使用内置函数)

lst=[-2,-99,31,1]
res=sorted(lst,key=abs)
print(res)

"""
-99=>99
-2=>2
45=>45
1=>1
"""
"""
abs 获取一个数的绝对值
print(abs(-80.34))
print(abs(90))
"""

#按照余数排序(使用自定义函数)
def func(n):
 return n%10
lst=[12,99,35,51]
#lst=(12,99,35,51)  元组
#lst=[12,99,35,51}  字典
res=sorted(lst,key=func)
print(res)

#如果排序字符串，按照ASCII编码排序
strvar="cbd"
res=sorted(strvar)
print(res)
"""
sort 基于原有列表进行修改
sorted  会产生一个新列表，原来的数据不动
其余的用法一摸一样
只不过sort只能用在列表中
sorted可以用在所有容器类型数据中
"""

(四)filter
"""
filter(func,iterable)
功能：过滤
 在自定义的函数中，如果
 return True  代表保留该数据
 return False 代表舍弃该数据
 
参数：
 1.func 自定义函数
 2.iterable 可迭代对象（容器类型数据 range对象  迭代器）
返回值：
 迭代器
"""
#1.基本写法
listvar=[24,2354,56,43,15,26,89,78,46,25,84]
for i in listvar:
 if i%2==0:
  print(i)
 else:
  pass

#2.filter写法
def func(n):
 if n%2==0:
  #保留该数据
  return True
 else:
  #舍弃该数据
  return False
it=filter(func,listvar)
print(list(it))

#3.优化版
func=lambda n :True if n%2==0 else False
it=filter(func,listvar)
print(list(it))

4.列表推导式

##推导式：阔以实现一些简单的操作，重要的是代码比较简洁
"""
通过一行循环判断，遍历出一系列数据的方式是推导式
语法：val for val in Iterable(把想要的值写在for的左侧)
里面是一行循环判断！根据套在推导式外层的符号判断具体是苏宁类型的推导式

种类：三种
 列表推导式：[val for val in Iterable]
 集合推导式：(val for val in Iterable)
 列表推导式：{a:b for a,b in Iterable}
"""
#lst=[1,2.3,3,4,5,6,7,8]
lst=[]
for i in range(1,1000000):
 lst.append()
print(lst)

#(1)普通列表推导式
lst=[i for i in range(1,1000001)]
print(lst)

#[1,2,3,4]  =>2,4,6,8
lst=[i*2 for i in range(1,10)]
print(lst)

#(2)带有判断条件的列表推导式
"""
推导式的后面只能跟单项分支，其他的是不行的
"""
lst=[1,2.3,3,4,5,6,7,8]
lst2=[]
for i in lst:
 if i%2==1:
  lst2.append(i)
print(lst2)

lst=[i for in lst if i%2==1]
print(lst)

#(3)  双循环的列表推导式
lst1=["麦杰康","增满","王铁男"]
lst2=["苏泽惠","郭艺梦","曾轶可"]
lst=[]
for i in lst1:
 for j in lst2:
  strvar=i+"aiai"+j
  #print(strvar)
  lst.append(i)
print(lst)

lst=[i+"aiai"+j for i in lst1 for j in lst2]
print(lst)

5.集合推导式

from collections import Iterator,Iterable
"""
案例:
   满足年龄在18到21,存款大于等于5000 小于等于5500的人,
   开卡格式为:尊贵VIP卡老x(姓氏),否则开卡格式为:抠脚大汉卡老x(姓氏)
   把开卡的种类统计出来
"""

listvar = [
   {"name":"王家辉","age":18,"money":10000},
   {"name":"王水机","age":19,"money":5100},
   {"name":"王鹏","age":20,"money":4800},
   {"name":"李站","age":21,"money":2000},
   {"name":"李小龙","age":180,"money":20}
]
"""
可哈希数据：不可变数据
    Number(int float complex bool) str tuple
不可哈希数据：可变数据
    list set dict
如果是字典的键或者是集合的值，数据类型必须可哈希
"""
setvar=set()
for i in listvar:
    if 18<=i["age"]<=21 and 5000<=i["money"]<=5500:
        strvar="尊贵VIP卡老"+i["name"][0]
    else:
        strvar = "抠脚大汉卡老" + i["name"][0]
    setvar.add(strvar)
print(setvar)

#集合推导式
lst=[15 if i%2==1 else 16 for i in range(3)]
print(lst)
setvar={"尊贵VIP卡老"+i["name"][0] if 18<=i["age"]<=21 and 5000<=i["money"]<=5500 else "抠脚大汉卡老" + i["name"][0] for i in listvar}
print(setvar)
"""
三目运算符：
True if 条件表达式 else Flase
如果条件表达式成立，执行True
如果条件表达式不成立，执行Flase
"""

#字典推导式
"""
enumerate 
语法：enumerate(iterable,start=0)
功能：枚举；将索引号和iterable中的值，一个一个拿出来，配对组成元组，放到迭代器中
参数：
    iterable:可迭代性数据（常用迭代器，容器类型数据，可迭代对象range）
    start:k可以选择开始的索引号（默认从0开始）
返回值：迭代器
"""
listvar=['罗淞峰',"李祥海","银燕","赖廷"]
print("======")
it=enumerate(listvar,start=1)
print(it)
print(isinstance(it,Iterator))
print(list(it))

"""
[里面可以是列表,元组,字符串]
(里面可以是列表,元组,字符串)
{里面是元组}
[('a',1),('b',"sdfsdfsdfsdfsd")]
(['a',1],('b',"sdfsdfsdfsdfsd"))
{('a',1),("b",909090909090909090900909)}
"""
print("-----------")
#dict 强转迭代器变成字典
#{'罗淞峰',"李祥海","银燕","赖廷"}
res=dict(it)
print(res)
it=enumerate(listvar,start=1)   #重置迭代器
dic={k:v for k,v in it}   #k接受的是012..345 v接受的是列表中的值
print(dic)

#zip
"""
zip（iterable,......)
功能：将多个iterable中的值，一个一个拿出来配对成元组放入迭代器中
iterable:可迭代性数据（常用迭代器,容器类型数据,可迭代对象range) 
返回: 迭代器

正常按照索引进行配对,放到元组中,如果找不到配对选项,直接舍弃.
"""
lst1 = ["吴波","帅乐","温素文"]
# lst2 = ["夜光花","吴耀橘","王照"]
lst2 = ["夜光花","吴耀橘","王照"]
lst3 = ["温红杰","刘璐","陈凤杰"]
it = zip(lst1,lst2,lst3)
print(it)
print(isinstance(it,Iterator))
print(list(it))

#dict强转迭代器变成字典
lst2 = ["夜光花","吴耀橘","王照"]
lst3 = ["温红杰","刘璐","陈凤杰"]
res=dict(zip(lst2,lst3))
print(res)
print("--------------")
#字典推导式
dic={k:v for k,v in zip(lst2,lst3)}
print(dic)

6.生成器表达式 generprint("<====>")ator
"""
#迭代器和生成器区别:
迭代器本身是系统内置的.重写不了.而生成器是用户自定义的,可以重写迭代逻辑
#元组推导式的返回值是一个生成器对象,简称生成器,生成器本质就是迭代器.

#生成器可以用两种方式创建:
(1)生成器表达式 (里面是推导式,外面用圆括号)
(2)生成器函数 (用def定义,里面含有yield)
"""
from collections import Iterator
# 基本定义
gen = (i for i in range(10))
print(gen) # 返回的是生成器对象,简称生成器
print(isinstance(gen,Iterator))

# 1.使用next方法调用生成器
res = next(gen)
res = next(gen)
res = next(gen)
print(res)

# 2.for 配合 next 进行调用
print("<====>")
for i in range(5):
res = next(gen)
print(res)

# 3.用for循环遍历生成器
print("<====>")
for i in gen:
print(i)

7. 生成器函数
"""
# yield 类似于 return
共同点在于:执行到这句话都会把值返回出去
不同点在于:yield每次返回时,会记住上次离开时执行的位置 , 下次在调用生成器 , 会从上次执行的位置往下走
而return直接终止函数,每次重头调用.
yield 6 和 yield(6) 2种写法都可以 yield 6 更像 return 6 的写法 推荐使用
"""

# 1.基本语法
def mygen():
print("one")
yield 1

print("two")
yield 2

print("three")
yield 3
"""
初始化生成器函数返回生成器对象,简称生成器
第一次,通过next调用,执行print("one") , 记录当前的状态,返回yield 1,程序添加阻塞,等待下一次调用
第二次,通过next调用,执行print("two") , 记录当前的状态,返回yield 2,程序添加阻塞,等待下一次调用
第三次,通过next调用,执行print("three") , 记录当前的状态,返回yield 3,程序添加阻塞,等待下一次调用

第四次,通过next调用,因为没有yield 返回值了,所以直接越界报错 ...
"""

# 初始化生成器函数 , 返回生成器对象 , 简称生成器
gen = mygen()
# 调用第一次
res = next(gen)
print(res)
# 调用第二次
res = next(gen)
print(res)
# 调用第三次
res = next(gen)
print(res)
'''
# 调用第四次 error
res = next(gen)
print(res)
'''

# 2.升级版生成器函数
def mygen():
for i in range(100):
yield "我的球衣号码是{:d}".format(i)

# 初始化生成器函数 ,返回生成器对象,简称生成器
gen = mygen()
for i in range(50):
res = next(gen)
print(res)

for i in range(30):
print(next(gen))

# 如果是极大数据量,通过for遍历等于执行死循环
for i in gen:
print(i)

# 3. send 使用 send只能给上一个yield发送数据
"""
### send
# next和send区别:
next 只能取值
send 不但能取值,还能发送值
# send注意点:
第一个 send 不能给 yield 传值 默认只能写None
最后一个yield 接受不到send的发送值
"""
def mygen():
print("start")
res1 = yield 1
print(res1,"<内头>")

res2 = yield 2
print(res2,"<内头>")

res3 = yield 3
print(res3,"<内头>")

print("end")

# 初始化生成器函数 返回生成器对象, 简称生成器
gen = mygen()
# 第一次无法给上一个yield发送数据,强制发送None,硬性的语法要求
res = gen.send(None)
print(res)
# # 第二次
res = gen.send(111)
print(res,"<外头>")
# # 第三次
res = gen.send(222)
print(res,"<外头>")
"""
# # 第四次 error StopIteration
res = gen.send(333)
print(res,"<外头>")
"""

"""
代码执行过程:
第一次调用时,没有遇到上一个yield,所以默认只能发送None,执行生成器函数
print("start") res1 = yield 1 记录当前代码执行的状态 把 1 返回给函数外的res变量接受,程序添加阻塞,等待下一次调用 ,执行到77行

第二次调用时,把111发送给 res1 = yield 1 , res1 = 111 接收到发送值,
代码从77往下执行 print(111) res2 = yield 2 把 2 返回给函数外的res变量接受 print(res)
程序添加阻塞,等待下一次调用 ,执行到80行

第三次调用时,把222发送给 res2 = yield 2 , res2 = 222 接收到发送值,
代码从80往下执行 print(222) res2 = yield 3 把 3 返回给函数外的res变量接受 print(res)
程序添加阻塞,等待下一次调用 ,执行到83行

第四次调用时,把333发送给 res3 = yield 3 , res3 = 333 接收到发送值,
代码从83往下执行 print(333) print("end") , 因为没有yield的返回值,直接越界报错.

解决生成器越界错误,可以使用try... except..方法解决.
"""

# yield from : 将一个可迭代对象变成一个迭代器返回
def mygen():
yield from [1,2,3]
gen = mygen()
res = next(gen)
print(res)
res = next(gen)
print(res)
res = next(gen)
print(res)

print("<===>")
# 斐波那契数列 (用前两数相加得到第三个) (面试题)
# 1 1 2 3 5 8 13 21 34 .. 要第n个数是多少?
def mygen(n):
a,b = 0,1
i = 0
while i < n:
yield b
# print(b)
a,b=b,a+b
i+=1
gen = mygen(5)
for i in gen:
print(i)

8. 内置函数
# abs 绝对值函数
res = abs(-90)
res = abs(-99.7)
print(res)

# round 四舍五入(n.5 n为偶数则舍去 n.5 n为奇数，则进一!) 奇进偶不进
res = round(3.67)
res = round(3.8999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999)
res = round(6.5)
res = round(8.5)
res = round(7.5)
res = round(8.51)
print(res)

# sum 计算一个序列得和
tup = (1,34,34,23,42,34,2,342,43,2,34)
print(sum(tup))

# max 获取一个序列里边的最大值
lst = [2,4,23,423,42,43,23,4,234,2,34,234,999]
print(max(lst))
lst2 = sorted(lst)
print(lst2)

# 最大值
print(lst2[-1])
# 最小值
print(lst2[0])

# min 获取一个序列里边的最小值 key = 自定义函数
lst = [2,4,23,423,42,43,23,4,234,2,34,234,999]
res = min(lst)
print(res)

print("<=====>")
"""
('罗送风', 80)
('银燕', 81)
('舒则会', 18)
('郭一萌', 90)
"""
lst = [("罗送风",82),("银燕",81),("舒则会",18),("郭一萌",90)]
def func(n):
# print(n)
return n[1] % 10
"""
0 ("郭一萌",90)
1 ("银燕",81)
2 ("罗送风",82)
8 ("舒则会",18)
"""
res = min(lst,key=func)
print(res)

# pow 计算某个数值的x次方
"""第三个参数是可选项,如果存在,那么前两个数平方之后再和第三个数取余."""
res = pow(2,3)
print(res)
res = pow(2,3,3) # 2
res = pow(2,3,4) # 0
res = pow(2,3,5) # 3
print(res)

# range 产生指定范围数据的可迭代对象
for i in range(5):
print(i)
for i in range(3,7):
print(i)
for i in range(9,0,-2):
print(i)

# bin 将10进制数据转化为二进制
print(bin(6))
# oct 将10进制数据转化为八进制
print(oct(9))
# hex 将10进制数据转化为16进制
print(hex(16))

# chr 将ASCII编码转换为字符
print(chr(97))
# ord 将字符转换为ASCII编码
print(ord("A"))

# eval 将字符串当作python代码执行
strvar = "print(1234)"
# print(strvar)
res = eval(strvar)
print(res) # eval返回值没有意义,直接执行即可

strvar = 'wangwen = "宇宙最帅的人啊"'
# eval(strvar) error eval 执行部分字符串时,比如声明变量,是不允许的

# exec 将字符串当作python代码执行(功能更强大)
strvar = 'wangwen = "宇宙最帅的人啊"'
exec(strvar)
print(wangwen)

strvar = """
for i in range(10):
print(i)
"""
exec(strvar)

# repr 不转义字符输出字符串 (原型化输出)
strvar = "老男孩老师来到深圳校区视察工作 每个员工表现的非常积极"
res = repr(strvar)
print(res)

# input 接受输入字符串,程序会添加阻塞
res = input("先森,你妈贵姓?")
print(res)

# hash 生成哈希值
strvar1 = "保定爱迪生,狄龙,专门早无用发明"
strvar2 = "保定爱迪生,狄龙,专门早无用发明"
print(hash(strvar1))
print(hash(strvar2))

 9.math 数学模块 使用:模块.方法()

import math
#ceil() 向上取整操作 (对比内置round)
res = math.ceil(3.01)
res = math.ceil(3.000000000000000000000000000000001)
res = math.ceil(3.999)
print(res)

#floor() 向下取整操作 (对比内置round)
res = math.floor(3.98)
res = math.floor(3.1111)
print(res)

#pow() 计算一个数值的N次方(结果为浮点数) (对比内置pow)
res = math.pow(2,3)
print(res)
# res = math.pow(2,3,3) error 没有第三个参数
# print(res)

#sqrt() 开平方运算(结果浮点数)
res = math.sqrt(9)
print(res)

#fabs() 计算一个数值的绝对值 (结果浮点数) (对比内置abs)
res = math.fabs(-8)
print(res)

#modf() 将一个数值拆分为整数和小数两部分组成元组
res = math.modf(5.12)
print(res) # (0.1200000000000001, 5.0)

#copysign() 将参数第二个数值的正负号拷贝给第一个
res = math.copysign(5,-9)
res = math.copysign(-5,-9)
print(res)
#fsum() 将一个容器数据中的数据进行求和运算 (结果浮点数)(对比内置sum)
lst = [1,3,43,4,34]
res = math.fsum(lst)
print(res)

#圆周率常数 pi
res = math.pi
print(res)

10. time 时间模块
import time

#time() 获取本地时间戳
res = time.time()
print(res)

#mktime() 通过[时间元组]获取[时间戳] (参数是时间元组)
# 年月日,时分秒,周几, 年中第几天 ,夏令时
ttp = (2019,7,21,18,28,0,0,0,0)
res = time.mktime(ttp)
print(res)

#localtime() 通过[时间戳]获取[时间元组] (默认当前时间)
# 用法1
res = time.localtime() #time.struct_time(tm_year=2019, tm_mon=7, tm_mday=21, tm_hour=18, tm_min=30, tm_sec=44, tm_wday=6, tm_yday=202, tm_isdst=0)
print(res)
# 用法2 可以具体指定时间戳
res = time.localtime(1563704880)
print(res)
# time.struct_time(tm_year=2019, tm_mon=7, tm_mday=21, tm_hour=18, tm_min=28, tm_sec=0, tm_wday=6, tm_yday=202, tm_isdst=0)

#ctime() 通过[时间戳]获取[时间字符串] (默认当前时间)
res = time.ctime()
print(res) # Sun Jul 21 18:32:46 2019

res = time.ctime(1563704880)
print(res)

#asctime() 通过[时间元组]获取[时间字符串](参数是时间元组)
'''asctime不能够自动识别周几,需要手动填写'''
ttp = (2019,7,21,18,28,0,6,0,0)
res = time.asctime(ttp)
print(res)

# 解决方式:用mktime和ctime配合解决
ttp = (2019,7,21,18,28,0,0,0,0)
res = time.mktime(ttp)
strtime = time.ctime(res)
print(strtime)

#strftime() 通过[时间元组]格式化[时间字符串] (格式化字符串,[可选时间元组参数])
# 年月日,时分秒 linux 使用中文不会报错,windows会报错
res = time.strftime("%Y-%m-%d %H:%M:%S")
print(res)
# 加上第二个参数,按照实际的时间元组转成时间字符串,如果不加,以当前默认时间进行转化.
ttp = (2019,7,21,18,28,0,0,0,0)
res = time.strftime("%Y-%m-%d %H:%M:%S",ttp)
print(res)

#strptime() 通过[时间字符串]提取出[时间元组] (时间字符串,格式化字符串)
"""两个字符串之间,除了格式化标签,其他必须一模一样"""
strvar1 = "2019年8月1号5点10分20秒是建军节"
strvar2 = "%Y年%m月%d号%H点%M分%S秒是建军节"
res = time.strptime(strvar1,strvar2)
print(res)
# time.struct_time(tm_year=2019, tm_mon=8, tm_mday=1, tm_hour=5, tm_min=10, tm_sec=20, tm_wday=3, tm_yday=213, tm_isdst=-1)

#sleep() 程序睡眠等待
# time.sleep(3)
# print("睡醒了")

#perf_counter() 用于计算程序运行的时间
starttime = time.perf_counter()

for i in range(1000000000):
pass

endtime = time.perf_counter()
res = endtime - starttime
print(res)