Informática y Programación

La informática es el tratamiento automático de la información mediante sistemas computacionales. Una computadora es un dispositivo electrónico que puede guardar, extraer y procesar datos bajo el control de programas.

Los programas son secuencias de instrucciones que indican a la computadora qué hacer paso a paso. Estas instrucciones están escritas en lenguajes de programación, que son traducidos al lenguaje que la máquina puede entender.

Python es un lenguaje ideal para iniciarse en la programación por varias razones:

• Es sintácticamente sencillo y fácil de aprender
• Está disponible gratuitamente en múltiples plataformas
• Permite ejecución interactiva del código, agilizando el aprendizaje
• Facilita el desarrollo rápido de aplicaciones

💡 Este curso no pretende cubrir todo el lenguaje Python, sino usar algunas de sus estructuras básicas para ejercitar el desarrollo de algoritmos mediante la práctica de funciones.

El objetivo principal es aprender a resolver problemas mediante programación, usando Python como herramienta para expresar soluciones de manera clara y eficiente.

Conceptos Básicos de Programación

Computadoras y Programas

Las computadoras son máquinas que almacenan y manipulan información bajo el control de programas que pueden cambiar. Lo que diferencia a una computadora de una calculadora simple es que podemos elegir qué programa ejecutar según la tarea que queremos realizar.

Mito de la Máquina Todopoderosa

No todos los problemas pueden resolverse con computadoras, y para los que sí, puede haber diferentes algoritmos (métodos de resolución) con distintos costos en recursos computacionales.

Por ejemplo, para calcular N^33 podríamos:

1. Multiplicar N por sí mismo 32 veces (32 multiplicaciones)
2. O hacerlo con solo 6 multiplicaciones mediante potencias sucesivas

Un algoritmo es un método para obtener un resultado, y puede haber varios algoritmos que resuelvan el mismo problema con distinta eficiencia.

Instrucciones con Python

Python nos proporciona un intérprete que ejecuta nuestras órdenes a medida que las escribimos. Podemos usar Python como una calculadora avanzada:

>>> 2+3
5
>>> 5*7
35
>>> 2+3*7
23
>>> (2+3)*7
35

También podemos trabajar con texto (cadenas):

>>> '¡Hola Mundo!'
'¡Hola Mundo!'
>>> 'abcd' + 'efgh'
'abcdefgh'

🔑 Python distingue entre números enteros (para valores exactos) y números de punto flotante (para valores aproximados). Es importante elegir el tipo adecuado según el problema que resolvamos.

Variables y Funciones

Variables

Python permite asignarle un nombre a un valor para "recordarlo" y usarlo posteriormente:

>>> x = 8
>>> y = x*x
>>> 2*y
128
>>> lenguaje = 'Python'
>>> 'Estoy programando en ' + lenguaje
'Estoy programando en Python'

Funciones

Las funciones son fragmentos de programa que permiten efectuar una operación determinada:

>>> abs(-10)
10
>>> max(5,9,-3)
9
>>> len("abcd")
4

Podemos crear nuestras propias funciones:

>>> def hola_marta():
...     return "Hola Marta! Estoy programando en Python."
... 
>>> hola_marta()
'Hola Marta! Estoy programando en Python.'

Las funciones pueden recibir parámetros para hacerlas más versátiles:

>>> def hola(alguien):
...     return "Hola " + alguien + "! Estoy programando en Python."
... 
>>> hola("Ana")
'Hola Ana! Estoy programando en Python.'
>>> hola("Juan")
'Hola Juan! Estoy programando en Python.'

También podemos crear funciones que realicen cálculos matemáticos:

>>> def cuadrado(n):
...     return n*n
... 
>>> cuadrado(5)
25

💡 Las funciones son poderosas porque nos permiten definir operaciones reutilizables que podemos invocar cuando las necesitemos, sin tener que escribir el mismo código varias veces.

Ciclos y Estructuras de Control

Ciclos Definidos

Para repetir una acción un número específico de veces, usamos ciclos definidos con la instrucción for:

>>> def suma_5_cuadrados():
...     suma = 0
...     for x in range(1, 6):
...         suma = suma + cuadrado(x)
...     return suma
... 
>>> suma_5_cuadrados()
55

El ciclo for genera una secuencia de valores enteros y ejecuta el cuerpo del ciclo para cada valor.

Programas y Módulos

Para conservar nuestros programas, debemos escribirlos en un archivo con extensión .py:

# cuad100.py
def cuadrado(n):
    return n*n

def suma_cuadrados(n):
    suma = 0
    for x in range(1, n+1):
        suma = suma + cuadrado(x)
    return suma

print("La suma de los primeros 100 cuadrados es", suma_cuadrados(100))

Para ejecutarlo:

$ python cuad100.py
La suma de los primeros 100 cuadrados es 338350

Interacción con el Usuario

