python 函数进阶

#      =========================    添加一下 其他的 None====
#[},{},"",(),{},    没设返回值 ，都指向 None

#函数运行的 顺序
# def func():
#     count = 2
#     l1 = []
#     l1.append(count)
#     return l1
# ret = func()     #遇到函数名 先执行 函数， 函数运行完之后在赋值给 ret
# print(ret)

# def func():
#     count = 2
#     l1 = []
#     l1.append(count)
#     return 11,2,count
# ret1 = func()
# ret2 = func()    #结果都是11，2，count  因为 调用了 三次函数
# ret3 = func()


#++++++++++++++++++++++++++++++++++    动态参数 ===========================
#参数 一般一个参数约定俗成  参数名 是 args
 #   动态参数是 参数名 前面 加 * 号  也叫不定长参数
# def func(*args):  # *args 只接收位置参数，有多少接收多少
#     print(args,type(args))  #args 元组，它包含你所有的位置参数
# func(1,2,3,4,5,6,6,8)

# 要是有别的参数 *args 放在最后  , 不传参数给它 也不会报错
# def func(a,b,c,*args):
#     print(a)
#     print(b)
#     print(c)
#     print(args,type(args))
# func(111,2,3,4,5,)q


#  ** kwargs 接受不定长的关键字参数， 是字典类型。
# def func(**kwargs):
#     print(kwargs)
# func(a = 1,b = 2,c = 5)


#一般情况下 都写 *args  和 **kwargs  这两个写一块也叫万能参数
# def func(*args,**kwargs):
#     print(args)
#     print(kwargs)
# func(11,2,23,name = "alel",geg = 55)

#补充添加 内置函数部分命令  sum ，len ， input，
#print(sum([1,2,3,88]))  直接 可以出来 列表里的 数字总和


#魔法运算 ：打散 可以迭代的 插入到函数中
# def func(*args,**kwargs):
#     print(args)
# l1 = [1,2,3]
# l2 = [1,2,4,5,6,7,86,5,4]
# func(*l1,*l2)

# def func(*args,**kwargs):
#     print(args)
#     print(kwargs)
# dic = {"name":"alex","age":12}
# dic2 = {"name":"alex","age":22}
# func({"name":"alex","age":22},{"name":"alex","age":12})  #这是位置参数 所以*args接收

# def func(*args,**kwargs):
#     print(args)
#     print(kwargs)
# dic = {"name":"alex","age":12}
# dic2 = {"name":"alex","age":22}    # 这是**kwargs 接收， 注意key的 名字
# func(**{"name1":"alex","age":22},**{"name2":"alex","age5":12},name3 = "alex")

#+++++++=================    名称空间         ============’
# name = 1    -----》           #变量名与变量的 对应关系保存在内存中，这个内存叫 名称空间
# def func():   -----》 遇见函数格式 函数名保存到 内存中
#     n = 2                执行 函数形成一个临时的空间   也叫 局部名称空间
#     print(66)   函数里的变量存储在这里           函数内部代码 结束， 临时空间 消失
# func()    --------》 遇见函数名  执行 函数


#名称空间：1，全局名称空间   外部的所有 变量都存储在这里
          #2，局部名称空间   函数内部的 变量 存储在这里
          #3,内置名称空间  input， print，sum,len,

#加载顺序 ：  从大到小找
#内置名称空间-----》全局名称空间-------》局部名称空间（执行函数时）

# 取值顺序：  从小往大找
# 先从局部名称空间找 ----》 全局名称空间找 ------》 内置名称空间
# name = "wusir"
# def func():
#     name = "alex"
#     print(name)
# print(func())

#print(globals())
#print(locals())    打印局部变量


#++++++++++++++++++++++++++++++++++++++++=   函数的嵌套 ++++++++++++++++

# def fun1():
#     print(111)
# def fun2():
#     print(222)
#     fun1()
# fun2()

# def fun2():
#     print(222)
#     def fun3():
#         print(666)
#     fun3()
# fun2()

# print(111)
# def fun2():
#     print(222)
#     def fun3():
#         print(666)
#     print(444)
#     fun3()
#     print(888)
# print(333)
# fun2()
# print(555)

#global() 1,声明一个全局变量
        #2,在局部作用域想要对全局作用域的全局变量进行修改时
        # 需要用global （限于字符串，数字）
        #ps 可变数据类型不需要
# def func():
#     global a
#     a = 2
#     print(a)
# func()
# print(a)

#nonlocal
#1.不能修改全局变量
#2，在局部作用域中，对父级作用域（或者更外层作用域非全局作用域)的变量进行引用和修改，
#并且引用的那层，从那层以下此变量全部发生改变》
# def add_b():
#     b = 42
#     def do_global():
#         b = 10
#         print(b)
#         def dd_nonlocal():
#             nonlocal b
#             b = b + 20
#             print(b)
#         dd_nonlocal()
#         print(b)
#     do_global()
#     print(b)
# add_b()



#    ++++++++++++++++++++++++++++++++++          面试题 ====================
# def func(name,l = []):    因为他们公用一个列表 ，第一次的内容 已经添加到列表中了
#    l.append(name)
#    print(l)
#    return l
# print(func("alex"))
# print(func("wusir"))