內置函數

截止到python3.6.2，python一共為我們提供了68個內置函數。它們就是python提供可以直接拿來使用的所有函數

?	?	Built-in Functions	?	?
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()	?

上面就是內置函數的表，這個表的順序是按照首字母的排列順序來的，你會發現都混亂的堆在一起。比如，oct和bin和hex都是做進制換算的，但是卻被寫在了三個地方。。。這樣非常不利于大家歸納和學習。我把這些函數分成了6大類

作用域相關

基于字典的形式獲取局部變量和全局變量

globals()? ? ? ? ?# 獲取全局變量的字典

locals()? ?? ? ? ? # 獲取執行本方法所在命名空間內的局部變量的字典

迭代器/生成器相關

range()?創建一個整數列表，一般用在 for 循環中。

# 函數語法
range(start, stop[, step])start: 計數從 start 開始。默認是從 0 開始。例如range（5）等價于range（0， 5）;stop:  計數到 stop 結束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]沒有5step:  步長，默認為1。例如：range（0， 5） 等價于 range(0, 5, 1)# 實例
range(10)        # 從 0 開始到 10,[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
range(1, 11)     # 從 1 開始到 11,[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
range(0, 30, 5)  # 步長為 5,[0, 5, 10, 15, 20, 25]
range(0, -10, -1) # 負數,[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
range(0)         # []
range(1, 0)      # []

其他

字符串類型代碼的執行

eval()? ?#?將字符串類型的代碼執行并返回結果，或者將字符串轉化為元組等

print(eval('1+2+3+4')) # 10

exec()? ?# 將自字符串類型的代碼執行，無返回值

