Python基礎學習之內置函式

Python3.5版本中的68個內置函式，按順序逐個進行了自認為詳細的決議，現在是時候進行個總結了，為了方便記憶，將這些內置函式進行了如下分類：

1. 數學運算(7個)

1.1 abs()，求絕對值

求數值的絕對值

abs(-10)   # 輸出：10

1.2 divmod()，求商和余數

求兩個數值的商和余數

# divmod
divmod(10 , 3)  # 輸出：(3, 1)
divmod(10.1,3)  # 輸出：(3.0, 1.0999999999999996)
divmod(-10,4)   # 輸出：(-3, 2)

1.3 max()，求最大值

求最大值

max(1,2,3)     # 傳入3個引數 取3個中較大者；輸出：3
max('1234')    # 傳入1個可迭代物件，取其最大元素值；輸出：'4'
max(-1,0)     # 數值默認去數值較大者；輸出：0
max(-1,0,key = abs)  # 傳入了求絕對值函式，則引數都會進行求絕對值后再取較大者；輸出：-1

1.4 min()，求最小值

求最小值

min(1, 2, 3)    # 傳入3個引數 取3個中較小的；輸出：1
min('1234')     # 傳入1個可迭代物件，取其最小元素值；輸出：'1'
min(-1,-2)      # 數值默認去數值較小者；輸出：-2
min(-1,-2,key = abs)  # 傳入了求絕對值函式，則引數都會進行求絕對值后再取較小者；輸出：-1

1.5 pow()，求冪運算

求兩個數的冪運算

pow(2, 3)    # 2^3 = 8

1.6 round()，四舍五入

對數值進行四舍五入

round(1.131415926,1)  # 輸出：1.1
round(1.131415926,5)  # 輸出：1.13142

1.7 sum()，求和

求數值的和

# 傳入可迭代物件
sum((1,2,3,4))    # 輸出：10
# 元素型別必須是數值型
sum((1.5,2.5,3.5,4.5))    # 輸出：12.0
sum((1,2,3,4),-10)    # 輸出：0 

2. 型別轉換(24個)

2.1 bool()，布爾轉換

根據傳入的引數的邏輯值創建一個新的布林值

bool() # 未傳入引數；輸出：False
bool(0) # 數值0、空序列等值為False；輸出：False
bool(1)  # 輸出：True

2.2 int()，整型轉換

根據傳入的引數創建一個新的整數

int() #不傳入引數時，得到結果0；輸出：0
int(3) # 輸出：3
int(3.6) # 輸出：3

2.3 float()，浮點型轉換

根據傳入的引數創建一個新的浮點數

float() # 不提供引數的時候，回傳:0.0
float(3)   # 回傳:3.0
float('3')    # 回傳:3.0

2.4 complex()，復數

根據傳入引數創建一個新的復數

complex() # 當兩個引數都不提供時，回傳復數 0j，
complex('1+2j') # 傳入字串創建復數，輸出：(1+2j)
complex(1,2) # 傳入數值創建復數，輸出：(1+2j)

2.5 str()，字串轉換

回傳一個物件的字串表現形式(給用戶)

str()  # 回傳：''
str(None)  # 輸出：'None'
str('abc')    # 輸出：'abc'
str(123)    # 輸出：'123'

2.6 bytearray()，位元組陣列

根據傳入的引數創建一個新的位元組陣列，不怎么用；

bytearray('中文','utf-8')    # bytearray(b'\xe4\xb8\xad\xe6\x96\x87')

2.7 bytes()，不可變位元組陣列

根據傳入的引數創建一個新的不可變位元組陣列

bytes('中文','utf-8')    # b'\xe4\xb8\xad\xe6\x96\x87'

2.8 memoryview()，記憶體查看

根據傳入的引數創建一個新的記憶體查看物件

v = memoryview(b'abcefg')
v[1]    # 輸出：98
v[-1]   # 輸出：103

2.9 ord()，字符 --> ASC

回傳Unicode字符對應的整數

ord('a')    # 輸出：97

2.10 chr() ，ASC --> 字符

回傳整數所對應的Unicode字符

chr(97)    # 輸出：'a'

2.11 bin()，轉換成二進制

將整數轉換成2進制字串

bin(3)  # 輸出：'0b11'

2.12 oct()，轉換成八進制

將整數轉化成8進制數字串

oct(10)   # 輸出：'0o12'

2.13 hex()，轉換成十六進制

將整數轉換成16進制字串

hex(15)  # 輸出：'0xf'

2.14 tuple()，創建元組

根據傳入的引數創建一個新的元組

