python定义匿名函数关键字_Python(11):Python函数基础(定义函数、函数参数、匿名函数)...
函數先定義函數,后調用
一、定義函數:
1、簡單的規則:
函數代碼塊以 def 關鍵詞開頭,后接函數標識符名稱和圓括號 ()。
任何傳入參數和自變量必須放在圓括號中間,圓括號之間可以用于定義參數。
函數的第一行語句可以選擇性地使用文檔字符串—用于存放函數說明。
函數內容以冒號起始,并且縮進。
return [表達式] 結束函數,選擇性地返回一個值給調用方。不帶表達式的return相當于返回 None。
2、語法
Python 定義函數使用 def 關鍵字
默認情況下,參數值和參數名稱是按函數聲明中定義的順序匹配起來的。
def函數名(param1,param2……):"""函數功能的描述信息
:param1:描述
:param2:描述
:return:返回值"""code
...return 返回值
3、無參函數
defregister():"""注冊功能"""username= input('username:').strip()
pwd= input('password:').strip()
with open('32.txt', 'a', encoding='utf8') as fa:
fa.write(f"{username}:{pwd}\n")
fa.flush()
4、有參函數
defsum_self(x, y):"""求和"""res= x+yprint(res)
sum_self(1,2) #3
5、空函數
你只知道你需要實現某個功能,但不知道該如何用代碼實現時,你可以暫時寫個空函數
deffunc():pass
二、調用函數及返回值
定義一個函數:給了函數一個名稱,指定了函數里包含的參數,和代碼塊結構。
這個函數的基本結構完成以后,你可以通過另一個函數調用執行,也可以直接從 Python 命令提示符執行。
函數名(param1、param2……)
如:
register()
1、函數運行完畢所有代碼,如果函數體不寫return,則會返回None。
deffoo():pass
print(foo()) #None
2、函數可以返回一個或多個值(元組類型)
deffunc():
name= 'nick'age= 19hobby_list= ['read', 'run']returnname, age, hobby_list
name, age, hobby_list=func()print(name,age,hobby_list) #('nick', 19, ['read', 'run'])
三、函數的參數
1、普通參數,位置必需參數
在函數定義階段,按照從左到右的順序依次定義的形參,稱之為位置形參。
特點:按照位置定義的形參,都必須被傳值,多一個不行,少一個也不行。
deffunc(x, y):print(x)print(y)
在函數調用階段,按照從左到右的順序依次定義的實參,稱之為位置實參。
特點:按照位置為對應的形參依次傳值。
func(1, 2)
2、關鍵字參數
在調用函數時,按照key=value的形式為指定的參數傳值,稱為關鍵字實參。
特點:可以打破位置的限制,但仍能為指定的形參賦值。
func(y=2, x=1)
可以混用位置實參和關鍵字實參,但是位置實參必須在關鍵字實參的左邊。
可以混用位置實參和關鍵字實參,但不能對一個形參重復賦值。
func(x, y=2)
func(y=2, x) #SyntaxError: positional argument follows keyword argument
func(x, x=1) #NameError: name 'x' is not defined
3、默認參數
在定義階段,就已經被賦值。意味著在調用時可以不用為其賦值。位置形參必須放在默認形參的左邊。
def func(x, y=10):print(x)print(y)
func(2)
默認形參的值只在定義階段賦值一次,也就是說默認參數的值在函數定義階段就已經固定了。
m = 10
def foo(x=m):print(x)
m= 111foo()#10
默認參數的值通常應該是不可變類型。
def register(name, hobby, hobby_list=None):
hobby_list=[hobby]print(f"{name} prefer {hobby_list}")
register('nick', 'read') #['read']
register('tank', 'zuipao') #[ 'zuipao']
register('jason', 'piao') #['piao']
#演示形參是可變類型,(列表是可變類型)
def register(name, hobby, hobby_list=None):
hobby_list=[hobby]print(f"{name} prefer {hobby_list}")
register('nick', 'read') #nick prefer ['read']
register('tank', 'zuipao') #tank prefer ['zuipao']
register('jason', 'piao') #jason prefer ['piao']o']
4、不定長參數之*
形參中的*會將溢出的位置實參全部接收,然后存儲元組的形式,然后把元組賦值給*后的參數。需要注意的是:*后的參數名約定俗成為args。
def sum_self(*args):
res=0for num inargs:
res+=numreturnres
res= sum_self(1, 2, 3, 4)print(res) #10
注意:實參之*
實參中的*,*會將*后參數的值循環取出,打散成位置實參。以后但凡碰到實參中帶*的,它就是位置實參,應該馬上打散成位置實參去看。
def func(x, y, z, *args):print(x, y, z, args)
func(1, *(1, 2) , 3, 4) #1 1 2 (3, 4)
5、不定長參數之**
形參中的**會將溢出的關鍵字實參全部接收,然后存儲字典的形式,然后把字典賦值給**后的參數。需要注意的是:**后的參數名約定俗成為kwargs。
def func(**kwargw):print(kwargw)
func(a=5,b=3) #{'a': 5, 'b': 3}
注意:實參之**
實參中的**,**會將**后參數的值循環取出,打散成關鍵字實參。以后但凡碰到實參中帶**的,它就是關鍵字實參,應該馬上打散成關鍵字實參去看。
def func(x, y, z, **kwargs):print(x, y, z, kwargs)
func(1, 3, 4, **{'a': 1, 'b': 2} ) #1 3 4 {'a': 1, 'b': 2}
可變長參數應用
defindex(name, age, sex):print(f"name: {name}, age: {age}, sex: {sex}") #name: nick, age: 19, sex: male
def wrapper(*args, **kwargs):print(f"args: {args}") #args: ()
print(f"kwargs: {kwargs}") #kwargs: {'name': 'nick', 'sex': 'male', 'age': 19}
index( *args, **kwargs)
wrapper(name='nick', sex='male', age=19)
6、命名關鍵字參數
命名關鍵字則是在「位置參數」和「命名關鍵字參數」中使用,*,隔開,后面的即為命名關鍵字。* 后的參數必須用關鍵字傳入。
def student(name, age, *, city, gender):print(name, age, city, gender)
student('xiaoming', 6, city='beijing', gender='male') #xiaoming 6 beijing male
student('xiaoming', 6, 'beijing', 'male') #TypeError: student() takes 2 positional arguments but 4 were given
特點:在傳值時,必須按照key=value的方式傳值,并且key必須命名關鍵字參數的指定的參數名。
def register(x, y, *, name, gender='male', age):print(x)print(name)print(age)
register(1, 2, name1='nick', age=19) #TypeError: register() got an unexpected keyword argument 'name1'
Python3.8 新增了一個函數形參語法, “/” 用來指明函數形參必須使用指定位置參數,不能使用關鍵字參數的形式。
在以下的例子中,形參 a 和 b 必須使用指定位置參數,c 或 d 可以是位置形參或關鍵字形參,而 e 或 f 要求為關鍵字形參:
def f(a, b, /, c, d, *, e, f):print(a, b, c, d, e, f)
以下使用方法是正確的:
f(10, 20, 30, d=40, e=50, f=60)
四、函數對象
函數是第一類對象,即函數可以被當做數據處理。
deffunc():print('from func')print(func) #
1、函數當作參數傳給一個另一函數
deffunc():print('from func')deffoo(m):
m()
foo(func)#from func
2、函數當作另一函數的返回值
deffunc():print('from func')deffoo(x):returnx
res=foo(func)print(res) #
3、函數可以當作容器類型的元素
deffunc():print('from func')
function_list=[func]
function_list[0]()#from func
五、函數遞歸
遞歸的精髓在于通過不斷地重復逼近一個最終的結果。
age(1)=26,age(n)=age(n-1)+2 ,求age(5)的值:
'''...
age(5) = age(4) + 2
age(4) = age(3) + 2
age(3) = age(2) + 2
age(2) = age(1) + 2
age(1) = 26
age(n) = age(n-1) +2
age(1) = 26 # n=1'''
defage(n):if n == 1:return 26res= age(n-1) + 2
returnresprint(f"age(5): {age(5)}")
遞歸的本質就是干重復的活。
lis = [1, [2, [3, [4, [5, [6, ]]]]]]deftell(lis):for i inlis:if type(i) islist:
tell(i)else:print(i)
tell(lis)
二分法的思想實現查找數字。
from random importrandint
nums= [randint(1, 100) for i in range(100)]
nums=sorted(nums)defsearch(search_num, nums):print(nums)
mid_index= len(nums) // 2
if notnums:print('not exists')return
if search_num >nums[mid_index]:#in the right
nums = nums[mid_index + 1:]
search(search_num, nums)elif search_num
nums =nums[:mid_index]
search(search_num, nums)else:print('find it')
search(7, nums)
六、匿名函數:
python 使用 lambda 來創建匿名函數。
所謂匿名,意即不再使用 def 語句這樣標準的形式定義一個函數。
lambda 只是一個表達式,函數體比 def 簡單很多。
lambda的主體是一個表達式,而不是一個代碼塊。僅僅能在lambda表達式中封裝有限的邏輯進去。
lambda 函數擁有自己的命名空間,且不能訪問自己參數列表之外或全局命名空間里的參數。
雖然lambda函數看起來只能寫一行,卻不等同于C或C++的內聯函數,后者的目的是調用小函數時不占用棧內存從而增加運行效率。
1、語法
lamdbda 參數 : 邏輯代碼
#可寫函數說明
sum = lambda arg1, arg2: arg1 +arg2#調用sum函數
print ("相加后的值為 :", sum( 10, 20))print ("相加后的值為 :", sum( 20, 20 ))
匿名函數,他沒有綁定名字,使用一次即被收回,加括號既可以運行。
print(lambda x, y: x + y ) #(x, y)>
res = (lambda x, y: x + y)(1, 2)print(res) #3
lambda 匿名函數也是可以使用"關鍵字參數"進行參數傳遞,也可以設定默認值。
g = lambda x=0, y=0: x ** 2 + y ** 2
print(g(2, 3))#13
print(g(2))#4
print(g(y=3))#9
2、與內置函數聯用
匿名函數通常與max()、sorted()、filter()、sorted()方法聯用。
1.max()
如果我們想從上述字典中取出薪資最高的人,我們可以使用max()方法,但是max()默認比較的是字典的key。
首先將可迭代對象變成迭代器對象
res=next(迭代器對象),將res當做參數傳給key指定的函數,然后將該函數的返回值當做判斷依據
salary_dict ={'nick': 3000,'jason': 100000,'tank': 5000,'sean': 2000}print(max(salary_dict)) #tank
deffunc(k):returnsalary_dict[k]print(max(salary_dict, key=func)) #jason
print(max(salary_dict, key=lambda name: salary_dict[name] ) ) #jason 匿名函數
2.sorted()
如果我們想對上述字典中的人,按照薪資從大到小排序,可以使用sorted()方法。
首先將可迭代對象變成迭代器對象
res=next(迭代器對象),將res當做參數傳給第一個參數指定的函數,然后將該函數的返回值當做判斷依據。
lis = [1, 3, 2, 5, 8, 6]
sorted(lis)print(lis) #[1, 3, 2, 5, 8, 6]
print(sorted(lis, reverse=True)) #[8, 6, 5, 3, 2, 1]
salary_dict={'nick': 3000,'jason': 100000,'tank': 5000,'sean': 2000}print(sorted(salary_dict, key=lambda name: salary_dict[name] )) #['sean', 'nick', 'tank', 'jason']
3.map()
如果我們想對一個列表中的某個人名做處理,可以使用map()方法。
首先將可迭代對象變成迭代器對象
res=next(迭代器對象),將res當做參數傳給第一個參數指定的函數,然后將該函數的返回值作為map()方法的結果之一。
name_list = ['jason', 'tank', 'sean']
res= map(lambda name: f"{name} sb", name_list)print(list(res)) #['jason sb', 'tank sb', 'sean sb']
4.filter()
如果我們想篩選除名字中含有'sb'的名字,我們可以使用filter()方法。
首先將可迭代對象變成迭代器對象
res=next(迭代器對象),將res當做參數傳給第一個參數指定的函數,然后filter會判斷函數的返回值的真假,如果為真則留下。
name_list = ['nick', 'jason sb', 'tank sb', 'sean sb']
filter_res= filter(lambda name: name.endswith('sb'), name_list)print(list(filter_res)) #['jason sb', 'tank sb', 'sean sb']
七、內置函數
共68個:
abs()、 all()、 any()、 ascii()、 bin()、 bool()、 bytearray()、 bytes()、 callable()、 chr()、 classmethod()、 compile()、 complex()、 delattr()、
dict()、 dir()、 divmod()、 enumerate()、 eval()、 exec()、 filter()、 float()、 format()、 frozenset()、 getattr()、 globals()、 hasattr()、 hash()、
help()、 hex()、 id()、 input()、 int()、 isinstance()、 issubclass()、 iter()、 len()、 list()、 locals()、 map()、 max()、 memoryview()、
min()、 next()、 object()、 oct()、 open()、 ord()、 pow()、 print()、 property()、 range()、 repr()、 reversed()、 round()、 set()、
setattr()、 slice()、 sorted()、 staticmethod()、 str()、 sum()、 super()、 tuple()、 type()、 vars()、 zip()、 __import__()、
1.bytes():解碼字符。
res = '你好'.encode('utf8')print(res) #b'\xe4\xbd\xa0\xe5\xa5\xbd'
res = bytes('你好', encoding='utf8')print(res) #b'\xe4\xbd\xa0\xe5\xa5\xbd'
2.chr()/ord():chr()參考ASCII碼表將數字轉成對應字符;ord()將字符轉換成對應的數字。
print(chr(65)) #A
print(ord('A')) #65
3.divmod():分欄。
print(divmod(10, 3)) #(3, 1)
4.enumerate():帶有索引的迭代。
l = ['a', 'b', 'c']for i inenumerate(l):print(i)#(0, 'a')#(1, 'b')#(2, 'c')
5.eval():把字符串翻譯成數據類型。
lis = '[1,2,3]'lis_eval=eval(lis)print(lis_eval) #[1, 2, 3]
6.hash():是否可哈希。
print(hash(1)) #1
7.abs():求絕對值。
print(abs(-13)) #13
8.all():可迭代對象內元素全為真,則返回真。
print(all([1, 2, 3, 0])) #False
print(all([])) #True
9.any():可迭代對象中有一元素為真,則為真。
print(any([1, 2, 3, 0])) #True
print(any([])) #False
10.bin()/oct()/hex():二進制、八進制、十六進制轉換。
print(bin(17)) #0b10001
print(oct(17)) #0o21
print(hex(17)) #0x11
11.dir():列舉出所有time的功能。
importtimeprint(dir(time))#['_STRUCT_TM_ITEMS', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'altzone', 'asctime', 'clock', 'ctime', 'daylight', 'get_clock_info', 'gmtime', 'localtime', 'mktime', 'monotonic', 'perf_counter', 'process_time', 'sleep', 'strftime', 'strptime', 'struct_time', 'time', 'timezone', 'tzname', 'tzset']
12.frozenset():不可變集合。
s = frozenset({1, 2, 3})print(s) #({1, 2, 3})
13.globals()/loacals():查看全局名字;查看局部名字。
#print(globals())
deffunc():
a= 1
#print(globals())
print(locals())
func()#{'a': 1}
14.pow():
print(pow(3, 2, 3)) #(3**2)%3 =0
15.round():
print(round(3.5)) #4
16.slice():
lis = ['a', 'b', 'c']
s= slice(1, 4, 1)print(lis[s]) #['b', 'c']#print(lis[1:4:1])
17.sum():
print(sum(range(100))) #4950
18.__import__():通過字符串導入模塊。
m = __import__('time')print(m.time()) #1556607502.334777
19. 面向對象知識點
classmethod
staticmethod
property
delattr
hasattr
getattr
setattr
isinstance()
issubclass()
object()
super()
總結
以上是生活随笔為你收集整理的python定义匿名函数关键字_Python(11):Python函数基础(定义函数、函数参数、匿名函数)...的全部內容,希望文章能夠幫你解決所遇到的問題。
- 上一篇: 如何开一家精品水果店 要结合自身的条件
- 下一篇: python numpy官网_pytho