1.迭代器

# ### 迭代器
"""能被next調(diào)用,并不斷返回下一個值的對象"""
"""
特征:迭代器會生成惰性序列,它通過計算把值依次的返回,一邊循環(huán)一邊計算而不是一次性得到所有數(shù)據(jù)
優(yōu)點:需要數(shù)據(jù)的時候,一次取一個,可以大大節(jié)省內(nèi)存空間.而不是一股腦的把所有數(shù)據(jù)放進(jìn)內(nèi)存.
"""
# 1.可迭代對象
"""
如果一個數(shù)據(jù)類型其中的成員包含了__iter__方法,這個數(shù)據(jù)類型就是可迭代對象
dir 這個函數(shù)可以獲取該數(shù)據(jù)類型的成員結(jié)構(gòu)
"""
setvar = {1,2,"a","b"}
print(setvar)
for i in setvar:
print(i)

res = dir(setvar)
print(res)

# 2.迭代器
"""
for循環(huán)在迭代數(shù)據(jù)的時候,內(nèi)部先轉(zhuǎn)化成迭代器,然后通過next方法來進(jìn)行調(diào)用,形成迭代效果

可迭代對象 -> 迭代器 從不可被直接調(diào)用 -> 可被直接調(diào)用的過程

變成迭代器:
(1) iter (2) __iter__()
遍歷迭代器:
(1) next (2)__next__()
判斷迭代器:
(1)該數(shù)據(jù)含有__iter__ 和 __next__ 兩個方法,
就說該數(shù)據(jù)類型是迭代器
(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調(diào)用的,一定是一個迭代器
# next(range(10)) error

# 變成迭代器
it = iter(range(10))
print(it)
# 判斷類型:isinstance
print(isinstance(it,Iterator))

# 調(diào)用range轉(zhuǎn)換的迭代器
"""如果在調(diào)用時,超出了原有的數(shù)據(jù)個數(shù),直接越界報錯.
next在調(diào)用數(shù)據(jù)的時,是單向不可逆的.(一條路走到黑,一次性)
"""
# 遍歷方法一
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 配合調(diào)用
for i in range(3):
res = next(it)
print(res)

# 遍歷方法三,也可以通過for 一次性遍歷所有迭代器中數(shù)據(jù)
print("<====>")
for i in it:
print(i)
# next(it) error
"""
用法1:isinstance(要判斷的數(shù)據(jù),數(shù)據(jù)類型) 返回True或者返回False
用法2:isinstance(要判斷的數(shù)據(jù),(數(shù)據(jù)類型1,數(shù)據(jù)類型2,數(shù)據(jù)類型3.....) ) 如果有一個條件滿足,就返回真
int float bool complex str list tuple dict set
"""
"""
lst = [1,2,3]
res = isinstance(lst,list)
res = isinstance(lst,tuple)
# 有一個數(shù)據(jù)類型滿足條件,就返回真
res = isinstance(lst, (list,tuple,set,str) )
print(res)
"""

3.高階函數(shù):能夠把函數(shù)當(dāng)成參數(shù)傳遞的就是高階函數(shù)
"""
map reduce sorted filter
"""
（一）map
"""
map(func,iterable)
功能:把iterable里面的數(shù)據(jù),一個一個扔到func函數(shù)中進(jìn)行處理,把處理的結(jié)果放到迭代器中,最終返回迭代器
參數(shù):
(1)func :內(nèi)置函數(shù) 或 自定義函數(shù)
(2)iterable: 可迭代對象 容器類型數(shù)據(jù),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進(jìn)行調(diào)用
res = next(it)
res = next(it)
res = next(it)
res = next(it)
print(res)

# (2)可使用for進(jìn)行調(diào)用
it = map(int,lst)
for i in it:
print(i)

# (3) for 配合 next 進(jìn)行調(diào)用迭代器
it = map(int,lst)
for i in range(2):
res = next(it)
print(res)

