Python經常使用內置函數

Python 做爲一門高級編程語言，爲咱們提供了許多方便易用的內置函數，節省了很多開發應用的時間。目前，Python 3.7 共有 69 個內置函數，一些是咱們耳熟能詳的函數，另外一些卻不是很常見，這裏主要介紹一些新手必備函數及其用法。

我把這些內置函數中經常使用的大體的地分爲八大類：

輸入輸出	print() open()  input()
迭代相關	enumerate()  zip()
序列屬性	sum()  max()  min()  len()
操做序列	sorted()  reversed()  range()
對象屬性	dir()  id()  isinstance()  type()
映射類型	eval()  map()  slice()
數值計算	abs(), all(). any(), pow(), divmod()
其餘	exec(), __import__()

1、輸入輸出

1.print 函數將對象輸出至控制檯

print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

value爲可變參數，能夠接受任意多個對象。sep 參數表示輸出對象之間的分隔符，默認爲空格。

print('人生苦短', '我用Python')
人生苦短 我用Python

分隔符爲'+'

print('人生苦短', '我用Python', sep='+')
人生苦短+我用Python

格式化輸出字符串的三種方式：

name = '飛凡空間'
print('公衆號：%s'%name)
公衆號：飛凡空間
print('公衆號：{}'.format(name))
公衆號：飛凡空間
print(f'公衆號：{name}')
公衆號：飛凡空間

2. open 函數打開文件並返回文件對象

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

file 爲文件地址，mode 爲打開文件的模式，默認爲 'r'，表示讀取文件，經常使用的還有：'w' 表示寫入文件、'b' 表示以二進制形式打開。經常使用上下文管理器 with 打開文件，f.read( ) 讀取所有內容，f.readline() 讀取一行內容。

with open('test.txt', 'r') as f:
   text1 = f.read()

with open('test.txt', 'r') as f:
   text2 = ''
   line = f.readline()
   while line:
       text2 += line
       line = f.readline()

assert text1 == text2
print(text1)

###############
輸出內容：
人生苦短 我用Python
人生苦短 我用Python
人生苦短 我用Python
人生苦短 我用Python
###############

有時候，咱們讀取文件還會遇到亂碼問題，能夠指定編碼格式：

當文件中有中文的時候，使用 'utf-8' 編碼會致使異常：UnicodeDecodeError: 'utf-8' codec can't decode byte 0xb8 in position 7: invalid start byte

with open('test.txt', 'r', encoding='utf-8') as f:
   text1 = f.read()

 這時候，咱們能夠嘗試 'gb2312' 或者 'gbk' 編碼來打開含有中文字符的文件。這時，即可以成功打開文件。　

with open('test.txt', 'r', encoding='gb2312') as f:
   text1 = f.read()

with open('test.txt', 'w', encoding='gbk') as f:
   f.write('人生苦短 我用Python')

3. input 函數獲取控制檯輸入　

input([prompt])

input 可接受字符串爲參數，提示用戶輸入。   

name = input('請輸入你的名字：')
請輸入你的名字：>? 張亞飛
name
Out[11]: '張亞飛'

2、迭代相關

1. enumerate 函數返回元素的序號與對應值

enumerate(iterable, start=0)

iterable 參數表示可迭代對象，start 參數是元素序號的起點，默認爲 0。enumerate 函數的等價形式以下：

def enumerate(sequence, start=0):
	n = start
	for elem in sequence:
	 yield n, elem
	 n += 1

seq = ['P', 'y', 't', 'h', 'o', 'n']
for i, elem in enumerate(seq):
	print(i, elem)

2. zip 函數用於同時迭代多個對象

zip(*iterables)

*iterable 能夠接受任意多個可迭代對象

a = ["**", '**', '**']
b = ['微信公衆號', '關注', '飛凡空間']
c = a
print('#'*20)
for i, j, k in zip(a, b, c):
   print(i, j, k)
print('#'*20)


####################
** 微信公衆號 **
** 關注 **
** Python飛凡空間 **
####################

3、序列屬性

• 序列最大值：max
• 序列最小值：min
• 序列的和：   sum
• 序列長度：   len

基本用法：向這四個函數中傳入序列，能夠獲得對應屬性。

import random
random.seed(21)
seq = [random.randint(0, 100) for i in range(10)]
print(seq)
# [21, 53, 88, 53, 81, 36, 61, 27, 60, 65]
print(max(seq))
# 88
print(min(seq))
# 21
print(sum(seq))
# 545
print(len(seq))
# 10

做爲內置函數，能夠直接傳入生成器（不須要括號）做爲參數：

import random
random.seed(21)
num = max(random.randint(0, 100) for i in range(10))
print(num)
# 88

可傳入 key 參數，做爲比較大小的依據，至關於把序列中每個元素 item 先傳入函數 key 中，將函數返回的數值做爲判斷對象大小的依據。

def foo(x):
   return 1. / x
max(seq, key = foo)
# 21

對於咱們自定義的類型，必須實現特殊方法，才能進行 len 等操做。

__len__ 表明：len 操做，__eq__ 表明：= 操做，__lt__ 表明 < 操做。

