Tipos de datos

Números

En Python, los números son uno de los tipos de datos fundamentales que utilizarás constantemente en tus programas. Imagina los números como las herramientas básicas para realizar cálculos, desde operaciones simples como sumar el precio de tus compras hasta análisis de datos complejos.

Python maneja diferentes tipos de números para adaptarse a distintas necesidades. Vamos a explorarlos con ejemplos sencillos y prácticos.

Números enteros (int)

Los enteros representan números sin parte decimal. Son perfectos para contar objetos o representar cantidades exactas.

edad = 25
temperatura_bajo_cero = -10
población_mundial = 8_000_000_000  # Los guiones bajos mejoran la legibilidad

Observa que en Python 3 los enteros no tienen límite práctico de tamaño, lo que significa que pueden ser tan grandes como la memoria de tu computadora permita.

número_grande = 123456789012345678901234567890
print(número_grande + 1)  # Python maneja esto sin problemas

Números decimales (float)

Los flotantes (o float) representan números con parte decimal. Son ideales para mediciones precisas, cálculos científicos o cualquier valor que no sea un número entero exacto.

altura = 1.75  # metros
pi = 3.14159
temperatura = 36.6  # grados

Es importante saber que los flotantes pueden tener pequeñas imprecisiones debido a cómo las computadoras almacenan los números decimales:

resultado = 0.1 + 0.2
print(resultado)  # Muestra 0.30000000000000004, no exactamente 0.3

Para comparaciones con flotantes, es mejor usar una aproximación:

# Forma correcta de comparar flotantes
import math
math.isclose(0.1 + 0.2, 0.3)  # Devuelve True

Números complejos (complex)

Los números complejos tienen una parte real y una imaginaria. Son útiles en cálculos científicos, ingeniería eléctrica y otras aplicaciones avanzadas.

# Formato: real + imaginarioj
complejo = 3 + 4j
print(complejo.real)  # 3.0
print(complejo.imag)  # 4.0

Operaciones básicas con números

Python permite realizar todas las operaciones matemáticas que ya conoces:

suma = 5 + 3        # 8
resta = 10 - 4      # 6
multiplicación = 3 * 7  # 21
división = 20 / 4   # 5.0 (siempre devuelve un float)

También ofrece operaciones más específicas:

división_entera = 7 // 2    # 3 (descarta la parte decimal)
módulo = 7 % 2             # 1 (el resto de la división)
potencia = 2 ** 3          # 8 (2 elevado a 3)

Funciones numéricas útiles

Python incluye funciones integradas para operaciones comunes:

valor_absoluto = abs(-10)      # 10
redondeo = round(3.7)          # 4
redondeo_decimal = round(3.14159, 2)  # 3.14 (redondea a 2 decimales)

Para operaciones matemáticas más avanzadas, puedes usar el módulo math:

import math

raíz_cuadrada = math.sqrt(16)    # 4.0
seno = math.sin(math.pi/2)       # 1.0
logaritmo = math.log10(100)      # 2.0

Conversión entre tipos numéricos

Puedes convertir entre diferentes tipos numéricos según tus necesidades:

# De float a int (trunca la parte decimal)
edad_aproximada = int(25.8)  # 25

# De int a float
precio_exacto = float(20)    # 20.0

# De string a número
cantidad = int("15")         # 15
medida = float("7.5")        # 7.5

Números binarios, octales y hexadecimales

Python permite representar números en diferentes bases:

# Binario (base 2)
binario = 0b1010  # 10 en decimal

# Octal (base 8)
octal = 0o17      # 15 en decimal

# Hexadecimal (base 16)
hexadecimal = 0xFF  # 255 en decimal

print(binario, octal, hexadecimal)  # Muestra: 10 15 255

También puedes convertir en la otra dirección:

# Convertir decimal a otras bases
print(bin(10))  # '0b1010'
print(oct(15))  # '0o17'
print(hex(255)) # '0xff'

Números aleatorios

Para generar números aleatorios, Python ofrece el módulo random:

import random

# Número aleatorio entre 1 y 10
dado = random.randint(1, 6)

# Número decimal aleatorio entre 0 y 1
probabilidad = random.random()

# Elegir un número aleatorio de una lista
carta = random.choice([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, "J", "Q", "K", "A"])

Los números en Python son la base para realizar cálculos, tomar decisiones basadas en condiciones numéricas y procesar datos. Dominar su uso te permitirá resolver una amplia variedad de problemas de programación.

Texto

El texto en Python se maneja mediante el tipo de dato str (string o cadena de caracteres), que es una de las estructuras más versátiles y utilizadas en el lenguaje. Imagina las cadenas de texto como secuencias de caracteres que te permiten almacenar y manipular información textual, desde un simple nombre hasta documentos completos.

