python学习Day10--传参

【主要内容】

1. 动态参数
    位置参数的动态参数: *args
    关键字参数的动态参数 : **kwargs
    顺序:
        位置,*args,默认值,**kwargs
    在形参上*聚合, **聚合
    在实参上*打散, **打散
2. 命名空间和作用域
    命名空间:
        1. 内置命名空间: python解释内部运行时的变量函数
        2. 全局命名空间: 我们在py文件中直接声明出来的变量,函数
        3. 局部命名空间: 在函数内部声明的变量和函数.
    作用域:
        1.全局作用域:内置+全局
        2.局部作用域:局部
      globals() 查看全局作用域中的名字
      locals() 查看当前作用域中的名字

3. global和nonlocal
    global: 把全局变量拿到局部来用.
    nonlocal: 把离他最近的一层的变量拿过来.不会找全局

【代码】

1、动态传参

# def chi(good_food, bad_food,drink, ice, jiu):
#     print("我要吃", good_food, bad_food)
#
# chi("盖浇饭", "辣条")

# 位置参数 > *动态参数 > 默认值参数


# def chi( *food, a, b): # 可以传入任意的位置参数
#     print("我要吃", food)  # 动态参数接收到的是tuple类型的数据
#
# chi("盖浇饭", "辣条", "面条")
# def func(a, b, c, *args, d = 5):
#     print(a, b, c, d, args)
#
# func(1,2,3)
# func(1,2,3,4,5,6,7, d ="马大哈")

# def chi(*food):
#     print("我要吃", food)

#　写函数. 给函数传递任意个整数. 返回这些数的和
# def he(*n):
#     sum = 0
#     for e in n:
#         sum += e
#     return sum
# print(he(5))


# 动态接收关键字参数
#  *位置参数
# **关键字参数
# def func(**food):   # **food动态接收关键字参数
#     print(food) # 接收到的是字典
#
# func(good_food="盖浇饭", bad_food="辣条", drink="冰封")

# 关键字参数一定在位置参数后面
# 位置参数 > *args > 默认值 > **kwargs

# 这个函数可以接收所有的参数(无敌的)
# def func(*args, **kwargs):
#     print(args)
#     print(kwargs)
# func(1, 2, 5, 6, name="taibai",age=18, sex="不详")

# 把列表中的每一个元素作为参数, 传递给函数. 一次都传过去

# def func(*args, **kwargs):  # *表示聚合,所有的位置参数, 聚合成元组 **聚合成字典
#     print(args)
#     print(kwargs)
#
#
# # lst = ["马虎疼", "大洋哥", "小花生", "毛尖妹妹"]
# # func(*lst)  # 实参, 打散, 迭代产生的
#
# dic = {"name":"太白", "alex":"wuse"}
# func(**dic) # 把字典打散. 以key=value形式进行传参


# def func(a, b):
#     """
#     计算a+b的和, 返回一个数
#     :param a: 第一个数
#     :param b: 第二个数
#     :return: 返回计算之后的和
#     """
#     return a + b

# 定义函数
# def 函数名(形参):  1.位置参数, 2, *args, 3.默认值参数, 4. **kwargs
#     函数体   return 返回值
# 函数名(实参)    1. 位置参数. 2.关键字参数. 3. 混合参数,

2、命名空间

# a = "123"   # 全局
# b = 36  # 全局
# def func(): # 全局
#     c = "马化腾"   # 局部
#
# def func2():
#     print(c)

a = 10
def func():
    a = 20
    print(a)    # 就近原则
    print(globals())  # globals() 获取到全局作用域(内置,全局)中的所有名字
    print(locals())  # locals() 查看当前作用域中的所有名字
func()

3、函数的嵌套

# def chi():
#     print("我要吃")
#
# print(chi())

# def func1():
#     print("哈哈")
#
# def func2():
#     func1()
#     print("呵呵")
#     func1()
# func2()

# def func1():
#     print("呵呵")
#     def func2():
#         print("哈哈")
#     func2()
#     print("吼吼")
# func1() #

def func1():
    print("赵")
    def func2():
        print("钱")
        def func3():
            print("孙")
        print("李")
    def func4():
        print("哈哈")
        func2()
    print("周")
    func2()
func1()

4、global与nonlocal

# def func():
#     global a    # a 不再是局部变量. 是全局变量
#     a = 30  # 把全局中的a重新赋值成30
#     print(a)
# func()
# print(a)

# a = 10
# def func1():
#
#     def func2():
#         nonlocal a  # 找局部作用域中 离他最近的那个变量引入进来
#         a = 20
#         print(a)
#     func2()
#     print(a)
# func1()

