函数的进阶

1. 函数的传参：形参的第三种参数：万能参数--动态参数(解决参数数目不定的问题)

   def eat(food1,food2,food3):
        print(f'我请你吃：{food1},{food2},{food3}')
   eat('蒸羊羔','蒸熊掌','蒸鹿尾')
   
   当给函数传入的参数数目不定时，之前的传参方式解决不了问题。
   万能参数，动态参数。 *args
   def eat(food1,food2,food3):
        print(f'我请你吃：{food1},{food2},{food3}')
    eat('蒸羊羔','蒸熊掌','蒸鹿尾','烧花鸭','烧企鹅')
   
   def eat(*args):  # 将实参角度：定义一个函数时，* 所有的位置参数聚合到一个元组中。
       print(args)
       print(f'我请你吃：{args}')
   eat('蒸羊羔','蒸熊掌','蒸鹿尾','烧花鸭','烧企鹅')
   
   函数接收不定个数的数字实参，将最终的和返回出去。
   def sum1(*args):
   	print(args)  (100, 2, 67, 3)
   	result = 0
   	for i in args:
        	result += i
        return result
    print(sum1(100,2,67,3))
   
   **kwargs
   
   def func(**kwargs):  # 函数的定义时：**将实参角度所有的关键字参数聚合成了一个字典，给了kwargs.
        print(kwargs)
   func(name='alex',age=84,hobby='唱跳rap篮球')
   
   *args,**kwargs 万能参数
   def func(*args,**kwargs):
       print(args,kwargs)
   func(1,2,4,'fjdksal',age=84,hobby='唱跳rap篮球')
   
   *的魔性用法： （函数中）
   
   def func(*args,**kwargs):
       print(args)  # (1, 2, 3,'太白', 'wusir', '景女神')
       print(kwargs)
   
    l1 = [1, 2, 3]
    l2 = ['太白', 'wusir', '景女神']
    func(l1,l2)
    func(*l1,*l2)  # 当函数的执行时：*iterable 代表打散。
    func(*[1, 2, 3],*(11,22),*'fdsakl')  # 当函数的执行时：*iterable 代表打散。
   
    def func(*args,**kwargs):
        print(args)
        print(kwargs)
    func(**{'name':"alex"},**{'age': 73,'hobby': '吹'})
   当函数的执行时：**dict 代表打散。
   
   
   函数外：处理剩余元素
   a,b,*c = [1,2,3,4,5]
   a,*c,b, = [1,2,3,4,5]
   a,*c = range(5)
   a,*c,b = (1,2,3,4,5,6)
   print(a,c,b)
   

2. 函数形参角度，形参的顺序

   *args的位置
   *args不能放在位置参数前面，a,b取不到值
   def func(*args,a,b,sex='man',):
      print(a)
      print(b)
      print(sex)
      print(args)
      print(kwargs)
   func(1,2,4,5,6)
   
   *args如果想要接收到值之前，肯定要改变sex默认参数。
   def func(a,b,sex='man',*args):
   	print(a)
   	print(b)
   	print(sex)
   	print(args)
   	print(kwargs)
   func(1,2,4,5,6)
   
   def func(a,b,*args,sex='man'):
   	print(a)
   	print(b)
   	print(sex)
   	print(args)
   	print(kwargs)
   func(1,2,4,5,6)
   func(1,2,4,5,6,sex='women')
   
   **kwargs
   位置参数,*args,默认参数，**kwargs
   def func(a,b,*args,sex='man',**kwargs,):
   	print(a)
   	print(b)
   	print(sex)
   	print(args)
   	print(kwargs)
   func(1,2,4,5,6,name='太白',age=18)
   
   形参角度第四种传参方式：仅限关键字参数  (了解)
   位置参数,*args,默认参数，仅限关键字参数,**kwargs
   def func(a,b,*args,sex='man',c,**kwargs,):
   	print(a)
   	print(b)
   	print(sex)
   	print(c)
   	print(args)
   	print(kwargs)
   func(1,2,4,5,6,67,c=666,name='太白',age=18,)
   

