Python中的函数式编程

函数式编程是一种编程范式，我们在其中尝试以纯数学函数风格绑定所有内容。它是一种声明式的编程风格。它的主要焦点是“要解决什么”，而命令式风格的主要焦点是“如何解决”。它使用表达式而不是语句。计算表达式以产生值，而执行语句以分配变量。

函数式编程的概念

任何函数式编程语言都应该遵循这些概念。

• 纯函数：这些函数有两个主要属性。首先，它们总是为相同的参数产生相同的输出，而不管其他任何事情。其次，它们没有副作用，即它们确实修改了任何参数或全局变量或输出了一些东西。
• 递归：函数式语言中没有“for”或“while”循环。函数式语言中的迭代是通过递归实现的。
• 函数是一等的并且可以是高阶的：一等函数被视为一等变量。第一类变量可以作为参数传递给函数，可以从函数返回或存储在数据结构中。
• 变量是不可变的：在函数式编程中，我们不能在变量初始化后对其进行修改。我们可以创建新变量——但我们不能修改现有变量。

Python中的函数式编程

Python也支持函数式编程范式，而无需任何特殊功能或库的支持。

纯函数

如上所述，纯函数有两个属性。

• 它总是为相同的参数产生相同的输出。例如，无论如何，3+7 永远是 10。
• 它不会更改或修改输入变量。

第二个属性也称为不变性。纯函数的唯一结果是它返回的值。它们是确定性的。使用函数式编程完成的程序很容易调试，因为纯函数没有副作用或隐藏的 I/O。纯函数还可以更轻松地编写并行/并发应用程序。当代码以这种风格编写时，智能编译器可以做很多事情——它可以并行化指令，在需要时等待评估结果，并记住结果，因为只要输入不改变，结果就永远不会改变。

例子：

# Python program to demonstrate
# pure functions
  
  
# A pure function that does Not
# changes the input list and 
# returns the new List
def pure_func(List):
      
    New_List = []
      
    for i in List:
        New_List.append(i**2)
          
    return New_List
      
# Driver's code
Original_List = [1, 2, 3, 4]
Modified_List = pure_func(Original_List)
  
print("Original List:", Original_List)
print("Modified List:", Modified_List)

输出：

Original List: [1, 2, 3, 4]
Modified List: [1, 4, 9, 16]

递归

在函数式编程期间，没有for循环或while循环的概念，而是使用递归。递归是一个函数直接或间接调用自身的过程。在递归程序中，提供了基本情况的解决方案，而较大问题的解决方案则用较小的问题来表示。可能会出现一个问题，什么是基本情况？基本情况可以被认为是告诉编译器或解释器退出函数的条件。

注意：有关详细信息，请参阅递归

示例：让我们考虑一个程序，该程序将在不使用任何 for 循环的情况下找到列表中所有元素的总和。

# Python program to demonstrate
# recursion
  
  
# Recursive Function to find
# sum of a list
def Sum(L, i, n, count):
      
    # Base case
    if n <= i:
        return count
      
    count += L[i]
      
    # Going into the recursion
    count = Sum(L, i + 1, n, count)
      
    return count
      
# Driver's code
L = [1, 2, 3, 4, 5]
count = 0
n = len(L)
print(Sum(L, 0, n, count))

输出：

15

函数是一流的，可以是高阶的

一流的对象自始至终统一处理。它们可以存储在数据结构中，作为参数传递，或者在控制结构中使用。如果一种编程语言将函数视为一等对象，则称其支持一等函数。

一等函数的性质：

• 函数是 Object 类型的实例。
• 您可以将函数存储在变量中。
• 您可以将函数作为参数传递给另一个函数。
• 您可以从函数。
• 您可以将它们存储在数据结构中，例如哈希表、列表……

# Python program to demonstrate
# higher order functions
  
  
def shout(text): 
    return text.upper() 
    
def whisper(text): 
    return text.lower() 
    
def greet(func): 
    # storing the function in a variable 
    greeting = func("Hi, I am created by a function passed as an argument.") 
    print(greeting)  
    
greet(shout) 
greet(whisper) 

输出：

HI, I AM CREATED BY A FUNCTION PASSED AS AN ARGUMENT.
hi, I am created by a function passed as an argument.

注意：有关更多信息，请参阅Python中的 First Class 函数。

内置高阶函数

为了使列表和迭代器等可迭代对象的处理更加容易， Python实现了一些常用的高阶函数。这些函数返回一个节省空间的迭代器。一些内置的高阶函数是：

