1 函數

在python中的函數，內置函數有很多，如：int(), str(), list(), dict(), set() 等內置整形函數，bool()內置布爾值函數，len()內置長度計算函數 ，等等。在使用這些內置函數時，直接調用即可，且這些函數功能明確，十分方便簡單。但是這些內置函數在我們寫項目時仍然不夠我們使用，有些地功能相同，重復寫相同功能的代碼，代碼冗余，還十分費力，這就需要我們自己寫函數了。

定義函數的基本形式

#定義函數的基本形式

def xxx(a): #def固定語法 xxx函數名 a函數參數

代碼1 #函數內執行代碼

代碼2

代碼3

...

retuen y#y返回值

在python中定義一個函數，固定語法 def ，執行時表示這是一個定義的函數。空格一下與函數名區分開，(xxx)再取函數名，函數名的起名規則與變量相同。后加() 和 ：a 括號內可加不加參數。

另起一行，縮進四個空格，表示下面的代碼是此函數的子代碼快。寫代碼。函數結束需要 return 關鍵字，表示函數執行完畢。y retuen后空格寫返回值，這個返回值是執行此函數之后，得到的值。

在調用函數時有三種方式

xxx() #直接調用

a= xxx() #賦值形式調用

a

b= xxx #賦值函數名,再調用

b()

1.1 函數返回值

函數的返回值有四種形式

#函數不寫retuen

deffun():

a= 1+2rec=fun()print(rec)>>>None#函數返回值為空

deffun1():

a= 1+2

returnrec1=fun1()print(rec1)>>>None#函數返回值有一個值

deffun2():

a= 1+2

returna

rec2=fun2()print(rec2)>>> 3

#函數返回值有多個值

deffun3():

a= 1+2b= 1-2

returna, b

rec3=fun3()print(rec3)>>>(3, -1)

1.2 函數的參數

函數的參數分為形參和實參。實參是調用函數時函數內的參數，形參在定義函數內的參數。函數的實參和形參在函數結束之后隨之結束。

函數的參數類型

位置參數

#位置參數

def fun(x, y): 函數形參第一參數是x, 其次是y。則按照位置對應賦值x = 20, y = 100x+= 1y+= 1

returnx, y

fun(20, 100) #調用函數，函數內第一個參數值是20，其次是100

位置參數形式，傳入實參的個數必須與形參個數保持一致。

默認參數

#形參默認參數形式

def fun(x, y = 100): #x = 10 ,y默認為100

pass

returnx, y

fun(20) #函數第一個位置傳入20

fun(1, 30) #x = 1, y 不在使用默認值100，y = 30

deffunc(x, y):pass

returnx, y

fun(y=10, x=20) #不在受位置的約束，直接指定賦值，這種傳參方式，如果有位置參數，賦值參數必須在位置參數后面

#形參默認參數補充

m= 3

def func(x, y = m): #默認參數以變量名傳參，變量在定義函數前被定義

pass

returnx, y

rec= func(10, 30)

可變參數

當位置參數實參有多個值需要傳入形參中，可以使用可變參數

def func(x, *y):pass

returnx, y

rec= func(0, 1, 2, 3, 4, 5)print(rec)>>>0, (1, 2, 3, 4, 5) #溢出的參數將會以元組的形式保存，元組名是y

當實參是一個一個容器類型，要把里面的值傳入形參

deffunc(x, y, z):pass

returnx, y, z

rec= func(*[1, 2, 3]) #將容器打散，以位置參數形式送入。容器可以是字符串類型，列表類型， 元組類型以及集合

print(rec)>>> 1, 2, 3

實參賦值，有多個需要傳入

def func(**z)： #將賦值變量轉成字典/ z={'a': 0, 'b': 1, 'c': 2}

pass

returnx, y

rec= func(a = 0, b = 1, c =2)

# 反之

def func(a, b, c): # 將賦值變量轉成字典

pass

return a, b, c

z = {'a': 0, 'b': 1, 'c': 2}

rec = func(**z) # 將字典打撒賦值，給形參

print(rec)

可變參數使用十分頻繁。通常我使用的形式是

def func(*args, **kwargs): #python中推薦這樣使用，是實參不管傳入多少值都可以被形參接收

print(args, kwargs)

2 函數對象

函數有函數名，函數名指向的值，稱之為函數對象。

deffunc():print('這是func函數')return

print(func)

>>> # 函數名指向的值

函數對象可以被引用，可以被當作參數傳給另一個變量。也可以當作函數返回值，還可以當作容器類型的元素。

#可以被引用

deffunc():print('這是func函數')return

print(func)#可以被賦值

f =func

f()#可以當作函數返回值

