Funciones predefinidas

Funciones Predefinidas de Python (Built-in Functions)

Qué son las funciones predefinidas

Las funciones predefinidas o built-in functions son funciones que Python incluye de serie, sin necesidad de importar ningún módulo. Están siempre disponibles en cualquier programa Python desde el primer momento.

Python tiene 69 funciones predefinidas organizadas en varias categorías según su propósito.

1. Funciones de entrada y salida

`print()`

Muestra información en pantalla. Es la función más usada en Python.

python

# Uso básico
print("Hola mundo")                        # Hola mundo

# Varios argumentos separados por comas
print("Nombre:", "Ana", "Edad:", 22)       # Nombre: Ana Edad: 22

# Cambiar el separador
print("2024", "01", "15", sep="-")         # 2024-01-15

# Cambiar el final de línea
print("Cargando", end="...")
print("listo")                             # Cargando...listo

# Sin salto de línea
for i in range(5):
    print(i, end=" ")                      # 0 1 2 3 4

`input()`

Lee texto introducido por el usuario desde el teclado. Siempre devuelve un string.

python

nombre = input("¿Cómo te llamas? ")
print(f"Hola, {nombre}!")

# Siempre devuelve string, hay que convertir
edad = int(input("¿Cuántos años tienes? "))
nota = float(input("¿Cuál es tu nota? "))

# Proteger contra entradas inválidas
try:
    numero = int(input("Introduce un número: "))
except ValueError:
    print("Eso no es un número")

2. Funciones de conversión de tipos

`int()`

Convierte a número entero. Trunca los decimales sin redondear.

python

print(int(7.9))         # 7   ← no redondea, trunca
print(int(7.1))         # 7
print(int(-7.9))        # -7  ← también trunca hacia cero
print(int("42"))        # 42
print(int("  15  "))    # 15  ← ignora espacios

# Con base numérica
print(int("1010", 2))   # 10  ← binario a decimal
print(int("FF", 16))    # 255 ← hexadecimal a decimal
print(int("17", 8))     # 15  ← octal a decimal

# Uso práctico
precio_texto = "1299"
precio = int(precio_texto)
con_iva = precio * 1.21
print(f"Con IVA: {con_iva:.2f} €")    # Con IVA: 1571.79 €

`float()`

Convierte a número decimal.

python

print(float(5))           # 5.0
print(float("3.14"))      # 3.14
print(float("  2.5  "))   # 2.5
print(float("inf"))       # inf
print(float("-inf"))      # -inf

# Uso práctico
notas = ["8.5", "6.0", "9.2", "7.5"]
notas_numericas = [float(n) for n in notas]
media = sum(notas_numericas) / len(notas_numericas)
print(f"Media: {media:.2f}")    # Media: 7.80

`str()`

Convierte cualquier valor a string.

python

print(str(42))          # "42"
print(str(3.14))        # "3.14"
print(str(True))        # "True"
print(str(None))        # "None"
print(str([1, 2, 3]))   # "[1, 2, 3]"

# Uso práctico: construir mensajes
edad = 22
mensaje = "Tengo " + str(edad) + " años"
print(mensaje)    # Tengo 22 años

# Guardar número en archivo de texto
numero = 12345
with open("numero.txt", "w") as f:
    f.write(str(numero))

`bool()`

Convierte a booleano. La mayoría de valores son True excepto los vacíos y cero.

python

# Falsy — se convierten a False
print(bool(0))          # False
print(bool(0.0))        # False
print(bool(""))         # False
print(bool([]))         # False
print(bool({}))         # False
print(bool(None))       # False

# Truthy — todo lo demás es True
print(bool(1))          # True
print(bool(-1))         # True
print(bool("hola"))     # True
print(bool([0]))        # True  ← lista con un elemento, aunque sea 0

# Uso práctico: validar campos vacíos
nombre = input("Nombre: ")
if not bool(nombre.strip()):
    print("El nombre no puede estar vacío")

`list()`

Convierte a lista o crea una lista vacía.

python