tuple()    # 不傳入引數，創建空元組; 輸出：()
tuple('121')  # 傳入可迭代物件，使用其元素創建新的元組；輸出: ('1', '2', '1')

2.15 list()，創建串列

根據傳入的引數創建一個新的串列

list() # 不傳入引數，創建空串列；輸出：[] 
list('abcd') # 傳入可迭代物件，使用其元素創建新的串列；輸出：['a', 'b', 'c', 'd']

2.16 dict()，創建字典

根據傳入的引數創建一個新的字典

dict() # 不傳入任何引數時，回傳空字典，回傳：{}
dict(a = 1,b = 2) #  可以傳入鍵值對創建字典，回傳：{'b': 2, 'a': 1}
dict(zip(['a','b'],[1,2])) # 可以傳入映射函式創建字典，回傳：{'b': 2, 'a': 1}
dict((('a',1),('b',2))) # 可以傳入可迭代物件創建字典，回傳：{'b': 2, 'a': 1}

2.17 set()，創建集合

根據傳入的引數創建一個新的集合

set() # 不傳入引數，創建空集合；輸出：set()
set(range(10)) # 傳入可迭代物件，創建集合；輸出：{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

2.18 frozenset()，創建不可變集合

根據傳入的引數創建一個新的不可變集合

a = frozenset(range(10))   # 輸出：frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})

2.19 enumerate()，創建列舉物件

根據可迭代物件創建列舉物件

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')]

2.20 range()，創建range物件

根據傳入的引數創建一個新的range物件

a = range(10)
b = range(1,10)
c = range(1,10,3)
a,b,c # 分別輸出a,b,c，輸出：(range(0, 10), range(1, 10), range(1, 10, 3))
list(a),list(b),list(c) # 分別輸出a,b,c的元素;輸出：([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [1, 2, 3, 4, 5, 6, 7, 8, 9], [1, 4, 7])

2.21 iter()，創建可迭代物件

根據傳入的引數創建一個新的可迭代物件

a = iter('abcd') #字串序列
print(a)    # 輸出：<str_iterator object at 0x03FB4FB0>
next(a)    # 輸出：'a'
next(a)    # 輸出：'b'
next(a)    # 輸出：'c'
next(a)    # 輸出：'d'
next(a)    # 由于后面沒有元素了，所以會報錯；報錯內容如下：
# Traceback (most recent call last):
#   File "<pyshell#29>", line 1, in <module>
#     next(a)
# StopIteration

2.22 slice()，創建切片物件

根據傳入的引數創建一個新的切片物件

slice(5)    # 輸出：slice(None, 5, None)
slice(2,5)    # 輸出：slice(2, 5, None)
slice(1,10,3)   # 輸出：slice(1, 10, 3)

2.23 super()，繼承

根據傳入的引數創建一個新的子類和父類關系的代理物件

#定義父類A
class A(object):
    def __init__(self):
        print('A.__init__')

#定義子類B，繼承A
class B(A):
    def __init__(self):
        print('B.__init__')
        super().__init__()

#super呼叫父類方法
b = B()

print(b)    # 輸出：
# B.__init__
# A.__init__
# <__main__.B object at 0x0000025B3398C160>

2.24 object()，創建物件

創建一個新的object物件

a = object()

3. 序列操作(8個)

3.1 all()，all運算

判斷可迭代物件的每個元素是否都為True值

all([1,2]) # 串列中每個元素邏輯值均為True，回傳True; 輸出：True
all([0,1,2]) #串列中0的邏輯值為False，回傳False；
all(()) # 空元組，輸出：True
all({}) # 空字典，輸出：True

3.2 any()，any運算

判斷可迭代物件的元素是否有為True值的元素

any([0,1,2]) # 串列元素有一個為True，則回傳True
any([0,0]) # 串列元素全部為False，則回傳False
any([]) # 空串列,輸出: False
any({}) # 空字典,輸出: False

3.3 filter()，過濾可迭代物件

使用指定方法過濾可迭代物件的元素

a = list(range(1,10)) #定義序列, 輸出 a 為：[1, 2, 3, 4, 5, 6, 7, 8, 9]
def if_odd(x): # 定義奇數判斷函式
    return x % 2 == 1

list(filter(if_odd , a)) # 篩選序列中的奇數，輸出：[1, 3, 5, 7, 9]

3.4 map()，對可迭代物件中每個元素運算

使用指定方法去作用傳入的每個可迭代物件的元素，生成新的可迭代物件

a = map(ord,'abcd')    # 此時，a為：<map object at 0x03994E50>
list(a)    # 對字串'abcd' 分別計算ord(), 輸出為：[97, 98, 99, 100]

