Python Day 14 函數（內置函數，匿名函數（lambda表達式））

Python Day 14 函數（內置函數，匿名函數（lambda表達式））

　　內置函數

　　　　截止到python版本3.6.2，如今python一共爲咱們提供了68個內置函數。它們就是python提供給你直接能夠拿來使用的全部函數。

		內置函數
abs()	dict()	help()	min()	setattr()
all()	dir()	hex()	next()	slice()
any()	divmod()	id()	object()	sorted()
ascii()	enumerate()	input()	oct()	staticmethod()
bin()	eval()	int()	open()	str()
bool()	exec()	isinstance()	ord()	sum()
bytearray()	filter()	issubclass()	pow()	super()
bytes()	float()	iter()	print()	tuple()
callable()	format()	len()	property()	type()
chr()	frozenset()	list()	range()	vars()
classmethod()	getattr()	locals()	repr()	zip()
compile()	globals()	map()	reversed()	__import__()
complex()	hasattr()	max()	round()
delattr()	hash()	memoryview()	set()

 

　　1.1 做用域相關

　　　　　　** locals()：函數會以字典的類型返回當前位置的所有局部變量。

　　　　　　** globals()：函數以字典的類型返回所有全局變量。

　　1.2 其餘相關

　　　　1.2.1 執行相關

　　　　　　*** eval() 去除字符串的引號，返回對應內部的值。

s = '{"a":1,"b":3}'
dic = eval(s)
print(dic,type(dic))
print(eval('2 + 2'))
print(eval('print(666)'))

==============
{'a': 1, 'b': 3} <class 'dict'>
4
666
None

　　　　　　*** exec() 執行字符串內部的代碼。

print(exec('1 + 1'))   
==============
None #exec 沒有返回值，主要用於直接打印結果，或交互型。

ret = '''
name = input('請輸入名字：').strip()
if name == 'alex':
    print(666)
'''
exec(ret)

　　　　　　compile() 將字符串類型的代碼編譯。代碼對象可以經過exec語句來執行或者eval()進行求值。

