python-函數（上）：函數返回值、函數調用、前向引用

編程方法：

1、面向對象：類--class
2、面向過程：過程--def
3、函數式編程：函數--def

# python中函數
# 函數的定義
# 打印一個佛祖鎮樓 -> 一個功能點的解釋
def print_info():print("                            _ooOoo_  ")
    print("                           o8888888o  ")
    print("                           88  .  88  ")
    print("                           (| -_- |)  ")
    print("                            O\\ = /O  ")
    print("                        ____/`---'\\____  ")
    print("                      .   ' \\| |// `.  ")
    print("                       / \\||| : |||// \\  ")
    print("                     / _||||| -:- |||||- \\  ")
    print("                       | | \\\\\\ - /// | |  ")
    print("                     | \\_| ''\\---/'' | |  ")
    print("                      \\ .-\\__ `-` ___/-. /  ")
    print("                   ___`. .' /--.--\\ `. . __  ")
    print("                ."" '< `.___\\_<|>_/___.' >'"".  ")
    print("               | | : `- \\`.;`\\ _ /`;.`/ - ` : | |  ")
    print("                 \\ \\ `-. \\_ __\\ /__ _/ .-` / /  ")
    print("         ======`-.____`-.___\\_____/___.-`____.-'======  ")
    print("                            `=---='  ")
    print("  ")
    print("         .............................................  ")
    print("                  佛祖鎮樓                  BUG辟易  ")
    print("          佛曰:  ")
    print("                  寫字樓里寫字間，寫字間里程序員；  ")
    print("                  程序人員寫程序，又拿程序換酒錢。  ")
    print("                  酒醒只在網上坐，酒醉還來網下眠；  ")
    print("                  酒醉酒醒日復日，網上網下年復年。  ")
    print("                  但願老死電腦間，不願鞠躬老板前；  ")
    print("                  奔馳寶馬貴者趣，公交自行程序員。  ")
    print("                  別人笑我忒瘋癲，我笑自己命太賤；  ")
    print("                  不見滿街漂亮妹，哪個歸得程序員？")
a = 10
if a == 10:
    # pass 占位 防止語法錯誤
    print_info()
# 函數 -> python

函數是邏輯結構化和過程化的一種編程方法
python中函數定義方法：

def test(x):
　　"The function definitions"
　　x+=1
　　return x

def：定義函數的關鍵字
test :函數名
（）：內可定義形參
“”：文檔描述（非必要，但是強烈建議為你的函數添加描述信息）
x+=1：泛指代碼塊或程序處理邏輯
return：定義返回值

#函數
def func1():
    "testing1"
    print("in the func1")
    return 0
#過程
def func2():
    "testing2"
    print("in the func2")
x = func1()  # in the func1
y = func2()  # in the func2
print("from func1 return is %s"%x)  # from func1 return is 0
print("from func2 return is %s"%y)  # from func2 return is None

使用函數的三大優點：
1.代碼重用
2.保持一致性
3.可擴展性

函數返回值
返回值數=0:返回None（沒有return的情況）
返回值數=1:返回object
返回值數>1:返回tuple(返回一個元組)

如：

def test01():
    pass
def test02():
    return 0
def test03():
    return 0,10,'Hello',['alex','lb'],{'WuDaLang':'lb'}
t1 = test01()
t2 = test02()
t3 = test03()
print("from test01 return is [%s]:"%type(t1),t1)
print("from test01 return is [%s]:"%type(t2),t2)
print("from test01 return is [%s]:"%type(t3),t3)

函數調用
調用方法：通過 函數名() 即可完成調用
test()執行，()表示調用函數test，()內可用有參數也可以沒有

注意：

• 每次調用函數時，函數都會從頭開始執行，當這個函數中的代碼執行完畢后，意味着調用結束了
• 當然了如果函數中執行到了return也會結束函數

參數：
1.形參和實參

• 定義時小括號中的參數，用來接收參數用的，稱為 “形參”
• 調用時小括號中的參數，用來傳遞給函數用的，稱為 “實參”

形參：形式參數，不是實際存在，是虛擬變量。在定義函數和函數體的時候使用形參，目的是在函數調用時接收實參（實參個數，類型應與形參一一對應）
實參：實際參數，調用函數時傳給函數的參數，可以是常量，變量，表達式，函數，傳給形參
區別：形參是虛擬的，不占用內存空間，形參變量只有在被調用時才分配內存單元，實參是一個變量，占用內存空間，數據傳送單向，實參傳給形參，不能形參傳給實參

# 定義一個有參數的函數
# 形參: 形式參數
# 格式: def 函數名(形參1, 形參2, ...):
def my_func(a, b):
    ret = a + b
    print(ret)
# 執行一個有參數的函數
# 實參: 實際參數
# 格式: 函數名(實參1, 實參2,...)
num1 = 80
num2 = 9
# 在執行函數的時候 就好比是a = num1 b = num2
my_func(num1, num2)

2.位置參數和關鍵字（標准調用：實參和形參位置一一對應；關鍵字調用：位置無需固定）

def test(x,y):
    print(x)
    print(y)
test(1,2)     #位置參數調用，實參的位置與形參的位置要一一對應
test(y=2,x=1) #關鍵字參數，調用函數的時候使用的是函數的形參名，與形參順序無關
test(3,y=2)   #混合使用時，位置參數在前，關鍵字參數在后，關鍵字參數是不能寫在位置參數前面的

3.默認參數（缺省參數）: 給形參設置了一個默認值

def test(x,y=2):
    print(x)
    print(y)
