在寫python程序時,常能用到一些函數(shù)和方法,總結一下,保存起來,方便查詢。
創(chuàng)新互聯(lián)公司自2013年起,是專業(yè)互聯(lián)網(wǎng)技術服務公司,擁有項目成都網(wǎng)站建設、網(wǎng)站建設網(wǎng)站策劃,項目實施與項目整合能力。我們以讓每一個夢想脫穎而出為使命,1280元岳麓做網(wǎng)站,已為上家服務,為岳麓各地企業(yè)和個人服務,聯(lián)系電話:028-86922220
一、內(nèi)置函數(shù)
# abs()獲取數(shù)字絕對值
# chr(i)數(shù)字轉(zhuǎn)換為字符類型
# divmod() 獲取兩個數(shù)值的商和余數(shù)
# enumerate() 將可遍歷序列組合為索引序列
# float()轉(zhuǎn)換為浮點數(shù)
# format() 格式化字符串
# int()轉(zhuǎn)換為整數(shù)?
# input() 接受用戶輸入內(nèi)容
# len() 計算元素個數(shù)
# max() 返回最大值
# min() 返回最小值
# math.ceil() 返回指定數(shù)值的上舍整數(shù)
# open()打開文件并返回文件對象
# pow() 冪運算
# print()打印輸出?
# range() 生成器
# reversed()反轉(zhuǎn)所有元素
# round()四舍五入求值
# sorted()對可迭代對象進行排序?
# str() 轉(zhuǎn)換為字符串
# sum() 求和
# set() 創(chuàng)建集合
# tuple() 將序列轉(zhuǎn)換為元組
# zip()將可迭代對象打包成元組
二、方法
# append() 添加列表元素
# capitalize()首字母轉(zhuǎn)換為大寫?
# count()字符出現(xiàn)次數(shù)
# close() 關閉文件
# decode() 解碼字符串
# dict.keys() 獲取字典所有的鍵
# find()字符串首次出現(xiàn)的索引
# f.read() 讀取文件內(nèi)容
# dict.update()更新字典
# dict.items() 獲取字典鍵/值對
# dict.get() 返回指定鍵的值
# encode() 編碼字符串
# list.sort() 排序列表元素
# index() 元素首次出現(xiàn)的索引
# isdigit() 判斷字符串是否只由數(shù)字組成
# isupper() 是否所有字母都為大寫
# isnum() 判斷字符串是否由字母和數(shù)字組成
# islower() 是否所有字母都為小寫
# isdecimal() 檢查字符串是否只包含十進制字符
# isalpha() 檢測字符串是否為純字母
# random.shuffle()隨機排序
# random.sample()返回無重復隨機數(shù)列表
# random.choice() 返回一個隨機元素
# random.randint() 生成指定范圍的隨機整數(shù)
# random.randrange() 生成指定范圍的指定遞增基數(shù)隨機整數(shù)
# pop() 刪除列表中的元素
# remove()刪除列表中的指定元素
# strip()去除空格
# lstrip()去除左側(cè)空格
# rstrip() 去除右側(cè)空格
# readline() 讀取單行內(nèi)容
# root.after() Tkinter中等待一段時間后再執(zhí)行命令
# str.isnumeric() 驗證字符串是否為數(shù)字(適用于Unicode)
# split()分割字符串
# ord() 將字符轉(zhuǎn)換為整數(shù)
# replace() 字符串替換
# ljust() 左對齊填充
# rjust() 左對齊填充
# readlines() 讀取所有行內(nèi)容
# datetime.datetime.now() 返回指定時區(qū)的本地日期時間
# datetime.datetime.today() 獲取當前本地日期的date對象
# datetime.utcnow() 返回當前UTC時間的datetime對象
# time.strptime()把時間字符串解析為元組
# time.time()返回當前時間的時間戳
# time.sleep()暫停指定秒數(shù)
# time.strftime() 返回指定格式的日期字符串
# time.mktime() 接收時間元組并返回時間戳
# os.getcwd() 獲取當前工作目錄
# os.listdir() 獲取指定路徑下的目錄和文件列表
# os.makedirs() 遞歸創(chuàng)建目錄
# os.rename() 重命名目錄或文件
# os.path.exists() 判斷路徑是否存在
# upper() 全部轉(zhuǎn)換為大寫字母
# lower()? 全部轉(zhuǎn)換為小寫字母
# sys.stdout.write() 標準輸出打印
# sys.stdout.flush()刷新輸出?
# shutil.copy() 復制單個文件到另一文件或目錄
# write() 寫入文件內(nèi)容
# winsound.Beep() 打開電腦揚聲器
# zfill() 在字符串前面填充0
三、循環(huán)語句
# break終止當前循環(huán)
# continue 終止本循環(huán)進入下一次循環(huán)
# with open() as file 以with語句打開文件(數(shù)據(jù)保存)
四、轉(zhuǎn)義字符
\ 行尾續(xù)行符
\' 單引號?
\'' 雙引號
\a 響鈴
\e 轉(zhuǎn)義
\n 換行
\t 橫向制表符
\f 換頁
\xyy 十六進制yy代表的字符
\\反斜杠符號
\b 退格
\000 空
\v 縱向制表符
\r 回車
\0yy 八進制yy代表的字符
\other 其他的字符以普通格式輸出
4.6. 定義函數(shù)
我們可以創(chuàng)建一個用來生成指定邊界的斐波那契數(shù)列的函數(shù):
def fib(n): # write Fibonacci series up to n
... """Print a Fibonacci series up to n."""
... a, b = 0, 1
... while a n:
... print(a, end=' ')
... a, b = b, a+b
... print()
...
# Now call the function we just defined:
... fib(2000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597
關鍵字 def 引入了一個函數(shù) 定義。在其后必須跟有函數(shù)名和包括形式參數(shù)的圓括號。函數(shù)體語句從下一行開始,必須是縮進的。
函數(shù)體的第一行語句可以是可選的字符串文本,這個字符串是函數(shù)的文檔字符串,或者稱為 docstring。(更多關于 docstrings 的信息請參考 文檔字符串) 有些工具通過 docstrings 自動生成在線的或可打印的文檔,或者讓用戶通過代碼交互瀏覽;在你的代碼中包含 docstrings 是一個好的實踐,讓它成為習慣吧。
函數(shù) 調(diào)用 會為函數(shù)局部變量生成一個新的符號表。確切的說,所有函數(shù)中的變量賦值都是將值存儲在局部符號表。變量引用首先在局部符號表中查找,然后是包含函數(shù)的局部符號表,然后是全局符號表,最后是內(nèi)置名字表。因此,全局變量不能在函數(shù)中直接賦值(除非用 global 語句命名),盡管他們可以被引用。
函數(shù)引用的實際參數(shù)在函數(shù)調(diào)用時引入局部符號表,因此,實參總是 傳值調(diào)用 (這里的 值 總是一個對象 引用 ,而不是該對象的值)。[1] 一個函數(shù)被另一個函數(shù)調(diào)用時,一個新的局部符號表在調(diào)用過程中被創(chuàng)建。
一個函數(shù)定義會在當前符號表內(nèi)引入函數(shù)名。函數(shù)名指代的值(即函數(shù)體)有一個被 Python 解釋器認定為 用戶自定義函數(shù) 的類型。 這個值可以賦予其他的名字(即變量名),然后它也可以被當作函數(shù)使用。這可以作為通用的重命名機制:
fib
f = fib
f(100)
0 1 1 2 3 5 8 13 21 34 55 89
如果你使用過其他語言,你可能會反對說:fib 不是一個函數(shù),而是一個方法,因為它并不返回任何值。事實上,沒有 return 語句的函數(shù)確實會返回一個值,雖然是一個相當令人厭煩的值(指 None )。這個值被稱為 None (這是一個內(nèi)建名稱)。如果 None 值是唯一被書寫的值,那么在寫的時候通常會被解釋器忽略(即不輸出任何內(nèi)容)。如果你確實想看到這個值的輸出內(nèi)容,請使用 print() 函數(shù):
字典是一種通過名字或者關鍵字引用的得數(shù)據(jù)結構,其鍵可以是數(shù)字、字符串、元組,這種結構類型也稱之為映射。字典類型是Python中唯一內(nèi)建的映射類型,基本的操作包括如下:
(1)len():返回字典中鍵—值對的數(shù)量;
(2)d[k]:返回關鍵字對于的值;
(3)d[k]=v:將值關聯(lián)到鍵值k上;
(4)del d[k]:刪除鍵值為k的項;
(5)key in d:鍵值key是否在d中,是返回True,否則返回False。
(6)clear函數(shù):清除字典中的所有項
(7)copy函數(shù):返回一個具有相同鍵值的新字典;deepcopy()函數(shù)使用深復制,復制其包含所有的值,這個方法可以解決由于副本修改而使原始字典也變化的問題
(8)fromkeys函數(shù):使用給定的鍵建立新的字典,鍵默認對應的值為None
(9)get函數(shù):訪問字典成員
(10)has_key函數(shù):檢查字典中是否含有給出的鍵
(11)items和iteritems函數(shù):items將所有的字典項以列表方式返回,列表中項來自(鍵,值),iteritems與items作用相似,但是返回的是一個迭代器對象而不是列表
(12)keys和iterkeys:keys將字典中的鍵以列表形式返回,iterkeys返回鍵的迭代器
(13)pop函數(shù):刪除字典中對應的鍵
(14)popitem函數(shù):移出字典中的項
(15)setdefault函數(shù):類似于get方法,獲取與給定鍵相關聯(lián)的值,也可以在字典中不包含給定鍵的情況下設定相應的鍵值
(16)update函數(shù):用一個字典更新另外一個字典
(17)?values和itervalues函數(shù):values以列表的形式返回字典中的值,itervalues返回值得迭代器,由于在字典中值不是唯一的,所以列表中可以包含重復的元素
一、字典的創(chuàng)建
1.1 直接創(chuàng)建字典
d={'one':1,'two':2,'three':3}
printd
printd['two']
printd['three']
運算結果:
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
1.2 通過dict創(chuàng)建字典
# _*_ coding:utf-8 _*_
items=[('one',1),('two',2),('three',3),('four',4)]
printu'items中的內(nèi)容:'
printitems
printu'利用dict創(chuàng)建字典,輸出字典內(nèi)容:'
d=dict(items)
printd
printu'查詢字典中的內(nèi)容:'
printd['one']
printd['three']
運算結果:
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
items中的內(nèi)容:
[('one',1), ('two',2), ('three',3), ('four',4)]
利用dict創(chuàng)建字典,輸出字典內(nèi)容:
{'four':4,'three':3,'two':2,'one':1}
查詢字典中的內(nèi)容:
或者通過關鍵字創(chuàng)建字典
# _*_ coding:utf-8 _*_
d=dict(one=1,two=2,three=3)
printu'輸出字典內(nèi)容:'
printd
printu'查詢字典中的內(nèi)容:'
printd['one']
printd['three']
運算結果:
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
輸出字典內(nèi)容:
{'three':3,'two':2,'one':1}
查詢字典中的內(nèi)容:
二、字典的格式化字符串
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3,'four':4}
printd
print"three is %(three)s."%d
運算結果:
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'four':4,'three':3,'two':2,'one':1}
threeis3.
三、字典方法
3.1?clear函數(shù):清除字典中的所有項
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3,'four':4}
printd
d.clear()
printd
運算結果:
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'four':4,'three':3,'two':2,'one':1}
{}
請看下面兩個例子
3.1.1
# _*_ coding:utf-8 _*_
d={}
dd=d
d['one']=1
d['two']=2
printdd
d={}
printd
printdd
運算結果:
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'two':2,'one':1}
{}
{'two':2,'one':1}
3.1.2
# _*_ coding:utf-8 _*_
d={}
dd=d
d['one']=1
d['two']=2
printdd
d.clear()
printd
printdd
運算結果:
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'two':2,'one':1}
{}
{}
3.1.2與3.1.1唯一不同的是在對字典d的清空處理上,3.1.1將d關聯(lián)到一個新的空字典上,這種方式對字典dd是沒有影響的,所以在字典d被置空后,字典dd里面的值仍舊沒有變化。但是在3.1.2中clear方法清空字典d中的內(nèi)容,clear是一個原地操作的方法,使得d中的內(nèi)容全部被置空,這樣dd所指向的空間也被置空。
3.2?copy函數(shù):返回一個具有相同鍵值的新字典
# _*_ coding:utf-8 _*_
x={'one':1,'two':2,'three':3,'test':['a','b','c']}
printu'初始X字典:'
printx
printu'X復制到Y:'
y=x.copy()
printu'Y字典:'
printy
y['three']=33
printu'修改Y中的值,觀察輸出:'
printy
printx
printu'刪除Y中的值,觀察輸出'
y['test'].remove('c')
printy
printx
運算結果:
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
初始X字典:
{'test': ['a','b','c'],'three':3,'two':2,'one':1}
X復制到Y:
Y字典:
{'test': ['a','b','c'],'one':1,'three':3,'two':2}
修改Y中的值,觀察輸出:
{'test': ['a','b','c'],'one':1,'three':33,'two':2}
{'test': ['a','b','c'],'three':3,'two':2,'one':1}
刪除Y中的值,觀察輸出
{'test': ['a','b'],'one':1,'three':33,'two':2}
{'test': ['a','b'],'three':3,'two':2,'one':1}
注:在復制的副本中對值進行替換后,對原來的字典不產(chǎn)生影響,但是如果修改了副本,原始的字典也會被修改。deepcopy函數(shù)使用深復制,復制其包含所有的值,這個方法可以解決由于副本修改而使原始字典也變化的問題。
# _*_ coding:utf-8 _*_
fromcopyimportdeepcopy
x={}
x['test']=['a','b','c','d']
y=x.copy()
z=deepcopy(x)
printu'輸出:'
printy
printz
printu'修改后輸出:'
x['test'].append('e')
printy
printz
運算輸出:
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
輸出:
{'test': ['a','b','c','d']}
{'test': ['a','b','c','d']}
修改后輸出:
{'test': ['a','b','c','d','e']}
{'test': ['a','b','c','d']}
3.3?fromkeys函數(shù):使用給定的鍵建立新的字典,鍵默認對應的值為None
# _*_ coding:utf-8 _*_
d=dict.fromkeys(['one','two','three'])
printd
運算輸出:
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':None,'two':None,'one':None}
或者指定默認的對應值
# _*_ coding:utf-8 _*_
d=dict.fromkeys(['one','two','three'],'unknow')
printd
運算結果:
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':'unknow','two':'unknow','one':'unknow'}
3.4?get函數(shù):訪問字典成員
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
printd.get('one')
printd.get('four')
運算結果:
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
1
None
注:get函數(shù)可以訪問字典中不存在的鍵,當該鍵不存在是返回None
3.5?has_key函數(shù):檢查字典中是否含有給出的鍵
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
printd.has_key('one')
printd.has_key('four')
運算結果:
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
True
False
3.6?items和iteritems函數(shù):items將所有的字典項以列表方式返回,列表中項來自(鍵,值),iteritems與items作用相似,但是返回的是一個迭代器對象而不是列表
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
list=d.items()
forkey,valueinlist:
printkey,':',value
運算結果:
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
three :3
two :2
one :1
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
it=d.iteritems()
fork,vinit:
print"d[%s]="%k,v
運算結果:
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
d[three]=3
d[two]=2
d[one]=1
3.7?keys和iterkeys:keys將字典中的鍵以列表形式返回,iterkeys返回鍵的迭代器
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
printu'keys方法:'
list=d.keys()
printlist
printu'\niterkeys方法:'
it=d.iterkeys()
forxinit:
printx
運算結果:
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
keys方法:
['three','two','one']
iterkeys方法:
three
two
one
3.8?pop函數(shù):刪除字典中對應的鍵
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
d.pop('one')
printd
運算結果:
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
{'three':3,'two':2}
3.9?popitem函數(shù):移出字典中的項
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
d.popitem()
printd
運算結果:
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
{'two':2,'one':1}
3.10?setdefault函數(shù):類似于get方法,獲取與給定鍵相關聯(lián)的值,也可以在字典中不包含給定鍵的情況下設定相應的鍵值
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
printd.setdefault('one',1)
printd.setdefault('four',4)
printd
運算結果:
{'three':3,'two':2,'one':1}
{'four':4,'three':3,'two':2,'one':1}
3.11?update函數(shù):用一個字典更新另外一個字典
# _*_ coding:utf-8 _*_
d={
'one':123,
'two':2,
'three':3
}
printd
x={'one':1}
d.update(x)
printd
運算結果:
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':123}
{'three':3,'two':2,'one':1}
3.12?values和itervalues函數(shù):values以列表的形式返回字典中的值,itervalues返回值得迭代器,由于在字典中值不是唯一的,所以列表中可以包含重復的元素
# _*_ coding:utf-8 _*_
d={
'one':123,
'two':2,
'three':3,
'test':2
}
printd.values()
運算結果:
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
[2,3,2,123]
len函數(shù)python用法如下:
操作設備:戴爾筆記本電腦
操作系統(tǒng):win10
操作程序:python2017
1、len函數(shù)的作用就是返回容器中項目的數(shù)目。
2、len的變量必須是容器,單獨的數(shù)字行不通:a=2,print(len(a))。
3、容器可以是列表:a=[],print(len(a))。
4、容器可以是嵌套列表:a=[[],1,2,3,[1,2,3]],print(len(a))。
5、容器可以是字符串。
6、字符串的長度與字符有關:a='abcdefg369,print(len(a))。
7、反斜杠組合而成的轉(zhuǎn)移符,只是一個字符:a='\n\t',print(len(a)),這里要特別注意,\n是一個字符。
函數(shù)是組織好,可重復使用的,用來實現(xiàn)相關功能的代碼段
函數(shù)提高了代碼的重復利用率和應用的模塊性。
除Python自帶的函數(shù)之外,也可以自己創(chuàng)建函數(shù),叫做自定義函數(shù)
語法:
函數(shù)代碼塊以 def 開頭
參數(shù)為 輸入值 ,放于函數(shù)名后口號里面,
函數(shù)內(nèi)容以冒號:開始,函數(shù)體縮進, return 返回 輸出值
函數(shù)調(diào)用使用關鍵字參數(shù)來確定傳入的參數(shù)值,此時,如果多個函數(shù)則不需要按照指定順序。
在定義函數(shù)時,指定參數(shù)默認值。調(diào)用時如果不傳入?yún)?shù),則使用默認值
不定長部分如果沒有指定參數(shù),傳入是一個空元組
加了 兩個星號 ** 的參數(shù)會以字典的形式導入
/ 用來指明函數(shù)形參必須使用指定位置參數(shù),不能使用關鍵字參數(shù)的形式。
3.8版本之后的才能使用
不使用 def 定義函數(shù),沒有函數(shù)名
lamdba主體時一個表達式,而不是代碼塊,函數(shù)體比def簡單很多
定義在函數(shù)內(nèi)部的為局部變量,僅能在函數(shù)內(nèi)部使用
定義在函數(shù)外部的為全局變量,可在全局使用
模塊是將包含所有定義的函數(shù)和變量的文件,一般將同類功能的函數(shù)組和在一起稱為模塊。
模塊需要導入后,在調(diào)用相應函數(shù)進行使用
模塊導入的方法:
從模塊中導入一個指定的部分
把一個模塊的所有內(nèi)容全都導入
range()函數(shù)的用法如下:
(1)range(stop)
創(chuàng)建一個(0,stop)之間的整數(shù)序列,步長為1。
(2)range(start,stop)
創(chuàng)建一個(start,stop)之間的整數(shù)序列,步長為1。
(3)range(start,stop,step)
創(chuàng)建一個[start,stop)之間的整數(shù)序列,步長為step。
參數(shù)介紹:
start:表示從返回序列的起始編號,默認情況下從0開始。
stop:表示生成最多但不包括此數(shù)字的數(shù)字。
step:指的是序列中每個數(shù)字之間的差異,默認值為1。
range()是Python的內(nèi)置函數(shù),在用戶需要執(zhí)行特定次數(shù)的操作時使用它,表示循環(huán)的意思。內(nèi)置函數(shù)range()可用于以列表的形式生成數(shù)字序列。在range()函數(shù)中最常見用法是使用for和while循環(huán)迭代序列類型(List,string等)。
簡單的來說,range()函數(shù)允許用戶在給定范圍內(nèi)生成一系列數(shù)字。根據(jù)用戶傳遞給函數(shù)的參數(shù)數(shù)量,用戶可以決定該系列數(shù)字的開始和結束位置以及一個數(shù)字與下一個數(shù)字之間的差異有多大。
標題名稱:python函數(shù)操作方法 python函數(shù)大全
文章出自:http://www.muchs.cn/article14/hphjde.html
成都網(wǎng)站建設公司_創(chuàng)新互聯(lián),為您提供App開發(fā)、面包屑導航、標簽優(yōu)化、響應式網(wǎng)站、網(wǎng)站設計公司、網(wǎng)站建設
聲明:本網(wǎng)站發(fā)布的內(nèi)容(圖片、視頻和文字)以用戶投稿、用戶轉(zhuǎn)載內(nèi)容為主,如果涉及侵權請盡快告知,我們將會在第一時間刪除。文章觀點不代表本網(wǎng)站立場,如需處理請聯(lián)系客服。電話:028-86922220;郵箱:631063699@qq.com。內(nèi)容未經(jīng)允許不得轉(zhuǎn)載,或轉(zhuǎn)載時需注明來源: 創(chuàng)新互聯(lián)