Programación Básica en Python

by Beastieux, posted in Programación, Python, Tutoriales

Algunos ejemplos de código para comenzar con la programación básica en Python. Estos ejemplos cubren conceptos como variables, operadores, estructuras de control, funciones, listas, tuplas, diccionarios, filtros, decoradores, etc.

Table of Contents

Imprimir en pantalla:

print("Hola, mundo!")

Variables y operadores:

# Declaración de variables
nombre = "Juan"
edad = 25
altura = 1.75

# Operaciones
suma = 5 + 3
resta = 10 - 2
multiplicacion = 4 * 6
division = 15 / 3
modulo = 17 % 4  # Resto de la división

# Concatenación de cadenas
saludo = "Hola, " + nombre

Estructuras de control – Condicionales:

edad = 18

if edad >= 18:
    print("Eres mayor de edad")
else:
    print("Eres menor de edad")

Estructuras de control – Bucles:

# Bucle while
contador = 0
while contador < 5:
    print("Contador:", contador)
    contador += 1

# Bucle for
for i in range(5):
    print("Valor de i:", i)

Funciones:

# Definición de una función
def saludar(nombre):
    print("Hola,", nombre)

# Llamada a la función
saludar("Beastieux")

Listas y bucles con listas:

# Declaración de una lista
frutas = ["cereza", "platanos", "naranja"]

# Acceso a elementos de la lista
print(frutas[0])  # Imprime "cereza"

# Recorriendo la lista con un bucle
for fruta in frutas:
    print("Tengo una", fruta)

Trabajo con listas de listas (Listas anidadas):

matriz = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# Acceso a elementos de la matriz
elemento = matriz[1][2]  # Obtendría el valor 6

Diccionarios:

# Declaración de un diccionario
persona = {
    "nombre": "Miguel",
    "edad": 30,
    "ciudad": "Perú"
}

# Acceso a valores del diccionario
print(persona["nombre"])  # Imprime "Miguel"

Funciones incorporadas útiles:

# Obtener la longitud de una cadena o lista
longitud = len("Hola, mundo!")
print("Longitud:", longitud)  # Imprime 13

# Obtener el máximo y mínimo de una lista de números
numeros = [5, 2, 9, 1, 7]
maximo = max(numeros)
minimo = min(numeros)

# Convertir un número en cadena
numero_str = str(42)

Agregar, modificar y eliminar elementos de Listas:

frutas = ["manzana", "banana", "naranja"]

# Agregar elemento al final de la lista
frutas.append("pera")

# Modificar elemento en la lista
frutas[1] = "kiwi"

# Eliminar elemento de la lista
frutas.remove("manzana")

Uso de bibliotecas externas (ejemplo con la biblioteca random):

import random

# Generar un número aleatorio entre 1 y 10
numero_aleatorio = random.randint(1, 10)
print("Número aleatorio:", numero_aleatorio)

Manejo de excepciones:

try:
    numero = int(input("Ingrese un número: "))
    resultado = 10 / numero
    print("El resultado es:", resultado)
except ZeroDivisionError:
    print("Error: No se puede dividir por cero.")
except ValueError:
    print("Error: Ingrese un número válido.")

Manejo de excepciones personalizadas:

class MiError(Exception):
    def __init__(self, mensaje):
        self.mensaje = mensaje

try:
    raise MiError("Este es mi mensaje de error personalizado.")
except MiError as e:
    print("Error:", e.mensaje)

Manejo de excepciones con finally:

try:
    resultado = 10 / 0
except ZeroDivisionError:
    print("Error: No se puede dividir por cero.")
finally:
    print("Este bloque se ejecuta siempre.")

Funciones con retorno de valor:

def suma(a, b):
    return a + b

resultado_suma = suma(3, 7)
print("Resultado de la suma:", resultado_suma)

Trabajo con cadenas:

mensaje = "¡Hola, cómo estás?"