print(list("Python"))           # ['P', 'y', 't', 'h', 'o', 'n']
print(list((1, 2, 3)))          # [1, 2, 3]  ← tupla a lista
print(list({1, 2, 3}))          # [1, 2, 3]  ← set a lista
print(list(range(5)))           # [0, 1, 2, 3, 4]
print(list())                   # []  ← lista vacía

# Uso práctico
rango = list(range(1, 11))      # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
rango.append(11)
print(rango)

`tuple()`

Convierte a tupla o crea una tupla vacía.

python

print(tuple([1, 2, 3]))         # (1, 2, 3)
print(tuple("abc"))             # ('a', 'b', 'c')
print(tuple(range(4)))          # (0, 1, 2, 3)
print(tuple())                  # ()

# Uso práctico: hacer inmutable una lista de configuración
colores_validos = tuple(["rojo", "verde", "azul"])
# colores_validos[0] = "amarillo"  ← esto daría error, es inmutable

`set()`

Convierte a conjunto (elimina duplicados, sin orden garantizado).

python

print(set([1, 2, 2, 3, 3, 3]))        # {1, 2, 3}
print(set("mississippi"))              # {'m', 'i', 's', 'p'}
print(set())                           # set()  ← conjunto vacío

# Uso práctico: encontrar valores únicos
notas = [8.5, 6.0, 8.5, 9.2, 6.0, 7.5, 8.5]
notas_unicas = set(notas)
print(f"Notas distintas: {sorted(notas_unicas)}")
# Notas distintas: [6.0, 7.5, 8.5, 9.2]

`dict()`

Crea un diccionario.

python

# Desde pares clave=valor
d = dict(nombre="Ana", edad=22, ciudad="Madrid")
print(d)    # {'nombre': 'Ana', 'edad': 22, 'ciudad': 'Madrid'}

# Desde lista de tuplas
pares = [("a", 1), ("b", 2), ("c", 3)]
d = dict(pares)
print(d)    # {'a': 1, 'b': 2, 'c': 3}

# Diccionario vacío
vacio = dict()
print(vacio)    # {}

`complex()`

Crea números complejos (parte real + parte imaginaria).

python

print(complex(3, 4))      # (3+4j)
print(complex(5))         # (5+0j)
print(complex("3+4j"))    # (3+4j)

z = complex(3, 4)
print(z.real)             # 3.0
print(z.imag)             # 4.0

3. Funciones numéricas

`abs()`

Devuelve el valor absoluto (siempre positivo).

python

print(abs(-5))        # 5
print(abs(5))         # 5
print(abs(-3.14))     # 3.14
print(abs(3+4j))      # 5.0  ← módulo del número complejo

# Uso práctico: diferencia entre dos valores
def diferencia(a, b):
    return abs(a - b)

print(diferencia(10, 15))    # 5
print(diferencia(15, 10))    # 5  ← siempre positivo

`round()`

Redondea a un número de decimales.

python

print(round(3.14159))        # 3      ← sin decimales
print(round(3.14159, 2))     # 3.14   ← 2 decimales
print(round(3.14159, 4))     # 3.1416
print(round(3.5))            # 4
print(round(4.5))            # 4      ← redondeo bancario (al par más cercano)
print(round(-3.5))           # -4

# Uso práctico
precio = 19.99
cantidad = 3
total = round(precio * cantidad, 2)
print(f"Total: {total} €")    # Total: 59.97 €

`max()`

Devuelve el valor máximo.

python

# Entre varios argumentos
print(max(3, 7, 2, 9, 1))         # 9

# De una lista
notas = [8.5, 4.8, 9.2, 6.0]
print(max(notas))                  # 9.2

# Con clave personalizada
palabras = ["python", "es", "genial", "programación"]
print(max(palabras, key=len))      # programación  ← la más larga

# Con diccionarios
alumnos = [
    {"nombre": "Ana",    "nota": 8.5},
    {"nombre": "Carlos", "nota": 9.2},
    {"nombre": "María",  "nota": 7.5},
]
mejor = max(alumnos, key=lambda a: a["nota"])
print(f"Mejor alumno: {mejor['nombre']} con {mejor['nota']}")
# Mejor alumno: Carlos con 9.2

