python中內置了很多有用的函數，調用前來賊雞兒爽。
調用函數需要知道函數的名稱和參數。
這是Python的官方文檔介紹內置函數。
http://docs.python.org/3/library/functions.html#abs

數學相關

abs(x) 求絕對值

abs()函數返回參數的絕對值

圖-1

fabs()與abs()的區別
abs()是一個內置函數，fabs()在math模塊中定義
fabs()函數只適用于float和integer類型， abs(）也適用于復數類型。

圖-2

min()求最小值

返回給參數最小值

1. 初級用法

   
   
   image.png
2. 中級用法
   key屬性的運用

當key參數不為空時，就以key的函數對象為判斷的標準。
如果我們想找出value中絕對值最小的數，就可以配合lamda先進行處理，再找出最小值

price = {"HPQ": 37.2, 'FB': 10.75, 'AAPL': 612.78}
min(price, key=lambda k: price[k])

結果如下：

result

3. 高級用法
   找出字典中最小的那組數據

price = {"HPQ": 37.2, 'FB': 10.75, 'AAPL': 612.78}
min_price = min(zip(price.value(), price.key()))
print(min_price)

結果如下：

結果

max()求最大值

用法min()相似
中級用法

當key參數不為空時，就以key的函數對象為判斷的標準。
如果我們想找出一組數中絕對值最大的數，就可以配合lamda先進行處理，再找出最大值

a = [-9, -8, 1, 2, -1, 6]
max(a, key=lambda x：abs(x))

結果如下：

結果

sum(): 求和

語法：sum(iterable[, start])
參數:
iterable -- 可迭代的
start -- 指定相加的參數，如果沒有設置這個值，默認為0。

結果

sorted() 排序

sort與sorted的區別

1. 初級用法

g = [1, 4, 6, 8, 9, 3, 5]
print(sorted(g))
print("--------------------")
print(sorted((1, 4, 6, 8, 9, 3, 5)))
print("--------------------")
print(sorted("gafrtp"))
# 反序
print("--------------------")
print(sorted(g, reverse=True))

結果如下：

結果

2. 高級用法

有時候，我們要處理的數據內的元素不是一維的，而是二維的甚至是多維的，那要怎么進行排序呢？這時候，sorted()函數內的key參數就派上用場了！從幫助信息上可以了解到，key參數可傳入一個自定義函數。

L = [('a', 1), ('b', 2), ('c', 6), ('d', 4), ('e', 3)]
sorted(L, key=lambda x:x[0])

sorted(L, key=lambda x:x[1])

sorted(L, key=lambda x:x[0], reverse=True)

sorted(L, key=lambda x:x[1], reverse=True)

這里，列表里面的每一個元素都為二維元組，key參數傳入了一個lambda函數表達式，其x就代表列表里的每一個元素，然后分別利用索引返回元素內的第一個和第二個元素，這就代表了sorted()函數利用哪一個元素進行排列。而reverse參數就如同上面講的一樣，起到逆排的作用。默認情況下，reverse參數為False

結果

divmod() 獲取上和余數

divmod(a,b)方法返回的是a//b（商）以及a%b(余數)，返回結果類型為tuple

>>> divmod(9, 2)
(4, 1)
>>> divmod(9, 2)[0]
4
>>> divmod(9, 2)[1]
1

pow() 獲取乘方數

與math.pow的區別

1、pow(x,y):這個是表示x的y次冪。
2、pow(x,y,z)：這個是表示x的y次冪后除以z的余數

>>> pow(2, 4)
16                   這個是2**4
>>> pow(2, 4, 5)
1                    這個是2**4/5的余數

round() 方法返回浮點數x的四舍五入值.

語法：
round( x [, n] )
參數：
x -- 數字表達式
n -- 表示從小數點位數， 其中x需要四舍五入， 默認值為0

>>> print ("round(70.23456) : ", round(70.23456))
round(70.23456) :  70
>>> print ("round(56.659,1) : ", round(56.659,1))
round(56.659,1) :  56.7
>>> print ("round(80.264, 2) : ", round(80.264, 2))
round(80.264, 2) :  80.26
>>> print ("round(100.000056, 3) : ", round(100.000056, 3))
round(100.000056, 3) :  100.0
>>> print ("round(-100.000056, 3) : ", round(-100.000056, 3))
round(-100.000056, 3) :  -100.0

range() 生成一個a到b的數組， 左閉右開

語法：
range(start, stop[, step])
參數說明：

• start: 計數從 start 開始。默認是從 0 開始。例如range（5）等價于range（0， 5）;
• stop: 計數到 stop 結束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]沒有5
• step：步長，默認為1。例如：range（0， 5） 等價于 range(0, 5, 1)

