Funciones integradas en Python

Python tiene un total de 69 funciones integradas que podemos utilizar sin necesidad de importar ningún módulo. En este artículo vamos a ver una selección de 27 de estas funciones que siempre viene bien tener a mano. Dichas funciones se han agrupado en 8 categorías distintas en función de su utilidad, tal y como se muestra a continuación en el índice de este post.

Entrada/salida

print()

Esta es seguramente la función más conocida de todas. Lo que hace print() es imprimir por la salida estándar la representación en string de cualquier objeto. Además tiene varios parámetros de entrada opcionales que modifican su comportamiento. Entre ellos, sep que define el separador que delimita los objetos que se imprimen, y end para especificar qué se imprime después del último objeto. Tanto sep como end deben de ser strings.

>>> print("Hola Mundo!")
Hola Mundo!
>>> print([1, 2, 3, 4])
[1, 2, 3, 4]
>>> print("Bienvenido", "al", "Mundo", "de", "Python", sep="\n")
Bienvenido
al
Mundo
de
Python
>>> print("Python", "te", "saluda", sep="\n", end="\n*-*-*-\n")
Python
te
saluda
*-*-*-

input()

La función integrada input() toma datos de entrada por el teclado hasta que pulsamos intro. Normalmente se usa en la forma input(mensaje), donde mensaje es un string para indicar al usuario qué datos espera el programa. Dichos datos suelen almacenarse en una variable para su posterior procesado. Cabe mencionar que en Python 3 los datos retornados por esta función son en formato string. Por tanto, en caso necesario tenemos que hacer una conversión al tipo de dato deseado.

>>> nombre = input("¿Tu lenguaje de programación favorito? ")
¿Tu lenguaje de programación favorito? python
>>> nombre
'python'
>>> type(nombre)
<class 'str'>
>>> tiempo = input("¿Cuántos años llevas usándolo? ")
¿Cuántos años llevas usándolo? 5
>>> type(tiempo)
<class 'str'>

open()

Esta función abre un fichero del disco y retorna un objeto para poder interactuar con dicho fichero. En caso que el fichero especificado no exista lanza un error del tipo FileNotFoundError. El tipo de objeto retornado dependerá del modo en que abramos el fichero, el cual se especifica mediante el parámetro mode. Por defecto, cuando no especificamos ningún modo, los ficheros se abren en modo texto 't' para ser leídos 'r'. También se pueden abrir en modo escritura eliminando el contenido actual del fichero 'w', o añadiendo los nuevos contenidos al final del fichero 'a'. El otro modo de apertura es en bytes 'b' en cuyo caso hay que especificar si queremos abrir el fichero en modo de crear 'bx', leer 'br', escribir 'bw', o adjuntar 'ba'. Si quieres conocer con más detalle cómo funciona el modo texto te recomiendo el artículo donde explico cómo leer y escribir ficheros de texto con Python.

>>> fichero_texto_lectura = open("test.txt")
>>> type(fichero_texto_lectura)
<class '_io.TextIOWrapper'>
>>> fichero_texto_escritura = open("test.txt", 'w')
>>> type(fichero_texto_escritura)
<class '_io.TextIOWrapper'>
>>> fichero_bytes_lectura = open("test.txt", 'br')
>>> type(fichero_bytes_lectura)
<class '_io.BufferedReader'>
>>> fichero_bytes_escritura = open("test.txt", 'bw')
>>> type(fichero_bytes_escritura)
<class '_io.BufferedWriter'>

format()

La función format(valor, formato) formatea el valor numérico de acuerdo al formato que le especifiquemos. En concreto retorna un string que representa ese valor formateado. Esta función se utiliza típicamente para determinar el número de decimales con los que se muestra un valor numérico al usuario. Si queremos representar dicho número con una precisión de dos decimales tenemos que hacerlo con el formato ".2f". En caso de no especificar ningún formato el valor numérico se queda tal cual.

>>> format(3)
'3'
>>> format(1.4142, ".2f")
'1.41'
>>> format(1.4142, ".3f")
'1.414'

Ayuda para programar/debugging

help()