`min()`

Devuelve el valor mínimo. Funciona igual que max().

python

print(min(3, 7, 2, 9, 1))         # 1
print(min([8.5, 4.8, 9.2, 6.0]))  # 4.8

palabras = ["python", "es", "genial"]
print(min(palabras, key=len))      # es  ← la más corta

# Uso práctico: limitar valores
def limitar(valor, minimo, maximo):
    return max(minimo, min(maximo, valor))

print(limitar(15, 0, 10))    # 10  ← se limita al máximo
print(limitar(-5, 0, 10))    # 0   ← se limita al mínimo
print(limitar(7, 0, 10))     # 7   ← dentro del rango

`sum()`

Suma todos los elementos de un iterable.

python

print(sum([1, 2, 3, 4, 5]))          # 15
print(sum(range(1, 101)))            # 5050
print(sum([1.5, 2.5, 3.0]))         # 7.0

# Con inicio personalizado
print(sum([1, 2, 3], 10))            # 16  ← 10 + 1 + 2 + 3

# Uso práctico
precios = [29.99, 49.99, 9.99, 19.99]
total = sum(precios)
print(f"Total: {total:.2f} €")       # Total: 109.96 €

# Sumar campo específico de lista de diccionarios
ventas = [{"mes": "Enero", "importe": 1500},
          {"mes": "Febrero", "importe": 1800},
          {"mes": "Marzo", "importe": 2100}]
total_ventas = sum(v["importe"] for v in ventas)
print(f"Total ventas: {total_ventas} €")    # Total ventas: 5400 €

`pow()`

Calcula potencias, con opción de módulo.

python

print(pow(2, 10))          # 1024   ← 2^10
print(pow(2, 0.5))         # 1.4142 ← raíz cuadrada
print(pow(2, -1))          # 0.5    ← potencia negativa

# Con módulo (útil en criptografía)
print(pow(2, 10, 1000))    # 24  ← (2^10) % 1000

# Equivalente a ** pero con módulo integrado
print(2 ** 10)             # 1024

`divmod()`

Devuelve el cociente y el resto de una división en una sola llamada.

python

print(divmod(17, 5))       # (3, 2)  ← 17 ÷ 5 = 3 resto 2
print(divmod(10, 3))       # (3, 1)

# Uso práctico: convertir segundos
def convertir_tiempo(segundos_totales):
    minutos, segundos = divmod(segundos_totales, 60)
    horas, minutos = divmod(minutos, 60)
    return horas, minutos, segundos

h, m, s = convertir_tiempo(3661)
print(f"{h}h {m}m {s}s")    # 1h 1m 1s

4. Funciones de secuencias e iterables

`len()`

Devuelve el número de elementos.

python

print(len("Python"))            # 6
print(len([1, 2, 3, 4]))       # 4
print(len((1, 2, 3)))          # 3
print(len({1, 2, 3}))          # 3
print(len({"a": 1, "b": 2}))   # 2

# Uso práctico
def es_contraseña_valida(contraseña):
    return len(contraseña) >= 8

print(es_contraseña_valida("abc"))         # False
print(es_contraseña_valida("abc12345"))    # True

`range()`

Genera secuencias de números. No crea la lista en memoria, la genera bajo demanda.

python

print(list(range(5)))           # [0, 1, 2, 3, 4]
print(list(range(2, 8)))        # [2, 3, 4, 5, 6, 7]
print(list(range(0, 20, 4)))    # [0, 4, 8, 12, 16]
print(list(range(10, 0, -2)))   # [10, 8, 6, 4, 2]

# Uso práctico
for i in range(1, 6):
    print(f"Intento {i}/5")

# Números pares del 2 al 20
pares = list(range(2, 21, 2))
print(pares)    # [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

`enumerate()`

Añade un índice a cada elemento de un iterable.

python

frutas = ["manzana", "pera", "naranja"]

for i, fruta in enumerate(frutas):
    print(f"{i}: {fruta}")