Python3.x 中 range() 函數返回的結果是一個整數序列的對象，而不是列表。
>>> list(range(10))  # 從0到10
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(1, 11))  # 從1到11
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> list(range(0, 30, 5))  # 步長為5
[0, 5, 10, 15, 20, 25]
>>> list(range(0, 10, 3))  # 步長為3
[0, 3, 6, 9]
>>> list(range(0, -10, -1))  # 負數
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> list(range(0))
[]
>>> list(range(1, 0))
[]

萌萌噠的分割線

類型轉換

int() 轉為int形

語法：int(x base)
x -- 字符串或數字
base -- 進制數， 默認是十進制

>>> int()  # 不傳入參數
0
>>> int(3)
3
>>> int(3.6)  # 浮點數將向下取整
3
>>> int("12", 16) #如果是帶參數base的話，12要以字符串的形式進行輸入，12 為 16進制
18
>>> int("0xa", 16)
10
>>> int('10', 16)
16
>>> int(100, 2)          # 出錯，base 被賦值后函數只接收字符串

參考博客：https://www.cnblogs.com/guyuyuan/p/6827987.html?utm_source=itdadao&utm_medium=referral

float() 轉為浮點型

語法：float(x)
x -- 整數或字符串

>>> float(1)
1.0
>>> float(-123.6)
-123.6
>>> float("123")
123.0

str() 轉為字符型

語法：str(object="")

>>> str(s)
'asfg'
>>> dict = {"a": 1, "b": 2}
>>> str(dict)
"{'a': 1, 'b': 2}"

bool() 轉為布爾型

語法：bool([x])
x -- 要進行轉換的參數

>>> bool()
False
>>> bool(0)
False
>>> bool(1)
True
>>> issubclass(bool, int)  #bool 是int子類
True
-------------------------------------------------------
>>> bool("")  # 空字串 False
False
>>> bool("a")
True
-------------------------------------------------------
>>> bool(()) # 空元組
False
>>> bool((0,)) # 非空
True
>>> bool([]) # 空列表
False
>>> bool([1]) 
True
>>> bool({}) # 空字典
False
>>> bool({"a": 1})
True

bytes()

desc: bytes 函數返回一個新的 bytes 對象，該對象是一個 0 <= x < 256 區間內的整數不可變序列。
bytes([source[, encoding[, error]]])

• 如果 source 為整數，則返回一個長度為 source 的初始化數組。
• 如果 source 為字符串，則按照指定的 encoding 將字符串轉換為字節序列。
• 如果 source 為可迭代類型，則元素必須為[0 ,255] 中的整數。
• 如果 source 為與 buffer 接口一致的對象，則此對象也可以被用于初始化 bytearray。如果沒有輸入任何參數，默認就是初始化數組為0個元素。

>>> a = bytes([1, 2, 3, 4])
>>> a
b'\x01\x02\x03\x04'
>>> type(a)
<class 'bytes'>
>>> a = bytes("helloi", 'ascii')
>>> a
b'helloi'
>>> type(a)
<class 'bytes'>

list() 將元組轉化為列表

元組與列表類似， 區別在于元組值不能修改，元組放在（）中， 列表放在[]
語法: list(iterable)

>>> t = (123, "Goole", "asdas")
>>> list(t)
[123, 'Goole', 'asdas']
>>> str = "sadas"
>>> list(str)
['s', 'a', 'd', 'a', 's']
>>> dict_date = {"a": 1, "b": 2, "c": 3}  # 字典好像不能直接轉
>>> list(dict_date)
['a', 'b', 'c']

iter() 返回一個可迭代的對象

用來生成迭代器
語法： iter(object[, sentine])
object -- 支持迭代的集合
sentinel -- 如果傳遞了第二個參數， 則參數 object 必須是一個可調用的對象（如，函數），此時，iter 創建了一個迭代器對象，每次調用這個迭代器對象的next()方法時，都會調用 object。

>>> l = [1, 3, 4]
>>> ite = iter(l)
>>> ite
<list_iterator object at 0x00C211D0>
>>> ite.__next__()
1
>>> ite.__next__()
3
>>> ite.__next__()
4
>>> ite.__next__()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