# (4) 使用list瞬間強(qiáng)轉(zhuǎn)成列表.
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當(dāng)中進(jìn)行處理,返回3,放到迭代器中
第二次把lst中的2拿出來,扔到func當(dāng)中進(jìn)行處理,返回6,放到迭代器中
第三次把lst中的3拿出來,扔到func當(dāng)中進(jìn)行處理,返回9,放到迭代器中
第四次把lst中的4拿出來,扔到func當(dāng)中進(jìn)行處理,返回12,放到迭代器中
到此iterable中的數(shù)據(jù)已經(jīng)沒有,終止函數(shù),返回迭代器.
"""
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
# 反轉(zhuǎn)字典中的鍵值對
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自定義函數(shù),需要一個參數(shù),必須寫一個返回值
def func(n):
dic = {97:"a",98:"b",99:"c"}
# 反轉(zhuǎn)字典中的鍵值對
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個數(shù)據(jù),放到func中進(jìn)行計算,得到的結(jié)果和iterable中的第三個元素,
在扔到func中做計算,依次類推,最終返回計算結(jié)果
參數(shù):(1)func 內(nèi)置函數(shù) 或 自定義函數(shù)
(2)iterable 可迭代對象 (容器類型數(shù)據(jù),range對象,迭代器)
返回值: 計算出來的最終結(jié)果
"""
# 方法一
# 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 進(jìn)行改寫
print("<============>")
"""
首先把5和4扔到func當(dāng)中 5* 10 + 4 = 54
然后把54和iterable中的8,這兩個參數(shù)扔到func中,
54 * 10 + 8 = 548
然后把548和iterable中的最后一個8兩個參數(shù)扔到func中,
548 * 10 + 8 = 5488
計算完畢返回6=5488 結(jié)束.
"""
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強(qiáng)轉(zhuǎn)的前提下完成
"""
"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=函數(shù))
功能：
?排序
參數(shù)：
?iterable 可迭代對象（容器類型 range對象 迭代器）
?reverse? 控制正序或倒敘
?key:可自定義排序規(guī)則
返回值：
"""
#默認(rèn)從小到大排序
lst=[0,-90,31,88]
res=sorted(lst)
print(res)

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

#按照絕對值排序(使用內(nèi)置函數(shù))

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

"""
-99=>99
-2=>2
45=>45
1=>1
"""
"""
abs 獲取一個數(shù)的絕對值
print(abs(-80.34))
print(abs(90))
"""

#按照余數(shù)排序(使用自定義函數(shù))
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 基于原有列表進(jìn)行修改
sorted? 會產(chǎn)生一個新列表，原來的數(shù)據(jù)不動
其余的用法一摸一樣
只不過sort只能用在列表中
sorted可以用在所有容器類型數(shù)據(jù)中
"""

(四)filter
"""
filter(func,iterable)
功能：過濾
?在自定義的函數(shù)中，如果
?return True? 代表保留該數(shù)據(jù)
?return False 代表舍棄該數(shù)據(jù)
?
參數(shù)：
?1.func 自定義函數(shù)
?2.iterable 可迭代對象（容器類型數(shù)據(jù) 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:
??#保留該數(shù)據(jù)
??return True
?else:
??#舍棄該數(shù)據(jù)
??return False
it=filter(func,listvar)
print(list(it))

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

4.列表推導(dǎo)式

##推導(dǎo)式：闊以實現(xiàn)一些簡單的操作，重要的是代碼比較簡潔
"""
通過一行循環(huán)判斷，遍歷出一系列數(shù)據(jù)的方式是推導(dǎo)式
語法：val for val in Iterable(把想要的值寫在for的左側(cè))
里面是一行循環(huán)判斷！根據(jù)套在推導(dǎo)式外層的符號判斷具體是蘇寧類型的推導(dǎo)式

種類：三種
?列表推導(dǎo)式：[val for val in Iterable]
?集合推導(dǎo)式：(val for val in Iterable)
?列表推導(dǎo)式：{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)普通列表推導(dǎo)式
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)帶有判斷條件的列表推導(dǎo)式
"""
推導(dǎo)式的后面只能跟單項分支，其他的是不行的
"""
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)? 雙循環(huán)的列表推導(dǎo)式
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.集合推導(dǎo)式 from collections import Iterator,Iterable
"""
案例:
滿足年齡在18到21,存款大于等于5000 小于等于5500的人,
開卡格式為:尊貴VIP卡老x(姓氏),否則開卡格式為:摳腳大漢卡老x(姓氏)
把開卡的種類統(tǒng)計出來
"""

listvar = [
{"name":"王家輝","age":18,"money":10000},
{"name":"王水機(jī)","age":19,"money":5100},
{"name":"王鵬","age":20,"money":4800},
{"name":"李站","age":21,"money":2000},
{"name":"李小龍","age":180,"money":20}
]
"""
可哈希數(shù)據(jù)：不可變數(shù)據(jù)
Number(int float complex bool) str tuple
不可哈希數(shù)據(jù)：可變數(shù)據(jù)
list set dict
如果是字典的鍵或者是集合的值，數(shù)據(jù)類型必須可哈希
"""
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)

#集合推導(dǎo)式
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 條件表達(dá)式 else Flase
如果條件表達(dá)式成立，執(zhí)行True
如果條件表達(dá)式不成立，執(zhí)行Flase
"""

