Python 常用內置函數


Python 常用內置函數如下:

 

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

print( abs(-45) )                  # 返回 45

print("abs(0.2):",abs(0.2)) # 返回 abs(0.2): 0.2

 

2. all() 函數用於判斷給定的參數中的所有元素是否都為 TRUE,如果是返回 True,否則返回 False。元素除了是 0、空、None、False 外都算 True;空元組、空列表返回值為True。

print( all( [0.1,1,-1] )  )        # 返回 True
print( all( (None,1) )  )          # 返回 False(其中一個元素為None)
print( all( [0,1,-1] )  )          # 返回 False(其中一個元素為0)
print( all( [" ","a",""] )  )      # 返回 False(第三個元素為空)

 

3.  any() 函數用於判斷給定的參數是否全部為False,是則返回False,如果有一個為True,則返回True。 元素除了是 0、空、False外都算 TRUE。

# 參數全部不為 0、空、FALSE
print(any("-45"))                 #  True
print(any(["-45"]))               #  True
print( any( ("0","ab","") ) )     #  True(注意:第一個參數0加了雙引號,表示為一個字符串)

# 參數全部為 0、空、False
print( any( (0,"") ) )            #  False
print( any( (0,"",False) ) )      #  False

 

4. bin()函數返回一個整數int或者長整數long int的二進制表示。

print( bin(10) )        #  0b1010

print( bin(133) ) # 0b10000101

 

5. bool() 函數用於將給定參數轉換為布爾類型,如果參數不為空或不為0,返回True;參數為0或沒有參數,返回False。

print( bool(10) )                 #  True
print( bool([0]) )                #  True
print( bool(["123","s",0]) )      #  True

print( bool(0) )                  #  False
print( bool() )                   #  False

 

6. bytearray()方法返回一個新字節數組。這個數組里的元素是可變的,並且每個元素的值范圍: 0 <= x < 256(即0-255)。即bytearray()是可修改的二進制字節格式。

1 b = bytearray("abcd",encoding="utf-8")
2 print(b[0])            #  返回數字97,即把“abcd”的“a"對應的ascii碼打印出來了
3 b[0] = 99              #  把字符串第一個字節修改為99(即對應字母為“c”)
4 print(b)               #  返回:bytearray(b'cbcd')---第一個字節a已被修改為c

 

7. callable()函數用於檢查一個對象是否可調用的。對於函數、方法、lambda函式、類以及實現了 __call__ 方法的類實例, 它都返回 True。(可以加括號的都可以調用)

1 def sayhi():pass                 #  先定義一個函數sayhi()
2 print( callable( sayhi ) )       #  True
1 a = 1
2 print( callable( a ) )           #  False

 

8. chr()函數用一個范圍在range(256)內(即0~255)的整數作參數,返回一個對應的ASCII數值。

# 把數字98在ascii碼中對應的字符打印出來
print( chr(98) )                   #  返回:b

 

9. dict()函數用來將元組/列表轉換為字典格式。

print(dict(a='a', b='b', t='t'))
#  返回:{'b': 'b', 'a': 'a', 't': 't'}

print(dict( [ ('one',1),('two',2),('three',3) ]  ) )   # 可迭代對象方式來構造字典
#  返回:{'two': 2, 'one': 1, 'three': 3}

print(dict(zip(["1","2","3"],["a","b","c"])))     # 映射函數方式來構造字典
#  返回:{'2': 'b', '3': 'c', '1': 'a'}

 

10. dir()函數不帶參數時,返回當前范圍內的變量、方法和定義的類型列表;帶參數時,返回參數的屬性、方法列表。

print( dir() )           #  獲得當前模塊的屬性列表
#  返回:['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__']

print( dir([]) ) # 查看列表的方法 # 返回:['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__',
'__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__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']

 

11. divmod() 函數把除數和余數運算結果結合起來,返回一個包含商和余數的元組(商x,余數y)。

