day3-python之函數初識(二)

　　　　目錄
1、爲何要使用函數？
2、函數的定義與調用
　　一、函數的定義
　　二、函數的調用
3、函數的返回值
4、函數的參數
　　一、實參和形參
　　二、傳遞多個參數
　　三、位置參數

5、總結

 

 

 

 

1、爲何要使用函數？

　　　1.避免代碼重用

　　　2.提升代碼的可讀性

例1：統計字符串長度

步驟1：

1 li = [1, 2, 3, 43, 'fdsa', 'alex'] 2 count = 0
3 for i in li: 4     count += 1
5 print(count)

步驟2：

1 s1 = 'fdsgdfkjlgdfgrewioj'
2 
3 count = 0
4 for i in s1: 5     count += 1
6 print(count)

步驟3：

1 s1 = 'fdsgdfkjlgdfgrewioj'
2 def my_len(): 3     count = 0
4     for i in s1: 5         count += 1
6  # print(count) 7 
8 my_len()

 步驟4：

1 def my_len(): 2     count = 0
3     for i in s1: 4         count += 1
5  return count 6 print(my_len()) 7 print(len(s1))

  步驟5：

 1 #函數的傳參  2 li = [1, 2, 3, 43, 'fdsa', 'alex']  3 s1 = 'fdsgdfkjlgdfgrewioj'
 4 
 5 def my_len(a): # 函數的定義（）放的是形式參數，形參  6     count = 0
 7     for i in a:  8         count += 1
 9  return count 10 ret = my_len(li) # 函數的執行（） 實際參數，實參 11 print(ret) 12 print(len(s1))

2、函數的定義與調用

一、函數的定義

def 函數名（參數1，參數2）
　　''' 函數註釋'''
　　print（'函數體'）
　　return 返回值
定義：def關鍵字開頭，空格以後接函數名和圓括號，最後還要加一個冒號。
def是固定的，不能變。
函數名：函數名是包含字母，數字，下劃線的任意組合，可是不能以數字開頭。雖然函數名能夠隨便取名，可是通常儘可能定義成能夠表示函數功能的。

二、函數的調用

返回值=函數名（參數1，參數2）#記得函數名後面加括號

例2：計算字符串的長度

 1 # 1.給定一個字符串，調用函數，當他沒有返回值的時候返回Null  2 def length():  3         s='hello world'
 4         length=0
 5         for i in s:  6                 length+=1
 7  print(length)  8 print(length())  9 
10 
11 # 2.return 必須放在函數裏，當函數有返回值的時候，必須用變量接收纔會有效果 12 def length(): 13         s='hello world'
14         length=0
15         for i in s: 16                 length+=1
17  return length 18 print(length())

3、函數的返回值

1.return的做用:結束一個函數的執行
2.首先返回值能夠是任意的數據類型。
3.函數能夠有返回值：若是有返回值，必需要用變量接收纔有效果
也能夠沒有返回值：
　　沒有返回值的時候分三種狀況：
　　　　1)當不寫return的時候，函數的返回值爲None
　　　　2)當只寫一個return的時候，函數的返回值爲None
　　　　3)return None的時候，函數的返回值爲None（幾乎不用）
4.return返回一個值（一個變量）
5.return返回多個值（多個變量）：多個值之間用逗號隔開，以元組的形式返回。
　　　　　　　　　　　　　　　 接收：能夠用一個變量接收，也能夠用多個變量接收，返回幾個就用幾個變量去接收

 1 ## 函數有一個或多個返回值  2 def func():  3         a=111
 4         b=[1,2,3]  5         c={'a':15,'b':6}  6  #return a#返回一個值  7  #return a,b,c#返回多個值，變量之間按逗號隔開，以元組的形式返回  8 print(func())  9 