#字典推導(dǎo)式
"""
enumerate
語法：enumerate(iterable,start=0)
功能：枚舉；將索引號和iterable中的值，一個一個拿出來，配對組成元組，放到迭代器中
參數(shù)：
iterable:可迭代性數(shù)據(jù)（常用迭代器，容器類型數(shù)據(jù)，可迭代對象range）
start:k可以選擇開始的索引號（默認(rèn)從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 強(qiáng)轉(zhuǎn)迭代器變成字典
#{'羅淞峰',"李祥海","銀燕","賴廷"}
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:可迭代性數(shù)據(jù)（常用迭代器,容器類型數(shù)據(jù),可迭代對象range)
返回: 迭代器

正常按照索引進(jìn)行配對,放到元組中,如果找不到配對選項,直接舍棄.
"""
lst1 = ["吳波","帥樂","溫素文"]
# lst2 = ["夜光花","吳耀橘","王照"]
lst2 = ["夜光花","吳耀橘","王照"]
lst3 = ["溫紅杰","劉璐","陳鳳杰"]
it = zip(lst1,lst2,lst3)
print(it)
print(isinstance(it,Iterator))
print(list(it))

#dict強(qiáng)轉(zhuǎn)迭代器變成字典
lst2 = ["夜光花","吳耀橘","王照"]
lst3 = ["溫紅杰","劉璐","陳鳳杰"]
res=dict(zip(lst2,lst3))
print(res)
print("--------------")
#字典推導(dǎo)式
dic={k:v for k,v in zip(lst2,lst3)}
print(dic)

6.生成器表達(dá)式 generprint("<====>")ator
"""
#迭代器和生成器區(qū)別:
迭代器本身是系統(tǒng)內(nèi)置的.重寫不了.而生成器是用戶自定義的,可以重寫迭代邏輯
#元組推導(dǎo)式的返回值是一個生成器對象,簡稱生成器,生成器本質(zhì)就是迭代器.

#生成器可以用兩種方式創(chuàng)建:
(1)生成器表達(dá)式 (里面是推導(dǎo)式,外面用圓括號)
(2)生成器函數(shù) (用def定義,里面含有yield)
"""
from collections import Iterator
# 基本定義
gen = (i for i in range(10))
print(gen) # 返回的是生成器對象,簡稱生成器
print(isinstance(gen,Iterator))

# 1.使用next方法調(diào)用生成器
res = next(gen)
res = next(gen)
res = next(gen)
print(res)

# 2.for 配合 next 進(jìn)行調(diào)用
print("<====>")
for i in range(5):
res = next(gen)
print(res)

# 3.用for循環(huán)遍歷生成器
print("<====>")
for i in gen:
print(i)

7. 生成器函數(shù)
"""
# yield 類似于 return
共同點在于:執(zhí)行到這句話都會把值返回出去
不同點在于:yield每次返回時,會記住上次離開時執(zhí)行的位置 , 下次在調(diào)用生成器 , 會從上次執(zhí)行的位置往下走
而return直接終止函數(shù),每次重頭調(diào)用.
yield 6 和 yield(6) 2種寫法都可以 yield 6 更像 return 6 的寫法 推薦使用
"""

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

print("two")
yield 2

print("three")
yield 3
"""
初始化生成器函數(shù)返回生成器對象,簡稱生成器
第一次,通過next調(diào)用,執(zhí)行print("one") , 記錄當(dāng)前的狀態(tài),返回yield 1,程序添加阻塞,等待下一次調(diào)用
第二次,通過next調(diào)用,執(zhí)行print("two") , 記錄當(dāng)前的狀態(tài),返回yield 2,程序添加阻塞,等待下一次調(diào)用
第三次,通過next調(diào)用,執(zhí)行print("three") , 記錄當(dāng)前的狀態(tài),返回yield 3,程序添加阻塞,等待下一次調(diào)用

第四次,通過next調(diào)用,因為沒有yield 返回值了,所以直接越界報錯 ...
"""

# 初始化生成器函數(shù) , 返回生成器對象 , 簡稱生成器
gen = mygen()
# 調(diào)用第一次
res = next(gen)
print(res)
# 調(diào)用第二次
res = next(gen)
print(res)
# 調(diào)用第三次
res = next(gen)
print(res)
'''
# 調(diào)用第四次 error
res = next(gen)
print(res)
'''

# 2.升級版生成器函數(shù)
def mygen():
for i in range(100):
yield "我的球衣號碼是{:d}".format(i)

