round stop 內置函數 天氣 false als 錯誤 class key

一:匿名函數 lambda表達式
用一句話來表達只有返回值的函數,叫匿名函數
特點:簡潔方便
語法:
lambda 參數: 返回值
#(1)不帶有參數的lambda表達式
def func():
return "今天要下雨,天氣挺冷"

#定義一個lambda表達式
func = lambda : "今天要下雨,天氣挺冷"
res = func()
print(res)
#(2) 帶有參數的lambda表達式
def func(n):
return type(n)

func = lambda n : type(n)
res = func(6)
print(res)

def func(n):
print(n)
res = func(6)

print(res)
res = print(6)
print(res)

func = lambda n : print(n)
res = func(13)
print(res)
#(3)帶有條件分支的lambda表達式
三門運算符:
語法:
真值if條件表達式else 假值
如果條件表達式是真的,返回真值
如果條件表達式是假的,返回假值(else 後面跟的值)
#例1:
res = 15 if 5>3 else 6
print(res)
#結果為: 15
#例2:

def func(n):
if n % 2 == 0:
return "偶數"
else:
return "奇數"

n = 15
res = "偶數" if n % 2 == 0 else "奇數"
print(res)

func = lambda n : "偶數" if n % 2 == 0 else "奇數"
res = func(15)
print(res)
#例3:
#把兩個值當中較大的數返回出來
def func(x,y):
if x>y:
return x
else:
return y

func = lambda x,y : x if x>y else y
res = func(3,5)
res = func(3,5)
print(res)

二:叠代器
定義:能夠被next

調用,並不斷返回下一個值得對象,叫叠代器(叠代器時對象)
特征:叠代器會生成惰性序列,它通過計算把值一次的返回,一遍虛幻一遍計算而不是一次性得到所有數據
優點: 需要數據的時候,一次取一個,可以大大節省內存空間,而不是一股腦的把所有數據放進內存
總結:
1.惰性序列,節省內存空間
2.遍歷獲取值的時候使用next,方向不可逆
3.叠代器可以遍歷無線量大的數據
#(1)可叠代對象
‘‘‘__iter__‘‘‘
setvar = {"one",22,"dhqoh",798}
for i in setvar:
print(i)

#print(dir(setvar))
print("__iter__" in dir(setvar))
#next(setvar)
#for 循環遍歷setvar 這個數據時,先把setvar變成叠代器,並進行取值
#(2)叠代器
可叠代對象 -> 叠代器 | 不能直接調用 -> 可直接調用
__iter__ __next__ 都包含在當前數據類型當,就是叠代器
如果變成一個叠代器?
(1)next 可以調用 (推薦)
(2)__next__() 也可以調用
#例:
servar = {"one",13,"aa",56}
it1 = iter(setvar)
print(it1)
res = next(it1)
print(res)
res = next(it1)
print(res)
res = next(it1)
print(res)
res = it1.__next__()
print(‘============================‘)
print(res)
#如果調用時,超出了正常的數據範圍,會報越界錯誤.StopIteration
#res = next(it1)
#print(res)

#判斷是否是叠代器
listvar = dir(it1)
print(listvar)
print("__iter__" in listvar and "__next__" in listvar)

#(3)判斷是否是叠代器或可叠代對象
#from ...import 從哪裏模塊..引入...
#collections (模塊) Iterator 叠代器模型 Iterable 可叠代對象類型
from collections import Iterator,Iterable
setvar = {"one",14,"dd",80}
res = isinstance(setvar,Iterator)
print(res)
res = isinstance(setvar,Iterable)
print(res)

#判斷range對象的叠代屬性
for i in range(9):
print(i)

#res = next(range(9))
res1 = isinstance(range(9),Iterable)
print(res1)
res2 = isinstance(range(9),Iterator)
print(res2)

