Funciones en Python

Para definir funciones en Python disponemos de la instrucción def

Después de esta palabra reservada va el nombre de la función junto con una lista de argumentos delimitados por paréntesis y separados por comas, finalizando con el símbolo :

def nombre( param1, param2,..., paramn ):
    ["""DOCSTRING_DE_FUNCION"""]
    instrucciones en Python
    [return expresión]

La definición de una función no ejecuta el cuerpo de la función

Solamente será ejecutada cuando la función sea llamada

Su ejecución enlaza el nombre de la función con el namespace local actual a un objecto función (un envoltorio alrededor del código ejecutable para la función)

Este objeto función contiene una referencia al namespace local global como el namespace global para ser usado cuando la función sea llamada

De forma opcional puede añadirse una expresión que será devuelta por la función

La expresión puede será un tipo válido de Python precedida por la sentencia return

El DOCSTRING es un texto descriptivo de la función encerrado entre tres comillas dobles de apertura y cierre, antes de la primera instrucción

Es opcional, así que si no queremos añadir una descripción, podemos omitirlo

Pero se recomienda su uso para que cuando revisemos después de un tiempo nuestro código, recordemos qué hacía nuestra función

Argumentos

El paso de argumentos es opcional y en algunos casos puede haber funciones que carezcan de ellos

Tipo de los argumentos

Admite los tipos str, int, float, complex,bool, list, tuple, dic y class

Argumentos con valor por posición

Cuando enviamos argumentos a una función, estos se reciben por orden en los parámetros definidos

def resta(a, b):
     return a - b

resta(30, 10) #mostrará 20, sin necesidad de usar la función print

Argumentos con valor por nombre

Es posible evadir el orden de los parámetros si indicamos durante la llamada el valor que tiene cada parámetro a partir de su nombre

def resta(a, b):
     return a - b

resta(b=30, a=10) #mostrará -20, sin necesidad de usar la función print

Sin Argumentos

Al momento de llamar una función la cual tiene definidos unos parámetros, si no pasa los argumentos correctamente provocará una excepción TypeError

def resta(a, b):
     return a - b

resta() #lanza una excepción TypeError

Argumentos con valor por defecto

En ocasiones necesitamos que un argumento tenga un valor, para evitar un error (que provocaría el lanzamiento de la excepción TypeError), aunque el usuario de la función no lo introduzca

Hay que tener en cuenta, que los argumentos con valor por defecto pasan a ser opcionales y que todos los argumentos a la izquierda del primer valor por defecto, son obligatorios

def resta(a=None, b=None):
     if a == None or b == None:
         print("Error, debes enviar dos números a la función")
         return
     return a - b

resta(30) #Sólo hemos pasado un argumento, muestra: 'Error, debes enviar dos números a la función'
resta() #No hemos pasado argumentos, muestra: 'Error, debes enviar dos números a la función'

En el ejemplo se ha utilizado el valor nulo (None) para expresar que no se habían pasado argumentos

Pero podríamos utilizar cualquier tipo que precisemos como valor por defecto

Argumentos indeterminados

En algunas ocasiones no sabremos previamente cuantos elementos necesitamos enviar a una función

Para estos casos podemos utilizar los parámetros indeterminados por posición o por nombre

Argumentos por posición

Como argumento usaremos un tipo tuple precediendolo con el símbolo *

De esta forma todos los argumentos serán recibidos por posición, pudiendo recorrerlos cómodamente con un bucle for

def ind_pos(*args):
     for arg in args:
         print( type(arg) )
         print(arg)

ind_pos(5, "Hola", [1,2,3,4,5] )

#devuelve
#<class 'int'>
#5
#<class 'str'>
#Hola
#<class 'list'>
#[1, 2, 3, 4, 5]

Argumentos por nombre

Como argumento usaremos un tipo dict precediendolo con los símbolos **

De esta forma todos los argumentos serán recibidos por el nombre de la clave del diccionario, pudiendo recorrerlos cómodamente con un bucle for

def ind_nom(**kwargs):
    print(kwargs)
    for kwarg in kwargs:
        print(kwarg, "=>", kwargs[kwarg])

ind_nom(n=5, c="Hola", l=[1,2,3,4,5])

#devuelve
#{'n': 5, 'c': 'Hola', 'l': [1, 2, 3, 4, 5]}
#n => 5
#c => Hola
#l => [1, 2, 3, 4, 5]