# 初始化生成器函數(shù) ,返回生成器對象,簡稱生成器
gen = mygen()
for i in range(50):
res = next(gen)
print(res)

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

# 如果是極大數(shù)據(jù)量,通過for遍歷等于執(zhí)行死循環(huán)
for i in gen:
print(i)

# 3. send 使用 send只能給上一個yield發(fā)送數(shù)據(jù)
"""
### send
# next和send區(qū)別:
next 只能取值
send 不但能取值,還能發(fā)送值
# send注意點:
第一個 send 不能給 yield 傳值 默認(rèn)只能寫None
最后一個yield 接受不到send的發(fā)送值
"""
def mygen():
print("start")
res1 = yield 1
print(res1,"<內(nèi)頭>")

res2 = yield 2
print(res2,"<內(nèi)頭>")

res3 = yield 3
print(res3,"<內(nèi)頭>")

print("end")

# 初始化生成器函數(shù) 返回生成器對象, 簡稱生成器
gen = mygen()
# 第一次無法給上一個yield發(fā)送數(shù)據(jù),強(qiáng)制發(fā)送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,"<外頭>")
"""

"""
代碼執(zhí)行過程:
第一次調(diào)用時,沒有遇到上一個yield,所以默認(rèn)只能發(fā)送None,執(zhí)行生成器函數(shù)
print("start") res1 = yield 1 記錄當(dāng)前代碼執(zhí)行的狀態(tài) 把 1 返回給函數(shù)外的res變量接受,程序添加阻塞,等待下一次調(diào)用 ,執(zhí)行到77行

第二次調(diào)用時,把111發(fā)送給 res1 = yield 1 , res1 = 111 接收到發(fā)送值,
代碼從77往下執(zhí)行 print(111) res2 = yield 2 把 2 返回給函數(shù)外的res變量接受 print(res)
程序添加阻塞,等待下一次調(diào)用 ,執(zhí)行到80行

第三次調(diào)用時,把222發(fā)送給 res2 = yield 2 , res2 = 222 接收到發(fā)送值,
代碼從80往下執(zhí)行 print(222) res2 = yield 3 把 3 返回給函數(shù)外的res變量接受 print(res)
程序添加阻塞,等待下一次調(diào)用 ,執(zhí)行到83行

第四次調(diào)用時,把333發(fā)送給 res3 = yield 3 , res3 = 333 接收到發(fā)送值,
代碼從83往下執(zhí)行 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("<===>")
# 斐波那契數(shù)列 (用前兩數(shù)相加得到第三個) (面試題)
# 1 1 2 3 5 8 13 21 34 .. 要第n個數(shù)是多少?
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. 內(nèi)置函數(shù)
# abs 絕對值函數(shù)
res = abs(-90)
res = abs(-99.7)
print(res)

# round 四舍五入(n.5 n為偶數(shù)則舍去 n.5 n為奇數(shù)，則進(jìn)一!) 奇進(jìn)偶不進(jì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 = 自定義函數(shù)
lst = [2,4,23,423,42,43,23,4,234,2,34,234,999]
res = min(lst)
print(res)

print("<=====>")
"""
('羅送風(fēng)', 80)
('銀燕', 81)
('舒則會', 18)
('郭一萌', 90)
"""
lst = [("羅送風(fēng)",82),("銀燕",81),("舒則會",18),("郭一萌",90)]
def func(n):
# print(n)
return n[1] % 10
"""
0 ("郭一萌",90)
1 ("銀燕",81)
2 ("羅送風(fēng)",82)
8 ("舒則會",18)
"""
res = min(lst,key=func)
print(res)

# pow 計算某個數(shù)值的x次方
"""第三個參數(shù)是可選項,如果存在,那么前兩個數(shù)平方之后再和第三個數(shù)取余."""
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 產(chǎn)生指定范圍數(shù)據(jù)的可迭代對象
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進(jìn)制數(shù)據(jù)轉(zhuǎn)化為二進(jìn)制
print(bin(6))
# oct 將10進(jìn)制數(shù)據(jù)轉(zhuǎn)化為八進(jìn)制
print(oct(9))
# hex 將10進(jìn)制數(shù)據(jù)轉(zhuǎn)化為16進(jìn)制
print(hex(16))

# chr 將ASCII編碼轉(zhuǎn)換為字符
print(chr(97))
# ord 將字符轉(zhuǎn)換為ASCII編碼
print(ord("A"))

# eval 將字符串當(dāng)作python代碼執(zhí)行
strvar = "print(1234)"
# print(strvar)
res = eval(strvar)
print(res) # eval返回值沒有意義,直接執(zhí)行即可

