python学习Day10--传参

【主要内容】

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+"
")
 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