python匿名函数-高阶函数-实参高阶函数

1. 匿名函数

"""
匿名函数的本质还是函数，但是匿名函数只能实现一句代码就能实现的功能
1)语法： 
lambda 参数列表:返回值

2)说明：
a.lambda  - 关键字；固定写法
b.参数列表  -  普通函数写在()中的形参列表
c.:       -   固定写法
d.返回值   -  相当于普通函数return后面的值

3)注意: 匿名函数需要先保存才能再调用

函数名 = lambda 参数列表:返回值
相当于
def 函数名(参数列表):
    return 返回值
"""
sum1 = lambda x, y=2: x+y
result = sum1(10, 20)
print(result)

result = sum1(y=200, x=100)
print(result)

result = sum1(10)
print(result)

# 练习：写一个匿名函数，判断指定整数是否是偶数
is_even = lambda num: num % 2 == 0
print(is_even(41))


list1 = [10, lambda x: x*2]
print(list1[-1](10))

dict1 = {'a': 10, 'b': lambda x: x*2}
print(dict1['b'](2) + 100)


func1 = lambda *x: 100
func1(10)
func1(20, 34)

高阶函数

# 1. 函数就是变量
"""
Python中定义函数其实就是定义一个类型是function的变量，函数名就是变量名。
变量能做的事情，函数都能做。
"""

# 函数名 = lambda 参数列表:返回值
#
# def 函数名(参数列表):
#     return 返回值

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 % 2)

x = 'abc'
print(x[-1])

x = [10, 20, 30]
x.append(200)

x = {'a': 100, 'b': 200}
print(x['a'])

x = lambda m: m+100
print(x(7))

def x(m):
    return m+100

x(10)
print(x)        # <function x at 0x10da17790>

# 场景二：用一个变量给另外一个变量赋值
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)

a = 100

def b():
    print('我是另外一个函数')


list1 = [a, 200, b]
print(list1)        # [100, 200, <function b at 0x108d43160>]
print('x:', list1[-1]())     # print('x:', b())

list1 = [a, 200, b()]
print(list1)    # [100, 200, 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))    # 84

# def f(item):
#     return item
# f = lambda item:item

# [28, 52, 61, 70, 84, 9]
print(max(nums, key=lambda item: item))    # 84

# 练习1：获取nums中个位数最大的元素
# [28, 52, 61, 70, 84, 39]  -> 39
nums = [28, 52, 61, 70, 84, 39]
# [8, 2, 1, 0, 4, 9]
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}
]
# [28, 20, 18, 32]
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}
print(min(students, key=lambda item: item['score']))

# 练习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

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

# 练习：将下面列表中的元素按照数值大小从大到小排序
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))

# 2.map
"""
1) map(函数, 序列)   -  将序列中的元素按照函数提供的方式进行变换
函数的要求: 1.有且只有一个参数，指向序列中的每个元素
          2.需要一个返回值，返回值就是新序列中的元素 (描述清楚新序列的元素和原序列元素的关系)
          
相当于：[返回值 for 参数 in 序列]

2) map(函数, 序列1, 序列2)
函数的要求：1.有且只有两个参数，分别指向两个序列中元素
          2.需要一个返回值，返回值就是新序列中的元素
          
3) map(函数, 序列1, 序列2, 序列3, 序列4,...)

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

# 练习：
# A = [10, 20, 30, 40]   B = ['a', 'b', 'c', 'm']
# 新列表 = ['a10', 'b20', 'c30', 'm40']
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  -   将一个序列中的元素按照指定的规则合并成一个数据
""" 
reduce(函数, 序列, 初始值)  -  用指定的初始值来将序列中的元素按照函数指定的规则合并成一个数据
函数的要求：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)       # 60

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

# -> '102030' -> '10'+'20'+'30'  -> str(10) + str(20) + str(30)
# 初始值 + str(10) + str(20) + str(30)  == '102030'
result = reduce(lambda x, y: x + str(y), nums, '')
print(result)   # '102030'

nums = [10, 20, 30]
# -> '123' -> '1'+'2'+'3'  -> str(1) + str(2) + str(3)
# 初始值 + str(10//10%10) + str(20//10%10) + str(30//10%10)   -> '123'
result = reduce(lambda x, y: x+str(y // 10 % 10), nums, '')
print(result)

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

全局变量与局部变量

# 1. 变量的作用域  -  变量可以使用的范围
"""
根据变量作用域的不同，可以将变量分为：全局变量和局部变量
"""

# 2. 全局变量
"""
没有定义在函数或者类里面的变量就是全局变量;
全局变量的作用域：从定义开始到程序结束(从定义开始到文件结束的任何位置都可以使用)
"""
# 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. 局部变量
"""
局部变量就是定义在函数里面的变量（形参也是局部变量）;
局部变量的作用域：从定义开始到函数结束
"""
# m和n是局部变量
def func2(m):
    # m = 100
    n = 10
    print(f'函数里面m:{m}, n:{n}')


func2(100)
# print(f'函数外面m:{m}, n:{n}')

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

# 5. global和nonlocal
"""
1)global
作用1：在函数内部修改全局变量的值使用global
作用2：在函数内部定义一个全局变量

注意：使用global的时候必须保证在函数里面global修饰的变量不会出现在它的前面。
"""
xx = 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}')


func3()
print(f'函数外部xx: {xx}')
print(f'函数外部yy:{yy}')
print(f'函数外部num:{num}')


# （了解）nonlocal  -  在局部的局部修改一个局部变量的值
def func4():
    k = 100
    def func5():
        nonlocal k
        k = 200
        print(f'func5中k：{k}')
    func5()
    print(f'func4中k:{k}')


func4()

欢迎查看我的技术文档
网站有我的联系方式，欢迎学习交流