Instalación y configuración del intérprete

En sistemas Linux/Unix, el intérprete de Python generalmente se encuentra en rutas como /usr/bin/python3 o /usr/local/bin/python3. Para ejecutar scripts directamente desde la terminal, es común agregar la ruta al entorno y usar un shebang.

#!/usr/bin/env python3

Sintaxis de comentarios

Python permite tres tipos de comentarios para documentar código:

# Comentario de una línea

'''
Comentario multilínea usando comillas simples.
Puede abarcar varias líneas.
'''

"""
Comentario multilínea usando comillas dobles.
Útil para documentación más detallada.
"""

Tipos de datos fundamentales

Python3 incluye varios tipos de datos integrdaos: números (int, float, complejos), cadenas (str), listas, tuplas, conjuntos (set) y diccionarios (dict).

Operadores y su precedencia

Python soporta múltiples tipos de operadores, cada uno con un propósito específico.

Operadores aritméticos

Estos operadores realizan cálculos matemáticos básicos.

Operador	Descripción	Ejemplo
+	Suma de operandos	x + y resulta en 15
-	Resta	x - y resulta en 5
*	Multiplicación	x * y resulta en 50
/	División	y / x resulta en 2.0
%	Módulo (resto)	y % x resulta en 0
**	Exponente	x ** 2 resulta en 100
//	División entera	y // x resulta en 2

Operadores de comparación

Devuelven valores booleanos (True o False) basados en la relación entre operandos.

Operador	Descripción	Ejemplo
==	Igualdad	(a == b) retorna False
!=	Desigualdad	(a != b) retorna True
>	Mayor que	(a > b) retorna False
<	Menor que	(a < b) retorna True
>=	Mayor o igual	(a >= b) retorna False
<=	Menor o igual	(a <= b) retorna True

Operadores de asignación

Asignan valores a variables, con variantes compuestas.

Operador	Descripción	Ejemplo
=	Asignación simple	res = a + b
+=	Asignación con suma	res += a equivale a res = res + a
-=	Asignación con resta	res -= a equivale a res = res - a
*=	Asignación con multiplicación	res *= a equivale a res = res * a
/=	Asignación con división	res /= a equivale a res = res / a
%=	Asignación con módulo	res %= a equivale a res = res % a
**=	Asignación con exponente	res **= a equivale a res = res ** a
//=	Asignación con división entera	res //= a equivale a res = res // a

Operadores lógicos

Combinan expresiones booleanas usando lógica AND, OR y NOT.

Operador	Expresión lógica	Descripción	Ejemplo
and	x and y	Devuelve y si x es verdadero, sino x	(a and b) retorna 20
or	x or y	Devuelve x si es verdadero, sino y	(a or b) retorna 10
not	not x	Invierte el valor booleano	not(a and b) retorna False

Operadores de pertenencia

Verifican si un elemento existe en una secuencia.

Operador	Descripción	Ejemplo
in	True si el valor está en la secuencia	x in y retorna True si x está en y
not in	True si el valor no está en la secuencia	x not in y retorna True si x no está en y

Operadores de identidad

Comparan la identidad de objetos en memoria.

Operador	Descripción	Ejemplo
is	True si los operandos son el mismo objeto	x is y retorna True si id(x) == id(y)
is not	True si los operandos no son el mismo objeto	x is not y retorna True si id(x) != id(y)

Precedencia de operadores

La precedencia determina el orden de evaluación, con exponentes primero y lógicos al final.

Operador	Descripción
**	Exponente (mayor precedencia)
~ + -	Operadores unarios
* / % //	Multiplicación, división, módulo
+ -	Suma y resta
>> <<	Desplazamiento de bits
&	AND bit a bit
^ |	OR y XOR bit a bit
<= < > >=	Comparaciones
== !=	Igualdad
= %= /= //= -= += *= **=	Asignación
is is not	Identidad
in not in	Pertenencia
not or and	Lógicos (menor precedencia)

Control de flujo

Estructuras condicionales

Permiten tomar decisiones basadas en condiciones.

if condicion_uno:
    bloque_codigo_uno
elif condicion_dos:
    bloque_codigo_dos
else:
    bloque_codigo_tres

Bucles

Bucle while

Repite código mientras una condición sea verdadera.

while condicion:
    sentencias

Bucle for

Itera sobre una secuencia.

for elemento in secuencia:
    sentencias

Función range()

Genera secuencias numéricas.

for idx in range(0, 10, 3):
    print(idx)

Sentencias break y continue

break termina el bucle, continue salta a la siguiente iteración.

Sentencia pass

No realiza ninguna acción, usada como marcador de posición.

while True:
    pass  # Espera interrupción

Funciones

Las funciones se definen con def y encapsulan código reutilizable.

def nombre_funcion(parametros):
    cuerpo_funcion

Alcance de variables

Las variables locales tienen prioridad sobre las globales dentro de una función.

#!/usr/bin/env python3
valor_global = 4

def funcion_uno():
    valor_local = 17
    print("Dentro de funcion_uno:", valor_local)

def funcion_dos():
    print("Dentro de funcion_dos:", valor_global)

funcion_uno()
funcion_dos()
print("Global:", valor_global)

Salida esperada: Dentro de funcion_uno: 17, Dentro de funcion_dos: 4, Global: 4.

Argumentos clave

Las funciones pueden llamarse con argumentos nombrados.

