day11函数的进阶动态参数，命名空间，作用域，第一类对象

一、习题收藏

 5、写函数，计算传入字符串中【数字】、【字母】、【空格】 以及 【其他】的个数，并返回结果。
# def func4(s):
#     dic = {
#         'num':0,'alpha':0,'space':0,'others':0
#     }
#     for i in s:
#         if i.isdigit():
#             dic['num'] += 1
#         elif i.isalpha():
#             dic['alpha'] +=1
#         elif i.isspace():
#             dic['space'] += 1
#         else:
#             dic['others'] += 1
#     return dic
# s = 'asdjk2330  sdjkfh#$^&'
# ret = func4(s)
# print(ret)
# 6、写函数，检查用户传入的对象（字符串、列表、元组）的每一个元素是否含有空内容，并返回结果。
# def func5(s_l_t):
#     if s_l_t:
#         for i in s_l_t:
#             if not i and i != 0 and i != False:
#                 return True
#     else:
#         return True

# 7、写函数，检查传入字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。
#     dic = {"k1": "v1v1", "k2": [11,22,33,44]}
#     PS:字典中的value只能是字符串或列表
# def func6(dic):
#     for k in dic:
#         value = dic[k]
#         if len(value) > 2:
#             dic[k] = value[:2]
#     return dic
# def func6(dic):
#     for k in dic:
#         dic[k] = dic[k][:2]
#     return dic
# dic = {"k1": "v1v1", "k2": [11,22,33,44]}
# print(func6(dic))
# 8、写函数，接收两个数字参数，返回比较大的那个数字。
# a = 1
# b = 2
# def func7(a,b):
#     if a > b:
#         return a
#     else:
#         return b
# print(func7(1,1))
#
# #三元运算符
# c = 0
# if a>b:
#     c = a
# else:
#     c = b

#新知识：重要程度五颗星*****
# c = a if a>b else b  # 三元运算符 三元运算表达式

初始函数的作业题

def fun(a,b):
    c = a if a>b else b  # 三元运算符 三元运算表达式
    return c
print(fun(1,2)) #2

二、动态参数

#动态参数
#*args ：接收所有按照位置传的参数，接收到的是参数组成的元祖

#*args  ：接收所有按照位置传的参数，接收到的是参数组成的元祖
def func1(*args):
    print(args)
func1('name',18,'e')  # args = ('name', 18, 'e')
# 注：名字不一定是args 这是使用习惯，方便代码阅读
# 注：如果调用args时候前边加了一个* 便是将其迭代的形式变为形参  字符串前加*会变成单个元素
#注 ：*args 在位置参数之后。关键字参数的前边
def func1(*args):
    print(*args)
func1(*('name',18,'e'))  #name 18 e
#传入的参数也可以用*打散

def my_sum(*args): #求合
# print(args)
# # sum_2 = 0
# # for i in args:
# # sum_2 += i
# # return sum_2
# l = [1,24,5,7]

可以求和

#**kwargs :接收所有按照关键字传的参数，接收到的是参数组成的字典

#**kwargs   :接收所有按照关键字传的参数，接收到的是参数组成的字典
def func1(**kwargs):
    print(kwargs)
func1(**{'abc':2,'bcd':3}) #{'a': 2, 'b': 3}   如果用*号得到的是key的参数
#所有的参数的顺序：位置参数，*args，默认参数，**kwargs
#keywords must str
#顺序：
#在调用函数的时候，可以打散：*l（按顺序打散）、**dic（打散）

#所有的参数的顺序：位置参数，*args，默认参数，**kwargs

二 、命名空间

#namespace 命名空间，名称空间
#局部命名空间：每一个函数都拥有自己的命名空间
#全局命名空间：写在函数外面的变量名
#内置命名空间：python解释器启动之后就可以使用的名字
#python的解释器要运行起来
#加载顺序：
    # 先所有内置命名空间的中的名字-->然后按照顺序加载全局命名空间中的名字
    #局部命名空间中的名字：在调用函数的时候产生，并且随着调用的结束而消失

如下代码的加载顺序：

# func(1,2,3,4,5)
    # def f1():                        1
    #     a = 1                         3
    #     def f2():                      4
    #         def f3():                 6
    #             a = 3                 8
    #             print(a)              9
    #         f3()                      7
    #     f2()                            5
    # f1()                             2

三、函数的嵌套

嵌套内部的函数不能直接被外部调用，只能由他的上一层函数调用，或者自身将函数名返回到外层

#函数的嵌套定义
# def func():
#     def qqxing():
#         print('我是qqxing')
#     qqxing()
# func()

# print(len('123'))
# def len(x):
#     print('***%s***'%x)
#
# len('123')

#函数的嵌套定义
# n = 0
# def func1():
#     def func2():
#         print(n)
#     func2()
#
# func1()
#fun2()   会报错

四、作用域

#作用域：一个名字可以使用的区域
#全局作用域：内置名字空间和全局名字空间中的名字都属于全局作用域
#局部作用域：局部名字空间中的名字属于局部作用域
#局部作用域可以使用全局作用域中的变量
#而全局作用域不能使用局部作用域中的变量
#局部作用域中还可以嵌套更小的局部作用域
#作用域链：小范围作用域可以使用大范围的变量，但作用域链是单向的，不能反向应用

# func1()
# def func():
#     a = 10
#     b = 20
#     print(locals())  #保存了当前作用域中变量
#     print(globals())

# n = 10
# m = 22
# print(globals())   #保存了在全局作用域中的名字和值
# func()

#globals()   #保存了在全局作用域中的名字和值
#locals() #中的内容会根据执行的位置来决定作用域中的内容
#如果在全局执行
#globals和locals打印的结果是一致的

如果局部作用域中的想修改全部变量，那么用globals  如果局部内层函数想修改外层函数那么用nonlocals

n = 1
def func2():
    n = 2
    def func3():
        nonlocal n  # 使用nonlocak前，本层函数不能出现该变量
        n+=1
        #print(n)
        #global n   # 使用nonlocak前，所有层函数不能出现该变量
        n += 10
    func3()
    print(n)
func2()
print(n)

五、第一类对象（函数名）

#第一类对象的概念：
#函数名可以赋值
#可以作为一个数据结构的元素
#可以作为一个函数的参数
#可以作为一个函数的返回值

def func():
    print('in func')
    return 10

def func2(arg):
    arg()
    return arg

f = func2(func)
f()    #可以作为参数传递

def f1():
    pass
def f2():
    pass
def f3():
    dic = {'alex':f1,'tai':f2}
    name = input('请输入账户名：')
    if name in dic:
        dic[name]()
f3()