print( divmod(5,2) )    #  返回:(2, 1)
print( divmod(5,1) )    #  返回:(5, 0)
print( divmod(5,3) )    #  返回:(1, 2)

 

12. enumerate() 函數用於將一個可遍歷的數據對象(如列表、元組或字符串)組合為一個索引序列,同時列出數據和數據下標,一般用在 for 循環當中。Python 2.3. 以上版本可用,2.6 添加 start 參數。

1 seasons = ['Spring', 'Summer', 'Fall', 'Winter']    
2 print(list(enumerate(seasons)))                  
# 返回:[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
1 print(list(enumerate(seasons, start=1)) )         # 下標從 1 開始 
# 返回:[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

 

13. eval() 函數用來執行一個字符串表達式,並返回表達式的值。 

print(eval('3 * 2'))          # 6
1 x = 7
2 print(eval('3 + x'))        # 10

 

14. exec() 執行儲存在字符串或文件中的Python語句,相比於eval,exec可以執行更復雜的Python代碼。 

exec("print('Hello World')")        # 執行簡單的字符串
# Hello World
exec("for i in range(5): print('iter time is %d'%i)")      # 執行復雜的for循環
# iter time is 0
# iter time is 1
# iter time is 2
# iter time is 3
# iter time is 4

 

15.  filter()用於過濾序列,過濾掉不符合條件的元素,返回一個迭代器對象,可用list()來轉換為列表。 

注意: filter()接收兩個參數,第一個為函數,第二個為序列,序列的每個元素作為參數傳遞給函數進行判斷,然后返回True或 False,最后將返回 True 的元素放到新列表中。

res = filter(lambda n:n>5,range(10))   # 過濾掉0-9中不符合n>5的數據
for i in res:                          # 循環打印符合n>5的數據
    print(i)  
    
# 5
# 6
# 7
# 8
# 9

 

16. format()是一種格式化字符串的函數 ,基本語法是通過 {} 和 : 來代替以前的 % 。format 函數可以接受不限個參數,位置可以不按順序。

# 位置映射

print( "{}{}".format('a','1') )
# a1

print('name:{n},url:{u}'.format(n='alex',u='www.xxxxx.com'))
# name:alex,url:www.xxxxx.com
# 元素訪問

print( "{0[0]},{0[1]}".format(('baidu','com')) )                # 按順序
# baidu,com

print( "{0[2]},{0[0]},{0[1]}".format(('baidu','com','www')) )   # 不按順序
# www,baidu,com

 

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

print(float(1))
# 1.0

print(float(0.1))
# 0.1

print(float('123'))
# 123.0

 

18. frozenset() 返回一個凍結的集合(一個無序的不重復元素序列),凍結后集合不能再添加或刪除任何元素。

1 a = frozenset(range(10))             # 先創建一個凍結集合
2 print(a)                 
3 # frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
4 
5 del a[0]                             # 試圖刪除凍結集合a中的元素,報錯
6 # TypeError: 'frozenset' object doesn't support item deletion
1 b = frozenset("happy")               # 將字符串轉換成一個集合
2 print(b)
3 # frozenset({'a', 'h', 'p', 'y'})    # 無序不重復
1 c = frozenset()                      # 創建一個空集合
2 print(c)
3 # frozenset()                        # 如果不提供任何參數,默認會生成空集合

 

19. globals() 函數會以字典格式返回當前位置的全部全局變量。

print(globals())     # globals 函數返回一個全局變量的字典,包括所有導入的變量。

#  {'__file__': 'C:/Users/Administrator/PycharmProjects/test/day4/內置函數-globals().py', '__spec__': None, '__doc__': None, '__package__': None,
'a': 'append', '__cached__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000000000666B00>,
'__builtins__': <module 'builtins' (built-in)>, '__name__': '__main__'}

 

20. hasattr() 函數用於判斷對象是否包含對應的屬性。如果對象有該屬性返回 True,否則返回 False。

