神奇的python系列9：函数（二）

1.函数的参数 -- 动态参数

动态参数分为两种：

1.动态位置参数：在参数位置用*表示接受任意参数

def eat(a,b,*args):  # 聚合 打包　　
    print(a,b,args)  # 以元祖的形式返回
    #　形参位置　　：　位置参数　＞　动态位置参数
eat('方便面','包子','麻团','豆浆','咸菜','油条','火鸡面','小笼包','炒饼')

注意:

1.*args会把所有的都接收,位置参数接收不到内容了。

2.按照形参的顺序:位置参数 , 动态参数 , 默认参数。

2.动态关键字参数：在python中使用**来接收动态关键字参数

def eat(b=1,**kwargs):  # b=1 b ='2'
    print(kwargs)   # {'a': '1', 'c': '4', 'd': '5', 'f': '22'} #以字典的形式返回
    # print(kwargs['b'])   #keyError
    print(b)
eat(a='1',b='2',c='4',d='5',f='22')  

注意：位置参数 > *args(动态位置参数)  > 默认值参数 > **kwargs(动态默认参数)

万能接受所有参数：

def func(*args,**kwargs):  #万能　无敌
    print(args,kwargs)
func(1,2,3,4,a=1,b=2,c=3)  # 位置  关键字  混合

动态参数传参的方法：

lst = [1,4,7]
# 方法一
def func(*args):   #聚合
    print(args)
 
func(lst[0],lst[1],lst[2])

lst = [1,4,7]
# 方法二
def func(*args):   #聚合
    print(args)
func(*lst)         #打散

在实参的位置上用*将lst(可迭代对象)按照顺序打散。

在形参的位置上用*把收到的参数组合成一个元祖。

#字典也可以进行打散,不过需要**
dic = {'a':1,'b':2}
def func(**kwargs):
    print(kwargs)
 
func(**dic)

2.函数的注释

def func(a,**kwargs):
    '''
    #很重要　写函数一定要写注释
    这里描述这个函数是做什么的
    :param a:  这里描述a参数是什么意思
    :param kwargs: 这里描述kwargs参数是什么意思
    :return: 返回值
    '''
    print(args)
    print(kwargs)
    return args
print(func.__doc__)  #查看函数的注释   函数名.__doc__

3.函数的名称空间

我们给存放名字和值的关系的空间起一个名字叫: 命名空间. 我们的变量在存储的时候就 是存储在这片空间中的.  

命名空间分类:         

　　　 1. 内置命名空间--> 存放python解释器为我们提供的名字, list, tuple, str, int这些都是内置命名空间

            2. 全局命名空间--> 我们直接在py文件中, 函数外声明的变量都属于全局命名空间       

            3. 局部命名空间--> 在函数中声明的变量会放在局部命名空间

找值顺序: 局部空间 > 全局空间 > 内置空间
加载顺序: 内置空间 > 全局空间 > 局部空间

作⽤域命名空间:         

　　1. 全局作⽤用域:全局命名空间 + 内置命名空间      globals() 查看全局空间的内容

　　2. 局部作⽤用域:局部命名空间                                locals()  查看局部空间的内容

           局部空间:数据不能共享,是独立的

a = 10
def func():   
    a = 40   
    b = 20   
    def abc():       
        print("哈哈")   
        print(a, b)     # 这⾥里里使⽤用的是局部作⽤用域   
        print(globals())    # 打印全局作用域中的内容   
        print(locals())     # 打印局部作用域中的内容
func()

4.函数的嵌套

只要遇见了()就是函数的调用. 如果没有()就不是函数的调用

# 函数的嵌套
def fun2():   
    print(222)   
    def fun3():       
        print(666)   
    print(444)   
    fun3()   
    print(888)
print(33)
fun2()
print(555)

函数名+()不管在哪都是调用,调用的时候先定义后调用

5.global 和 nonlocal

global：在局部修改全局的数据，如果全局没有的时候，在局部修改的时候回创建一个。

a = 100
def func():   
    global a    # 加了个global表示不再局部创建这个变量了. 而是直接使用全局的a   
    a = 28   
print(a)
func()
print(a)

nonlocal：在局部里,修改离它最近的上一级,上一级不存在就继续往上找。最多找到最外成的函数就结束了

a = 10
def func1():   
    a = 20   
    def func2():
        nonlocal a       
        a = 30       
        print(a)  
    func2()   
    print(a)
func1()
 
'''
结果:
加了nonlocal
30
30
'''