Python 內置函數

1.　　abs()

# 對傳入參數取絕對值
print(abs(-4))
print(abs(7))

4
7

 

 

2.　　all()

# 判斷可迭代參數iterable中全部元素，都爲真返回True，不然返回False
# 0，空，False外都爲真
print(all(['a', 'b']))
print(all(['', 3]))
print(all((0, 3)))
print(all(['0', 1]))

True
False
False
True

 

 

3.　　any()

# 判斷可迭代參數iterable中全部元素，都爲假返回False，不然返回Ture
# 0，空，False外都爲真
print(any(['a', 'b']))
print(any(['', 3]))
print(any((0, False)))
print(any(['0', 1]))

True
True
False
True

 

 

4.　　ascii()

# ascii 函數相似repr()函數，返回一個表示對象的字符串
# 可是對於字符串中的非ASCII字符則返回經過repr()函數使用\x,\u或\U編碼的字符
# 生成相似Python2中repr()函數的返回值
print(ascii('runoob'))

'runoob'

 

 

5.　　bin()

# bin()返回一個整數int或者長整數long int 的二進制表示
print(bin(12))

0b1100

 

 

6.　　oct()

# oct()函數將一個整數轉換成8進制字符串
print(oct(8))

0o10

 

 

7.　　hex()

#hex()用於將10進制整數轉換成16進制，以字符串形式表示
print(hex(23))

0x17

 

 

8.　　bool()

# bool()函數用於將給定參數轉換成布爾類型
# 若是沒有參數則返回False，bool是int的子類
print(bool())
print(bool(0))
print(bool(1))
print(bool(False))

False
False
True
False

 

 

9.　　bytearray()

# bytearray()方法返回一個新字節數組
# 這個數組裏的元素是可變的，而且每一個元素的值範圍：0<=x<256
# 語法：class bytearray([source[,encoding[,errors]]])
# 若是source爲整數，則返回一個長度爲source的初始化數組
# 若是source爲字符串，則按照指定的encoding將字符串轉爲字節序列
# 若是source爲可迭代類型，則元素必須爲[0， 255]中的整數
# 若是source爲與buffer接口一致的對象，則此對象也能夠被用於初始化bytearray
# 若是沒有輸入任何參數，默認就是初始化數組爲0個元素
print(bytearray())
print(bytearray([1,2,3]))
print(bytearray('res','utf-8'))

bytearray(b'')
bytearray(b'\x01\x02\x03')
bytearray(b'res')

 

 

10.　　　　bytes()

# bytes()函數返回一個新的bytes對象，
# 該對象是一個0<=x<256區間的整數不可變序列
# 它是bytearray的不可變版本
# 語法： class bytes([source[,encoding[,errors]]])
# 若是source爲整數，則返回一個長度爲source的初始化數組
# 若是source爲字符串，則按照指定的encoding將字符串轉爲字節序列
# 若是source爲可迭代類型，則元素必須爲[0， 255]中的整數
# 若是source爲與buffer接口一致的對象，則此對象也能夠被用於初始化bytearray
# 若是沒有輸入任何參數，默認就是初始化數組爲0個元素
print(bytes([1,2,3]))
print(bytes('hello', 'ascii'))

b'\x01\x02\x03'
b'hello'

 

 

11.　　callable()

# callable(object)函數用於檢查一個對象是不是可調用的
# 若是返回True，object仍然可能調用失敗
# 但若是返回False，調用對象object絕對不會成功
print(callable(0))
print(callable('res'))
class A:
    def method(self):
        return 0
print(callable(A))
a = A()
print(callable(a))

False
False
True
False

 

 

12.　　chr()

# chr()用一個範圍在range(256)內的整數做爲參數，返回一個對應的字符
print(chr(97))
print(chr(100))

a
d

 

 

13.　　ord()

# ord()函數是chr()函數（對於8位的ASCII字符串）或unichr()函數（對於unicode對象）的配對函數
# 返回對應ASCII數值或unicode數值
# 若是所給Unicode字符超出了你的Python定義範圍。則會引起一個TypeError的異常
print(ord('a'))
print(ord('d'))

97
100

 

 

14.　　classmethod

