Introducción a Python y Tipos de Datos Primitivos

Fundamentos de variables y tipos de datos primitivos: enteros, flotantes, cadenas y booleanos

Módulo 1 ⏱️ 2 horas 🐍 Variables 🔢 Tipos de datos 💻 Práctica

Introducción

Python es uno de los lenguajes de programación más populares y versátiles en la actualidad, especialmente valorado en ingeniería por su simplicidad y potencia. En esta primera lección, exploraremos los fundamentos de Python enfocándonos en los tipos de datos primitivos: números enteros, flotantes, cadenas y booleanos. Estos elementos constituyen los bloques básicos de construcción para cualquier programa Python.

Objetivos de aprendizaje
  • Comprender qué son las variables en Python y cómo declararlas
  • Identificar y trabajar con los cuatro tipos de datos primitivos
  • Aplicar operaciones básicas con cada tipo de dato
  • Implementar conversiones entre diferentes tipos de datos

Variables en Python: Fundamentos

Las variables en Python son contenedores que almacenan valores de datos. Python es dinámicamente tipado, lo que significa que no necesitamos declarar explícitamente el tipo de una variable. Python determina automáticamente el tipo basándose en el valor asignado. Una variable se crea en el momento en que le asignamos un valor usando el operador de asignación (=).

Reglas para nombres de variables:
  • Pueden contener letras, números y guiones bajos
  • No pueden comenzar con un número
  • Son sensibles a mayúsculas y minúsculas
  • Deben ser descriptivos del propósito
Declaración básica de variables y verificación de tipos Copiar
# Creación de variables de diferentes tipos
nombre = 'Juan'
edad = 25
altura = 1.75
estudiante = True

# Verificación de tipos
print('Variable nombre:', nombre, '- Tipo:', type(nombre))
print('Variable edad:', edad, '- Tipo:', type(edad))
print('Variable altura:', altura, '- Tipo:', type(altura))
print('Variable estudiante:', estudiante, '- Tipo:', type(estudiante))
Variable nombre: Juan - Tipo: 
Variable edad: 25 - Tipo: 
Variable altura: 1.75 - Tipo: 
Variable estudiante: True - Tipo: 

Números Enteros (int): Precisión y Operaciones