dict() 轉化為字典

創建一個字典
語法：dict(**kwarg)
dict(mapping, **kwarg)
dict(iterable, **kwarg)
**kwargs ---關鍵字
mapping --- 元素的容器
iterable --- 可迭代對象

>>> dict()   # 創建字典
{}
>>> dict(a="a", b="b", c="c")  # 傳入關鍵字
{'a': 'a', 'b': 'b', 'c': 'c'}
>>> dict(zip(["one", "two", "three"], [1,2,3]))  # 映射函數方式來構造字典
{'one': 1, 'two': 2, 'three': 3}
>>> dict([('one', 1), ('two', 2), ("three", 3)])  # 可迭代對象方式來構造字典
{'one': 1, 'two': 2, 'three': 3}

enumerate() 返回一個枚舉對象

函數用于將一個可遍歷的數據對象(如列表、元組或字符串)組合為一個索引序列，同時列出數據和數據下標，一般用在 for 循環當中。
語法: enumerate(iterable, [start=0])

seasons = ["Spring", "Summer", "Fall", "Winter"]
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

__________________ 分割線________________
普通for 循環
>>> i = 0
>>> seq = ["one", "two", "three"]
>>> for element in seq:
...     print(i, seq[i])
...     i += 1
...
0 one
1 two
2 three

enumerate 循環
>>> seq = ["one", "two", "three"]
>>> for i, element in enumerate(seq):
...     print(i, seq[i])
...
0 one
1 two
2 three

————————————————————補充———————————————————
# 如果要統計文件的行數，可以這樣寫
>>>count = len(open(filepath, 'r').readlines())
>>>1
# 這種方法簡單，但是可能比較慢，當文件比較# 大時甚至不能工作。
可以利用enumerate()：
>>>count = 0
>>>for index, line in enumerate(open(filepath,'r'))： 
>>>    count += 1
>>>1
>>>2
>>>3

參考博客：https://www.cnblogs.com/quietwalk/p/7997850.html

tuple() 函數將列表轉換為元組。

語法：tuple(seq)
seq --- 要轉換為元組的序列

>>> list = ["Google", "tabao", "baidu"]
>>> tuple1 = tuple(list)
>>> tuple1
('Google', 'tabao', 'baidu')

set() 轉化為set

desc: 函數創建一個無序不重復元素集，可進行關系測試，刪除重復數據，還可以計算交集、差集、并集等。
語法： set([iterable])
返回新的集合

>>> x = set("runoob")
>>> y = set("google")
>>> x,y
({'u', 'o', 'r', 'b', 'n'}, {'o', 'g', 'e', 'l'})
>>> x&y  # 交集
{'o'}
>>> x | y  # 并集
{'l', 'u', 'o', 'r', 'b', 'g', 'n', 'e'}
>>> x - y  # 差集
{'b', 'r', 'n', 'u'}

hex() 轉化為16進制

語法：hex(x)

>>> hex(12233)
'0x2fc9'
>>> hex(-12)
'-0xc'

oct() 轉化為8進制

語法：oct(x)

>>> oct(12)
'0o14'
>>> oct(-12)
'-0o14'

bin() 轉化為2進制

語法：bin(x)

>>> bin(1)
'0b1'
>>> bin(-1)
'-0b1'

chr() 轉化為數字為相應的ASCII碼

描述： 用一個范圍在 range（256）內的（就是0～255）整數作參數，返回一個對應的字符。

>>> chr(0x31)  # 十六進制
'1'
>>> chr(0x61)
'a'
>>> chr(49)    # 十進制
'1'
>>> chr(97)
'a'

ord() 轉化ASCII字符為相應的數字

語法：ord(c)

>>> ord("a")
97
>>> ord("b")
98
>>> ord("c")
99

相關操作

eval(): 執行一個表達式， 或字符串作為運算。

描述：eval() 函數用來執行一個字符串表達式，并返回表達式的值。
語法：eval(expression[, globals[, locals]])

• expression -- 表達式
• globals -- 變量作用域，全局命名空間，如果被提供，則必須是一個字典對象。
• locals -- 變量作用域，局部命名空間，如果被提供，可以是任何映射對象。

>>> x = 7
>>> eval('3 * x')
21
>>> eval('pow(2, 2)')
4
>>> eval('2+2')
4
>>> n = 81
>>> eval("n+4")
85