Argumentos por posición y nombre

En alguna ocasión puede necesitar utilizar ambos tipos de parámetros simultáneamente en una función, entonces debe crear ambas colecciones dinámicas

Primero los argumentos indeterminados por valor y luego por nombre

def pos_nom(*args,**kwargs):
     total = 0
     for arg in args:
         total += arg
     print("sumatorio => ", total)
     for kwarg in kwargs:
         print(kwarg, "=>", kwargs[kwarg])

pos_nom(50, -1, 1.56, 10, 20, 300, nombre="Raúl", edad=38)

#devuelve
#sumatorio =>  380.56
#nombre => Raúl
#edad => 38

En todos los ejemplos se han utilizado los nombres args y kwargs pero no son obligatorios

Muchos frameworks y librerías los utilizan por lo que es una buena practica llamarlos así, por convención

La sentencia pass

Es una operación nula, cuando la ejecutamos, parece que nada sucede

Es útil como un contenedor cuando una sentencia es requerida sintácticamente, pero no es necesario ejecutar código

#una función que no hace nada
def consultar(letra): 
    pass

type(consultar)

La sentencia return

La sentencia return es la que permite devolver el resultado de una función

Admite los tipos str, int, float, complex,bool, list, tuple, dic y class

def suma(numero1, numero2):
    '''Suma dos números'''
    print(numero1 + numero2)
    print("\n")

La setencia return es opcional, pero si se omite, por defecto devolverá el valor nulo (None)

Retorno múltiple

Una característica interesante de las funciones en Python, es la posibilidad de devolver valores múltiples separados por comas

def prueba():
     return "Raúl", 20, [1,2,3]
cadena, numero, lista = prueba()
print (cadena, type(cadena) ) #devuelve Raúl <class 'str'>
print (numero, type(numero) ) #devuelve 20 <class 'int'>
print (lista, type(lista) ) #devuelve [1, 2, 3] <class 'list'>

Funciones predefinidas por el lenguaje

Las funciones predefinidas por el lenguaje están ordenadas por módulos

Un módulo es un conjunto de clases y funciones almacenadas en un archivo que pueden ser utilizadas posteriormente

Podemos crear nuestros propios módulos e importarlos a los nuevos programas que hagamos

Sin embargo, es aconsejable reutilizar los módulos ya existentes

Para importar un módulo utilizaremos la sentencia import

De esta forma estaremos manejando un namespace, de forma similar a como lo hace C++ (using namespaces) o Java

Que tiene la siguiente sintaxis

import nombre_modulo [as alias]

Para llamar a una función concreta del módulo utilizaremos nombre.funcion() o alias.funcion en caso de que le hayamos dado un alias al módulo

En caso de no querer utilizar todas la funciones del módulo pero si una concreta, utilizaremos la sentencia from

Que tiene la siguiente sintaxis

from nombre_modulo import nombre_funcion

Módulo sys

Este módulo es el encargado de proveer variables y funcionalidades relacionadas con el intérprete

Las variables del módulo sys son:

• sys.executable

  Retorna el directorio absoluto del archivo binario ejecutable del intérprete de Python

• sys.platform

  Retorna la plataforma sobre la cual se está ejecutando el intérprete

• sys.version

  Retorna el número de versión de Python con información adicional

Los métodos más destacados del módulo sys son los siguientes:

• sys.exit()

  Forzar la salida del intérprete

• sys.getdefaultencoding()

  Retorna la codificación de caracteres por defecto

• sys.getfilesystemencoding()

  Retorna la codificación de caracteres que se utiliza para convertir los nombres de archivos unicode en nombres de archivos del sistema

• sys.getsizeof()

  Retorna el tamaño del objeto pasado como parámetro

import sys

cad = 'El perro de San Roque no tiene rabo'

print( sys.executable ) #devuelve c:\python.exe, ya que estoy usando el sistema de archivos de Windows
print( sys.platform ) #devuelve win32, ya que estoy usando un sistema Windows de 32 bits
print( sys.version ) #devuelve 3.7.3 (v3.7.3:ef4ec6ed12, Mar 25 2019, 21:26:53) [MSC v.1916 32 bit (Intel)]
print( sys.getdefaultencoding() ) #devuelve utf-8
print( sys.getfilesystemencoding() ) #devuelve utf-8
print( sys.getsizeof(cad) ) #devuelve 60