class foo:
   def __init__(self, num, seq):
       self.num = num
       self.seq = seq
       
   def __len__(self):
       return len(self.seq)
       
   def __eq__(self, other):
       return self.num == other.num
       
   def __lt__(self, other):
       return self.num < other.num

f1 = foo(18, [1, 4, 6])
f2 = foo(21, [1, 7, 9, 10])
f1 < f2
True
f1 > f2
False
f1 == f2
False
f3 = foo(18, [9, 9, 0, 7])
f1 == f3
True
en(f1)
3
len(f2)
4

4、操做序列

    1. range 函數生成序列

range(start, stop[, step])

• start 可選參數，默認爲 0 ，表示序列起點

• stop 必選參數，表示序列終點，不包括終點

• step 可選參數，序列的步長，默認爲 1

range(5)
Out[12]: range(0, 5)
list(range(5))
Out[13]: [0, 1, 2, 3, 4]
list(range(1, 5))
Out[14]: [1, 2, 3, 4]
list(range(1, 10, 2))
Out[15]: [1, 3, 5, 7, 9]

range 函數生成的對象能夠迭代，和列表很相似，_ 表示廢棄變量（爲了不污染變量環境）：

In[16]: for _ in range(3):
   ...:     print('咱們就別再分離')
   ...:     
咱們就別再分離
咱們就別再分離
咱們就別再分離
 

2. reversed 函數能夠將序列逆置

reversed 能夠將序列逆置，包括元組、字符串、列表。對於列表和字符串的逆置，使用 list[::-1] 或者slice()更加方便。

import random
random.seed(21)
seq = [random.randint(0, 100) for i in range(10)]
print(seq)
# [21, 53, 88, 53, 81, 36, 61, 27, 60, 65]
reversed(seq)
print(list(reversed(seq)))
# [65, 60, 27, 61, 36, 81, 53, 88, 53, 21]

 字符串逆置：

a = '我愛你'
a[::-1]
Out[18]: '你愛我'
reversed(a)
Out[19]: <reversed at 0xd3f24aa390>
''.join(reversed(a))
Out[20]: '你愛我'

3. sorted 函數能夠對序列進行排序

sorted(iterable, *, key=None, reverse=False)

sorted 不一樣於 list.sort 操做（原地排序），返回一個新的有序序列，原序列保持不變。* 表示僅限關鍵字參數(keyword-only)，也就是說，key、reverse 參數只能經過關鍵字傳參，而不能經過位置傳參。reverve 參數表示逆置操做，key 與以前 len 中的 key 參數相似，是函數排序的依據。 

sorted([9, 6, 2, 3, 6])
[2, 3, 6, 6, 9]

5、對象屬性

• dir 函數返回屬性列表
• id  函數返回對象地址
• isinstance  判斷對象的類型
• type 返回對象的類型

class foo:
   pass

>>> dir(foo)
['__class__',
'__delattr__',
'__dict__',
'__dir__',
......
'__str__',
'__subclasshook__',
'__weakref__']
# 建立實例
>>> f = foo()
>>> type(foo)
__main__.foo
>>> isinstance(f, foo)
True
>>> id(f)
2135099584864

6、映射類型

• eval 解除引號的束縛
• map 應用函數於單個對象
• slice 生成切片

eval 能夠去除字符串的單引號，從而獲取引號內部內容。下面的演示展現了，如何使用 eval 函數獲取字符串中的字典：

>>> info = '{"name": "LiHua", "age": 12}'
>>> eval(info)
{'name': 'LiHua', 'age': 12}
>>> info_dict = eval(info)
>>> type(info_dict)
dict
 

map 將傳進來的函數應用於序列中的每個元素，並返回迭代器。

map(function, iterable, ...)

舉例來講,map 就是對 seq 列表中的每個元素 item 進行 int 操做(int(item))。匿名函數同理，就是對序列中的每個元素進行加 2 的操做。

seq = [1.5, 4.5, 9.1]
list(map(int, seq))
[1, 4, 9]
list(map(lambda x: x + 2, seq))
[3.5, 6.5, 11.1]

slice 函數爲切片操做命名，使得切片操做更加清晰明瞭。

slice(start, stop[, step])

start 爲起點，stop 爲終點，step 爲步長。使用該操做，使得截取有規律的文本內容變得很輕鬆。特別是長文本，使用 slice 函數更加清晰易懂。

>>> text = '微信公衆號 飛凡空間'
>>> name = slice(0, 6)
>>> text[name]
微信公衆號 
>>> content = slice(6, 16)
>>> text[content]
飛凡空間　

7、數值計算

1. abs(x)

返回一個數的絕對值。實參能夠是整數或浮點數。若是實參是一個複數，返回它的模。

2. all(iterable)

若是 iterable 的全部元素爲真（或迭代器爲空），返回 True 。等價於:

def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True　

3. any(iterable)

若是*iterable*的任一元素爲真則返回``True``。若是迭代器爲空，返回``False``。等價於:

def any(iterable):
    for element in iterable:
        if element:
            return True
    return False　　

4. divmod(a, b)

