【Python全棧筆記】04 [模塊二] 18 Oct lambda表達式， 內置函數

lambda表達式

lambda表達式是函數的一種簡化，以下面兩種函數定義方法，實際上效果是同樣的。

使用lambda表達式的函數，func2是函數名，lambda: 後面的123 即爲返回值。

 

 1 def func1():
 2     return 123
 3 
 4 result1 = func1()
 5 print(result1)
 6 # 正常定義一個函數 => 123 
 7 
 8 
 9 func2 = lambda: 123
10 result2 = func2()
11 print(result2)
12 # 使用lambda定義函數，效果同上 => 123 

 

lambda表達式也能夠添加本身的參數（放在lambda關鍵字後面），如：

 1 def func1(x, y):
 2     return x + y
 3 
 4 result1 = func1(2, 3)
 5 print(result1)
 6 # func1()求兩數之和 => 5 
 7 
 8 
 9 func2 = lambda i, j: i + j
10 result2 = func2(2, 3)
11 print(result2)
12 # 效果同上 => 5 

lambda 確實簡化了代碼，不過因爲學習內容還不夠多，優點還未能明顯感覺到，找到一個知乎討論帖，加入to read list. 

 

python內置函數

 1 # abs() 取絕對值函數
 2 
 3 print(abs(-19))
 4 # => 19
 5 
 6 # all() 傳入一個可迭代的參數，若是參數裏全部元素爲真，則返回真
 7 # 判斷元素的真假可使用bool(args)來判斷
 8 list0 = [1, 'python', (1), {'key':'value'}]
 9 print(all(list0))
10 # 以上列表裏全部的元素都爲真 因此結果 => True
11 # 出現False的狀況：元素裏含有 0, None, [], (), {} 即 0， None 以及各類空值
12 a = (0,1)
13 b = [2, {}]
14 print(all(a))
15 print(all(b))
16 # 以上a 裏面有0， b 裏面有{}, 兩個結果都爲False
17 
18 # any() 方法和all() 相似，any()的參數列表裏只要有一個元素爲True, 返回結果則爲True
19 a = (0,1)
20 b = [2, {}]
21 c = (0, [])
22 print(any(a))
23 print(any(b))
24 print(any(c))
25 # 以上結果分別爲True, True, False
26 
27 # ascii() 使用ascii()會去對象所在的類裏面找到__repr__() 方法，而後獲取其返回值
28 #
29 list0 = list()
30 result = ascii(list0)
31 print(result)
32 # 結果 => []
33 
34 
35 # bin(), oct(), int(), hex() 二進制，八進制，十進制，十六進制
36 # 參數默認十進制，在數字前加上所要轉換的對應的方法便可獲得相對應進制的值
37 
38 n1 = 12
39 print(bin(n1))  # 0b1100
40 print(oct(n1))  # 0o14
41 print(int(n1))  # 12 十進制固然就不變啦
42 print(hex(n1))  # 0xc
43 
44 # 其餘進制轉爲十進制同理：
45 i1 = int('10101100', base=2)
46 print(i1)  # 172
47 i2 = int('17', base=8)
48 print(i2)  # 15
49 i3 = int('aa', base=16)
50 print(i3)  # 170
51 
52 # bool() 判斷真假，即把一個對象轉換爲bool值
53 print(bool(None))
54 print(bool(0))
55 print(bool([]))
56 # 正如前面所提，上述bool值皆爲False
57 
58 
59 # bytes(), bytearray() bytes是字節，bytearray是字節數組/字節列表，二者的關係相似於字符串和列表
60 # 須要記住的字符串和字節的轉換
61 print(bytes('爬蟲', encoding='utf-8'))
62 # 結果 => b'\xe7\x88\xac\xe8\x99\xab'
63 
64 # chr(), ord()
65 # chr() 接收一個數字，找到數字在ascii碼裏對應的元素
66 # ord() 接收一個ascii碼裏的元素，找到這個元素在ascii碼裏所對應的數字
67 print(chr(56))  # => 8 ascii碼裏56對應數字8
68 print(chr(255))  # => ÿ
69 print(ord('0'))  # => '0' 在ascii表裏對應數字48
70 print(ord('A'))  # => 'A' 在ascii表裏對應65

 

random.randrange() 生成一個隨機數

下面利用random作一個隨機數字/字母驗證碼 

＃在寫這個驗證碼的時候無心將文件名命名爲了random.py 以致於import random 一直報錯。切記切記在命名文件名的時候不要用python關鍵詞 

 1 import random
 2 
 3 
 4 code = ''
 5 
 6 for i in range(0, 6):
 7     number = random.randrange(0, 4)
 8     if number == 1 or number == 2:
 9         dig = random.randrange(0, 10)