Módulo os

Este módulo nos permite acceder a funcionalidades dependientes del SO

Sobre todo, aquellas que nos dan información sobre el entorno del mismo y nos permiten manipular la estructura de directorios

Algunos de los métodos más utilizados son:

• os.getcwd()

  Nos informa de cuál es el directorio actual

• os.chdir(ruta)

  Cambia el directorio de trabajo a la ruta pasada como argumento

• os.chroot()

  Cambia al directorio raiz

• os.mkdir(directorio)

  Crea el directorio pasado como argumento

• os.rmdir(directorio)

  Elimina el directorio pasado como argumento

• os.remove(fichero)

  Eliminar el archivo pasado como argumento

• os.rename(actual, nuevo)

  Renombra el archivo actual por el nombre del archivo nuevo, pasados como argumentos

Módulo math

Este módulo nos provee de funciones y constantes matemáticas

Podemos encontrar todas las funciones y atributos en su documentación

Algunas de los variables más utilizadas son:

• math.pi

  Representa el valor de la variable \pi (número Pi)

• math.e

  Representa el valor de la variable e (número de Euler o constante de Napier)

• math.tau

  Representa el valor de la variable \tau = 2\cdot\pi (constante Tau, propuesta por Bob Palais, Peter Harremoes, Hermann Laurent, Fred Hoyle, Michael Hartl, Nicolás Atanes, entre otros)

Algunos de los métodos más utilizados son:

• math.ceil(x)

  Devuelve el entero menor que sea mayor o igual que x

• math.floor(x)

  Devuelve el entero mayor menor o igual a x

• math.exp(x)

  Devuelve el número e elevado a la potencia x

• math.log2(x)

  Devuelve el logaritmo en base 2 de x

• math.sin(x)

  Devuelve el seno de x radianes

• math.cos(x)

  Devuelve el coseno de x radianes

• math.tan(x)

  Devuelve la tangente de x radianes

• math.degrees(x)

  Convierte el ángulo x de radianes a grados

import math

a = 4.5786
b = 2.873

print( math.ceil(a) ) #devuelve 5
print( math.floor(a) ) #devuelve 4
print( math.exp(a) ) #devuelve 97.37796957468944
print( math.log2(a) ) #devuelve 2.194906532422851
print( math.sin(a) ) #devuelve -0.9910635960591139
print( math.cos(a) ) #devuelve -0.133390211658793
print( math.tan(a) ) #devuelve 7.429807507871837
print( math.degrees(a) ) #devuelve 262.3344560785987
print( math.pi ) #devuelve 3.141592653589793
print( math.e ) #devuelve 2.718281828459045
print( math.tau ) #devuelve 6.283185307179586

Módulo random

El módulo random se utiliza para todo lo relacionado con números aleatorios

Algunos de los métodos más utilizados son:

• shuffle(col)

  Reordena aleatoriamente los elementos de una colección

• sample(col, k)

  Toma n elementos sin reemplazo de una coleccion

• random()

  Genera un número aleatorio en el intervalo [0, 1)

• uniform(a, b)

  Genera un número aleatorio en el intervalo [a, b]

• randint(a, b)

  Genera un número aleatorio entero en el intervalo [a, b]

• gauss(media, sigma)

  Genera un número aleatorio siguiendo una distribución gaussiana con media y sigma dadas

import random

list = [1, 2, 3]

print( random.shuffle(list) ) #devuelve None
print( random.sample(list, 2) ) #devuelve [1, 2]
print( random.random() ) #devuelve 0.06298135634914415
print( random.uniform(0, 10) ) #devuelve 3.304708273440835
print( random.randint(0, 10) ) #devuelve 6
print( random.gauss(50, 1.28) ) #devuelve 50.28864476388755

Módulo NumPy

Numpy nos proporciona una gran cantidad de funciones matemáticas y el tipo de variable NumPy array

Por lo general el paquete NumPy suele importarse con el alias np

Este módulo nos permite trabajar con estructuras matemáticas de una forma muy cómoda (producto de matrices, números aleatorios, operaciones sobre matrices…)

Es un módulo que no viene instalado por defecto

Para ello abre un terminal y ejecuta:

python -m pip install numpy

Podemos encontrar todas las funciones y atributos en su documentación

Algunos de los métodos más utilizados son:

• random.rand()

  Nos devuelve valores aleatorios con la forma deseada

