python以內置函數（一）

時間 2019-11-12

標籤 python 內置函數欄目 Python 简体版

原文原文鏈接

1、內置函數一python

一、內置函數總覽

內置函數
abs()	dict()	help()	min()	setattr()
all()	dir()	hex()	next()	slice()
any()	divmod()	id()	object()	sorted()
ascii()	enumerate()	input()	oct()	staticmethod()
bin()	eval()	int()	open()	str()
bool()	exec()	isinstance()	ord()	sum()
bytearray()	filter()	issubclass()	pow()	super()
bytes()	float()	iter()	print()	tuple()
callable()	format()	len()	property()	type()
chr()	frozenset()	list()	range()	vars()
classmethod()	getattr()	locals()	repr()	zip()
compile()	globals()	map()	reversed()	__import__()
complex()	hasattr()	max()	round()
delattr()	hash()	memoryview()	set()

二、做用域相關 ******

globals() :返回一個字典(包含所有的全局變量)locals() ：返回一個字典(包含的是當前做用域的全部變量)函數

b = 2
a = 3
print(globals())
print(locals())
# 結果：這兩個結果同樣，由於都是在全局執行的。


def fun():
    a = 3
    b = 2
    print(globals())
    print(locals())
fun()
# 結果：
globals():
{'__name__': '__main__', '__doc__': None, '__package__': None, 
'__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x00000228CB787748>, 
'__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 
'__file__': 'E:/OldBoy/Knight/PythonProject/day13/t2.py', '__cached__': None, 'b': 2, 'a': 3, 
'fun': <function fun at 0x00000228CB351E18>}

locals():{'b': 2, 'a': 3}

三、字符串類型代碼的執行：eval，exec，compile (不建議使用 ***)

eval: 執行字符串類型的代碼，並返回最終結果
s1 = '1+2+3+4+5'
print(eval(s1),type(eval(s1)))  #15 <class 'int'>


s2 = "{'name':'xiaoming'}"
print(eval(s2),type(eval(s2)))  #{'name': 'xiaoming'} <class 'dict'>


s3 = 'print(666)'
eval(s3)   # 666
print(eval(s3))  # 666 None(執行s3裏面的代碼沒有返回值，就返回None)

exec:執行字符串類型的代碼，不返回結果(代碼流)
s3 = 'print(666)'
exec(s3)  #666(沒有返回值的代碼流可用exec())


s4 = '''for i in range(10):
    print(i)
'''
exec(s4) # 0 1 2 3 4 5 6 7 8 9
eval(s4) # 報錯

s1 = '1+2+3+4+5'
print(eval(s1),type(eval(s1)))  #15 <class 'int'>
print(exec(s1))  #None(有返回值不能用exec)


compile(瞭解便可)：將字符串類型的代碼編譯。代碼對象可以經過exec語句來執行或者eval()進行求值。
參數說明：　　　
1. 參數source：字符串或者AST（Abstract Syntax Trees）對象。即須要動態執行的代碼段。　　
2. 參數 filename：代碼文件名稱，若是不是從文件讀取代碼則傳遞一些可辨認的值。當傳入了source參數時，filename參數傳入空字符便可。　　
3. 參數model：指定編譯代碼的種類，能夠指定爲 ‘exec’,’eval’,’single’。當source中包含流程語句時，model應指定爲‘exec’；
   當source中只包含一個簡單的求值表達式，model應指定爲‘eval’；當source中包含了交互式命令語句，model應指定爲'single'。

例子：
#流程語句使用exec
s5 = 'for i in range(5):print(i)'
compile1 = compile(s5,'','exec')
exec(compile1)
結果：0 1 2 3 4


#簡單求值表達式用eval
s5 = '1*2*3*4'
compile2 = compile(s5,'','eval')
print(eval(compile2))
結果：24


#交互語句用single
s5 = 'name = input("please input your name:")'
compile3 = compile(s5,'','single')
exec(compile3)  #運行後會讓用戶進行輸入，please input your name:
print(name)     #在exec(compile3)運行前沒有值，運行後，值爲用戶輸入的值。