# 0: manzana
# 1: pera
# 2: naranja

# Empezar desde 1
for i, fruta in enumerate(frutas, start=1):
    print(f"{i}. {fruta}")
# 1. manzana
# 2. pera
# 3. naranja

# Uso práctico: numerar una lista de resultados
resultados = ["Ana: 8.5", "Carlos: 6.0", "María: 9.2"]
for pos, resultado in enumerate(resultados, 1):
    print(f"  {pos}º {resultado}")

`zip()`

Combina varios iterables elemento a elemento.

python

nombres = ["Ana", "Carlos", "María"]
notas   = [8.5, 6.0, 9.2]
ciudades = ["Madrid", "Barcelona", "Valencia"]

for nombre, nota, ciudad in zip(nombres, notas, ciudades):
    print(f"{nombre} ({ciudad}): {nota}")

# Crear diccionario desde dos listas
claves  = ["nombre", "edad", "ciudad"]
valores = ["Ana", 22, "Madrid"]
alumno  = dict(zip(claves, valores))
print(alumno)    # {'nombre': 'Ana', 'edad': 22, 'ciudad': 'Madrid'}

# Descomprimir con zip(*lista)
pares = [(1, "a"), (2, "b"), (3, "c")]
numeros, letras = zip(*pares)
print(numeros)    # (1, 2, 3)
print(letras)     # ('a', 'b', 'c')

`map()`

Aplica una función a cada elemento de un iterable.

python

# Convertir lista de strings a enteros
textos = ["1", "2", "3", "4", "5"]
numeros = list(map(int, textos))
print(numeros)    # [1, 2, 3, 4, 5]

# Con función propia
def al_cuadrado(n):
    return n ** 2

resultado = list(map(al_cuadrado, range(1, 6)))
print(resultado)    # [1, 4, 9, 16, 25]

# Con lambda
precios = [100, 250, 80, 320]
con_iva = list(map(lambda p: round(p * 1.21, 2), precios))
print(con_iva)    # [121.0, 302.5, 96.8, 387.2]

# Uso práctico: normalizar nombres
nombres = ["  ana garcía  ", "CARLOS LÓPEZ", "maría ruiz"]
normalizados = list(map(lambda n: n.strip().title(), nombres))
print(normalizados)    # ['Ana García', 'Carlos López', 'María Ruiz']

`filter()`

Filtra elementos de un iterable según una condición.

python

# Filtrar números pares
numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
pares = list(filter(lambda n: n % 2 == 0, numeros))
print(pares)    # [2, 4, 6, 8, 10]

# Filtrar notas aprobadas
notas = [8.5, 4.8, 9.2, 3.0, 7.5, 5.0]
aprobadas = list(filter(lambda n: n >= 5, notas))
print(aprobadas)    # [8.5, 9.2, 7.5, 5.0]

# Filtrar strings no vacíos
entradas = ["Ana", "", "Carlos", "  ", "María"]
no_vacias = list(filter(lambda s: s.strip(), entradas))
print(no_vacias)    # ['Ana', 'Carlos', 'María']

# Con función propia
def es_adulto(persona):
    return persona["edad"] >= 18

personas = [
    {"nombre": "Ana",    "edad": 22},
    {"nombre": "Luis",   "edad": 15},
    {"nombre": "María",  "edad": 19},
    {"nombre": "Pedro",  "edad": 16},
]
adultos = list(filter(es_adulto, personas))
print([p["nombre"] for p in adultos])    # ['Ana', 'María']

`reversed()`

Devuelve un iterador al revés.

python

numeros = [1, 2, 3, 4, 5]
print(list(reversed(numeros)))    # [5, 4, 3, 2, 1]

for letra in reversed("Python"):
    print(letra, end=" ")         # n o h t y P

# No modifica el original
print(numeros)    # [1, 2, 3, 4, 5]  ← sin cambios

5. Funciones de ordenación

`sorted()`

Devuelve una nueva lista ordenada sin modificar la original. Es la función de ordenación más versátil de Python.

python

