Python para Dummies

En esta clase fundamental de programación aplicada, esencial para cualquier profesional que desee incursionar en el desarrollo de scripts para Sistemas de Información Geográfica, abordaremos los cimientos de la lógica computacional: las estructuras de control condicionales y los operadores lógicos en Python.

La capacidad de un programa para tomar decisiones basadas en criterios específicos es lo que diferencia a una calculadora simple de un algoritmo inteligente capaz de procesar datos espaciales o tabulares complejos. Al igual que en la vida cotidiana evaluamos variables antes de realizar una acción, en Python utilizamos sentencias específicas para dirigir el flujo de ejecución del código según se cumplan o no ciertas condiciones preestablecidas.

Sentencias if y else

El bloque constructivo primario para la toma de decisiones es la sentencia if, acompañada opcionalmente por else. Esta estructura permite que el programa evalúe una expresión lógica; si el resultado es verdadero (True), se ejecuta un bloque de código indentado específico, y si es falso (False), el programa puede optar por ejecutar un bloque alternativo bajo la sentencia else.

Es crucial notar la sintaxis de Python, donde la indentación define qué instrucciones pertenecen a qué bloque. Un error común es confundir el operador de asignación (=) con el operador de comparación de igualdad (==).

edad = 18

if edad >= 18:
    print("Es mayor de edad")
else:
    print("No es mayor de edad")

Condicionales Múltiples: elif

Para análisis más sofisticados donde una variable binaria es insuficiente, introducimos la sentencia elif (abreviatura de "else if"). Esta instrucción permite encadenar múltiples condiciones secuenciales. El sistema evaluará las condiciones en orden hasta encontrar la primera coincidencia verdadera, omitiendo el resto.

edad = 10

if edad == 0:
    print("Es un bebé")
elif edad < 12:
    print("Es un niño")
elif edad < 18:
    print("Es un joven")
elif edad < 60:
    print("Es un adulto")
else:
    print("Es un adulto mayor")

El Operador Módulo %

Un operador matemático indispensable es el módulo, representado por %, que retorna el residuo de una división entera. Es la herramienta estándar para determinar paridad o divisibilidad numérica, vital para operaciones de muestreo sistemático o validación de reglas en bases de datos.

Operadores Lógicos and y or

Para construir condiciones robustas que evalúen múltiples criterios, empleamos los operadores booleanos and (intersección estricta) y or (unión). Un ejercicio práctico que integra estos conceptos es la determinación de un año bisiesto según el algoritmo gregoriano.

Introducción a los Ciclos en Python

En esta lección se abordará el funcionamiento y aplicación de las estructuras de control repetitivas en Python, específicamente los ciclos for y while. Estas herramientas son esenciales en el ámbito de los Sistemas de Información Geográfica y el análisis de datos, ya que permiten automatizar tareas iterativas como el procesamiento de grandes volúmenes de información, cálculos matemáticos sobre listas de atributos o la navegación a través de cadenas de texto.

El Ciclo For y la Iteración de Rangos

Para comprender la utilidad del ciclo for, analizaremos cómo calcular el cuadrado de una serie de números de forma eficiente. Utilizaremos la estructura for numero in range(inicio, fin):. Es fundamental recordar que en Python, la función range incluye el valor inicial pero excluye el valor final.

# Iterar del 1 al 6 (el rango debe llegar hasta 7)
for numero in range(1, 7):
    cuadrado = numero ** 2
    print(f"El cuadrado de {numero} es {cuadrado}")

Iteración sobre Cadenas y Listas

El ciclo for permite recorrer elementos de una secuencia, como cadenas de texto o listas (definidas entre corchetes []). Esta capacidad es vital para manipular atributos de entidades geográficas.

El Ciclo While y el Control por Condiciones

A diferencia del for, el ciclo while ejecuta código mientras una condición booleana sea verdadera. Requiere un manejo cuidadoso de las variables de control para evitar bucles infinitos.

contador = 1
while contador <= 5:
    print(contador)
    contador += 1  # Crucial incrementar para evitar bucle infinito

Importancia de la Indentación en Python

En Python, la indentación (sangría) define la jerarquía y pertenencia de las instrucciones en bloques de control. Una indentación incorrecta provoca errores de sintaxis o lógicos, alterando el flujo esperado del programa y los resultados del análisis de datos.

