day 9 - 1 函數

函數

函數：定義了以後，能夠在任何須要它的地方調用

函數模擬 len() 方法

#len() 方法的使用
s="世界上惟一不變的就是變化"
print(len(s))

#下面是咱們經常使用的 len() 方法的使用 
s="世界上惟一不變的就是變化"
print(len(s))

#下面咱們來使用函數模擬 len() 方法 
s="世界上惟一不變的就是變化"
def my_len():  #def 關鍵字定義函數 聲明函數
    i=0
    for j in s:
        i=i+1
    print(i)
my_len()  #調用函數

這樣咱們便實現了使用函數來計算長度的功能，但這並非咱們想要的

與 len() 相比的不一樣
1.不能變，只能計算 s 字符串的長度
2.只是輸出告終果
3.沒有返回值

咱們先來解決返回值的問題（還有 print() 打印結果的問題）

s="世界上惟一不變的就是變化"
def my_len():
    i=0
    for j in s:
        i=i+1
    return i  #設定返回值

#而後咱們能夠賦值的調取
length = my_len()
print(length)

#咱們也能夠直接調取，是否是發現什麼
print(my_len())

#是否是和下面 len() 又相近了些
s="世界上惟一不變的就是變化"
print(len(s))

返回值
return 表示結束一個函數
　　與 break 的區別：break 跳出循環，函數的循環後面若是還有內容，則繼續執行
　　return 直接結束函數
return 的做用：執行過該關鍵字後，不在實行後面的內容

下面咱們來看看返回值的各類狀況

1.沒有返回值——當沒有返回值時 默認爲 None
　　1）不寫 return——經常使用
　　2）只寫 return——經常使用
　　　　1.2一、與 break 的區別
　　3) return None——最不經常使用
2.返回一個值
　　1）數字、字符串、列表、字典 都是能夠的,便可以返回任何數據類型
　　注意：
　　　　1. 只要返回就能夠接守
　　　　2. 若是在一個程序中有多個 return，那麼只執行第一個
3.返回多個值
　　1）多個返回值用多個變量接受，有幾個返回值就用多少變量接收
　　2）若是多個值，用一個返回值來接收，則返回一個元組

#1.1 不寫 return——經常使用
def func():
    s = ['anc','ghj']
    for j in s:
        print(j)
value = func()
print(value)


#1.2 只寫 return——經常使用
def func():
    s = ['anc','ghj']
    for j in s:
        print(j)
    return
value = func()
print(value)


#1.21 與 break 的區別
def func():
    s = ['anc','ghj']
    for j in s:
        print(j)
#        break   #當執行 break 時，循環將再也不進行 而打印下面「=」
        return   #當執行 return 時，中止循環且不執行 「=」
    print('='*10)
ret = func()
print(ret)

#1.3 return None——最不經常使用
def func():
    s = ['anc','ghj']
    for j in s:
        print(j)
        return None
    print('='*10)
ret = func()
print(ret)

#2.1 返回一個值
def func():
    return ['f','g']
print(func())

#3.1 多個返回值用多個變量接受
def func2():
    return 1,2
r1,r2 = func2()
print(r1)
print(r1)

#3.2 多個值，用一個返回值來接收
def func2():
    return 1,2
r1 = func2()
print(r1)

咱們接着來解決（不能變，只能計算 s 字符串的長度）的問題

使用形式參數來接收參數的方式，使 my_len 能夠處理任意實際參數的值
在使用形式參數來寫函數時，形式參數沒必要有對應的值

def my_len(s):   #自定義函數只須要 0 個參數，此處爲接收參數或叫形式參數，簡稱：形參
    i=0          #注意：形參處的 s 值必須與 for 循環中 s 值保持一致 
    for j in s:
        i=i+1
    return i     #採用形式函數時，此處沒有 return 時，值返回 None
#print(my_len()) #這樣寫就會報錯，此處爲傳遞參數或叫實際參數，或叫實參（由於沒傳遞參數）


k="習慣是十倍的天性"
s="世界上惟一不變的就是變化"
ret = my_len(s)  #傳參
ret2 = my_len(k)
ret3 = my_len([1,2,3])
print(ret)
print(ret2)
print(ret3)

#或者
print(my_len(s))
print(my_len(k))
print(my_len([1,2,3]))

#有沒有發現和下面 len() 方法的使用變得一致了
s="世界上惟一不變的就是變化"
print(len(s))

參數

下面咱們來較爲詳細的瞭解下參數

#參數
    #沒有參數
        #定義函數和調用函數時括號裏都不寫內容
    #有一個參數
        #傳什麼就是什麼
    #有多個參數
        #位置參數