# Obtener longitud de una cadena
longitud_mensaje = len(mensaje)

# Convertir a mayúsculas y minúsculas
mayusculas = mensaje.upper()
minusculas = mensaje.lower()

# Buscar una subcadena
posicion = mensaje.find("cómo")

# Reemplazar parte de la cadena
nuevo_mensaje = mensaje.replace("estás", "te encuentras")

Módulos personalizados (crear un archivo .py aparte):

# En un archivo llamado operaciones.py
def multiplicacion(a, b):
    return a * b

# En otro archivo
import operaciones
resultado = operaciones.multiplicacion(4, 5)

Comentarios y documentación:

# Esto es un comentario de una línea

"""
Esto es un comentario
de varias líneas.
"""

def funcion():
    """
    Esta función realiza una acción.
    Detalles adicionales.
    """
    pass

Tuplas (similar a las listas pero inmutables):

coordenadas = (3, 5)
x, y = coordenadas  # Desempaquetado de tupla

Operador ternario (forma concisa de escribir una estructura condicional):

edad = 20
mensaje = "Mayor de edad" if edad >= 18 else "Menor de edad"

Bucles y control de flujo:

numeros = [1, 2, 3, 4, 5]

# Bucle for con índice y valor
for indice, valor in enumerate(numeros):
    print("Índice:", indice, "Valor:", valor)

# Bucle while con break y continue
contador = 0
while contador < 10:
    if contador == 5:
        break  # Sale del bucle
    if contador == 3:
        contador += 1
        continue  # Salta a la siguiente iteración
    print("Contador:", contador)
    contador += 1

List comprehensions (construcción concisa de listas):

numeros = [1, 2, 3, 4, 5]
cuadrados = [numero ** 2 for numero in numeros]

pares = [numero for numero in numeros if numero % 2 == 0]

Manejo de archivos:

# Escritura en un archivo
with open("archivo.txt", "w") as archivo:
    archivo.write("Hola, mundo!")

# Lectura de un archivo
with open("archivo.txt", "r") as archivo:
    contenido = archivo.read()
    print("Contenido:", contenido)

Funciones lambda (funciones pequeñas y anónimas):

doble = lambda x: x * 2
resultado = doble(5)

Diferentes tipos de datos:

# Conjunto (set)
conjunto = {1, 2, 3, 4, 4, 5}

# Booleanos
verdadero = True
falso = False

Formato de cadenas:

nombre = "Ana"
edad = 28
mensaje = "Mi nombre es {} y tengo {} años.".format(nombre, edad)

Funciones integradas útiles:

# Obtener la suma de una lista de números
suma_total = sum([1, 2, 3, 4])

# Ordenar una lista
numeros = [3, 1, 4, 1, 5, 9, 2, 6]
numeros_ordenados = sorted(numeros)

Módulo datetime (trabajar con fechas y horas):

import datetime

ahora = datetime.datetime.now()
print("Fecha y hora actual:", ahora)

Manejo de fechas con datetime:

import datetime

fecha_actual = datetime.datetime.now()

# Sumar un día a la fecha actual
nueva_fecha = fecha_actual + datetime.timedelta(days=1)

Uso de f-strings:

nombre = "Carlos"
edad = 35
mensaje = f"Mi nombre es {nombre} y tengo {edad} años."

Funciones de cadenas y listas:

cadena = "Python es genial"
lista = [3, 1, 4, 1, 5]

# Convertir cadena a lista
lista_cadena = list(cadena)

# Convertir lista a cadena
cadena_lista = "".join(lista_cadena)

# Dividir una cadena en una lista
palabras = cadena.split()  # Divide por espacios en blanco

Funciones recursivas (funciones que se llaman a sí mismas):

def recursividad(n):
    if n == 0:
        return 1
    else:
        return n * recursividad(n - 1)

Enumeración inversa con enumerate:

numeros = [10, 20, 30, 40, 50]