strvar = 'wangwen = "宇宙最帥的人啊"'
# eval(strvar) error eval 執(zhí)行部分字符串時,比如聲明變量,是不允許的

# exec 將字符串當(dāng)作python代碼執(zhí)行(功能更強(qiáng)大)
strvar = 'wangwen = "宇宙最帥的人啊"'
exec(strvar)
print(wangwen)

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

# repr 不轉(zhuǎn)義字符輸出字符串 (原型化輸出)
strvar = "老男孩老師來到深圳校區(qū)視察工作\n每個員工表現(xiàn)的非常積極"
res = repr(strvar)
print(res)

# input 接受輸入字符串,程序會添加阻塞
res = input("先森,你媽貴姓?")
print(res)

# hash 生成哈希值
strvar1 = "保定愛迪生,狄龍,專門早無用發(fā)明"
strvar2 = "保定愛迪生,狄龍,專門早無用發(fā)明"
print(hash(strvar1))
print(hash(strvar2))

?9.math 數(shù)學(xué)模塊 使用:模塊.方法()

import math
#ceil() 向上取整操作 (對比內(nèi)置round)
res = math.ceil(3.01)
res = math.ceil(3.000000000000000000000000000000001)
res = math.ceil(3.999)
print(res)

#floor() 向下取整操作 (對比內(nèi)置round)
res = math.floor(3.98)
res = math.floor(3.1111)
print(res)

#pow() 計算一個數(shù)值的N次方(結(jié)果為浮點數(shù)) (對比內(nèi)置pow)
res = math.pow(2,3)
print(res)
# res = math.pow(2,3,3) error 沒有第三個參數(shù)
# print(res)

#sqrt() 開平方運算(結(jié)果浮點數(shù))
res = math.sqrt(9)
print(res)

#fabs() 計算一個數(shù)值的絕對值 (結(jié)果浮點數(shù)) (對比內(nèi)置abs)
res = math.fabs(-8)
print(res)

#modf() 將一個數(shù)值拆分為整數(shù)和小數(shù)兩部分組成元組
res = math.modf(5.12)
print(res) # (0.1200000000000001, 5.0)

#copysign() 將參數(shù)第二個數(shù)值的正負(fù)號拷貝給第一個
res = math.copysign(5,-9)
res = math.copysign(-5,-9)
print(res)
#fsum() 將一個容器數(shù)據(jù)中的數(shù)據(jù)進(jìn)行求和運算 (結(jié)果浮點數(shù))(對比內(nèi)置sum)
lst = [1,3,43,4,34]
res = math.fsum(lst)
print(res)

#圓周率常數(shù) pi
res = math.pi
print(res)

?

10. time 時間模塊
import time

#time() 獲取本地時間戳
res = time.time()
print(res)

#mktime() 通過[時間元組]獲取[時間戳] (參數(shù)是時間元組)
# 年月日,時分秒,周幾, 年中第幾天 ,夏令時
ttp = (2019,7,21,18,28,0,0,0,0)
res = time.mktime(ttp)
print(res)

#localtime() 通過[時間戳]獲取[時間元組] (默認(rèn)當(dāng)前時間)
# 用法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() 通過[時間戳]獲取[時間字符串] (默認(rèn)當(dāng)前時間)
res = time.ctime()
print(res) # Sun Jul 21 18:32:46 2019

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

#asctime() 通過[時間元組]獲取[時間字符串](參數(shù)是時間元組)
'''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() 通過[時間元組]格式化[時間字符串] (格式化字符串,[可選時間元組參數(shù)])
# 年月日,時分秒 linux 使用中文不會報錯,windows會報錯
res = time.strftime("%Y-%m-%d %H:%M:%S")
print(res)
# 加上第二個參數(shù),按照實際的時間元組轉(zhuǎn)成時間字符串,如果不加,以當(dāng)前默認(rèn)時間進(jìn)行轉(zhuǎn)化.
ttp = (2019,7,21,18,28,0,0,0,0)
res = time.strftime("%Y-%m-%d %H:%M:%S",ttp)
print(res)

#strptime() 通過[時間字符串]提取出[時間元組] (時間字符串,格式化字符串)
"""兩個字符串之間,除了格式化標(biāo)簽,其他必須一模一樣"""
strvar1 = "2019年8月1號5點10分20秒是建軍節(jié)"
strvar2 = "%Y年%m月%d號%H點%M分%S秒是建軍節(jié)"
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)

?

轉(zhuǎn)載于:https://www.cnblogs.com/vivian0119/p/11241888.html

總結(jié)

以上是生活随笔為你收集整理的python学习之路day05（迭代器和生成器）的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。