# Ordenación básica
numeros = [3, 1, 4, 1, 5, 9, 2, 6]
print(sorted(numeros))              # [1, 1, 2, 3, 4, 5, 6, 9]
print(numeros)                      # [3, 1, 4, 1, 5, 9, 2, 6]  ← sin cambios

# Descendente
print(sorted(numeros, reverse=True))   # [9, 6, 5, 4, 3, 2, 1, 1]

# Strings
palabras = ["banana", "manzana", "pera", "kiwi"]
print(sorted(palabras))                # ['banana', 'kiwi', 'manzana', 'pera']

# Con key — criterio personalizado
print(sorted(palabras, key=len))       # ['pera', 'kiwi', 'banana', 'manzana']
print(sorted(palabras, key=len, reverse=True))  # ['manzana', 'banana', 'kiwi', 'pera']

# Ordenar ignorando mayúsculas
nombres = ["Zebra", "ana", "Marta", "carlos"]
print(sorted(nombres))                 # ['Marta', 'Zebra', 'ana', 'carlos']  ← incorrecto
print(sorted(nombres, key=str.lower))  # ['ana', 'carlos', 'Marta', 'Zebra']  ← correcto

Ordenar listas de diccionarios:

python

alumnos = [
    {"nombre": "Carlos", "nota": 6.0, "edad": 20},
    {"nombre": "Ana",    "nota": 9.2, "edad": 22},
    {"nombre": "María",  "nota": 7.5, "edad": 19},
    {"nombre": "Pedro",  "nota": 6.0, "edad": 21},
]

# Por nota descendente
por_nota = sorted(alumnos, key=lambda a: a["nota"], reverse=True)
for a in por_nota:
    print(f"{a['nombre']}: {a['nota']}")
# Ana: 9.2
# María: 7.5
# Carlos: 6.0
# Pedro: 6.0

# Por múltiples criterios: primero por nota desc, luego por nombre asc
por_nota_y_nombre = sorted(
    alumnos,
    key=lambda a: (-a["nota"], a["nombre"])
)
for a in por_nota_y_nombre:
    print(f"{a['nombre']}: {a['nota']}")
# Ana: 9.2
# María: 7.5
# Carlos: 6.0   ← Carlos antes que Pedro (orden alfabético)
# Pedro: 6.0

El truco de poner -a["nota"] convierte el número a negativo, lo que hace que ordenar ascendentemente por ese valor negativo sea equivalente a ordenar descendentemente por el valor original.

Ordenar por múltiples campos con operator.itemgetter:

python

from operator import itemgetter

datos = [("Ana", 22, 8.5), ("Carlos", 20, 6.0), ("María", 22, 9.2)]

# Ordenar por edad y luego por nota
ordenado = sorted(datos, key=itemgetter(1, 2))
print(ordenado)
# [('Carlos', 20, 6.0), ('Ana', 22, 8.5), ('María', 22, 9.2)]

`.sort()` — método de lista (modifica en sitio)

A diferencia de sorted(), .sort() modifica la lista original y no devuelve nada.

python

numeros = [3, 1, 4, 1, 5, 9, 2]
numeros.sort()
print(numeros)    # [1, 1, 2, 3, 4, 5, 9]  ← lista modificada

# Con los mismos parámetros que sorted
alumnos = ["Carlos", "Ana", "María", "Pedro"]
alumnos.sort(key=str.lower)
print(alumnos)    # ['Ana', 'Carlos', 'María', 'Pedro']

alumnos.sort(key=str.lower, reverse=True)
print(alumnos)    # ['Pedro', 'María', 'Carlos', 'Ana']

Cuándo usar sorted() vs .sort():

python

# Usa sorted() cuando necesites conservar el original
original = [3, 1, 4, 1, 5]
ordenada = sorted(original)
print(original)    # [3, 1, 4, 1, 5]  ← intacto
print(ordenada)    # [1, 1, 3, 4, 5]  ← nueva lista

# Usa .sort() cuando no necesites el original y quieras eficiencia
datos = [3, 1, 4, 1, 5]
datos.sort()       # más eficiente en memoria
print(datos)       # [1, 1, 3, 4, 5]