# classmethod修飾符對應的函數不須要實例化，不須要self參數
# 可是第一個參數須要是表示自身類的class參數，
# 能夠來調用類的屬性，類的方法，實例化對象等
class A(object):
    bar = 1
    def func1(self):
        print('foo')
    @classmethod
    def func2(cls):
        print('func2')
        print(cls.bar)
        # 調用foo方法
        cls().func1()
# 不須要實例化
A.func2()

func2
1
foo

 

 

15.　　complile()

# compile()函數將一個字符串編譯爲字節代碼
# compile(score,filename,mode[,dont_inherit]])
# source--字符串或者AST(Abstract Syntax Trees)對象
# filename--代碼文件名稱，若是不是從文件讀取代碼則傳遞一些可辨認的值
# mode--指定編譯代碼的種類，能夠指定爲exec, eval, single
# flags--變量做用域，局部命名空間，若是被提供，能夠是任何映射對象
# flags和dont_inherit是用來控制編譯源碼時的標誌
str = 'for i in range(0, 10): print(i)'
c = compile(str,'','exec')
print(c)
exec (c)

<code object <module> at 0x0000000000538270, file "", line 1>
0
1
2
3
4
5
6
7
8
9

 

str = '3 * 4 + 5'
a = compile(str, '', 'eval')
print(eval(a))

17

 

 

16.　　complex()

# complex()函數用於建立一個值爲real+imag*j的複數或者轉化爲一個字符串或數爲複數
# 若是第一個參數爲字符串，則不須要指定第二個參數
# class complex([real[,img]])
# real--int,long,float或字符串
# imag--int，long，float
print(complex(1,2))
print(complex(1))

(1+2j)
(1+0j)

 

 

17.　　delattr()

# delattr(object, name)函數用於刪除屬性
# delatter(x,'foo')至關於del x.foo
# object--對象
# name--必須是對象的屬性
class C:
    x = 10
    y = 5
    z = 0
point1 = C()
print('x=',point1.x)
print('y=',point1.y)
print('z=',point1.z)
delattr(C,'z')
print('--刪除z屬性後--')
print('x=',point1.x)
print('y=',point1.y)

x= 10
y= 5
z= 0
--刪除z屬性後--
x= 10
y= 5

 

 

18.　　dir()

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

 

 

19.　　divmod()

# divmod()返回一個包含商和餘數的元組(a//b, a%b)
print(divmod(7,2))
print(divmod(8,2))

(3, 1)
(4, 0)

 

 

20.　　enumerate()

# enumerate()用於將一個可遍歷的數據對象（列表、元組、字符串）組合爲一個索引序列
# 同時列出數據和數據下標，通常用在for循環當中
# enumerate(sequence, [start=0])
# sequence--一個序列、迭代器或其餘支持迭代的對象
# start--下標的起始位置
print(list(enumerate(['a', 'b', 'c'])))

[(0, 'a'), (1, 'b'), (2, 'c')]

 

 

21.　　eval

#eval()用來執行一個字符串表達式，並返回表達式的值
# eval(expression[,globals[,locals]])
# expression--表達式
# globals--變量做用域，全局命名空間，若是被提供，則必須是一個字典對象
# locals--變量做用域，局部命名空間，若是被提供，能夠是任何映射對象
print(eval('3 * 2'))
print(eval('3''*''2'))

6
6

 

 

22.　　exec()

# exec()執行儲存在字符串或文件中的Python語句
# 至關於eval，exec能夠執行更復雜的Python代碼
# exec(object[,globals[,locals]])
# object--必選參數，表示須要被指定的Python代碼，它必須是字符串或code對象
# 若是object是一個字符串，該字符串會先被解析爲一組Python語句，而後在執行（除非發生錯誤）
# 若是object是一個code對象，那麼它只是被簡單地執行
# globals--可選參數，表示全局命名空間（存放全局變量），若是被提供，則必須是一個字典對象
# locals--可選參數，表示當前局部命名空間（存放局部變量），若是被提供，能夠是任何映射對象
# 若是該參數被忽略，那麼它將會取與globals相同的值
exec('''for i in range(5):
    print('iter time:%d'%i)
''')

iter time:0
iter time:1
iter time:2
iter time:3
iter time:4

 

 

