一、函數的定義、調用、返回值、參數。

一、函數介紹

1.1：函數是什么？

函數是組織好的，可重復使用的，用來實現單一，或相關聯功能的代碼段。

函數能提高應用的模塊性，和代碼的重復利用率。你已經知道Python提供了許多內建函數，比如print()。但你也可以自己創建函數，這被叫做用戶自定義函數。

1.2：為什么要使用函數？

　　　1.避免代碼重用

　　　2.提高代碼的可讀性

 

二、函數的定義與調用

2.1：定義規則

你可以定義一個由自己想要功能的函數，以下是簡單的規則：

• 函數代碼塊以 def 關鍵詞開頭，后接函數標識符名稱和圓括號 ()。
• 函數名是包含字母，數字，下划線的任意組合，但是不能以數字開頭。
• 任何傳入參數和自變量必須放在圓括號中間，圓括號之間可以用於定義參數。
• 函數的第一行語句可以選擇性地使用文檔字符串—用於存放函數說明。
• 函數內容以冒號起始，並且縮進。
• return [表達式] 結束函數，選擇性地返回一個值給調用方。不帶表達式的return相當於返回 None。

2.2：語法

def  函數名（參數1，參數2）:

　　　''' 函數注釋'''

　　　print（'函數體'）

　　　return 返回值　

2.3：函數的調用

• 定義一個函數：給了函數一個名稱，指定了函數里包含的參數，和代碼塊結構；
• 這個函數的基本結構完成以后，你可以通過另一個函數調用執行，也可以直接從 Python 命令提示符執行；
• 返回值=函數名（參數1，參數2）#記得函數名后面加括號；

實例1：

1.給定一個字符串，調用函數，當他沒有返回值的時候返回Null
def  length():
        s='hello world'
        length=0
        for i in s:
                length+=1
        print(length)
print(length())
#輸出結果：
True

2.return 必須放在函數里，當函數有返回值的時候，必須用變量接收才會有效果
def  length():
        s='hello world'
        length=0
        for i in s:
                length+=1
        return  length
print(length())
#輸出結果：
True

實例2：

def mylen():   #函數定義
    """計算s1的長度"""
    s1 = "hello world"
    length = 0
    for i in s1:
        length = length+1
    print(length)

mylen()   #函數調用

  

##定義：

　　  def 關鍵詞開頭，空格之后接函數名稱和圓括號()，最后還有一個":"。

　　  def 是固定的，不能變，他就是定義函數的關鍵字。

　　  空格 為了將def關鍵字和函數名分開，必須空(四聲)，當然你可以空2格、3格或者你想空多少都行，但正常人還是空1格。

　  　函數名：函數名只能包含字符串、下划線和數字且不能以數字開頭。雖然函數名可以隨便起，但我們給函數起名字還是要盡量簡短，並能表達函數功能

　  　括號：是必須加的，先別問為啥要有括號，總之加上括號就對了！

##注釋：

　  　每一個函數都應該對功能和參數進行相應的說明，應該寫在函數下面第一行。以增強代碼的可讀性。

##調用：

　  　就是 函數名() 要記得加上括號。

實例3：

#!/usr/bin/python3
 
# 定義函數
def printme( str ):
   "打印任何傳入的字符串"
   print (str)
   return
 
# 調用函數
printme("我要調用用戶自定義函數!")
printme("再次調用同一函數")

#輸出結果：
我要調用用戶自定義函數!
再次調用同一函數

三、函數的返回值

函數的最后都有一個返回值return，可以用來獲取該函數執行結果返回給該函數，讓外部調用該函數的根據返回的值不同做不同的事。

返回值可指定，如果不指定默認返回None。

實例1：

#函數定義
def mylen():
    """計算s1的長度"""
    s1 = "hello world"
    length = 0
    for i in s1:
        length = length+1
    return length

#函數調用
str_len = mylen()
print('str_len : %s'%str_len)

return 返回值

實例2：

def test1():
    print('alex')
print(test1())
 
def test2():
    a = 5
    if a < 5:
        return True
    else:
        return False
print(test2())
 
#根據返回的值進行其他判斷
if test2():
    print('yes')
else:
    print('no')
　
#輸出結果：
alex
None

False
no

3.1：沒有返回值

不寫return的情況下，會默認返回一個None：