10 ## 函數沒有返回值的函數 11 # 1.不寫return時返回None 12 def func(): 13     a=111
14     b=[1,2,3] 15 
16 ret=func() 17 print(ret) 18 
19 
20 # 2.只寫一個return時返回None 21 def func(): 22     a=111
23     b=[1,2,3] 24  return 25 ret=func() 26 print(ret) 27 
28 # 3.return None的時候返回None 29 def func(): 30     a=111
31     b=[1,2,3] 32  return None 33 ret=func() 34 print(ret) 35 
36 ## return的做用 37 def func4(): 38     print (1111111) 39  return#結束一個函數的執行 40     print (1242451) 41 func4() 42 
43 ## 定義一個列表，返回列表的最後一個值 44 方法一 45 def func(): 46     list=['hello','egon',11,22] 47     return list[-1] 48 
49 print(func()) 50 
51 方法二 52 def func(): 53     list=['hello','egon',11,22] 54  return list 55 
56 m,n,k,g=func()# 57 print(g)

4、函數的參數

 1 # 函數定義  2 def fun(s):#參數接受：形式參數，簡稱形參  3     '''  4         計算字符串長度的函數---------函數的功能  5         參數s：接受要計算的字符串--------參數的信息  6         return：要計算字符串長度 ---------返回值得信息  7     '''  8     length=0
 9     for i in s: 10         length+=1
11  return length 12 
13 # 函數調用 14 ret=fun('helloword')#參數傳入：實際參數，簡稱實參 15 print(ret)

一、實參和形參

形參：是函數定義時候定義的參數

實參：是函數調用的時候傳進來的參數

二、傳遞多個參數

參數能夠傳遞多個，多個參數之間用逗號分隔。

1 def mymax(x,y): 2     the_max = x if x > y else y 3  return the_max 4 
5 ma = mymax(10,20) 6 print(ma)

三、位置參數

### 站在實參角度：

　　1）按照位置傳值，必須一一對應，按順序

1 # 按照位置傳參 2 def mymax(x,y): 3     #此時x=10,y=20
4     the_max = x if x > y else y 5  return the_max 6 
7 ma = mymax(10,20) 8 print(ma)

　　2）按照關鍵字傳值必須一一對應，不分順序

1 # 按照關鍵字傳參 2 def mymax(x,y): 3     #此時x = 20,y = 10
4  print(x,y) 5     the_max = x if x > y else y 6  return the_max 7 
8 ma = mymax(y = 10,x = 20) 9 print(ma)

　　3）位置、關鍵字形式混着用，一一對應，且關鍵字參數必須在位置參數後面

1 # 混合傳參 2 def mymax(x,y): 3     #此時x = 10,y = 20
4  print(x,y) 5     the_max = x if x > y else y # 若是x大於y，the_max等於x，不然the_max等於y。 6  return the_max 7 
8 ma = mymax(10,y = 20) 9 print(ma)

 　　正確用法：

　　　　　　位置參數必須在關鍵字參數的前面

　　　　　　對於一個形參只能賦值一次

 1 # 傳遞多個參數，實現比大小的功能  2 def my_max(a,b):#位置參數：按順序定義參數  3     if a>b:  4  return a  5     else:  6  return b  7 # 站在實參的角度上  8 print(my_max(20,30))  9 print(my_max(10,20))# 1.按照位置傳參 10 print(my_max(b=50,a=30))# 2.按照關鍵字傳參 11 print(my_max(10,b=30))#3.位置和關鍵字傳參混搭

  ### 站在形參角度

　　1）按照位置傳值，必須一一對應，按順序

1 def func1(x,y): 2  print(x,y) 3 func1(1,2)

　　2）默認參數，必須在位置參數後面

用法：爲何要用默認參數？將變化比較小的值設置成默認參數（好比一個班的男生多，女生就幾個，就能夠設置個默認值參數）
定義：默認參數能夠不傳，不傳的時候用的就是默認值，若是傳會覆蓋默認值。
　　　默認的值是在定義函數的時候就已經肯定了的