如果是一個叠代器,一定具備可叠代性屬性
如果是可叠代對象,不一定是叠代器
#把range對象變成叠代器
print("----------------")
#iter __iter__()
it2 = range(9).__iter__()
print(isinstance(it2,Iterator))
print(isinstance(it2,Iterable))

#(4)配合for循環遍歷叠代器
for i in it2:
print(i)

#叠代器在遍歷數據時,要註意方向不可逆
#next(it2) #越界
#重置叠代器
print("==============")

it2 = iter(range(9))
for i in range(3):
res = next(it2)
print(res)

print(next(it2))
print(next(it2))

三:高階函數

定義:能夠把函數當成參數傳遞的就是高階函數(map reduce sorted filter)
1.map()
map(func,iterable)
功能:把iterable裏面的數據一個個的拿出來放到func函數進行處理,最後把處理的結果返回到叠代器中
參數:
func:自定義函數或內置函數
iterable:可叠代性數據(常用:容器類型數據,range對象,叠代器)
返回值:叠代器
#例:
#1.["1","2","3","4"] =>[1,2,3,4]
listvar = ["1","2","3","4"]
lst = []
for i in listvar:
res = int(i)
lst.append(res)
print(lst)
#下面是判斷it是都是可叠代性和是否是叠代器類型數據
from collections import Iterator,Iterable
it = map(int,listvar)
print(isinstance(it,Iterator))
print(isinstance(it,Iterable))
conut = 0
for i in it:
conut += 1
if conut == 2:
break
print(i)
#
#(2)使用next獲取叠代器中的數據
print("=============")
#next 調用叠代器中的數據,是單向不可逆,一條路走到黑
res = next(it)
print(res)
res = next(it)
print(res)
# res = next(it)
# print(res)
# res = next(it)
# print(res)

結果為:

1

2

=============

3

4

#因為叠代器不可逆,所以留兩次給next()調用

#(2)使用next獲取叠代器中的數據
it2 = it
#next 調用叠代器中的數據,是單向不可逆,一條路走到黑
res = next(it)
print(res)
res = next(it)
print(res)
res = next(it)
print(res)
res = next(it)
print(res)

#(3)使用list強轉叠代器(瞬間得到叠代器中的所有數據)
res = list(it)
print(res)

#例2:.[1,2,3,4,5] => [1,4,9,16,25]
listvar = [1,2,3,4,5]
lst = []
for i in listvar:
res = i**2
lst.append(res)
print(lst)

#map 如果是自定義函數,一定要有返回值
代碼解析:
首先把listvar當中的第一個值1拿到func當中進行處理,返回1 扔到叠代器裏
然後把listvar當中的第二個值2拿到func當中進行處理,返回4扔到叠代器裏
然後把listvar當中的第三個值3拿到func當中進行處理,返回9扔到叠代器裏
...
依次類推,直到把列表裏面的數據全部拿完為止.

listvar = [1,2,3,4,5]
def func(n):
return n**2
it = map(func,listvar)
print(isinstance(it,Iterator))
listvar = list(it)
print(listvar)

#例3:.{97:"a",98:"b",99:‘c‘,100:‘d‘,101:"e"} {"c","a","b"} => [99,97,98]
dic = {97:"a",98:"b",99:‘c‘,100:‘d‘,101:"e"}
dic2 = {}
for a,b in dic.items():
dic2[b] = a
print(dic2)
lst = ["c","a","b"]
lst2 = []
#
for i in lst:
res = dic2[i]
lst2.append(res)
print(lst2)

def func(n):
dic = {97:"a",98:"b",99:‘c‘,100:‘d‘,101:"e"}
dic2 = {}
for a,b in dic.items():
dic2[b] = a

return dic2[n]
it = map(func,["c","a","b"])
print(isinstance(it,Iterator))
lst = list(it)
print(lst)

2.reduce()
reduce(func,iterable)
功能:計算
先把iterable中的前兩個數據拿出來,扔到func當中
進行計算,把計算的結果在和iterrable當中的第三個數據扔到func中
進行計算,依次類推... ...
直到iterbale中的數據全部拿出來為止.
參數:
func:內置函數 或者自定義函數
iterable:可叠代性數據(常用:容器類型數據,range對象,叠代器)
返回值:
計算最終的結果