• empty()

  Crea un array vacío con la forma indicada

• zeros()

  Crea un array de ceros con la forma indicada

• dot()

  Calcula el producto matricial entre dos arrays

• sum()

  Calcula la suma de los elementos de un array

import numpy as np

np.random.seed(3)
A = np.random.rand(3,3) * 2
B = np.random.rand(3,3) * 2
A = np.round(A, 2)
B = np.round(B, 2)

print("A = ", A)
#devuelve
#A =  [[1.1  1.42 0.58]
# [1.02 1.79 1.79]
# [0.25 0.41 0.1 ]]

print("B = ", B)
#devuelve
#B =  [[0.88 0.06 0.91]
# [1.3  0.56 1.35]
# [1.18 0.05 1.12]]

print("A * B = ", np.round(np.dot(A, B), 2) )
#devuelve
#A * B =  [[3.5  0.89 3.57]
# [5.34 1.15 5.35]
# [0.87 0.25 0.89]]

print("Suma de A: ", np.sum(A) )
#devuelve
#Suma de A:  8.459999999999999

print("Suma de A: ", np.sum(A, axis = 0) )
#devuelve
#Suma de A:  [2.37 3.62 2.47]

C = A[A>1]
print(C) #devuelve [1.1  1.42 1.02 1.79 1.79]

Módulo Pandas

El paquete pandas es muy utilizado en el Data Scientists

Es uno de los paquetes sobre el que deberíamos centrarnos para aprender sobre análisis de datos

A través de pandas podemos familiarizarnos con nuestro set de datos limpiándolo, transformándolo y analizándolo

Por ejemplo, con pandas podemos leer un fichero CSV de nuestro ordenador, pasarlo a un DataFrame (una tabla, en esencia) y hacer cosas como:

• Calcular estadísticas y responder preguntas sobre los datos como sacar el máximo, minimo y media de cada columna, saber cómo de correlacionadas están las columnas A y B o conocer la distribución estadística de la columna C
• Limpiar los datos haciendo cosas como eliminar los valores faltantes o filtrando filas y columnas de acuerdo a algún criterio
• Visualizar los datos con la ayuda de matplotlib
• Guardar los datos ya limpiados de vuelta en un CSV o una base de datos

Pandas se basa en NumPy, por lo que debemos tener ese módulo instalado previamente

Jupyter Notebooks es una aplicación que se complementa muy bien con Pandas, ya que podemos ejecutar el código por celdas en vez que de forma completa, lo cual es útil si trabajamos con grandes datasets

Los componentes primarios de Pandas son series y DataFrame, siendo el primer tipo una columna y el segundo una table

Por lo general el paquete pandas suele importarse con el alias np

Es un módulo que no viene instalado por defecto

Para ello abre un terminal y ejecuta:

python -m pip install pandas

Podemos encontrar todas las funciones y atributos en su documentación

Ahora vamos a crear un ejemplo sencillo para mostrar el uso de pandas usando una serie que contendrá a los integrantes de la selección Española de fútbol que ganó el mundial del año 2010

Para crear la serie utilizamos el método pd.Series que recibirá una lista con los nombres de los jugadores y una lista con el número de dorsal de los jugadores

Después lo mostraremos por pantalla

import pandas as pd

jugadoresEspañoles = pd.Series(
    ['Casillas', 'Ramos', 'Pique', 'Puyol', 'Capdevila', 'Xabi Alonso', 'Busquets', 'Xavi Hernandez', 'Pedrito',
     'Iniesta', 'Villa'], index=[1, 15, 3, 5, 11, 14, 16, 8, 18, 6, 7] )
print("Futbolistas españoles: \n%s" %(jugadoresEspañoles) )

#devuelve
#Futbolistas españoles: 
#1           Casillas
#15             Ramos
#3              Pique
#5              Puyol
#11         Capdevila
#14       Xabi Alonso
#16          Busquets
#8     Xavi Hernandez
#18           Pedrito
#6            Iniesta
#7              Villa
#dtype: object

Ahora no le vamos a indicar los índices de forma explícita, entonces generará los índices de forma automática empezando desde el valor cero

import pandas as pd

jugadoresEspañoles= pd.Series(
    ['Casillas', 'Ramos', 'Pique', 'Puyol', 'Capdevila', 'Xabi Alonso', 'Busquets', 'Xavi Hernandez', 'Pedrito',
     'Iniesta', 'Villa'] )