La función help() muestra la ayuda integrada de cualquier componente de Python, y como tal está pensada para ser utilizada con el intérprete. Si no se especifica ningún parámetro inicia una sesión interactiva. Por el contrario, si se le pasa el nombre de una clase muestra la ayuda de esa clase. Además si le pasamos un objeto, determina la clase del objeto y muestra su ayuda.

>>> help(list)      # Muestra la ayuda para las listas
>>> help([1, 2, 3]) # Muestra la ayuda para las listas
>>> help(help)      # Muestra la ayuda de la función help
>>> help()          # Abre una sesión de ayuda interactiva

dir()

Con la función dir(objeto) obtenemos una lista cuyos elementos son los métodos de objeto ordenados alfabéticamente. Cabe destacar que objeto también puede ser el nombre de una clase como list, tuple, etc.

>>> dir(list)      # Muestra todos los métodos de una lista
>>> dir([1, 2, 3]) # Muestra todos los métodos de una lista

type()

La función type(objeto) retorna el tipo de objeto, o en otras palabras el nombre su clase. Se trata de una función que puede resultar muy útil ya que Python es un lenguaje de programación no tipado.

>>> type("Hola")
<class 'str'>
>>> type(123)
<class 'int'>
>>> type([1, 2, 3])
<class 'list'>

id()

Esta función toma un objeto como parámetro de entrada y retorna un número entero que representa su “identidad”. Esto significa que dos objetos con la misma identidad apuntan al mismo espacio físico en memoria. Es lo que vemos en el siguiente ejemplo, donde las listas mi_lista y tu_lista tienen la misma identidad y al modificar una de ellas también se modifica la otra. Un aspecto a considerar de esta función es que dos objetos con vidas útiles no superpuestas pueden compartir la misma entidad.

>>> mi_lista = [1, 2, 3]
>>> tu_lista = mi_lista
>>> id(mi_lista)
2048480207488
>>> id(tu_lista)
2048480207488
>>> mi_lista.append(4)
>>> tu_lista
[1, 2, 3, 4]

hash()

La función hash(objeto) retorna un número entero que representa el hash de objeto, siempre y cuando tenga uno. El hash se calcula a partir de los datos de un objeto, por tanto dos objetos distintos pueden tener el mismo hash. En el siguiente código vemos como las variables saludo y saludo_a_python apuntan a distintos objetos en memoria, sin embargo tienen el mismo hash ya que el contenido de ambos objetos es idéntico.

>>> saludo = "Hola Python!"
>>> saludo_a_python = "Hola Python!"
>>> id(saludo)
2048489068336
>>> id(saludo_a_python)
2048489068400
>>> hash(saludo)
-2583109900626686436
>>> hash(saludo_a_python)
-2583109900626686436

Funciones matemáticas

abs()

La función abs(numero) retorna el valor absoluto de numero, es decir su valor sin importar su signo. El parámetro numero puede ser un entero, un número de coma flotante o un objeto que implemente la función __abs__(). En caso de números complejos retorna el valor de la magnitud.

>>> abs(3)
3
>>> abs(-3)
3
>>> abs(-3.0)
3.0
>>> abs(3+4j)
5.0

round()

La función round(numero) redondea numero a su entero más próximo. Pero los números decimales que terminan en 5 son un caso especial. Python sigue la estrategia de “redondear empates a números pares”. Esto significa que parar redondear un número de coma flotante terminado en 5, se mira el dígito que tiene a su izquierda. Si ese dígito es par, el redondeo se hace hacia abajo. Es por eso que en Python tanto 1.5 como 2.5 redondean a 2. Adicionalmente, podemos utilizar esta función como round(numero, ndigitos), donde ndigitos especifica el número de decimales que ha de tener el resultado.

>>> round(1.5)
2
>>> round(2.5)
2
>>> round(3.141592, 4)
3.1416

pow()

La función pow(base, exponente) calcula la potenciación de base elevado a exponente. Se trata de una función equivalente a realizar el cálculo base ** exponente. Adicionalmente, podemos utilizar esta función como pow(base, exponente, modulo), donde el parámetro opcional modulo se utiliza para calcular el módulo del resultado de la exponenciación. Es una operación equivalente a la siguiente: (base ** exponente) % modulo.

