Programas en Python

Validar una dirección IP

import socket

def es_direccion_ip_valida(ip):
    try:
        # Intenta convertir la dirección IP en una representación binaria de 32 bits.
        socket.inet_aton(ip)
        # Si la conversión es exitosa, la dirección IP es válida y se devuelve True.
        return True
    except socket.error:
        # Si ocurre algún error durante la conversión, se captura la excepción y se devuelve False.
        return False
        
# Solicita al usuario que ingrese una dirección IP.
direccion_ip = input("Ingrese una dirección IP: ")

# Verifica si la dirección IP es válida utilizando la función es_direccion_ip_valida(ip).
if es_direccion_ip_valida(direccion_ip):
    print("Dirección IP válida")
else:
    print("Dirección IP inválida")

Ingrese una dirección IP:  3464536


Dirección IP válida

Imprimir el calendario de un mes y año dado

import calendar

# Solicitar al usuario que ingrese el año y el mes.
año = int(input("Ingrese el año: "))
mes = int(input("Ingrese el mes: "))

# Utilizar la función month() de la biblioteca calendar para imprimir el calendario del mes y año especificados.
print(calendar.month(año, mes))

Ingrese el año:  2024
Ingrese el mes:  5


      May 2024
Mo Tu We Th Fr Sa Su
       1  2  3  4  5
 6  7  8  9 10 11 12
13 14 15 16 17 18 19
20 21 22 23 24 25 26
27 28 29 30 31

Verificar si una cadena es una dirección de correo electrónico válida

import re

def es_direccion_email_valida(email):
    return bool(re.match(r"[^@]+@[^@]+\.[^@]+", email))

email_ingresado = input("Ingrese una dirección de correo electrónico: ")
if es_direccion_email_valida(email_ingresado):
    print("Dirección de correo electrónico válida")
else:
    print("Dirección de correo electrónico inválida")

Ingrese una dirección de correo electrónico:  asburon@gmail.com


Dirección de correo electrónico válida

Generar una contraseña aleatoria con requisitos específicos

import random
import string

def generar_contraseña(longitud, incluir_digitos=True, incluir_caracteres_especiales=True):
    caracteres = string.ascii_letters
    if incluir_digitos:
        caracteres += string.digits
    if incluir_caracteres_especiales:
        caracteres += string.punctuation
    contraseña = ''.join(random.choice(caracteres) for _ in range(longitud))
    return contraseña

longitud_contraseña = 12
print("Contraseña generada:", generar_contraseña(longitud_contraseña))

Contraseña generada: uwqEiQ!Q!NCd

Verificar si una cadena es una URL válida

import re

def es_url_valida(url):
    regex = re.compile(
        r'^(?:http|ftp)s?://'  # Protocolo
        r'(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+(?:[A-Z]{2,6}\.?|[A-Z0-9-]{2,}\.?)|'  # Dominio
        r'localhost|'  # Localhost
        r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}|'  # Dirección IP (IPv4)
        r'\[?[A-F0-9]*:[A-F0-9:]+\]?)'  # Dirección IP (IPv6)
        r'(?::\d+)?'  # Puerto
        r'(?:/?|[/?]\S+)$', re.IGNORECASE)  # Rutas y parámetros opcionales
    return re.match(regex, url) is not None

input_url = input("Ingrese una URL: ")
if es_url_valida(input_url):
    print("URL válida")
else:
    print("URL inválida")

Ingrese una URL:  http://www.google.es


URL válida

Calcula el pago mensual de una hipoteca

def calcular_hipoteca(monto_prestamo, tasa_interes, años):
    # Convertir tasa de interés anual a tasa de interés mensual
    tasa_interes_mensual = (tasa_interes / 100) / 12

    # Convertir años a meses
    meses = años * 12

    # Calcular el pago mensual utilizando la fórmula de la hipoteca
    pago_mensual = (monto_prestamo * tasa_interes_mensual) / (1 - (1 + tasa_interes_mensual)**(-meses))

    return pago_mensual