Para obtener información del usuario, usamos la función input():

# saludar.py
def hola(nombre):
    return "Hola " + nombre + "!"

def saludar():
    nombre = input("Por favor ingrese su nombre: ")
    saludo = hola(nombre)
    print(saludo)

saludar()

🔑 La función input() siempre devuelve una cadena. Si necesitamos un número, debemos convertirlo con int() o float().

Estado y Depuración

Estado de las Variables

El "estado" de un programa se refiere a los valores que tienen todas las variables en un momento dado. La sucesión de estados por los que pasa un programa durante su ejecución se denomina "computación".

Por ejemplo, en este fragmento:

n1 = 3
n2 = 5
x = 3
print(x * x)  # Imprime 9
x = 4
print(x * x)  # Imprime 16

El estado va cambiando a medida que se ejecutan las instrucciones:

1. n1 → 3
2. n1 → 3, n2 → 5
3. n1 → 3, n2 → 5, x → 3
4. n1 → 3, n2 → 5, x → 4

Depuración de Programas

Una manera de seguir la evolución del estado es insertar instrucciones de impresión en sitios críticos del programa:

def imprimir_cuadrados():
    print("Se calcularán cuadrados de números")
    n1 = int(input("Ingrese un número entero: "))
    print("el valor de n1 es:", n1)
    n2 = int(input("Ingrese otro número entero: "))
    print("el valor de n2 es:", n2)
    for x in range(n1, n2):
        print("el valor de x es:", x)
        print(x * x)
    print("Es todo por ahora")

💡 La depuración es una habilidad crucial en programación. Insertar instrucciones print() en puntos estratégicos te permite ver cómo evolucionan las variables y detectar errores.

Estas instrucciones de impresión son temporales y deberían eliminarse una vez que el programa funciona correctamente.

Construcción de Programas

Metodología de Desarrollo

Construir programas requiere seguir una metodología, no simplemente escribir código sin reflexión. Una metodología sencilla incluye estos pasos:

1. Analizar el problema: Entender profundamente qué se intenta resolver.
2. Especificar la solución: Describir qué debe hacer el programa (entradas, salidas y relación entre ellas).
3. Diseñar la solución: Decidir cómo resolver el problema (algoritmos y estructuras de datos).
4. Implementar el diseño: Traducir el diseño a código Python.
5. Probar el programa: Verificar que funcione correctamente.
6. Mantener el programa: Realizar cambios según nuevas necesidades.

Ejemplo Práctico

Supongamos que queremos convertir medidas del sistema inglés al sistema métrico:

1. Análisis: Necesitamos convertir millas, pies y pulgadas a metros.

• 1 milla = 1609.344 m
• 1 pie = 0.3048 m
• 1 pulgada = 0.0254 m

2. Especificación:

• Entrada: cantidad de millas, pies y pulgadas
• Salida: cantidad de metros
• Fórmula: metros = 1609.344 * millas + 0.3048 * pies + 0.0254 * pulgadas

3. Diseño: Estructura Entrada-Cálculo-Salida

Leer millas
Leer pies
Leer pulgadas
Calcular metros = 1609.344 * millas + 0.3048 * pies + 0.0254 * pulgadas
Mostrar metros

🔑 Documentar cada paso del proceso de desarrollo es fundamental para construir programas mantenibles y comprensibles.

Elementos de un Programa Python

Nombres (Identificadores)

Los nombres en Python (variables, funciones, etc.) deben seguir ciertas reglas:

• Comienzan con letra o guion bajo _
• Continúan con letras, números o guiones bajos
• No pueden contener espacios
• Python distingue entre mayúsculas y minúsculas (hola y Hola son diferentes)

Python tiene 33 palabras reservadas que no pueden usarse como identificadores, como: if, for, while, def, etc.

Expresiones

Las expresiones son porciones de código que producen un valor:

• Valores literales: 12345, "Hola"
• Variables: x
• Operaciones: x + 1, 2 * $a + b$

Para operaciones matemáticas:

• Exponenciación: x**3 (x elevado a 3)
• División flotante: 6 / 4 (resultado: 1.5)
• División entera: 6 // 4 (resultado: 1)
• Módulo (resto): 6 % 4 (resultado: 2)

Tipos de Datos

Python tiene varios tipos de datos básicos:

• Números enteros (int): 10, 42, -5
• Números de punto flotante (float): 3.14, 0.0, -2.5
• Cadenas de texto (str): "Hola", 'Ana'
• Booleanos (bool): True, False

Las cadenas pueden crearse con comillas simples o dobles:

'Ana'     # Cadena con comillas simples
"Laura"   # Cadena con comillas dobles

💡 Elige enteros cuando necesites valores exactos (cantidades, conteos) y flotantes cuando la precisión absoluta no sea crucial (mediciones físicas, proporciones).

Instrucciones y Control de Flujo

