[Python知识库]Python第一阶段学习总结

【第12天】Python第一阶段学习总结

2021/09/29

一. 匿名函数（没有名字的函数）

1. 本质：匿名函数的本质还是函数，但是匿名函数只能实现一句代码就能实现的功能

2. 语法：

   函数名 = lambda 参数列表：返回值
   

3. 说明：

   1. lambda - 关键字；固定写法
   2. 参数列表 - 普通函数写在（）中的形参列表
   3. ： - 固定写法
   4. 返回值 - 相当于普通函数return后面的值

4. 注意：匿名函数需要保存才能调用

   函数名 = lambda 参数列表：返回值
   相当于
   def (参数列表)：
       return 返回值
   

   sum1 = lambda x, y=2: x + y
   result = sum1(10)
   print(result)
   

   # 练习：写一个匿名函数，判断指定整数是否是偶数
   even = lambda x: x % 2 == 0
   
   x = 2
   result = even(x)
   print(result)
   
   y = 3
   result = even(y)
   print(result)
   

二. 变量作用域

1. 变量的作用域：变量可以使用的范围

1. 根据变量作用域的不同，可以将变量分为：全局变量和局部变量

2. 全局变量

1. 没有定义在函数或者类里面的变量就是全局变量
   全局变量的作用域:从定义开始到程序结束（从定义开始到文件结束的任何位置都可以使用）

    a是全局变量
   a = 100
   
   # x和b也是全局变量
   for x in range(3):
       b = 10
   
   print(f'函数外a:{a}, x:{x}, b:{b}')
   
   
   def func1():
       print(f'函数外a:{a}, x:{x}, b:{b}')
   
   
   func1()
   

3. 局部变量

1. 局部变量就是定义在函数里面的变量（形参也是局部变量）
   局部变量的作用月：从定义开始到函数结束

   # m和n是局部变量
   def func2(m):
       n = 10
       print(f'函数里面m:{m}, n:{n}')
   
   
   func2(100)
   # print(f'函数里面m:{m}, n:{n}')  报错，局部变量在函数外不能使用
   

4. 全局变量和局部变量的底层逻辑

1. 全局变量是保存在全局的栈区间中，全局栈区间是在程序运行结束的时候才会被释放。
   当程序调用函数的时候，系统会自动给这个函数创建一个独立的栈区间，专门用来保存在函数中产生的数据（局部变量就是保存在这个内存区间中），当函数调用结束这个栈区间会自动释放。

5. global和nonlocal

1. global

   作用1：在函数内部修改全局变量的值使用global
   作用2：在函数内部定义一个全局变量

   注意：使用global的时候必须保证在函数里面global修饰的变量不会出现在它的前面。

   x = 1000
   yy = 1000
   
   def func3():
       # 在函数里面不能直接修改全局变量的值，而是定义一个新的局部变量
       xx = 2000
       print(f'函数内部xx:{xx}')
   
       # 应用1：在函数内部修改全局变量的值使用global
       global yy
       yy = 2000
       print(f'函数内部yy:{yy}')
   
   
       global num
       num = 100
       print(f'函数内部num:{num}')
   
       global zz
       zz = 1000
   
   
   
   func3()
   print(f'函数外部xx:{xx}')
   print(f'函数外部yy:{yy}')
   print(f'函数外部num:{num}')
   print(f'函数外部zz:{zz}')
   

2. (了解)nonlocal - 在局部的局部修改一个局部变量的值

def func4():
    k = 100
    def func5():
        nonlocal k
        k = 200
        print(f'func5中k:{k}')
    func5()
    print(f'func4中k:{k}')

三. 高阶函数

1. 函数就是变量

1. Python中定义函数其实就是定义一个类型是function的变量，函数名就是变量名

2. 变量能做的函数都能做

   a = lambda x:x*2
   print(type(a))      # <class 'function'>
   
   
   a = 100
   print(type(a))    # <class 'int'>
   
   def a(x):
       return x*2
   
   print(type(a))     #  <class 'function'>
   

   # 场景一:可以通过使用变量来使用变量中保存的数据.如果这个数据是函数,函数的通用操作是调用它。
   
   x = 100
   print(x)
   

   # 场景二：用一个变量给另外一个变量赋值
   m = 100
   n = m
   print(n * 100)
   
   
   def mm():
       print('这是一个函数')
   
   nn = mm
   nn()
   

   # 场景三：修改变量的值
   m = 100
   print(m % 10)
   m = [10, 20, 30]
   print(m[-1])
   
   
   def mm():
       print('这是一个函数')
   
   
   mm()
   mm = 100
   print(mm % 10)
   
   
   
   def b():
       print('这是另一个函数')
   
   
   b()        # 这是另一个函数
   print(b())   # 这是另一个函数（函数调用时执行函数体） b()的返回值：None
   

2. 高阶函数

1. 变量可以作为函数的实参
   实参高阶函数 - 如果一个函数的参数是函数，那么这个函数就是一个实参高阶函数

2. 函数可以作为函数的返回值
   返回值高阶函数 - 如果一个函数的返回值是函数， 那么这个函数就是一个返回高阶函数

   # func2就是实参高阶函数
   def func2(x):
       x() + 10
   
   
   def t():
       return 12.9
   
   func2(t)
   
   
   
   def func3(x):
       def t():
           pass
       return t
   
   
   func3(10)()     # t()
   