3.5 next()，迭代物件中的下一個

回傳可迭代物件中的下一個元素值

a = iter('abcd') #字串序列
print(a)    # 輸出：<str_iterator object at 0x03FB4FB0>
next(a)    # 輸出：'a'
next(a)    # 輸出：'b'
next(a)    # 輸出：'c'
next(a)    # 輸出：'d'
next(a)    # 由于后面沒有元素了，所以會報錯；報錯內容如下：
# Traceback (most recent call last):
#   File "<pyshell#29>", line 1, in <module>
#     next(a)
# StopIteration

3.6 reversed()，返序

反轉序列生成新的可迭代物件

a = reversed(range(10)) # 傳入range物件
list(a) # 輸出：[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

3.7 sorted()，排列

對可迭代物件進行排序，回傳一個新的串列

a = ['a','b','d','c','B','A']
sorted(a)  # 默認按字符ascii碼排序，輸出：['A', 'B', 'a', 'b', 'c', 'd']
sorted(a,key = str.lower) # 轉換成小寫后再排序，'a'和'A'值一樣，'b'和'B'值一樣；輸出：['a', 'A', 'b', 'B', 'c', 'd']

3.8 zip()，串列 --> 字典

聚合傳入的每個迭代器中相同位置的元素，回傳一個新的元組型別迭代器

x = [1,2,3] #長度3
y = [4,5,6,7,8] #長度5
list(zip(x,y)) # 取最小長度3，輸出： [(1, 4), (2, 5), (3, 6)]

4. 物件操作(9個)

4.1 help()，幫助檔案

回傳物件的幫助資訊

help(list)
Help on class list in module builtins:

class list(object)
 |  list() -> new empty list
 |  list(iterable) -> new list initialized from iterable's items
 |
 |  Methods defined here:
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __contains__(self, key, /)
 |      Return key in self.
 |
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |
 |  __eq__(self, value, /)
 |      Return self==value.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getitem__(...)
 |      x.__getitem__(y) <==> x[y]
 |

4.2 dir()，屬性串列

回傳物件或者當前作用域內的屬性串列

dir(list)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

4.3 id()，唯一識別符號

回傳物件的唯一識別符號

a = 'kai'
id(a)   # 輸出：2332201834456

4.4 hash()，哈希值

獲取物件的哈希值

hash('good good study')  # 輸出：6003936519601954108

4.5 type()，物件型別

回傳物件的型別，或者根據傳入的引數創建一個新的型別

type(10)    # 輸出：<class 'int'>
type('10')     # 輸出：<class 'str'>

4.6 len()，物件長度

回傳物件的長度

len('abcd') # 字串,回傳：4
len(bytes('abcd','utf-8')) # 位元組陣列，回傳：4
len((1,2,3,4)) # 元組,回傳：4
len([1,2,3,4]) # 串列,回傳：4
len(range(1,5)) # range物件,回傳：4
len({'a':1,'b':2,'c':3,'d':4}) # 字典，,回傳：4
len({'a','b','c','d'}) # 集合，,回傳：4
len(frozenset('abcd')) #不可變集合，,回傳：4

4.7 ascii()，可列印字串

回傳物件的可列印表字串表現方式

ascii(1)     # 輸出：'1'
ascii('&')    # 輸出："'&'"
ascii(9000000)    # 輸出：'9000000'
ascii('中文') #非ascii字符    # 輸出："'\\u4e2d\\u6587'"

4.8 format()，格式化顯示

格式化顯示值

# 整形數值可以提供的引數有 'b' 'c' 'd' 'o' 'x' 'X' 'n' None
format(3,'b') #轉換成二進制，輸出：'11'
format(97,'c') # 轉換unicode成字符，輸出：'a'
format(11,'d') # 轉換成10進制，輸出：'11'
format(11,'o') # 轉換成8進制，輸出：'13'
format(11,'x') # 轉換成16進制 小寫字母表示，輸出：'b'
format(11,'X') # 轉換成16進制 大寫字母表示，輸出：'B'
format(11,'n') # 和d一樣，輸出：'11'
format(11) # 默認和d一樣，輸出：'11'