Los números enteros en Python representan números sin parte decimal. Python maneja enteros de tamaño arbitrario, limitado únicamente por la memoria disponible del sistema. Los enteros soportan todas las operaciones aritméticas básicas: suma (+), resta (-), multiplicación (*), división (/), división entera (//), módulo (%) y potenciación (**).

Importante

La división regular / siempre retorna un float, mientras que la división entera // retorna un entero.

Operaciones aritméticas con números enteros Copiar
# Declaración de enteros
a = 15
b = 4

# Operaciones básicas
print('Suma:', a + b)
print('Resta:', a - b)
print('Multiplicación:', a * b)
print('División:', a / b)
print('División entera:', a // b)
print('Módulo:', a % b)
print('Potencia:', a ** b)
Suma: 19
Resta: 11
Multiplicación: 60
División: 3.75
División entera: 3
Módulo: 3
Potencia: 50625

Representación en diferentes bases

Representación de enteros en diferentes bases Copiar
# Números en diferentes bases
decimal = 42
binario = 0b101010
octal = 0o52
hexadecimal = 0x2A

print('Decimal:', decimal)
print('Binario 0b101010 en decimal:', binario)
print('Octal 0o52 en decimal:', octal)
print('Hexadecimal 0x2A en decimal:', hexadecimal)
print('Todos son iguales:', decimal == binario == octal == hexadecimal)
Decimal: 42
Binario 0b101010 en decimal: 42
Octal 0o52 en decimal: 42
Hexadecimal 0x2A en decimal: 42
Todos son iguales: True

Números Flotantes (float): Precisión Decimal

Los números flotantes representan números reales con parte decimal, implementados según el estándar IEEE 754 de doble precisión. En ingeniería, los floats son esenciales para cálculos que requieren precisión decimal, como mediciones físicas, cálculos financieros y simulaciones.

Características de los floats:
  • Notación científica: Usa 'e' o 'E' para números muy grandes o pequeños
  • Funciones matemáticas: round(), abs(), math module
  • Precisión limitada: Pueden introducir errores de redondeo
Operaciones y notación científica con flotantes Copiar
# Declaración de flotantes
pi = 3.14159
velocidad_luz = 3e8  # Notación científica
planck = 6.626e-34

print('Pi:', pi)
print('Velocidad de la luz:', velocidad_luz)
print('Constante de Planck:', planck)

# Operaciones con flotantes
radio = 5.0
area = pi * radio ** 2
print('Área del círculo con radio', radio, ':', area)
print('Área redondeada:', round(area, 2))
Pi: 3.14159
Velocidad de la luz: 300000000.0
Constante de Planck: 6.626e-34
Área del círculo con radio 5.0 : 78.53975
Área redondeada: 78.54

Cadenas de Texto (str): Manipulación de Texto

Las cadenas (strings) en Python son secuencias inmutables de caracteres Unicode, delimitadas por comillas simples o dobles. Son fundamentales para el manejo de texto en aplicaciones de ingeniería, desde interfaces de usuario hasta procesamiento de datos.

Formas de crear cadenas

Creación y manipulación básica de cadenas Copiar
# Diferentes formas de crear cadenas
nombre = 'Python'
version = "3.9"
descripcion = '''Python es un lenguaje
de programación versátil'''

# Operaciones básicas
saludo = 'Hola ' + nombre
repeticion = '=' * 20

print('Nombre:', nombre)
print('Versión:', version)
print('Descripción:', descripcion)
print('Saludo:', saludo)
print('Separador:', repeticion)
Nombre: Python
Versión: 3.9
Descripción: Python es un lenguaje
de programación versátil
Saludo: Hola Python
Separador: ====================

F-strings y métodos de cadena

F-strings y métodos de cadena Copiar
# F-strings para formateo avanzado
nombre = 'Ana'
edad = 22
carrera = 'ingeniería de sistemas'

# Formateo con f-strings
mensaje = f'Hola, soy {nombre}, tengo {edad} años y estudio {carrera}'
print(mensaje)

# Métodos de cadena
print('Mayúsculas:', mensaje.upper())
print('Número de caracteres:', len(mensaje))
print('Reemplazar:', mensaje.replace('Ana', 'María'))
print('¿Contiene Python?', 'python' in mensaje.lower())
Hola, soy Ana, tengo 22 años y estudio ingeniería de sistemas
Mayúsculas: HOLA, SOY ANA, TENGO 22 AÑOS Y ESTUDIO INGENIERÍA DE SISTEMAS
Número de caracteres: 63
Reemplazar: Hola, soy María, tengo 22 años y estudio ingeniería de sistemas
¿Contiene Python? False

Valores Booleanos (bool): Lógica y Control

Los valores booleanos representan verdad o falsedad y son fundamentales para la lógica de programación y estructuras de control. En Python, los valores booleanos son True y False (con mayúscula inicial).

Operadores de comparación:
  • ==, != - Igualdad y desigualdad
  • <, >, <=, >= - Comparaciones numéricas
  • and, or, not - Operadores lógicos
Operaciones booleanas y comparaciones Copiar
# Valores booleanos básicos
es_estudiante = True
ha_graduado = False

# Operaciones de comparación
edad = 20
mayor_edad = edad >= 18

print('Es estudiante:', es_estudiante)
print('Ha graduado:', ha_graduado)
print('Edad:', edad)
print('Es mayor de edad:', mayor_edad)

# Operaciones lógicas
puede_votar = mayor_edad and es_estudiante
print('Puede votar y es estudiante:', puede_votar)
print('No ha graduado:', not ha_graduado)
Es estudiante: True
Ha graduado: False
Edad: 20
Es mayor de edad: True
Puede votar y es estudiante: True
No ha graduado: True

Truthiness y conversión a booleano

Concepto de "Truthiness"

Python puede evaluar otros tipos como True o False. Los valores falsy incluyen: False, 0, '', [], None

Truthiness y conversión a booleano Copiar
# Evaluación de truthiness
valores = [0, 1, '', 'texto', [], [1, 2], None]

print('Evaluación de truthiness:')
for valor in valores:
    print(f'{repr(valor):10} -> {bool(valor)}')

# Uso práctico en validaciones
nombre = input('Ingresa tu nombre: ')
if nombre:  # Se evalúa como True si no está vacío
    print(f'Hola, {nombre}!')
else:
    print('No ingresaste un nombre.')
Evaluación de truthiness:
0          -> False
1          -> True
''         -> False
'texto'    -> True
[]         -> False
[1, 2]     -> True
None       -> False

Conversión entre Tipos de Datos

La conversión de tipos (type casting) es el proceso de cambiar un valor de un tipo de dato a otro. Python proporciona funciones incorporadas para conversiones: int(), float(), str(), y bool().

Tipos de conversiones:
  • Implícitas: Python las realiza automáticamente
  • Explícitas: El programador las especifica manualmente
  • Validación: Siempre verificar antes de convertir
Conversiones explícitas entre tipos Copiar
# Conversiones numéricas
entero_str = '42'
flotante_str = '3.14'

entero = int(entero_str)
flotante = float(flotante_str)
entero_desde_float = int(flotante)

print('String a entero:', entero_str, '->', entero)
print('String a flotante:', flotante_str, '->', flotante)
print('Float a entero:', flotante, '->', entero_desde_float)

# Conversiones a string
numero = 123
resultado = 'El número es: ' + str(numero)
print(resultado)
String a entero: 42 -> 42
String a flotante: 3.14 -> 3.14
Float a entero: 3.14 -> 3
El número es: 123

Ejercicios Prácticos

Calculadora de IMC
BÁSICO

Crea un programa que solicite al usuario su peso en kilogramos y su altura en metros, luego calcule y muestre el IMC. El IMC se calcula como peso dividido por altura al cuadrado.

Pista:

Usa input(), float() y round(). IMC normal: 18.5-24.9

Analizador de Texto
BÁSICO

Desarrolla un programa que analice una frase: caracteres totales, número de palabras, vocales y si contiene 'Python'.

Pista:

Usa len(), split(), count() y in

Conversor de Temperatura
BÁSICO

Convierte Celsius a Fahrenheit y Kelvin. Incluye validación para el cero absoluto (-273.15°C).

Pista:

F = C × 9/5 + 32, K = C + 273.15. Usa f-strings para formato elegante

Sistema de Login Básico
BÁSICO

Sistema simple de autenticación con usuario/contraseña predefinidos y contador de intentos.

Pista:

Usa variables booleanas y operadores lógicos para las validaciones

Resumen y Próximos Pasos

En esta primera lección hemos establecido las bases fundamentales de Python explorando variables y los cuatro tipos de datos primitivos. Hemos aprendido que las variables son contenedores flexibles que Python maneja dinámicamente, y que cada tipo de dato tiene características específicas para resolver problemas de ingeniería.

Próxima lección

Exploraremos estructuras de datos más complejas como listas y sus métodos de manipulación.