四. 实参高阶函数

1. max、min、sorted

1. max(序列，key=函数) - 根据函数提供的方式来获取序列中元素的最大值

   函数的要求：

   1. 有且只有一个参数，这个参数指向的是序列中的每个元素
   2. 需要一个返回值，返回值是比较对象

nums = [28, 52, 61, 70, 84, 9]
print(max(nums))


def f(item):
    return item

print(max(nums, key=lambda item: item)) # 84

# 练习1：获取nums中个位数最大的元素
# [28, 52, 61, 70, 84, 39]  -> 39
nums = [28, 52, 61, 70, 84, 39]
print(max(nums, key=lambda item: item % 10))     # 39

# 练习2：获取年龄最大的学生
students = [
    {'name': 'stu1', 'age': 28, 'score': 90},
    {'name': 'stu2', 'age': 20, 'score': 99},
    {'name': 'stu3', 'age': 18, 'score': 88},
    {'name': 'stu4', 'age': 32, 'score': 92}
]

print(max(students, key=lambda item: item['age']))    # {'name': 'stu4', 'age': 32, 'score': 92}

# 练习3：获取分数最大的学生
students = [
    {'name': 'stu1', 'age': 28, 'score': 90},
    {'name': 'stu2', 'age': 20, 'score': 99},
    {'name': 'stu3', 'age': 18, 'score': 88},
    {'name': 'stu4', 'age': 32, 'score': 92}
]

print(max(students, key=lambda item: item['score']))     # {'name': 'stu2', 'age': 20, 'score': 99}

# 练习4：获取nums中各个位数的和最大的元素
# [123, 78, 90, 301, 49]   ->  [6, 15, 9, 4, 13]  -> 78

nums = [123, 78, 90, 301, 49]
# [6, 15, 9, 4, 13]
def t(item):
    sum1 = 0
    for x in str(item):
        sum1 += int(x)
    return sum1

print(max(nums, key=t))    # 78
print(max(nums, key=lambda item: sum([int(x) for x in str(item)])))      # 78

2. sorted

# 练习1：将nums中元素按照个位数的大小从小到大排序
nums = [28, 52, 61, 70, 84, 39]
print(sorted(nums, key=lambda item: item % 10))   # [70, 61, 52, 84, 28, 39]

# 练习2：将下面列表中的元素按照数值大小从大到小排序
nums = [23, '100', 56, '12.7', '100.2']
# ['100.2', '100', 56, 23, '12.7']
print(sorted(nums, key=lambda item: float(item),reverse=True))    # ['100.2', '100', 56, 23, '12.7']

2. map

1. map(函数，序列) - 将序列中的元素按照函数提供的方式进行变换
   函数的要求：

   1. 有且只有一个参数，指向序列中的每个元素
   2. 需要一个返回值，返回值就是新序列中的元素(描述清楚新序列的元素和原序列元素的关系)

   相当于：[返回值 for 参数 in 序列] （可以用推导式完成）

2. map(函数，序列1，序列2)
   函数的要求：

   1. 有且只有两个参数，分别指向两个序列中的元素
   2. 需要一个返回值，返回值就是新序列中的元素(描述清楚新序列的元素和原序列元素的关系)

3. map(函数，序列1，序列2，序列3，…)

   nums = [28, 52, 61, 70, 84, 39]
   # [8, 2, 1, 0, 4, 9]
   result = map(lambda item: item % 10, nums)
   print(list(result))  # [8, 2, 1, 0, 4, 9]
   

   # 练习：
   A = [10, 20, 30, 40]
   B = ['a', 'b', 'c', 'm']
   result = list(map(lambda i1, i2: i2+str(i1), A, B))
   print(result)      # ['a10', 'b20', 'c30', 'm40']
   

   # 练习：
   names = ['张三', '小明', '李四', '小花']
   scores = [90, 89, 99, 70]
   # 结束: [{'name': '张三', 'score': 90}, {'name': '小明', 'score': 89},....]
   
   result = list(map(lambda i1, i2: {'name': i1, 'score': i2}, names, scores))
   print(result)
   

3. reduce：将一个序列中的元素按照指定的规则合并成一个数据

1. reduce(函数，序列，初始值) - 用指定的初始值来将序列中的元素按照函数指定的规则合并成一个数据
2. 函数的要求：
   1. 有且只有两个参数：第一个参数指向初始值；第二个参数指向序列中的每个元素
   2. 需要一个返回值：描述清楚最后合并的结果是初始值和序列中的元素通过什么样的方式合并产生的

from functools import reduce

nums = [10, 20, 30]
# 1) 初始值+10+20+30 -> 60
result = reduce(lambda x, y: x+y, nums, 0)
print(result)

# 2) 10*20*30 -> 6000
result = reduce(lambda x, y: x*y, nums, 1)
print(result)

# 3) -> '102030'
result = reduce(lambda x, y: x + str(y), nums, '')
print(result)

# 4) -> '123'
result = reduce(lambda x, y: x + str(y // 10), nums, '')
print(result)

# 5) 1+2+3 -> 6
result = reduce(lambda x, y: x + (y // 10), nums, 0)
print(result)