注意：有返回值的字符串形式的代碼用eval，沒有返回值的字符串形式的代碼用exec，通常不用compile。
可是！通常不推薦使用這幾個方法，爲何呢？
舉個栗子：
　　在工做中，別人發給你一個文本文件，你讀文件的時候，讀出來的都是字符串吧，那麼就可使用這三個方法，
可是，一旦你使用了這幾個方法，它立馬就執行了，你想過沒有，若是別人在傳送文件給你的時候，你的文件被
黑客截取了，植入了病毒，再發回給你，那你使用eval,exec不就把病毒也讀取了嗎？post

四、輸入輸出相關 input()，print() *****

input:函數接受一個標準輸入數據，返回爲string類型。
print:打印輸出。ui

print的參數分析：print(self, *args, sep=' ', end='\n', file=None)
1,*args：可接收多個位置參數
2,sep:打印多個值之間的分隔符，默認爲空格
3,end:每一次打印的結尾，默認爲換行符
4,file: 默認是輸出到屏幕，若是設置爲文件句柄，輸出到文件this

1,*args：可接收多個位置參數
print('666') # 666
print(1,2,3,4) # 1 2 3 4
print(*[1,2,3]) # 1 2 3
拓展：spa

def func1(*args,**kwargs): #在函數的定義 *參數表明聚合。
　　print(*args) #args=(1,2,3,4)這裏的*args不是在函數的定義中，
　　　　　　　　 #因此表明的是(*(1,2,3,4)) 打散結果輸出：1,2,3,4
　　print(args) #args是一個元組，輸出(1, 2, 3, 4)
　　print(**kwargs) #print(name='xiaoming',age=1000) print方法中沒有**kwargs
　　　　　　　　　 #不能接收多個關鍵字參數，因此這裏會報錯。
　　print(kwargs) #這裏的kwargs是一個字典，print輸出一個字典：{'name': 'xiaoming', 'age': 1000}
func1(1,2,3,4,name='xiaoming',age=1000)code

2,sep:打印多個值之間的分隔符，默認爲空格
print(1,2,3,sep='|') # 1|2|3|4orm

3,end:每一次打印的結尾，默認爲換行符
print(11,end=' ')
print(22)
結果：11 22對象

4,file: 默認是輸出到屏幕，若是設置爲文件句柄，輸出到文件
f = open('t1',encoding='utf-8',mode='w')
print(666,'777','888',file=f)blog

五、內存相關 hash id ***

hash：獲取一個對象（可哈希對象(不可變類型)：int，str，Bool，tuple）的哈希值。
id:獲取該對象的內存地址。

print(hash('name')) # -163295680327498572
print(hash('name1')) # 9065259785983334233
print(hash(123)) # 123
print(hash(100000)) # 100000
print(hash(True)) # 1
print(hash(False)) # 0
print(hash([1,2,3])) #報錯列表是可變數據類型，是不可哈希的
注意：數字的哈希值就是數字自己！

小知識點：
　　以前學字典的時候說過字典的優勢之一是查詢速度快，
　　字典的查詢甚至比二分查找還要快，爲何呢？
　　字典的鍵是不可變的數據類型，因此是可哈希的，
　　字典在存入內存的時候會將你的全部的key先進行哈希，再將哈希值存入內存中，
　　這樣在查詢的時候能夠根據哈希值直接就能夠找到，因此查詢速度很快！

六、文件操做相關 *****

open：函數用於打開一個文件，建立一個file對象，相關的方法才能夠調用它進行讀寫。

七、模塊相關 ***

__import__：函數用於動態加載類和函數。

八、幫助 **

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

九、調用相關

callable：函數用於檢查一個對象是不是可調用的。若是返回True，object仍然可能調用失敗；
但若是返回False，調用對象ojbect絕對不會成功。 ***
name = 'abc'

def fun():
　　a = 2
　　return a
print(callable(name)) #False 不可調用
print(callable(fun())) #False 不可調用:fun()不是一個對象，它是函數的執行者
print(callable(fun)) #True 可調用：fun是一個對象

十、查看內置屬性 ***

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

十一、range

range：函數可建立一個整數對象，通常用在 for 循環中。
python2x: range(3) ---> [0,1,2] 列表
　　　　　xrange(3) ---> 迭代器
python3x: range(3) ---> range(0,3) 可迭代對象

next：內部實際使用了__next__方法，返回迭代器的下一個項目
iter：函數用來生成迭代器（將一個可迭代對象，生成迭代器）

十二、數字相關(14)

