Day10 函数

函数

1. 什么是匿名函数

   匿名函数还是函数，只是声明的格式和普通函数都不一样，只适用于函数功能比较简单的函数

2. 匿名函数的声明

   • 语法
     变量名 = lambda 形参列表：返回值
   • 说明
     变量名 - 相当于函数名
     lambda - 声明匿名函数的关键字
     形参列表 - 和普通函数的形参列表一样
     ：- 固定写法
     返回值 - 相当于普通函数中只有一条return语句的函数

3. 匿名函数的调用和普通函数一样

   # 1.匿名函数的参数也可以设置默认值（不会有类型提示）
   # 2.匿名函数不能通过添加:类型名来说明参数类型
   
   func1 = lambda x, y = 0: 100
   func1(10,20)
   print(func1(10,20))
   # 匿名函数中可以设置不定长参数
   func2 = lambda  *nums: sum(nums)
   print(func2(1, 2, 3, 4))
   
   func3 = lambda x:print(x)
   print(func3(100))  # None
   

作用域

1. 什么是变量的作用域
   就是变量能够使用的范围

2. 全局变量和局部变量

   • 全局变量 - 没有声明在函数或者类中的变量都是全局变量
     全局变量的作用域是从声明开始到整个文件结束，都可以用

   • 局部变量 - 声明在函数或者类中变量就是局部变量

   • 总结：当我们调用函数的时候，系统会自动在栈区间，专门为函数开辟一块独立的内存空间，
     ​ 用来保存在函数中声明的变量，(形参也是属于声明在函数中的变量)当函数调用结束后，这个栈区间会自动销毁
     ​ -----(函数调用过程是一个压栈的过程)

     # 1.全局变量1
     # 变量a是全局变量
     a = 100
     print(a)
     
     for x in range(5):
         print('循环里：', a)
     
     
     def func1():
         print('函数中：', a)
     
     
     func1()
     
     # 2.全局变量
     # 这儿的y也是全局变量
     for y in range(3):
         print(y)
     
     
     # 3.局部变量
     # a.函数的形参就相当于声明在函中的变量，所以就是局部变量
     
     def func3(num1):
         print(num1)
         for x in range(3):
             print(num1)
     
     
     func3(10)
     
     # 4.如果全局变量和局部变量同名，那么在局部变量作用域中使用的是局部变量，外部使用的是全局变量
     aa = 100
     
     
     def func5():
         aa = 200
         print('函数里', aa)
     
     
     print(func5())
     print(aa)
     

3. global - 在函数中声明一个全局变量(只能在函数中使用)
   在函数中：
   global 变量名
   变量名 = 值

   bb = 111
   
   
   def func6():
       global bb
       bb = 222
       print(bb)
   
   
   func6()
   print(bb)
   

4. nonlocal - 想要在局部的局部去修改局部变量的值，就使用nonlocal对变量进行说明

   nonlocal 局部变量
   局部变量 = 值

   def func11():
       abc = 123
   
       def func22():
           nonlocal abc
           abc = 333
           print('func22', abc)
   
       func22()
   
       print('func11', abc)
   
   
   func11()
   # func11 123
   
   
   list1 = []
   for i in range(5):
       list1.append(lambda x: x * i)
   
   """
   函数在调用的时候不会执行
   list1 = []
   i = 0 list1[lambda x : x*i]
   i = 1 list1[lambda x : x*i, lambda x : x*i]
   i = 2 list1[lambda x : x*i, lambda x : x*i, lambda x : x*i]
   i = 3 list1[lambda x : x*i, lambda x : x*i, lambda x : x*i, lambda x : x*i]
   i = 4 list1[lambda x : x*i, lambda x : x*i, lambda x : x*i, lambda x : x*i, lambda x : x*i]
   """
   
   print(list1[0](3))
   print(list1[3](3))
   
   a = 10
   
   
   func8 = lambda x: x*a
   a = 20
   print(func8(2))
   

函数作为变量

python中声明函数，其实就是声明一个类型是function的变量，函数名就是变量名

1. 给别的变量赋值

   # 声明了一个列表变量 list1
   list1 = [1, 2, 3]
   
   
   # 声明一个函数变量func1
   def func1():
       print('我是一个函数')
       return 10
   
   
   # 列表变量给另外一个变量list2赋值
   list2 = list1
   # 赋值后就可以当做列表来用
   print(list2[1])
   print(list2[::-1])
   
   # 使用函数变量给另外一个函数变量func2赋值
   func2 = func1
   # 赋值后func2就可以当做函数来使用
   func2()
   print(func2())
   

2. 变量作为容器类数据的元素

   a = 10
   nums = [a, 100, 100]
   print(nums)
   print(nums[0])
   
   
   def func3():
       print('abc')
       return 10
   
   
   list2 = [func3, func3(), 100]
   print(list2)
   print(list2[0])
   print(list2[0]())
   

3. 变量作为函数的实参
   ​ 函数作为函数的实参
   ​ 函数1作为函数2的实参 -- 函数2是一个高阶函数

   a = 10
   
   
   def func4(n: int):
       print(n + n - 1)
   
   
   func4(a)
   
   
   def func5(x):
       print(x)
       x(111)
   
   
   func5(func4)
   func5(lambda x: x*2)
   

4. 函数作为参数的应用：sort函数
   列表.sort(key=None, reverse=True)
   参数key - 要求是一个带有一个参数，并且返回值是bool的函数。这儿的参数指向的是列表中元素
   ​ 确定按照元素的某一个值进行排序

   list1 = [1, 2, 9, 8, 7, 5]
   list1.sort(reverse=True)
   print(list1)
   
   all_students = [
       {'name': '张三', 'age': 19, 'score': {'c': 78, 'm': 90, 'e': 40}},
       {'name': '李四', 'age': 24, 'score': {'c': 89, 'm': 60, 'e': 90}},
       {'name': '王五', 'age': 35, 'score': {'c': 78, 'm': 67, 'e': 86}},
       {'name': '赵六', 'age': 46, 'score': {'c': 34, 'm': 99, 'e': 50}}
   ]
   
   
   print(sum)
   # 这的item是需要排序的列表元素
   def func(item):
       return item['age']
   
   
   # all_students.sort(key=func)
   all_students.sort(key=lambda item: item['age'])
   # all_students.sort(key=lambda item: item['score'])
   all_students.sort(key=lambda item: (item['score']['c'] + item['score']['c'] + item['score']['c']))
   print(all_students)
   

5. 变量作为函数的返回值
   函数1作为函数2的返回值 - 函数2是返回值高阶函数

   def operation(char):
       if char == '+':
           def fun1(*nums):
               return sum(nums)
           return fun1
       elif char == '-':
           def fun2(*nums):
               if not nums:
                   return 0
               sum1 = nums[0]
               for index in range(1,len(nums)-1):
                   sum1 -= nums[index]
           return fun2
   
   
   print(operation('+')(1,2,3,4))