5.python的基礎語法元素_函數

#-*- coding: utf-8 -*-
print("===========函數的定義及調用===========")
#函數的定義及調用
#函數三要素：參數、函數體、返回值
# 函數定義 求正方形的面積
def area_of_square(length_of_side):
    square_area = pow(length_of_side,2)
    return square_area

#函數調用  函數名(參數)
area = area_of_square(5)
print (area)

#參數的傳遞
#形參（形式參數）：函數定義時的參數，實際上就是變量名
#實參（實際參數）：函數調用時的參數，實際上就是變量的值

#位置參數 嚴格按照位置順序，用實參對形參進行賦值（關聯） 一般用在參數比較少的時候
#形參與實參必須一一對應，一個不能多，一個不能少
def function(x,y,z):
    print (x,y,z)

function(1,2,3)
#關鍵字參數
#打破位置限制，直呼其名的進行值的傳遞(形參=實參）
#必須遵守實參與形參數量上的一一對應 多用在參數比較多的場合
def function1(x,y,z):
    print(x,y,z)
function1(y = 1, z = 2, x = 3)
#位置參數可以與關鍵字參數混合使用，但是位置參數必須放在關鍵字參數前面
function1(1,z=2,y=3)
#不能爲同一個形參重複傳值
def function2(x,y,z):
    print(x,y,z)
#function2(1, z=2, x = 3) 報錯
#默認參數 在定義階段就給形參賦值 -- 該形參的常用值
#機器學習庫中類的方法裏非常常見 調用函數時，可以不對該參數傳值
def register(name,age,sex="male"):
    print(name,age,sex)
register("andy",18)
#也可以按正常的形參進行傳值
register("linzhiling",38,"female")
#默認參數應該設置爲不可變類型(數字、字符串、元組)
#不能是可變類型，比如如下所示的列表，列表的地址不發生變化，具有記憶功能
# 但是它裏面的內容會發生變化
def function3(ls=[]):
    print (id(ls)) #打印ls列表的地址
    ls.append(1)
    print (id(ls))
    print (ls)

function3()
function3()
function3()
#同一個函數我們把形參改成字符串,我們可以看到每次地址都發生來變化，無記憶功能
def function4(ls="Python"):
    print (id(ls))
    ls += "3.7"
    print (id(ls))
    print (ls)

function4()
function4()
function4()
#把不確定是否會使用的參數設置成None，讓參數變成可選的
def name(first_name,last_name,middle_name=None):
    if middle_name:
        return first_name+middle_name+last_name
    else:
        return first_name+last_name

print(name("da","zai"))
print(name("da","zai","jie"))
#4.可變長參數 *args
#不知道會傳過來多少參數 *args 該形參必須放在參數列表道最後
def foo(x,y,z,*args):
    print (x,y,z)
    print (args)

foo(1,2,3,4,5,6)  #多餘道參數，打包傳遞給args
#實參打散
def foo1(x,y,z,*args):
    print (x,y,z)
    print (args)
foo1(1,2,3,[4,5,6]) #[4,5,6]這個列表作爲作爲元組道一個元素而存在
foo1(1,2,3,*[4,5,6]) #將列表中道元組打散，作爲一個個單獨的元素
#可變長參數 **kwargs 它的用法和字典有關
def foo2(x,y,z, **kwargs):
    print(x,y,z)
    print(kwargs)

foo2(1,2,3, a=4,b=5,c=6)#多餘的參數，以字典的形式打包傳遞給kwargs
#字典實參打散
def foo3(x,y,z,**kwargs):
    print (x,y,z)
    print (kwargs)

foo3(1,2,3,**{"a":4,"b":5,"c":6})
#可變長參數的組合使用
def foo4(*args,**kwargs):
    print(args)
    print(kwargs)

foo4(1,2,3,a=4,b=5,c=6)

#函數體與變量的作用域
#函數體就是一段只在函數被調用時，纔會執行的代碼，代碼構成與其他代碼並無不同
#局部變量   僅在函數體內定義和發揮作用
def multipy(x,y):
    z = x*y
    return z

multipy(2,9)
#print (z) 這裏報錯，因爲函數執行完畢，局部變量z已經被釋放掉了
#全局變量  外部定義的都是全局變量 全局變量可以在函數體直接使用
n = 3
ls = [0]
def multify1(x,y):
    z = n*x*y
    ls.append(z)
    return z
print (multify1(2,9))

#通過global在函數體內定義全局變量
def multipy2(x,y):
    global c
    c = x*y
    return c

multipy2(2,9)
print (c)