'''
參數說明：　　　

1. 參數source：字符串或者AST（Abstract Syntax Trees）對象。即須要動態執行的代碼段。　　

2. 參數 filename：代碼文件名稱，若是不是從文件讀取代碼則傳遞一些可辨認的值。當傳入了source參數時，filename參數傳入空字符便可。　　

3. 參數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'"

　　

　　　　1.2.2 輸入輸出相關

　　　　　　input()　交互輸入信息，數據類型爲字符串。

　　　　　　print()　打印信息。

　　　　1.2.3 內存相關

　　　　　　* hash() 將不可變的數據經過hash算法轉化成hash值,數字類型hash值是數字自己，其餘類型hash值不固定。

print(hash('name'))
print(hash('age'))
print(hash((1, 2, 3,)))

　　　　　　id()

　　　　1.2.4 文件操做相關

　　　　　　***（open() 函數用於打開一個文件，建立一個file對象，相關的方法才能夠調用它進行讀寫。

　　　　1.2.5 模塊相關

　　　　　　__import__: 函數用於動態加載類和函數

　　　　1.2.6 幫助

　　　　　　* help() 函數用於查看函數或模塊用途的詳細說明。

　　　　1.2.7 調用相關

　　　　　　*** callable() 函數用於檢查一個對象是不是可調用的。若是返回True，object仍然可能調用失敗；但若是返回False，調用對象ojbect絕對不會成功。

def func1():
    print(666)
age = 16  
print(callable('name')) #字符串不是可調用的對象
print(callable(age)) #變量名不是可調用的對象
print(callable(func1)) #True

　　　　1.2.8 查看內置屬性

　　　　　　** dir()  函數不帶參數時，返回當前範圍內的變量、方法和定義的類型列表；帶參數時，返回參數的屬性、方法列表。若是參數包含方法__dir__()，該方法將被調用。若是參數不包含__dir__()，該方法將最大限度地收集參數信息。

print(dir(str))

　　1.3 迭代器生成器相關

　　　　*** range()

print(len(range(100)))

　　　　*** iter()

l = [1, 2, 3, 4, 5]

l_obj = l.__iter__()   

l_obj = iter(l)

效果一致 iter()調用__iter__()

　　　　*** next()

print(l_obj.__next__())

print(next(l_obj))

　　1.4 數字相關

　　　　1.4.1 數據類型

　　　　　　bool() 用於將給定參數轉換爲布爾類型，若是沒有參數，返回 False。

　　　　　　int() 函數用於將一個字符串或數字轉換爲整型,不能將內部爲浮點數的字符串轉換爲整數。

　　　　　　float()：函數用於將整數和字符串轉換成浮點數。

　　　　　　complex：函數用於建立一個值爲 real + imag * j 的複數或者轉化一個字符串或數爲複數，若是第一個參數爲字符串，則不須要指定第二個參數。

　　　　1.4.2 進制轉換

　　　　　　　bin：將十進制轉換成二進制並返回。

print(bin(100))
0b1100100

　　　　　　　oct：將十進制轉化成八進制字符串並返回。

print(oct(10))
0o12

　　　　　　　hex：將十進制轉化成十六進制字符串並返回。

print(hex(13))
0xd

　　　　1.4.3 數學運算

　　　　　　　*** abs() 函數返回數字的絕對值。

print(abs(-5))
5

　　　　　　　*** divmod()  計算除數與被除數的結果，返回一個包含商和餘數的元組(a // b, a % b)。

print(divmod(7, 3))

(2, 1)

　　　　　　　** round()  保留浮點數的小數位數，默認保留整數。

print(round(1.234,2))
1.23

　　　　　　　*pow()：求x**y次冪。（三個參數爲x**y的結果對z取餘）

print(pow(2, 3)) # 2的三次冪     8
print(pow(2, 3, 3))  # 2的三次冪對3取餘數   2

　　　　　　　***sum()：對可迭代對象進行求和計算（可設置初始值）。

print(sum([1, 2, 3, 4]))   #10

print(sum([1, 2, 3, 4], 100)) #110

　　　　　　*** min()：返回可迭代對象的最小值（可加key，key爲函數名，經過函數的規則，返回最小值）。

print(min([1, 3, 5, 7, -4]))  # -4 
print(min([1, 3, 5, 7, -4], key=abs))  # 1

　　　　　　*** max(): 返回可迭代對象的最大值（可加key，key爲函數名，經過函數的規則，返回最大值）。

print(max([1, 3, 5, 7, -4]))  #7
print(max([1, 3, 5, 7, -9], key=abs)) #-9

　　　1.5 數據結構相關　

　　　　1.5.1 列表和元組

　　　　　　list()：將一個可迭代對象轉化成列表（若是是字典，默認將key做爲列表的元素）。

l1 = list({'name':'alex','age':1000})    #只取鍵
print(l1)

['name', 'age']

　　　　　　tuple()：將一個可迭代對象轉化成元祖（若是是字典，默認將key做爲元祖的元素）。

　　　　1.5.2 相關內置函數

　　　　　　*** reversed()：將一個序列翻轉，並返回此翻轉序列的迭代器。

l1 = [11, 22, 33, 44, 77, 66]
l_obj = reversed(l1)
for i in l_obj:
    print(i)

66
77
44
33
22
11

　　　　　　slice()：構造一個切片對象，用於列表的切片。

l1 = [11, 22, 33, 44, 77, 66]
l2 = [111, 222, 333, 444, 777, 666]
print(l1[1::2])
rule = slice(1, len(l2), 2)   #重複切片動做，使用同一規則時使用slice
print(l2[rule])

　　　　1.6 字符串相關

　　　　　　str()：將數據轉化成字符串。

　　　　　　format:與具體數據相關，用於計算各類小數，精算等。

print(format('test', '<20'))  # 左對齊
print(format('test', '>20'))  # 右對齊
print(format('test', '^20'))  # 居中

test                
                test
        test    

　　　　　　*** bytes：str---> bytes  與 str.encode 相同

s1 = 'alex'
b1 = s1.encode('utf-8')
b2 = bytes(s1,encoding='utf-8')
print(b1)
print(b2)

b'alex'
b'alex'

　　　　　　　　bytearray()

ret = bytearray('alex', encoding='utf-8')  # 類比：[97,103,....]
print(id(ret))
print(ret)  # bytearray(b'alex')
print(ret[0])
ret[0] = 65
print(ret)
print(id(ret))　　　　　

　　　　　　　　memoryview()  分字節去轉換成str

b1 = bytes('你好',encoding='utf-8')
print(b1)   #b'\xe4\xbd\xa0\xe5\xa5\xbd'
ret = memoryview(b1)
print(len(ret)) #6
print(ret)     # <memory at 0x000002AE9240F048>
print(bytes(ret[:3]).decode('utf-8')) #你
print(bytes(ret[3:]).decode('utf-8')) #好

　　　　　　　　ord():輸入字符找該字符編碼的位置 

print(ord('a'))  #97 
print(ord('中'))  # unicode 20013

　　　　　　　　chr():輸入位置數字找出期對應的字符  經常使用範圍（大寫字母:65-90  A-Z）  (小寫字母:96-122) (數字：48-57)

33 !
34 "
35 #
36 $
37 %
38 &
39 '
40 (
41 )
42 *
43 +
44 ,
45 -
46 .
47 /
48 0
49 1
50 2
51 3
52 4
53 5
54 6
55 7
56 8
57 9
58 :
59 ;
60 <
61 =
62 >
63 ?
64 @
65 A
66 B
67 C
68 D
69 E
70 F
71 G
72 H
73 I
74 J
75 K
76 L
77 M
78 N
79 O
80 P
81 Q
82 R
83 S
84 T
85 U
86 V
87 W
88 X
89 Y
90 Z
91 [
92 \
93 ]
94 ^
95 _
96 `
97 a
98 b
99 c
100 d
101 e
102 f
103 g
104 h
105 i
106 j
107 k
108 l
109 m
110 n
111 o
112 p
113 q
114 r
115 s
116 t
117 u
118 v
119 w
120 x
121 y
122 z
123 {
124 |
125 }
126 ~

View Code

print(chr(65))  #A
print(chr(20013)) # unicode 中

　　　　　　　　ascii:是ascii碼中的返回該值，不是就返回/u...+16進制

print(ascii('a')) #'a'
print(ascii(1))   # 1 
print(ascii('中')) # '\u4e2d'

　　　　　　　　*** repr:返回一個對象的string形式（原形畢露）。

msg = '小數%f' %(1.234)
print(msg)
msg = '姓名：%r' % ( 'alex')
print(msg)
print(repr('{"name":"alex"}'))
print('{"name":"alex"}')


小數1.234000
姓名：'alex'
'{"name":"alex"}'
{"name":"alex"}

　　　　1.7  數據集合（3）

　　　　　　　　dict() 建立一個字典

dic = dict({'name': 'alex'})
print(dic)

{'name': 'alex'}

　　　　　　　　set() 建立一個集合

set1 = set(('alex','wusir'))
print(set1)

　　　　　　　　frozenset()：返回一個凍結的集合，凍結後集合不能再添加或刪除任何元素。

　　　　1.8 相關內置函數

　　　　　　　　*** len() 返回一個對象中元素的個數

　　　　　　　　sorted():對全部可迭代的對象進行排序操做。

print(sorted([1, 2, 3, 4, 5, -6]))
print(sorted([1, 2, 3, 4, 5, -6], key=abs))

[-6, 1, 2, 3, 4, 5]
[1, 2, 3, 4, 5, -6]

L = [('a', 1), ('c', 2), ('d', 4), ('b', 3), ]
print(sorted(L))
def func1(x):
    return x[1]
L = [('a', 1), ('c', 2), ('d', 4),('b', 3), ]
print(sorted(L, key=func1))

　　　　　　　　*all：可迭代對象中，全都是True纔是True

print(all([1, 'alex', True, (1,2,3)]))  # True

print(all([0, 'alex', True, (1,2,3)]))    #False

　　　　　　　　*any：可迭代對象中，有一個True 就是True

print(any([0, '', False, (1,2,3)])) # True

print(any([0, '', False, ()])) #False

　　　　　　　　***zip 拉鍊方法 返回的是一個迭代器

l1 = [1, 2, 3, 4]
tu1 = ('老男孩', 'alex', 'wusir')
l2 = ['*', '**', '***', "****"]
obj = zip(l1,tu1,l2)
for i in obj:
    print(i)


(1, '老男孩', '*')
(2, 'alex', '**')
(3, 'wusir', '***')

　　　　　　　　***map: 循環模式

def func2(x):
    return x**2
obj = map(func2, [1, 2, 3, 4])
for i in obj:
    print(i)
print((i**2 for i in [1, 2, 3, 4]))

def func2(x, y):
    return x + y
obj1 = map(func2, [1, 2, 3, 4, 6], (2, 3, 4, 5))
for i in obj1:
    print(i)

　　　　　　　　***filter 篩選模式

def func(x):
    return x % 2 == 0
ret = filter(func,[1, 2, 3, 4, 5, 6, 7])
print(ret) #<filter object at 0x0000021C5FB53E80>
for i in ret:
    print(i)


2
4
6

print((i for i in [1, 2, 3, 4, 5, 6, 7] if i % 2 == 0))   #<generator object <genexpr> at 0x0000021C5FA90F68>

***lambda 匿名函數 一句話函數

ret = lambda x, y: x+y
函數名 = lambda 參數 ：返回值

#參數能夠有多個，用逗號隔開
#匿名函數無論邏輯多複雜，只能寫一行，且邏輯執行結束後的內容就是返回值
#返回值和正常的函數同樣能夠是任意數據類型