Instrucciones Básicas

Las instrucciones son órdenes que entiende Python:

• Asignación: nombre = valor
• Return: return expresión
• Expresión simple: abs(-10) (se evalúa y se descarta el resultado)

Ciclos Definidos

El ciclo for permite repetir instrucciones un número determinado de veces:

for x in range(n1, n2):
    print(x * x)

El rango range(n1, n2) genera los valores enteros desde n1 hasta n2-1.

Guía para el Diseño

Al diseñar soluciones, pregúntate:

• ¿Has visto este problema antes?
• ¿Conoces un problema relacionado?
• ¿Puedes resolver una parte del problema?
• ¿Has utilizado todos los datos disponibles?

Calidad de Software

La calidad de un programa puede evaluarse según estas propiedades:

• Confiabilidad: ¿Resuelve el problema correctamente?
• Testabilidad: ¿Es fácil verificar que funciona?
• Performance: ¿Cuánto tiempo y recursos consume?
• Usabilidad: ¿Es fácil de usar?
• Mantenibilidad: ¿El código es legible y modificable?
• Escalabilidad: ¿Funciona bien cuando aumenta la demanda?
• Portabilidad: ¿Funciona en diferentes plataformas?
• Seguridad: ¿Los datos están protegidos?

🔑 La calidad del software no se limita a que "funcione" - aspectos como la mantenibilidad y la legibilidad son cruciales para el desarrollo profesional.

Cada proyecto tiene prioridades diferentes. En este curso nos enfocaremos principalmente en la confiabilidad y mantenibilidad de nuestros programas.

Funciones en Profundidad

Documentación de Funciones

Es importante documentar cada función para saber qué hace, qué parámetros recibe y qué devuelve:

def hola(alguien):
    """Devuelve un saludo dirigido a la persona indicada por parámetro."""
    return "Hola " + alguien + "! Estoy programando en Python."

La documentación se escribe entre triple comillas al inicio de la función. Puedes acceder a ella usando help(hola).

Devolver vs. Imprimir

Hay dos formas de mostrar resultados:

1. Devolver con return: permite reutilizar el resultado en otras operaciones.
2. Imprimir con print(): solo muestra el resultado en pantalla.

Comparemos estas dos funciones:

def devolver_segundos(horas, minutos, segundos):
    """Transforma en segundos una medida de tiempo."""
    return 3600 * horas + 60 * minutos + segundos

def imprimir_segundos(horas, minutos, segundos):
    """Imprime una medida de tiempo en segundos."""
    print(3600 * horas + 60 * minutos + segundos)

Con la primera podemos hacer:

s1 = devolver_segundos(1, 10, 10)
s2 = devolver_segundos(2, 32, 20)
print(s1 + s2)  # Podemos operar con los resultados

💡 Una función es más reutilizable si devuelve un resultado (con return) en lugar de imprimirlo directamente, y si recibe parámetros en lugar de leer datos con input().

Uso Práctico de Funciones

Ejemplo Completo: Tarifador Telefónico

Veamos cómo resolver un problema utilizando funciones:

Problema: Facturar llamadas telefónicas. Se informa la tarifa por segundo y la duración de cada comunicación. Debemos calcular la duración en segundos y su costo.

Análisis:

• Una tarifa única por segundo
• n llamadas telefónicas
• Duraciones expresadas en horas, minutos y segundos
• Calcular duración en segundos y costo

Diseño:

leer tarifa por segundo
leer cantidad de llamadas
repetir n veces:
    leer horas, minutos y segundos de la llamada
    calcular duración en segundos
    calcular costo
    mostrar duración y costo

Implementación:

def a_segundos(horas, minutos, segundos):
    """Convierte tiempo en formato h:m:s a segundos totales."""
    return 3600 * horas + 60 * minutos + segundos

def tarifador():
    """Factura llamadas telefónicas según su duración."""
    tarifa = float(input("Costo por segundo: $"))
    n = int(input("Cantidad de comunicaciones a facturar: "))
    
    for i in range(n):
        print("Comunicación", i+1)
        h = int(input("Horas: "))
        m = int(input("Minutos: "))
        s = int(input("Segundos: "))
        duracion = a_segundos(h, m, s)
        costo = tarifa * duracion
        print("Duración:", duracion, "segundos")
        print("Costo: $", costo)

Variables Locales

Las variables definidas dentro de una función son locales y solo existen mientras la función se ejecuta:

def suma_cuadrados(n):
    suma = 0
    for x in range(1, n+1):
        suma = suma + x*x
    return suma

y = suma_cuadrados(5)  # y será 55
print(suma)  # ¡ERROR! 'suma' no existe fuera de la función

🔑 El alcance limitado de las variables locales ayuda a evitar "efectos secundarios" no deseados en tu programa, ya que cada función maneja sus propios datos de forma aislada.