for indice, valor in enumerate(reversed(numeros)):
    print("Índice:", len(numeros) - indice - 1, "Valor:", valor)

Uso de enumerate con índices personalizados:

numeros = [10, 20, 30, 40, 50]

for indice, valor in enumerate(numeros, start=1):
    print("Índice:", indice, "Valor:", valor)

Generadores (creación de secuencias de valores de manera eficiente):

def numeros_pares(n):
    for i in range(n):
        if i % 2 == 0:
            yield i

pares_hasta_10 = numeros_pares(10)

Uso de map y filter (funciones para transformar y filtrar secuencias):

numeros = [1, 2, 3, 4, 5]

# Duplicar cada número usando map
duplicados = map(lambda x: x * 2, numeros)

# Filtrar números pares usando filter
pares = filter(lambda x: x % 2 == 0, numeros)

Módulo “os" para trabajar con el sistema operativo:

import os

# Obtener el directorio actual
directorio_actual = os.getcwd()

# Listar archivos en un directorio
archivos = os.listdir(directorio_actual)

Argumentos de línea de comandos (acceso a argumentos pasados al script):

import sys

argumentos = sys.argv
print("Argumentos:", argumentos)

Gestión de archivos JSON:

import json

datos = {"nombre": "Ana", "edad": 28}

# Escribir datos en un archivo JSON
with open("datos.json", "w") as archivo:
    json.dump(datos, archivo)

# Leer datos desde un archivo JSON
with open("datos.json", "r") as archivo:
    datos_leidos = json.load(archivo)

Uso de zip para combinar listas:

nombres = ["Ana", "Juan", "María"]
edades = [28, 35, 22]

# Combinar listas usando zip
personas = list(zip(nombres, edades))

Uso de zip para desempaquetar listas:

nombres = ["Ana", "Juan", "María"]
edades = [28, 35, 22]

# Desempaquetar listas con zip
for nombre, edad in zip(nombres, edades):
    print("Nombre:", nombre, "Edad:", edad)

Trabajo con conjuntos (sets):

conjunto1 = {1, 2, 3, 4, 5}
conjunto2 = {4, 5, 6, 7, 8}

# Unión de conjuntos
union = conjunto1 | conjunto2

# Intersección de conjuntos
interseccion = conjunto1 & conjunto2

# Diferencia de conjuntos
diferencia = conjunto1 - conjunto2

Módulo math para operaciones matemáticas:

import math

# Raíz cuadrada
raiz = math.sqrt(25)

# Valor absoluto
absoluto = math.fabs(-7)

# Función exponencial
exponencial = math.exp(2)

Decoradores de funciones (para modificar o extender el comportamiento de funciones):

def decorador(funcion):
    def wrapper(*args, **kwargs):
        print("Antes de llamar a la función")
        resultado = funcion(*args, **kwargs)
        print("Después de llamar a la función")
        return resultado
    return wrapper

@decorador
def funcion_decorada():
    print("Dentro de la función decorada")

funcion_decorada()

Expresiones regulares (trabajo con patrones en cadenas):

import re

patron = r'\b\w+\b'
texto = "Esto es una prueba de expresiones regulares."

coincidencias = re.findall(patron, texto)

Comprensión de conjuntos:

numeros = [1, 2, 3, 4, 4, 5]

# Crear un conjunto a partir de una lista con comprensión de conjuntos
conjunto_numeros = {numero for numero in numeros}

Expresiones lambda en ordenamiento:

personas = [
    {"nombre": "Ana", "edad": 28},
    {"nombre": "Juan", "edad": 35},
    {"nombre": "María", "edad": 22}
]

# Ordenar personas por edad usando una expresión lambda
personas_ordenadas = sorted(personas, key=lambda x: x["edad"])

Uso de collections para contar elementos:

from collections import Counter

