python莫比乌斯环_python基础|函数
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基础|函数的全部內容,希望文章能夠幫你解決所遇到的問題。
- 上一篇: 凯利讯半导体滤波器的种类与作用
- 下一篇: 计算机找不到无线设备,win10找不到无