python学习之高阶函数

一、定义：

        1、变量名可以指向函数。

        示例：

        f=abs
        print(abs)
        print(f)
        print(f(-10))

                输出结果：

                <built-in function abs>
                <built-in function abs>
                10

                说明：变量f指向abs函数本身。

        2、函数名也是变量。

                函数名就是指向函数的变量。对于abs（）函数，可以把abs看作一个变量，指向计算绝对值的函数。

                验证：

                        

        abs=10
        print(abs(-10))

                结果：

                         print(abs(-10))
                         TypeError: 'int' object is not callable

报错，这时候abs指向10，不能再指向计算绝对值的函数。所以出现错误。验证了函数名也是变量。

        3、定义：既然1、变量名可以指向函数。2函数名也是变量。那么 一个函数就可以接收另外一个函数作为参数。这种函数就叫做高阶函数。

        4、高阶函数示例：

def fun(x,y,f):
    return f(x)+f(y)
result1=fun(-10,5,abs)
result2=fun(-10.5,-6.3,round)
print(result1)
print(result2)

round函数是取整。结果是15，-16。

把函数作为参数传入，这样的函数称为高阶函数。

函数式编程是指这种高度抽象的编程范式。

二、内置高阶函数：

1、map（）

在Python中，`map()` 函数是一个内置的高阶函数，它接受一个函数和一个可迭代对象作为参数，将传入的函数应用于可迭代对象的每个元素，并返回一个新的迭代器。这个新迭代器中的元素是原始元素经过函数处理后的结果。

以下是 `map()` 函数的一些基本用法：

### 基本用法
```python
# 定义一个简单的函数，比如将数字翻倍
def double(x):
    return x * 2

# 创建一个列表
numbers = [1, 2, 3, 4, 5]

# 使用 map 函数将 double 函数应用于每个元素
doubled_numbers = map(double, numbers)

# map 返回的是一个 map 对象，可以使用 list 转换为列表
print(list(doubled_numbers))  # 输出: [2, 4, 6, 8, 10]
```

### 多个参数的函数
`map()` 函数也可以接受多个序列作为参数，并将传入的函数应用于这些序列的对应元素。

```python
# 定义一个函数，接受两个参数并返回它们的和
def add(a, b):
    return a + b

# 创建两个列表
numbers1 = [1, 2, 3]
numbers2 = [4, 5, 6]

# 使用 map 函数将 add 函数应用于两个列表的对应元素
sums = map(add, numbers1, numbers2)

# 将结果转换为列表
print(list(sums))  # 输出: [5, 7, 9]
```

### 使用 lambda 表达式
`map()` 经常与匿名函数（lambda 表达式）一起使用，以简化代码。

```python
# 使用 lambda 表达式将列表中的每个数字乘以 3
numbers = [1, 2, 3, 4, 5]
tripled_numbers = map(lambda x: x * 3, numbers)

# 将结果转换为列表
print(list(tripled_numbers))  # 输出: [3, 6, 9, 12, 15]
```

### 注意事项
- `map()` 返回的是一个迭代器，如果你需要一个列表，可以使用 `list()` 函数将其转换。
- `map()` 可以用于任何可迭代对象，不仅仅是列表。

`map()` 函数是Python中实现函数式编程风格的强大工具之一，它提供了一种优雅的方式来对集合进行转换。

2、reduce（）

在Python中，`reduce()` 函数是一个内置的高阶函数，它位于 `functools` 模块中。`reduce()` 函数接受两个参数：一个函数和一个可迭代对象。这个函数将两个参数的元素配对，然后应用传入的二元函数，将它们归约（reduce）为单个值。

### 基本用法

from functools import reduce
# 定义一个函数，用于计算两个数的乘积
def multiply(x, y):
    return x * y

# 创建一个数字列表
numbers = [1, 2, 3, 4, 5]

# 使用 reduce 函数将 multiply 函数应用于列表的元素，得到所有数字的乘积
product = reduce(multiply, numbers)

print(product)  # 输出: 120
```

### 使用 lambda 表达式
`reduce()` 函数也可以与 lambda 表达式一起使用，以简化代码。

```python
from functools import reduce

# 使用 lambda 表达式计算列表中所有数字的和
numbers = [1, 2, 3, 4, 5]
sum = reduce(lambda x, y: x + y, numbers)

print(sum)  # 输出: 15
```

### 指定初始值
在某些情况下，你可能希望在归约过程中提供一个初始值。这可以通过 `functools.reduce()` 的 `initial` 参数实现。

```python
from functools import reduce

# 使用初始值 10 来计算列表中所有数字的累积和
numbers = [1, 2, 3, 4, 5]
sum_with_initial = reduce(lambda x, y: x + y, numbers, 10)