可以把list,tuple,dict和string相互轉化。
參考博客：https://www.cnblogs.com/liu-shuai/p/6098246.html
詳解：
https://www.cnblogs.com/dadadechengzi/p/6149930.html

exec() 執行Python語句

?沒用過

map() 根據提供的函數對指定序列做出映射

描述：
第一個參數 function 以參數序列中的每一個元素調用 function 函數，返回包含每次 function 函數返回值的新列表。
ensp; 用法靈活，結合lambda 使用。
語法：
map()函數語法：
map(function, iterable, ...)

• function 函數， 有兩個參數
• iterable 一個或多個序列

返回值：
?Python 2 列表
?Python3 迭代器

>>> def square(x):
...     return pow(x, 2)
...
>>> map(square, [1,2,3,4,5])
<map object at 0x0173B610>
>>> l = map(square, [1,2,3,4,5])
>>> l.__next__()
1
>>> l.__next__()
4
>>> l.__next__()
9
>>> l.__next__()
16
>>> l.__next__()
25
>>> l.__next__()
————————————————————————————————
>>> lst = map(lambda x:x ** 2, [1, 2, 3, 4, 5])   # 使用lambda 函數
>>> for i in lst:
...     print(i)
...
1
4
9
16
25

filter() 對指定序列執行過濾操作

描述： 用于過濾序列，過濾掉不符合條件的元素，返回由符合條件元素組成的新列表。
該接收兩個參數，第一個為函數，第二個為序列，序列的每個元素作為參數傳遞給函數進行判，然后返回 True 或 False，最后將返回 True 的元素放到新列表中。
語法： filter(function, iterable)
function -- 判斷函數
iterable -- 可迭代對象
返回值
返回一個迭代對象

>>> def is_odd(n):
...     return n % 2 == 1
...
>>> tmplist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
>>> newlist = list(tmplist)
>>> print(newlist)
[1, 3, 5, 7, 9]

過濾1-100中平方根是整數的數：

>>> import math
>>> def is_sqr(x):
...     return math.sqrt(x) % 1 == 0
...
>>> tmplist = filter(is_sqr, range(1, 101))
>>> newlist = list(tmplist)
>>> print(newlist)
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

reduce() 對參數序列中元素進行累積

描述：函數將一個數據集合（鏈表，元組等）中的所有數據進行下列操作：用傳給 reduce 中的函數 function（有兩個參數）先對集合中的第 1、2 個元素進行操作，得到的結果再與第三個數據用 function 函數運算，最后得到一個結果。
注意：在python3.0以后， reduce不在內建函數中了， 要用它就要from functools import reduce
語法：
reduce(function, iterable[, initializer])

• function 函數， 有兩個參數
• iterable 可迭代對象
• initializer 可選， 初始參數

>>> from functools import reduce
>>> reduce(lambda x, y: x+y, [1, 2, 3])
6
>>> reduce(lambda x, y: x+y, [1, 2, 3], 9)
15
-----------------------------------------------------
from functools import reduce

def add(x,y):
    return x + y

print (reduce(add, range(1, 101)))
result=5050
————————————————————————————————
統計某字符串重復的次數
>>> from functools import reduce
>>> sentences = ['The Deep Learning textbook is a resource intended to help students and practitioners enter the field of machine learning in general and deep learning in particular. '] 
>>> word_count =reduce(lambda a,x:a+x.count("learning"),sentences,0)
>>> print(word_count)
>>> 2

zip() 將iterable分組合并。返回一個zip對象

函數用于將可迭代的對象作為參數，將對象中對應的元素打包成一個個元組，然后返回由這些元組組成的列表。
如果各個迭代器的元素個數不一致，則返回列表長度與最短的對象相同，利用 * 號操作符，可以將元組解壓為列表。

zip 方法在 Python 2 和 Python 3 中的不同：在 Python 3.x 中為了減少內存，zip() 返回的是一個對象。如需展示列表，需手動 list() 轉換。

語法：
zip([iterable, ...])

>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> c = [4, 5, 6, 7, 8]
>>> zipped = zip(a, b)  # 返回一個對象
>>> zipped
<zip object at 0x00B58440>
>>> list(zipped)
[(1, 4), (2, 5), (3, 6)]
>>> list(zip(a, c))  # 元素個數與最短的列表一致
[(1, 4), (2, 5), (3, 6)]
>>>
>>> a1, a2 = zip(*zip(a, b))  # 與zip相反， *zip可以理解為解壓， 返回二維矩陣。
>>> list(a1)
[1, 2, 3]
>>> list(a2)
[4, 5, 6]

