Python函數基礎（定義函數、函數引數、匿名函數）

2022-05-28 18:01:25

一、定義函數：

1、簡單的規則：

函數程式碼塊以 def 關鍵詞開頭，後接函數識別符號名稱和圓括號 ()。
任何傳入引數和自變數必須放在圓括號中間，圓括號之間可以用於定義引數。
函數的第一行語句可以選擇性地使用檔案字串—用於存放函數說明。
函數內容以冒號起始，並且縮排。
return [表示式] 結束函數，選擇性地返回一個值給呼叫方。不帶表示式的return相當於返回 None。

2、語法

Python 定義函數使用 def 關鍵字

預設情況下，引數值和引數名稱是按函數宣告中定義的順序匹配起來的。

def 函數名(param1,param2……):
"""
函數功能的描述資訊
:param1：描述
:param2：描述
:return：返回值
"""
code
...
return 返回值

3、無參函數

def register():
    """註冊功能"""
    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、有參函數

def sum_self(x, y):
    """求和"""
    res = x+y
    print(res)

sum_self(1,2)  # 3

5、空函數

你只知道你需要實現某個功能，但不知道該如何用程式碼實現時，你可以暫時寫個空函數

def func():
    pass

二、呼叫函數及返回值

定義一個函數：給了函數一個名稱，指定了函數裡包含的引數，和程式碼塊結構。

這個函數的基本結構完成以後，你可以通過另一個函數呼叫執行，也可以直接從 Python 命令提示字元執行。

函數名(param1、param2……)

如：

register()

1、函數執行完畢所有程式碼，如果函數體不寫return，則會返回None。

def foo():
    pass

print(foo()) #None

2、函數可以返回一個或多個值(元組型別)

def func():
    name = 'nick'
    age = 19
    hobby_list = ['read', 'run']
    return name, age, hobby_list


name, age, hobby_list = func()
print(name,age,hobby_list) #('nick', 19, ['read', 'run'])

三、函數的引數

1、普通引數，位置必需引數

在函數定義階段，按照從左到右的順序依次定義的形參，稱之為位置形參。

特點：按照位置定義的形參，都必須被傳值，多一個不行，少一個也不行。

def func(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 = 111
foo()  # 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 = 0
    for num in args:
        res += num
    return res


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}

可變長引數應用

def index(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)

四、函數物件

函數是第一類物件，即函數可以被當做資料處理。

def func():
    print('from func')


print(func)  #

1、函數當作引數傳給一個另一函數

def func():
    print('from func')


def foo(m):
    m()


foo(func)  # from func

2、函數當作另一函數的返回值

def func():
    print('from func')


def foo(x):
    return x


res = foo(func)
print(res)  #

3、函數可以當作容器型別的元素

def func():
    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
'''


def age(n):
    if n == 1:
        return 26
    res = age(n-1) + 2
    return res


print(f"age(5): {age(5)}")

遞迴的本質就是乾重復的活。

lis = [1, [2, [3, [4, [5, [6, ]]]]]]


def tell(lis):
    for i in lis:
        if type(i) is list:
            tell(i)
        else:
            print(i)


tell(lis)

二分法的思想實現查詢數位。

from random import randint

nums = [randint(1, 100) for i in range(100)]
nums = sorted(nums)


def search(search_num, nums):
    print(nums)
    mid_index = len(nums) // 2
    if not nums:
        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[mid_index]:
        # in the left
        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


def func(k):
    return salary_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'xe4xbdxa0xe5xa5xbd'
res = bytes('你好', encoding='utf8')
print(res)  # b'xe4xbdxa0xe5xa5xbd'

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 in enumerate(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的功能。

import time
print(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())
def func():
    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函數的文章就介紹到這了。希望對大家的學習有所幫助，也希望大家多多支援it145.com。