print("Futbolistas españoles: \n%s" %(jugadoresEspañoles) )

#devuelve
#Futbolistas españoles: 
#0           Casillas
#1             Ramos
#2              Pique
#3              Puyol
#4         Capdevila
#5       Xabi Alonso
#6          Busquets
#7     Xavi Hernandez
#8           Pedrito
#9            Iniesta
#10              Villa
#dtype: object

Ahora vamos a introducir en la serie un diccionario en vez de una lista y le vamos a añadir un jugador más

import pandas as pd

jugadoresEspañoles = pd.Series( {1: 'Casillas', 15: 'Ramos', 3: 'Pique', 5: 'Puyol', 11: 'Capdevila', 14: 'Xabi Alonso', 16: 'Busquets', 8: 'Xavi Hernandez', 18: 'Pedrito', 6: 'Iniesta', 7: 'Villa'} )
jugadoresEspañoles[10] = 'Cesc' #añadimos un jugador
print("Futbolistas españoles: \n%s" %(jugadoresEspañoles) )

#devuelve
#Futbolistas españoles: 
#1           Casillas
#15             Ramos
#3              Pique
#5              Puyol
#11         Capdevila
#14       Xabi Alonso
#16          Busquets
#8     Xavi Hernandez
#18           Pedrito
#6            Iniesta
#7              Villa
#10              Cesc
#dtype: object

Ahora vamos a crear un ejemplo sencillo para mostrar el uso de pandas usando un DataFrame que contendrá a los integrantes de la selección Española de fútbol que ganó el mundial del año 2010

Para crear el DataFrame utilizamos el método pd.DataFrame que recibirá un diccionario con los datos de los jugadores, una lista con el nombre de la columna y una lista con el número de dorsal de los jugadores

Añadiremos un jugador más utilizando el método loc del objeto DataFrame

Después lo mostraremos por pantalla

import pandas as pd

jugadoresEspañoles= pd.DataFrame(
    {
        'name': ['Casillas', 'Ramos', 'Pique', 'Puyol', 'Capdevila', 'Xabi Alonso', 'Busquets', 'Xavi Hernandez',
                 'Pedrito', 'Iniesta', 'Villa'],
        'demarcation': ['Portero', 'Defensa lateral derecho', 'Defensa', 'Defensa', 'Defensa lateral izquierdo', 'Centrocampista defensivo', 'Centrocampista defensivo', 'Centrocampista', 'Extremo izquierdo', 'Extremo derecho', 'Delantero centro'],
        'team': ['Real Madrid', 'Real Madrid', 'FC Barcelona', 'FC Barcelona', 'Villareal', 'Real Madrid',
                 'FC Barcelona', 'FC Barcelona', 'FC Barcelona', 'FC Barcelona', 'FC Barcelona']
    }, columns=['nombre', 'demarcación', 'equipo'], index=[1, 15, 3, 5, 11, 14, 16, 8, 18, 6, 7]
)
jugadoresEspañoles.loc[10] = ['Cesc', 'Delantero', 'Arsenal'] #añadimos un jugador
print("Futbolistas españoles: \n%s" %(jugadoresEspañoles) )

#devuelve
#Futbolistas españoles: 
#            nombre                demarcación          equipo
#1         Casillas                    Portero     Real Madrid
#15           Ramos    Defensa lateral derecho     Real Madrid
#3            Pique                    Defensa    FC Barcelona
#5            Puyol                    Defensa    FC Barcelona
#11       Capdevila  Defensa lateral izquierdo       Villareal
#14     Xabi Alonso   Centrocampista defensivo     Real Madrid
#16        Busquets   Centrocampista defensivo    FC Barcelona
#8   Xavi Hernandez             Centrocampista    FC Barcelona
#18         Pedrito          Extremo izquierdo    FC Barcelona
#6          Iniesta            Extremo derecho    FC Barcelona
#7            Villa           Delantero centro    FC Barcelona
#10            Cesc                  Delantero         Arsenal

Funciones de visualización

print

La función print sirve para enviar la salida de sus argumentos al navegador con un formato

Operador %

El operador % también se puede utilizar para el formato de la cadena

Interpreta el argumento izquierdo de manera muy parecida a una cadena de formato de estilo de la función printf de C++, que se aplica al argumento derecho