frutas = ["manzana", "banana", "manzana", "naranja", "banana", "manzana"]
conteo_frutas = Counter(frutas)

# Obtener la cantidad de cada fruta
cantidad_manzanas = conteo_frutas["manzana"]

Trabajo con archivos CSV:

import csv

datos = [
    ["Nombre", "Edad"],
    ["Ana", 28],
    ["Juan", 35],
    ["María", 22]
]

# Escribir datos en un archivo CSV
with open("datos.csv", "w", newline="") as archivo:
    escritor = csv.writer(archivo)
    for fila in datos:
        escritor.writerow(fila)

# Leer datos desde un archivo CSV
with open("datos.csv", "r") as archivo:
    lector = csv.reader(archivo)
    for fila in lector:
        print(fila)

Uso de itertools para generar combinaciones y permutaciones:

import itertools

# Generar todas las combinaciones de 2 elementos
combinaciones = itertools.combinations([1, 2, 3], 2)

# Generar todas las permutaciones de 3 elementos
permutaciones = itertools.permutations([1, 2, 3])

Módulo random para generar números aleatorios:

import random

# Generar un número entero aleatorio entre 1 y 100
numero_aleatorio = random.randint(1, 100)

# Elegir un elemento aleatorio de una lista
elemento_aleatorio = random.choice(["rojo", "verde", "azul"])

Uso de defaultdict para manejo de diccionarios:

from collections import defaultdict

frutas = ["manzana", "banana", "manzana", "naranja", "banana", "manzana"]
conteo_frutas = defaultdict(int)

for fruta in frutas:
    conteo_frutas[fruta] += 1

Uso de time para medir el tiempo de ejecución:

import time

inicio = time.time()

# Código que deseas medir

fin = time.time()
tiempo_transcurrido = fin - inicio
print("Tiempo transcurrido:", tiempo_transcurrido, "segundos")

Manejo de argumentos en funciones (argumentos posicionales y argumentos con nombre):

def saludar(nombre, edad):
    print(f"Hola, me llamo {nombre} y tengo {edad} años.")

saludar("Ana", 28)

Funciones de agregación con functools:

import functools

numeros = [1, 2, 3, 4, 5]

# Sumar todos los elementos de la lista
suma_total = functools.reduce(lambda x, y: x + y, numeros)

Uso de any y all para evaluación de condiciones:

numeros = [10, 5, -3, 0]

# Verificar si algún número es negativo
hay_negativos = any(num < 0 for num in numeros)

# Verificar si todos los números son positivos
todos_positivos = all(num > 0 for num in numeros)

Módulo pickle para serialización de objetos:

import pickle

datos = {"nombre": "Ana", "edad": 28}

# Guardar datos en un archivo
with open("datos.pkl", "wb") as archivo:
    pickle.dump(datos, archivo)

# Cargar datos desde un archivo
with open("datos.pkl", "rb") as archivo:
    datos_cargados = pickle.load(archivo)

Gestión de rutas y directorios con pathlib:

from pathlib import Path

ruta = Path("carpeta/archivo.txt")

# Verificar si la ruta existe
existe = ruta.exists()

# Obtener la extensión del archivo
extension = ruta.suffix

Uso de isinstance y issubclass para comprobar tipos:

x = 5

# Verificar si x es un entero
es_entero = isinstance(x, int)

# Verificar si una clase es subclase de otra
class Padre:
    pass

class Hijo(Padre):
    pass

es_subclase = issubclass(Hijo, Padre)

Uso de assert para pruebas de aserción:

x = 10
y = 5

assert x > y, "x no es mayor que y"

Uso de itertools para crear infinitos iterables:

import itertools

# Crear un iterador infinito de números naturales
naturales = itertools.count(start=1)

# Tomar los primeros 5 elementos
primeros_5 = list(itertools.islice(naturales, 5))

Uso de itertools.chain para concatenar iterables:

iterable1 = [1, 2, 3]
iterable2 = [4, 5, 6]