#返回值
#單個返回值
def foo5(x):
    return x**2

#多個返回值 -- 以元組的形式
def foo6(x = 1):
    return 1,x,x**2,x**3
print (foo6(3))
a,b,c,d = foo6(3)  #解包賦值
print (a,b,c,d)

#可以有多個return語句，一旦其中一個執行，代表了函數運行的結束
def is_holidy(day):
    if day in ["Sunday","Saturday"]:
        return "Is holiday"
    else:
        return "Not holiday"
    print ("lalalala damaxiya") #沒機會運行

print(is_holidy("Sunday"))
print(is_holidy("Monday"))
#沒有return語句，返回值爲None
def foo7():
    print("我是孫悟空")

res = foo7()
print (res)



print("=================函數式編程=================")
#我們用一個例子解釋一下什麼是函數式編程
#小A和小B進行比賽，小A每球獲勝的概率爲55%，小B每球獲勝的概率爲45%，每局比賽，先贏21球者獲勝
#假設進行 n=10000局獨立的比賽，小A會獲勝多少?(n較大但時候，實驗結果≈真實期望)

def main():
    #主要邏輯
    prob_A, prob_B, number_of_games = get_inputs() #獲取原始數據，小A每球獲勝概率，小B每球獲勝概率，比賽場次
    win_A,win_B = sim_n_games(prob_A,prob_B,number_of_games) #獲取小A贏了多少場，小B贏了多少場
    #print_summary(win_A,win_B,number_of_games)  #將獲取但結果打印輸出

#輸入原始數據
def get_inputs():
    #輸入原始數據
    prob_A = input('請輸入運動員A的每球獲勝概率：')
    prob_B = round(1-prob_A,2)
    number_of_gamgs = input("請輸入模擬但場次（正整數): ")
    # print("模擬比賽總次數：",number_of_gamgs)
    # print("A 選手每球獲勝概率：",prob_A)
    # print("B 選手每球獲勝概率：",prob_B)
    return prob_A,prob_B,number_of_gamgs

#單元測試
prob_A,prob_B,number_of_games = get_inputs()
#print (prob_A,prob_B,number_of_games)

#多場比賽模擬
def sim_n_games(prob_A,prob_B,number_of_gmaes):
    #模擬多場比賽但結果
    win_A,win_B = 0,0  #初始化A，B獲勝但場次
    for i in range(number_of_games):
        score_A, score_B = sim_one_game(prob_A,prob_B) #獲得模擬一次比賽但比分
        if score_A > score_B:
            win_A += 1
        else:
            win_B += 1

    return win_A,win_B

import random
def sim_one_game(prob_A,prob_B):
    #模擬一場比賽但結果
    score_A,score_B = 0,0
    while not game_over(score_A,score_B):
        if random.random() < prob_A:
            score_A += 1
        else:
            score_B += 1
    return score_A,score_B

def game_over(score_A,score_B):
    return  score_A == 21 or score_B == 21


#單元測試 用 asser---斷言
#表達式結果爲false但時候觸發異常
assert game_over(21,8) == True

if __name__ == "__main__":
    main()


print("==============匿名函數===============")
#匿名函數 基本形式 lambda 變量：函數體
#常用用法 在參數列表中最適合使用匿名函數 尤其是 key = 搭配
#排序sort()  sorted()
ls = [(93,88),(79,100),(86,71),(85,85),(76,94)] #默認根據每一個元組的第一個元素進行升序排列
ls.sort()
print(ls)
#如果我們想要根據每個元組但第二個元素進行排序，則可以使用匿名函數完成
ls.sort(key = lambda x:x[1]) #按照key這個元素設置的量進行排序，每個元素x也就是可迭代對象裏的單個元素，根據每個元素的第一個位置(第2個元素)的值進行排序
print (ls)

ls1 = [(93,88),(79,100),(86,71),(85,85),(76,94)]
temp = sorted(ls,key=lambda x:x[0]+x[1],reverse=True) #根據總成績進行排序
print (temp)
#max() min()
ls2 = [(93,88),(79,100),(86,71),(85,85),(76,94)]
n = max(ls,key=lambda x:x[1]) #找到第二個元素的最大值
print (n)
n = min(ls,key=lambda x:x[1]) #找到第二個元素的最小值
print (n)

print ("============面向對象和麪向過程=============")
#面向過程 已過程爲中心的編程思想，以“什麼正在發生”爲主要目標進行編程。 冰冷的 程序化的
#面向對象  將現實生活中的事物抽象成對象，更關注"誰在受影響"，更加貼近現實 有血有肉，擬人的（物）化的