def mostrar_info(voltaje, estado='rígido', accion='zoom', tipo='Azul Noruego'):
    print("-- Este loro no haría", accion)
    print("si se le aplican", voltaje, "voltios.")
    print("-- Hermoso plumaje, el", tipo)
    print("-- Está", estado, "!")

Llamadas válidas:

mostrar_info(1000)
mostrar_info(voltaje=1000000, accion='VOOOOOM')
mostrar_info('un millón', 'sin vida', 'saltar')

Llamadas inválidas:

mostrar_info()
mostrar_info(voltaje=5.0, 'muerto')

Argumentos variables

Permiten aceptar un número variable de argumentos.

def promedio_aritmetico(*args):
    total = 0
    for numero in args:
        total += numero
    return total

Valor de retorno

Las funciones devuelven valores con return.

def calcular_suma(a, b):
    resultado = a + b
    return resultado

Manejo de excepciones

Python usa bloques try-except-finally para manejar errores.

import sys

try:
    archivo = open('datos.txt')
    linea = archivo.readline()
    valor = int(linea.strip())
except OSError as error_os:
    print("Error de OS:", error_os)
except ValueError:
    print("No se pudo convertir a entero.")
except:
    print("Error inesperado:", sys.exc_info()[0])
    raise
finally:
    # Código de limpieza
    pass

Lanzar excepciones

Se usa raise para generar excepciones.

raise ValueError('Valor inválido proporcionado')

Excepciones personalizadas

Se pueden crear clases de excepción heredando de Exception.

class ErrorBase(Exception):
    """Clase base para excepciones personalizadas."""
    pass

class ErrorEntrada(ErrorBase):
    """Error en datos de entrada."""
    def __init__(self, expresion, mensaje):
        self.expresion = expresion
        self.mensaje = mensaje

class ErrorTransicion(ErrorBase):
    """Error en transición de estados."""
    def __init__(self, estado_anterior, estado_nuevo, mensaje):
        self.estado_anterior = estado_anterior
        self.estado_nuevo = estado_nuevo
        self.mensaje = mensaje

Programación orientada a objetos

Conceptos básicos

Las clases definen plantillas para objetos, con atributos y métodos.

class NombreClase:
    # Atributos de clase
    def metodo(self):
        # Código del método
        pass

Instanciación y métodos

Los objetos se crean instanciando clases.

#!/usr/bin/env python3

class Ejemplo:
    """Una clase de demostración."""
    contador = 0

    def __init__(self, nombre):
        self.nombre = nombre
        Ejemplo.contador += 1

    def saludar(self):
        return f"Hola, soy {self.nombre}"

obj = Ejemplo("Python")
print(obj.saludar())
print("Instancias creadas:", Ejemplo.contador)

Herencia simple

Las clases pueden heredar de otras clases.

class Padre:
    def metodo_padre(self):
        print("Método de la clase padre")

class Hijo(Padre):
    def metodo_hijo(self):
        print("Método de la clase hijo")

instancia = Hijo()
instancia.metodo_padre()
instancia.metodo_hijo()

Herencia múltiple

Python soporta herencia de múltiples clases.

class ClaseA:
    def metodo_a(self):
        print("Método de ClaseA")

class ClaseB:
    def metodo_b(self):
        print("Método de ClaseB")

class ClaseC(ClaseA, ClaseB):
    def metodo_c(self):
        print("Método de ClaseC")

obj = ClaseC()
obj.metodo_a()
obj.metodo_b()
obj.metodo_c()

Sobrescritura de métodos

Las subclases pueden redefinir métodos de la clase padre.

class Base:
    def mostrar(self):
        print("Método base")

class Derivada(Base):
    def mostrar(self):
        print("Método sobrescrito")

obj = Derivada()
obj.mostrar()

Miembros privados

Los atributos y métodos privados se denotan con doble guion bajo.

class ClasePrivada:
    def __init__(self):
        self.__secreto = 42
        self.publico = 100

    def __metodo_privado(self):
        print("Acceso interno")

    def metodo_publico(self):
        self.__metodo_privado()
        return self.__secreto

obj = ClasePrivada()
print(obj.publico)
print(obj.metodo_publico())
# print(obj.__secreto)  # Esto causaría un error

Sobrecarga de operadores

Se pueden definir operadores personalizados mediante métodos especiales.

class Vector2D:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        return f"Vector({self.x}, {self.y})"

    def __add__(self, otro):
        return Vector2D(self.x + otro.x, self.y + otro.y)

v1 = Vector2D(1, 2)
v2 = Vector2D(3, 4)
resultado = v1 + v2
print(resultado)

Módulos de la biblioteca estándar

Python incluye módulos útiles para tareas comunes.

Interfaz del sistema operativo

El módulo os proporciona funciones interactuar con el SO.

import os

directorio_actual = os.getcwd()
os.chdir('/nueva/ruta')
os.system('comando')

Manejo de arhcivos

El módulo glob permite buscar archivos con comodines.

import glob

archivos_python = glob.glob('*.py')

Argumentos de línea de comandos

sys.argv almacena los argumentos pasados al script.

import sys

argumentos = sys.argv

Expresiones regulares

El módulo re facilita el trabajo con patrones de texto.

import re

coincidencias = re.findall(r'\bpalabra\b', 'texto con palabra clave')
texto_modificado = re.sub(r'(\d+)', 'NÚMERO', 'hay 123 números')

Matemáticas

El módulo math ofrece funciones matemáticas avanzadas.

import math

valor = math.sqrt(144)
angulo = math.sin(math.pi / 2)