1 # 默認參數 2 def stu_info(name,sex = "male"): 3     """打印學生信息函數，因爲班中大部分學生都是男生，
4         因此設置默認參數sex的默認值爲'male'
5     """ 6  print(name,sex) 7 stu_info('alex') 8 stu_info('gaodong','female')

 

 1 def register(name,sex='男'):  2     with open('register',encoding='utf-8',mode='a') as f1:  3         f1.write('{} {}\n'.format(name,sex))  4 
 5 while True:  6     username = input('請輸入姓名：/q 或者 Q 退出')  7     if username.upper() == 'Q':break  8     if 'a' in username:  9         sex = input('請輸入性別：') 10  register(username,sex) 11     else: 12         register(username)

 默認參數缺陷：默認參數是一個可變數據類型

1 def  default_param(a,l=[]): 2  l.append(a) 3  print(l) 4 
5 default_param('alex') 6 default_param('rgon') 7 
8 輸出：['alex'] 9         ['alex', 'egon']

　　3）動態參數

按位置傳值多餘的參數都由args統一接收，保存成一個元組的形式
按關鍵字傳值接受多個關鍵字參數，由kwargs接收，保存成一個字典的形式

 1 # 接收全部位置參數，保存成一個元組的形式  2 def fun(a,b,*args):  3     sum=a+b  4     for i in args:  5            sum+=i  6     return sum
 7 print(fun(1,5,6,4))#輸出1+5+6+4的和  8 
 9 
10 # 接收全部關鍵字參數，保存成一個字典的形式 11 def fun(a,b,**kwargs): 12  print(a,b,kwargs) 13 
14 fun(a = 10,b = 20,cccc= 30,dddd = 50) 15 # 輸出：10 20 {'cccc': 30, 'dddd': 50} 16 
17 
18 # 位置參數, *args, 默認參數, **kwargs 19 def f(a,b,*args,defult=6,**kwargs): 20     #位置參數，*args, 默認參數，**kwargs 21  # print(a,b,args,defult,kwargs) 22  return a,b,args,defult,kwargs 23 
24 #傳參數的時候：必須先按照位置傳參數，再按照關鍵字傳參數 25 print(f(1,2,7,8,ccc=10,der=5))

 動態參數，也叫不定長傳參，就是你須要傳給函數的參數不少，不定個數，那這種狀況下，你就用*args，**kwargs接收，args是元祖形式，接收除去鍵值對之外的全部參數，kwargs接收的只是鍵值對的參數，並保存在字典中。

 1 def func1(*args,**kwargs):  #　函數的定義 * 聚合。  2  print(args)  3  print(kwargs)  4 l1 = [1,2,3,4]  5 l11 = (1,2,3,4)  6 l2 = ['alex','wusir',4]  7 func1(*l1,*l2,*l11)  # 函數的執行：* 打散功能。  8 # func1(1,2,3,4,'alex','wusir',4,1,2,3,4)  # 函數的執行：* 打散功能。  9 
10 def func1(*args,**kwargs):  #　函數的定義 * 聚合。 11  print(args) 12  print(kwargs) 13 dic1 = {'name1':'alex'} 14 dic2 = {'name2':'laonanhai'} 15 func1(**dic1,**dic2)

5、總結 

# 函數
    # 定義
        # 關鍵字 def 函數名(形參):
        # 參數 ：
            # 位置參數
            # *args  動態傳參 ：接收在調用的時候傳過來的多餘的全部按位置傳的參數
            # 關鍵字參數 默認參數，若是不傳會有一個默認的值，若是傳了會覆蓋默認的值
            # **kwargs  動態傳參 ：接收在調用的時候傳過來的多餘的全部按關鍵字傳的參數
        # 返回值
            # return 中止一個程序的運行，返回參數
                # 沒有返回值 默認返回None
                # 有一個返回值
                # 返回多個值
    # 調用
        # 調用的關鍵字 函數名(實參)
        # 傳參數 ：
            # 按照位置傳
            # 按照關鍵字傳
        # 接收返回值
            # 沒有返回值 不接受
            # 有一個返回值 用一個變量接收
            # 有多個返回值
                # 用一個變量接收 所用返回值都會被組織成一個元組
                # 用多個變量接收 有多少個返回值 就必須用多少個變量接收
# 函數是第一類對象的概念
    # 函數名 --> 函數的內存地址
    # 函數名能夠做爲 容器類型的元素 函數的參數、返回值 還能進行賦值  --> 變量