deffunc():print('這是func函數')return func #返回值 func

#可以當作容器類型的參數

lis = [1, 2, 3, func]

3 函數嵌套

函數的嵌套有兩種形式。一種是在調用函數的內部在調用另一個函數。另一種是，在函數內部定義一個函數，并調用。

#函數調用的第一種形式

deff1():print('這是f1函數')deff2():

f1()print('這是f2函數')

f2()>>>這是f1函數

這是f2函數#第二種形式

deff1():deff2():print('這是f2函數')print('這是f1函數')returnf2

rec=f1()

rec()>>>這是f1函數

這是f2函數

4 名稱空間

名稱空間就是名字存在的空間。python中有三種名稱空間。分別是內置名稱空間，全局名稱空間和局部名稱空間。內置空間是python解釋器運行時的空間，在啟動python整個過程始終在其中運作，len , str, int bool, break等這這內置函數名都在內置空間。全局名稱空間是py文件運行時的變量名稱 ，局部空間是自定義函數內的變量名稱。

在調用一個值是，需要一個變量名來綁定，通過變量名可以調用該值。對于變量名的查找，python有自己的規定。程序執行順序是，內置---->全局--->局部。查找名稱的順序則是反著來的且與查找位置有關。如果在局部需要調用該值，查找該值的名稱的順序是先從局部--->全局--->內置。如果在全局調用該值，那么查找改制變量名的順序是先從全局--->內置。

名稱空間中的變量名有作用域。主要有全局作用域，和局部作用域，全局作用域包含內置空間變量名和全局空間變量名，在全局作用都有效。局部作用域就是在局部空間的變量名，在局部空間有效。

在局部要修改全局作用域變量內的值。需要使用global, nonlocal

#在局部修改全局作用域的值#修改一個可變類型

lis =[]deffunc():

lis.append('meKing')print(lis)>>>['meking']#修改一個不可變類型

a = 10

deffunc():global a #在局部聲明，變量來自全局空間。(變量必須為不可變類型)

a = 20func()print(a)>>>20

# 在局部的局部內內修改局部變量(變量為不可變類型)

def func():

a = 20

def f1():

nonlocal a

a = 30

f1()

print(a)

func()

4 閉包函數

閉包函數定義在函數內部，引用外部函數的全局作用域變量名。

#閉包函數

defoutter():def inner(): #定義在函數內部的函數