1 class t:
2     a = 1
3     b = 2
4     c = 3
5 
6 p = t()
7 print(hasattr(p,'a'))    # True
8 print(hasattr(p,'b'))    # True
9 print(hasattr(p,'x'))    # False

 

21. hash() 用於獲取一個對象(數字或者字符串等)的哈希值。不能直接應用於 list、set、dictionary。

注意:在 hash() 對對象使用時,所得的結果不僅和對象的內容有關,還和對象的 id(),也就是內存地址有關。

print(hash(1))                  # 1
print(hash(20000))              # 20000
print(hash('123'))              # -6436280630278763230
print(hash('ab12'))             # 5468785079765213470
print(hash('ab12'))             # 5468785079765213470

 

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

help('sys')             # 查看 sys 模塊的幫助
help('str')             # 查看 str 數據類型的幫助
a = [1,2,3]
help(a)                 # 查看列表 list 幫助信息
help(a.append)          # 顯示list的append方法的幫助

 

23. hex() 函數用於將一個整數轉換為十六進制數。返回一個字符串,以0x開頭。

print(hex(1))        # 0x1

print(hex(-256))     # -0x100
print(type(hex(-256)))    #<class 'str'>

 

24. id()函數用於獲取對象的內存地址。

a = "123"                             # 字符串
print(id(a))                          # 13870392

b = [1,2,3]                           # 列表
print(id(b))                          # 7184328

c = {'num1':1,'num2':2,'num3':3}       # 字典
print(id(c))                           # 6923656

 

25. input() 函數接受一個標准輸入數據,返回為 string 類型。這個函數是最最常用的了。在Python3.x中 raw_input() 和 input() 進行了整合,僅保留了input( )函數。

a = '123456'
b = input("username:")

if b == a :            # 如果b的輸入數據等於a存儲的數據,打印”right“
    print("right")
else:                  # 否則打印”wrong“
    print("wrong")

    

 

26. int() 函數用於將一個字符串或數字轉換為整型。

print(int())                # 不傳入參數時,得到結果0
print(int(0.5))             # 去掉小數部分,得到結果0
print(int(3))               # 得到結果3
print(int('0xa',16))        # 十六進制數“0xa”轉換成十進制整數,得到結果10
print(int('00010',2))       # 二進制數“00010”轉換成十進制整數,得到結果2

 

 27. isinstance() 函數來判斷一個對象是否是一個已知的類型,返回布爾值。類似 type()。

a = 2

print(isinstance(a,int))                   #  True
print(isinstance(a,str))                   #  False
print(isinstance(a,(str,tuple,dict)))      #  False
print(isinstance(a,(str,tuple,int)))       # 是元組其中的一個則返回True
  • isinstance() 與 type() 區別:

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

示例:
 1 class A:
 2     pass
 3 
 4 class B(A):
 5     pass
 6 
 7 print(isinstance(A(),A))    # True
 8 print( type(A()) == A )     # True
 9 
10 print(isinstance(B(),A))    # True
11 print( type(B()) == A )     # False   --type()不考慮繼承關系

 

28. issubclass()用於判斷參數class是否是類型參數classinfo的子類,是則返回True,否則返回False。

      語法:issubclass(class,classinfo)。 

1 class a:
2     pass
3 class b(a):     # b繼承了a,即b是a的子類
4     pass
5 
6 print(issubclass(a,b))    # 判斷 a 是 b 的子類?
7 # False
8 print(issubclass(b,a))    # 判斷 b 是 a 的子類?
9 # True

 

 29. iter() 函數用來生成迭代器。list、tuple等都是可迭代對象,我們可以通過iter()函數獲取這些可迭代對象的迭代器,然后可以對獲取到的迭代器不斷用next()函數來獲取下條數據。iter()函數實際上就是調了可迭代對象的 __iter__ 方法。