23.　　float()

# float()將整數和字符串轉換成浮點數
print(float(10))
print(float('10'))

10.0
10.0

 

 

24.　　frozenset()

#frozenset()返回一個凍結的集合，凍結後集合不能添加或刪除任何元素
# frozenset（[iterable]）
# iterable--可迭代對象（字典、元組、列表等）
print(frozenset(range(5)))
print(frozenset([1,2,3]))

frozenset({0, 1, 2, 3, 4})
frozenset({1, 2, 3})

 

 

 

25.　　getattr

# getattr()返回一個對象屬性值
# getattr(object,name[,default])
# object--對象
# name--字符串，對象屬性
# default--默認返回值，若是不提供該參數，在沒有對應屬性時，將觸發AttributeError
class A(object):
    bar = 1
a = A()
print(getattr(a, 'bar'))

 1

 

 

26.　　hasattr()

# hasattr()用於判斷對象是否包含對應的屬性
# hasattr(object,name)
# object--對象
# name--字符串，屬性名
# 若是對象有該屬性返回True，不然返回False
class C:
    x = 10
    y = 2
    z = 5
point1 = C
print(hasattr(point1, 'x'))
print(hasattr(point1, 'n'))

True
False

 

 

27.　　hash()

# 獲取一個對象（字符串或數值等）的hash值
print(hash('test'))
print(hash(str([1, 2, 3])))
print(hash(str({'1':'a'})))

-5407184177310519943
4889424586042814161
1115203415993729361

 

 

28.　　help()

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

顯示str數據類型的幫助

 

 

29.　　id()

# id()用於獲取對象的內存地址
a = '12'
print(id(a))

30649960

 

 

30.　　isinstance()

# isinstance()判斷一個對象是不是一個已知類型，相似type()
# isinstance()與type()區別：
#type()不會認爲子類是一種父類類型，不考慮繼承關係
# isinstance()會認爲子類是父類類型，考慮繼承關係
# 若是要判斷兩個類型是否相同推薦使用isinstance()
# isinstance(object,classinfo)
# classinfo--能夠是直接或間接類名，基本類型或者由他們組成的元組
# 若是對象的類型與參數二的類型（classinfo）相同則返回True，不然返回False
a = 2
print(isinstance(a, int))
print(isinstance(a, str))

True
False

 

 

31.　　issubclass()

# issubclass()方法用於判斷class是不是類型參數classinfo的子類
# issubclass(class, classinfo)
# 若是class是classinfo的子類返回True，不然返回False
class A:
    pass
class B(A):
    pass
print(issubclass(B, A))

True

 

 

32.　　locals()

# locals()以字典類型返回當前位置的所有局部變量
# 對於函數，方法lambda函式，類，以及實現了__call__方法的類實例，它都返回True
def ru(arg):
    z = 1
    print(locals())
ru(4)

{'arg': 4, 'z': 1}

 

 

33.　　max()

# 函數max的終極用法
people = [
    {'name': 'ax', 'age': 100},
    {'name': 'wq', 'age': 500},
    {'name': 'lf', 'age': 19}
]
print(max(people,key=lambda dic:dic['age']))
# 解釋：比較列表people裏元素的大小，people裏的元素是字典
# 字典是沒有辦法直接比較的，用lambda定義max的比較方法key
# key的意思是比較age的值

{'name': 'wq', 'age': 500}

 

 

34.　　min()

用法與max（）相同

 

 

35.　　memoryview()

# memoryview(object)返回給定參數的內存查看對象
# 內存查看對象，是指支持緩衝區協議的數據進行包裝，再不須要複製對象基礎上容許Python代碼訪問
v = memoryview(bytearray('abcd','utf-8'))
print(v[1])
print(v[-1])
print(v[1:4].tobytes())

98
100
b'bcd'

 

 

36.　　next()

# next(iterator[,default])返回迭代器的下一個項目
# iterator--可迭代對象
# default--可選，用於設置在下一個元素時返回該默認值
# 若是不設置，有沒有下一個元素則會觸發Stoplteration異常
it = iter([1, 2, 3])
while True:
    try:
        x = next(it)
        print(x)
    except StopIteration:
        break