Creación de cadenas de texto

En Python puedes crear cadenas de texto utilizando comillas simples, dobles o triples:

nombre = 'Ana'                   # Comillas simples
mensaje = "Hola, ¿cómo estás?"   # Comillas dobles
descripción = """Este es un texto
que ocupa varias
líneas"""                        # Comillas triples para texto multilínea

Las comillas triples son especialmente útiles cuando necesitas preservar los saltos de línea en tu texto.

Acceso a caracteres

Cada cadena en Python funciona como una secuencia ordenada de caracteres a los que puedes acceder mediante índices:

palabra = "Python"
primera_letra = palabra[0]   # 'P'
última_letra = palabra[5]    # 'n'
# También puedes usar índices negativos
última = palabra[-1]         # 'n'
penúltima = palabra[-2]      # 'o'

Longitud de una cadena

Para conocer cuántos caracteres tiene una cadena, utilizamos la función len():

frase = "Aprendiendo Python"
longitud = len(frase)        # 18

Subcadenas (slicing)

Puedes extraer porciones de una cadena utilizando la notación de rebanado (slicing):

texto = "Programación"
# formato: cadena[inicio:fin:paso]
primeras_cuatro = texto[0:4]     # "Prog"
desde_índice_5 = texto[5:]       # "amación"
hasta_índice_6 = texto[:6]       # "Progra"
saltando_caracteres = texto[::2] # "Pormcó"
invertir = texto[::-1]           # "nóicamargorP"

Concatenación y repetición

Puedes unir cadenas con el operador + y repetirlas con el operador *:

saludo = "Hola" + " " + "mundo"  # "Hola mundo"
repetición = "eco " * 3          # "eco eco eco "

Métodos de cadenas

Las cadenas en Python tienen numerosos métodos integrados que facilitan su manipulación:

texto = "  Python es genial  "

# Eliminar espacios en blanco
sin_espacios = texto.strip()           # "Python es genial"

# Convertir a mayúsculas/minúsculas
mayúsculas = texto.upper()             # "  PYTHON ES GENIAL  "
minúsculas = texto.lower()             # "  python es genial  "
capitalizado = texto.strip().title()   # "Python Es Genial"

# Reemplazar texto
nuevo_texto = texto.replace("genial", "increíble")  # "  Python es increíble  "

# Dividir una cadena
palabras = texto.split()               # ["Python", "es", "genial"]

Búsqueda en cadenas

Puedes buscar subcadenas y verificar contenido:

frase = "Aprender Python es divertido"

# Verificar si contiene una subcadena
contiene_python = "Python" in frase    # True

# Encontrar la posición de una subcadena
posición = frase.find("Python")        # 9
# Si no encuentra la subcadena, devuelve -1
posición_no = frase.find("Java")       # -1

# Contar ocurrencias
veces_e = frase.count("e")             # 4

Verificación de contenido

Python ofrece métodos para verificar características del texto:

# ¿Es alfabético? (solo letras)
"Python".isalpha()           # True
"Python3".isalpha()          # False

# ¿Es alfanumérico? (letras y números)
"Python3".isalnum()          # True
"Python 3".isalnum()         # False (por el espacio)

# ¿Es numérico?
"123".isdigit()              # True

# ¿Está en minúsculas/mayúsculas?
"python".islower()           # True
"PYTHON".isupper()           # True

# ¿Empieza o termina con...?
"Python".startswith("Py")    # True
"Python".endswith("on")      # True

Formateo de cadenas

Python ofrece varias formas de formatear cadenas para incluir valores variables:

1. Método f-string (Python 3.6+)

La forma más moderna y recomendada:

nombre = "María"
edad = 25
mensaje = f"Hola, me llamo {nombre} y tengo {edad} años"
# "Hola, me llamo María y tengo 25 años"

# Puedes incluir expresiones
precio = 19.99
mensaje = f"El precio con IVA es: {precio * 1.21:.2f}€"
# "El precio con IVA es: 24.19€"

2. Método format()

nombre = "Juan"
edad = 30
mensaje = "Hola, me llamo {} y tengo {} años".format(nombre, edad)
# "Hola, me llamo Juan y tengo 30 años"

# Con posiciones específicas
mensaje = "Tengo {1} años y me llamo {0}".format(nombre, edad)
# "Tengo 30 años y me llamo Juan"

# Con nombres
mensaje = "Hola, me llamo {n} y tengo {e} años".format(n=nombre, e=edad)
# "Hola, me llamo Juan y tengo 30 años"

