5. 迭代器生成器高阶函数推导式内置函数模块(math.time)

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)
"""

 2.高阶函数

2.1 map函数

# ### 高阶函数:能够把函数当成参数传递的就是高阶函数
"""
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(res)
print(isinstance(res,Iterator)) # False
print(isinstance(res,Iterable)) # True
# 反转字典中的键值对
for k,v in res:
    print(k,v)
    dic2[v] = k
print(dic2)

# 同过字典的键,获取值,插入到新列表中.
print("---------")
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]

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

2.2 reduce

# ### 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)

2.3. sorted

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

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

# 按照绝对值排序(使用内置函数)
lst = [-99,-2,45,1]
res = sorted(lst,key=abs)
print(res)  #[1, -2, 45, -99]
"""
1   => 1
-2  => 2
45  => 45
-99 => 99
"""
"""
abs 获取一个数的绝对值
print(abs(-80.34))
print(abs(90))
"""
# 按照余数排序(使用自定义函数)
def func(n):
   return n % 10
lst = (19,24,91,36)
"""
91 % 10 => 1
24 % 10 => 4
36 % 10 => 6
19 % 10 => 9 
"""
res = sorted(lst,key=func)
print(lst)
print(res)

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

2.4.fliter

# ### filter
"""
filter(func,iterable)
功能:过滤  
   在自定义的函数中,如果
      return True  代表保留该数据
      return False 代表舍弃该数据
参数:
   1.func 自定义函数
   2.iterable 可迭代对象 (容器类型数据 range对象 迭代器)  
返回值:
   迭代器
"""
# 1.基本写法
listvar = [24,234,23,423,4,234,1,23,12,31,231,2,3]
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(lambda n : True if n % 2 == 0 else False,listvar)
print(list(it))

 3.推导式

 3.1 列表推导式

#!/usr/bin/env python
#-*- coding:utf-8 -*-
# ### 推导式 : 可以实现一些简单的操作,重要是代码比较简洁
"""
通过一行循环判断,遍历出一系列数据的方式是推导式
语法: 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,4,5,6,7,8,9,10]
lst = []
for i in range(1,10):    
    lst.append(i)
print(lst)

# (1).普通列表推导式
lst = [i for i in range(1,10)]
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,4,5,6,67,7,8,9]
lst2 = []
for i in lst:
    if i % 2 == 1:
        lst2.append(i)
print(lst2)

# 推导式写法
lst = [i for i in lst if i % 2 == 1]
print(lst)

# (3) 双循环的列表推导式
lst1 = ['麦秸唐',"曾曼","王铁男"]
lst2 = ["舒则会","郭一萌","廖萍萍"]
# "谁♥♥谁"
lst = []
for i in lst1:
    for j in lst2:
        strvar = i +"♥♥" +j
        # print(strvar)
        lst.append(strvar)
print(lst)

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

# (4) 带有判断条件的双循环列表推导式
lst1 = ['麦秸唐',"曾曼","王铁男"]
lst2 = ["舒则会","郭一萌","廖萍萍"]
lst = []
for  i in lst1:
    for j in lst2:
        if lst1.index(i) == lst2.index(j):
            strvar = i + "♥♥" + j
            lst.append(strvar)

print(lst)

lst = [i + "♥♥" + j for i in lst1 for j in lst2 if lst1.index(i) == lst2.index(j)]
print(lst)

3.2 集合推导式

# ### 集合推导式
"""
案例:
   满足年龄在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
如果是字典的键或者是集合的值,数据类型必须可哈希
"""

"""
三目运算符:
True if 条件表达式 else False
如果条件表达式成立,执行True
如果条件表达式不成立,执行False
"""

# 基本语法
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)]# 16 15 16 例子
"""
# 分解:
{
左手边:
"尊贵VIP卡老" + i['name'][0] if 18<=i['age']<=21 and 5000 <= i['money'] <= 5500 else "抠脚大汉卡老" + i['name'][0] 
右手边:
for i in listvar
}  
"""
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)

3.3 字典推导式

# ### 字典推导式
"""
### (1)enumerate
enumerate(iterable,[start=0])
功能:枚举 ; 将索引号和iterable中的值,一个一个拿出来配对组成元组放入迭代器中
参数:
    iterable: 可迭代性数据 (常用:迭代器,容器类型数据,可迭代对象range) 
    start:  可以选择开始的索引号(默认从0开始索引)
返回值:迭代器
"""
from collections import Iterator,Iterable
listvar = ['罗淞峰',"李祥海","银燕","赖廷"]
it = enumerate(listvar)
# print(it)
# print(isinstance(it,Iterator))
# print(list(it))
"""
[里面可以是列表,元组,字符串]
(里面可以是列表,元组,字符串)
{里面是元组}
[('a',1),('b',"sdfsdfsdfsdfsd")]
(['a',1],('b',"sdfsdfsdfsdfsd"))
{('a',1),("b",909090909090909090900909)}
"""

# dict 强转迭代器变成字典
# {0: '罗淞峰', 1: '李祥海', 2: '银燕', 3: '赖廷'}
res = dict(it)
print(res)

# 字典推导式的写法变成字典
it = enumerate(listvar) # 重置迭代器
dic = {k:v for k,v in it} #k接受的是012..345 v接受的是列表中的值
print(dic)

it = enumerate(listvar,start= 10)
dic = {k:v for k,v in it}
print(dic)


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

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

# 字典推导式
dic = {k:v for k,v in zip(lst2,lst3) }
print(dic)

 4.生成器

4.1 生成器表达式

# ### 生成器表达式 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)
   
 4.2 生成器函数

# ### 生成器函数
"""
# 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)
print('-------')
for i in range(30):
   print(next(gen))
print('-------')
# 如果是极大数据量,通过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)
print('%%%%%%%%%%%%')
# # 第二次
res = gen.send(111)
print(res,"<外头>")
print('%%%%%%%%%%%%')
# # 第三次
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)

 5.内置函数

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

# round 四舍五入(n.5 n为偶数则舍去 n.5 n为奇数，则进一!) 奇进偶不进
res = round(3.67)
res = round(3.899999999999999999999999999999999999999999)
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))

6.模块

6.1 math数学模块

# ### 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)


6.2 time时间模块

# ### 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)