>>> pow(2, 3)
8
>>> pow(2, -1)
0.5
>>> pow(2, 3, 2)
0

Estructuras de datos

list()

En realidad list() no es una función en si, sino que se trata de un constructor para listas. Cuando lo utilizamos sin argumentos crea una lista vacía. También le podemos pasar como parámetro una secuencia iterable, en cuyo caso la convierte a una lista. Normalmente esa secuencia iterable que le pasamos a list() no suele ser una lista ya que estaríamos generando código redundante.

>>> list()
[]
>>> list((1, 2, 3))
[1, 2, 3]
>>> list(range(3))
[0, 1, 2]

dict()

dict() es el constructor de la clase diccionario. Usado sin argumentos retorna un diccionario vacío. Con dict() también podemos crear un diccionario que no sea vacío. Para ello tenemos que pasarle argumentos nombrados, donde los nombres de los argumentos se corresponden con las claves del diccionario y los valores con los valores para dicha clave.

>>> dict()
{}
>>> dict(uno=1, dos=2, tres=3)
{'uno': 1, 'dos': 2, 'tres': 3}

tuple()

tuple() es el constructor de la clase tupla. Podemos usarlo sin argumentos para crear una tupla vacía, o pasarle un objeto iterable cuyos elementos serán los elementos de la tupla. En este sentido, podemos utilizar tuple() para convertir fácilmente un string o una lista a una tupla.

>>> tuple()
()
>>> tuple("Python")
('P', 'y', 't', 'h', 'o', 'n')
>>> tuple([1, 2, 3])
(1, 2, 3)

set()

set() es el constructor de la clase set. Podemos usarlo sin argumentos para crear un set vacío, o pasarle un objeto iterable cuyos elementos no repetidos serán los elementos del set. En este sentido, podemos utilizar set() para filtrar los elementos repetidos de un string o una lista.

>>> set()
set()
>>> set("Python")
{'o', 't', 'h', 'P', 'n', 'y'}
>>> set([1, 1, 2, 2, 3, 3])
{1, 2, 3}

Generación de secuencias iterables

range()

La función range(fin) genera una secuencia de números enteros que podemos utilizar para iterar en un bucle. La secuencia generada empieza en 0 y termina en el entero anterior a fin. Es decir, el valor fin no forma parte de la secuencia. Alternativamente, podemos usar range(inicio, fin, paso), donde inicio indica el primer número de la secuencia y paso cada cuantos números se toman en cuenta para la secuencia. Los valores por defecto de parámetros inicio y paso son 0 y 1 respectivamente. A modo de ejemplo, range(4, 7, 2) genera una secuencia de enteros que empieza en 4, termina en 6 y toma sus valores de 2 en 2.

>>> for x in range(2):
...     print(x)
...
0
1
>>> list(range(4, 7))
[4, 5, 6]
>>> list(range(4, 7, 2))
[4, 6]

enumerate()

La función enumerate(iterable) toma una secuencia o un iterador y retorna objeto de tipo enumerate. Dicho objeto es una secuencia iterable de tuplas con sus respectivos índices. Cada una de estas tuplas tiene la forma (i, x) donde i es el índice del objeto x perteneciente a iterable, el parámetro de entrada de la función. Por defecto el primer índice es 0, aunque también podemos definir su valor usando la función enumerate(iterable, inicio).

>>> lenguajes = ["Python", "Java", "JavaScript", "C++"]
>>> list(enumerate(lenguajes))
[(0, 'Python'), (1, 'Java'), (2, 'JavaScript'), (3, 'C++')]
>>> for i, x in enumerate(lenguajes, 1):
...     print(i, "-", x)
...
1 - Python
2 - Java
3 - JavaScript
4 - C++

Operaciones con objetos iterables

len()

La función len(objeto) retorna el número de elementos que contiene un objeto. Dicho objeto puede ser tanto una secuencia (un string, una lista, una tupla, etc.) como una colección (un diccionario).

>>> len("Python")
6
>>> len([0, 1, 2])
3
>>> len({"a":0, "b":1, "c":2})
3

