函數先定義函數，后調用

一、定義函數：

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函数基础（定义函数、函数参数、匿名函数）...的全部內容，希望文章能夠幫你解決所遇到的問題。

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