它將兩個（非複數）數字做爲實參，並在執行整數除法時返回一對商和餘數。對於混合操做數類型，適用雙目算術運算符的規則。對於整數，結果和 (a // b, a % b) 一致。對於浮點數，結果是 (q, a % b) ，q 一般是 math.floor(a / b) 但可能會比 1 小。在任何狀況下， q * b + a % b 和 a 基本相等；若是 a % b 非零，它的符號和 b 同樣，而且 0 <= abs(a % b) < abs(b) 。

divmod(10, 3)
Out[21]: (3, 1)

5. pow(x, y[, z])

返回 x 的 y 次冪；若是 z 存在，則對 z 取餘（比直接 pow(x, y) % z 計算更高效）。兩個參數形式的 pow(x,y) 等價於冪運算符： x**y。

參數必須爲數值類型。 對於混用的操做數類型，則適用二元算術運算符的類型強制轉換規則。 對於 int 操做數，結果具備與操做數相同的類型（轉換後），除非第二個參數爲負值；在這種狀況下，全部參數將被轉換爲浮點數並輸出浮點數結果。 例如，10**2 返回 100，但 10**-2 返回 0.01。 若是第二個參數爲負值，則第三個參數必須省略。 若是存在 z，則 x 和 y 必須爲整數類型，且 y 必須爲非負數。

pow(2,3,7)
Out[26]: 1
pow(2,3)
Out[27]: 8

8、其餘

1. exec(object[, globals[, locals]])

這個函數支持動態執行 Python 代碼。object 必須是字符串或者代碼對象。若是是字符串，那麼該字符串將被解析爲一系列 Python 語句並執行（除非發生語法錯誤）。[1] 若是是代碼對象，它將被直接執行。在任何狀況下，被執行的代碼都須要和文件輸入同樣是有效的（見參考手冊中關於文件輸入的章節）。請注意即便在傳遞給 exec() 函數的代碼的上下文中，return 和 yield 語句也不能在函數定義以外使用。該函數返回值是 None。

不管哪一種狀況，若是省略了可選參數，代碼將在當前範圍內執行。若是提供了 globals 參數，就必須是字典類型，並且會被用做全局和本地變量。若是同時提供了 globals 和 locals 參數，它們分別被用做全局和本地變量。若是提供了 locals 參數，則它能夠是任何映射型的對象。請記住在模塊層級，全局和本地變量是相同的字典。若是 exec 有兩個不一樣的 globals 和 locals 對象，代碼就像嵌入在類定義中同樣執行。

若是 globals 字典不包含 __builtins__ 鍵值，則將爲該鍵插入對內建 builtins 模塊字典的引用。所以，在將執行的代碼傳遞給 exec() 以前，能夠經過將本身的 __builtins__ 字典插入到 globals 中來控制可使用哪些內置代碼。

exec('import os')
os.getcwd()
Out[25]: 'E:\\爬蟲\\spider_project'

2. __import__: 動態導入模塊

__import__(name, globals=None, locals=None, fromlist=(), level=0)

註解

與 importlib.import_module() 不一樣，這是一個平常 Python 編程中不須要用到的高級函數。

此函數會由 import 語句發起調用。 它能夠被替換 (經過導入 builtins 模塊並賦值給 builtins.__import__) 以便修改 import 語句的語義，可是 強烈 不建議這樣作，由於使用導入鉤子 (參見 PEP 302) 一般更容易實現一樣的目標，而且不會致使代碼問題，由於許多代碼都會假定所用的是默認實現。 一樣也不建議直接使用 __import__() 而應該用 importlib.import_module()。

該函數會導入 name 模塊，有可能使用給定的 globals 和 locals 來肯定如何在包的上下文中解讀名稱。 fromlist 給出了應該從由 name 指定的模塊導入對象或子模塊的名稱。 標準實現徹底不使用其 locals 參數，而僅使用 globals 參數來肯定 import 語句的包上下文。

level 指定是使用絕對仍是相對導入。 0 (默認值) 意味着僅執行絕對導入。 level 爲正數值表示相對於模塊調用 __import__() 的目錄，將要搜索的父目錄層數 (詳情參見 PEP 328)。

當 name 變量的形式爲 package.module 時，一般將會返回最高層級的包（第一個點號以前的名稱），而 不是以 name 命名的模塊。 可是，當給出了非空的 fromlist 參數時，則將返回以 name 命名的模塊。

例如，語句 import spam 的結果將爲與如下代碼做用相同的字節碼:

spam = __import__('spam', globals(), locals(), [], 0)

語句 import spam.ham 的結果將爲如下調用:

spam = __import__('spam.ham', globals(), locals(), [], 0)

請注意在這裏 __import__() 是如何返回頂層模塊的，由於這是經過 import 語句被綁定到特定名稱的對象。

另外一方面，語句 from spam.ham import eggs, sausage as saus 的結果將爲

_temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)
eggs = _temp.eggs
saus = _temp.sausage

在這裏， spam.ham 模塊會由 __import__() 返回。 要導入的對象將今後對象中提取並賦值給它們對應的名稱。

若是您只想按名稱導入模塊（可能在包中），請使用 importlib.import_module()