#下面咱們來看下位置參數
def my_sum(a,b):
    print(a,b)
    res=a+b   #result
    return res

#咱們來重點看下 a b 的值分別是什麼，由於結果都是同樣的
ret=my_sum(12,23)    # 12 23
print(ret)

ret2 = my_sum(b=23,a=12) #這裏爲關鍵字傳參，即指定參數對應的位置
print(ret2)          # 12 23

ret3 = my_sum(23,12) # 23 12
print(ret3) 

 

站在實參的角度上
　　按照位置傳參
　　按照關鍵字傳參
　　混着用能夠：可是 必須先按照位置傳參，再按照關鍵字傳參數
　　注意：不能給同一個變量傳多個值

站在形參的角度上
　　位置參數：必須傳,且有幾個參數就傳幾個值
　　默認參數：能夠不傳，若是不傳就是用默認的參數，若是傳了就用所傳的參數

下面咱們來了解下默認參數

#帶默認參數的函數
def classmate(name,sex='男'):    #參數中有倆個值：形參，默認參數性別爲男
    print('%s: %s'%(name,sex))   #適合於在輸入某些值時，大多的值是相同的狀況
classmate('諾娃',"女")
classmate('雷諾')
classmate('薩爾')

只有調用函數的時候
　　按照位置傳：直接寫參數的值
　　按照關鍵字：關鍵字 = 值

定義函數的時候：
　　位置參數：直接定義參數
　　默認參數，關鍵字參數：參數名 = '默認的值'
　　動態參數：能夠接受任意多個參數
　　　　參數名以前加 *，習慣參數名 args 
　　　　參數名以前加 **，習慣參數名 kwargs 
順序：位置參數，*args，默認參數，**kwargs 

下面咱們來了解下動態參數

###動態參數
#求任意數的和
def sum(*args): #關鍵字「*」
    n=0
    for i in args:
        n+=i
    return n

print(sum(12,23,13))
print(sum(14,25,36,123))


#注意：**kwargs 只能接受關鍵字傳參
def func(**kwargs):  #關鍵字「**」
    print(kwargs)

func(a = 1,b = 2,c = 3)
func(a = 1,b = 2)
func(a = 1)
func(1,2,c = 3)  #報錯 **kwargs 只能接收關鍵字傳參的值

下面咱們較爲詳細的瞭解下動態參數

動態參數有兩種：能夠接受任意個參數
　　1. *args 只接收位置參數的值，不能接收關鍵字傳參的值
　　　　組織成一個元組
　　2. **kwargs 只能接收關鍵字傳參的值
　　　　組織成一個字典
　　3. args 必須在 kwargs 以前

#注意：傳參時必須先傳位置參數在傳關鍵字參數
def func(*args,**kwargs):
    print(args,kwargs)
func(1,2,3,4,a='5',b='6')#傳參時必須先傳位置參數在傳關鍵字參數 

#動態參數的另外一種傳參方式
def func(*args):  #站在形參的角度上，給變量加上*，就是組合全部傳來的值
    print(args)
func(1,2,3,4,5)

l=[1,2,3,4,5]
func(*l)  #站在實參的角度上，給一個序列加上*，就是將這個序列按照順序打散

#**kwargs 與 *args 邏輯同樣，類推就能夠了
def func(**kwargs):
    print(kwargs)
func(a=1,b=2,c=3)

d={'a':4,'b':5,'c':6}
func(**d)

函數的註釋

def func():
    #這個函數實現了什麼功能
    #參數1：
    #參數2：
    #:return: 是字符串或者列表的長度
    pass

默認參數的陷阱

若是默認參數的值是一個可變數據類型
那麼每一次調用函數的時候
若是不傳值就公用這個數據類型的資源

def qqxing(f = []):
    f.append(1)
    print(f)
qqxing([])  #表示使用了自定義參數
qqxing()    #表示使用了默認參數 因此下面每次調用參數都在同一個列表中遞增
qqxing()
qqxing()


def qqxing2(k,f={}):
    f[k] = 'v'
    print(f)

qqxing2(1)
qqxing2(2)
qqxing2(3)

###回顧

函數
　　1.函數的定義 def
　　2.函數的調用
　　3.函數的返回值 return
　　4.函數的參數
　　　　形參：
　　　　　　位置參數：必須傳
　　　　　　*args：能夠接收任意多個位置參數
　　　　　　默認參數：能夠不傳
　　　　　　**kwargs：能夠接收多個關鍵字參數
　　　　實參：按照位置傳參，按照關鍵字傳參