sum()

La función sum(iterable) retorna el total de sumar los elementos de la secuencia iterable. Para poder realizar la suma, los elementos de iterable tienen que ser números. Por defecto, el resultado de la suma empieza a contar en 0, pero podemos hacer que empiece en otro valor si lo pasamos como segundo argumento a la función.

>>> sum([1, 2, 3])
6
>>> sum([1, 2, 3], 4)
10

max()

La función max(iterable) retorna el elemento más grande del objeto iterable. También se pueden utilizar dos o más argumentos, en cuyo caso retorna el mayor de los argumentos.

>>> max([4, 2, 8, 5])
8
>>> max("python")
'y'
>>> max("a", "z", "A", "Z")
'z'

min()

La función min(iterable) retorna el elemento más pequeño del objeto iterable. También se pueden utilizar dos o más argumentos, en cuyo caso retorna el menor de los argumentos.

>>> min([4, 2, 8, 5])
2
>>> min("python")
'h'
>>> min("a", "z", "A", "Z")
'A'

Modificaciones de objetos iterables

sorted()

La función sorted(iterable) retorna una lista con los elementos de iterable ordenados de menor a mayor. También puede retornar los elementos ordenados de mayor a menor cuando se especifica el parámetro opcional reverse del siguiente modo: sorted(iterable, reverse=True).

>>> sorted([3, 2, 5, 1, 4])
[1, 2, 3, 4, 5]
>>> sorted([3, 2, 5, 1, 4], reverse=True)
[5, 4, 3, 2, 1]

reversed()

La función reversed(secuencia) retorna un iterador revertido de los valores de una secuencia como por ejemplo un string, una lista, una tupla, etc. Es decir, intercambia el primer elemento con el último, el segundo con el penúltimo, etc.

>>> list(reversed([1, 2, 3, 4]))
[4, 3, 2, 1]
>>> tuple(reversed((1, 2, 3, 4)))
(4, 3, 2, 1)

Funciones aplicadas a iterables

map()

La función map(funcion, iterable) aplica funcion a cada uno de los elementos del objeto iterable y retorna el resultado en un objeto map. Dicho objeto se puede convertir a tipo lista con list(), a tipo tupla con tuple(), etc.

>>> mi_lista = [1, 2, 3, 4]
>>> def cuadrado(x):
...     return x * x
...
>>> lista_map = map(cuadrado, mi_lista)
>>> type(lista_map)
<class 'map'>
>>> list(lista_map)
[1, 4, 9, 16]

filter()

La función filter(funcion, iterable) extrae todos los elementos de una secuencia iterable para los cuales la funcion retorna True. El resultado es un objeto filter que se puede convertir a secuencias tipo lista con list(), a tipo tupla con tuple(), etc.

>>> mi_lista = [1, 2, 3, 4]
>>> def es_par(x):
...     if x % 2 == 0:
...             return True
...     return False
...
>>> iterador_num_pares = filter(es_par, mi_lista)
>>> type(iterador_num_pares)
<class 'filter'>
>>> list(iterador_num_pares)
[2, 4]

zip()

La función zip() toma como argumentos un número arbitrario de iteradores, y los agrega en un objeto de tipo zip. Dicho objeto es un iterador de tuplas, donde la primera tupla está compuesta por los primeros elementos de cada uno de los iteradores, la segunda tupla por los segundos elementos, etc. Esta operación de agregación se realiza hasta haberse completado todos los elementos del iterador más corto. Como el objeto zip es iterable, podemos iterar sus elementos en un bucle for. Alternativamente, podemos convertirlo a tipo lista con list(), aunque para iterar es más eficiente usar el objeto zip ya que la lista necesita memoria para cada uno de sus elementos, mientras que los elementos de zip se van generando de manera dinámica conforme se necesitan.

>>> lista_1 = [1, 2, 3]
>>> lista_2 = [4, 5, 6]
>>> lista_zip = zip(lista_1, lista_2)
>>> type(lista_zip)
<class 'zip'>
>>> list(lista_zip)
[(1, 4), (2, 5), (3, 6)]