• Map()： map()函数在将给定函数应用于给定迭代（列表、元组等）的每个项目后返回结果列表
  

  Syntax: map(fun, iter)

  Parameters:
  fun: It is a function to which map passes each element of given iterable.
  iter: It is a iterable which is to be mapped.

  Return Type: Returns an iterator of map class.

  例子：

  # Python program to demonstrate working 
  # of map. 
      
  # Return double of n 
  def addition(n): 
      return n + n 
      
  # We double all numbers using map() 
  numbers = (1, 2, 3, 4) 
  results = map(addition, numbers) 
    
  # Does not Print the value
  print(results)
    
  # For Printing value
  for result in results:
      print(result, end = " ")
  

  输出：

  注意：更多信息请参考Python map()函数

• filter()： filter() 方法在一个函数的帮助下过滤给定的序列，该函数测试序列中的每个元素是否为真。
  

  Syntax: filter(function, sequence)

  Parameters:
  function: a function that tests if each element of a sequence true or not.
  sequence: sequence which needs to be filtered, it can be sets, lists, tuples, or containers of any iterators.

  Return Type: returns an iterator that is already filtered.

  例子：

  # Python program to demonstrate working 
  # of the filter. 
      
  # function that filters vowels 
  def fun(variable): 
        
      letters = ['a', 'e', 'i', 'o', 'u'] 
        
      if (variable in letters): 
          return True
      else: 
          return False
      
      
  # sequence 
  sequence = ['g', 'e', 'e', 'j', 'k', 's', 'p', 'r'] 
      
  # using filter function 
  filtered = filter(fun, sequence) 
      
  print('The filtered letters are:') 
    
  for s in filtered: 
      print(s) 
  

  输出：

  The filtered letters are:
  e
  e
  

  注意：更多信息请参考Python中的 filter()

• Lambda 函数：在Python中，匿名函数意味着函数没有名称。我们已经知道 def 关键字用于定义普通函数，而 lambda 关键字用于创建匿名函数。

  句法：

  lambda arguments: expression
  

  1) 这个函数可以有任意数量的参数，但只有一个表达式，它被计算并返回。
  2) 任何需要函数对象的地方都可以免费使用 lambda 函数。
  3) 您需要了解 lambda 函数在语法上仅限于单个表达式。
  4) 除了函数中的其他类型的表达式外，它在特定的编程领域有多种用途。

  例子：

  # Python code to demonstrate
  # lambda
    
      
  cube = lambda x: x * x*x 
  print(cube(7)) 
      
      
  L = [1, 3, 2, 4, 5, 6]
  is_even = [x for x in L if x % 2 == 0]
    
  print(is_even)  
  

  输出：

  343
  [2, 4, 6]
  

  注意：有关详细信息，请参阅Python lambda。

不变性

不变性是一种可用于调试的函数式编程范例，因为它会在变量被更改而不是值被更改的地方引发错误。 Python也支持一些不可变的数据类型，如字符串、元组、数字等。

例子：

# Python program to demonstrate 
# immutable data types
    
  
# String data types
immutable = "GeeksforGeeks"
  
# changing the values will
# raise an error
immutable[1] = 'K'

输出：

Traceback (most recent call last):
  File "/home/ee8bf8d8f560b97c7ec0ef080a077879.py", line 10, in 
    immutable[1] = 'K'
TypeError: 'str' object does not support item assignment

函数式编程和面向对象编程的区别

当您对事物有一组固定的操作时，面向对象的语言是很好的，并且随着代码的发展，您主要是添加新事物。这可以通过添加实现现有方法的新类来完成，而现有类则不作任何处理。

当你有一组固定的东西时，函数式语言是很好的，并且随着你的代码的发展，你主要是在现有的东西上添加新的操作。这可以通过添加使用现有数据类型进行计算的新函数来完成，而现有函数将被单独保留。

FUNCTIONAL PROGRAMMING	OBJECT ORIENTED PROGRAMMING
This programming paradigm emphasizes on the use of functions where each function performs a specific task.	This programming paradigm is based on object oriented concept.Classes are used where instance of objects are created
Fundamental elements used are variables and functions.The data in the functions are immutable(cannot be changed after creation).	Fundamental elements used are objects and methods and the data used here are mutable data.
It follows declarative programming model.	It follows imperative programming model.
It uses recursion for iteration.	It uses loops for iteration.
It is parallel programming supported.	It does not support parallel programming.
The statements in this programming paradigm does not need to follow a particular order while execution.	The statements in this programming paradigm need to follow a order i.e., bottom up approach while execution.