3. 从空间角度研究函数

   • 全局命名空间--> 我们直接在py文件中, 函数外声明的变量都属于全局命名空间
   • 局部命名空间--> 在函数中声明的变量会放在局部命名空间
   • 内置命名空间--> 存放python解释器为我们提供的名字, list, tuple, str, int这些都是内置命名空间
   • 加载顺序：函数直接可以用的比如abs(-1),max(1,3)等等，在启动Python解释器的时候，就已经导入到内存当中供我们使用，所以肯定是先加载内置名称空间，然后就开始从文件的最上面向下一行一行执行，此时如果遇到了初始化变量，就会创建全局名称空间，将这些对应关系存放进去，然后遇到了函数执行时，在内存中临时开辟一个空间，加载函数中的一些变量等等。所以这三个空间的加载顺序为：内置命名空间(程序运行伊始加载)->全局命名空间(程序运行中：从上到下加载)->局部命名空间(程序运行中：调用时才加载。
   • 取值顺序：取值顺序就是引用一个变量，先从哪一个空间开始引用。这个有一个关键点：从哪个空间开始引用这个变量。
   • 所以空间的取值顺序与加载顺序是相反的，取值顺序满足的就近原则，从小范围到大范围一层一层的逐步引用

   name = 'alex'
   l1 = [1,2,3]
   def func():
   name = '太白'
   print(666)
   func()
   
   # def func1():
   
   #     age = 18
   
   模块
   # import time
   
   # # print(time.time())
   
   # print(111)
   
   # time.sleep(1)
   
   # age = 18
   
   #
   
   # print(66)
   
   # input()
   
   
   
   # 变量（函数名也叫变量）
   
   
   # input = 666
   
   # print(input)
   
   # 从全局寻找input ————> 全局名称空间 ——————> 内置
   
   
   
   # input = '太白'
   
   # def func():
   
   #     # input = 666
   
   #     print(input)
   
   #
   
   # func()
   
   
   
   # 从局部寻找input ——————> 局部名称空间 ————> 全局名称空间 ——————> 内置
   
   # 取值顺序：单向不可逆
   
   
   
   # def func():
   
   #     name = 'alex'
   
   #
   
   # func()
   
   # print(name)
   
   
   
   # name = '太白'
   
   # def func():
   
   #     # name = 'alex'
   
   #     def inner():
   
   #         print(name)
   
   #     inner()
   
   # func()
   

4. 作用域

   作用域就是作用范围, 按照生效范围来看分为全局作用域和局部作用域

   全局作用域: 包含内置命名空间和全局命名空间. 在整个文件的任何位置都可以使用(遵循 从上到下逐⾏执行).

   局部作用域: 在函数内部可以使用.

   作⽤域命名空间:

   1. 全局作用域: 全局命名空间 + 内置命名空间
   2. 局部作⽤域: 局部命名空间

5. 内置函数：locals，globals

"""
此文件研究的是内置函数 globals locals
"""
name = 'alex'
l1 = [1, 2, 3]

def func():
age = '18'
print(globals()) # 全局作用域所有的内容
print(locals())  # 当前位置

name = 'alex'
l1 = [1, 2, 3]
def func():
age = '18'
oldboy = '老男孩教育'
print(globals()) # 全局作用域所有的内容
print(locals())  # 当前位置的变量与值的对应关系
func()

name = 'alex'
l1 = [1, 2, 3]

def func():
	age = '18'
	oldboy = '老男孩教育'
		def inner():
		name_class = 'python23期'
			print(globals()) # 全局作用域所有的内容
			print(locals())  # 当前位置的变量与值的对应关系
		inner()
func()

12. 高阶函数

例1：
def func1():
     print('in func1')
     print(3)
def func2():
     print('in func2')
     print(4)

func1()
print(1)
func2()
print(2)

in func1

3

1

in func2'

4

2

例2：

def func1():
    print('in func1'
    print(3)
def func2():
    print('in func2')
    func1()
    print(4)

print(1)

func2()

print(2)

'''

1

in func2

in func1

3

4

2

'''

# # 例3：

def fun2():

    print(2)

    def func3():

        print(6)

    print(4)

    func3()

    print(8)

print(3)

fun2()

print(5)
'''
3 2 4 6 8 5
'''