# 浮點數可以提供的引數有 'e' 'E' 'f' 'F' 'g' 'G' 'n' '%' None
format(314159267,'e') # 科學計數法，默認保留6位小數，輸出：'3.141593e+08'
format(314159267,'0.2e') # 科學計數法，指定保留2位小數，輸出：'3.14e+08'
format(314159267,'0.2E') # 科學計數法，指定保留2位小數，采用大寫E表示，輸出：'3.14E+08'
format(314159267,'f') # 小數點計數法，默認保留6位小數，輸出：'314159267.000000'
format(3.14159267000,'f') # 小數點計數法，默認保留6位小數，輸出：'3.141593'
format(3.14159267000,'0.8f') # 小數點計數法，指定保留8位小數，輸出：'3.14159267'
format(3.14159267000,'0.10f') # 小數點計數法，指定保留10位小數，輸出：'3.1415926700'
format(3.14e+1000000,'F')  # 小數點計數法，無窮大轉換成大小字母，輸出：'INF'

# g的格式化比較特殊，假設p為格式中指定的保留小數位數，先嘗試采用科學計數法格式化，得到冪指數exp，如果-4<=exp<p，則采用小數計數法，并保留p-1-exp位小數，否則按小數計數法計數，并按p-1保留小數位數
format(0.00003141566,'.1g') # p=1,exp=-5 ==》 -4<=exp<p不成立，按科學計數法計數，保留0位小數點，輸出：'3e-05'
format(0.00003141566,'.2g') # p=1,exp=-5 ==》 -4<=exp<p不成立，按科學計數法計數，保留1位小數點，輸出：'3.1e-05'
format(0.00003141566,'.3g') # p=1,exp=-5 ==》 -4<=exp<p不成立，按科學計數法計數，保留2位小數點，輸出：'3.14e-05'
format(0.00003141566,'.3G') # p=1,exp=-5 ==》 -4<=exp<p不成立，按科學計數法計數，保留0位小數點，E使用大寫，輸出：'3.14E-05'
format(3.1415926777,'.1g') # p=1,exp=0 ==》 -4<=exp<p成立，按小數計數法計數，保留0位小數點，輸出：'3'
format(3.1415926777,'.2g') # p=1,exp=0 ==》 -4<=exp<p成立，按小數計數法計數，保留1位小數點，輸出：'3.1'
format(3.1415926777,'.3g') #  p=1,exp=0 ==》 -4<=exp<p成立，按小數計數法計數，保留2位小數點，輸出：'3.14'
format(0.00003141566,'.1n') # 和g相同，輸出：'3e-05'
format(0.00003141566,'.3n') # 和g相同，輸出：'3.14e-05'
format(0.00003141566) # 和g相同，輸出：'3.141566e-05'

4.9 vars()，區域變數和值

回傳當前作用域內的區域變數和其值組成的字典，或者回傳物件的屬性串列

class A(object):
    pass
a = A()

print(a.__dict__)    # 輸出：{}
print(vars(a))    # 輸出：{}
a.name = 'Kim'
print(a.__dict__)    # 輸出：{'name': 'Kim'}
print(vars(a))    # 輸出：{'name': 'Kim'}

5. 反射操作(8個)

5.1 import()，動態匯入模塊

動態匯入模塊

index = __import__('index')
index.sayHello()

5.2 isinstance()，判斷實體

判斷物件是否是類或者型別元組中任意類元素的實體

isinstance(1,int)   # 輸出：True
isinstance(1,str)    # 輸出：False
isinstance(1,(int,str))    # 輸出：True

5.3 issubclass()，判斷子類

判斷類是否是另外一個類或者型別元組中任意類元素的子類

issubclass(bool,int)    # 輸出：True
issubclass(bool,str)      # 輸出：False
issubclass(bool,(str,int))     # 輸出：True

5.4 hasattr()，判斷屬性

檢查物件是否含有屬性

class Student:
    def __init__(self, name):
        self.name = name

s = Student('Aim')
hasattr(s, 'name')  # a含有name屬性,True
hasattr(s, 'age')   # a不含有age屬性,False

5.5 getattr()，獲取屬性

獲取物件的屬性值

class Student:
    def __init__(self, name):
        self.name = name

s = Student('Aim')
hasattr(s, 'name')  # a含有name屬性,True
hasattr(s, 'age')   # a不含有age屬性,False

getattr(s, 'name')   # 存在屬性name，回傳: Aim
getattr(s,'age',0)   # 不存在屬性age，但提供了默認值，回傳默認值0;
getattr(s,'age')     # 不存在屬性age，沒有默認值，則會報錯；AttributeError: 'Stduent' object has no attribute 'age'

5.6 setattr() ，設定屬性

設定物件的屬性值

class Student:
    def __init__(self,name):
        self.name = name

a = Student('Kim')
a.name    # 輸出：'Kim'
setattr(a,'name','Bob')    # 修改name
a.name   # 輸出：'Bob'

5.7 delattr()，洗掉屬性

洗掉物件的屬性