# 注意:當已經迭代完最后一個數據之后,再次調用next()函數會拋出 StopIteration的異常,來告訴我們所有數據都已迭代完成。 

 1 it = [1,2,3]
 2 it_list = iter(it)
 3 
 4 print(next(it_list))
 5 # 1
 6 print(next(it_list))
 7 # 2
 8 print(next(it_list))
 9 # 3
10 print(next(it_list))
11 # StopIteration

 

30. len() 方法返回對象(字符、列表、元組等)長度或元素個數。

# len()方法返回對象(字符、列表、元組等)長度或元素個數。
print(len('1234'))              # 字符串,返回字符長度4
print(len(['1234','asd',1]))    # 列表,返回元素個數3
print(len((1,2,3,4,50)))        # 元組,返回元素個數5

print(len(12))                  # 注意:整數類型不適用,否則報錯
# TypeError: object of type 'int' has no len()

 

 31.  list() 方法用於將元組轉換為列表。

 注:元組與列表是非常類似的,區別在於元組的元素值不能修改,元組是放在括號中,列表是放於方括號中。

print( list((1,2,3)))           # [1, 2, 3]

 

32. map()接收函數f和list,並通過把函數f依次作用在list的每個元素上,得到一個新的list並返回。

 1 res = map(lambda n: n*2,[0,1,2,3,4,5])    # 使用 lambda 匿名函數
 2 for i in res:
 3     print(i)
 4 
 5 # 返回以下數據:
 6 # 0
 7 # 2
 8 # 4
 9 # 6
10 # 8
11 # 10
 1 # 提供了兩個列表,對相同位置的列表數據進行相加
 2 
 3 a = map(lambda x,y : x+y,[1,2,3,4,5],[2,4,6,8,10])
 4 for i in a:
 5     print(i)
 6 
 7 # 返回以下數據:
 8 # 3
 9 # 6
10 # 9
11 # 12
12 # 15

 

33. max()函數返回給定參數的最大值,參數可以為序列。

print("max(10,20,30):" , max(10,20,30) )
# max(10,20,30): 30

print("max(10,-2,3.4):" , max(10,-2,3.4) )
# max(10,-2,3.4): 10

print("max({'b':2,'a':1,'c':0}):" , max({'b':2,'a':1,'c':0}) )   # 字典,默認按key排序
# max({'b':2,'a':1,'c':0}): c

 

34. min()函數返回給定參數的最小值,參數可以為序列。

print("min(10,20,30):" , min(10,20,30) )
# min(10,20,30): 10

print("min(10,-2,3.4):" , min(10,-2,3.4) )
# min(10,-2,3.4): -2

print("min({'b':2,'a':1,'c':0}):" , min({'b':2,'a':1,'c':0}) )   # 字典,默認按key排序
# min({'b':2,'a':1,'c':0}): a

 

35. next() 返回迭代器的下一個項目。

 1 # 首先獲得Iterator對象:
 2 it = iter([1,2,3,4,5])
 3 
 4 # 循環:
 5 while True:
 6     try:
 7         # 獲得下一個值:
 8         x = next(it)
 9         print(x)
10     except StopIteration:
11         break
12     # 遇到StopIteration就退出循環

 

36. oct() 函數將一個整數轉換成八進制字符串。

print( oct(10) )          # 0o12
print( oct(255) )         # 0o377
print( oct(-6655) )       # -0o14777

 

37. open() 函數用於打開一個文件,創建一個 file 對象,相關的方法才可以調用它進行讀寫。

f = open("test1.txt","w",encoding="utf-8")    # 創建一個file
print(f.write("abc"))

f = open("test1.txt","r",encoding="utf-8")    # 讀取文件數據
print(f.read())

 

38. ord()函數是chr()的配對函數,它以一個字符(長度為1的字符串)作為參數,返回對應的ASCII數值,或者Unicode數值,如果所給的 Unicode 字符超出了定義范圍,則會引發一個 TypeError 的異常。