3. Operador % (estilo antiguo)

nombre = "Pedro"
edad = 40
mensaje = "Hola, me llamo %s y tengo %d años" % (nombre, edad)
# "Hola, me llamo Pedro y tengo 40 años"

Caracteres especiales y secuencias de escape

Para incluir caracteres especiales en tus cadenas, puedes usar secuencias de escape:

# Salto de línea
print("Primera línea\nSegunda línea")

# Tabulación
print("Nombre:\tJuan")

# Comillas dentro de comillas
print("Él dijo: \"Hola\"")
print('Ella respondió: \'Adiós\'')

# Barra invertida
print("Ruta de Windows: C:\\Usuarios\\Juan")

# Caracteres Unicode
print("\u03A9")  # Muestra la letra griega Omega (Ω)

Cadenas sin procesar (raw strings)

Si necesitas que Python ignore las secuencias de escape, puedes usar cadenas sin procesar añadiendo r antes de las comillas:

# Normal - interpreta \n como salto de línea
print("C:\nuevos\archivos")  # Imprime en dos líneas

# Raw string - mantiene \n como texto literal
print(r"C:\nuevos\archivos") # Imprime C:\nuevos\archivos

Esto es especialmente útil para expresiones regulares y rutas de Windows.

Conversión entre tipos

Puedes convertir otros tipos de datos a cadenas y viceversa:

# De número a cadena
edad = 25
edad_texto = str(edad)       # "25"

# De cadena a número
número_texto = "42"
número = int(número_texto)   # 42
decimal_texto = "3.14"
decimal = float(decimal_texto)  # 3.14

Las cadenas de texto son fundamentales en casi cualquier programa que escribas. Te permiten almacenar información legible para humanos, procesar datos textuales y comunicarte con los usuarios de tus aplicaciones. Dominar su manipulación te dará una gran ventaja al programar en Python.

Booleanos

Los booleanos en Python representan uno de los tipos de datos más simples pero fundamentales en programación. Este tipo de dato solo puede tener dos valores posibles: True (verdadero) o False (falso). Imagina los booleanos como interruptores de luz que solo pueden estar encendidos o apagados, sin estados intermedios.

Valores booleanos básicos

En Python, los valores booleanos se escriben con la primera letra en mayúscula:

está_lloviendo = True
es_fin_de_semana = False

Estos valores son perfectos para representar estados, condiciones o respuestas a preguntas de sí/no en tus programas.

Operaciones de comparación

Una de las formas más comunes de generar valores booleanos es mediante operaciones de comparación:

edad = 18
es_mayor_de_edad = edad >= 18    # True
temperatura = 15
hace_calor = temperatura > 25    # False

Python ofrece varios operadores de comparación:

• == (igual a)
• != (diferente de)
• > (mayor que)
• < (menor que)
• >= (mayor o igual que)
• <= (menor o igual que)

x = 5
y = 10
print(x == y)    # False
print(x != y)    # True
print(x < y)     # True

Operadores lógicos

Los operadores lógicos te permiten combinar condiciones booleanas:

• and - Verdadero si ambas condiciones son verdaderas
• or - Verdadero si al menos una condición es verdadera
• not - Invierte el valor booleano

edad = 25
tiene_licencia = True

puede_conducir = edad >= 18 and tiene_licencia    # True
necesita_abrigo = not (temperatura > 15)          # True (porque temperatura es 15)
está_en_oferta = precio < 20 or tiene_descuento   # Depende de las variables

Estos operadores son fundamentales para crear condiciones complejas en tus programas.

Tablas de verdad

Para entender mejor cómo funcionan los operadores lógicos, es útil visualizar sus tablas de verdad:

Para and:

• True and True → True
• True and False → False
• False and True → False
• False and False → False

Para or:

• True or True → True
• True or False → True
• False or True → True
• False or False → False

Para not:

• not True → False
• not False → True

Evaluación en cortocircuito

Python utiliza la evaluación en cortocircuito para los operadores lógicos, lo que significa que deja de evaluar una expresión tan pronto como conoce el resultado:

# Si x es False, Python ni siquiera evalúa y
resultado = x and y

# Si x es True, Python ni siquiera evalúa y
resultado = x or y

Esto es útil para evitar errores y optimizar el rendimiento:

# Evita división por cero
divisor = 0
es_seguro = divisor != 0 and 10 / divisor > 2  # False, no intenta dividir

Valores que se evalúan como booleanos

En Python, todos los valores pueden ser interpretados como booleanos en contextos condicionales. Esto se conoce como evaluación de veracidad (truthiness):

Valores que se evalúan como False:

• False
• None
• 0 (cero)
• "" (cadena vacía)
• [] (lista vacía)
• () (tupla vacía)
• {} (diccionario vacío)
• set() (conjunto vacío)

Todo lo demás se evalúa como True:

# Ejemplos
if 0:
    print("Esto no se imprime")

if 42:
    print("Esto sí se imprime")

if "Hola":
    print("Las cadenas no vacías son True")

if []:
    print("Esto no se imprime")

Esta característica permite escribir código más conciso:

nombre = ""
# En lugar de if len(nombre) > 0:
if nombre:
    print(f"Hola, {nombre}")
else:
    print("Nombre no proporcionado")

Funciones booleanas integradas

Python proporciona dos funciones útiles relacionadas con booleanos:

• all() - Devuelve True si todos los elementos de un iterable son verdaderos
• any() - Devuelve True si al menos un elemento de un iterable es verdadero

números = [2, 4, 6, 8]
todos_pares = all(num % 2 == 0 for num in números)    # True
alguno_mayor_que_5 = any(num > 5 for num in números)  # True

Uso de booleanos en estructuras de control

Los booleanos son fundamentales en las estructuras de control como if, while y for:

edad = 17
if edad >= 18:
    print("Eres mayor de edad")
else:
    print("Eres menor de edad")

# En bucles
respuesta_correcta = False
while not respuesta_correcta:
    respuesta = input("¿Cuál es la capital de Francia? ")
    respuesta_correcta = respuesta.lower() == "parís"

Operador ternario

Python ofrece una forma concisa de expresar condiciones con el operador ternario:

# Sintaxis: valor_si_verdadero if condición else valor_si_falso
estado = "aprobado" if puntuación >= 60 else "suspendido"

Esto es equivalente a:

if puntuación >= 60:
    estado = "aprobado"
else:
    estado = "suspendido"

Comparación de identidad con is

Además de comparar valores con ==, Python permite comparar la identidad de los objetos con el operador is:

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

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

Para booleanos, is se usa frecuentemente para comparar con None:

resultado = función()
if resultado is None:
    print("La función no devolvió nada")

Conversión a booleano

Puedes convertir explícitamente cualquier valor a booleano usando la función bool():

print(bool(0))           # False
print(bool(42))          # True
print(bool(""))          # False
print(bool("Hola"))      # True
print(bool([]))          # False
print(bool([1, 2, 3]))   # True

Esta función es útil cuando necesitas asegurarte de tener un valor booleano explícito.

Los valores booleanos son esenciales para controlar el flujo de tus programas, tomar decisiones basadas en condiciones y representar estados binarios. Aunque parezcan simples, su correcta utilización es fundamental para crear programas lógicos y eficientes en Python.

Conversiones

Las conversiones entre tipos de datos son operaciones fundamentales en Python que te permiten transformar un valor de un tipo a otro. Imagina que tienes información en un formato (como texto) pero necesitas trabajar con ella en otro formato (como número) - aquí es donde las conversiones entran en juego.

Conversiones básicas entre tipos

Python ofrece funciones integradas para convertir entre los tipos de datos fundamentales:

# Convertir a entero (int)
número_entero = int(42.9)      # 42 (trunca la parte decimal)
texto_a_entero = int("100")    # 100
booleano_a_entero = int(True)  # 1

# Convertir a decimal (float)
decimal = float(42)            # 42.0
texto_a_decimal = float("3.14") # 3.14
booleano_a_decimal = float(False) # 0.0

# Convertir a texto (str)
entero_a_texto = str(42)       # "42"
decimal_a_texto = str(3.14)    # "3.14"
booleano_a_texto = str(True)   # "True"

# Convertir a booleano (bool)
número_a_booleano = bool(42)   # True (cualquier número excepto 0 es True)
texto_a_booleano = bool("")    # False (cadena vacía es False)

Conversiones numéricas

Cuando trabajas con diferentes tipos de números, Python realiza algunas conversiones automáticamente:

# Conversión implícita
resultado = 5 + 3.14  # resultado es 8.14 (float)

Sin embargo, para conversiones específicas, es mejor hacerlas explícitamente:

precio = 19.99
# Redondear a entero
precio_redondeado = round(precio)  # 20

# Truncar a entero (eliminar parte decimal)
precio_truncado = int(precio)      # 19

# Convertir a entero con redondeo hacia abajo
import math
precio_suelo = math.floor(precio)  # 19

# Convertir a entero con redondeo hacia arriba
precio_techo = math.ceil(precio)   # 20

Conversiones entre sistemas numéricos

Python facilita la conversión entre diferentes sistemas numéricos:

# Decimal a binario, octal y hexadecimal
número = 42
binario = bin(número)    # '0b101010'
octal = oct(número)      # '0o52'
hexadecimal = hex(número)  # '0x2a'

# De otros sistemas a decimal
binario_a_decimal = int('101010', 2)  # 42
octal_a_decimal = int('52', 8)        # 42
hexa_a_decimal = int('2a', 16)        # 42

Conversiones de texto

Además de convertir otros tipos a texto, puedes transformar el formato del texto mismo:

texto = "python es genial"

# Cambiar mayúsculas/minúsculas
mayúsculas = texto.upper()          # "PYTHON ES GENIAL"
minúsculas = texto.lower()          # "python es genial"
primera_mayúscula = texto.capitalize()  # "Python es genial"
título = texto.title()              # "Python Es Genial"

# Convertir lista a texto
palabras = ["Python", "es", "genial"]
texto_unido = " ".join(palabras)    # "Python es genial"

# Convertir texto a lista
texto = "manzana,naranja,plátano"
frutas = texto.split(",")           # ["manzana", "naranja", "plátano"]

Manejo de errores en conversiones

Las conversiones pueden fallar si el valor de origen no es compatible con el tipo de destino:

# Esto generará un error
try:
    número = int("abc")
except ValueError:
    print("No se puede convertir 'abc' a número")

Para hacer conversiones más seguras, puedes verificar primero si es posible:

texto = input("Introduce tu edad: ")

# Verificar si es un número antes de convertir
if texto.isdigit():
    edad = int(texto)
    print(f"El año que viene tendrás {edad + 1} años")
else:
    print("Por favor, introduce un número válido")

Conversiones con formato específico

A veces necesitas convertir valores con un formato particular:

# Formatear un número como precio
precio = 19.99
precio_formateado = f"{precio:.2f}€"  # "19.99€"

# Convertir número a texto con separador de miles
población = 1234567
población_formateada = f"{población:,}"  # "1,234,567"

# Convertir a porcentaje
proporción = 0.3542
porcentaje = f"{proporción:.2%}"  # "35.42%"

Conversiones entre colecciones

Python también permite convertir entre diferentes tipos de colecciones:

# Lista a tupla
mi_lista = [1, 2, 3]
mi_tupla = tuple(mi_lista)  # (1, 2, 3)

# Tupla a lista
otra_tupla = (4, 5, 6)
otra_lista = list(otra_tupla)  # [4, 5, 6]

# Lista/tupla a conjunto (elimina duplicados)
números_con_duplicados = [1, 2, 2, 3, 3, 3]
conjunto_sin_duplicados = set(números_con_duplicados)  # {1, 2, 3}

# Conjunto a lista
mi_conjunto = {7, 8, 9}
lista_desde_conjunto = list(mi_conjunto)  # [7, 8, 9]

Conversiones prácticas en situaciones cotidianas

Veamos algunos escenarios comunes donde las conversiones son útiles:

# Calcular edad a partir del año de nacimiento
año_actual = 2023
texto_nacimiento = input("¿En qué año naciste? ")
if texto_nacimiento.isdigit():
    año_nacimiento = int(texto_nacimiento)
    edad = año_actual - año_nacimiento
    print(f"Tienes aproximadamente {edad} años")

# Convertir temperatura de Celsius a Fahrenheit
celsius = float(input("Temperatura en °C: "))
fahrenheit = (celsius * 9/5) + 32
print(f"{celsius}°C equivale a {fahrenheit:.1f}°F")

# Calcular el IVA de un producto
precio_texto = input("Precio del producto: ")
try:
    precio = float(precio_texto)
    iva = precio * 0.21
    precio_con_iva = precio + iva
    print(f"IVA: {iva:.2f}€")
    print(f"Precio final: {precio_con_iva:.2f}€")
except ValueError:
    print("Por favor, introduce un precio válido")

Conversión de datos de usuario

Cuando obtienes datos del usuario mediante input(), siempre recibes texto que normalmente necesitas convertir:

# La función input siempre devuelve un string
respuesta = input("¿Cuántas manzanas quieres? ")

# Convertir a entero de forma segura
try:
    cantidad = int(respuesta)
    precio_unitario = 0.45
    total = cantidad * precio_unitario
    print(f"Total a pagar: {total:.2f}€")
except ValueError:
    print("Por favor, introduce un número")

Las conversiones son una herramienta esencial en tu caja de herramientas de programación. Te permiten adaptar los datos al formato que necesitas para cada operación, facilitando la interacción entre diferentes partes de tu programa y asegurando que la información se procese correctamente.