En esta clase se abordarán los fundamentos de la lógica de programación utilizando el lenguaje Python, una habilidad transversal y esencial para cualquier especialista en Sistemas de Información Geográfica que desee automatizar procesos o desarrollar scripts de geoprocesamiento. La sesión se estructura en torno a la resolución de problemas algorítmicos prácticos y la comprensión de la interacción usuario-máquina.

Conversión de Divisas: Estructura Secuencial

Para iniciar el aprendizaje práctico, se desarrollará un algoritmo de conversión de pesos colombianos a dólares. Este ejercicio introduce el concepto de variables, tipos de datos (enteros y flotantes) y la estructura secuencial de un programa: entrada, procesamiento y salida.

trm = 3950.50
pesos = float(input("Ingrese el monto en COP: "))
dolares = pesos / trm
print(f"Equivale a {dolares:.2f} USD")

Piedra, Papel o Tijera: Lógica y Librerías

Se elevará la complejidad con el juego de piedra, papel o tijera, explicando la importancia de importar librerías externas como random para simular un oponente impredecible. Se consolidará el entendimiento de la lógica booleana y los operadores de comparación.

Números Primos: Ciclos y Optimización

Finalmente, se abordará la validación de números primos. Este ejercicio es fundamental para comprender la iteración, los contadores, banderas booleanas y la sentencia de ruptura de ciclos (break), elementos cruciales para el análisis de grandes volúmenes de datos.

Entorno de Desarrollo y Configuración Inicial

Para el desarrollo de scripts y algoritmos de procesamiento de datos, en esta clase se utilizará Google Colab como entorno principal. Esta plataforma basada en la nube permite escribir y ejecutar código Python de manera inmediata, facilitando la gestión de librerías y el almacenamiento de los scripts directamente en Google Drive sin instalaciones locales complejas.

Estructuras de Datos: Listas

Las listas son estructuras de datos versátiles que permiten almacenar secuencias ordenadas de diversos tipos de elementos. En Python, el conteo de índices siempre inicia desde cero. Se pueden realizar operaciones de "slicing" (rebanado) y manipulación dinámica mediante métodos integrados.

# Creación y manipulación básica de listas
datos_biometricos = [1.75, 1.50, 1.80, 1.20]
print(datos_biometricos[0])  # Imprime el primer valor: 1.75

# Métodos esenciales
datos_biometricos.append(1.65)       # Agrega al final
datos_biometricos.insert(2, 1.90)    # Inserta en la posición 2
datos_biometricos.remove(1.50)       # Elimina el valor 1.50
ultimo_dato = datos_biometricos.pop() # Elimina y retorna el último valor

Estructuras de Datos: Diccionarios

Basados en el modelo de pares clave-valor (key-value), son ideales para asociar atributos descriptivos a una entidad mediante claves únicas. Su estructura es similar a la de los archivos JSON.

Programación Orientada a Objetos (POO)

Paradigma que modela entidades del mundo real mediante Clases (plantillas) y Objetos (instancias). Incluye conceptos fundamentales como el método constructor __init__ para inicializar atributos y la Herencia para fomentar la reutilización de código y la jerarquización lógica entre superclases y subclases.

En esta clase se aborda la resolución de problemas algorítmicos complejos utilizando los fundamentos de Python, enfocándose en la modularización del código a través de funciones. Se integran conceptos de cadenas de texto (strings), listas y diccionarios para gestionar flujos de información de manera eficiente.

Encriptación de Mensajes y Operador Módulo

El primer módulo se centra en la encriptación por sustitución basada en diccionarios y operaciones aritméticas. Se utiliza el operador módulo (%) para garantizar que los valores se mantengan dentro del rango de caracteres disponibles.

Estructuras Anidadas: Gestión de Pensum

Se examina la manipulación de listas que contienen diccionarios para modelar un plan de estudios. Se enfatiza el manejo de índices (comenzando en cero) y el uso de la instrucción del para eliminar elementos específicos de forma segura.

Procesamiento y Análisis de Texto

Se profundiza en la limpieza y normalización de datos mediante el método lower() y la eliminación de ruido con replace(). El objetivo es generar diccionarios de frecuencias para identificar las palabras más recurrentes en un texto depurado.

Slicing y Lógica de Juegos: Cartas