6. Funciones de comprobación

`isinstance()`

Comprueba si un objeto es de un tipo determinado. Más seguro que type().

python

print(isinstance(42, int))           # True
print(isinstance(42, float))         # False
print(isinstance(42, (int, float)))  # True  ← acepta tupla de tipos
print(isinstance("hola", str))       # True
print(isinstance([1,2], list))       # True

# Uso práctico: validar tipos de entrada
def calcular_media(notas):
    if not isinstance(notas, list):
        raise TypeError("Se esperaba una lista")
    if not all(isinstance(n, (int, float)) for n in notas):
        raise ValueError("Todos los elementos deben ser números")
    return sum(notas) / len(notas)

print(calcular_media([8, 6, 9]))     # 7.666...
# calcular_media("notas")            # TypeError

`type()`

Devuelve el tipo de un objeto.

python

print(type(42))           # <class 'int'>
print(type(3.14))         # <class 'float'>
print(type("hola"))       # <class 'str'>
print(type([1,2,3]))      # <class 'list'>
print(type(None))         # <class 'NoneType'>

# Comparar tipos
x = 42
print(type(x) == int)     # True
print(type(x) is int)     # True  ← forma recomendada

# Obtener el nombre del tipo
print(type(x).__name__)   # int

`callable()`

Comprueba si un objeto se puede llamar como función.

python

def saludar():
    return "Hola"

print(callable(saludar))    # True
print(callable(42))         # False
print(callable(list))       # True  ← list es callable
print(callable(len))        # True

# Uso práctico
def ejecutar_si_posible(obj):
    if callable(obj):
        return obj()
    return obj

print(ejecutar_si_posible(saludar))    # Hola
print(ejecutar_si_posible(42))         # 42

`hasattr()`, `getattr()`, `setattr()`, `delattr()`

Trabajan con atributos de objetos.

python

class Alumno:
    def __init__(self, nombre, nota):
        self.nombre = nombre
        self.nota   = nota

alumno = Alumno("Ana", 8.5)

# hasattr — ¿tiene este atributo?
print(hasattr(alumno, "nombre"))     # True
print(hasattr(alumno, "email"))      # False

# getattr — obtener atributo por nombre
campo = "nombre"
print(getattr(alumno, campo))        # Ana
print(getattr(alumno, "email", "no disponible"))  # no disponible ← valor por defecto

# setattr — asignar atributo por nombre
setattr(alumno, "ciudad", "Madrid")
print(alumno.ciudad)                 # Madrid

# delattr — eliminar atributo
delattr(alumno, "ciudad")
print(hasattr(alumno, "ciudad"))     # False

7. Funciones de representación

`repr()`

Devuelve la representación oficial del objeto, útil para depuración.

python

print(repr("Hola\nmundo"))     # 'Hola\nmundo'  ← muestra el \n literal
print(repr([1, 2, 3]))         # [1, 2, 3]
print(repr(3.14))              # 3.14

# Diferencia con str()
texto = "Hola\nmundo"
print(str(texto))    # Hola
                     # mundo        ← interpreta el salto de línea
print(repr(texto))   # 'Hola\nmundo' ← muestra el escape literal

`format()`

Formatea un valor según una especificación.

python

print(format(3.14159, ".2f"))     # 3.14
print(format(1234567, ","))       # 1,234,567
print(format(0.856, ".1%"))       # 85.6%
print(format(42, "08d"))          # 00000042
print(format(255, "x"))           # ff  ← hexadecimal
print(format(255, "b"))           # 11111111  ← binario

# Equivalente a usar f-strings
numero = 3.14159
print(f"{numero:.2f}")            # 3.14

`chr()` y `ord()`

Convierten entre caracteres y sus códigos Unicode.

python

# ord — carácter a número
print(ord("A"))     # 65
print(ord("a"))     # 97
print(ord("0"))     # 48
print(ord("ñ"))     # 241

