函数

一、写函数的时候，要尽量以功能为导向，结果最好不要直接在函数中打印

例：

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()