# 把字符 b(長度為1的字符串)作為參數在ascii碼中對應的字符打印出來

print( ord('b') )    # 返回:98
print( ord('%') )    # 返回:37

 

39. pow()函數返回x的y次方的值。

注意:pow()通過內置的方法直接調用,內置方法會把參數作為整型,而 math 模塊則會把參數轉換為 float。

# 通過內置的方法直接調用

print( pow(2,2) )          #  2的二次方
# 4
print( pow(2,-2) )         #  2的負二次方
# 0.5
1 # 導入math模塊
2 
3 import math
4 
5 print(math.pow(3,2))   # 3的負二次方
6 # 9.0

 

40. print()用於打印輸出,最常見的一個函數。print 在Python3.x是一個函數,但在Python2.x版本只是一個關鍵字。

print( abs(-45) )           # 45
print("Hello World!")       # Hello World!
print([1,2,3])              # [1, 2, 3]

 

41. range() 函數可創建一個整數列表,一般用在 for 循環中。語法:range(start, stop[, step])

for i in range(10):
    print(i)            # 依次打印數字0-9

for a in range(0,10,2):     # 步長為2
    print(a)            # 打印0,2,4,6,8

for b in range(10, 0, -2):  # 步長為-2
    print(b)            # 打印10,8,6,4,2

 

42. reduce() 函數會對參數序列中元素進行累積。在Python3 ,reduce()被放置在functools模塊里,如果想要使用它,需要先引入functools模塊。

import functools

a = functools.reduce(lambda x,y:x+y,[1,2,3])
print(a)           # 6 , 即從1加到3

b = functools.reduce(lambda x,y:x+y,range(10))
print(b)           # 45 , 即從0加到9

 

43. repr() 函數將對象轉化為供解釋器讀取的形式。返回一個對象的 string 格式。

r = repr((1,2,3))
print( r )              # (1, 2, 3)
print( type(r) )        #  <class 'str'>

dict = repr({'a':1,'b':2,'c':3})
print( dict )    # {'c': 3, 'a': 1, 'b': 2}
print( type(dict) )    # <class 'str'>

 

44. reversed() 函數返回一個反轉的迭代器。 reversed(seq)要轉換的序列,可以是 tuple, string, list 或 range。

rev = reversed( [1,2,3,4,5] )       # 列表
print(list(rev))
# [5, 4, 3, 2, 1]

rev1 = reversed( "school" )         # 元組
print(tuple(rev1))
# ('l', 'o', 'o', 'h', 'c', 's')

rev2 = reversed(range(10))          # range
print(list(rev2))
# [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

 

45. round() 方法返回浮點數x的四舍五入值。(除非對精確度沒什么要求,否則盡量避開用round()函數)

print( round(4.3))         # 只有一個參數時,默認保留到整數
# 4

print( round(2.678,2))     #  保留2位小數
#  2.68

print( round(5/3,3))     #  運算表達式並保留3位小數
#  1.667

 

46. set() 函數創建一個無序不重復元素集,可進行關系測試,刪除重復數據,還可以計算交集、差集、並集等。

1 a = set('school')
2 print(a)            # 重復的被刪除,得到結果:{'o', 'c', 's', 'l', 'h'}
1 b = set([1,2,3,4,5])
2 c = set([2,4,6,8,10])
3 
4 print(b & c)     # 交集,得到結果為{2, 4}
5 print(b | c)     # 並集,得到結果為{1, 2, 3, 4, 5, 6, 8, 10}
6 print(b - c)     # 差集,得到結果為{1, 3, 5}

 

47. slice() 函數實現切片對象,主要用在切片操作函數里的參數傳遞。

a = slice("school")
print(a)            # slice(None, 'school', None)

 

 48. sorted() 函數對所有可迭代的對象進行排序(默認升序)操作。

