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
# 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.
# 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
# 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
# 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
# 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 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
# 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
# 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 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ÁSICOCrea 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ÁSICODesarrolla 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ÁSICOConvierte 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ÁSICOSistema 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.