print(sum_with_initial)  # 输出: 25
```

### 注意事项
- `reduce()` 函数在Python 3中被移到了 `functools` 模块中，而在Python 2中是内置函数。
- `reduce()` 函数对于空的可迭代对象会抛出 `TypeError`，除非你提供了初始值。
- 由于 `reduce()` 函数在处理大数据集时可能会消耗大量内存，因此在某些情况下，使用循环或其他方法可能更高效。

`reduce()` 是实现归约操作的强大工具，它可以用于多种场景，包括但不限于数学运算、数据聚合等。

3、filter（）

在Python中，`filter()` 函数是一个内置的高阶函数，它用于过滤序列，从中提取符合条件的元素，返回一个迭代器。`filter()` 函数接受两个参数：一个函数和一个序列（如列表、元组等）。传入的函数用于测试序列中的每个元素，返回 `True` 或 `False`。序列中使得该函数返回 `True` 的元素会被 `filter()` 函数收集并返回。

### 基本用法
```python
# 定义一个函数，用于检查数字是否为偶数
def is_even(num):
    return num % 2 == 0

# 创建一个数字列表
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 使用 filter 函数过滤出偶数
even_numbers = filter(is_even, numbers)

# filter 返回的是一个 filter 对象，可以使用 list 转换为列表
print(list(even_numbers))  # 输出: [2, 4, 6, 8]
```

### 使用 lambda 表达式
`filter()` 函数经常与 lambda 表达式一起使用，以简化代码。

```python
# 使用 lambda 表达式过滤出列表中的偶数
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
even_numbers = filter(lambda x: x % 2 == 0, numbers)

# 将结果转换为列表
print(list(even_numbers))  # 输出: [2, 4, 6, 8]
```

### 过滤复杂条件
`filter()` 函数可以用于更复杂的条件过滤。

```python
# 过滤出列表中大于5的数字
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
greater_than_five = filter(lambda x: x > 5, numbers)

# 将结果转换为列表
print(list(greater_than_five))  # 输出: [6, 7, 8, 9]
```

### 注意事项
- `filter()` 返回的是一个迭代器，如果你需要一个列表，可以使用 `list()` 函数将其转换。
- `filter()` 可以用于任何可迭代对象，不仅仅是列表。
- 如果序列中没有元素满足条件，`filter()` 将返回一个空的迭代器。

`filter()` 函数是Python中实现函数式编程风格的强大工具之一，它提供了一种简洁的方式来从集合中筛选出满足特定条件的元素。

4、sorted（）

在Python中，`sorted()` 函数用于对可迭代对象的元素进行排序，并返回一个新的排好序的列表。排序默认是升序，但你也可以指定一个自定义的排序方式。

### 基本用法
```python
# 对数字列表进行排序
numbers = [3, 1, 4, 1, 5, 9, 2, 6]
sorted_numbers = sorted(numbers)
print(sorted_numbers)  # 输出: [1, 1, 2, 3, 4, 5, 6, 9]
```

### 降序排序
你可以通过设置 `reverse` 参数为 `True` 来实现降序排序。

```python
# 对数字列表进行降序排序
sorted_numbers_desc = sorted(numbers, reverse=True)
print(sorted_numbers_desc)  # 输出: [9, 6, 5, 4, 3, 2, 1, 1]
```

### 使用自定义排序函数(作为高阶函数)
你还可以通过 `key` 参数指定一个函数，用于从每个元素中提取一个用于排序的值。

```python
# 假设有一个字符串列表，我们根据字符串的长度进行排序
words = ['bananaaa', 'app', 'cher', 'dateee']
# 使用 key 参数指定按字符串长度排序
sorted_words = sorted(words, key=len)
print(sorted_words)  # 输出: ['app', 'cher', 'dateee', 'bananaaa']
```

### 使用 lambda 表达式作为 key
`key` 参数也可以使用 lambda 表达式来指定排序的依据。

```python
# 假设有一个字典列表，我们根据字典中的某个值进行排序
data = [{'name': 'John', 'age': 45},
        {'name': 'Diana', 'age': 32},
        {'name': 'Zoe', 'age': 25}]
# 使用 lambda 表达式按年龄排序
sorted_data = sorted(data, key=lambda x: x['age'])
print(sorted_data)
# 输出: [{'name': 'Zoe', 'age': 25}, {'name': 'Diana', 'age': 32}, {'name': 'John', 'age': 45}]
```

### 注意事项
- `sorted()` 函数不会修改原始的可迭代对象，它总是返回一个新的列表。
- 如果你需要对原始列表进行排序，可以使用列表的 `sort()` 方法，这个方法会就地修改列表。
- `sorted()` 函数对于任何可迭代对象都是有效的，不仅仅是列表。

`sorted()` 函数是Python中非常有用的工具，它提供了灵活的排序方式，可以轻松实现复杂的排序逻辑。