# 對列表進行排序
print(sorted([1,2,5,30,4,22]))    # [1, 2, 4, 5, 22, 30]

# 對字典進行排序
dict = {23:42,1:0,98:46,47:-28}
print( sorted(dict) )                     # 只對key排序
# [1, 23, 47, 98]

print( sorted(dict.items()) )             # 默認按key進行排序
# [(1, 0), (23, 42), (47, -28), (98, 46)]

print( sorted(dict.items(),key=lambda x:x[1]) )      # 用匿名函數實現按value進行排序
# [(47, -28), (1, 0), (23, 42), (98, 46)]
# 利用key進行倒序排序
test1 = [1,2,5,30,4,22]
r_list = sorted(test1,key=lambda x:x*-1)
print(r_list)                     # [30, 22, 5, 4, 2, 1]


# 要進行反向排序,也可以通過傳入第三個參數 reverse=True:
test2 = [1,2,5,30,4,22]
print(sorted(test2,reverse=True))    # [30, 22, 5, 4, 2, 1]

 

49. str() 函數將對象轉化為string格式。

1 a =  str((1,2,3))
2 print(a)            # 打印a,得到結果(1, 2, 3)
3 print(type(a))      # 打印a的類型,得到結果 <class 'str'>

 

 50. sum()函數對參數進行求和計算。

print( sum([1,2,3]) )        #  6
print( sum([1,2,3],4) )      #  列表計算總和后再加4,得到結果10
print( sum( (1,2,3),4 ) )    #  元組計算總和后再加4,得到結果10

 

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

# 注:元組與列表是非常類似的,區別在於元組的元素值不能修改,元組是放在括號中,列表是放於方括號中。

print( tuple([1, 2, 3]))     # (1,2,3)

 

 52. type() 函數如果你只有第一個參數則返回對象的類型,三個參數返回新的類型對象。

print(type(1))                   # <class 'int'>
print(type("123"))               # <class 'str'>
print(type([123,456]))           # <class 'list'>
print(type( (123,456) ) )        # <class 'tuple'>
print(type({'a':1,'b':2}) )      # <class 'dict'>

 

 53. zip() 函數用於將可迭代的對象作為參數,將對象中對應的元素打包成一個個元組,然后返回由這些元組組成的對象,這樣做的好處是節約了不少的內存。可以使用 list() 轉換來輸出列表。如果各個迭代器的元素個數不一致,則返回列表長度與最短的對象相同。利用 * 號操作符,可以將元組解壓為列表。

 1 a = [1,2,3]
 2 b = [4,5,6]
 3 c = [7,8,9,10]
 4 
 5 for i in zip(a,b):
 6     print(i)
 7 
 8 # 返回結果:
 9 # (1, 4)
10 # (2, 5)
11 # (3, 6)
12 
13 print(list(zip(a,b)))       # list() 轉換為列表
14 # [(1, 4), (2, 5), (3, 6)]
15 
16 print(list(zip(b,c)))       # 元素個數與最短的列表一致
17 # [(4, 7), (5, 8), (6, 9)]
18 
19 a1,a2 = zip(*zip(a,b))      #  用zip(*)解壓
20 print(list(a1))         # [1, 2, 3]
21 print(list(a2))         # [4, 5, 6]

 

54. __import__() 函數用於動態加載類和函數。如果一個模塊經常變化就可以使用 __import__() 來動態載入。

__import__('decorator')

# 返回結果如下:
# in the bar
# the func run time is 3.000171661376953
# 首先獲得Iterator對象:
it = iter([1,2,3,4,5])
# 循環:
while True:
try:
# 獲得下一個值:
x = next(it)
print(x)
except StopIteration:
break
# 遇到StopIteration就退出循環


免責聲明!

本站轉載的文章為個人學習借鑒使用,本站對版權不負任何法律責任。如果侵犯了您的隱私權益,請聯系本站郵箱yoyou2525@163.com刪除。



 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM