Apuntes de Introducción a la Programación
con Python
Autor: Preguntar
Curso / Asignatura: Fundamentos de Programación / Python I
Fecha: 19 de julio de 2025
Palabras clave: Python, Programación, Algoritmos, Estructuras de datos, Buenas prácticas
1. Resumen Ejecutivo
Estos apuntes proporcionan una base sólida para comenzar a programar en Python, abarcando
desde conceptos elementales (tipos de datos, control de flujo) hasta nociones intermedias
(funciones, manejo de archivos, modularidad y pruebas simples). Incluyen ejemplos claros,
ejercicios propuestos y buenas prácticas profesionales.
2. Objetivos de Aprendizaje
Al finalizar el estudio de este material el estudiante será capaz de:
1. Comprender el ciclo editar–ejecutar–depurar.
2. Usar tipos de datos primitivos y estructuras de colección en Python.
3. Construir algoritmos básicos con estructuras de control.
4. Definir y documentar funciones reutilizables.
5. Emplear módulos estándar y crear módulos propios.
6. Manipular archivos de texto (lectura/escritura) con seguridad.
7. Aplicar principios de estilo (PEP 8) y pruebas unitarias elementales.
3. Conceptos Fundamentales
3.1 ¿Qué es Programar?
Dar instrucciones formales y no ambiguas a un computador para resolver problemas. Un
algoritmo es una secuencia finita de pasos bien definidos.
3.2 Instalación y Entorno
Intérprete: Python 3.x (verificar python --version).
Entornos recomendados: VS Code, PyCharm, o cuadernos Jupyter para
experimentos.
Gestor de paquetes: pip / venv para aislar dependencias.
3.3 Ejecución Básica
Archivo hola.py:
def main():
print("Hola, mundo")
if __name__ == "__main__":
main()
Ejecutar: python hola.py.
4. Tipos de Datos y Variables
Tipo Ejemplos Descripción
int 0, -5, 42 Enteros arbitrariamente grandes
float 3.14, -0.001 Coma flotante (doble precisión)
bool True, False Lógica
str "cadena" Texto Unicode
list [1, 2, 3] Secuencia mutable
tuple (1, 2) Secuencia inmutable
dict {"a":1} Pares clave-valor
set {1,2,3} Conjunto sin duplicados
Asignación: x = 10. Dinámicamente tipado: el tipo se infiere en tiempo de ejecución.
4.1 Conversión de Tipos
int("5"), str(3.14), list("hola") -> ['h','o','l','a'].
5. Operadores Básicos
Aritméticos: + - * / // % **
Comparación: == != < <= > >=
Lógicos: and or not
Pertenencia: in not in
Asignación compuesta: += -= *= /=.
Ejemplo:
x = 7
x += 3 # x = 10
6. Control de Flujo
6.1 Condicionales
edad = 20
if edad >= 18:
print("Mayor de edad")
else:
print("Menor de edad")
6.2 Bucles
while (cuando no sabemos cuántas iteraciones):
i = 0
while i < 5:
print(i)
i += 1
for (iterar sobre colección / rango):
for c in "python":
print(c)
Uso de range(start, stop, step).
6.3 Comprensiones
Sintaxis compacta: [x**2 for x in range(5)] -> [0,1,4,9,16].
7. Funciones
7.1 Definición
def area_circulo(radio: float) -> float:
"""Calcula el área de un círculo dado su radio."""
import math
return math.pi * radio**2
7.2 Parámetros y Argumentos
Posicionales, nombrados, valores por defecto (def f(a, b=0): ...).
*args (tupla de argumentos variables), **kwargs (diccionario de argumentos
nombrados).
7.3 Alcance (Scope)
Variables definidas dentro de función son locales. Palabra clave global (evitar su abuso) y
nonlocal (en closures).
8. Estructuras de Datos Compuestas
8.1 Listas
Métodos: .append(), .extend(), .insert(), .pop(), .sort(), .reverse().
Copias: lista[:] o list(lista).
8.2 Diccionarios
Acceso seguro: mi_dict.get("clave", valor_por_defecto). Iteración: .keys(),
.values(), .items().
8.3 Sets
Operaciones: unión |, intersección &, diferencia -, diferencia simétrica ^.
9. Cadenas (Strings)
Inmutables. Métodos útiles: .lower(), .upper(), .strip(), .replace(), .split(),
.join().
F-strings para formateo:
nombre = "Ana"
edad = 30
print(f"{nombre} tiene {edad} años")
10. Manejo de Errores y Excepciones
def divide(a, b):
try:
return a / b
except ZeroDivisionError:
print("Error: división por cero")
except TypeError as e:
print("Tipos incompatibles:", e)
finally:
print("Fin de la operación")
Usar excepciones para condiciones excepcionales, no para flujo normal.
11. Entrada / Salida y Archivos
with open("datos.txt", "r", encoding="utf-8") as f:
contenido = f.read()
with open("salida.txt", "w", encoding="utf-8") as f:
f.write("Línea 1\n")
with gestiona el cierre automático del archivo.
12. Módulos y Paquetes
Importar: import math, from math import sqrt.
Crear módulo propio: archivo utilidades.py con funciones; usar import
utilidades.
Paquete: carpeta con __init__.py.
13. Programación Defensiva y Buenas Prácticas
1. Nombrado claro (snake_case).
2. Funciones cortas con responsabilidad única.
3. Comentarios que expliquen por qué, no lo obvio.
4. Documentar con docstrings (estilo reStructuredText o Google).
5. Seguir PEP 8 (longitud de línea recomendada 79/88).
6. Evitar duplicación (principio DRY).
14. Pruebas Unitarias (Introducción)
Archivo test_area.py:
import math
from circulo import area_circulo
def test_area_circulo():
assert math.isclose(area_circulo(1), math.pi)
Ejecutar con pytest.
15. Ejemplo Integrado
Objetivo: leer números de un archivo, filtrar los pares, calcular promedio.
def promedio_pares(ruta: str) -> float:
with open(ruta, "r", encoding="utf-8") as f:
numeros = [int(linea.strip()) for linea in f if linea.strip()]
pares = [n for n in numeros if n % 2 == 0]
return sum(pares) / len(pares) if pares else float('nan')
Uso:
print(promedio_pares("numeros.txt"))
16. Depuración (Debugging)
Print statements (rápido, pero ensucia).
Debugger (breakpoints en IDE, módulo pdb).
Estrategias: reproducir error, aislar, formular hipótesis, probar, documentar causa.
17. Complejidad Algorítmica Breve
Notación Big-O: mide crecimiento asintótico.
| Operación (lista) | Complejidad |
|-------------------|------------|
| Indexación lst[i] | O(1) |
| Append | O(1) amortizado |
| Búsqueda lineal | O(n) |
| Ordenación (sort) | O(n log n) |
Optimizar solo tras medir (principio: premature optimization is the root of all evil).
18. Seguridad y Errores Comunes
No almacenar credenciales en texto plano.
Validar entrada externa.
Evitar variables globales compartidas.
No atrapar excepciones genéricas sin control (except Exception:) salvo logging
final.
Cuidar uso de recursión (profundidad y stack).
19. Ejercicios Propuestos
1. Escribe función es_primo(n) y prueba con varios valores.
2. Implementa fibonacci(n) iterativo y recursivo; compara tiempos para n=30.
3. Dado un texto, cuenta frecuencia de cada letra (ignora mayúsculas). Muestra top 5.
4. Crea script que lea un CSV simple (separado por comas) y calcule promedio de una
columna numérica.
5. Implementa juego de adivinar número (1..100) con retroalimentación (más alto / más
bajo).
6. Escribe pruebas unitarias para es_primo y fibonacci.
20. Recursos Recomendados
Documentación oficial Python (docs.python.org).
"Automate the Boring Stuff with Python" (Al Sweigart).
"Python Crash Course" (Eric Matthes).
PEP 8: Guía de estilo.
21. Glosario Breve
Término Definición
Algoritmo Secuencia finita de pasos para resolver un problema.
Intérprete Programa que ejecuta código línea a línea.
Función Bloque reutilizable que produce un resultado.
Módulo Archivo .py con definiciones reutilizables.
Paquete Carpeta con módulos y __init__.py.
Excepción Evento anómalo que altera flujo normal.
Prueba unitaria Verifica comportamiento de una unidad de código.
22. Resumen Final
Python ofrece una sintaxis clara y una extensa biblioteca estándar, facilitando el aprendizaje
progresivo. Dominar fundamentos (tipos, control de flujo, funciones, estructuras) posibilita
abordar librerías más avanzadas (datos, web, IA). La clave: práctica deliberada, escribir
código limpio y probar de forma sistemática.