#定義類A
class A:
    def __init__(self,name):
        self.name = name
    def sayHello(self):
        print('hello',self.name)

#測驗屬性和方法
a.name    # 輸出：'小麥'
a.sayHello()    # 輸出： hello 小麥

#洗掉屬性
delattr(a,'name')
a.name    # 報錯：'A' object has no attribute 'name'

5.8 callable()，物件是否可呼叫

檢測物件是否可被呼叫

class B:  # 定義類B
    def __call__(self):
        print('instances are callable now.')

callable(B)  # 類B是可呼叫物件，輸出：True
b = B()  # 呼叫類B
callable(b)  # 實體b是可呼叫物件，輸出：True
b()  # 呼叫實體b成功，輸出：instances are callable now.

6. 作用域變數操作(2個)

6.1 globals()，全域變數 & 值

回傳當前作用域內的全域變數和其值組成的字典

globals()  # 直接可以呼叫，查看當前的全域變數和其值組成的字典；

6.2 locals()，區域變數 & 值

回傳當前作用域內的區域變數和其值組成的字典

locals()  # 直接可以呼叫，查看當前的區域變數和其值組成的字典；

7. 互動操作(2個)

7.1 print()，列印輸出

向標準輸出物件列印輸出

print(1,2,3)    # 輸出：1 2 3
print(1,2,3,sep = '+')    # 輸出：1+2+3
print(1,2,3,sep = '+',end = '=?')    # 輸出：1+2+3=?

7.2 input()，用戶輸入

讀取用戶輸入值

s = input('please input your name:')  # 代碼運行到此，就需要用戶進行輸入；

8. 檔案操作(1個)

8.1 open()，打開檔案

使用指定的模式和編碼打開檔案，回傳檔案讀寫物件

# t為文本讀寫，b為二進制讀寫
a = open('test.txt','rt')
a.read()    # 輸出：'some text'
a.close()

9. 編譯執行(4個)

9.1 compile()，編譯代碼

將字串編譯為代碼或者AST物件，使之能夠通過exec陳述句來執行或者eval進行求值

#流程陳述句使用exec
code1 = 'for i in range(0,10): print (i)'
compile1 = compile(code1,'','exec')
exec (compile1)

9.2 eval()，執行動態運算式

執行動態運算式求值

eval('1+2+3+4')     # 輸出：10

9.3 exec()，執行動態陳述句

執行動態陳述句塊

exec('a=1+2')  # 執行陳述句，

9.4 repr()，字串表現形式

回傳一個物件的字串表現形式(給解釋器)

a = 'some text'
str(a)    # 輸出：'some text'
repr(a)    # 輸出："'some text'"

10. 裝飾器(3個)

10.1 property()，屬性裝飾器

標示屬性的裝飾器

class C:
    def __init__(self):
        self._name = ''

    @property
    def name(self):
        """i'm the 'name' property."""
        return self._name

    @name.setter
    def name(self, value):
        if value is None:
            raise RuntimeError('name can not be None')
        else:
            self._name = value

c = C()

print(c.name)    # 訪問屬性,輸出為''

c.name = 'Kim'  # 設定屬性
print(c.name)  # 訪問屬性，輸出為：Kim

c.name = None  # 設定屬性時進行驗證
# 彈出錯誤： RuntimeError: name can not be None

del c.name  # 洗掉屬性，不提供deleter則不能洗掉

10.2 classmethod()，類裝飾器

標示方法為類方法的裝飾器

class C:
    @classmethod
    def f(cls, arg1):
        print(cls)
        print(arg1)

C.f('類物件呼叫類方法')
# 輸出如下：
# <class '__main__.C'>
# 類物件呼叫類方法

c = C()
c.f('類實體物件呼叫類方法')
# 輸出如下：
# <class '__main__.C'>
# 類實體物件呼叫類方法

10.3 staticmethod()，靜態方法裝飾器

標示方法為靜態方法的裝飾器

# 使用裝飾器定義靜態方法
class Student(object):
    def __init__(self, name):
        self.name = name

    @staticmethod
    def sayHello(lang):
        print(lang)
        if lang == 'en':
            print('Welcome!')
        else:
            print('你好！')

Student.sayHello('en')  # 類呼叫,'en'傳給了lang引數
# 輸出如下：
# en
# Welcome!

b = Student('Kim')
b.sayHello('zh')  # 類實體物件呼叫,'zh'傳給了lang引數
# 輸出如下：
# zh
# 你好

本文參考地址：https://blog.csdn.net/oaa608868/article/details/53506188?utm_medium=distribute.pc_relevant.none-task-blog-title-9&spm=1001.2101.3001.4242