Python自動化開發學習3-2-匿名函數、內置函數
匿名函數
如果函數值使用一次，並且結構結單（需要一行表達式），就可以使用匿名函數。匿名函數的好處：
程序一次行使用，所以不需要定義函數名，節省內存中變量定義空間
讓程序更加簡潔
普通函數：
def test(x,y):
return x+y
print(test(1,2))匿名函數：
test = lambda x,y:x+y print(test(1,2))
lambda：定義一個匿名函數
冒號（:）：分隔符
冒號之前的部分：函數的參數，可以無參數，但是冒號不能省
冒號之後的部分：函數的返回值。lambda沒有return，後面的就是返回值
上面的列子我們還是定了一個變量名，因為方便後面給參數賦值，這樣函數用完後並沒有釋放空間。把整個函數括起來，後面再寫個括號寫入參數。
print((lambda x,y:x+y)(1,2))
最終變成了一行，這就很像函數式編程了。
再舉個求最大值的例子：
f = (lambda x,y:x if x>y else y) print(f(2,3)) print(f(6,4))
但是上面的例子平時根本不用這麽寫。平時不用這麽用，因為一般匿名函數是配合別的函數一起使用的，如reduce、filter。
a = filter(lambda x:x>3,[1,2,3,4,5,6,7,8,9]) # 通過lambda函數來過濾列表中的元素 print(list(a))
嵌套使用
匿名函數可以嵌套在普通函數中，匿名函數本身作為return的返回值。
def func(n):
return lambda x:n**x
f = func(3)
print(f(2),f(3),f(4))內置函數
然後是把所有的內置函數都講了一遍，也不是所有，很多關於對象的類的都先跳過了。
abs()取絕對值
print(abs(3),abs(0),abs(-4))
all()一個可叠代對象如果所有的值都為True則返回True
print(all([0,1,2,3,4,5])) # False print(all([1,2,3,4,5])) # True
any()一個可叠代對象只有其中有一個的值都為True就返回True
print(any([0,1,2,3,4,5])) # True print(any([0,‘‘,False,None])) # False
ascii()把一個對象變成一個可打印的字符串的形式，沒什麽用。
print(type(123),type(ascii(123)),ascii(123)) # int類型通過ascii()變成了str類型
print(ascii("你好")) # 中文字還會轉碼bin()把一個整數轉換成二進制
print(bin(8)) # 0b1000
bool()布爾，判斷True還是False
print(bool(1))
print(bool([]))
print(bool([1,2,3]))
print(bool("你好"))
print(bool(None))bytearray()變成一個bytearray格式
bytes()變成一個bytes格式
a = bytes("abcde",encoding="utf-8")
b = bytearray("abcde",encoding="utf-8")
print(type(a),type(b))
#a[1] = 99 # bytes類型是不可以修改的，str類型也是
b[1] = 99 # 這個可以修改
print(a,b)callable() 判斷一個對象是否可以被調用。函數名後面可以加()，加了()就是調用。是否可以被調用，就是是否可以後面加()
a = []
print(callable(a)) # Fales，列表不能被調用
def b():
pass
print(callable(b)) # True，函數可以被調用
c = ( i for i in range(10) )
print(callable(c.__next__)) # True，生成器c可以用next方法調用下一個元素chr()返回這個整數對應的字符
ord()返回這個字符對應的字符的編碼
print(chr(100))
print(ord("d"))
print(chr(8364)) # 是這個符號
print(chr(7)) # 這個會發出“嘟”的一聲classmethod(function)類方法，以後會講
compile()把代碼進行編譯，大概是這樣。我們用不到，給個了可以執行的演示。
把字符串形式的代碼編譯執行。
# 把你的代碼轉成字符串存在變量裏
code = """
def fib(n):
i,a,b = 0,0,1
while i < n:
#print(b)
yield b
a,b = b,a+b
i += 1
return "結束"
f = fib(10)
while 1:
try:
x = next(f) # x = f.__next__()
print(x)
except StopIteration as e:
print("返回值是：",e.value)
break
"""
#exec(code) # 其實這裏直接exec也是可以執行的
py_obj = compile(code,"","exec") # 編譯你的代碼，第二個參數是文件名存放編譯過程中出錯的信息
exec(py_obj) # 上面是用exec編輯的，這裏用exec執行這個例子並不是很好，把上面的那句註釋掉的語句直接執行也是可以的，不需要經過compile的編譯。但是也沒有別的例子了，總之就是用不到
這裏為啥是exec，什麽是exec，還能不能是別的，暫時不知道。
complex()生成復數
a = complex("1+2j") # 字符串轉為復數
print(type(a),a)
b = complex(1,2) # 兩個參數都是數字，第一個為實部，第二個為虛部
print(type(b),b)delattr()被略過了，以後會講
dict()創建字典，其實可以用來生成很復雜的字典，比如用列表來構造
a = dict() # 創建一個空字典 print(type(a),a)
dir()查看對象有什麽方法
a = {}
print(dir(a))
b = "123"
print(dir(b))
c = 123
print(dir(c))不同的數據類型，能使用的方法是不用的。兩個__下劃線的是內部方法，一般都不能用，也有能用的，比如叠代器的__next__。
divmod(a,b)，a除以b，得到商和余數
print(divmod(9,5)) # (1,4) print(divmod(10,4)) # (2,2)
enumerate()可以為元組或列表等生產索引序列
list1 = [‘a‘,‘b‘,‘c‘,‘d‘,‘e‘]
for i,j in enumerate(list1):
print(i,j)eval()把字符串形式的字典、列表等等，轉換成對應的數據類型
a = "{‘a‘:1,‘b‘:2,‘c‘:3}"
print(type(a),a)
b = eval(a)
print(type(b),b)exec()，可以執行字符串形式的代碼
comm = """
a = [1,2,3,4,5]
for i in a:
print(i)
"""
exec(comm)filter(),根據參數1的函數對參數2進行過濾
map(),根據參數1的函數對參數2進行處理
res1 = filter(lambda n:n>6,range(10))
for i in res1:
print(i)
res2 = map(lambda n:n*2,range(10))
for j in res2:
print(j)frozenset()，創建一個不可變的集合
a = set([1,2,3,4,5]) a.pop() # set可以從中增加或者刪除元素 print(type(a),a) b = frozenset([1,2,3,4,5]) #b.pop() # frozenset無法改變裏面的元素 print(type(b),b)
globals()，返回全局變量的變量名和值，字典的形式。局部變量可以用locals()
print(globals())
getattr()，返回對象屬性值，關於對象還沒講到，以後會講，應該是很重要的內容
hasattr()，判斷對象是否包含這個屬性
setattr()，設置對象屬性值，和上面的getattr相對應。
hash()，獲取一個字符串或數值的哈希值
print(hash(123)) print(hash(‘123‘)) print(hash(‘test‘)) print(hash(str([1,2,3]))) # 列表不可以，需要轉成字符串
help()，查看幫助
help(‘hash‘) # 查看hash函數的幫助 a = [] # a現在是一個列表 help(a) # 查看列表的幫助
hex()，把數字轉成16進制
print(hex(15)) print(hex(1023)) print(hex(-256))
id()，返回內存地址
def a():
pass
print(a) # 這裏直接打印函數的內存地址
print(hex(id(a))) # id默認是10進制，轉成16進制和上面一樣input()，獲取輸入的字符串
a = input("輸入任意字符串：")
print(a)int()，轉成10進制，默認輸入的數據是10進制，或者用第二個參數指定
print(int(‘15‘)) # 默認10進制 print(int(‘10‘,16)) # 16進制的10就是10進制的16 print(int(‘0x10‘,16)) # 即時字符串前有0x，後面的16進制也不能省略 print(int(‘ff‘,16)) print(int(‘0b100‘,2)) print(int(‘100‘,5)) # 還可以有奇怪的進制，5進制 print(int(‘1gg‘,17)) # 17進制
isinstance()，判斷參數1是否是參數2的類型
print(isinstance(1,str)) # False print(isinstance(‘1‘,str)) # True print(isinstance([],(set,dict))) # False，是否是元祖中的其中一個類型 print(isinstance([],(list,dict))) # True
issubclass()，是不是一個子類。啥是類，還沒學
iter()，裝換成叠代器
from collections import Iterator a = [1,2,3,4,5,6] # a是列表 print(isinstance(a,Iterator)) # Fales，現在a還不是一個叠代器 b = iter(a) # 把a變成成叠代器 print(isinstance(b,Iterator)) # True，現在b是一個叠代器了 print(b.__next__()) # 可以用next print(b.__next__()) print(b.__next__())
len()，返回長度
print(len(‘123‘)) print(len([1,2,3]))
list()，可以將元祖轉換成列表。只要是可叠代對象應該都可以
a = (1,2,3) b = list(a) print(type(a),a) print(type(b),b) print(range(10)) print(list(range(10))) # range()也可以轉
locals()，打印當前位置的局部變量，字典的形式，變量名和值
def test():
local_var = 123
print(locals()) # 打印局部變量，只有一個local_var
print(globals()) # 打印的依然是全局變量，沒有當前位置的局部變量
test()
print(locals()) # 這個位置打印的就是全局變量
print(globals()) # 打印的還是全局變量map()，根據提供的函數，對指定的對象做映射
a = map(lambda x:x**2,[1,2,3,4,5]) # 列表中的每個元素都用lambda的方法計算一次 print(list(a))
max()和min()，返回最大值和最小值
print(max(1,2,3)) # 可以是好幾個變量 print(min([1,2,3])) # 也可以是一個列表
memoryview()，返回給定對象的內存查看對象(Momory view)。不懂，也用不到。
next()，通過__next__()調用叠代器的下一項
a = ( (lambda x:x**2)(i) for i in range(2,10) ) # 構造一個叠代器 print(next(a)) # 打印出叠代器中的下一項 print(next(a)) print(next(a))
object，Python裏，一切皆對象。至於這裏有什麽用，不知道
oct()，將整數轉為8進制
print(oct(1)) print(oct(8)) print(oct(9)) print(oct(0xa)) # 這個是16進制的寫法
open()，打開文件。之前用過很多了，略。
ord()，前面chr()一起講了
pow()，求冪。其實可以有3個參數pow(x,y,z)，就是計算(x**y)%z，有z的情況下求余數。
print(pow(2,10,3)) # 2**10除以3的余數 print(pow(2,10)) # 求2的10次冪
print()，略
property()，返回新式類屬性，以後會講。
range()，直接看例子
print(list(range(10))) # 1個參數，從0開始 print(list(range(2,10))) # 2個參數：指定開始和結束 print(list(range(2,10,2))) # 3個參數：再加上步長
repr()，把對象轉為字符串
a = [1,2,3,4,5] b = repr(a) print(type(a),a) # a是列表 print(type(b),b) # b是字符串
reversed()，對對象進行反轉，返回的是一個叠代器
a = (1,2,3,4,5) b = reversed(a) print(next(b)) print(next(b)) print(list(b)) c = [‘a‘,‘b‘,‘c‘,‘d‘,‘e‘] d = reversed(c) print(list(d))
round()，格式化浮點數。第一個參數是數值，第二個參數是小數位數。用字符串格式化的%f應該更方便，但是如果要用參數控制小數位數，應該只能靠round()
print(round(0.1234,2))
num = 0.1234567
for i in range(3,7):
print(round(num,i))set()，創建集合
a = [1,2,3,4,5,2,3] b = set(a) print(type(b),b)
setattr()，設置對象屬性值，和上面的getattr相對應。這個非常重要，以後會講
slice()，切片。一般用[x:y:z]，所以沒用
arr = range(10) print(arr[slice(2,8,2)]) print(arr[2:8:2]) # 和上面效果一樣
sorted()，
a = {‘c‘:5,‘z‘:2,‘a‘:4,‘o‘:9,‘f‘:8}
b = sorted(a.items()) # 按字典的key來排序
c = sorted(a.items(),key=lambda x:x[1]) # 按字典的value排序比較復雜
print(a) # 原來的字典
print(b) # 排序後，但是這裏是列表了，因為字典是無序的
print(c) # 排序後，按照原來字典的value輸出了b=sorted(a.items(),key=lambda x:x[1])這句解釋一下。sorted的第二個參數是指定排序的關鍵字。這裏的key=是sorted函數的關鍵參數(不是字典的key)，就是按lambda x:x[1]的值進行排序。這裏已經把字典的每一個元素變成一個元組了，參考b的輸出。這裏的x[1]就是元組的第二個元素，也就是字典的value值。所以就是按字典的value來進行排序了。
staticmethod()，是一個方法，以後會講。
str()，轉換成字符串。
sum()，求和
super()，非常重要的面向對象裏的繼承的概念，也要以後講了。
tuple()，生成一個元組
type()，查看數據類型
print(type(1))
print(type(‘1‘))
print(type(True))
print(type({}))
print(type([]))
print(type(()))vars()，返回一個對象的所有的屬性名和值，缺省參數就和locals()一樣了。要加上對象才有別的效果。但是：1、對象還沒學；2、還是用不到
class Runoob:
a = 1
def test():
a = 1
print(vars())
print(locals())
print("在函數內部，2個效果一樣")
test()
print("作用於全局，2個效果還是一樣")
print(vars())
print(locals())
print("vars可以帶參數，指定一個class，主要是這個作用")
print(vars(Runoob))zip()，把幾個可叠代對象組合起來
a = [1,2,3,4]
b = [‘a‘,‘b‘,‘c‘,‘d‘]
for i in zip(a,b): # 把兩個可叠代對象組合起來
print(i)
c = [‘A‘,‘B‘,‘C‘,‘D‘,‘E‘]
for i in zip(a,c): # 如果長度不一樣，按短的來
print(i)
for i in zip(a,b,c): # 參數的數量不定
print(i)__import__()，動態加載。一般用import加載模塊就好了。如果一個模塊經常變化就要使用 __import__() 來動態載入。以後可能會用到。暫時知道就行了。
Python自動化開發學習3-2-匿名函數、內置函數