print(exec("1+2+3+4"))        # None
exec("print('hello,world')")  # hello,worldcode = '''
print(123)
a = 20
print(a)
'''
a = 10
exec(code,{'print':print},)  # 123 # 20
print(a)                     # 10

compile(source,filename,model)? ?#?將字符串類型的代碼編譯。代碼對象能夠通過exec語句來執行或者eval()進行求值。

參數說明：

? ? ? ? source：字符串或者AST（Abstract Syntax Trees）對象。即需要動態執行的代碼段。
? ? ? ? filename：代碼文件名稱，如果不是從文件讀取代碼則傳遞一些可辨認的值。當傳入了source參數時，filename參數傳入空字符即可。
? ? ? ? model：指定編譯代碼的種類，可以指定為 ‘exec’,’eval’,’single’。當source中包含流程語句時，model應指定為‘exec’；當source中只包含一個簡單的求值表達式，model應指定為‘eval’；當source中包含了交互式命令語句，model應指定為’single’。

# 流程語句使用exec
code1 = 'for i in range(0,10): print (i)'
compile1 = compile(code1,'','exec')
exec(compile1)# 簡單求值表達式用eval
code2 = '1 + 2 + 3 + 4'
compile2 = compile(code2,'','eval')
eval(compile2)# 交互語句用single
code3 = 'name = input("please input your name:")'
compile3 = compile(code3,'','single')
name            # 執行前name變量不存在
Traceback (most recent call last):File "<pyshell#29>", line 1, in <module>name
NameError: name 'name' is not defined
exec(compile3)  # 執行時顯示交互命令，提示輸入
print(name)     # 執行后name變量有值
please input your name:'pythoner'
"'pythoner'"

輸入輸出相關：

input()? ??輸入

s = input("請輸入內容")   # 輸入的內容賦值給s變量
print(s)                 # 輸入什么打印什么，數據類型是str

print()? ?輸出

def print(self, *args, sep=' ', end='\n', file=None): """print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)file:  默認是輸出到屏幕，如果設置為文件句柄，輸出到文件sep:   打印多個值之間的分隔符，默認為空格end:   每一次打印的結尾，默認為換行符flush: 立即把內容輸出到流文件，不作緩存"""
f = open('tmp_file','w')
print(123,456,sep=',',file = f,flush=True)# 用 % 表示完成度
import time
for i in range(0,101,2):  time.sleep(0.1)char_num = i//2                     # 打印多少個'*'per_str = '\r%s%% : %s\n' % (i, '*' * char_num) if i == 100 else '\r%s%% : %s'%(i,'*'*char_num)print(per_str,end='', flush=True)   # \r 可以把光標移動到行首但不換行

數據類型相關：

type(o)? ? ? # 返回變量o的數據類型

內存相關：

id(o)?? ? ? ? # o是參數，返回變量的內存地址

hash(o)???

# o是參數，返回一個可hash變量的哈希值，不可hash的變量被hash之后會報錯。TypeError: unhashable type: ‘list’
#?hash函數會根據一個內部的算法對當前可hash變量進行處理，返回一個int數字。
# 每一次執行程序，內容相同的變量hash值在這一次執行過程中不會發生改變。

文件操作相關

open()? ? # 打開一個文件，返回一個文件操作符(文件句柄),操作文件的模式有r,w,a,r+,w+,a+ 共6種，每一種方式都可以用二進制的形式操作(rb,wb,ab,rb+,wb+,ab+),可以用encoding指定編碼.

模塊操作相關

import? ?# 導入一個模塊

os = __import__('os')    # impore os 效果相同

幫助方法

在控制臺執行help()進入幫助模式。可以隨意輸入變量或者變量的類型。輸入q退出。或者直接執行help(o)，o是參數，查看和變量o有關的操作。。。

調用相關

callable(o)? ? ? # o是參數，看這個變量是不是可調用。如果o是一個函數名，就會返回True

def func():pass
print(callable(func))  # 參數是函數名，可調用，返回True
print(callable(123))   # 參數是數字，不可調用，返回False

查看參數所屬類型的所有內置方法

dir()? ? ? ? ? ?# 默認查看全局空間內的屬性，也接受一個參數，查看這個參數內的方法或變量

print(dir(list))   # 查看列表的內置方法
print(dir(int))    # 查看整數的內置方法

基礎類型相關

和數字相關

數據類型相關：

bool()?? ? ? ?# 用于將給定參數轉換為布爾類型，如果沒有參數，返回 False，bool 是 int 的子類。

bool()? ? ? ? ?#?False
bool(0)? ? ? ? #?False
bool(1)? ? ? ? #?True
bool(2)? ? ? ? #?True
issubclass(bool, int) # bool 是 int 子類 True

int(x, base=10)?? ? ?# 將一個字符串或數字轉換為整型。（x-字符串或數字，base-進制數，默認十進制。）返回整型數據。

int()? ? ? ? ? ? ?# 不傳入參數時，得到結果0
int(3)? ? ? ? ? ? # 3
int(3.6)          # 3
int('12',16)? ? ? # 如果是帶參數base的話，12要以字符串的形式進行輸入，12 為 16進制 18
int('0xa',16)     # 10

float(x)? ? ? ? ? ? ?# 函數用于將整數和字符串轉換成浮點數，x — 整數或字符串，返回浮點數。

float(1)         # 1.0?
float(112)       # 112.0?
float(-123.6)    # -123.6?
float('123')     # 字符串 123.0

complex([real[,?imag]])? ?# 函數用于創建一個值為 real + imag * j 的復數或者轉化一個字符串或數為復數。如果第一個參數為字符串，則不需要指定第二個參數

real — int, long, float或字符串；
imag — int, long, float；

complex(1, 2)   # (1 + 2j) 
complex(1)      # 數字 (1 + 0j)
complex("1")    # 當做字符串處理 (1 + 0j)
complex("1+2j") # (1 + 2j),注意：這個地方在"+"號兩邊不能有空格，也就是不能寫成"1 + 2j"，應該是"1+2j"，否則會報錯

進制轉換：

bin(x)? ? # (x-int 或者 long int 數字)將一個整數 int 或者長整數 long int 轉化為二進制表示，返回值為字符串

bin(10)        # '0b1010'
bin(20)        # '0b10100'

oct(x)??? ? # (x-整數)將一個整數轉換成8進制字符串。

oct(10)        # '012'
oct(20)        # '024'

hex()??? ? ?# (x-10進制整數)將10進制整數轉換成16進制，以字符串形式表示

hen(255)       # '0xff''
hen(-42)       # '-0x2a'

數學運算：

round(a,n)? # 對a保留n位小數

round(2.355, 2)   # 2.35

abs(x)?? ? ? ? ? ?# 返回數字x的絕對值。

abs(-45)          # 45

divmod(a, b)?# 把除數和余數運算結果結合起來，返回一個包含商和余數的元組(a//b, a%b)。

divmod(7,2)       # (3,1)
divmod(8,2)       # (4,0)

min(iterable,key=func)??# 返回給定參數的最小值，iterable可以為序列和可迭代對象，key跟要使用的函數

max(iterable,key=func)??# 返回給定參數的最大值，iterable可以為序列和可迭代對象，key跟要使用的函數

sum(iterable[, start])? ? ? # 對可迭代對象進行求和計算，必須為可迭代對象

iterable — 可迭代對象，如：列表、元組、集合。
start — 指定相加的參數，如果沒有設置這個值，默認為0

sum([0,1,2])      # 3  
sum((2, 3, 4), 1) # 元組計算總和后再加，1結果10

pow(x,y,[,z])?? ? ? # 返回 xy（x的y次方）的值，如果有z，則返回xy（x的y次方）%z

import math       # 導入 math 模塊
print("math.pow(100, 2)") # 10000.0

和數據結構相關

列表和元組相關的

list(tup)??? ? ?# (tup要轉化為列表的元組) 用于將元組轉換為列表

tuple(list)? ? # (list要轉化為元組的列表) 用于將元組轉換為列表

字符串相關的

bytearry，memoryview，ord，chr，ascii暫不介紹

str(x)? ? ? ? ? #?將對象x轉化為字符串

bytes(s,encoding=’utf-8′)?# 返回一個新的 bytes 對象

repr()??? ? ? ? ?# 將對象轉化為供解釋器讀取的形式。不會去除引號

s = 'RUNOOB'
print(repr(s))    # "'RUNOOB'"

format()??? ? ?# 格式化輸出，函數功能將一個數值進行格式化顯示。?如果參數format_spec未提供，則和調用str(value)效果相同，轉換成字符串格式化。

format(3.1415936)     # '3.1415936'
str(3.1415926)        # '3.1415926'

對于不同的類型，參數format_spec可提供的值都不一樣

# 字符串可以提供的參數,指定對齊方式，<是左對齊， >是右對齊，^是居中對齊
print(format('test', '<20'))  # test                
print(format('test', '>20'))  #                 test
print(format('test', '^20'))  #         test        # 整形數值可以提供的參數有 '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'

序列

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

l = (1,2,23,213,5612,342,43)
print(reversed(l))          # <reversed object at 0x00000189156A9860>
print(list(reversed(l)))    # [43, 342, 5612, 213, 23, 2, 1]

slice()?? ? ? ? ? ? ? ?# 實現切片對象，主要用在切片操作函數里的參數傳遞,不常用

sli = slice(1,5,2)
print(l[sli])

字典和集合：

dict()? ? #?函數用于創建一個字典。

set()??? ?#?函數用于創建一個集合。

frozenset(iterable)? #?返回一個凍結的集合，凍結后集合不能再添加或刪除任何元素。

相關內置函數

len，sorted，enumerate，all，any，zip，filter，map

len(x)? ? ? ? ? ? ? ? ?# 返回x長度

any(iterable)? ? ?# 用于判斷給定的可迭代參數 iterable 是否全部為 False，則返回 False，如果有一個為 True，則返回 True。元素除了是 0、空、FALSE 外都算 TRUE。Python 2.5 以上版本可用。

all(iterable)??? ? ? # 用于判斷給定的可迭代參數 iterable 中的所有元素是否都為 TRUE，如果是返回 True，否則返回 False。元素除了是 0、空、FALSE 外都算 TRUE。Python 2.5 以上版本可用。

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

對List、Dict進行排序，Python提供了兩個方法
? ? ? ?用List的成員函數sort進行排序，在本地進行排序，不返回副本，修改原始數據
? ? ? ?用built-in函數sorted進行排序（從2.4開始），返回副本，原始數據不變

參數：

? ? ? ? iterable：是可迭代類型;
? ? ? ? key：傳入一個函數名，函數的參數是可迭代類型中的每一項，根據函數的返回值大小排序;
? ? ? ? reverse：排序規則. reverse = True ?降序 或者 reverse = False 升序，有默認值。

返回值：有序列表

# 列表按照其中每一個值的絕對值排序
l1 = [1,3,5,-2,-4,-6]
l2 = sorted(l1,key=abs)
print(l1)          # [1, 3, 5, -2, -4, -6]
print(l2)          # [1, -2, 3, -4, 5, -6]# 列表按照每一個元素的len排序
l = [[1,2],[3,4,5,6],(7,),'123']
print(sorted(l,key=len))   # [(7,), [1, 2], '123', [3, 4, 5, 6]]

enumerate(sequence, [start=0])? # 用于將一個可遍歷的數據對象(如列表、元組或字符串)組合為一個索引序列，同時列出數據和數據下標，一般用在 for 循環當中。

參數：

? ? sequence — 一個序列、迭代器或其他支持迭代對象。
? ? start — 下標起始位置。

seasons = ['Spring', 'Summer', 'Fall', 'Winter']
list(enumerate(seasons))    # [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]

zip(iterable,…)? ? ?# (zip,翻譯拉鏈)用于將可迭代的對象作為參數，將對象中對應的元素打包成一個個元組，然后返回由這些元組組成的對象，如果各個迭代器的元素個數不一致，則返回列表長度與最短的對象相同

list1 = [1,2]
list2 = ['a','b','c']
list3 = ['A','B','C','D']
print(zip(list1,list2,list3))          # <zip object at 0x103abc288>
print(list(zip(list1,list2,list3)))    # [(1,'a','A'),(2,'b','B')]

注：Python 2.x 返回列表。
Python 3.x 返回迭代器。需用list（）調用

filter(key=func,iterables)? ? ?# 用于過濾序列，過濾掉不符合條件的元素，返回一個迭代器對象，如果要轉換為列表，可以使用?list()?來轉換。filter接收一個函數 f?和一個list，這個函數?f?的作用是對每個元素進行判斷，返回 True或 False，filter()根據判斷結果自動過濾掉不符合條件的元素，返回由符合條件元素組成的新list。

# 例如，要從一個list [1, 4, 6, 7, 9, 12, 17]中刪除偶數，保留奇數，首先，要編寫一個判斷奇數的函數：
def is_odd(x):return x % 2 == 1
# 然后，利用filter()過濾掉偶數：
print(list(filter(is_odd, [1, 4, 6, 7, 9, 12, 17])))   # [1, 7, 9, 17]

利用filter()，可以完成很多有用的功能，例如，刪除 None 或者空字符串：

def is_not_empty(s):return s and len(s.strip()) > 0
print(list(filter(is_not_empty, ['test', None, '', 'str', '  ', 'END'])))  #['test', 'str', 'END']

注意:?s.strip(rm) 刪除 s 字符串中開頭、結尾處的 rm 序列的字符。

當rm為空時，默認刪除空白符（包括’\n’, ‘\r’, ‘\t’, ‘ ‘)，如下：

a = ' 123'
a.strip()? ? # '123'
a = '\t\t123\r\n'
a.strip()? ? # '123'

請利用filter()過濾出1~100中平方根是整數的數，即結果應該是：[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

import math
def is_sqr(x):return math.sqrt(x) % 1 == 0
print(list(filter(is_sqr, range(1, 101))))       # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

map(key=func,iterables,….)? ??# map函數應用于每一個可迭代的項，把每一個參數都以相應的處理函數進行迭代處理。map()函數接收兩個參數，一個是函數，一個是序列，map將傳入的函數依次作用到序列的每個元素，

# L = [1,2,3,4,]，將f(x)=x^2作用于list上
L = [1,2,3,4,] 
def pow2(x): return x*x list(map(pow2,L))     # [1, 4, 9, 16]

注：Python 2.x 返回列表。
Python 3.x 返回迭代器。需用list（）調用

匿名函數

匿名函數：為了解決那些功能很簡單的需求而設計的一句話函數

def calc(n):return n**n
print(calc(10))# 換成匿名函數
calc = lambda n:n**n
print(calc(10))

上面是我們對calc這個匿名函數的分析，下面給出了一個關于匿名函數格式的說明

函數名 = lambda 參數 ：返回值
# 參數可以有多個，用逗號隔開
# 匿名函數不管邏輯多復雜，只能寫一行，且邏輯執行結束后的內容就是返回值
# 返回值和正常的函數一樣可以是任意數據類型

我們可以看出，匿名函數并不是真的不能有名字。匿名函數的調用和正常的調用也沒有什么分別。 就是 函數名(參數) 就可以了～～～
上面是匿名函數的函數用法。除此之外，匿名函數也不是浪得虛名，它真的可以匿名。在和其他功能函數合作的時候

l = [3,2,100,999,213,1111,31121,333]
print(max(l))
dic={'k1':10,'k2':100,'k3':30}
print(max(dic))
print(dic[max(dic,key=lambda k:dic[k])])

res = map(lambda x:x**2,[1,5,7,4])
for i in res:print(i)輸出
1
25
49
16

res = filter(lambda x:x>10,[5,8,11,9,15])
for i in res:print(i)輸出
11
15

現有兩個元組((‘a’),(‘b’)),((‘c’),(‘d’))，請使用python中匿名函數生成列表[{‘a’:’c’},{‘b’:’d’}]

# 答案一
test = lambda t1,t2 :[{i:j} for i,j in zip(t1,t2)]
print(test(t1,t2))
# 答案二
print(list(map(lambda t:{t[0]:t[1]},zip(t1,t2))))
# 還可以這樣寫
print([{i:j} for i,j in zip(t1,t2)])

注：max(), min(), map(), filter() , sort() 中都有key，都可以和匿名函數結合使用

重點掌握：

其他：input,print,type,hash,open,import,dir
str類型代碼執行：eval,exec
數字：bool,int,float,abs,divmod,min,max,sum,round,pow
序列——列表和元組相關的：list和tuple
序列——字符串相關的：str，bytes，repr
序列：reversed，slice
數據集合——字典和集合：dict，set，frozenset
數據集合：len，sorted，enumerate，zip，filter，map