10         code += str(dig)
11     else:
12         char = random.randrange(65, 91)
13         code += chr(char)
14 
15 print(code)
16 # 生成一個六位的隨機驗證碼 

 

其餘經常使用python內置函數：

 

 1 # callable() 判斷一個對象是不是可執行的
 2 def f1():
 3     return 123
 4 
 5 
 6 ret = callable(f1)
 7 print(ret)
 8 # 返回True，表示f1是可執行的
 9 f1 = 123
10 ret = callable(f1)
11 print(ret)
12 # 返回False，可見變量f1是不可執行的
13 
14 # complex() 複數
15 
16 # dir()，顯示對象所具備的全部功能 help() 顯示具體類的功能
17 
18 
19 # divmod() 輸入兩個參數，被除數和除數，返回商和餘數
20 r1 = divmod(100, 23)
21 print(r1)
22 r2 = divmod(20, 20)
23 print(r2)
24 # 分別結果爲(4, 8) 和(1, 0)
25 # divmod() 方法在數據分頁中會用到，好比一共有120條博客，每一頁只能顯示25條，那麼就須要5頁來顯示，最後一頁顯示20條博客信息。
26 
27 
28 # eval() exec() eval()能夠將字符串轉換爲表達式，exec()能夠將字符串轉爲代碼來執行
29 # eval() 有返回值，exec() 無返回值
30 a = ' 21 * 2 + 62 * 3'
31 print(a)  # 結果 => 21 * 2 + 62 * 3
32 print(eval(a))  # 結果 => 228
33 # 在有一堆字符串記錄的數字的時候，能夠經過eval()方法來提取數據進行轉換計算，很是方便。
34 a = eval('a + 30', {'a': 20})
35 print(a)
36 # 結果爲50 eval()的參數還能夠帶有參數，參數能夠經過列表來傳入
37 
38 a = exec('print("Hello Python")')
39 a = exec('for i in range(0, 3): print(i)')
40 print(a)
41 # 第一個語句輸出了'Hello Python'
42 # 第二個語句循環出了0, 1, 2
43 # exec() 沒有返回值
44 # compile() 用來編譯， exec() 用來執行
45 
46 
47 # filter() - map()
48 # filter() 輸入兩個參數：1. 函數， 2. 可迭代的對象。所作的事情是循環可迭代的對象，對每一個元素執行函數，留下返回值爲True的元素
49 # map() 對每一個元素進行統一的操做
50 def f1(x):
51     if x > 10:
52         return True
53 result = filter(f1, [2, 12, 3, 41, 21, 9])
54 print(result)  # 結果爲<filter object at 地址> 迭代後建立顯示結果
55 for i in result:
56     print(i)
57 # 結果爲12, 41, 21
58 # 以上用lambda表達式也能夠寫爲：
59 result = filter(lambda x: x > 10, [2, 12, 3, 41, 21, 9])
60 for i in result:
61     print(i)
62 # 結果和上例同樣
63 
64 map_result = map(lambda x: x**2, [1, 3, 5, 7, ])
65 for i in map_result:
66     print(i)
67 # 獲得結果1, 9, 25, 49
68 
69 # format() 字符串格式化
70 # frozenset() 凍結的一個set，不能夠增刪改
71 
72 # globals() 獲取當前代碼裏全部的全局變量
73 # locals() 獲取全部的局部變量
74 ret = globals()
75 ret2 = locals()
76 print(ret)
77 print(ret2)
78 # 獲得結果： {'result': <filter object at 0x0000020E81268588>, '__package__': None, '__doc__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000020E811F7B70>, 'r1': (4, 8), '__file__': 'D:/NaomiPyer/naomi_01/mod8/built_in2.py', '__name__': '__main__', 'ret': {...}, 'ret2': {...}, '__builtins__': <module 'builtins' (built-in)>, 'i': 49, 'f1': <function f1 at 0x0000020E8125F2F0>, '__spec__': None, 'map_result': <map object at 0x0000020E81268518>, 'r2': (1, 0), 'a': None, '__cached__': None}
79 # {'result': <filter object at 0x0000020E81268588>, '__package__': None, '__doc__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000020E811F7B70>, 'r1': (4, 8), '__file__': 'D:/NaomiPyer/naomi_01/mod8/built_in2.py', '__name__': '__main__', 'ret': {...}, 'ret2': {...}, '__builtins__': <module 'builtins' (built-in)>, 'i': 49, 'f1': <function f1 at 0x0000020E8125F2F0>, '__spec__': None, 'map_result': <map object at 0x0000020E81268518>, 'r2': (1, 0), 'a': None, '__cached__': None}

 

 1 # hash() 用在key的保存上，給定一個對象，能夠自動轉一個hash值
 2 print(hash(18.91))
 3 print(hash('a'))
 4 print(hash(0.1342))
 5 # 分別返回了 2098317138384461842, -7491389250214063272, 309444131836477760
 6 
 7 
 8 # iter() 返回一個能夠被迭代的對象
 9 obj = iter([1, 2, 3])