def main():
    # Solicitar información al usuario
    monto_prestamo = float(input("Ingrese el monto del préstamo: "))
    tasa_interes = float(input("Ingrese la tasa de interés anual (%): "))
    años = int(input("Ingrese el número de años: "))

    # Calcular el pago mensual
    pago_mensual = calcular_hipoteca(monto_prestamo, tasa_interes, años)

    # Mostrar el pago mensual
    print(f"El pago mensual de la hipoteca es: {pago_mensual:.2f}")


if __name__ == "__main__":
    main()

Ingrese el monto del préstamo:  200000
Ingrese la tasa de interés anual (%):  5
Ingrese el número de años:  25


El pago mensual de la hipoteca es: 1169.18

Calcula el cambio a devolver después de una compra

def calcular_cambio(precio, cantidad_recibida):
    # Calcular el cambio
    cambio = cantidad_recibida - precio
    return cambio


def main():
    # Solicitar información al usuario
    precio = float(input("Ingrese el precio del artículo: "))
    cantidad_recibida = float(input("Ingrese la cantidad recibida: "))

    # Calcular el cambio
    cambio = calcular_cambio(precio, cantidad_recibida)

    # Mostrar el cambio
    print(f"El cambio a devolver es: {cambio:.2f}")


if __name__ == "__main__":
    main()

Ingrese el precio del artículo:  636
Ingrese la cantidad recibida:  433


El cambio a devolver es: -203.00

Calcula distancia entre dos ciudades

# Importar la clase Nominatim de la biblioteca geopy.geocoders
from geopy.geocoders import Nominatim
from geopy.distance import geodesic

def calcular_distancia(ciudad1, ciudad2):
    # Crear un objeto Nominatim para geolocalizar ciudades
    geolocalizador = Nominatim(user_agent="my_geocoder")

    # Obtener las coordenadas geográficas de las ciudades
    coordenadas_ciudad1 = geolocalizador.geocode(ciudad1)
    coordenadas_ciudad2 = geolocalizador.geocode(ciudad2)

    # Calcular la distancia entre las ciudades
    distancia = geodesic((coordenadas_ciudad1.latitude, coordenadas_ciudad1.longitude),
                         (coordenadas_ciudad2.latitude, coordenadas_ciudad2.longitude)).kilometers

    return distancia

def main():
    ciudad1 = "New York, USA"
    ciudad2 = "Los Angeles, USA"

    # Calcular la distancia entre las ciudades
    distancia = calcular_distancia(ciudad1, ciudad2)

    # Mostrar la distancia entre las ciudades
    print(f"La distancia entre {ciudad1} y {ciudad2} es de {distancia:.2f} kilómetros.")

if __name__ == "__main__":
    main()

La distancia entre New York, USA y Los Angeles, USA es de 3944.28 kilómetros.

Valida un número de tarjeta de crédito utilizando el algoritmo de Luhn