a = 1
def fun_1():
    a = 2
    def fun_2():
         def fun_3():
             nonlocal a
             a =  4
             print(a)
         print(a)
         fun_3()
         print(a)
    print(a)
    fun_2()
    print(a)
print(a)
fun_1()
print(a)

5、作业与练习

#****************作业讲解******************
'''
# 2.写函数，检查传入列表或元组对象所有奇数位索引对应的元素，并将其作为新列表返回给调用者
def func(lst):
    ll=[]
    for i in range(len(lst)):
        if i % 2 == 0:
            ll.append(lst[i])
    return ll
a=[1,5,7,9,12]
ret=func(a)
print(ret)


# 3.写函数，判断用户传入的对象（字符串、列表、元组）长度是否大于5
def func(a):
    if len(a)>5:
        return True
    else:
        return False
ll=(1,2,3,4,5,6)
ret=func(ll)
print(ret)

# 4.写函数，检查传入列表德尔长度，如果大于2，将列表的前两项内容返回给调用者
def func(lst):
    if len(lst) > 2:
        return lst[0],lst[1]
ll=[1,2,3,4,5]
ret=func(ll)
#ret=list(ret)
print(ret)

# 5.写函数，计算输入函数的字符串中，数字、字母、空格以及其他内容的个数，并返回结果
def func(s=""):
    shuzi=0
    zimu=0
    kongge=0
    qita=0
    for c in s:
        if c.isdigit():
            shuzi+=1
        elif c.isalpha():
            zimu+=1
        elif c == ' ':
            kongge+=1
        else:
            qita+=1
    return shuzi,zimu,kongge,qita
s="dnsdvfv esm x234467432ndjdknv456452  r4222c...#$%^^"
ret=func(s)
print(ret)

# 6.写函数，接收两个数字参数，返回较大的那一个
def func(a,b):
    if a > b:
        return a
    else:
        return b
    #c= a if a>b else b
    #return c
a=input("请输入第一个数：")
b=input("请输入第二个数：")
ret=func(int(a),int(b))
print(ret)

# 7.写函数，检查传入字典的每一个value的长度，如果大于2，那么仅保留前两个长度的内容，并将新的内容返回给调用者
# dic={"k1":"v1v1","k2":[11,22,33,44]}
# dic={"k1":"v1","k2":[11,22]}
def func(dic):
    new_dic={}
    for k,v in dic.items():
        if len(v) > 2:
            new_dic[k]=v[0:2]
        else:
            new_dic[k]=v
    return new_dic
dic={"k1":"v1v1","k2":[11,22,33,44]}
print(func(dic))

# 8.写函数，此函数只接收一个参数且此参数必须是列表数据类型，此函数完成的功能是返回给调用者一个字典，此字典的键值对为此列表的索引及对应的元素。
def func(lst):
    dic={}
    for i in range(len(lst)):
        dic[i]=lst[i]
    return dic
lst=[11,22,33]
print(func(lst))

# 9.写函数，函数接收四个参数分别是：姓名，性别，年龄，学历。用户通过输入这四个内容，
# 然后将这四个内容传入到函数中，此函数接收到这四个内容，将内容追加到一个student_msg文件中。
def func(name,age,sex,edu):
    f=open("student_msg",mode="a",encoding="utf-8")
    f.write(name+"_"+str(age)+"_"+sex+"_"+edu+"
")
    f.flush()
    f.close()

# 11.写函数，用户传入修改的文件名，与要修改的内容（两个：修改与被修改），执行函数，完成整个文件的批量修改操作。
import os
def func(filename,old,new):
    with open(filename,mode="r",encoding="utf-8") as f1,
        open(filename+"_副本",mode="w",encoding="utf-8") as f2:

        for line in f1:
            s=line.replace(old,new)
            f2.write(s)
    os.remove(filename)
    os.rename(filename+"_副本",filename)
func("student.msg","学","本")
'''

#*************今日练习*********************
'''
# 动态传参
# 1、*位置参数
def func(*n):
    sum=0
    for i in n:
        sum+=i
    return sum
print(func(5,6,7))

# 2、**关键字参数
def func(**food):
    print(food)   #接收到的是字典
func(good_food="盖浇饭",bad_food="辣条")
'''
# 命名空间
# 加载顺序：内置空间 > 全局空间 > 局部空间
# 取值顺序：局部空间 > 全局空间 > 内置空间（就近原则）
a="123"       #全局
b=12          #全局
def func():   #全局
    c="麻花特" #局部
    def hah():#局部
        pass