Finalmente, se explora el "slicing" o rebanado de listas para extraer segmentos específicos. En un contexto de juego de cartas, se implementan funciones que evalúan secuencias inmediatas y calculan puntajes mediante índices dinámicos y condicionales anidados.

Hola, soy 'Manuales GeoCositas'. A continuación presento la guía de estudio detallada sobre el manejo de matrices en Python, abarcando desde la programación secuencial hasta la orientación a objetos.

Fundamentos de Matrices como Listas de Listas

En Python, una matriz se conceptualiza como una lista de listas, donde cada elemento de la lista principal es otra lista que representa una fila. Al acceder a los datos, es crucial recordar que la indexación comienza desde cero: matriz[fila][columna].

Creación Dinámica y Errores de Inicialización

Un error común es inicializar matrices mediante multiplicación (ej. [[0]*n]*m), lo que crea referencias al mismo objeto en memoria. El método correcto es mediante ciclos e instanciación de listas independientes.

# Inicialización correcta de una matriz de 3x3 con ceros
filas, columnas = 3, 3
matriz = []
for i in range(filas):
    fila = [0] * columnas
    matriz.append(fila)

Recorrido de Matrices y Operaciones

Para manipular datos se emplean ciclos anidados (i para filas, j para columnas). Las operaciones sobre diagonales requieren condiciones lógicas específicas:

• Diagonal Principal: i == j
• Diagonal Secundaria: j == n - 1 - i

Implementación mediante POO

El manejo de matrices puede encapsularse en una clase para mejorar la abstracción y reutilización. Mediante el método constructor __init__ y el uso de self, se definen los atributos y métodos de la matriz.

Abordamos los conceptos esenciales de la POO, un paradigma fundamental para el desarrollo de software. Un objeto es cualquier entidad real o conceptual (persona, animal, entidad vectorial) que posee atributos (características, sustantivos) y comportamientos (métodos, verbos).

Clase vs Instancia: El Molde y la Galleta

Una clase es el molde o esqueleto que define la estructura básica. Las instancias son los objetos individuales creados a partir de ese molde, cada uno con sus propios datos (atributos de instancia) pero compartiendo la misma funcionalidad.

Implementación Técnica: class, __init__ y self

La implementación en Python utiliza la palabra reservada class y el método constructor __init__, que inicializa los atributos. El parámetro self es vital para referenciar la instancia actual del objeto.

class Persona:
    def __init__(self, nombre, edad):
        self.nombre = nombre
        self.edad = edad

    def saludar(self, otra_persona):
        return f"Hola {otra_persona.nombre}, me llamo {self.nombre}"

# Instanciación
juan = Persona("Juan", 32)
carolina = Persona("Carolina", 28)
print(juan.saludar(carolina))

Interacción entre Objetos

La POO permite que los objetos interactúen entre sí. Al definir métodos como atacar, podemos pasar otro objeto completo como argumento, accediendo a sus atributos internos y modelando sistemas complejos de forma coherente.

Abstracción de Datos Personalizados: Vector

Utilizamos clases para crear abstracciones que no existen de forma nativa, como un Vector. Mediante la librería random, podemos gestionar estructuras internas (listas) ocultando la complejidad del proceso de inicialización al usuario final.

Abordamos conceptos fundamentales de ciencias de la computación aplicados en Python. El dominio de estas estructuras requiere una base sólida en ciclos, condicionales y Programación Orientada a Objetos (POO).

Listas Ligadas: Nodos y Secuencias

Una lista ligada es una secuencia de nodos conectados. Cada nodo es un objeto que almacena un dato y una referencia al siguiente elemento. Se implementa mediante clases personalizadas para gestionar el flujo de información.

class Nodo:
    def __init__(self, dato):
        self.dato = dato
        self.siguiente = None

class ListaLigada:
    def __init__(self):
        self.head = None
        self.size = 0

Pilas: Principio LIFO

Las pilas se rigen por el principio Last In, First Out (el último en entrar es el primero en salir). Son fundamentales para procesos como el historial de acciones. En Python, se simulan eficientemente usando métodos nativos de listas.

pila = []
pila.append("Acción 1")  # Apilar (push)
pila.append("Acción 2")
ultimo = pila.pop()       # Desapilar (pop)

Colas: Principio FIFO

Las colas siguen el principio First In, First Out (el primero en entrar es el primero en salir), similar a una fila de atención. Se implementan eliminando el elemento en la posición inicial de la estructura.

cola = []
cola.append("Cliente 1")  # Encolar
cola.append("Cliente 2")
primero = cola.pop(0)     # Desencolar (FIFO)

Fundamentos de Lectura y Escritura

Abordamos el manejo de archivos CSV utilizando la librería estándar csv. Se utiliza with open() para garantizar el cierre seguro de archivos y csv.reader para iterar sobre los registros. Empleamos next() para omitir encabezados y csv.writer para generar reportes estructurados con delimitadores personalizados.

Lógica de Procesamiento y Clasificación

El núcleo del análisis reside en la conversión explícita de tipos (int, float) y la categorización mediante condicionales. Clasificamos registros en categorías como "Infante" o "Adulto" basándonos en la edad y el estado de salud.

import csv

with open('datos.csv', 'r') as archivo:
    lector = csv.reader(archivo)
    header = next(lector)
    for fila in lector:
        edad = int(fila[2])
        estado = "Adulto" if edad >= 18 else "Infante"

Estandarización de Unidades

Normalizamos datos heterogéneos (años, meses, días) a una unidad común para permitir cálculos comparables. Dividimos por 12 si son meses o por 365 si son días, asegurando la precisión estadística.

Estadísticas y Encapsulamiento

Utilizamos funciones nativas como min(), sum() y len() para obtener métricas clave. Todo el proceso se orquesta dentro de una función solucion que gestiona la entrada, transformación y salida de los datos.

Metodología de Manipulación de Datos

En esta sesión abordamos la manipulación técnica de datos estructurados. Utilizamos las librerías nativas csv y json para ingerir volúmenes de información, procesarlos mediante lógica condicional y generar reportes profesionales.

Flujo Completo con Archivos CSV

La apertura de archivos se realiza con la sentencia with open(), garantizando el cierre automático y la eficiencia de memoria. Empleamos csv.reader para la lectura, next() para omitir encabezados y csv.writer para la escritura de resultados.

import csv

with open('datos.csv', 'r') as f_in:
    lector = csv.reader(f_in)
    next(lector)  # Saltar encabezados
    for fila in lector:
        # Procesamiento aquí...

with open('reporte.csv', 'w') as f_out:
    escritor = csv.writer(f_out, delimiter=';')
    escritor.writerow(['ID', 'Resultado'])

Procesamiento Lógico y Conversión de Tipos

Dado que los datos CSV se leen como cadenas de texto, es imperativo realizar conversiones con float() o int(). Aplicamos lógica if-elif-else para categorizar información financiera o climática y funciones como abs() para cálculos de valores absolutos.

Estructuración de Datos con JSON

El manejo de archivos JSON se integra para crear resúmenes estandarizados. Construimos diccionarios de Python poblados con estadísticas y los serializamos utilizando json.dump() para persistir la información técnica.

En esta sesión integradora enfocamos la programación en la resolución creativa de problemas mediante el desarrollo de lógica para juegos, fortaleciendo la transición desde la concepción mental hasta la implementación técnica.

Lógica de Control con 'Adivinar el Número'

Repasamos conceptos esenciales como la entrada de datos (input), ciclos (while) y condicionales. Utilizamos la librería random para generar el número secreto y estructuras anidadas para guiar al usuario en la búsqueda del valor correcto.

import random

secreto = random.randint(1, 100)
gano = False
while not gano:
    intento = int(input("Adivina: "))
    if intento == secreto:
        gano = True
        print("¡Victoria!")

Manipulación de Cadenas con el 'Ahorcado'

Abordamos el manejo de strings y listas para gestionar estados complejos. Aplicamos conceptos de slicing, iteración con for-range y el operador in para validar letras y actualizar la representación visual de la palabra secreta en tiempo real.

Introducción a POO con Sudoku

Elevamos el nivel técnico modelando un tablero de Sudoku mediante Programación Orientada a Objetos. Definimos una clase con su constructor __init__, utilizando listas anidadas para representar matrices y encapsulando comportamientos en métodos especializados como agregar_valor.

class Sudoku:
    def __init__(self, filas, columnas):
        self.tablero = [[0 for _ in range(columnas)] for _ in range(filas)]

    def agregar_valor(self, f, c, v):
        self.tablero[f][c] = v