En Python, no hay una función printf pero se le ha dotado de su funcionalidad a print

Para este propósito, el operador % está sobrecargado para cadenas para mostrar el formato de la cadena

A menudo se le llama operador de módulo de cadena (o, a veces, incluso, módulo)

Tiene el formato:

print( texto_formateado %(variable1 [, variable2, ..., variableN] )

Para formatear un texto deberemos introducir los siguientes caracteres de formato precedidos por el símbolo %:

Caracteres de formato para texto
Caracter	Descripción
c	El argumento es tratado como un valor de tipo string y recoge un único carácter
d	El argumento es tratado como un valor de tipo int y presentado como un número entero
e	El argumento es tratado con notación científica (por ejemplo 1.2e+2)
E	Como %e pero utiliza la letra mayúscula (por ejemplo 1.2E+2)
f	El argumento es tratado como un valor de tipo float y presentado como un número de punto flotante (considerando la configuración regional)
F	El argumento es tratado como un valor de tipo float y presentado como un número de punto flotante (sin considerar la configuración regional)
g	Igual que %e y %f
G	Igual que %E y %f
o	El argumento es tratado como un valor de tipo integer y presentado como un número octal
s	El argumento es tratado como un valor de tipo string y recoge una cadena de caracteres
u	El argumento es tratado como un valor de tipo int y presentado como un número decimal sin signo
x	El argumento es tratado como un valor de tipo integer y presentado como un número hexadecimal
X	El argumento es tratado como un valor de tipo integer y presentado como un número hexadecimal en mayúsculas

n =  int (43951789) #cast para que el valor de n sea entero
u = int(-43951789) #cast para que el valor de u sea entero
c = str("A") #cast para que el valor de c sea una cadena

print("%c" %(c) ) # c para valor ASCII del número, muestra 'A'
print("%d" %(n) ) # d para número entero, muestra '43951789'
print("%+d" %(n) ) # +d para número entero positivo con signo, muestra '+43951789'
print("%+d" %(u) ) # +d para número entero negativo con signo, muestra '-43951789'
print("%e" %(n) ) # e para notación científica del número entero, muestra '4.39518e+7'
print("%E" %(n) ) # E para notación científica del número entero, muestra '4.39518E+7'
print("%f" %(n) ) # f para número decimal (considerando configuración regional), muestra '43951789.000000'
print("%F" %(n) ) # F para número decimal (sin considerar la configuración regional), muestra '43951789.000000'
print("%g" %(n) ) # g igual que e y f
print("%G" %(n) ) # G igual que E y f
print("%o" %(n) ) # o para número octal, muestra '247523255'
print("%s" %(n) ) # s como una cadena, muestra '43951789'
print("%u" %(n) ) # u para número entero positivo, muestra '43951789'
print("%u" %(u) ) # u para número entero negativo, muestra '-43951789'
print("%x" %(u) ) # x para número hexadecimal, muestra '-29ea6ad'
print("%X" %(n) ) # X para número hexadecimal en mayúsculas, muestra '29EA6AD'

Método format

El método format se añadió a los tipos string en Python 2.6

Permite el uso de los caracteres {} para marcar dónde se sustituirá una variable y utiliza directivas de formato detalladas usadas para formatear

Este método nos permite concatenar elementos dentro de una salida a través del formato posicional

Los corchetes y los caracteres dentro de ellos (llamados campos de formato) se reemplazan con los objetos pasados al método format

texto = "raíz cuadrada de dos"
valor = 2 ** 0.5

print("el resultado de {} es {}".format(texto, valor) ) #devuelve 'el resultado de raíz cuadrada de dos es 1.4142135623730951'

Se puede usar un número entre paréntesis para referirse a la posición del argumento pasado al método format

Hay que tener en cuenta que el primer argumento empieza en cero

texto = "raíz cuadrada de dos"
valor = 2 ** 0.5

print("el resultado de {0} es {1}".format(texto, valor) ) #devuelve 'el resultado de raíz cuadrada de dos es 1.4142135623730951'

También se puede usar un identificador clave cuando el argumento sea pasado por nombre

Esta opción nos será útil cuando trabajemos con diccionarios o cuando queramos reducir algo el código

dic = dict(texto="raíz cuadrada de dos",  valor=2**0.5)

print("el resultado de {texto} es {valor}".format(**dic) ) #devuelve 'el resultado de raíz cuadrada de dos es 1.4142135623730951'
print("el resultado de {texto} es {valor}".format(texto="raíz cuadrada de dos", valor=2**0.5) ) #devuelve 'el resultado de raíz cuadrada de dos es 1.4142135623730951'

Opcionalmente se puede poner el símbolo : después del número o nombre, y explicitar el tipo del objeto:

Caracteres de formato para texto
Caracter	Descripción
s	El argumento es tratado como un valor de tipo string y recoge una cadena de caracteres
d	El argumento es tratado como un valor de tipo int y presentado como un número decimal (con signo)
f	El argumento es tratado como un valor de tipo float y presentado como un número de punto flotante (considerando la configuración regional)

import math

texto = "raíz cuadrada de dos"
valor = 2 ** 0.5

print("el resultado de {} es {:4d}".format(texto, math.ceil(valor) ) ) #con 4 espacios de relleno devuelve 'el resultado de raíz cuadrada de dos es    2'
print("el resultado de {} es {:04d}".format(texto, math.ceil(valor) ) ) #con 4 espacios de relleno y poniendo 0 a su izquierda devuelve 'el resultado de raíz cuadrada de dos es 0002'
print("el resultado de {} es {:.4f}".format(texto, valor) ) #con 4 valores decimales devuelve 'el resultado de raíz cuadrada de dos es 1.4142'
print("el resultado de {} es {:7.3f}".format(texto, valor) ) #con 7 espacios y 3 valores decimales devuelve 'el resultado de raíz cuadrada de dos es   1.414'
print("el resultado de {} es {:07.3f}".format(texto, valor) ) #con 7 espacios, 3 valores decimales y poniendo 0 a su izquierda devuelve devuelve 'el resultado de raíz cuadrada de dos es 001.414'

Funciones de orden superior

En matemáticas y ciencias de la computación, las funciones de orden superior son funciones que cumplen al menos una de las siguientes condiciones:

• Tomar una o más funciones como entrada
• Devolver una función como salida

def funcion_doble(f): #la función va a realizar lo que en matemáticas se llama composición
    def resultado(x):
        return f( f(x) ) #la función se llama a si misma, es una función recursiva
    return resultado #devuelve el resultado final de la composición

def cuadrado(x):
    return x * x #calcula el cuadrado de x

g = funcion_doble(cuadrado) #La composición se ejecuta de la función más interior (cuadrado) a la más exterior (funcion_doble)
g(3) #devuelve 81

Funciones lambda

Las funciones lambda son funciones anónimas, es decir, funciones sin nombre

Sólo se utilizan en el lugar en el que se han creado (aunque se les puede asignar un nombre y usarlas más adelante)

Se utilizan por lo general junto a las funciones map, filter y reduce

Por lo general se utilizan para crear funciones que son pasadas como argumentos a otras funciones

En Python la sintaxis de una función lamdba es:

lambda variable1<, variable2, ..., variableN>: expresión

Donde la expresión puede ser cualquier operación que haríamos al realizar una asignación

multiplica = lambda x, y: x * y

print( multiplica(2, 3) ) #devuelve 6

Funcion map

Nos permite aplicar una función sobre cada uno de los elementos de un iterable

Nos devuelve un map object, que podemos transformar fácilmente en una lista

lista = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
resultado = map(lambda x: x * x, lista)

print( resultado ) #devuelve <map object at 0x04E889B0>
print( list(resultado) ) #devuelve [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Funcion filter

Nos permite filtrar los elementos de una colección (por ejemplo una lista)

Es una función muy utilizada en el tratamiento de colecciones

lista = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
resultado = map(lambda x:x*x, lista)
filtrado = filter(lambda x:x>30, resultado)

print( list(filtrado) ) #devuelve [36, 49, 64, 81, 100]

Función reduce

Toma una función y una colección reduciéndola a un solo valor

Sería equivalente a una función de agregación

Pertenece al módulo functools, por lo que deberá ser importado antes de poder usar reduce

from functools import reduce

La función que pasemos debe tomar al menos dos parámetros y uno opcional

El primero es el parámetro del agregado que se va acumulado en cada iteración sobre los elementos de la colección

El segundo el elemento corresponde al paso de la iteración

El tercero es en caso que se necesite un valor inicial

from functools import reduce

lista = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

print( reduce(lambda acumulador, numero: acumulador + numero, lista) ) #devuelve 55