函數返回值和參數進階

目標

# 函數參數和返回值的做用
# 函數的返回值 進階
# 函數的參數 進階
# 遞歸函數

01.函數參數和返回值的做用

# 函數根據 有沒有參數 以及 有沒有返回值，能夠相互組合，一共有4種組合形式
# 1.無參數，無返回值
# 2.無參數，有返回值
# 3.有參數，無返回值
# 4.有參數，有返回值

定義函數時，是否接收參數，或者是否返回結果，是根據實際功能需求來決定的！

# 1.若是函數內部處理的數據不肯定，就能夠將外界的數據以參數傳遞到函數內部
# 2.若是但願一個函數執行完成後，向外界彙報執行結果，就能夠增長函數的返回值

 02.函數的返回值 進階

# 在程序開發中，有時候，會但願一個函數執行結束後，告訴調用者一個結果，
以便調用者針對具體的結果作後續的處理
# 返回值是函數完成工做後，最後給調用者的一個結果
# 在函數中使用 return 關鍵字能夠返回結果
# 調用函數一方，可使用變量來接收函數的返回結果

問題：一個函數執行後可否返回多個結果？

示例——溫度和溼度測量

假設要開發一個函數可以同時返回當前的溫度和溼度

def measure():
    """測量溫度和溼度"""
    print("測量開始...")
    temp = 39
    wetness = 50
    print("測量結束。。。")
　　# 利用元組在返回溫度的同時，也可以返回溼度
    # 元組-能夠包含多個數據，所以可使用元組讓函數一次返回多個值
    # 若是函數返回的類型是元組，小括號能夠省略
    # return(temp,wetness)
    return temp,wetness
result = measure()
print(result)

接收返回元組函數的方式

# 當函數執行完成以後，result中保存的數據是元組
result = measure()
print(result)
# 要單獨的處理溫度或者溼度 記錄單獨的下標 不方便
print(result[0])
print(result[1])
# 若是函數返回的類型是元組，同時但願單獨的處理元組中的元素
# 可使用多個變量，一次接收函數的返回結果
# 注意：使用多個變量接收結果時，變量的個數應該和元祖中元素的個數保持一致
gl_temp,gl_wetness = measure()

print(gl_temp)
print(gl_wetness)

面試題——交換兩個數字

題目要求

# 1.有兩個整數變量 a = 6，b = 100
# 2.不使用其餘變量，交換兩個變量的值

# 解法1- 使用其餘變量
a = 6
b = 100

c = a
a = b
b = c
print(a)
print(b)

# 解法2- 不使用其餘變量
a = 6
b = 100

a = a + b
b = a - b
a = a - b
print(a)
print(b)

#解法3- Python專有，利用元組
a = 6
b = 100

# a,b = (b,a)
# 提示：等號右邊是一個元組，只是把小括號省略了
a,b = b,a

print(a)
print(b)

 

03.函數的參數 進階

3.1 不可變和可變的參數

問題1：在函數內部，針對參數使用賦值語句，會不會影響調用函數時傳遞的實參變量？

不會！　　　　不管傳遞的參數是可變仍是不可變，只要針對參數使用賦值語句，會在函數內部修改局部變量的引用，不會影響到外部變量的引用

def demo(num,num_list):
    print("函數內部的代碼")
    # 在函數內部，針對參數使用賦值語句,不會修改到外部的實參變量
    num = 100
    num_list = [1,2,3]
    print(num)
    print(num_list)
    print("函數執行完成")
gl_num = 99
gl_list = [4,5,6]
demo(gl_num,gl_list)
print(gl_num)
print(gl_list)

問題2：若是傳遞的參數是可變類型，在函數內部，使用方法修改了數據的內容，一樣會影響到外部的數據

def demo(num_list):
    print("函數內部的代碼")
    # 使用方法修改列表的內容
    num_list.append(9)

    print(num_list)
    print("函數執行完成")

gl_list = [1,2,3]
demo(gl_list)
print(gl_list)

 

面試題—— +=

在Python中，列表變量調用+=本質上是在執行列表變量的extend方法，不會修改變量的引用

def demo(num,num_list):
    print("函數開始")
    # 本質上是在作 num = num + num
    num += num
    print(num)
    num_list += num_list
    # 本質上並不是 num_list = num_list + num_list
    # 而是調用列表的extend方法
    # 列表變量使用+=不會作相加再賦值的操做
    # 即影響並修改了全局變量中的列表變量調用
    # 因爲是調用方法，因此不會修改變量的引用
    # 函數執行結束後，外部數據一樣會發生變化
    # num_list.extend(num_list)
    print(num_list)
    print("函數完成")

gl_num = 9
gl_list = [1,2,3]
demo(gl_num,gl_list)
print(gl_num)
print(gl_list)

 

3.2 缺省參數

# 定義函數時，能夠給某個參數指定一個默認值，具備默認值的參數就叫作缺省參數
# 調用函數時，若是沒有傳入缺省參數的值，則在函數內部使用定義函數時指定的參數默認值
# 函數的缺省參數，將常見的值設置爲參數的缺省值，從而簡化函數的調用
# 例如：對列表排序的方法

gl_list = [6,3,9]
# sort方法若是不傳遞參數，默認按照升序排列-由於較爲經常使用
gl_list.sort()
# 若是須要按照降序排列,須要執行reverse參數
gl_list.sort(reverse=True)
# reverse就是缺省參數，若是不傳遞任何參數就會採用默認值，reverse的默認值是false
# 函數的缺省參數，將常見的值設置爲參數的缺省值，從而簡化函數的調用
print(gl_list)