# chr — número a carácter
print(chr(65))      # A
print(chr(97))      # a
print(chr(241))     # ñ

# Uso práctico: cifrado César
def cifrar_cesar(texto, desplazamiento):
    resultado = ""
    for c in texto:
        if c.isalpha():
            base = ord("A") if c.isupper() else ord("a")
            resultado += chr((ord(c) - base + desplazamiento) % 26 + base)
        else:
            resultado += c
    return resultado

print(cifrar_cesar("Hola Mundo", 3))     # Krod Pxqgr
print(cifrar_cesar("Krod Pxqgr", -3))   # Hola Mundo

`bin()`, `oct()`, `hex()`

Convierten enteros a sus representaciones en otras bases.

python

print(bin(42))      # 0b101010  ← binario
print(oct(42))      # 0o52      ← octal
print(hex(42))      # 0x2a      ← hexadecimal
print(hex(255))     # 0xff

# Sin el prefijo
print(bin(42)[2:])  # 101010
print(hex(255)[2:]) # ff

8. Funciones de iteración avanzada

`any()` y `all()`

python

# any — True si AL MENOS UNO es True
notas = [4.8, 3.5, 4.2, 5.0]
print(any(n >= 5 for n in notas))    # True  ← el 5.0 cumple

# all — True si TODOS son True
print(all(n >= 5 for n in notas))    # False ← no todos cumplen

notas_aprobadas = [7.5, 8.0, 9.2, 6.5]
print(all(n >= 5 for n in notas_aprobadas))    # True

# Uso práctico
def formulario_completo(datos):
    campos = ["nombre", "email", "edad"]
    return all(campo in datos and datos[campo] for campo in campos)

datos = {"nombre": "Ana", "email": "ana@mail.com", "edad": 22}
print(formulario_completo(datos))    # True

datos_incompletos = {"nombre": "Ana", "email": "", "edad": 22}
print(formulario_completo(datos_incompletos))    # False

`next()`

Obtiene el siguiente elemento de un iterador.

python

numeros = iter([1, 2, 3, 4, 5])

print(next(numeros))    # 1
print(next(numeros))    # 2
print(next(numeros))    # 3

# Con valor por defecto si se agota
print(next(numeros, "agotado"))    # 4
print(next(numeros, "agotado"))    # 5
print(next(numeros, "agotado"))    # agotado  ← en lugar de StopIteration

# Uso práctico: encontrar el primero que cumple una condición
notas = [4.5, 3.8, 6.0, 8.5, 9.2]
primer_aprobado = next((n for n in notas if n >= 5), None)
print(primer_aprobado)    # 6.0

`iter()`

Crea un iterador a partir de un iterable.

python

lista = [1, 2, 3]
iterador = iter(lista)

print(next(iterador))    # 1
print(next(iterador))    # 2

9. Funciones de información del objeto

`id()`

Devuelve el identificador único del objeto en memoria.

python

a = [1, 2, 3]
b = a
c = [1, 2, 3]

print(id(a))           # por ejemplo: 140234567890
print(id(b))           # mismo que a ← apuntan al mismo objeto
print(id(c))           # diferente   ← objeto distinto con mismo valor

print(a is b)          # True   ← mismo objeto
print(a is c)          # False  ← objetos distintos
print(a == c)          # True   ← mismo valor

`dir()`

Lista todos los atributos y métodos de un objeto.

python

print(dir("hola"))      # muestra todos los métodos de str
print(dir([]))          # muestra todos los métodos de list
print(dir(42))          # muestra todos los métodos de int

# Filtrar los que no empiezan por guión bajo
metodos_str = [m for m in dir("hola") if not m.startswith("_")]
print(metodos_str)
# ['capitalize', 'casefold', 'center', 'count', 'encode', ...]

`help()`

Muestra la documentación de un objeto o función.

python

help(len)       # muestra la ayuda de len
help(str)       # muestra todos los métodos de str
help(sorted)    # muestra la ayuda de sorted

10. Funciones misceláneas

`open()`

Abre un archivo para leer o escribir.

python

