【主要内容】
1. 动态参数
位置参数的动态参数: *args
关键字参数的动态参数 : **kwargs
顺序:
位置,*args,默认值,**kwargs
在形参上*聚合, **聚合
在实参上*打散, **打散
2. 命名空间和作用域
命名空间:
1. 内置命名空间: python解释内部运行时的变量函数
2. 全局命名空间: 我们在py文件中直接声明出来的变量,函数
3. 局部命名空间: 在函数内部声明的变量和函数.
作用域:
1.全局作用域:内置+全局
2.局部作用域:局部
globals() 查看全局作用域中的名字
locals() 查看当前作用域中的名字
3. global和nonlocal
global: 把全局变量拿到局部来用.
nonlocal: 把离他最近的一层的变量拿过来.不会找全局【代码】
1、动态传参
1 # def chi(good_food, bad_food,drink, ice, jiu):
2 # print("我要吃", good_food, bad_food)
3 #
4 # chi("盖浇饭", "辣条")
5
6 # 位置参数 > *动态参数 > 默认值参数
7
8
9 # def chi( *food, a, b): # 可以传入任意的位置参数
10 # print("我要吃", food) # 动态参数接收到的是tuple类型的数据
11 #
12 # chi("盖浇饭", "辣条", "面条")
13 # def func(a, b, c, *args, d = 5):
14 # print(a, b, c, d, args)
15 #
16 # func(1,2,3)
17 # func(1,2,3,4,5,6,7, d ="马大哈")
18
19 # def chi(*food):
20 # print("我要吃", food)
21
22 # 写函数. 给函数传递任意个整数. 返回这些数的和
23 # def he(*n):
24 # sum = 0
25 # for e in n:
26 # sum += e
27 # return sum
28 # print(he(5))
29
30
31 # 动态接收关键字参数
32 # *位置参数
33 # **关键字参数
34 # def func(**food): # **food动态接收关键字参数
35 # print(food) # 接收到的是字典
36 #
37 # func(good_food="盖浇饭", bad_food="辣条", drink="冰封")
38
39 # 关键字参数一定在位置参数后面
40 # 位置参数 > *args > 默认值 > **kwargs
41
42 # 这个函数可以接收所有的参数(无敌的)
43 # def func(*args, **kwargs):
44 # print(args)
45 # print(kwargs)
46 # func(1, 2, 5, 6, name="taibai",age=18, sex="不详")
47
48 # 把列表中的每一个元素作为参数, 传递给函数. 一次都传过去
49
50 # def func(*args, **kwargs): # *表示聚合,所有的位置参数, 聚合成元组 **聚合成字典
51 # print(args)
52 # print(kwargs)
53 #
54 #
55 # # lst = ["马虎疼", "大洋哥", "小花生", "毛尖妹妹"]
56 # # func(*lst) # 实参, 打散, 迭代产生的
57 #
58 # dic = {"name":"太白", "alex":"wuse"}
59 # func(**dic) # 把字典打散. 以key=value形式进行传参
60
61
62 # def func(a, b):
63 # """
64 # 计算a+b的和, 返回一个数
65 # :param a: 第一个数
66 # :param b: 第二个数
67 # :return: 返回计算之后的和
68 # """
69 # return a + b
70
71 # 定义函数
72 # def 函数名(形参): 1.位置参数, 2, *args, 3.默认值参数, 4. **kwargs
73 # 函数体 return 返回值
74 # 函数名(实参) 1. 位置参数. 2.关键字参数. 3. 混合参数,2、命名空间
1 # a = "123" # 全局
2 # b = 36 # 全局
3 # def func(): # 全局
4 # c = "马化腾" # 局部
5 #
6 # def func2():
7 # print(c)
8
9 a = 10
10 def func():
11 a = 20
12 print(a) # 就近原则
13 print(globals()) # globals() 获取到全局作用域(内置,全局)中的所有名字
14 print(locals()) # locals() 查看当前作用域中的所有名字
15 func()3、函数的嵌套
1 # def chi():
2 # print("我要吃")
3 #
4 # print(chi())
5
6 # def func1():
7 # print("哈哈")
8 #
9 # def func2():
10 # func1()
11 # print("呵呵")
12 # func1()
13 # func2()
14
15 # def func1():
16 # print("呵呵")
17 # def func2():
18 # print("哈哈")
19 # func2()
20 # print("吼吼")
21 # func1() #
22
23 def func1():
24 print("赵")
25 def func2():
26 print("钱")
27 def func3():
28 print("孙")
29 print("李")
30 def func4():
31 print("哈哈")
32 func2()
33 print("周")
34 func2()
35 func1()4、global与nonlocal
1 # def func():
2 # global a # a 不再是局部变量. 是全局变量
3 # a = 30 # 把全局中的a重新赋值成30
4 # print(a)
5 # func()
6 # print(a)
7
8 # a = 10
9 # def func1():
10 #
11 # def func2():
12 # nonlocal a # 找局部作用域中 离他最近的那个变量引入进来
13 # a = 20
14 # print(a)
15 # func2()
16 # print(a)
17 # func1()
18
19 a = 1
20 def fun_1():
21 a = 2
22 def fun_2():
23 def fun_3():
24 nonlocal a
25 a = 4
26 print(a)
27 print(a)
28 fun_3()
29 print(a)
30 print(a)
31 fun_2()
32 print(a)
33 print(a)
34 fun_1()
35 print(a)5、作业与练习
1 #****************作业讲解******************
2 '''
3 # 2.写函数，检查传入列表或元组对象所有奇数位索引对应的元素，并将其作为新列表返回给调用者
4 def func(lst):
5 ll=[]
6 for i in range(len(lst)):
7 if i % 2 == 0:
8 ll.append(lst[i])
9 return ll
10 a=[1,5,7,9,12]
11 ret=func(a)
12 print(ret)
13
14
15 # 3.写函数，判断用户传入的对象（字符串、列表、元组）长度是否大于5
16 def func(a):
17 if len(a)>5:
18 return True
19 else:
20 return False
21 ll=(1,2,3,4,5,6)
22 ret=func(ll)
23 print(ret)
24
25 # 4.写函数，检查传入列表德尔长度，如果大于2，将列表的前两项内容返回给调用者
26 def func(lst):
27 if len(lst) > 2:
28 return lst[0],lst[1]
29 ll=[1,2,3,4,5]
30 ret=func(ll)
31 #ret=list(ret)
32 print(ret)
33
34 # 5.写函数，计算输入函数的字符串中，数字、字母、空格以及其他内容的个数，并返回结果
35 def func(s=""):
36 shuzi=0
37 zimu=0
38 kongge=0
39 qita=0
40 for c in s:
41 if c.isdigit():
42 shuzi+=1
43 elif c.isalpha():
44 zimu+=1
45 elif c == ' ':
46 kongge+=1
47 else:
48 qita+=1
49 return shuzi,zimu,kongge,qita
50 s="dnsdvfv esm x234467432ndjdknv456452 r4222c...#$%^^"
51 ret=func(s)
52 print(ret)
53
54 # 6.写函数，接收两个数字参数，返回较大的那一个
55 def func(a,b):
56 if a > b:
57 return a
58 else:
59 return b
60 #c= a if a>b else b
61 #return c
62 a=input("请输入第一个数：")
63 b=input("请输入第二个数：")
64 ret=func(int(a),int(b))
65 print(ret)
66
67 # 7.写函数，检查传入字典的每一个value的长度，如果大于2，那么仅保留前两个长度的内容，并将新的内容返回给调用者
68 # dic={"k1":"v1v1","k2":[11,22,33,44]}
69 # dic={"k1":"v1","k2":[11,22]}
70 def func(dic):
71 new_dic={}
72 for k,v in dic.items():
73 if len(v) > 2:
74 new_dic[k]=v[0:2]
75 else:
76 new_dic[k]=v
77 return new_dic
78 dic={"k1":"v1v1","k2":[11,22,33,44]}
79 print(func(dic))
80
81 # 8.写函数，此函数只接收一个参数且此参数必须是列表数据类型，此函数完成的功能是返回给调用者一个字典，此字典的键值对为此列表的索引及对应的元素。
82 def func(lst):
83 dic={}
84 for i in range(len(lst)):
85 dic[i]=lst[i]
86 return dic
87 lst=[11,22,33]
88 print(func(lst))
89
90 # 9.写函数，函数接收四个参数分别是：姓名，性别，年龄，学历。用户通过输入这四个内容，
91 # 然后将这四个内容传入到函数中，此函数接收到这四个内容，将内容追加到一个student_msg文件中。
92 def func(name,age,sex,edu):
93 f=open("student_msg",mode="a",encoding="utf-8")
94 f.write(name+"_"+str(age)+"_"+sex+"_"+edu+"\n")
95 f.flush()
96 f.close()
97
98 # 11.写函数，用户传入修改的文件名，与要修改的内容（两个：修改与被修改），执行函数，完成整个文件的批量修改操作。
99 import os
100 def func(filename,old,new):
101 with open(filename,mode="r",encoding="utf-8") as f1,\
102 open(filename+"_副本",mode="w",encoding="utf-8") as f2:
103
104 for line in f1:
105 s=line.replace(old,new)
106 f2.write(s)
107 os.remove(filename)
108 os.rename(filename+"_副本",filename)
109 func("student.msg","学","本")
110 '''
111
112 #*************今日练习*********************
113 '''
114 # 动态传参
115 # 1、*位置参数
116 def func(*n):
117 sum=0
118 for i in n:
119 sum+=i
120 return sum
121 print(func(5,6,7))
122
123 # 2、**关键字参数
124 def func(**food):
125 print(food) #接收到的是字典
126 func(good_food="盖浇饭",bad_food="辣条")
127 '''
128 # 命名空间
129 # 加载顺序：内置空间 > 全局空间 > 局部空间
130 # 取值顺序：局部空间 > 全局空间 > 内置空间（就近原则）
131 a="123" #全局
132 b=12 #全局
133 def func(): #全局
134 c="麻花特" #局部
135 def hah():#局部
136 pass
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