————————————————————————————————
>>> v1 = {1:11, 2:22}
>>> v2 = {3:33, 4:44}
>>> v3 = {5:55, 6:66}
>>> v = list(zip(v1, v2, v3))  # 壓縮
>>> print(v)
[(1, 3, 5), (2, 4, 6)]
>>> w = zip(*zip(v1, v2, v3))  # 解壓
>>> print(list(w))
[(1, 2), (3, 4), (5, 6)]

參考博客：https://www.cnblogs.com/wushuaishuai/p/7766470.html

hash() 返回一個對象的hash值，

用于獲取取一個對象（字符串或者數值等）的哈希值

語法：
?hash(obj)

>>> hash('test')   # 字符串
740618988
>>> hash(1)    # 數字
1
>>> hash(str([1, 2, 3]))   # 集合
2097662348
>>> hash(str(sorted({'1':1})))  # 字典
1162454008

isinstance() 函數來判斷一個對象是否是一個已知的類型，類似 type()。

- isinstance() 與 type()的區別
>**type() 不會認為子類是一種父類類型，不考慮繼承關系。
 isinstance() 會認為子類是一種父類類型，考慮繼承關系。
 如果要判斷兩個類型是否相同推薦使用 isinstance()。**

>>> class A:
...     pass
>>> class B(A):
...     pass
>>> isinstance(A(), A)
True
>>> type(A()) == A
True
>>> isinstance(B(), A)
True
>>> type(B()) == A
False

語法：
? isinstance(obj, classinfo)

• object -- 實例對象。
• classinfo -- 可以是直接或間接類名、基本類型或者由它們組成的元組。

>>> a = 2
>>> isinstance(a, int)
True
>>> isinstance(a, str)
False
>>> isinstance(a, (str, int, list))  # 是元組中的一個返回True
True

issubclass() 方法用于判斷參數 class 是否是類型參數 classinfo 的子類。

語法：
? issubclass(class, classinfo)

>>> class A:
...     pass
>>> class B(A):
...     pass
>>> print(issubclass(B,A))
True

reversed() 生成一個反序列的迭代器

語法： reversed(seq)
seq -- 要轉換的序列， 可以是tuple, string, list或者range

>>> seqstring = 'Runoob'  # 字符串
>>> print(list(reversed(seqstring)))
['b', 'o', 'o', 'n', 'u', 'R']
>>> seqtuple = ('R', 'u', 'n', 'o', 'o', 'b')  # 元組
>>> print(list(reversed(seqtuple)))
['b', 'o', 'o', 'n', 'u', 'R']
>>> seqrange = range(5, 9)
>>> print(list(reversed(seqrange)))
[8, 7, 6, 5]
>>> seqlist = [1, 2, 4, 3, 5]  # 列表
>>> print(list(reversed(seqlist)))
[5, 3, 4, 2, 1]

詳解博客：
https://blog.csdn.net/sxingming/article/details/51353379

globals() 返回當前全局變量的字典

函數會以字典類型返回當前位置的全部全局變量。

其他

hasattr(obj, name)

?判斷一個對象里面是否有name屬性或者name方法，返回BOOL值，有name特性返回True， 否則返回False。
需要注意的是name要用括號括起來

getattr(obj, name)

?獲取對象object的屬性或者方法，如果存在打印出來，如果不存在，打印出默認值，默認值可選。
需要注意的是，如果是返回的對象的方法，返回的是方法的內存地址，如果需要運行這個方法，
可以在后面添加一對括號。

setattr(obj, name, values)

?給對象的屬性賦值，若屬性不存在，先創建再賦值。

join()

用于將序列中的元素以指定的字符連接生成一個新的字符串。
語法：
str.join(seq)
seq --- 要連接的元素序列
返回值：
返回通過指定字符連接序列中元素后生成的新字符串

>>> str = "-"
>>> seq = ("a", "b", "c")
>>> str = str.join(seq)
>>> print(str)
a-b-c
>>> str = "".join(seq)
>>> str
'abc'

?參考博客：
?https://www.cnblogs.com/cenyu/p/5713686.html