#函數定義
def mylen():
    """計算s1的長度"""
    s1 = "hello world"
    length = 0
    for i in s1:
        length = length+1
    print(length)

#函數調用
str_len = mylen()
#因為沒有返回值，此時的str_len為None
print('str_len : %s'%str_len)

沒有return

只寫return，后面不寫其他內容，也會返回None，既然沒有要返回的值，為什么還要寫個return呢？return的另外一個用法，就是一旦遇到return，結束整個函數：

def ret_demo():
    print(111)
    return
    print(222)

ret = ret_demo()
print(ret)

只寫return

3.2：返回一個值

只需在return后面寫上要返回的內容即可：

#函數定義
def mylen():
    """計算s1的長度"""
    s1 = "hello world"
    length = 0
    for i in s1:
        length = length+1
    return length

#函數調用
str_len = mylen()
print('str_len : %s'%str_len)

return返回一個值

3.3：返回多個值

可以返回任意多個、任意數據類型的值：

def ret_demo1():
    '''返回多個值''' 
    return 1,2,3,4


def ret_demo2():
    '''返回多個任意類型的值'''
    return 1,['a','b'],3,4

ret1 = ret_demo1()
print(ret1)
ret2 = ret_demo2()
print(ret2)

返回多個值

return返回多個值

返回的多個值會被組織成元組被返回，也可以用多個值來接收：

def ret_demo2():
    return 1,['a','b'],3,4 #返回多個值，用一個變量接收
ret2 = ret_demo2()
print(ret2)

#返回多個值，用多個變量接收
a,b,c,d = ret_demo2()
print(a,b,c,d)

#用多個值接收返回值：返回幾個值，就用幾個變量接收
a,b,c,d = ret_demo2()
print(a,b,c,d)

多個返回值的接收

四、函數的參數

4.1.參數和傳參

我們告訴mylen函數要計算的字符串是誰，這個過程就叫做 傳遞參數，簡稱傳參，我們調用函數時傳遞的這個“hello world”和定義函數時的s1就是參數。

實例1：

#函數定義
def mylen(s1):
    """計算s1的長度"""
    length = 0
    for i in s1:
        length = length+1
    return length

#函數調用
str_len = mylen("hello world")
print('str_len : %s'%str_len)

#輸出結果：
True

實例2：

def fun(s):#參數接受：形式參數，簡稱形參。
    '''
        計算字符串長度的函數---------函數的功能
        參數s：接受要計算的字符串--------參數的信息
        return：要計算字符串長度 ---------返回值得信息
    '''
    length=0
    for i in s:
        length+=1
    return length

ret=fun('helloword')#參數傳入：實際參數，簡稱實參
print(ret)

#輸出結果：
True

4.2.實參和形參

• 形參：是函數定義時候定義的參數
• 實參：函數調用的時候傳進來的參數

def my_len(argv):  # 形式參數 ，形參

    count = 0
    for i in argv:
        count += 1
    return count
s = 'lkfjsjulkjdgjdsf'
l1 = [1, 2, 3, 4, 5]
# my_len(s)  # 實際參數， 實參
print(my_len(l1))

4.3.傳遞多個參數

可以傳遞多個參數，多個參數之間用逗號隔開。

def mymax(x,y):
    the_max = x if x > y else y
    return the_max

ma = mymax(10,20)
print(ma)

4.4：實參角度

4.4.1.位置參數（按順序一一對應）

def mymax(x,y):
    #此時x=10,y=20
    the_max = x if x > y else y
    return the_max

ma = mymax(10,20) #10,20必須和x，y按順序一一對應
print(ma)

#比較兩個數大小
def func1(a,b):
    if a > b:
        return a
    else:
        return b
print(func1(30,20))

#精簡版：
def max(a, b): return a if a > b else b
ret = 1 if 2 > 1 else 6
print(ret)
print(max(10, 2))
#或者：
def func1(a,b): retu
print(func1(30,20))

4.4.2.關鍵字參數（有指向性不在乎順序，但是也要一一對應）

def mymax(x,y):
    #此時x = 20,y = 10
    print(x,y)
    the_max = x if x > y else y
    return the_max

ma = mymax(y = 10,x = 20)
print(ma)

def func2(a, b):
    print(a, b)
func2(b=2, a=3)

4.4.3.混合參數（關鍵字參數必須在位置參數的后面）

def mymax(x,y):
    #此時x = 10,y = 20
    print(x,y)
    the_max = x if x > y else y
    return the_max