print('這是inner函數‘)

returninner

rec= outter() #內部函數inner引用全局作用域的變量名rec

函數傳參兩種方式

#函數傳參的第一種方式

deffunc():

x= 1y= 2

definnner()print(x, y)returninner

func()#閉包函數傳參的第二種方式

deffun1(x , y):definner1():print(x, y)returninner

fun1(1, 2)

# 這兩種傳參的效果是一樣的，但是方式二在參數變動時需要修改，明顯比方式一更有優勢

閉包函數傳參應用

#

import requests #requsets,爬蟲的一個庫

f = requests.get('https://www.jd.com') #爬取京東網頁數據

if f.status_code == 200:print(len(f.text)) #打印網頁字符串長度

#如果要多次爬取，我們這樣輸入，很麻煩。#

defindex():

f=requests.get(url)if f.status_code == 200:print(len(f.text))

indx(url)#如果要多次爬，且有不同的網站，這也有點麻煩#

importrequestsdefintto(url):defindex():

f=requests.get(url)if f.status_code == 200:print(len(f.text))returnindex

get_jd= intto('京東地址')

get_baidu= intto('百度地址’)

get_jd()

get_baidu()#這樣爬取次數和，不同內容都比較方便

裝飾器

在不改變原函數的基礎上給原函數添加一個新功能。這就需要裝飾器。裝飾器的特點對外擴展功能開發，對內修改封閉。在使用裝飾器原則是，不改變源碼，不改變被裝飾對象。

#簡單的python裝飾器

defintto(func):definner()print('這是內層函數inner')

func()returninner

index=intto(index)defindex():print('這是index函數')

index()>>>這是內層函數inner>>>這是index函數

語法糖

裝飾器有一個簡便的用法。那就是語法糖。是用@裝飾函數，程序會將最近的下一個函數名做變量名送如裝飾函數中運行，函數返回的內部定義函數的函數名，下一個最近的函數的函數名會接受。在調用原函數的函數名，實質是在調用裝飾函數內定義的函數。

defintto(func):definner()print('這是內層函數inner')

func()returninner

@intto#等價于：index = intto(index)

defindex():print('這是index函數')

index()

裝飾器使用時，我們打印indexd的時候會出現這樣一個信息.inner at 0x00000236268BBB70>。顯示index其實是inner函數。裝飾的函數還是不能和真的一樣。可以用python中的一個方法。

from functools importwrapsdefintto(func):

@wraps(func)definner():print('這是內層函數inner')

func()returninner

@intto#等價于：index = intto(index)

defindex():print('這是index函數')print(index)

>>> # 和原函數一模一樣。如假包換。

1 #無參裝飾器

2 from functools importwraps3 defintto(func):4 @wraps(func)5 def inner(*args, **kwargs):6 print('被裝飾函數執行之前操作！')7 res = func(*args, **kwargs) #被裝飾函數執行

8 print('被裝飾函數執行之后操作！')9 returnres10 returninner11 @intto12 defindex():13 print('被裝飾函數')14

15 #有參裝飾器

16 from functools importwraps17 defouter(data):18 defintto(func):19 @wraps(func)20 def inner(*args, **kwargs):21 print('被裝飾函數執行之前操作！', data)22 res = func(*args, **kwargs) #被裝飾函數執行

23 print('被裝飾函數執行之后操作！')24 returnres25 returninner26 returnintto27 @outer('參數')28 defindex():29 print('被裝飾函數')

有參與無參裝飾器

5 函數遞歸

函數的的遞歸就是函數在調用階段直接或間接調用自己。在python中函數的遞歸有最大的遞歸深度， 在997到998之間。在查看遞歸深度可以使用sys模塊，import sys，在打印sys.getrecursionlimit(),即可查看遞歸深度。當函數遞歸按理論上講可以無限遞歸，但是這中遞歸沒有任何意義，反而會占用大量內存資料，影響計算機的使用。所以跑python需要著這種遞歸深度。還可擴大遞歸深度，也是用sys模塊，sys.setrecursionlimit(n),n是設置的遞歸深度。

有意義的函數遞歸應該包含回溯和遞推。回溯是一次次重復的過程，但是重復就應該使問題復雜度下降，逐漸到達最終結束條件。遞歸：將結果往回推到結果。

# 將列表中的數字打印出來

l1= [1, [2, [3, [4, [5, [6, [7, [8, [9, [10]]]]]]]]]]

def index(lis):for i inlis:if type(i) is int: # 是數字就打印

print(i)else:

index(i) # 否者調用函數index

index(l1)

算法之二分法。算法解決問題是方法。數學王子高斯，在小學時老師讓全班同學計算從1到100的和。當大家都在奮筆疾書取算時，高斯已經算出來了。他發現所有的數，1+100=101，2+99=101...首位相加都是一樣的，這樣的數有50個，就很快算出來5050。對于計算機也一樣，算法的好壞，使計算機執行效率更高。就拿著來說計算1到1億的和，使用while循環，和使用數列計算公式，明顯感覺數列計算公式更加快捷。二分法是算法中的一種，在一個升序或降序數列中。尋找一個數，常規查找是一個一個順序查找，這樣可以找到，如果這個數在最后面，但無疑需要很大工作量。這個就可以用二分法了。被查找值與數列中間的值作比較，如果被查招數大于中間數，就切分列表，往中間數升序方向切分，否則，降序方向切分，切分后的列表在如此，如果找到便結束。這樣就算法的過程就減少了很多。

# 查找列表中某個值

l1= [i for i in range(1, 101)]

def fine(l1, a):

print(l1)ifnot l1: # 如果列表為空，退出

print('不在此列表')returnj= len(l1)//2

if a >l1[j]:

l1= l1[j+1:]

fine(l1, a)

elif a

l1= l1[0:j]

fine(l1, a)else:

print('fine it', a)

fine(l1,98) # 列表l1， 查找98

#列表生成式

li = [i for i in range(100) if i //2 == 0] #0到99之間所有偶數元素，組成的列表

li1 = list('abcdef')

li2= [i for i in li1 if i != 'b'] #'a'到'f'的元素，且沒有'b'#字典生成式

li1 = list('abcdef')

dict_1= {k:v for k,v inenumerate(li1)}print(dict_1)

6 匿名函數及應用

匿名函數和普通函數一樣有固定的語法：lambda 參數：運算方法。結果便是返回值。lambda是關鍵字和普通函數的def相同，是固定的也是必須的的。函數的參數可以是任意類型單個或多個值。運算方法的結果便是返回值。匿名函數只寫一行。

x = 1lambda_1= lambda x : x+1

print((lambda_1)(1)) #和函數調用相同,在后面加括號，此函數需要一個參數，傳入1

>>>2匿名函數的應用#匿名函數和max()，min()

dict_1 = {'a': 4, 'b': 3, 'c': 5, 'd': 2}print(max(dict_1)) #對字典經行排序，但max函數是查值遍歷方式查最大值，但是只能訪問到字典的鍵，無法訪問字典的值。所以一鍵大小來排

print(max(dict_1, key=lambdakey: dict_1[key]))>>>d>>>c#python中A到Z對應數字是65到90，a到z對于數字是97到122

dict_1 = {'a': 4, 'b': 3, 'c': 5, 'd': 2}print(min(dict_1))print(min(dict_1, key=lambda key: dict_1[key]))

#匿名函數與filter 過濾可迭代對象的一些值

l1 = [i for i in range(9) if i > 4]print(filter(lambda x: x != 7, l1)) #這是一個生成器

print(list(filter(lambda x:x != 7, l1))) #遍歷l1中的值，但條件為假直接跳過，開始下次遍歷

#匿名函數與reduce

from functools importreduce

li= [i for i in range(5)]print(reduce(lambda x, y: x + y, li)) #第一次將數列前兩個數送入x, y；得到x+y結果送入參數中，與li下一個參數相加，

# 如此，指導列表中元素沒有位置。得到列表元素和

>>>10

#匿名函數與map#map 映射

li = [i for i in range(5)]print(map(lambda x: x+1, li)) #利用map遍歷，遍歷對象就是列表li,每次遍歷一個值送給x，匿名函數返回x+1的值。這是一個生成器

print(list(map(lambda x: x+1, li)))>>>

>>>[1, 2, 3, 4, 5]

#zip 拉鏈

l1 = [i for i in range(9) if i > 4]

l2= list('abcdefg')

rec1=zip(l2,l1)

l3=dict(rec1)print(l3)>>>{'a': 5, 'b': 6, 'c': 7, 'd': 8}

6 迭代器與生成器

迭代器是常見的一種可以迭代取值的工具，更新重復但每次更新都是基于上一次的結果。在python中可迭代對象的類型有，字符串，列表，元組，字典，集合和文件對象。

判斷是否是可迭代對象，這個可根據雙下iter來判斷。迭代器對象可根據雙下next來判斷

#可迭代對象，雙下iter來判斷

str_1 = 'abcdefg'str_1.__iter__() #可迭代對象

str_1 = 'abcdefg's= str_1.__iter__()

s.__next__() #迭代器對象

在python中迭代器對象一定是可迭代對象，但可迭代對象不一定是迭代器對象。文件對象是迭代器對象。

#雙下iter和雙下next的使用

str_1 = 'abcdefg's= str_1.__iter__() # 傳成迭代器對象print(s.__next__())print(s.__next__())print(s.__next__())print(s.__next__())>>>a

b

c

d

for循環與迭代器

for循環就是經in后面的可迭代對象用__iter__轉成可迭代對象。再使用__next__迭代取值。當取到最后一個值，經行異常處理。

str_1 = '123456789'

for i instr_1:print(i, end=',')deffunc(n):

rec= n.__iter__()whileTrue:try: #異常捕獲

print(rec.__next__())exceptStopIteration:breakfunc(str_1)

小結：可迭代對象內置有__iter__方法，迭代器對象既內置有__iter__也有__next__方法。迭代取值是不依賴索引取值，在內存之占一份空間，對內存資源占小。但是取值的時候只能一個個取，不能取指定元素，取完會報錯StopIteration。

生成器，自定義的迭代器。自定義的迭代器需要用到關鍵字yield。當函數執行到yield時，會暫停，使用雙下next是打印出來，會打印yield后面的值，為空默認為None.

deffunc():for i in range(1, 101):yield f'{i}號球衣'g=func() # 生成器print(g.__next__()) #發衣服

print(g.__next__())print(g.__next__())print(g.__next__())

#for i in range(1, 10, 2): print(i) 實際執行過程

deffunc(start, end, step):while start

start+=step

g= func(1, 10, 2)whileTrue:try:print(g.__next__())exceptStopIteration:break

yield可以傳值。需要使用send函數。

deffunc():whileTrue:

color= yield

print(f'{color}衣服')

g=func()

g.__next__() #使程序運行到yield

g.send('紅色') #給yield賦值

g.send('黃色')

紅色衣服

黃色衣服

yield與return都在函數中。他們都有返回值，并且返回多個值時都是以元組的方式。區別也要很重要。函數執行到return會立即結束。但執行到yield會暫停，且yield還可以傳值。

生成器表達式。例：s = (i for i in range(10))。這里的s就是一個生成器。可以查看s只是一個生成器地址。

生成器的取值不會不會主動，需要用雙下next來取值。

總結

以上是生活随笔為你收集整理的python莫比乌斯环_python基础|函数的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。