python全栈开发 * 10知识点汇总 * 180612

10 函数进阶  知识点汇总
 一.动态参数  形参的第三种
1.动态接收位置传参  表达:*args  (在参数位置编写 * 表⽰接收任意内容)
 (1)动态位置参数
def eat(*args):
    print(args)
eat("水果","蔬菜","肉",)
# # 结果以元祖的形式呈现.  :  ('水果', '蔬菜', '肉')
 (2) 位置参数,动态位置参数: 动态参数必须在位置参数后⾯
def eat(a,b,*args):
    print(a,b,args)
eat("水果","蔬菜","鸡","鸭","鱼")
# # 结果 : 水果 蔬菜 ('鸡', '鸭', '鱼')
(3) 如果 "*args" ,位置参数,则后面的位置参数必须用关键字参数传值.
def eat(*args,a,b,):
    print(args,a,b,)
eat("苹果","香蕉","梨","芒果",a="荔枝",b="樱桃")
#   结果 : ('苹果', '香蕉', '梨', '芒果') 荔枝 樱桃
(4).如果有默认值参数,则默认值参数必须写在动态参数之后才能生效.
def eat(a,b,*args,c=66):
    print(a,b,args,c)
eat(1,2,3,4,5,6,7,8,)
# 结果: 1 2 (3, 4, 5, 6, 7, 8) 66
# 动态参数的顺序:  位置参数, 动态参数*, 默认值参数
 2.动态接收关键字参数    表达:(**kwargs)
def fun(**kwargs):
    print(kwargs)
fun(a=11,b=22,c=33)
# 结果以字典的形式呈现 ; {'a': 11, 'b': 22, 'c': 33}
# 动态接收关键字参数也要在后⾯
# 混合
def eat(a,b,*args,c=11,**kwargs):
    print(a,b,args,c,kwargs)
eat("苹果","香蕉","橘子","荔枝","芒果","西瓜",d="火龙果")
# 动态参数的顺序:位置参数 ,动态接收位置参数 ,默认值参数,.动态接收关键字参数.
 3.无敌传参:  def fun(*args,**kwargs)    先位置后关键字
def fun(*args,**kwargs):
    print(args,kwargs)
fun(1,2,3,4,a=33,b=44,c=55)
#  结果 (1, 2, 3, 4) {'a': 33, 'b': 44, 'c': 55}
 4."动态参数的另一种传参方式
 列表 (list)
def fun(*args):
 print(args)
lst = [1, 4, 7]
fun(lst[0], lst[1], lst[2])  #或者下面的方式
fun(*lst) # 可以使⽤*把⼀个列表按顺序打散
 字符串
s = "⾂妾做不到"
fun(*s)
 字典  (dict)
def fun(**kwargs):
 print(kwargs)
dic = {'a':1, 'b':2}
fun(**dic)
 5.函数的注释
 二.命名空间 :  我们给存放名字和值的关系的空间起⼀个名字叫: 命名空间
1.命名空间分类:
#  (1).全局命名空间--> 我们直接在py⽂件中, 函数外声明的变量都属于全局命名空间
#  (2) 局部命名空间--> 在函数中声明的变量会放在局部命名空间
#  (3) 内置命名空间--> 存放python解释器为我们提供的名字, list, tuple, str, int这些都是内置命名空间.
2.命名空间的加载顺序
# (1)内置命名空间;
# (2)全局命名空间:
# (3)局部命名空间 (函数被执行的时候)
3.命名空间的取值顺序;
# (1)局部命名空间
# (2)全局命名空间
# (3)内置命名空间
三.作用域:  作⽤域就是作⽤范围, 按照⽣效范围来看分为 全局作⽤ 域 局部作⽤域
1.全局作⽤域: 包含内置命名空间和全局命名空间. 在整个⽂件的任何位置都可以使⽤(遵循从上到下逐⾏执⾏)
2.局部作⽤域: 在函数内部可以使⽤.
3.globals()函数来查看全局作⽤域中的内容, locals()来查看局部作⽤域中的变量和函数信息
a = 10
def func():
 a = 40
 b = 20
 def abc():
  print("哈哈")
 print(a, b) # 这⾥使⽤的是局部作⽤域
 # print(globals()) # 打印全局作⽤域中的内容
 # print(locals()) # 打印局部作⽤域中的内容
func()
四.函数的嵌套
1. 只要遇⻅了()就是函数的调⽤. 如果没有()就不是函数的调⽤
2. 函数的执⾏顺序
def fun1():
    print(111)
def fun2():
    print(222)
    fun1()
fun2()
print(111)
# 结果:222,111,111
# 函数的嵌套
def fun2():
    print(222)
    def fun3():
        print(666)
    print(444)
    fun3()
    print(888)
print(33)
fun2()
print(555)
# 结果: 33,222,444,666,888,555
 四.global  and nonlocal
1.global表⽰. 不再使⽤局部作⽤域中的内容了. ⽽改⽤全局作⽤域中的变量
a = 100
def func():
    global a # 加了个global表示不再局部创建这个变量了. ⽽是直接使⽤全局的a
    a=28
    print(a)
func()
print(a)
# 对于可变数据类型可以直接进⾏访问. 但是不能改地址. 说⽩了. 不能赋值
lst = ["麻花藤", "刘嘉玲", "詹姆斯"]
def func():
 lst.append("⻢云云") # 对于可变数据类型可以直接进⾏访问. 但是不能改地址. 说⽩了. 不能赋值
 print(lst)
func()
print(lst)
2.nonlocal 表⽰在局部作⽤域中, 调⽤⽗级命名空间中的变量.
a = 10
def func1():
   a = 20
   def func2():
     nonlocal a
     a = 30
     print(a)
   func2()
   print(a)
func1()
# j结果: 加了nonlocal  30  30
# 不加nonlocal  30 20
# 多层嵌套
a = 1
def fun_1():
    a = 2
    def fun_2():
        nonlocal a
        a = 3
        def fun_3():
          a = 4
          print(a)
        print(a)
        fun_3()
        print(a)
    print(a)
    fun_2()
    print(a)
print(a)
fun_1()
print(a)