1.动态传参（形参）

1）问题描述：要给一个函数传参，但是参数个数是不确定的，即写的形参很多，此时可以使用动态传参，即在参数前加*

①位置参数的动态传参（*args）

def func(*food):
    print("我要吃",food)
func("牛肉面","盖浇饭","炒面")
输出：
我要吃 ('牛肉面', '盖浇饭', '炒面')
View Code

注：动态参数接受到的是元组数据类型的数据

#如果要将位置参数和动态参数一起使用，应该先写位置参数，再写动态参数

def func(a,b,*food):
    print("我要吃",a,b,food)
func("牛肉面","盖浇饭","炒面","辣条","西红柿炒蛋")
输出：
我要吃 牛肉面 盖浇饭 ('炒面', '辣条', '西红柿炒蛋')
View Code

#如果形参中不但有位置参数、动态参数，还有默认值参数，那么要将默认值参数放在最后面

def func(a,b,*food,d="汤汤汤"):
    print("我要吃",a,b,food,d)
func("牛肉面","盖浇饭","炒面","辣条","西红柿炒蛋")
输出：
我要吃 牛肉面 盖浇饭 ('炒面', '辣条', '西红柿炒蛋') 汤汤汤
View Code

结论：位置参数----》动态参数(*args)----》默认参数

例：写一个函数，给函数传递任意个整数，返回这些整数的和

def sum(*n):
    s = 0
    for i in n:
        s = s + i
    return  s
print(sum(1,2,3,4,5))
输出：
15
View Code

②动态接受关键字参数（**args）

         动态接受关键字参数，接受到的是一个字典

def func(**game):                #动态接受关键字参数
    print(game)                  #接受到的是一个字典
func(lol="英雄联盟",DNF="地下城勇士")
输出：
{'lol': '英雄联盟', 'DNF': '地下城勇士'}
View Code

2.命名空间

　　在python解释器开始执⾏之后, 就会在内存中开辟⼀个空间, 每当遇到⼀个变量的时候, 就 把变量名和值之间的关系记录下来, 但是当遇到函数定义的时候, 解释器只是把函数名读入内存, 表⽰这个函数存在了, ⾄于函数内部的变量和逻辑, 解释器是不关⼼的. 也就是说⼀开始 的时候函数只是加载进来, 仅此⽽已, 只有当函数被调⽤和访问的时候, 解释器才会根据函数 内部声明的变量来进⾏开辟变量的内部空间. 随着函数执⾏完毕, 这些函数内部变量占⽤的空间也会随着函数执⾏完毕⽽被清空。

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

） 命名空间分类

①内置命名空间：存放python解释器内部运行时的变量函数，如列表、元组、字典等数据类型，print()等内置的函数

②全局命名空间：直接写在py文件中变量、函数等属于全局命名空间

③局部命名空间：定义在函数中的变量位于局部命名空间

2）命名空间加载顺序

①内置命名空间

②全局命名空间

③局部命名空间（函数被执行的时候）

3）取值顺序：即若全局变量名和局部变量名相同，优先获取局部变量的值（就近原则）

①局部命名空间

②全局命名空间

③内置命名空间

a = 10
def func():
    a = 20
    print(a)
print(a)
输出：
20
View Code

3.作用域

         作用域即作用范围，按照生效范围分为全局作用域和局部作用域

1）作用域命名空间

①全局作用域：全局命名空间+内置命名空间

②局部作用域：局部命名空间

2）查看全局作用域和局部作用域内容（若都防止在外面，显示内容相同）

①可通过函数globals()查看全局作用域中的内容

②可通过函数locals()查看当前作用域中的变量和函数信息

print(globals())    #全局作用域内容
print(locals())    #当前作用域内容
View Code

4.函数的嵌套

1）只要遇见了()就是函数的调用，如果没有()就不是函数的调用；不再()打印的是函数的地址

2）函数的嵌套调用

def func1():
    print("哈哈")
def func2():
    func1()
    print("呵呵")     
    func2()      #函数的递归（自己调用自己，最多999次）
func2()
输出：
哈哈
呵呵
哈哈
呵呵
。。。
View Code

3）函数的嵌套

def fun1():
    print("哈哈")
    def func2():
        print("呵呵")
    func2()
    print("吼吼")
fun1()
输出：
哈哈
呵呵
吼吼
View Code

例：多次函数的嵌套定义和调用

def func1():
    print("赵")
    def func2():
        print("钱")
        def func3():
            print("孙")
        print("李")
        func3()
    print("周")
    func2()
func1()
输出：
赵
周
钱
李
孙
View Code

5.关键字global和nonlocal

1)global作用：被声明的变量，不再使用局部作用域中的内容，而是改用全局作用域中的变量

a = 10
def func():
    global a
    a = a + 10     #使用全局变量
    print(a)
func()
print(a)          #在函数中，全局变量发生了改变
输出：
20
20
View Code