1
2
3

 

 

37.　　pow()

# pow()方法返回X的Y次冪的值
import math
print(math.pow(10,2))

100.0

 

 

38.　　repr()

# repr(object)將對象轉化爲供解釋器讀取的形式
# 返回一個對象的string格式
s = 'ruuu'
print(repr(s))
dict1 = {'re': 1, 'ds': 2}
print(repr(dict1))
print(type(repr(dict1)))

'ruuu'
{'re': 1, 'ds': 2}
<class 'str'>

 

 

39.　　reversed()

# reversed(seq)返回一個反轉的迭代器
# seq--要轉換的序列，能夠是tupe，string、list、range
str1 = 'root'
print(list(reversed(str1)))

['t', 'o', 'o', 'r']

 

 

40.　　round()

# round(x[,n])返回浮點數X的四捨五入，默認值爲0
print(round(1.234))
print('round(1.567):',round(1.567))

1
round(1.567): 2

 

 

41.　　setattr

#setattr(object, name, value)對應函數getatt()
# 用於設置屬性值，該屬性必須存在
# object--對象
# name--字符串，對象屬性
# value--屬性值
class A(object):
    bar = 1
a = A()
print(getattr(a, 'bar'))
# 獲取屬性bar
setattr(a, 'bar', 5)
#設置屬性bar值 
print(a.bar)

1
5

 

 

42.　　slice()

# slice()實現切片對象，主要用在切片操做函數裏的參數傳遞
# class slice(start,stop[,step])
# step--間距
myslice = slice(1, 6, 2)
print(myslice)
arr = [1, 2, 3, 4, 5, 6]
print(arr)
print(arr[myslice])

slice(1, 6, 2)
[1, 2, 3, 4, 5, 6]
[2, 4, 6]

 

 

43.　　sorted()

# sorted()對全部可迭代對象進行排序操做
# list的sort方法返回的是對已經存在的列表進行操做
# 內建函數sorted方法返回的是一個新的list，而不是在原來的基礎上的操做
# sorted(iterable, key = None, reverse = False)
# iterable--可迭代對象
# key--主要用來進行比較元素，只有一個參數，具體的函數的參數就是取自於可迭代對象，指定可迭代對象的一個元素來進行排序
# reverse=True 降序， reverse=False 升序（默認）
list_1 = [ 2, 1, 3, 5, 4]
list_2 = sorted(list_1)
print(list_2)
print(list_1)
list_3 = [4, 2, 6, 1,]
list_4 = list_3.sort()
print(list_3)
print(list_4)

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

 

 

44.　　staticmethod()

#staticmethod(function)返回函數的靜態方法
# 該方法不強制要求傳遞參數
class C(object):
    @staticmethod
    def f():
        print('root')
# 靜態方法無需實例化
C.f()
co = C()
# 也能夠實例化後調用
co.f()

root
root

 

 

45.　　vars()

# vars()返回對下那個object的屬性和屬性值的字典對象
print(vars())
class Ro:
    a = 1
print(vars(Ro))

 

 

46.　　zip()

# zip()用於將可迭代對象做爲參數，將對象中對應的元素打包成一個元組
# 而後返回由這些元組組成的對象，這樣作的好處是節約內存
# 可使用list()轉換來輸出列表
# 若是各個迭代器的元素個數不一致，則返回列表長度與最短的對象相同
# 利用*號操做符，能夠將元組解壓爲列表
a = [1, 2, 3]
bb = ['a', 'b', 'c']
x1 = ['a1', 'd3', 'bv', 11]
zipped = zip(a,bb)
print(zipped)
print(list(zipped))
print(list(zip(a,x1)))
# 與zip相反，*zip可理解爲解壓，返回二維矩陣
a1,a2 = zip(*zip(a,bb))
print(list(a1))
print(list(a2))

<zip object at 0x0000000002378288>
[(1, 'a'), (2, 'b'), (3, 'c')]
[(1, 'a1'), (2, 'd3'), (3, 'bv')]
[1, 2, 3]
['a', 'b', 'c']

 

 

47.　　__import__

# __import__(name[,globals[,locals[,fromlist[,level]]]])
# __import__('a')
# 導入字符串形式的模塊 a.py