10 print(obj)
11 for i in obj:
12     print(i)
13 # 和range()同樣，返回一個對象，循環裏面每一個元素輸出每一個對象值
14 
15 # max() min() 返回參數裏的最大值/最小值
16 # pow(a, b) 求a的b次方
17 a = pow(2, 10)
18 print(a)  # =>1024
19 
20 # memoryview() 查看對象的內存地址 對象要求是bytes形式
21 a = bytes(123)
22 b = memoryview(a)
23 print(b)
24 # => <memory at 0x0000021DE8D02E88>
25 
26 # repr() 和ascii() 同樣，都是指向__repr__()，找到類的返回值
27 
28 # round() 四捨五入
29 a = 3.14
30 print(round(a))  # => 3
31 
32 # sum() 求和
33 a = [21, 35, 52, 63, 92, -62]
34 b = sum(a)
35 print(b)
36 # => 201
37 
38 # var() 查看一個對象裏有多少的變量
39 # super() 查看父類
40 
41 # reversed(), reverse(), sort(), sorted()
42 list0 = [1, 3, 5, 2, 4]
43 print(reversed(list0))
44 # reversed() 從新生成列表，返回對象位置 => reversed(list0) <list_reverseiterator object at 0x000001489292E358>
45 print(sorted(list0))
46 # 從新生成一個升序列表 => [1, 2, 3, 4, 5]
47 # sort(), sorted() 只能對同類型的數據進行排序
48 
49 list0.reverse()
50 print(list0)
51 # 直接修改原list, 結果 => [5, 4, 3, 2, 1]
52 list0.sort()
53 print(list0)
54 # sort() 也是直接修改list => [1, 2, 3, 4, 5]
55 
56 # zip() 將多個列表的元素一次串起來造成字典
57 a = [1, 2, 3, 4, 5, ]
58 b = ['bananas', 'carrots', 'blueberries', 'milk', 'queso', ]
59 c = ['nestle', 'oreo', 'cheetos', 'lays', 'pepsi', ]
60 d = zip(a, b, c)
61 for i in d:
62     print(i)
63 '''
64 返回結果：
65 (1, 'bananas', 'nestle')
66 (2, 'carrots', 'oreo')
67 (3, 'blueberries', 'cheetos')
68 (4, 'milk', 'lays')
69 (5, 'queso', 'pepsi')
70 '''
71 
72 # 關於排序， sort() 只排同一類型的數據
73 # sort() 比較字符串的時候，順序基本是數字>字母>中文，比較時，先對元素第一個字符進行比較
74 list1 = ['110', 'carrots', '大老虎', 'cap', '__',  '21', '瞎驢', '**', 'south park']
75 list1.sort()
76 print(list1)
77 # => ['**', '110', '21', '__', 'cap', 'carrots', 'south park', '大老虎', '瞎驢']

 

以上爲一些常見的python內置函數。沒有提到的一些後續繼續學習。

 

 # pycharm裏的格式化快捷鍵ctrl + alt + L 或者點code - reformat code  

 

------------補充以前內容------------

 

三元運算 

 

True_block if True else False_block 

以下：比較a, b的大小，若是a >= b, 輸出a, 反之輸出b 

 

>>> a = 4
>>> b = 3
>>> a if a >= b else b
4

判斷一個對象是否由某個類建立，用isinstance()這個方法

1 a = 'asdfewfqwef'
2 r = isinstance(a, str)
3 print(r)
4 # 若是a 是一個str，返回True
5 
6 b = 1323412
7 r = isinstance(b, int)
8 print(r)
9 # 若是b是一個int，返回True

Python 裏面，函數的傳參，傳入的是參數的引用，以下：

1 def func1(args):
2     args = [0]
3     return args
4 
5 li = [1, 2, 3]
6 ret = func1(li)
7 print(ret)  # => [0] 
8 print(li)  # => [1, 2, 3]

li 指向內存裏的[1, 2, 3], 傳入到args裏，args也指向[1, 2, 3], 向下走args指向了[0], 而li依舊是指向[1, 2, 3] 因此結果print(ret)爲args 指向的[0]， print(li) 結果爲li的[1, 2, 3] 

在python裏，值的改變通常分爲1. 改變變量自身的值; 2. 從新建立一個變量賦值 注意區別