Programación funcional en Python

La programación funcional es un paradigma de programación en el que tratamos de vincular todo en el estilo de funciones matemáticas puras. Es un tipo declarativo de estilo de programación. Su enfoque principal está en “ qué resolver ” en contraste con un estilo imperativo donde el enfoque principal es “ cómo resolver ”. Utiliza expresiones en lugar de declaraciones. Una expresión se evalúa para producir un valor, mientras que una instrucción se ejecuta para asignar variables.

Conceptos de Programación Funcional

Se espera que cualquier lenguaje de programación funcional siga estos conceptos.

• Funciones puras: estas funciones tienen dos propiedades principales. Primero, siempre producen la misma salida para los mismos argumentos independientemente de cualquier otra cosa. En segundo lugar, no tienen efectos secundarios, es decir, modifican cualquier argumento o variable global o generan algo.
• Recursividad: no hay bucles «for» o «while» en los lenguajes funcionales. La iteración en lenguajes funcionales se implementa mediante recursividad.
• Las funciones son de primera clase y pueden ser de orden superior: las funciones de primera clase se tratan como variables de primera clase. Las variables de primera clase se pueden pasar a funciones como un parámetro, se pueden devolver desde funciones o se pueden almacenar en estructuras de datos.
• Las variables son inmutables: en la programación funcional, no podemos modificar una variable después de haberla inicializado. Podemos crear nuevas variables, pero no podemos modificar las existentes.

Programación funcional en Python

Python también es compatible con los paradigmas de programación funcional sin el soporte de ninguna función o biblioteca especial.

Funciones puras

Como se discutió anteriormente, las funciones puras tienen dos propiedades.

• Siempre produce la misma salida para los mismos argumentos. Por ejemplo, 3+7 siempre será 10 pase lo que pase.
• No cambia ni modifica la variable de entrada.

La segunda propiedad también se conoce como inmutabilidad. El único resultado de la función pura es el valor que devuelve. Son deterministas. Los programas realizados mediante programación funcional son fáciles de depurar porque las funciones puras no tienen efectos secundarios ni E/S ocultas. Las funciones puras también facilitan la escritura de aplicaciones paralelas/concurrentes. Cuando el código está escrito en este estilo, un compilador inteligente puede hacer muchas cosas: puede paralelizar las instrucciones, esperar para evaluar los resultados cuando los necesite y memorizar los resultados, ya que los resultados nunca cambian mientras la entrada no cambie.

Ejemplo:

# 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)

Producción:

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

recursividad

Durante la programación funcional, no existe el concepto de forbucle o whilebucle, en su lugar se utiliza la recursividad. La recursión es un proceso en el que una función se llama a sí misma directa o indirectamente. En el programa recursivo, se proporciona la solución al caso base y la solución al problema más grande se expresa en términos de problemas más pequeños. Puede surgir una pregunta ¿qué es el caso base? El caso base se puede considerar como una condición que le dice al compilador o al intérprete que salga de la función.

Nota: Para obtener más información, consulte Recursividad

Ejemplo: Consideremos un programa que encontrará la suma de todos los elementos de una lista sin usar ningún bucle 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))

Producción:

15

Las funciones son de primera clase y pueden ser de orden superior

Los objetos de primera clase se manejan de manera uniforme en todo momento. Pueden almacenarse en estructuras de datos, pasarse como argumentos o usarse en estructuras de control. Se dice que un lenguaje de programación admite funciones de primera clase si trata las funciones como objetos de primera clase.

Propiedades de las funciones de primera clase:

• Una función es una instancia del tipo de objeto.
• Puede almacenar la función en una variable.
• Puede pasar la función como un parámetro a otra función.
• Puede devolver la función desde una función.
• Puedes almacenarlos en estructuras de datos como tablas hash, listas,…

# 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) 

Producción:

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

Nota: Para obtener más información, consulte Funciones de primera clase en Python .

Funciones integradas de orden superior

Para hacer que el procesamiento de objetos iterables como listas e iteradores sea mucho más fácil, Python ha implementado algunas funciones de orden superior de uso común. Estas funciones devuelven un iterador que ocupa poco espacio. Algunas de las funciones integradas de orden superior son:

• Map(): la función map() devuelve una lista de los resultados después de aplicar la función dada a cada elemento de un iterable dado (lista, tupla, etc.)
  

  Sintaxis: map(fun, iter)

  Parámetros:
  fun: Es una función a la que map pasa cada elemento del iterable dado.
  iter: Es un iterable que se va a mapear.

  Tipo de devolución: devuelve un iterador de clase de mapa.

  Ejemplo:

  # 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 = " ")

  Producción:

  <map object at 0x7fae3004b630>
  2 4 6 8 
  

  Nota: Para obtener más información, consulte la función Python map()

• filter(): El método filter() filtra la secuencia dada con la ayuda de una función que comprueba si cada elemento de la secuencia es verdadero o no.
  

  Sintaxis: filter(función, secuencia)

  Parámetros:
  función: una función que prueba si cada elemento de una secuencia es verdadero o no.
  secuencia: secuencia que necesita ser filtrada, pueden ser conjuntos, listas, tuplas o contenedores de cualquier iterador.

  Tipo de devolución: devuelve un iterador que ya está filtrado.

  Ejemplo:

  # 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)

  Producción:

  The filtered letters are:
  e
  e
  

  Nota: Para obtener más información, consulte filter() en Python

• Funciones lambda: en Python, función anónima significa que una función no tiene nombre. Como ya sabemos, la palabra clave def se usa para definir las funciones normales y la palabra clave lambda se usa para crear funciones anónimas.

  Sintaxis:

  lambda arguments: expression
  

  1) Esta función puede tener cualquier número de argumentos pero solo una expresión, que se evalúa y devuelve.
  2) Uno es libre de usar funciones lambda dondequiera que se requieran objetos de función.
  3) Debe tener en cuenta que las funciones lambda están restringidas sintácticamente a una sola expresión.
  4) Tiene varios usos en campos particulares de la programación además de otros tipos de expresiones en funciones.

  Ejemplo:

  # 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)

  Producción:

  343
  [2, 4, 6]
  

  Nota: Para obtener más información, consulte Python lambda .

Inmutabilidad

La inmutabilidad es un paradigma de programación funcional que se puede usar para la depuración, ya que arrojará un error donde se cambia la variable, no donde se cambia el valor. Python también admite algunos tipos de datos inmutables como strings, tuplas, numéricos, etc.

Ejemplo:

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

Producción:

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

Diferencia entre Programación Funcional y Programación Orientada a Objetos

Los lenguajes orientados a objetos son buenos cuando tiene un conjunto fijo de operaciones en las cosas y, a medida que su código evoluciona, agrega principalmente cosas nuevas. Esto se puede lograr agregando nuevas clases que implementen métodos existentes, y las clases existentes se dejan solas.

Los lenguajes funcionales son buenos cuando tiene un conjunto fijo de cosas y, a medida que su código evoluciona, agrega principalmente nuevas operaciones en las cosas existentes. Esto se puede lograr agregando nuevas funciones que calculan con los tipos de datos existentes, y las funciones existentes se dejan solas.