#例1:[5,4,8,8,] => 5488
#方法一:
lst = [5,4,8,8]
strvar = ‘‘
for i in lst:
strvar +=str(i)
print(strvar,type(strvar))
res = int(strvar)
print(res,type(res))

#方法二
‘‘‘

分析:
5*10 + 4 = 54
54*10 + 8 = 548
548*10 + 8 = 5488
‘‘‘
lst = [5,4,8,8]
it = iter(lst) #強轉成叠代器
num1 = next(it)
num2 = next(it)
total = num1 * 10 + num2
print(total)
for i in it:
total = total*10 +i
print(total,type(total))

#法三:
#使用reduce實現
#from ..import 從哪個模塊...導入...
#functools 是一個模塊文件(文件)
from functools import reduce
lst = [5,4,8,8]
def func(x,y):
return x*10 + y
res = reduce(func,lst)
print(res)

‘‘‘

代碼分析:
首先把5,4拿到func函數當中,進行運算得到54
然後把54和lst當中的第三個元素8拿到func當中進行運算得到548
然後把548和list當中的第四個元素8拿到func當中進行運算得到5488
到此,所有數據運算完畢,返回5488
‘‘‘

#例2:"987" => [9,8,7]
#法一:

str = "987"
lst = []
for i in str:
lst.append(int(i))
print(lst)

#法二:
#"987" => [9,8,7]
#不使用int強轉的方法下
print("=============================")
def func3(x,y):
return x*10 + y
def func2(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]

it = map(func2,"987")
#print(list(it))
res = reduce(func3,it)
print(res,type(res))

3.sorted()
參數:
sorted(iterable,reverse=False,key="函數")
reverse = False 從小到大排序(升序,正序)
reverse = Ture 從大到小排序(降序,倒序)
key = 內置函數 或 自定義函數
返回值:
排序後的結果
#(1) 從小到大排序
# listvar = [-99,13,24,0]
# listvar.sort()
# print(listvar)

listvar = [-99,13,24,0]
res = sorted(listvar)
print(res)

#(2)從大到小排序
listvar = [-99,-13,24,0]
res = sorted(listvar,reverse=True)
print(res)

#(3)利用內置函數進行排序
abs 絕對值函數
listvar = [-99,-13,24,0]

res = sorted(listvar,key=abs)
print(res)
‘‘‘
0 => 0
-13 => 13
‘‘‘
#(4) 利用自定義函數進行排序

listvar = [-99,-13,24,0]
def func(n):
return n % 10

listvar = [23,98,44,16]
res = sorted(listvar,key=func)
print(res)

‘‘‘
23 => 3
44 => 4
16 => 6
98 => 8
‘‘‘
sort 和 sorted 用法是一樣的,只是註意語法的格式不同
sort 是直接更改原有列表
sorted 是產生一個新的副本,新的數據(推薦)

listvar = [23,98,44,16]
listvar.sort(key=func)
print(listvar)

4.filter()
filter(func,iterable)
功能:過濾數據
參數:
func 自定義函數(return Ture 保留數據, return False 舍棄數據)
iterable: 可叠代性數據(常用:容器類型數據 range對象 叠代器)
返回值:
叠代器

#保留奇數,不要偶數
def func(n):
if n % 2 == 1:
return True
else:
return False
lst = {1,2,3,4,4,5,6,65,7,8}
it = filter(func,lst)
from collections import Iterator,Iterable
print(isinstance(it,Iterator))
#使用list強轉叠代器(瞬間拿到所有數據)
res = list(it)
print(res)

#通過lambda表達式來優化代碼
it2 = filter(lambda n : True if n % 2 ==1 else False,lst)
print(list(it2))

Python 基礎之匿名函數 叠代器和高階函數