python动态命名变量的作用_python学习第8天----函数动态参数、命名空间、作用域、函数嵌套、global和nonlocal...

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=0for i inn:

s= s +ireturnsprint(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

deffunc():

a= 20

print(a)print(a)

输出：20

View Code

3.作用域

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

1)作用域命名空间

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

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

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

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

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

print(globals()) #全局作用域内容

print(locals()) #当前作用域内容

View Code

4.函数的嵌套

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

2)函数的嵌套调用

deffunc1():print("哈哈")deffunc2():

func1()print("呵呵")

func2()#函数的递归(自己调用自己，最多999次)

func2()

输出：

哈哈

呵呵

哈哈

呵呵

。。。

View Code

3)函数的嵌套

deffun1():print("哈哈")deffunc2():print("呵呵")

func2()print("吼吼")

fun1()

输出：

哈哈

呵呵

吼吼

View Code

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

deffunc1():print("赵")deffunc2():print("钱")deffunc3():print("孙")print("李")

func3()print("周")

func2()

func1()

输出：

赵

周

钱

李

孙

View Code

5.关键字global和nonlocal

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

a = 10

deffunc():globala

a= a + 10 #使用全局变量

print(a)

func()print(a) #在函数中，全局变量发生了改变

输出：20

20

View Code

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

a = 100

deffunc():global a #加了个global表示不再局部创建这个变量了. ⽽是直接使⽤全局的a

a = 28 #对引入的全局变量进行了赋值，即把全局中的a进行了赋值

print(a)

func()print(a) #在函数内部对全局变量进行了赋值，所以值改变

输出：28

28

View Code

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

a = 10

deffunc1():

a= 20

deffunc2():

nonlocal a#若去掉，输出结果为30 20

a = 30

print(a)

func2()print(a)

func1()

输出：30

30

View Code

例：

a = 1

deffun_1():

a= 2

deffun_2():

nonlocal a

a= 3

deffun_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=0for i inargs:

sum= sum +ireturnsumprint(func(1,2,3,4,5))

输出：15

View Code

#法二

def func(*args):returnsum(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 inargs:

m= args[0] #假设传入的第一个参数为最大值，赋值给m

mi = args[0] #假设传入的第一个参数为最大值，赋值给mi

if i >m:

m=ielif i

mi=ireturn {'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 incolor:for j innum:

result.append((i,j))print(result)

输出：

[('红心', 'A'), ('红心', 'K'), ('红心', 'Q'), ('红心', 'J')。。。

View Code

4)执行inner函数

#法一

defwapper():definner():print("666")return inner #直接把函数返回

wapper()()

View Code

#法二：

defwapper():definner():print("666")returninner()

wapper()

View Code

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

def extendList(val, list=[]):

list.append(val)returnlist

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

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=12x1=2 2x2=43x1=3 3x2=6 3x3=94x1=4 4x2=8 4x3=12 4x4=165x1=5 5x2=10 5x3=15 5x4=20 5x5=256x1=6 6x2=12 6x3=18 6x4=24 6x5=30 6x6=367x1=7 7x2=14 7x3=21 7x4=28 7x5=35 7x6=42 7x7=498x1=8 8x2=16 8x3=24 8x4=32 8x5=40 8x6=48 8x7=56 8x8=649x1=9 9x2=18 9x3=27 9x4=36 9x5=45 9x6=54 9x7=63 9x8=72 9x9=81

View Code