#在函数中对引入的全局变量赋值，则全局变量会发生改变 

a = 100
def func():
    global a # 加了个global表示不再局部创建这个变量了. ⽽是直接使⽤全局的a
    a = 28    #对引入的全局变量进行了赋值，即把全局中的a进行了赋值
    print(a)
func()
print(a)     #在函数内部对全局变量进行了赋值，所以值改变
输出：
28
28
View Code

2）nonlocal:对于位于局部中，但是不属于自己的，再往上找一层，即在局部作⽤域中, 调⽤⽗级命名空间中的变量（将想当于把最内层的变量值，赋值给了上一层变量）,把离他最近一层的变量拿过来，不会找全局变量

a = 10
def func1():
    a = 20
    def func2():
        nonlocal a            #若去掉，输出结果为30 20
        a = 30
        print(a)
    func2()
    print(a)
func1()
输出：
30
30
View Code

例：

a = 1
def fun_1():
    a = 2
    def fun_2():
        nonlocal a
        a = 3
        def fun_3():
            a = 4
            print(a)
        print(a)
        fun_3()
        print(a)
    print(a)
    fun_2()
    print(a)
print(a)
fun_1()
print(a)
输出：
1
2
3
4
3
3
1
View Code

6.练习

1）接受动态参数，并求这些参数的和

 #法一

def func(*args):
    sum = 0
    for i in args:
        sum = sum + i
    return sum
print(func(1,2,3,4,5))
输出：
15
View Code

#法二

def func(*args):
    return sum(args)
print(func(1,2,3,4,5))
输出：
15
View Code

2）写一个函数，传入n个数，返回字典{'max':"最大值"，'min':"最小值"}，例如min_max(2,5,7,8,4,)，返回{'max':8,'min':2}

def func(*args):
    return {'max':max(args),'min':min(args)}
print(func(8,7,2,6))
输出：
{'min': 2, 'max': 8}
View Code

#法二

def func(*args):
    for i in args:
        m = args[0]      #假设传入的第一个参数为最大值，赋值给m
        mi = args[0]    #假设传入的第一个参数为最大值，赋值给mi
        if i > m:
            m = i
        elif i < mi:
           mi = i
    return {'max':m,'min':mi}
print(func(10,5,8,27,1))
输出：
{'min': 1, 'max': 10}
View Code

3）写一个函数，返回一个扑克盘列表，里面有52项，每一项是一个元组。例如[('红心',2), ('草花',2), ('黑桃',2), ('方块',2)]

color = ["红心","黑桃","草花","方块"]
num = ["A","K","Q","J","10","9","8","7","6","5","4","3","2"]
result = []
for i in color:
    for j in num:
        result.append((i,j))
print(result)
输出：
[('红心', 'A'), ('红心', 'K'), ('红心', 'Q'), ('红心', 'J')。。。
View Code

4)执行inner函数

#法一

def wapper():
    def inner():
        print("666")
    return inner         #直接把函数返回
wapper()()
View Code

#法二：

def wapper():
    def inner():
        print("666")
    return inner()
wapper()
View Code

5)补充：如果默认值参数是一个可变的数据类型，如果有人调用的时候改变了它，其他位置看到的也跟着改变了

def extendList(val, list=[]):
    list.append(val)
    return list
list1 = extendList(10)
list2 = extendList(123, [])
list3 = extendList('a') # 
print('list1=%s' % list1)   
print('list2=%s' % list2)   #
print('list3=%s' % list3)
输出：
list1=[10, 'a']
list2=[123]
list3=[10, 'a']
View Code
def extendList(val, list=[]):
    list.append(val)
    return list
list1 = extendList(10)
print('list1=%s' % list1)

list2 = extendList(123, [])
print('list2=%s' % list2)   #

list3 = extendList('a')
print('list3=%s' % list3)
输出：
list1=[10]
list2=[123]
list3=[10, 'a']
View Code

6) 打印9*9乘法表

a = 1
while a<=9:
    b =1
    while b<=a:
        print("%dx%d=%d\t" % (a,b,a*b),end = "")
        b = b + 1
    print()
    a = a + 1
输出：
1x1=1    
2x1=2    2x2=4    
3x1=3    3x2=6    3x3=9    
4x1=4    4x2=8    4x3=12    4x4=16    
5x1=5    5x2=10    5x3=15    5x4=20    5x5=25    
6x1=6    6x2=12    6x3=18    6x4=24    6x5=30    6x6=36    
7x1=7    7x2=14    7x3=21    7x4=28    7x5=35    7x6=42    7x7=49    
8x1=8    8x2=16    8x3=24    8x4=32    8x5=40    8x6=48    8x7=56    8x8=64    
9x1=9    9x2=18    9x3=27    9x4=36    9x5=45    9x6=54    9x7=63    9x8=72    9x9=81
View Code