# Escribir
with open("archivo.txt", "w", encoding="utf-8") as f:
    f.write("Hola mundo\n")
    f.write("Segunda línea\n")

# Leer todo
with open("archivo.txt", "r", encoding="utf-8") as f:
    contenido = f.read()
    print(contenido)

# Leer línea a línea
with open("archivo.txt", "r", encoding="utf-8") as f:
    for linea in f:
        print(linea.strip())

`globals()` y `locals()`

Devuelven diccionarios con las variables globales y locales.

python

x = 10
y = 20

print("x" in globals())    # True

def mi_funcion():
    a = 1
    b = 2
    print(locals())         # {'a': 1, 'b': 2}

mi_funcion()

`eval()` y `exec()`

Ejecutan código Python desde strings. Usar con precaución.

python

# eval — evalúa una expresión y devuelve el resultado
print(eval("2 + 3"))              # 5
print(eval("'hola'.upper()"))     # HOLA

x = 10
print(eval("x * 2"))              # 20

# exec — ejecuta código completo sin devolver valor
exec("resultado = 5 * 5")
print(resultado)                  # 25

Resumen completo por categorías

Categoría	Funciones
Entrada/Salida	`print()`, `input()`, `open()`
Conversión	`int()`, `float()`, `str()`, `bool()`, `list()`, `tuple()`, `set()`, `dict()`, `complex()`
Numéricas	`abs()`, `round()`, `max()`, `min()`, `sum()`, `pow()`, `divmod()`
Secuencias	`len()`, `range()`, `enumerate()`, `zip()`, `map()`, `filter()`, `reversed()`
Ordenación	`sorted()`, `.sort()`
Comprobación	`isinstance()`, `type()`, `callable()`, `hasattr()`, `getattr()`, `setattr()`, `delattr()`
Representación	`repr()`, `format()`, `chr()`, `ord()`, `bin()`, `oct()`, `hex()`
Iteración	`any()`, `all()`, `next()`, `iter()`
Información	`id()`, `dir()`, `help()`
Miscelánea	`globals()`, `locals()`, `eval()`, `exec()`

Power BI

Scripts con bash

Minimal APIs

WordPress

Copilot

Estadística con Python

Programación en Pyhton

Currículum

Funciones predefinidas

Funciones Predefinidas de Python (Built-in Functions)

Qué son las funciones predefinidas

1. Funciones de entrada y salida

print()

input()

2. Funciones de conversión de tipos

int()

float()

str()

bool()

list()

tuple()

set()

dict()

complex()

3. Funciones numéricas

abs()

round()

max()

min()

sum()

pow()

divmod()

4. Funciones de secuencias e iterables

len()

range()

enumerate()

zip()

map()

filter()

reversed()

5. Funciones de ordenación

sorted()

.sort() — método de lista (modifica en sitio)

6. Funciones de comprobación

isinstance()

type()

callable()

hasattr(), getattr(), setattr(), delattr()

7. Funciones de representación

repr()

format()

chr() y ord()

bin(), oct(), hex()

8. Funciones de iteración avanzada

any() y all()

next()

iter()

9. Funciones de información del objeto

id()

dir()

help()

10. Funciones misceláneas

open()

globals() y locals()

eval() y exec()

Resumen completo por categorías

Modal title

`print()`

`input()`

`int()`

`float()`

`str()`

`bool()`

`list()`

`tuple()`

`set()`

`dict()`

`complex()`

`abs()`

`round()`

`max()`

`min()`

`sum()`

`pow()`

`divmod()`

`len()`

`range()`

`enumerate()`

`zip()`

`map()`

`filter()`

`reversed()`

`sorted()`

`.sort()` — método de lista (modifica en sitio)

`isinstance()`

`type()`

`callable()`

`hasattr()`, `getattr()`, `setattr()`, `delattr()`

`repr()`

`format()`

`chr()` y `ord()`

`bin()`, `oct()`, `hex()`

`any()` y `all()`

`next()`

`iter()`

`id()`

`dir()`

`help()`

`open()`

`globals()` y `locals()`

`eval()` y `exec()`