concatenados = list(itertools.chain(iterable1, iterable2))

Uso de functools.partial para crear funciones parciales:

import functools

def potencia(base, exponente):
    return base ** exponente

cuadrado = functools.partial(potencia, exponente=2)
cubo = functools.partial(potencia, exponente=3)

Uso de collections.namedtuple para crear tuplas con nombres de campos:

from collections import namedtuple

Persona = namedtuple("Persona", ["nombre", "edad"])
persona1 = Persona(nombre="Ana", edad=28)

Uso de itertools.groupby para agrupar elementos en un iterable:

datos = [
    {"nombre": "Ana", "grupo": "A"},
    {"nombre": "Juan", "grupo": "B"},
    {"nombre": "María", "grupo": "A"}
]

datos_ordenados = sorted(datos, key=lambda x: x["grupo"])

grupos = itertools.groupby(datos_ordenados, key=lambda x: x["grupo"])

Manejo de codificación y decodificación de bytes:

texto = "¡Hola, mundo!"

# Codificar en bytes
bytes_codificados = texto.encode("utf-8")

# Decodificar bytes a texto
texto_decodificado = bytes_codificados.decode("utf-8")

Uso de filter con funciones de un solo retorno:

numeros = [1, 2, 3, 4, 5]

# Filtrar números pares usando filter y lambda
pares = filter(lambda x: x % 2 == 0, numeros)

Uso de collections.Counter para operaciones de conteo:

from collections import Counter

texto = "programación en Python es genial"

conteo_caracteres = Counter(texto)
caracter_mas_comun = conteo_caracteres.most_common(1)[0]

Uso de functools.lru_cache para caché de resultados de funciones:

import functools

@functools.lru_cache(maxsize=None)
def fib(n):
    if n <= 1:
        return n
    return fib(n - 1) + fib(n - 2)

Uso de map con múltiples iterables:

numeros1 = [1, 2, 3]
numeros2 = [10, 20, 30]

resultados = map(lambda x, y: x * y, numeros1, numeros2)

Trabajo con números complejos:

numero_complejo = 3 + 4j

parte_real = numero_complejo.real
parte_imaginaria = numero_complejo.imag

modulo = abs(numero_complejo)

Uso de asyncio para programación asíncrona:

import asyncio

async def tarea():
    print("Tarea iniciada")
    await asyncio.sleep(2)
    print("Tarea completada")

loop = asyncio.get_event_loop()
loop.run_until_complete(tarea())
loop.close()

Uso de metaprogramación para crear clases dinámicamente:

def crear_clase(nombre, atributos):
    return type(nombre, (object,), atributos)

MiClase = crear_clase("MiClase", {"x": 5, "y": 10})
objeto = MiClase()
print(objeto.x, objeto.y)

Uso de contextlib para crear administradores de contexto personalizados:

from contextlib import contextmanager

@contextmanager
def mi_contexto():
    print("Iniciando contexto")
    yield
    print("Finalizando contexto")

with mi_contexto():
    print("Dentro del contexto")

Uso de decoradores de clase para modificar el comportamiento de métodos:

class DecoradorClase:
    def __init__(self, funcion):
        self.funcion = funcion

    def __call__(self, *args, **kwargs):
        print("Antes de la función")
        resultado = self.funcion(*args, **kwargs)
        print("Después de la función")
        return resultado

@DecoradorClase
def funcion_decorada():
    print("Dentro de la función decorada")

funcion_decorada()

Uso de métodos mágicos para personalizar objetos:

class MiClase:
    def __init__(self, x):
        self.x = x

    def __str__(self):
        return f"MiClase con x = {self.x}"

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

objeto1 = MiClase(5)
objeto2 = MiClase(10)
resultado = objeto1 + objeto2
print(resultado)

Pueder ir al artículo principal:

Códigos Sencillos hechos en Python

Deja un comentario