ma = mymax(10,y = 20)
print(ma) 

def func3(a, b, c, d):
    print(a, b, c, d)
func3(1,2,d=3,c=5)

4.5：形參角度

4.5.1.位置參數（按順序一一對應）

def func1(a, b, c):
print(a, b, c)
func1(1, 2, 'alex')

4.5.2.默認參數（默認參數在位置參數的后面）

• 用法：將變化比較小的值設置成默認參數（比如一個班的男生多，女生就幾個，就可以設置個默認值參數）；
• 定義：默認參數可以不傳，不傳的時候用的就是默認值，如果傳會覆蓋默認值。默認的值是在定義函數的時候就已經確定了的；
• 缺陷：默認參數是一個可變數據類型；

def func1():
print(a, b, c)
func1(1, 2, 'alex')
def login(name,sex='男'):
with open('register', encoding='utf-8', mode='a') as f1:
f1.write('{},{}\n'.format(name,sex))
while True:
name = input('請輸入姓名：').strip()
if '1' in name:  #輸入男的時候前面加1
login(name)
else:
sex = input('請輸入性別：').strip()
login(name,sex)

def stu_info(name,sex = "male"):
    """打印學生信息函數，由於班中大部分學生都是男生，
        所以設置默認參數sex的默認值為'male'
    """
    print(name,sex)
stu_info('alex')
stu_info('海亮','male')

默認參數

def defult_param(a,l = []):
    l.append(a)
    print(l)

defult_param('alex')
defult_param('egon')

默認參數是個可變類型

4.5.3.動態參數

動態參數，也叫不定長傳參，就是你需要傳給函數的參數很多，不定個數，那這種情況下，你就用*args（元組形式）和**kwargs（字典形式）接收，接收除去鍵值對以外的所有參數，kwargs接收的只是鍵值對的參數，並保存在字典中。

• 所有位置參數，由args統一接收，放在一個元組；
  
• 所有關鍵字參數，由kwargs接收，放在一個字典中；
  
• *在函數定義的時候代表聚合；
• *在函數執行的時候代表打散；

 *args的應用

def fun(a,b,*args):
    sum=a+b
    for i in args:
           sum+=i
    return sum
print(fun(1,5,6,4))  #輸出1+5+6+4的和

>>> def fun1(*args):
...     for item in args:
...             print item
... 
>>> fun1(1, 'hello', True)
1
hello
True

>>> def fun1_1(arg1, arg2, arg3):
...     print arg1
...     print arg2
...     print arg3
... 
>>> args = ['hello', 3]
>>> 
>>> fun1_1('test', *args)
test
hello
3

 

*kwargs的應用

def fun(a,b,**kwargs):
    print(a,b,kwargs)

# 按照關鍵字傳參數
fun(a = 10,b = 20,cccc= 30,dddd = 50)#輸出10 20 {'cccc': 30, 'dddd': 50}



def f(a,b,*args,defult=6,**kwargs):
    #位置參數，*args, 默認參數，**kwargs
    # print(a,b,args,defult,kwargs)
    return a,b,args,defult,kwargs

#傳參數的時候：必須先按照位置傳參數，再按照關鍵字傳參數
print(f(1,2,7,8,ccc=10,der=5))

>>> def fun2(**kwargs):
...     for k in kwargs:
...             print "%s:%s" % (k, kwargs[k])
... 
>>> fun2(hello=1, world=2, welcome=3)
world:2
welcome:3
hello:1

>>> def fun2_2(arg1, hello, world):
...     print 'arg1:', arg1
...     print 'arg2:', hello
...     print 'arg3:', world
... 
>>> kwargs = {'hello':3, 'world':2}
>>> fun2_2(1, **kwargs)
arg1: 1
arg2: 3
arg3: 2

 **kwargs 打包關鍵字參數成dict給函數體調用

注意：參數arg、*args、**kwargs三個參數的位置必須是(arg,*args,**kwargs)這個順序，否則程序會報錯。

 

 

4.5.4.形參的順序

位置參數 ---》*args ---》默認參數 ---》**kwargs

def func5(a,b,*args,sex='男',**kwargs):
    print(a,b,)
    print(args)
    print(sex)
    print(kwargs)

4.6：內置函數

Python3.6內置參數詳解：https://docs.python.org/3/library/functions.html#next