#Para validar números de tarjetas de crédito, puedes utilizar el algoritmo de Luhn
#Es conocido como el algoritmo de suma de verificación de módulo 10. 
#Este algoritmo verifica la validez de un número de tarjeta de crédito mediante una fórmula matemática.
def validar_tarjeta_credito(numero_tarjeta):

    # Eliminar espacios en blanco y caracteres no numéricos
    numero_tarjeta = ''.join(numero_tarjeta.split())

    if not numero_tarjeta.isdigit():
        return False  # El número de tarjeta debe contener solo dígitos

    # Convertir el número de tarjeta en una lista de dígitos
    digitos = [int(d) for d in numero_tarjeta]

    # Duplicar cada segundo dígito, comenzando desde la derecha
    digitos_duplicados = [(2 * d if i % 2 == len(digitos) % 2 else d) for i, d in enumerate(digitos)]

    # Sumar los dígitos individuales de los números duplicados y no duplicados
    suma_digitos = sum((d // 10 + d % 10) for d in digitos_duplicados)

    # La tarjeta es válida si la suma de los dígitos es divisible por 10
    return suma_digitos % 10 == 0

def main():
    numero_tarjeta = input("Ingrese el número de tarjeta de crédito: ")
    if validar_tarjeta_credito(numero_tarjeta):
        print("El número de tarjeta de crédito es válido.")
    else:
        print("El número de tarjeta de crédito no es válido.")

if __name__ == "__main__":
    main()

Ingrese el número de tarjeta de crédito:  4567234567


El número de tarjeta de crédito no es válido.

Gestión de inventario

def __init__(self, id_producto, nombre, precio, cantidad):
        self.id_producto = id_producto
        self.nombre = nombre
        self.precio = precio
        self.cantidad = cantidad

    def calcular_valor_inventario(self):
        return self.precio * self.cantidad

class Inventario:
    def __init__(self):
        self.productos = []

    def agregar_producto(self, producto):
        self.productos.append(producto)

    def calcular_valor_total_inventario(self):
        valor_total = 0
        for producto in self.productos:
            valor_total += producto.calcular_valor_inventario()
        return valor_total

def main():
    inventario = Inventario()

    # Agregar algunos productos al inventario
    inventario.agregar_producto(Producto(1, "Camiseta", 20.99, 50))
    inventario.agregar_producto(Producto(2, "Pantalón", 39.99, 30))
    inventario.agregar_producto(Producto(3, "Zapatos", 59.99, 20))

    # Calcular el valor total del inventario
    valor_total = inventario.calcular_valor_total_inventario()
    print(f"El valor total del inventario es: ${valor_total:.2f}")

if __name__ == "__main__":
    main()

El valor total del inventario es: $3449.00

Calcula el Índice de Masa Muscular

# Definir la función para calcular el Índice de Masa Corporal (IMC)
def indice_masa_corporal(altura, peso):
    # Redondear el resultado a dos decimales
    return round((peso / altura ** 2), 2)

# Solicitar al usuario que ingrese su altura en metros
altura = float(input("Ingrese su altura en metros: "))

# Solicitar al usuario que ingrese su peso en kilogramos
peso = float(input("Ingrese su peso en kg: "))

# Imprimir mensaje de bienvenida al calculador de IMC
print("Bienvenido al calculador de IMC.")

# Calcular el IMC utilizando la función definida
imc = indice_masa_corporal(altura, peso)

# Imprimir el IMC del usuario
print("Su IMC es: ", imc)

# Determinar la categoría de peso basada en el IMC
if imc <= 18.5:
    print("Usted está bajo de peso.")
elif 18.5 < imc <= 24.9:
    print("Su peso es normal.")
elif 25 < imc <= 29.9:
    print("Usted está sobrepeso.")
else:
    print("Usted está obeso.")

Ingrese su altura en metros:  1.69
Ingrese su peso en kg:  70


Bienvenido al calculador de IMC.
Su IMC es:  24.51
Su peso es normal.

Convierte millas a kilómetros

# Solicitar al usuario que ingrese una distancia en millas
millas = float(input("Ingrese la distancia en millas: "))

# Factor de conversión: 1 milla = 1.60934 kilómetros
factor_de_conversion = 1.60934

# Calcular los kilómetros multiplicando las millas por el factor de conversión
kilometros = millas * factor_de_conversion

# Imprimir el resultado de la conversión
print(f"{millas} millas es igual a {kilometros} kilómetros")

Ingrese la distancia en millas:  5345


5345.0 millas es igual a 8601.9223 kilómetros

Convierte kilómetros a millas

# Solicitar al usuario que ingrese una distancia en kilómetros
kilometros = float(input("Ingrese la distancia en kilómetros: "))

# Factor de conversión: 1 kilómetro = 0.621371 millas
factor_de_conversion = 0.621371

# Calcular las millas multiplicando los kilómetros por el factor de conversión
millas = kilometros * factor_de_conversion

# Imprimir el resultado de la conversión
print(f"{kilometros} kilómetros es igual a {millas} millas")

Ingrese la distancia en kilómetros:  5435


5435.0 kilómetros es igual a 3377.151385 millas