test(1)
test(1,y=3)
test(1,3)
#默認參數特點：調用函數的時候，默認參數非必須傳遞

4.參數組

# *args: 接受N個位置參數，轉換成元組形式
def test(*args):    #參數不固定
    print(args)
test(1,3,2,4,5)
test(*[1,2,4,5,5])  #args = tuple([1,2,4,5,5])
def test1(x,*args):
    print(x)
    print(args)
test1(1,2,3,4,5,6,7)

 

# **kwargs:接受N個關鍵字參數，轉換成字典的方式
def test2(**kwargs):
    print(kwargs)
    print(kwargs['name'])
    print(kwargs['age'])
    print(kwargs['sex'])
test2(name='alex',age=8,sex='F')
test2(**{'name':'alex','age':8,'sex':'F'})
def test3(name,**kwargs):
    print(name)
    print(kwargs)
test3('alex')     #后面接收一個空字典
test3('alex',age=18,sex='m')
def test4(name,age=18,**kwargs):   #參數組要放后面
    print(name)
    print(age)
    print(kwargs)
test4('alex',sex='m',hobby='tesla')
test4('alex',5,sex='m',hobby='tesla')
test4('alex',sex='m',hobby='tesla',age=3)
def test5(name,age=18,*args,**kwargs):   #參數組要放后面
    print(name)
    print(age)
    print(args)
    print(kwargs)
test5('alex',age=34,sex='m',hobby='tesla')

函數返回值

# python 學習了 一個內置函數 len(object)
# 定一個字符串
my_str = "hello"
# 內置函數如何實現的
def my_len(object):
    ret = 0
    for i in object:
        ret += 1
    # 如果有一個return 數值 成為這個函數有返回值
    return ret
my_l = my_len(my_str)
# None 沒有返回值 空值類型
print("自定義的:",my_l)  # 自定義的: 5
l = len(my_str)
print(l)  # 5

# 四種函數的類型
# 01- 無參數無返回值
def my_print():
    print("你好")
    print("python")
# 執行函數
my_print()
# 02- 無參數有返回值
def my_pi():
    return 3.1415926
print(my_pi())
# 03- 有參數無返回值
def print_info(name):
    print("你好%s" % name)
print_info("龜叔")
# 04- 有參數有返回值def my_func(a, b):
    return a - b
result = my_func(10, 5)
print(result)

函數返回值之多個return

• 一個函數中可以有多個return語句，但是只要有一個return語句被執行到，那么這個函數就會結束了，因此后面的return沒有什么用處

• 如果程序設計為如下，是可以的因為不同的場景下執行不同的return

# 包含多個return
def my_func(score):
    if score < 0:
        print("您傳入的分數有誤!!!")
        return          # 函數的執行提前結束
    print("測試")
    # 對分數進行判斷
    if score >= 90:
        return "優"
    elif score >= 80:
        return "良"
    elif score >= 60:
        return "中"
    elif score >= 0:
        return "差"
    print("測試")      # 不會執行 因為在前面已經執行了return
# 提出需求 如果調用函數的人 傳入的分數小於0 那么就人為傳入的分數錯誤 告知函數的調用者
my_func(-10)

函數返回多個數據

• return后面可以是元組，列表、字典等，只要是能夠存儲多個數據的類型，就可以一次性返回多個數據
• 如果return后面有多個數據，那么默認是元組

# 需求 傳入一個人名字 和年齡，例如 小明 22
# 通過調用函數后 得到兩個字符串 姓名:小明  年齡:22
# 列表
def deal_name_age(name, age):
    # 處理后 姓名:小明  年齡:22
    new_name = "姓名:%s" % name
    new_age = "年齡:%d" % age
    return [new_name, new_age]
# 變量為列表
ret = deal_name_age("小明", 22)
print(ret[0])
print(ret[1])
# 字典
def deal_name_age(name, age):
    # 處理后 姓名:小明  年齡:22
    new_name = "姓名:%s" % name
    new_age = "年齡:%d" % age
    return {"name":new_name, "age":new_age}
my_dict = deal_name_age("小明", 22)
print(my_dict["name"])
print(my_dict["age"])
# 元組
def deal_name_age(name, age):
    # 處理后 姓名:小明  年齡:22
    new_name = "姓名:%s" % name
    new_age = "年齡:%d" % age
    # 如果在函數內部 使用return 返回值1 返回值2,... 默認就是元組類型 不需要寫小括號
    return new_name, new_age
my_tuple = deal_name_age("小明", 22)
print(type(my_tuple))  # <class 'tuple'>
print(my_tuple[0])  # 姓名:小明
print(my_tuple[1])  # 年齡:22

函數的嵌套調用

一個函數里面又調用了另外一個函數，這就是所謂的函數嵌套調用

def my_func1():
    print("my_func1開始")
    print("my_func1結束")
def my_func2():
    print("my_func2開始")
    my_func1()
    print("my_func2結束")
# 執行函數
my_func2()
"""
# 最終打印結果
my_func2開始
my_func1開始
my_func1結束
my_func2結束
"""

如果函數A中，調用了另外一個函數B，那么先把函數B中的任務都執行完畢之后才會回到上次 函數A執行的位置

前向引用
函數action體嵌套某一函數logger，該logger的聲明必須早於action的調用，否則報錯

def action():
    print("in the action")
    logger()
action()
def logger():
    print("in the logger")
#報錯：NameError: name 'logger' is not defined

 

def logger():
    print("in the logger")
def action():
    print("in the action")
    logger()
action()

 

def action():
    print("in the action")
    logger()
def logger():
    print("in the logger")
action()