函數

一、寫函數的時候，要儘量以功能爲導向，結果最好不要直接在函數中打印

例：

def my_len():          # 函數名的定義
    l = [1,2,3,4,5,6]
    count = 0
    for i in l:
        count += 1
    return count      # 函數的返回值
ret = my_len()         # 函數的調用  以及  返回值的接收
print(ret)  

    #沒有返回值：

    1.不寫return == returnNone
    2.只寫一個return == return None
    3.return的作用：1、返回一個值  2、終止一個函數的繼續

   #返回一個值：可以返回任意的數據類型。返回什麼就接受什麼

   #返回多個值：用一個變量接收返回值，接收到的是一個元組
          返回值有多個變量接收，那麼返回值得個數應該和接受變量的個數完全一致
二、參數(可以傳任意數據類型)
①形參、

1.位置參數：

數量必須與實參一致(必須傳的參數)

2.默認(關鍵字)參數(儘量避免使用可變參數)：

①不傳參數時使用默認值，若傳了參數則使用傳入的參數。

def classmate(name,sex='男'): 
    print('姓名：%s，性別：%s'(name,sex))
classmate('小A')   # 姓名：小A，性別：男
classmate('小B')  # 姓名：小B，性別：男
classmate('小C','女')  # 姓名：小C，性別：女

②魔性的用法：

def func(li = [])
    li.append(1)
    print(li)
func()        # [1]
func()        # [1,1]
-------------
def func(l):
    l.append(1)
    print(l)
func([])        # [1]
func([])         # [1]

3.動態參數(見下邊)：

*args：接收所有按位置傳的參數
**kwargs：接收所有按關鍵字傳的參數
所有傳的參數的順序：位置參數，*args，默認參數，**kwargs

②實參、

1、站在傳參數的角度上看問題：一共有兩種傳參的方式：
1.按照位置傳參數

def f2(arg1,arg2):   #站在接受、形參的角度上：位置參數
  print(arg1)
  print(arg2)
f2(1,2)

2.按照關鍵字傳參數f2(para1 = 'abc',para = [1,23])

def f2(arg1,arg2):   #站在接受、形參的角度上：位置參數
    print(arg1)
    print(arg2)
f2(arg2='abc',arg1 = [1,23])

(1.2)可以混用，但先按位置傳(超級容易出錯)，按照位置傳完該接收的參數只能接收一個值，不接收或者重複接收都不行

2、傳多個參數：多個參數分別可以使用任意數據類型(其個數必須對應)
------------------------------------------------------------------------------------------------------------------
20171101day11
    形參：
動態參數：    #  在參數前面加個 *,這個參數就變成動態參數了
1、*args

def func(a,b,c,*args,key = 'key')
    print(a,b,c)
    print(key)
    print(args)# 使用的時候，所有接收過來的參數都被組織成一個元組的形式
func(2,4,4,5,'asd',[1,2],key = qqxing)

魔性用法：

① def my_sum(*args):
       print(args)
       sum_2 = 0
     for i in args:
       sum_2 += i
     return sum_2
li = [2,4,7,9]
ret = my_sum(*li)          # 按順序打散(迭代進去)
print(ret)

② 

def fun(**kwargs):
    print(kwargs)
dic = {'a':1,'b':2}
func(**dic)                     #  {'a':1,'b':2}

2、**kwargs

def func(**kwargs): #  關鍵字傳參
    print(kwargs)     #  返回一個字典
func(a=1,b=2)

順序：def func(a,*args,key = 'qqxing',**kwargs)

def func(a,*args,key = 'qqxing',**kwargs):
    print('a:',a)              # a  : 5
    print('*args:',args)    # args  : (6,7)
     print('key:',key)        # key  : qqxing
    print('kwags:',kwargs)  # kwargs : {'b':'hahaha','c' : 'hehehe'}
func(5,6,7,b = 'hahaha',c = 'hehehe)

三、命名空間(namespace)

內置命名空間：Python解釋器啓動之後就可以使用的名字
局部命名空間：每一個函數都擁有自己的命名空間
全局命名空間：寫在函數外面的變量名
Python啓動器運行起來後，其加載順序：

內置  -->  全局(按順序加載)  -->  局部(在調用函數時產生,調用結束則消失)

四、函數的嵌套調用
1、定義：

def func2():
    print('in func2 now')
def func():
    func2():
        n = 20
        print(n)
func()

2、

作用域：一個名字可以使用的區域
全局作用域：內置名字空間和全局名字空間中的名字都屬於全局作用域
局部作用域：局部名字空間中的名字屬於局部作用域
局部作用域可以使用全局作用域中的變量，反過來不可以
局部作用域還可以嵌套更小的局部作用域
作用域鏈：小範圍使用大範圍的變量(就近)，但作用域鏈是單向的，不能反向應用

globals 和 locals 方法：

小範圍可以使用大範圍的，但不能修改
如果想修改全局的 ，則使用 globals關鍵字(儘量避免)
如果想修改外層函數的 ，則使用 nonlocal (不影響全局)

n  =  1
def  func():
    global  n
    n  =+ 1
func()
print(n)           #  2

3、關於 globals()、locals() :

globals()： # 保存了在全局變量域中的名字和值
locals() ： #會根據執行的位置來決定作用域中的內容
如果在全局執行：
globals 和 locals  打印的結果是一致的

兩個程序：

①	
n = 0
def func():
    n = 1
    def func2():
        global  n       # 可以用全局變量，且可以修改
        n += 1
    func2()
    print(n)                  # 1
func()
print(n)                        # 1

②nonlocal 隻影響就近的一個變量，其他不管
   nonlocal ：就近，但絕對不會找到全局去

n = 0
def func():
    n = 1
    def func2():
        nonlocal  n       # 相當於 n = 1,能用n但不能n+=1(不能修改),所以就借了
        n += 1             
    func2()
    print(n)                  # 2
func()
print(n)                        # 0

五、函數的名字

第一對象類：

函數名可以賦值

可以作爲一個數據結構的元素

可以作爲一個函數的參數

可以作爲一個函數的返回值

def func():
    print('in func')
    return 10
def func2(arg):
    print(arg)
    return arg
f = func2(func)                   # 同級可調用，若嵌套則不可這樣使用
f()