數據類型（4）：
bool ：用於將給定參數轉換爲布爾類型，若是沒有參數，返回False。 ***
print(bool(1 < 2 and 3 > 4 or 5 < 6 and 9 > 2 or 3 > 1)) # True
print(bool('fdsjkfl')) #True

int：函數用於將一個字符串或數字轉換爲整型。***
print(int('123')) # 123
print(int(3.74)) # 取整並非四捨五入：3
print(int('0101',base=2)) # 將2進制的0101轉化成十進制，結果爲5

float：函數用於將整數和字符串轉換成浮點數。 ***
print(float(5)) # 5.0
print(float(3.16)) # 3.16
print(float('2')) # 2.0
print(float('2.1')) # 2.1
　　　
complex：函數用於建立一個值爲real + imag * j的複數或者轉化一個字符串或數爲複數。
若是第一個參數爲字符串，則不須要指定第二個參數。。

1三、進制轉換（3）：

bin：將十進制轉換成二進制並返回。
print(bin(100)) # 0b1100100

oct：將十進制轉化成八進制字符串並返回。
print(oct(7)) # 0o7
print(oct(8)) # 0o10
print(oct(9)) # 0o11

hex：將十進制轉化成十六進制字符串並返回。
print(hex(10)) # 0xa
print(hex(15)) # 0xf
print(hex(17)) # 0x11

1四、數學運算（7）：

abs：函數返回數字的絕對值。 ****
print(abs(-100)) # 100

divmod：計算除數與被除數的結果，返回一個包含商和餘數的元組(a // b, a % b)。 ****
print(divmod(12,7)) # (1, 5) (商，餘數)

divmod的應用：分頁。
假設有103條數據，你每頁顯示12條數據，你最終顯示多少頁。
print(divmod(103,12)) # (8,7) 即要9頁，前8頁，每頁12條數據，最後一頁，7條數據

round：保留浮點數的小數位數，默認保留整數,四捨五入。 ***
print(round(3.141592653)) #默認保留整數(會四捨五入)：3
print(round(3.641592653)) #默認保留整數(會四捨五入)：4
print(round(3.141592653,4)) #保留四位小數(會四捨五入)：3.1416
print(round(3.141592653,2)) #保留兩位小數(會四捨五入)：3.14

pow：求x**y次冪。（三個參數爲x**y的結果對z取餘） **
print(pow(2,5)) # 2的5次冪：32
print(pow(2,5,12)) # 2的5次冪的結果對12取餘(32對12取餘)：8

sum：對可迭代對象進行求和計算（可設置初始值）。 *****
sum(iterable,start_num)
print(sum([1,2,3,4,100,101])) # 211
print(sum([1,2,3,4,100,101],100)) # 311(第二個參數爲初始值)
print(sum([int(i) for i in [1,'2',3,'4','100',101]]))　

min：返回可迭代對象的最小值（可加key，key爲函數名，經過函數的規則，返回最小值）。 *****
print(min([1,-2,3,4,100,101])) # -2
print(min([1,-2,3,4,100,101],key=abs)) # 1

應用：
求出年齡最小的那個元組
ls = [('daming',1000),('xiaoming',18),('zhongming',500)]
這裏的數據還不算複雜，可用以前學過的知識求出

min_age = min([i[1] for i in ls])
for j in ls:
    if j[1] == min_age:
        print(j)

可是有時候數據複雜的狀況下，用以前的知識寫，可能會很複雜。
這時可用min()方法，配合自定製的函數進行求值

def func(x):
    return x[1]  # 1000  18  500
print(min(ls,key=func))
# 結果：('xiaoming', 18)

min(可迭代對象,key=函數名)：
1,它會將iterable的每個元素當作函數的參數傳進去。
2,它會按照返回值去比較大小。
3,最後返回的是遍歷的元素 x

dic = {'a':3,'b':2,'c':1}
def func1(x):
    return dic[x]
print(min(dic,key=func1))  
結果：c
# 這裏傳進去的元素是字典的鍵，比較的返回值是字典的值，最後返回的是遍歷的鍵


def func2(x):
    return x[1]
print(min(dic.items(),key=func2))
結果：('c', 1)
# 這裏傳進去的元素是字典的鍵和值組成的元組，比較的返回值是字典的值，最後返回的是遍歷的元組