python_函數進階（5）
第1章 函數有用信息
1.1 login.__doc__
1.2 login.__name__
第2章 裝飾器的進階
2.1 帶參數的裝飾器
2.2 多個裝飾器裝飾一個函數
2.3 開放封閉原則
第3章 可叠代對象
3.1 判斷對象方法dir（）
3.2 通俗測試方法：
3.3 方法1：‘__iter__‘ in dir(list)
3.4 方法2：isinstance
第4章 叠代器
4.1 定義
4.2 叠代器轉換
4.2.1 判斷方法1
4.2.2 判斷方法2：
4.3 轉換成叠代器的優勢
4.4 模擬for循環
第5章 生成器
5.1 生成器對象
5.2 以函數的方式來構建生成器
6.1 生成表達式特性
6.2 遍歷模式
6.2.1 列表推導式簡單用法
6.2.2 列表推導式應用
6.3 篩選模式
6.4 生成器取值：
6.5 列表表達式轉換生成器表達式
6.5.1 區別：
6.6 練習題
6.7 作業題
第7章 內置函數
7.1 作用域相關
7.1.1 locals***
7.1.2 globals***
7.2 其它相關
7.2.1 eval***
7.2.2 exec***
7.2.3 compile
7.2.4 print
7.2.5 hash
7.2.6 callable**
7.3 數據類型相關
7.3.1 int
7.3.2 complex
7.4 數學運算
7.4.2 sum****
7.4.3 min****
7.5 數據結構相關
7.5.1 reversed
7.5.2 encode
7.5.3 repr
7.5.4 sorted****
7.5.5 enumerate****
7.5.6 any**
7.5.7 zip****
7.5.8 map****
7.5.9 filter
第8章 匿名函數
8.1 練習
第9章 拾遺
9.1 except StopIteration
第1章 函數有用信息
1.1 login.__doc__
解釋：得到有用信息
1.2 login.__name__
解釋：得到函數名
原函數：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
def login(username,password):
‘‘‘
次函數是完成登錄功能的函數，需要兩個參數用戶名和密碼，返回True登錄成功
:return: True
‘‘‘
print(666)
return True
# login(‘w‘,123)
print(login.__doc__) #得到有用信息
print(login.__name__)#得到函數名
輸出
C:\python3\python.exe D:/python/untitled2/python_5/lession.py
次函數是完成登錄功能的函數，需要兩個參數用戶名和密碼，返回True登錄成功
:return: True
例：要求加上裝飾器返回值也正常：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from functools import wraps
def logger(f):
@wraps(f)
def inner(*args,**kwargs):
ret = f(*args,**kwargs)
return ret
return inner
@logger
def login(username,password):
‘‘‘
次函數是完成登錄功能的函數，需要兩個參數用戶名和密碼，返回True登錄成功
:return: True
‘‘‘
print(666)
return True
輸出
print(login.__doc__) #得到有用信息
print(login.__name__)#得到函數名
C:\python3\python.exe D:/python/untitled2/python_5/lession.py
次函數是完成登錄功能的函數，需要兩個參數用戶名和密碼，返回True登錄成功
:return: True
login
第2章 裝飾器的進階
2.1 帶參數的裝飾器
解決批量加糖的方法：
1.將@與函數分開@ timerout(flag),將flag傳進去，返回了timer
2.將@與timer結合
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import time
def timmerout(flag1):
def timer(f):
def inner(*args,**kwargs):
if flag1:
start_time = time.time()
ret = f(*args,**kwargs)
end_time = time.time()
print(‘此函數的執行效率%s‘ % (end_time - start_time))
return ret
else:
ret = f(*args,**kwargs)
return ret
return inner
return timer
flag = True
@timmerout(flag)#1.將@與函數分開@ timmerout(flag) 返回了 timer 2.將@timer結合
def func1():
time.sleep(0.3)
print(‘非常復雜....‘)
return 666
@timmerout(flag)
def func2():
time.sleep(0.2)
print(‘非常復雜....‘)
return 777
@timmerout(flag)
def func3():
time.sleep(0.1)
print(‘非常復雜.....‘)
return 999
func1()
func3()
func2()
輸出：
C:\python3\python.exe D:/python/untitled2/python_5/練習.py
非常復雜....
此函數的執行效率0.3000171184539795
非常復雜.....
此函數的執行效率0.1000056266784668
非常復雜....
此函數的執行效率0.2000114917755127
2.2 多個裝飾器裝飾一個函數
def wrapper1(func):
def inner1():
print(‘wrapper1,before func‘)
func()
print(‘wrapper1,after func‘)
return inner1()
def wrapper2(func):
def inner2():
print(‘wrapper2,before func‘)
func()
print(‘wrapper2,after func‘)
return inner2()
@wrapper2 # f = warpper2(f) 裏面的f 是inner1 外面的f 是inner2。
@wrapper1 # f = warpper(f) 裏面的f函數名 外面的f是inner1.
def f():
print(‘in f‘)
f() #inner(2)
輸出
C:\python3\python.exe D:/python/untitled2/python_5/練習.py
wrapper2,before func
wrapper1,before func
in f
wrapper1,after func
wrapper2,after func
邏輯梳理：函數就近原則先讀，語法糖wrapper1è再讀wrapper2，並存入緩存，沒有輸出，此時當f參數傳入時，wrapper1中的 f = inner1,沒有輸出è繼續執行wrapper2 print（wrapper2,before func）；è執行f() = inner1()è輸出wrapper1,before func è繼續輸出èf() = in f è繼續輸出：wrapper1,after funcè執行inner2輸出èwrapper2,after func
2.3 開放封閉原則
l 對擴展開放
對於裝飾器本身的擴展內容是可添加和更改的
l 對修改是封閉的
對所裝飾的對象是不能進行修改的
第3章 可叠代對象
3.1 判斷對象方法dir（）
定義：該對象中含有__iter__方法就是可叠代對象，遵循可叠代協議。
3.2 通俗測試方法：
凡是用for循環能夠遍歷的都是可叠代的
str、list、tuple、dict、set、range、文件句柄
3.3 方法1：‘__iter__‘ in dir(list)
print(‘__iter__‘ in dir(str))
C:\python3\python.exe D:/python/untitled2/python_5/練習.py
True
3.4 方法2：isinstance
解釋：isinstance 比type的範圍更大
from collections import Iterable
print(isinstance(‘abc‘,Iterable))
輸出
D:/python/untitled2/python_5/練習.py
True
isinstance也可以判斷類型
from collections import Iterable
print(isinstance(‘abc‘,str))
輸出
D:/python/untitled2/python_5/練習.py
True
第4章 叠代器
4.1 定義
解釋：內部含有__iner__且含有__next__方法的對象就是叠代器，遵循叠代器協議。
叠代器可以取值，叠代對象也是轉換成叠代器才取值的
4.2 叠代器轉換
s1 = ‘abc‘
obj_s = s1.__iter__() #可叠代對象傳換成叠代器
obj_s1 =iter(s1) #可叠代對象傳換成叠代器
print(obj_s,obj_s1)
內置方法：
C:\python3\python.exe D:/python/untitled2/python_5/練習.py
<str_iterator object at 0x00000000022282E8> <str_iterator object at 0x00000000022282B0>
4.2.1 判斷方法1
s1 = ‘abc‘
print(‘__iter__‘ in dir(s1))
print(‘——next‘ in dir(s1))
輸出
C:\python3\python.exe D:/python/untitled2/python_5/練習.py
True
False
4.2.2 判斷方法2：
from collections import Iterator
l1 = [1,2,3]
print(isinstance(l1,Iterator))
l1_obj = l1.__iter__()
print(isinstance(l1_obj,Iterator))
輸出
C:\python3\python.exe D:/python/untitled2/python_5/練習.py
False
True
4.3 轉換成叠代器的優勢
l 節省內存，只占一條的數據
l 惰性機制
l 單向執行，不可逆
4.4 模擬for循環
for循環其實就是叠代器原理，我們之前在講循環對象的時候，曾提到一個StopIteration的異常，該異常是在循環對象窮盡所有元素時的報錯。
s1 = ‘fkdsafhdskfhsdklfjdslfksd‘
s1_obj = s1.__iter__()
while True:
try:
print(s1_obj.__next__())
except StopIteration:
break
輸出：
C:\python3\python.exe D:/python/untitled2/python_5/練習.py
f
k
d
s
a
f
……..
第5章 生成器
定義：生成器的本質就是叠代器，他是自定義的叠代器（用python代碼手寫一個叠代器叫做生成器）
凡是在函數中見到yield 就是生成器
例：
def func1():
print(111)
yield 666
ret = func1()
print(ret)
輸出
C:\python3\python.exe D:/python/untitled2/python_5/練習.py
<generator object func1 at 0x0000000001E8E4C0>
5.1 生成器對象
解釋:上述案例中
ret = func1() 為生成對象
print(ret)#凡事函數中見到yield 就是生成器
例：
def func1():
yield 999
print(222)
print(333)
yield ‘wang‘
print(888)
g_obj = func1()
#__next__()和yield 必須一一對應
print(g_obj.__next__())
print(g_obj.__next__())
輸出
C:\python3\python.exe D:/python/untitled2/python_5/練習.py
999
222
333
wang
5.2 以函數的方式來構建生成器
def cloth():
for i in range(1,5001):
print(‘衣服%s‘ %i)
cloth()
一次性生成
def cloth1():
for i in range(1,5001):
yield ‘衣服%s‘ %i
g_obj = cloth1() # 生成器對象
分批次生成，並且號碼相連
for i in range(50):
print(g_obj.__next__())
for i in range(150):
print(g_obj.__next__())
第6章 生成器表達式
6.1 生成表達式特性
u 生成表達式又稱：列表推導式
u 列表推導式：簡單，一行能搞定
u 特別復雜的數據列表推導式無法實現，只能用其他方式實現
u 列表推導式不能排錯
6.2 遍歷模式
[變量 （加工後的變量） for 變量 in iterable ] 遍歷模式
例：遍歷模式
l1 = []
for i in range(1,23):
l1.append(‘python%s期‘ % i)
print(l1)
輸出
C:\python3\python.exe D:/python/untitled2/python_5/練習.py
[‘python1期‘, ‘python2期‘, ‘python3期‘, ‘python4期‘, ‘python5期‘, ‘python6期‘, ‘python7期‘, ‘python8期‘, ‘python9期‘, ‘python10期‘, ‘python11期‘, ‘python12期‘, ‘python13期‘, ‘python14期‘, ‘python15期‘, ‘python16期‘, ‘python17期‘, ‘python18期‘, ‘python19期‘, ‘python20期‘, ‘python21期‘, ‘python22期‘]
6.2.1 列表推導式簡單用法
l = [i for i in range(1,11)]
print(l)
輸出
D:/python/untitled2/python_5/練習.py
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
6.2.2 列表推導式應用
l2 = [‘python%s期‘ %i for i in range(1,23)]
print(l2)
輸出
C:\python3\python.exe D:/python/untitled2/python_5/練習.py
[‘python1期‘, ‘python2期‘, ‘python3期‘, ‘python4期‘, ‘python5期‘, ‘python6期‘, ‘python7期‘, ‘python8期‘, ‘python9期‘, ‘python10期‘, ‘python11期‘, ‘python12期‘, ‘
6.3 篩選模式
[變量 （加工後的變量） for 變量 in iterable if 條件]刪選模式
l1 = []
for i in range(1,31):
if i % 3 == 0:
l1.append(i)
print(l1)
l2 = [i for i in range(1,31) if i % 3 == 0]
print(l2)
列表聲稱式 生成器表達式
6.4 生成器取值：
u send 和next 都是對生成器取值。
u send 會給上一個yield 發送一個值。
u send 不能用在第一次取值。
u 最後一個yield 不能得到值
例1：yield
def func1():
count = yield 666
print(count)
yield ‘alex‘
yield ‘abc‘
g_obj = func1() # 生成器對象
print(g_obj.__next__())
print(g_obj.__next__())
解釋：
# send 和next 都是對生成器取值。
# send 會給上一個yield 發送一個值。
# send 不能用在第一次取值。
# 最後一個yield 不能得到值
例2：send
def func1():
count = yield 666
print(count)
yield ‘afr‘
yield ‘abc‘
g_obj = func1() # 生成器對象
# print(g_obj.__next__())
# print(g_obj.__next__())
print(g_obj.__next__())
print(g_obj.send(‘taibai‘))
# print(g_obj.send(‘taibai‘))
print(g_obj.__next__())
輸出
C:\python3\python.exe D:/python/untitled2/python_5/lession.py
666
taibai
afr
abc
6.5 列表表達式轉換生成器表達式
6.5.1 區別：
u 列推直觀能看出，但是占內存
u 生成器表達式不易看出，但是節省內存
例：
l2_obj = (i for i in range(1,31) if i % 3 == 0 )
print(l2_obj)
輸出
C:\python3\python.exe D:/python/untitled2/python_5/lession.py
<generator object <genexpr> at 0x00000000021CC0A0>
6.6 練習題
1） 構建列表： 十以內的所有的元素的平方。
l1 = [i**2 for i in range(1,10)]
print(l1)
2） 30以內所有能被3整除的數的平方
l1 = [i**2 for i in range(1,31) if i % 3 == 0]
print(l1)
3）[3,6,9] 組成的列表M = [[1,2,3],[4,5,6],[7,8,9]]
l1 =[[i-2,i-1,i] for i in [3,6,9]]
print(l1)
4）
names = [[‘Tom‘, ‘Billy‘, ‘Jefferson‘, ‘Andrew‘, ‘Wesley‘, ‘Steven‘, ‘Joe‘],
[‘Alice‘, ‘Jill‘, ‘Ana‘, ‘Wendy‘, ‘Jennifer‘, ‘Sherry‘, ‘Eva‘]]
找出名字中含有兩個e的名字
l1 =[i for l in names for i in l if i.count(‘e‘) == 2 ]
print(l1)
6）
# l = [‘您好‘, ‘3.64‘,
# ‘請問您是劉曉宇同學的家長嗎‘, ‘6.25‘,
# ‘是的有什麽事情嗎‘, ‘6.15‘,
# ‘您好我是學大教育的劉老師‘, ‘5.06‘,
# ‘這次給給您打電話主要是想了解一下孩子上學期的協議情況‘, ‘5.86‘,
# ‘針對於上學期的學習狀況‘, ‘5.37‘,
# ‘我們學校邀請您和孩子周末過來聽一下針對性的輔導課好吧好吧‘, ‘5.36‘,
# ‘可以我想問一下都有什麽課程呢‘, ‘5.65‘,
# ‘呃主要是有英語和語文‘, ‘4.35‘,
# ‘你看‘, ‘3.77‘,
# ‘到時候咱們再聯系好吧‘, ‘6.10‘,
# ‘好的‘, ‘6.45‘,
# ‘恩再見‘, ‘4.84‘]
# 上面這個列表幫我轉成下面這種格式
# [{"onebest":"您好", "speed":"6.060606"},
# {"onebest":"我這是中國電信的客戶代表請問您是幺五幺幺零幺五六六六幺號碼的長期使用者嗎", "speed":"5.479452"},
# {"onebest":"是的", "speed":"5.405406"},
# {"onebest":"為啥謝謝您長期以來的支持", "speed":"5.529954"},
# {"onebest":"交銀退掉", "speed":"4.938272"},
# {"onebest":"考慮了解生活小貼士服務美元四月","speed":"4.672897"},
# {"onebest":"你們可以收到天氣情況活動", "speed":"5.529954"},
# {"onebest":"我建議", "speed":"4.347826"},
# {"onebest":"生活中了就是周轉現在開通後","speed":"4.024768"},
# {"onebest":"發到您的", "speed":"8.510638"},
# {"onebest":"都會","speed":"4.255319"},
# {"onebest":"現在","speed":"6.451613"},
# {"onebest":"可以享有就是看嗎", "speed":"5.161290"},
# {"onebest":"可以","speed":"6.451613"},
# {"onebest":"改天先生那是的", "speed":"4.046243"},
# {"onebest":"另外再見", "speed":"5.479452"}
# ]
方法：
print([{‘onebest‘:l[i],‘speed‘:l[i+1]} for i in range(len(l)) if i % 2 == 0])
輸出
C:\python3\python.exe D:/python/untitled2/python_5/lession.py
[{‘onebest‘: ‘您好‘, ‘speed‘: ‘3.64‘}, {‘onebest‘: ‘請問您是劉曉宇同學的家長嗎‘, ‘speed‘: ‘6.25‘}, {‘onebest‘: ‘是的有什麽事情嗎‘, ‘speed‘: ‘6.15‘}, {‘onebest‘: ‘您好我是學大教育的劉老師‘, ‘speed‘: ‘5.06‘}, {‘onebest‘: ‘這次給給您打電話主要是想了解一下孩子上學期的協議情況‘, ‘speed‘: ‘5.86‘}, {‘onebest‘: ‘針對於上學期的學習狀況‘, ‘speed‘: ‘5.37‘}, {‘onebest‘: ‘我們學校邀請您和孩子周末過來聽一下針對性的輔導課好吧好吧‘, ‘speed‘: ‘5.36‘}, {‘onebest‘: ‘可以我想問一下都有什麽課程呢‘, ‘speed‘: ‘5.65‘}, {‘onebest‘: ‘呃主要是有英語和語文‘, ‘speed‘: ‘4.35‘}, {‘onebest‘: ‘你看‘, ‘speed‘: ‘3.77‘}, {‘onebest‘: ‘到時候咱們再聯系好吧‘, ‘speed‘: ‘6.10‘}, {‘onebest‘: ‘好的‘, ‘speed‘: ‘6.45‘}, {‘onebest‘: ‘恩再見‘, ‘speed‘: ‘4.84‘}]
6.7 作業題
x = {
‘name‘:‘alex‘,
‘Values‘:[{‘timestamp‘:1517991992.94,
‘values‘:100,},
{‘timestamp‘: 1517992000.94,
‘values‘: 200,},
{‘timestamp‘: 1517992014.94,
‘values‘: 300,},
{‘timestamp‘: 1517992744.94,
‘values‘: 350},
{‘timestamp‘: 1517992800.94,
‘values‘: 280}
],}
# 將上面的數據通過列表推導式轉換成下面的類型：
# [[1517991992.94, 100], [1517992000.94, 200], [1517992014.94, 300], [1517992744.94, 350], [1517992800.94, 280]]
解答：
l2 = [[i[‘timestamp‘],i[‘values‘]] for i in x[‘Values‘] ]
第7章 內置函數
|
7.1 作用域相關
7.1.1 locals***
函數會以字典的類型返回當前位置的全部局部變量
7.1.2 globals***
函數以字典的類型返回全部全局變量
例：
a = 1
b = 2
print(locals())
print(globals())
# 這兩個一樣，因為是在全局執行的。
##########################
def func(argv):
c = 2
print(locals())
print(globals())
func(3)
#這兩個不一樣，locals() {‘argv‘: 3, ‘c‘: 2}
#globals() {‘__doc__‘: None, ‘__builtins__‘: <module ‘builtins‘ (built-in)>, ‘__cached__‘: None, ‘__loader__‘: <_frozen_importlib_external.SourceFileLoader object at 0x0000024409148978>, ‘__spec__‘: None, ‘__file__‘: ‘D:/lnh.python/.../內置函數.py‘, ‘func‘: <function func at 0x0000024408CF90D0>, ‘__name__‘: ‘__main__‘, ‘__package__‘: None}
7.2 其它相關
7.2.1 eval***
解釋：執行字符串類型的代碼，並返回最終結果
eval(‘2 + 2‘) # 4
n=81
eval("n + 4") # 85
eval(‘print(666)‘) # 666
7.2.2 exec***
解釋:執行字符串類型的代碼
例：
s = ‘‘‘
for i in [1,2,3]:
print(i)
‘‘‘
exec(s)
輸出
C:\python3\python.exe D:/python/untitled2/python_5/lession.py
1
2
3
7.2.3 compile
解釋：將字符串類型的代碼編譯。代碼對象能夠通過exec語句來執行或者eval()進行求值
參數說明：
u 參數source：字符串或者AST（Abstract Syntax Trees）對象。即需要動態執行的代碼段。
u 參數 filename：代碼文件名稱，如果不是從文件讀取代碼則傳遞一些可辨認的值。當傳入了source參數時，filename參數傳入空字符即可。
u 參數model：指定編譯代碼的種類，可以指定為 ‘exec’,’eval’,’single’。當source中包含流程語句時，model應指定為‘exec’；當source中只包含一個簡單的求值表達式，model應指定為‘eval’；當source中包含了交互式命令語句，model應指定為‘single‘。
‘‘‘
>>> #流程語句使用exec
>>> code1 = ‘for i in range(0,10): print (i)‘
>>> compile1 = compile(code1,‘‘,‘exec‘)
>>> exec (compile1)
>>> #簡單求值表達式用eval
>>> code2 = ‘1 + 2 + 3 + 4‘
>>> compile2 = compile(code2,‘‘,‘eval‘)
>>> eval(compile2)
>>> #交互語句用single
>>> code3 = ‘name = input("please input your name:")‘
>>> compile3 = compile(code3,‘‘,‘single‘)
>>> name #執行前name變量不存在
Traceback (most recent call last):
File "<pyshell#29>", line 1, in <module>
name
NameError: name ‘name‘ is not defined
>>> exec(compile3) #執行時顯示交互命令，提示輸入
please input your name:‘pythoner‘
>>> name #執行後name變量有值
"‘pythoner‘"
註釋：有返回值的字符串形式的代碼用eval，沒有返回值的字符串形式的代碼用exec，一般不用compile
7.2.4 print
input:函數接受一個標準輸入數據，返回為 string 類型。print:打印輸出。
print(111,222,333,sep=‘*‘) # 111*222*333
print(111,end=‘‘)
print(222) #兩行的結果 111222
f = open(‘log‘,‘w‘,encoding=‘utf-8‘)
print(‘寫入文件‘,file=f,flush=True)
7.2.5 hash
獲取一個對象（可哈希對象：int，str，Bool，tuple）的哈希值
print(hash(12322))
print(hash(‘123‘))
print(hash(‘arg‘))
print(hash(‘alex‘))
print(hash(True))
print(hash(False))
print(hash((1,2,3)))
輸出
12322
-2996001552409009098
-4637515981888139739
2311495795356652852
1
0
2528502973977326415
‘‘‘
將不可變元素定義一個值，除了int和bool
7.2.6 callable**
解釋：函數用於檢查一個對象是否是可調用的。如果返回True，object仍然可能調用失敗；但如果返回False，調用對象ojbect絕對不會成功
>>>callable(0)
False
>>> callable("runoob")
False
>>> def add(a, b):
... return a + b
...
>>> callable(add) # 函數返回 True
True
>>> class A: # 類
... def method(self):
... return 0
...
>>> callable(A) # 類返回 True
True
>>> a = A()
>>> callable(a) # 沒有實現 __call__, 返回 False
False
>>> class B:
... def __call__(self):
... return 0
...
>>> callable(B)
True
>>> b = B()
>>> callable(b) # 實現 __call__, 返回 True
7.3 數據類型相關
u bool ：用於將給定參數轉換為布爾類型，如果沒有參數，返回 False。
u int：函數用於將一個字符串或數字轉換為整型。
u float：函數用於將整數和字符串轉換成浮點數
u complex：函數用於創建一個值為 real + imag * j 的復數或者轉化一個字符串或數為復數。如果第一個參數為字符串，則不需要指定第二個參數。
7.3.1 int
print(int()) # 0
print(int(‘12‘)) # 12
print(int(3.6)) # 3
print(int(‘0100‘,base=2)) # 將2進制的 0100 轉化成十進制。結果為 4
7.3.2 complex
>>>complex(1, 2)
(1 + 2j)
>>> complex(1) # 數字
(1 + 0j)
>>> complex("1") # 當做字符串處理
(1 + 0j)
# 註意：這個地方在"+"號兩邊不能有空格，也就是不能寫成"1 + 2j"，應該是"1+2j"，否則會報錯
>>> complex("1+2j")
(1 + 2j)
7.4 數學運算
u abs：函數返回數字的絕對值。
u divmod：計算除數與被除數的結果，返回一個包含商和余數的元組(a // b, a % b)。
u round：保留浮點數的小數位數，默認保留整數。
u pow：求x**y次冪。（三個參數為x**y的結果對z取余）
u sum：對可叠代對象進行求和計算（可設置初始值）。
u min：返回可叠代對象的最小值（可加key，key為函數名，通過函數的規則，返回最小值）。
u max：返回可叠代對象的最大值（可加key，key為函數名，通過函數的規則，返回最大值）。
7.4.1 divmod
print(abs(-5)) # 5
print(divmod(7,2)) # (3, 1)
print(round(7/3,2)) # 2.33
print(round(7/3)) # 2
print(round(3.32567,3)) # 3.326
print(pow(2,3)) # 兩個參數為2**3次冪
print(pow(2,3,3)) # 三個參數為2**3次冪，對3取余。
7.4.2 sum****
print(sum([1,2,3]))
print(sum((1,2,3),100))
print(max([1,2,3])) # 返回此序列最大值
ret = max([1,2,-5,],key=abs) # 按照絕對值的大小，返回此序列最大值
print(ret)
dic = {‘a‘:3,‘b‘:2,‘c‘:1}
print(max(dic,key=lambda x:dic[x]))
# x為dic的key，lambda的返回值（即dic的值進行比較）返回最大的值對應的鍵
7.4.3 min****
print(min([1,2,3])) # 返回此序列最小值
ret = min([1,2,-5,],key=abs) # 按照絕對值的大小，返回此序列最小值
print(ret)
dic = {‘a‘:3,‘b‘:2,‘c‘:1}
print(min(dic,key=lambda x:dic[x]))
# x為dic的key，lambda的返回值（即dic的值進行比較）返回最小的值對應的鍵
7.5 數據結構相關
列表和元祖（2）
u list：將一個可叠代對象轉化成列表（如果是字典，默認將key作為列表的元素）。
u tuple：將一個可叠代對象轉化成元祖（如果是字典，默認將key作為元祖的元
相關內置函數（2）
u reversed：將一個序列翻轉，並返回此翻轉序列的叠代器。
u slice：構造一個切片對象，用於列表的切片。
字符串相關（9）
u str：將數據轉化成字符串。
u format:與具體數據相關，用於計算各種小數，精算等。
u bytes：用於不同編碼之間的轉化
u bytearry：返回一個新字節數組。這個數組裏的元素是可變的，並且每個元素的值範圍: 0 <= x < 256
u ord:輸入字符找該字符編碼的位置
u chr:輸入位置數字找出其對應的字符
u ascii:是ascii碼中的返回該值，不是就返回/u...
u repr:返回一個對象的string形式（原形畢露）
數據集合
u dict：創建一個字典。
u set：創建一個集合。
u frozenset：返回一個凍結的集合，凍結後集合不能再添加或刪除任何元素。
相關內置函數
u len:返回一個對象中元素的個數。
u sorted：對所有可叠代的對象進行排序操作。
7.5.1 reversed
建列表生成一個翻轉後的叠代器
ite = reversed([‘a‘,2,3,‘c‘,4,2])
for i in ite:
print(i)
li = [‘a‘,‘b‘,‘c‘,‘d‘,‘e‘,‘f‘,‘g‘]
sli_obj = slice(3)
print(li[sli_obj])
sli_obj = slice(0,7,2)
print(li[sli_obj]
7.5.2 encode
s = ‘完‘
b1 = s.encode(‘utf-8‘)
print(b1)
輸出
b‘\xe5\xae\x8c‘
7.5.3 repr
解釋：返回一個對象的string形式（原形畢露）
# %r 原封不動的寫出來
# name = ‘taibai‘
# print(‘我叫%r‘%name)
# repr 原形畢露
print(repr(‘{"name":"alex"}‘))
print(‘{"name":"alex"}‘)
7.5.4 sorted****
解釋：對所有可叠代的對象進行排序操作
L = [(‘a‘, 1), (‘c‘, 3), (‘d‘, 4),(‘b‘, 2), ]
sorted(L, key=lambda x:x[1]) # 利用key
[(‘a‘, 1), (‘b‘, 2), (‘c‘, 3), (‘d‘, 4)]
students = [(‘john‘, ‘A‘, 15), (‘jane‘, ‘B‘, 12), (‘dave‘, ‘B‘, 10)]
sorted(students, key=lambda s: s[2]) # 按年齡排序
[(‘dave‘, ‘B‘, 10), (‘jane‘, ‘B‘, 12), (‘john‘, ‘A‘, 15)]
sorted(students, key=lambda s: s[2], reverse=True) # 按降序
[(‘john‘, ‘A‘, 15), (‘jane‘, ‘B‘, 12), (‘dave‘, ‘B‘, 10)]
7.5.5 enumerate****
解釋：返回一個枚舉對象
l1 = [‘wang‘,‘li‘,‘zhao‘]
for index,count in enumerate(l1):
print(index,count)
輸出
0 wang
1 li
2 zhao
7.5.6 any**
# all 可叠代對象中，全都是True才是True
# any 可叠代對象中，有一個True 就是True
# print(all([1,2,True,0]))
# print(any([1,‘‘,0]))
7.5.7 zip****
解釋：函數用於將可叠代的對象作為參數，將對象中對應的元素打包成一個個元組，然後返回由這些元組組成的列表。如果各個叠代器的元素個數不一致，則返回列表長度與最短的對象相同。
l1 = [1,2,3,]
l2 = [‘a‘,‘b‘,‘c‘,5]
l3 = (‘*‘,‘**‘,(1,2,3))
for i in zip(l1,l2,l3):
print(i)
輸出
l1 = [1,2,3,]
l2 = [‘a‘,‘b‘,‘c‘,5]
l3 = (‘*‘,‘**‘,(1,2,3))
for i in zip(l1,l2,l3):
print(i)
7.5.8 map****
解釋：會根據提供的函數對指定序列做映射
>>>def square(x) : # 計算平方數
... return x ** 2
...
>>> map(square, [1,2,3,4,5]) # 計算列表各個元素的平方
[1, 4, 9, 16, 25]
>>> map(lambda x: x ** 2, [1, 2, 3, 4, 5]) # 使用 lambda 匿名函數
[1, 4, 9, 16, 25]
# 提供了兩個列表，對相同位置的列表數據進行相加
>>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
[3, 7, 11, 15, 19]
7.5.9 filter
#filter 過濾 通過你的函數，過濾一個可叠代對象，返回的是True
#類似於[i for i in range(10) if i > 3]
# def func(x):return x%2 == 0
# ret = filter(func,[1,2,3,4,5,6,7])
# print(ret)
# for i in ret:
# print(i)
第8章 匿名函數
定義：將一些簡單的函數用一行來體現
u 參數可以多個，用逗號隔開
u 匿名函數不管邏輯多復雜，只能寫一行，且邏輯執行的結束後的內容就是返回值
u 返回值和正常的函數一樣可以是任意數據類型
格式：
calc (函數名) = lambda（定義匿名函數關鍵字和def類似） n（參數） n**n（返回值）
print(calc(10))
例：
def func2(x,y):
return x + y
func1 = lambda x,y: x + y
print(func1(3,4))
例2：
res = map(lambda x: x**2,[1,5,7,4,8])
for i in res:
print(i)
輸出
C:\python3\python.exe D:/python/untitled2/python_5/lession.py
1
25
49
16
64
8.1 練習
l1 = [ {‘sales_volumn‘: 0},
{‘sales_volumn‘: 108},
{‘sales_volumn‘: 337},
{‘sales_volumn‘: 475},
{‘sales_volumn‘: 396},
{‘sales_volumn‘: 172},
{‘sales_volumn‘: 9},
{‘sales_volumn‘: 58},
{‘sales_volumn‘: 272},
{‘sales_volumn‘: 456},
{‘sales_volumn‘: 440},
{‘sales_volumn‘: 239}]
按照數字升序排序
print(sorted(l1,key = lambda x:x[‘sales_volumn‘]))
輸出
C:\python3\python.exe D:/python/untitled2/python_5/lession.py
[{‘sales_volumn‘: 0}, {‘sales_volumn‘: 9}, {‘sales_volumn‘: 58}, {‘sales_volumn‘: 108}, {‘sales_volumn‘: 172}, {‘sales_volumn‘: 239}, {‘sales_volumn‘: 272}, {‘sales_volumn‘: 337}, {‘sales_volumn‘: 396}, {‘sales_volumn‘: 440}, {‘sales_volumn‘: 456}, {‘sales_volumn‘: 475}]
第9章 拾遺
9.1 except StopIteration
for循環其實就是叠代器原理，我們之前在講循環對象的時候，曾提到一個StopIteration的異常，該異常是在循環對象窮盡所有元素時的報錯。
s1 = ‘fkdsafhdskfhsdklfjdslfksd‘
s1_obj = s1.__iter__()
while True:
try:
print(s1_obj.__next__())
except StopIteration:
break
輸出：
C:\python3\python.exe D:/python/untitled2/python_5/練習.py
f
k
d
s
a
f
python_函數進階（5）