指定函數的缺省參數

在參數後使用賦值語句，能夠指定參數的缺省值

def print_info(name,gender = True):
    """
    :param name: 班上同窗的姓名
    :param gender:True 男生 False 女生
    """
    gender_text = "男生"
    if not gender:
        gender_text = "女生"

    print("%s 是 %s"%(name,gender_text))

#假設班上的同窗，男生居多！
# 提示：在指定缺省參數的默認值時，應該使用最多見的值做爲默認值
print_info("小明")
print_info("小美",False)

提示

1.缺省參數，須要使用最多見的值做爲默認值

2.若是一個參數的值不能肯定，則不該該設置默認值，具體的數值在調用函數時，由外界傳遞！

缺省參數的注意事項

1）缺省參數的定義位置

必須保證帶有默認值的缺省參數在參數列表末尾

因此如下定義是錯誤的

def print_info(name,gender=True,title):

2）調用帶有多個缺省參數的函數

在調用函數時，若是有多個缺省參數，須要指定參數名，這樣解釋器纔可以知道參數的對應關係！

# 例如當定義了三個參數，須要定義肯定的參數，在後面直接寫上參數名跟上要傳遞的實參
def print_info(name,title="",gender=True)

print_info("小美",gender=False)

3.3 多值參數

定義支持多值參數的函數

#有時可能須要 一個函數 可以處理的參數 個數 是不肯定的，這個時候，就可使用 多值參數
#Python中有兩種多值參數：
#     參數名前增長一個 * 能夠接收 元組
#     參數名前增長兩個 * 能夠接收 字典

# 通常在給多值參數命名時，習慣使用如下兩個名字
#    *args - 存放元組參數，前面有一個 *
#    **kwargs - 存放字典參數，前面有兩個 *
#args 是 arguments 的縮寫，右邊梁的含義
#kw 是 keyword 的縮寫，kwargs 能夠記憶 鍵值對參數

def demo(num,*nums,**person):
    print(num)
    print(nums)
    print(person)

# 1爲實參num的參數，2345爲*nums的元組參數，
# name = "小明"爲**person的字典參數 
# 當輸入時能夠看到下方提示所屬參數
demo(1,2,3,4,5,name = "小明")

提示：多值參數 的應用會常常出如今網絡上一些大牛開發的框架中，知道多值參數，有利於咱們可以讀懂大牛的代碼

 多值參數案例 ——  計算任意多個數字的和

需求

1.定義一個函數 sum_numbers,能夠接收的任意多個整數

2.功能需求：將傳遞的全部數字累加而且返回累加結果

def sum_numbers(*args):
# def sum_numbers(args):
# 當使用*指令的參數和沒有*指令的參數，在調用函數時
# *指令的元組參數無需無需多加一對括號，
# 而沒有*指令的則須要在多個數據外再加個括號
# 若是想要調用任意多個參數，能夠在參數名前加個*
    num = 0

    print(args)
    # 循環遍歷
    for n in args:
        num += n
    return num
result = sum_numbers(1,2,3)
# result = sum_numbers((1,2,3))
print(result)

元組和字典的拆包

# 在調用帶有多支參數的函數時，若是但願：
        將一個元組變量，直接傳遞給 args
        將一個字典變量，直接傳遞給kwargs
# 就可使用拆包，簡化參數的傳遞，拆包的方式：
        在元組變量前，增長一個*
        在字典變量前，增長兩個*

def demo(*args,**kwargs):
    print(args)
    print(kwargs)

#元組變量/字典變量
gl_nums = (1,2,3)
gl_dict = {"name": "小明","age": 18}

# demo(gl_nums,gl_dict)
# 會致使兩個變量都在args參數中輸出，而kwargs參數只能輸出一個空的字典{}
# 因此就須要使用到拆包語法，簡化元組變量/字典變量的傳遞
demo(*gl_nums,**gl_dict)
# 下面的方法也稱爲拆包語法，只是沒有上面的方便
# demo(1,2,3,name="小明",age = 18)

 

04.函數的遞歸

函數調用自身的編程技巧稱爲遞歸

4.1遞歸的函數特色

特色

　　一個函數 內部 調用本身

　　函數內部能夠調用其餘函數，固然在函數內部也能夠調用本身

代碼特色

1.函數內部的代碼是相同的，只是針對參數不一樣，處理結果不一樣

2.當參數知足一個條件時，函數再也不執行

　　這個很是重要，一般被稱爲遞歸的出口，不然會出現死循環，形成程序出錯！

def sum_number(num):
    print(num)
    # 在編寫遞歸程序時，須要有一個遞歸的出口，當參數知足某個條件時，再也不執行函數
    if num == 1:
        return
    # 本身調用本身
    sum_number(num - 1)

sum_number(3)

4.2 遞歸案例 —— 計算數字累加

需求

1.定義一個函數 sum_numbers

2.可以接收一個 num 的整數參數

3.計算 1+2+...num 的結果

# 定義一個函數 sum_numbers
# 可以接收一個 num 的整數參數
# 計算 1+2+...num 的結果

def sum_numbers(num):
    # 1.設置出口
    if num == 1:
        return 1
    # 2.數字的累加 num + (1...num - 1)
    # 假設 sum_numbers 可以正確的處理1...num-1
    temp = sum_numbers(num - 1)
    # 兩個數字的相加
    return  num + temp

result = sum_numbers(5)
print(result)

 

提示：遞歸是一個編程技巧，初次接觸遞歸會感受有些吃力！在處理不肯定的循環條件時，格外的有用，例如：遍歷整個文件目錄的結構