Mostrando las entradas con la etiqueta Python. Mostrar todas las entradas
Mostrando las entradas con la etiqueta Python. Mostrar todas las entradas

miércoles, 15 de febrero de 2023

Python 2 Entorno Virtual

 La importancia de Python 2 en el análisis de datos: cómo se relacionan y la opción de correrlo en entorno virtual


Python 2 es una versión anterior del popular lenguaje de programación Python. Aunque ya no se encuentra en desarrollo activo y ha sido reemplazado por Python 3, Python 2 sigue siendo relevante en ciertos campos, especialmente en el análisis de datos.

Python es uno de los lenguajes de programación más utilizados en el análisis de datos gracias a su amplia gama de bibliotecas y herramientas especializadas. A pesar de la transición a Python 3, muchas bibliotecas y herramientas todavía se ejecutan en Python 2, incluyendo NumPy, Pandas y Matplotlib, que son fundamentales en el análisis de datos.

Además, algunas empresas y organizaciones todavía utilizan Python 2 en sus sistemas y aplicaciones, lo que significa que los desarrolladores necesitan saber cómo trabajar con esta versión del lenguaje.

Por estas razones, es importante para los profesionales del análisis de datos tener conocimientos tanto de Python 2 como de Python 3. Si bien la mayoría de los nuevos proyectos se basan en Python 3, es probable que los desarrolladores encuentren proyectos existentes que aún utilicen Python 2.

En cuanto a la opción de correr Python 2 en un entorno virtual, esto puede ser útil para mantener las bibliotecas y herramientas necesarias para el análisis de datos en una versión específica de Python. Un entorno virtual es un espacio aislado en el que se pueden instalar bibliotecas y herramientas específicas sin afectar el resto del sistema. De esta manera, es posible mantener proyectos separados que requieran diferentes versiones de Python y las bibliotecas asociadas.

Para crear un entorno virtual en Python, se puede utilizar la herramienta "virtualenv". Con virtualenv, se pueden crear y activar diferentes entornos virtuales, cada uno con su propia versión de Python y sus propias bibliotecas y herramientas.

En resumen, aunque Python 2 ya no se encuentra en desarrollo activo y ha sido reemplazado por Python 3, sigue siendo relevante en el análisis de datos gracias a la gran cantidad de bibliotecas y herramientas que aún se ejecutan en Python 2. Además, el uso de un entorno virtual puede ayudar a mantener proyectos separados y asegurar que se utilice la versión correcta de Python y las bibliotecas necesarias para cada proyecto. Por lo tanto, es importante para los profesionales del análisis de datos tener conocimientos tanto de Python 2 como de Python 3, así como de cómo trabajar con entornos virtuales.

 Entorno Virtual de Python 2

 Si desea utilizar Python 2.7 en un ambiente virtual, primero debe asegurarse de haber creado un ambiente virtual con la versión adecuada de Python instalada. Puede hacerlo con el siguiente comando:


virtualenv --python=python2.7 mi_ambiente_virtual


Esto creará un ambiente virtual llamado "mi_ambiente_virtual" con Python 2.7 instalado en él. Luego, para activar el ambiente virtual y utilizar Python 2.7, puede utilizar el siguiente comando:

mi_ambiente_virtual/bin/activate


Una vez activado el ambiente virtual, la versión de Python que esté disponible en ese ambiente será la que se utilice por defecto. Para desactivar el ambiente virtual, puede utilizar el siguiente comando:

deactivate

Es importante destacar que Python 2.7 llegó al final de su vida útil el 1 de enero de 2020 y ya no recibe actualizaciones de seguridad. Se recomienda utilizar una versión más reciente de Python, como Python 3.x.

Asegúrese de tener virtualenv instalado en su sistema. Si no lo tiene instalado, puede instalarlo utilizando pip ejecutando el siguiente comando en la línea de comandos:

pip install virtualenv

Si ya tiene virtualenv instalado, asegúrese de que la ubicación de la carpeta que contiene el archivo ejecutable de virtualenv esté agregada al PATH de su sistema. Esto permitirá que su sistema reconozca el comando virtualenv cuando se ejecute desde la línea de comandos.

Si está utilizando Windows, puede agregar la ubicación de la carpeta virtualenv al PATH siguiendo estos pasos:

a. Haga clic en el botón Inicio y busque "Editar variables de entorno para la cuenta". Seleccione esta opción.

b. Haga clic en el botón "Variables de entorno" en la ventana de Propiedades del sistema.

c. Busque la variable "Path" en la sección Variables de usuario y haga clic en "Editar".

d. Haga clic en "Nuevo" y agregue la ruta a la carpeta que contiene el archivo ejecutable virtualenv.

e. Haga clic en "Aceptar" para guardar los cambios y cierre todas las ventanas.

Si está utilizando un sistema operativo basado en Unix (como Linux o macOS), puede agregar la ubicación de la carpeta virtualenv al PATH editando el archivo ~/.bashrc y agregando la siguiente línea al final del archivo:


    export PATH=$PATH:/path/to/virtualenv/folder

    Asegúrese de reemplazar "/path/to/virtualenv/folder" con la ruta real de la carpeta que contiene el archivo ejecutable de virtualenv. Después de guardar el archivo, reinicie su terminal para que los cambios tengan efecto.

Después de seguir estos pasos, debería poder usar el comando virtualenv sin problemas.

Para instalar Python 2.7 en tu sistema, debes ir al sitio web oficial de Python, https://www.python.org/downloads/release/python-2718/ y descargar el instalador adecuado para tu sistema operativo.

Sin embargo, ten en cuenta que Python 2.7 ha llegado a su fin de vida (EOL) en enero de 2020 y ya no recibe actualizaciones de seguridad ni soporte oficial. Es posible que desees considerar actualizar tu código a Python 3.

En cuanto a tener Python 2 y Python 3 instalados en el mismo sistema no debería ser un problema siempre y cuando los mantengas en ambientes virtuales separados. Puedes crear un ambiente virtual con Python 2.7 usando el comando virtualenv -p python2.7 nombre_de_tu_entorno y luego activarlo con source nombre_de_tu_entorno/bin/activate. Esto te permitirá trabajar con Python 2.7 en ese ambiente virtual sin afectar a otras instalaciones de Python que tengas en tu sistema.

Si tienes ambos Python 2 y Python 3 instalados en tu sistema fuera del ambiente virtual y trabajas principalmente con Python 3, no deberías tener problemas.

Sin embargo, es posible que algunos de tus programas de Python 2 ya no funcionen correctamente, ya que Python 2 se considera obsoleto y ya no se está actualizando. Por lo tanto, se recomienda actualizar cualquier código de Python 2 a Python 3 para asegurar la compatibilidad y estabilidad a largo plazo.

En cualquier caso, si tienes ambas versiones instaladas y deseas trabajar solo con Python 3 fuera del ambiente virtual, simplemente asegúrate de llamar a la versión de Python 3 adecuada cuando lo necesites, utilizando el comando "python3" en lugar de "python".

Para Windows, lo recomendable es descargar el instalador MSI que corresponda a tu sistema operativo, es decir, si tienes una versión de 64 bits de Windows, debes descargar el "Windows x86-64 MSI installer". Si tienes una versión de 32 bits de Windows, debes descargar el "Windows x86 MSI installer".

Ten en cuenta que Python 2.7 ya no recibe soporte y se recomienda utilizar versiones más nuevas de Python. Si vas a trabajar con análisis de datos, es posible que necesites paquetes y bibliotecas específicos, y algunos de ellos pueden no ser compatibles con Python 2.7.

lunes, 13 de febrero de 2023

Abriendo Archivos en Python

Abriendo Archivos en Python

En Python, se pueden abrir diferentes tipos de archivos, incluyendo:

    Archivos de texto (.txt): Son los más simples de abrir y leer en Python. Se pueden leer como una cadena de caracteres y se pueden manipular fácilmente.

    Archivos CSV (.csv): Son un formato de intercambio de datos muy común que permite almacenar datos tabulares en un archivo de texto separado por comas. Se pueden leer y escribir fácilmente en Python usando el módulo csv.

    Archivos Excel (.xlsx): Son un formato de hoja de cálculo muy popular que permite almacenar datos tabulares y gráficos. Se pueden leer y escribir en Python usando el módulo pandas o el módulo openpyxl.

    Archivos JSON (.json): Son un formato de intercambio de datos que permite almacenar datos estructurados en formato de texto plano. Se pueden leer y escribir en Python usando el módulo json.

    Archivos de imágenes (.jpeg, .png, .gif, etc.): Son archivos que contienen imágenes. Se pueden leer y escribir en Python usando el módulo Pillow.

    Archivos de audio (.wav, .mp3, etc.): Son archivos que contienen audio. Se pueden leer y escribir en Python usando el módulo wave o el módulo pydub.

    Archivos de video (.mp4, .avi, etc.): Son archivos que contienen video. Se pueden leer y escribir en Python usando el módulo moviepy o el módulo opencv.

En cuanto a las ventajas de abrir ciertos tipos de archivos, depende de qué se quiera hacer con los datos y qué tipo de datos se manejan. Por ejemplo, si se trabaja con datos tabulares, el formato CSV o Excel es muy adecuado. Si se trabaja con datos estructurados, el formato JSON es una buena opción. Si se trabaja con imágenes o audio, es mejor usar los formatos correspondientes para poder manipular los datos correctamente.

Algunas otras ventajas incluyen:

    El formato CSV es fácil de leer y escribir en Python y es compatible con la mayoría de las aplicaciones de hojas de cálculo, lo que lo hace ideal para el intercambio de datos entre diferentes sistemas.

    El formato Excel es muy flexible y puede manejar una gran cantidad de datos, lo que lo hace adecuado para almacenar y analizar grandes cantidades de información.

    El formato JSON es fácil de leer y escribir y es compatible con una amplia gama de lenguajes de programación, lo que lo hace ideal para el intercambio de datos entre diferentes sistemas.

En general, al elegir un formato de archivo, es importante considerar cuál es el propósito de los datos y qué tipo de manipulación se requiere, para poder elegir el formato adecuado y aprovechar al máximo sus ventajas.
En Python, se pueden abrir archivos de diferentes maneras. Aquí hay dos formas comunes de abrirlos:

    Método "open": Este es el método más común para abrir archivos en Python. Se utiliza de la siguiente manera:

python

f = open("nombre_del_archivo.extensión", "modo", encoding='utf-8')

El primer argumento es el nombre del archivo, incluyendo la extensión, y el segundo argumento es el modo en que se abre el archivo. Hay diferentes modos en que se pueden abrir los archivos, tales como "r" para lectura, "w" para escritura, "a" para agregar y "b" para modo binario. Por ejemplo:

python

f = open("archivo.txt", "r", encoding='utf-8')

Este código abre un archivo llamado "archivo.txt" en modo de lectura.

    Método "with": Este método es una forma más segura de abrir archivos en Python, ya que se asegura de que el archivo se cierre automáticamente después de que se haya utilizado. Se utiliza de la siguiente manera:

python

with open("nombre_del_archivo.extensión", "modo", encoding='utf-8') as f:
    # código para leer o escribir en el archivo

El código dentro del bloque "with" se ejecutará después de que el archivo haya sido abierto y se cerrará automáticamente al final del bloque "with".

Para abrir un archivo CSV en Python puedes usar el módulo csv de la biblioteca estándar de Python. Aquí hay un ejemplo de código que abre un archivo CSV y lo lee en una lista de filas:

import csv

with open('example.csv', 'r', encoding='utf-8') as file:
    reader = csv.reader(file)
    rows = [row for row in reader]

print(rows)

En este ejemplo, se abre el archivo example.csv en modo de lectura ('r') y se especifica el encoding UTF-8 (encoding='utf-8') para garantizar que se puedan leer correctamente los caracteres especiales. Luego, se usa el objeto csv.reader para leer el archivo y guardar cada fila en una lista rows.


Puedes utilizar el módulo argparse en Python para leer argumentos en línea de comando y luego acceder a ellos desde el código. Aquí hay un ejemplo de código que permite leer un nombre de archivo como argumento en la línea de comando:

python

import argparse

parser = argparse.ArgumentParser()
parser.add_argument("filename", help="the name of the file to be opened")
args = parser.parse_args()

filename = args.filename

try:
    with open(filename, "r") as file:
        contents = file.read()
        print(contents)
except FileNotFoundError:
    print("File not found")

Puedes llamar este programa desde la terminal con el siguiente comando:

python program.py file.txt

En este ejemplo, program.py es el nombre del archivo que contiene el código y file.txt es el nombre del archivo que se abrirá.

sábado, 11 de febrero de 2023

Los Algoritmos de Enrutamiento

Los Algoritmos de Enrutamiento

Los algoritmos de enrutamiento

Los algoritmos de enrutamiento son una parte esencial de la tecnología de redes de computadoras. Estos algoritmos permiten a los routers en una red transmitir paquetes de información de un lugar a otro de manera eficiente y fiable. Desde sus primeras formas hasta las actuales, los algoritmos de enrutamiento han evolucionado para mejorar la seguridad, la escalabilidad y la eficiencia de las redes.

En los inicios de las redes de computadoras, los algoritmos de enrutamiento eran muy simples y se basaban en la idea de que todos los routers conocían la información completa sobre la red y utilizaban esa información para decidir cómo enrutar los paquetes. Con el tiempo, sin embargo, las redes se volvieron más grandes y complejas, y fue necesario desarrollar algoritmos más avanzados que pudieran manejar la creciente cantidad de información.

A lo largo de la historia de los algoritmos de enrutamiento, se han desarrollado muchos diferentes enfoques y técnicas para el enrutamiento de paquetes. Desde algoritmos de enrutamiento estáticos, que requieren la configuración manual de las rutas, hasta algoritmos de enrutamiento dinámicos, que permiten a los routers adaptarse a los cambios en la red de manera automática. Cada enfoque tiene sus propias fortalezas y debilidades, y la elección del algoritmo adecuado depende de muchos factores, como la topología de la red, el tamaño de la red y los requisitos de seguridad.

Uno de los algoritmos de enrutamiento más comunes y ampliamente utilizados es el Protocolo de Información de Enrutamiento (RIP, por sus siglas en inglés), que utiliza un enfoque basado en distancias para enrutar los paquetes. Otro algoritmo popular es el Protocolo de Enrutamiento de Interior de Gateway (IGRP), que se utiliza en redes de tamaño mediano y utiliza una combinación de información basada en distancias y en tiempo.

A medida que las redes continúan evolucionando y creciendo, es probable que los algoritmos de enrutamiento también continúen evolucionando y mejorando. En el futuro, es posible que veamos nuevos enfoques y técnicas que permitan a las redes ser aún más eficientes y seguras.

Los algoritmos de enrutamiento son un componente clave de los sistemas de comunicación de datos y redes de computadoras. Estos algoritmos determinan la forma en que los paquetes de datos son enrutados a través de la red hacia su destino final. Desde su creación en los años 60 hasta la actualidad, los algoritmos de enrutamiento han evolucionado mucho y han sido optimizados para satisfacer las demandas cada vez mayores de las redes.

Hay muchos tipos diferentes de algoritmos de enrutamiento, cada uno con sus propias fortalezas y debilidades. Algunos de los algoritmos más populares incluyen el Protocolo de Información de Enrutamiento (RIP), el Protocolo de Enrutamiento OSPF (Open Shortest Path First) y el Protocolo de Enrutamiento BGP (Border Gateway Protocol). Cada uno de estos algoritmos utiliza diferentes técnicas para determinar el mejor camino a través de la red, y es importante seleccionar el algoritmo adecuado en función de las necesidades específicas de la red.

Además de la selección del algoritmo adecuado, también es importante tener en cuenta otros factores a la hora de implementar un sistema de enrutamiento, como la escalabilidad, la robustez y la flexibilidad. Estos factores pueden influir en la capacidad de la red para responder a los cambios y adaptarse a las demandas cambiantes.

Los algoritmos de enrutamiento son un aspecto crítico de cualquier red y su importancia no puede ser subestimada. Desde su creación en los años 60 hasta la actualidad, los algoritmos de enrutamiento han evolucionado y han sido optimizados para satisfacer las necesidades cada vez mayores de las redes. Aunque hay muchos tipos diferentes de algoritmos de enrutamiento, es importante seleccionar el adecuado en función de las necesidades específicas de la red y tener en cuenta otros factores importantes como la escalabilidad, la robustez y la flexibilidad.

Si quieres saber más sobre los algoritmos de enrutamiento y cómo pueden afectar a tu red, ¡sigue leyendo! Estamos seguros de que encontrarás mucha información valiosa y útil.


Los algoritmos de enrutamiento surgieron con el desarrollo de redes de computadoras y la necesidad de transmitir paquetes de datos de manera eficiente a través de ellas. La primera red de computadoras fue ARPANET, una red de investigación financiada por el Departamento de Defensa de los Estados Unidos. Fue creada en los años 60 y se considera la precursora de la Internet actual.

En los primeros días de ARPANET, los paquetes de datos eran enrutados de manera estática a través de la red, es decir, cada nodo tenía una tabla predefinida que indicaba hacia dónde debían enviarse los paquetes. Este método era ineficiente, ya que no permitía la adaptación a cambios dinámicos en la topología de la red.

Fue entonces cuando se desarrollaron los primeros algoritmos de enrutamiento dinámico. Uno de los primeros fue el Routing Information Protocol (RIP), desarrollado en 1981. RIP es un algoritmo de enrutamiento basado en vector distancia, que utiliza una métrica para calcular la distancia a un destino determinado. La métrica utilizada por RIP es el número de saltos, o hops, necesarios para llegar a un destino.

A medida que las redes de computadoras fueron evolucionando, surgieron otros algoritmos de enrutamiento, como Open Shortest Path First (OSPF), Interior Gateway Routing Protocol (IGRP) y Border Gateway Protocol (BGP). Estos algoritmos utilizan métricas más avanzadas y permiten una mayor flexibilidad en la enrutación de los paquetes.

En resumen, la historia de los algoritmos de enrutamiento se ha desarrollado a lo largo de varias décadas, desde los primeros días de ARPANET hasta los algoritmos de enrutamiento modernos que utilizan técnicas más avanzadas para enrutar paquetes de datos a través de las redes. La selección del algoritmo de enrutamiento adecuado depende de muchos factores, como la topología de la red, las necesidades de enrutamiento, la escalabilidad y la seguridad.

El primer algoritmo de enrutamiento que se creó fue el Gateway Discovery Protocol (GDP), desarrollado por la National Physical Laboratory (NPL) en los años 1960. Este algoritmo fue utilizado en el sistema de computación NPL Data Network, que fue uno de los primeros sistemas de red de paquetes en el mundo.

Sin embargo, el algoritmo GDP no fue ampliamente utilizado fuera de NPL y fue reemplazado por otros algoritmos más avanzados y eficientes a medida que la tecnología de las redes de computadoras evolucionaba.

Los algoritmos de enrutamiento son un componente fundamental de los sistemas de comunicación de redes, ya que permiten a los dispositivos de red interconectados encontrar y seleccionar la ruta más eficiente para transmitir paquetes de datos a su destino.

Hay varios tipos de algoritmos de enrutamiento, cada uno con características únicas que los hacen adecuados para diferentes tipos de redes y requisitos de rendimiento. Algunas de las características más importantes de los algoritmos de enrutamiento incluyen:

  •     Escalabilidad: la capacidad de un algoritmo para adaptarse y funcionar de manera eficiente en redes de diferentes tamaños y complejidades.
  •     Fiabilidad: la capacidad de un algoritmo para mantener la integridad de los datos y asegurar la entrega confiable de los paquetes a su destino.
  •     Convergencia: la capacidad de un algoritmo para actualizar y mantener la información de enrutamiento en tiempo real en una red en constante cambio.
  •     Eficiencia: la capacidad de un algoritmo para utilizar recursos de red de manera eficiente y minimizar la congestión de la red.


    Simplicidad: la capacidad de un algoritmo para ser fácil de implementar y mantener en una red en constante evolución.

La elección del algoritmo de enrutamiento adecuado depende de muchos factores, incluyendo el tamaño y la topología de la red, los requisitos de rendimiento y la disponibilidad de recursos de hardware y software. Es importante seleccionar un algoritmo de enrutamiento que cumpla con los requisitos específicos de su red para garantizar una conectividad fiable y eficiente.

Existen varios factores que pueden influir en la elección del algoritmo de enrutamiento adecuado para una red específica. Algunos de estos factores incluyen:

  •     Tamaño de la red: El tamaño de la red es un factor importante en la elección del algoritmo de enrutamiento, ya que los algoritmos diferentes pueden tener un rendimiento diferente en redes de diferentes tamaños.
  •     Topología de la red: La topología de la red, es decir, la forma en que los dispositivos están conectados, también puede afectar la elección del algoritmo de enrutamiento. Por ejemplo, algunos algoritmos de enrutamiento funcionan mejor en redes de estrella, mientras que otros son más adecuados para redes en malla o anillo.
  •     Costo: El costo de una ruta puede ser determinado por varios factores, como la distancia, la velocidad de la conexión o la congestión del tráfico. Algunos algoritmos de enrutamiento pueden tener un enfoque en el costo, mientras que otros pueden tener un enfoque en la rapidez.
  •     Fiabilidad: La fiabilidad de una ruta es un factor importante en la elección de un algoritmo de enrutamiento. Algunos algoritmos de enrutamiento pueden proporcionar una alternativa en caso de falla de una ruta, mientras que otros no lo hacen.
  •     Escalabilidad: La escalabilidad es un factor importante, especialmente en redes de gran tamaño, ya que los algoritmos de enrutamiento deben ser capaces de manejar el crecimiento de la red sin comprometer el rendimiento.
  •     Seguridad: La seguridad también es un factor importante en la elección de un algoritmo de enrutamiento, ya que los algoritmos diferentes pueden tener diferentes niveles de protección contra ataques y amenazas.


Los algoritmos de actualización de enrutamiento son algoritmos que utilizan los routers para intercambiar información sobre la red y determinar la mejor ruta para enviar paquetes a su destino. Algunos de los algoritmos de actualización de enrutamiento más comunes son:

    Routing Information Protocol (RIP): Este algoritmo se utiliza en redes pequeñas y es uno de los algoritmos más antiguos. Utiliza una versión antigua del protocolo de enrutamiento y no es muy escalable.

    Open Shortest Path First (OSPF): Este algoritmo es utilizado en redes de mayor tamaño y se considera más avanzado que el RIP. Utiliza un algoritmo de enrutamiento basado en estado de enlace para determinar la mejor ruta.

    Border Gateway Protocol (BGP): Este algoritmo es utilizado en Internet y es el algoritmo de enrutamiento más avanzado. Es muy escalable y se utiliza para intercambiar información entre los proveedores de Internet.

    Enhanced Interior Gateway Routing Protocol (EIGRP): Este algoritmo es una versión mejorada del Interior Gateway Routing Protocol (IGRP) y se utiliza en redes de mayor tamaño. EIGRP combina características de OSPF y IGRP para proporcionar un algoritmo de enrutamiento más avanzado.

Es importante elegir el algoritmo de actualización de enrutamiento adecuado para su red en función de su tamaño y requisitos específicos.
Alan Esparza
cuales otros algoritmos de enrutamiento existen

Además de los algoritmos mencionados anteriormente, existen otros algoritmos de enrutamiento que se utilizan en diferentes tipos de redes y aplicaciones. Aquí hay algunos otros algoritmos de enrutamiento comunes:

    Interior Gateway Routing Protocol (IGRP): Este es un algoritmo de enrutamiento utilizado en redes de tamaño mediano y es un predecesor de EIGRP.

    Distance-Vector Multicast Routing Protocol (DVMRP): Este es un algoritmo de enrutamiento multicast que se utiliza para enrutar paquetes de una fuente a múltiples destinos.

    Routing Protocol for Low-Power and Lossy Networks (RPL): Este es un algoritmo de enrutamiento diseñado para redes de baja potencia y con pérdidas, como las redes de Internet de las cosas (IoT).

    Wireless Routing Protocol (WRP): Este es un algoritmo de enrutamiento específico para redes inalámbricas que se utiliza para determinar la mejor ruta para el tráfico inalámbrico.

    Ad-hoc On-Demand Distance Vector Routing (AODV): Este es un algoritmo de enrutamiento en tiempo real para redes ad-hoc que se utiliza para enrutar paquetes en una red sin una infraestructura central.

Estos son solo algunos ejemplos de los algoritmos de enrutamiento disponibles. El mejor algoritmo para su red dependerá de sus requisitos específicos, como el tamaño de la red, la cantidad de tráfico, la frecuencia de actualización de la tabla de enrutamiento, entre otros factores.


Además de los algoritmos de enrutamiento mencionados anteriormente (RIP, OSPF, BGP, EIGRP), existen otros algoritmos de enrutamiento que incluyen:

  •     IS-IS (Intermediate System to Intermediate System)
  •     IGRP (Interior Gateway Routing Protocol)
  •     EGP (Exterior Gateway Protocol)
  •     DVMRP (Distance Vector Multicast Routing Protocol)
  •     PIM (Protocol Independent Multicast)
  •     CBT (Core Based Trees)
  •     HSRP (Hot Standby Router Protocol)
  •     NHRP (Next Hop Resolution Protocol)
  •     VRRP (Virtual Router Redundancy Protocol)
  •     GLBP (Gateway Load Balancing Protocol)


Estos son solo algunos de los muchos algoritmos de enrutamiento que existen. Cada uno de ellos tiene características únicas y se utiliza en diferentes situaciones de red.
Hay muchos más algoritmos de enrutamiento que no mencioné, y es posible que algunos nuevos se desarrollen con el tiempo. Además, es posible que algunos algoritmos se fusionen o evolucionen para formar algoritmos más avanzados. En general, el número de algoritmos de enrutamiento disponibles es dinámico y depende de los desarrollos tecnológicos y las necesidades de la red.
Alan Esparza
enq ue lenguaje de programacion fue escrito este algoritmo Routing Information Protocol (RIP)

El protocolo de información de enrutamiento (RIP, por sus siglas en inglés) generalmente se implementa en lenguajes de programación de bajo nivel como C o C++. Sin embargo, es posible que algunas implementaciones de RIP se hayan escrito en otros lenguajes de programación. Es importante tener en cuenta que RIP es un protocolo de nivel de red y no es un programa en sí mismo, sino más bien un conjunto de reglas y procedimientos para el intercambio de información de enrutamiento. Por lo tanto, su implementación puede variar de un sistema a otro.

Puedo brindarte un ejemplo de código para una implementación simple de RIP en C. Este ejemplo es solo una muestra y puede variar en función de la implementación específica de RIP que desees utilizar:


c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <netinet/in.h>
#include <netdb.h>
#include <sys/socket.h>
#include <unistd.h>

#define PORT_NUMBER 520
#define MAX_LENGTH 1024
#define INFINITY 16

// Estructura para almacenar la información de la tabla de enrutamiento
struct route_entry {
    char address[16];
    int cost;
    char next_hop[16];
};

// Estructura para almacenar los paquetes RIP
struct rip_packet {
    int command;
    int version;
    int num_entries;
    struct route_entry entries[25];
};

// Inicializa la tabla de enrutamiento
void init_route_table(struct route_entry *table) {
    int i;

    // Inicializa todas las entradas con un costo infinito
    for (i = 0; i < 25; i++) {
        strcpy(table[i].address, "0.0.0.0");
        table[i].cost = INFINITY;
        strcpy(table[i].next_hop, "0.0.0.0");
    }
}

// Imprime la tabla de enrutamiento
void print_route_table(struct route_entry *table) {
    int i;

    printf("Destination\tCost\tNext Hop\n");
    for (i = 0; i < 25; i++) {
        if (table[i].cost != INFINITY) {
            printf("%s\t\t%d\t%s\n", table[i].address, table[i].cost, table[i].next_hop);
        }
    }
}

// Procesa los paquetes recibidos y actualiza la tabla de enrutamiento
void process_rip_packet(struct rip_packet *packet, struct route_entry *table, char *src_ip) {
    int i, j;
    int update;

    for (i = 0; i < packet->num_entries; i++) {
        update = 0;

        // Busca la entrada correspondiente en la tabla de enrutamiento
        for (j = 0; j < 25; j++) {
            if (strcmp(packet->entries[i].address, table[j].address) == 0) {
                update = 1;

                // Si el costo es menor, actualiza la entrada
                if (packet->entries[i].cost + 1 < table[j].cost) {
table[j].cost = packet->entries[i].cost + 1;
strcpy(table[j].next_hop, src_ip);
}

css

            break;
        }
    }

    // Si no se encontró la entrada, agrega una nueva
    if (!update) {
        for (j = 0; j < 25; j++) {
            if (table[j].cost == INFINITY) {
                strcpy(table[j].address, packet->entries[i].address);
                table[j].cost = packet->entries[i].cost + 1;
                strcpy(table[j].next_hop, src_ip);
                break;
            }
        }
    }
}

}

int main(int argc, char *argv[]) {
int sockfd;
int n;
int i;
struct sockaddr_in serv_addr, cli_addr;
socklen_t clilen;
char buffer[MAX_LENGTH];
struct rip_packet packet;
struct route_entry table[25];

scss

// Inicializa la tabla de enrutamiento
init_route_table(table);

// Crea un socket UDP
sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd < 0) {
    perror("ERROR opening socket");
    exit(1);
}

// Configura la dirección del servidor
memset((char *) &serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
serv_addr.sin_port = htons(PORT_NUMBER);

// Enlaza el socket a la dirección del servidor
if (bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0) {
    perror("ERROR on binding");
    exit(1);
}

// Espera y procesa los paquetes recibidos
while (1) {
    clilen = sizeof(cli_addr);
    n = recvfrom(sockfd, buffer, MAX_LENGTH - 1, 0, (struct sockaddr *) &cli_addr, &clilen);
    if (n < 0) {
        perror("ERROR reading from socket");
        exit(1);
    }

    // Copia el paquete recibido en la estructura rip_packet
    memcpy(&packet, buffer, sizeof(struct rip_packet));

    // Procesa el paquete y actualiza la tabla de enrutamiento
    process_rip_packet(&packet, table, inet_ntoa(cli_addr.sin_addr));

    // Imprime la tabla de enrutamiento
    print_route_table(table);
}

close(sockfd);

return 0;

}


 Aquí está el código de una implementación básica del protocolo de enrutamiento RIP en Python:

python

import socket

class Router:
    def __init__(self, address):
        self.address = address
        self.routes = {}
        self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        self.socket.bind(("0.0.0.0", 520))
        
    def start(self):
        while True:
            data, (ip, port) = self.socket.recvfrom(1024)
            # si el mensaje recibido es un mensaje RIP
            if data[0:2] == b"\x02\x02":
                # actualiza la tabla de enrutamiento
                self.update_routes(data[4:], ip)
                # reenvia el mensaje a todos los vecinos
                self.send_rip(ip)
    
    def update_routes(self, data, sender):
        offset = 0
        while offset < len(data):
            family, tag, address, mask, nexthop, metric = struct.unpack("!HB 4s 4s 4s H", data[offset:offset+20])
            metric += 1
            if metric > 16:
                break
            prefix = address & mask
            if prefix not in self.routes or self.routes[prefix][1] > metric:
                self.routes[prefix] = (nexthop, metric)
            offset += 20
    
    def send_rip(self, sender):
        message = b"\x02\x02\x00\x00"
        for prefix, (nexthop, metric) in self.routes.items():
            if nexthop != sender:
                address = int.from_bytes(prefix, "big")
                mask = int.from_bytes(b"\xff" * 4, "big")
                while (address & mask) != prefix:
                    mask = (mask >> 1) | 0x80000000
                message += struct.pack("!HB 4s 4s 4s H", 2, 0, prefix, mask, nexthop, metric)
        self.socket.sendto(message, ("224.0.0.9", 520))

Este código crea una clase Router que representa un router en la red. La clase tiene un método start que es un bucle infinito que recibe mensajes de otros routers y los procesa. Si el mensaje recibido es un mensaje RIP, se actualiza la tabla de enrutamiento y se reenvía el mensaje a todos los vecinos. El método update_routes procesa el contenido del mensaje RIP y actualiza la tabla de enrutamiento. El método send_rip reenvía el mensaje RIP a todos los vecinos.

martes, 7 de febrero de 2023

Cómo Analizar Datos con Pandas en Python: Una Guía Práctica

Cómo Analizar Datos con Pandas en Python: Una Guía Práctica

Analisis de Datos Imotechnologics


Pandas es una de las bibliotecas de Python más populares y útiles para el análisis de datos. Con una sintaxis clara y fácil de usar, Pandas te permite realizar una amplia gama de tareas de análisis de datos, desde la limpieza y la manipulación hasta la visualización y la exportación.

En este artículo, exploraremos cómo utilizar Pandas para analizar datos en Python. En primer lugar, cubriremos cómo leer datos en un DataFrame, el objeto central de Pandas. Después, verás cómo utilizar los métodos head, tail, info y shape para explorar tus datos.

Una vez que hayas comprendido cómo funciona el DataFrame, te mostraré cómo crear gráficos atractivos y visualmente impactantes con Pandas y Matplotlib. Con estos gráficos, podrás ver patrones y tendencias en tus datos que serían difíciles de detectar de otra manera.

Por último, cubriremos cómo exportar tus datos a diferentes formatos de archivo, incluyendo CSV, Excel, JSON, HTML y otros. Con esta habilidad, podrás compartir tus resultados con colegas o guardarlos para un uso posterior.

En resumen, si estás buscando una manera fácil y eficiente de analizar tus datos en Python, definitivamente deberías darle una oportunidad a Pandas. Con su sintaxis intuitiva y su amplia gama de características, Pandas te ayudará a hacer más en menos tiempo.

Un DataFrame es una estructura de datos en dos dimensiones que se utiliza en el análisis de datos y la manipulación de datos en Python. Es una estructura de datos que se asemeja a una hoja de cálculo o una tabla en una base de datos. Cada columna en un DataFrame representa una variable y cada fila representa una observación.

En Python, el paquete pandas es una herramienta popular para trabajar con DataFrames. Un DataFrame en pandas se puede crear a partir de diferentes fuentes de datos, como archivos CSV, hojas de cálculo de Excel, bases de datos relacionales, entre otros. Una vez creado, el DataFrame se puede manipular, procesar y visualizar de diferentes maneras para obtener información útil y responder preguntas sobre los datos.

Si quieres analizar un archivo CSV lo mejor es empezar en Python y leer el archivo en un DataFrame de pandas. Pandas es una biblioteca popular para el análisis de datos en Python, y proporciona una amplia variedad de funciones para manipular y analizar datos en un DataFrame.

Puedes leer un archivo CSV en un DataFrame de pandas con la función read_csv:

python

import pandas as pd

df = pd.read_csv('ruta/al/archivo.csv')

Una vez que tienes el archivo leído en un DataFrame, puedes empezar a explorar y manipular los datos utilizando funciones y métodos de pandas. Por ejemplo, puedes obtener información sobre el DataFrame con df.info(), ver las primeras filas con df.head(), o seleccionar columnas específicas con df['columna'].

Desde aquí, puedes continuar con tareas más complejas de análisis de datos, como la limpieza de datos, la transformación de variables, la agrupación de datos, la visualización de datos, etc. Todo depende de tus objetivos y tus datos.

Puedes implementar tail(), df['columna'] y df.info() de la siguiente manera:

# Mostrar las últimas 5 filas
print(df.tail(5))

# Seleccionar una columna específica
print(df['columna'])

# Obtener información sobre el DataFrame
print(df.info())

Cabe mencionar que debes reemplazar 'columna' por el nombre de la columna que deseas seleccionar. También puedes seleccionar más de una columna específica utilizando una lista de nombres de columnas, por ejemplo:

# Seleccionar varias columnas específicas
print(df[['columna_1', 'columna_2']])

El método shape en un DataFrame de pandas devuelve una tupla que indica las dimensiones del DataFrame. La primera entrada de la tupla representa el número de filas y la segunda entrada representa el número de columnas. Por ejemplo:

print(df.shape)

Puedes imprimir solo la primera fila de un DataFrame de la siguiente manera:

print(df.iloc[0])

El método iloc de pandas permite acceder a las filas de un DataFrame de forma posicional. La entrada entre paréntesis es un índice entero que indica la fila que deseas seleccionar. En este caso, 0 indica la primera fila.

También puedes imprimir la primera fila utilizando el método head con un argumento de 1:

print(df.head(1))

pandas tiene una integración nativa con la librería de visualización de datos matplotlib, lo que permite crear una amplia variedad de gráficos y visualizaciones de datos de manera sencilla y eficiente.

Puedes crear un gráfico a partir de un DataFrame de la siguiente manera:

python

import pandas as pd
import matplotlib.pyplot as plt

df = pd.read_csv('nba.csv')
df.plot(kind='bar')
plt.show()

El argumento kind especifica el tipo de gráfico que deseas crear. En este caso, 'bar' indica que deseas crear un gráfico de barras. Existen muchos otros tipos de gráficos disponibles en pandas, como líneas, puntos, histogramas, entre otros.

También puedes personalizar los gráficos y ajustar sus características, como el título, los ejes, la leyenda, entre otros. La documentación de pandas y matplotlib es una excelente fuente de información para aprender más sobre la creación de gráficos con pandas.

Código para crear gráficos en pandas con matplotlib:


    Gráfico de barras:

python

import pandas as pd
import matplotlib.pyplot as plt

# Leemos un archivo CSV y creamos un DataFrame
df = pd.read_csv('nba.csv')

# Agrupamos los datos por equipo y calculamos el promedio de la columna "points"
grouped_df = df.groupby('team').mean()

# Creamos un gráfico de barras de los promedios de puntos por equipo
grouped_df['points'].plot(kind='bar')

# Agregamos un título al gráfico
plt.title('Promedio de puntos por equipo en la NBA')

# Mostramos el gráfico
plt.show()

    Gráfico de líneas:

python

import pandas as pd
import matplotlib.pyplot as plt

# Leemos un archivo CSV y creamos un DataFrame
df = pd.read_csv('nba.csv')

# Agrupamos los datos por año y calculamos el promedio de la columna "points"
grouped_df = df.groupby(df['year']).mean()

# Creamos un gráfico de líneas de los promedios de puntos por año
grouped_df['points'].plot(kind='line')

# Agregamos un título al gráfico
plt.title('Promedio de puntos por año en la NBA')

# Mostramos el gráfico
plt.show()

    Gráfico de dispersión:

python

import pandas as pd
import matplotlib.pyplot as plt

# Leemos un archivo CSV y creamos un DataFrame
df = pd.read_csv('nba.csv')

# Creamos un gráfico de dispersión de los puntos vs las asistencias
plt.scatter(df['points'], df['assists'])

# Agregamos un título al gráfico
plt.title('Dispersión de puntos vs asistencias en la NBA')

# Agregamos etiquetas a los ejes
plt.xlabel('Puntos')
plt.ylabel('Asistencias')

# Mostramos el gráfico
plt.show()

    Histograma:

python

import pandas as pd
import matplotlib.pyplot as plt

# Leemos un archivo CSV y creamos un DataFrame
df = pd.read_csv('nba.csv')

# Creamos un histograma de la columna "points"
df['points'].plot(kind='hist', bins=20)

# Agregamos un título al gráfico
plt.title('Distribución de puntos en la NBA')

# Mostramos el gráfico
plt.show()

    Gráfico de pastel:

python

import pandas as pd
import matplotlib.pyplot as plt

# Leemos un archivo CSV y creamos un DataFrame
df = pd.read_csv('nba.csv')

# Agrupamos los datos por posición y calculamos la cantidad de jugadores por posición
grouped_df = df.groupby('position').count()

# Creamos un gráfico de pastel de la cantidad de jugadores por posición
grouped_df['name'].plot(kind='pie', autopct='%1.1f%%')

# Agregamos un título al gráfico
plt.title('Porcentaje de jugadores por posición en la NBA')

# Mostramos el gráfico
plt.show()

Estos son solo algunos ejemplos de los gráficos que se pueden crear con pandas y matplotlib. Hay muchas otras opciones y personalizaciones disponibles para cada tipo de gráfico. La documentación de pandas y matplotlib es una excelente fuente de información para aprender más.

Documentación para pandas y matplotlib:


    pandas: https://pandas.pydata.org/docs/

Secciones de Interes:

    Introducción a pandas

    Manipulación de datos con pandas

    Agrupamiento y agregación de datos con pandas

    Gráficos con pandas

    matplotlib: https://matplotlib.org/stable/contents.html

Secciones de Interes matploit:

    Introducción a matplotlib
    Gráficos básicos con matplotlib
    Personalización de gráficos con matplotlib
    Ejemplos de gráficos con matplotlib.
 

Existe un comando en pandas que te permite exportar un DataFrame a diferentes formatos, incluyendo CSV, Excel, JSON, HTML y otros.
 

Cómo exportar un DataFrame a un archivo CSV:


python

import pandas as pd

# Leemos un archivo CSV y creamos un DataFrame
df = pd.read_csv('nba.csv')

# Exportamos el DataFrame a un archivo CSV
df.to_csv('nba_export.csv', index=False)

El parámetro index se utiliza para especificar si se debe incluir o no una columna de índice en el archivo exportado. Establecer index en False significa que no se incluirá una columna de índice en el archivo exportado.

Para exportar a otros formatos, solo tienes que cambiar el método to_csv por el método correspondiente al formato que deseas exportar. Por ejemplo, para exportar a Excel, puedes usar el método to_excel.

pandas te permite exportar un DataFrame a los siguientes formatos de archivo:

    CSV (Comma Separated Values) - to_csv
    Excel - to_excel
    JSON (JavaScript Object Notation) - to_json
    HTML - to_html
    Parquet - to_parquet
    HDF5 - to_hdf
    SAS - to_sas
    SQL - to_sql
    Stata - to_stata
    SAS - to_sas
    msgpack - to_msgpack
    Fixed-Width Format - to_fwf
    Local clipboard - to_clipboard

Es importante tener en cuenta que para exportar a algunos de estos formatos es posible que debas instalar librerías adicionales. Por ejemplo, para exportar a Excel debes instalar openpyxl, y para exportar a Stata debes instalar stata_dta.

pandas no te permite exportar directamente a PNG. Sin embargo, puedes crear gráficos con pandas y matplotlib y luego guardarlos en formato PNG utilizando el método savefig de matplotlib.

Cómo crear un gráfico de barras y guardarlo en formato PNG

import pandas as pd
import matplotlib.pyplot as plt

# Leemos un archivo CSV y creamos un DataFrame
df = pd.read_csv('nba.csv')

# Creamos un gráfico de barras con pandas
df.plot(kind='bar', x='player', y='points', color='blue')

# Guardamos el gráfico en formato PNG
plt.savefig('nba_bargraph.png', bbox_inches='tight')

En este ejemplo, primero importamos pandas y matplotlib.pyplot y luego creamos un DataFrame a partir de un archivo CSV. Después, usamos el método plot de pandas para crear un gráfico de barras. Finalmente, guardamos el gráfico en formato PNG utilizando el método savefig de matplotlib.pyplot.

domingo, 5 de febrero de 2023

Calculadora de Bases Numericas en Python

 Calculadora de Bases Numericas en Python

Calculadora de Bases Numericas en Python

"En el mundo de la tecnología y la informática, trabajar con números es una tarea diaria. Sin embargo, a veces es necesario convertir entre diferentes sistemas numéricos para realizar tareas específicas o para interactuar con otros sistemas. Es aquí donde entra en juego el conversor de bases numéricas.

Las bases numéricas son sistemas de representación de números que se basan en una secuencia de dígitos y un conjunto de símbolos. Algunas de las bases numéricas más comunes son el sistema decimal (base 10), el sistema binario (base 2), el sistema octal (base 8) y el sistema hexadecimal (base 16). Cada una de estas bases tiene sus propias aplicaciones y usos específicos.

El conversor de bases numéricas es una herramienta que permite convertir números de un sistema numérico a otro, lo que hace posible la interacción entre diferentes sistemas y plataformas. Esta herramienta es esencial para cualquier persona que trabaje en el campo de la tecnología o la informática, ya que permite realizar tareas más eficientemente y evita errores humanos al convertir manualmente números de un sistema a otro.

Este post de programación en Python presenta un conversor de bases numéricas que puede convertir números entre binario, octal, decimal y hexadecimal. El programa combina conversiones previas como binario a decimal, octal a decimal y hexadecimal a decimal para lograr conversiones entre cualquier base. El conversor se ahorra el programar varias funciones al usar la base decimal como intermediaria. Además, se incluyen pruebas unitarias y un ejemplo de uso.

Funciones de conversión

Todas las conversiones de números las tenemos en un archivo que vamos a importar en el archivo principal:

# Función que regresa el verdadero valor hexadecimal.
# Por ejemplo, si recibe un 15 devuelve f, y si recibe un número menor a 10, devuelve el número sin modificarlo
def obtener_caracter_hexadecimal(valor):
    # Lo necesitamos como cadena
    valor = str(valor)
    equivalencias = {
        "10": "a",
        "11": "b",
        "12": "c",
        "13": "d",
        "14": "e",
        "15": "f",
    }
    if valor in equivalencias:
        return equivalencias[valor]
    else:
        return valor


def decimal_a_hexadecimal(decimal):
    hexadecimal = ""
    while decimal > 0:
        residuo = decimal % 16
        verdadero_caracter = obtener_caracter_hexadecimal(residuo)
        hexadecimal = verdadero_caracter + hexadecimal
        decimal = int(decimal / 16)
    return hexadecimal


def obtener_valor_real(caracter_hexadecimal):
    equivalencias = {
        "f": 15,
        "e": 14,
        "d": 13,
        "c": 12,
        "b": 11,
        "a": 10,
    }
    if caracter_hexadecimal in equivalencias:
        return equivalencias[caracter_hexadecimal]
    else:
        return int(caracter_hexadecimal)


def hexadecimal_a_decimal(hexadecimal):
    # Convertir a minúsculas para hacer las cosas más simples
    hexadecimal = hexadecimal.lower()
    # La debemos recorrer del final al principio, así que la invertimos
    hexadecimal = hexadecimal[::-1]
    decimal = 0
    posicion = 0
    for digito in hexadecimal:
        # Necesitamos que nos dé un 10 para la A, un 9 para el 9, un 11 para la B, etcétera
        valor = obtener_valor_real(digito)
        elevado = 16 ** posicion
        equivalencia = elevado * valor
        decimal += equivalencia
        posicion += 1
    return decimal


def decimal_a_octal(decimal):
    octal = ""
    while decimal > 0:
        residuo = decimal % 8
        octal = str(residuo) + octal
        decimal = int(decimal / 8)
    return octal


def octal_a_decimal(octal):
    decimal = 0
    posicion = 0
    # Invertir octal, porque debemos recorrerlo de derecha a izquierda
    # pero for in empieza de izquierda a derecha
    octal = octal[::-1]
    for digito in octal:
        valor_entero = int(digito)
        numero_elevado = int(8 ** posicion)
        equivalencia = int(numero_elevado * valor_entero)
        decimal += equivalencia
        posicion += 1
    return decimal


def decimal_a_binario(decimal):
    if decimal <= 0:
        return "0"
    # Aquí almacenamos el resultado
    binario = ""
    # Mientras se pueda dividir...
    while decimal > 0:
        # Saber si es 1 o 0
        residuo = int(decimal % 2)
        # E ir dividiendo el decimal
        decimal = int(decimal / 2)
        # Ir agregando el número (1 o 0) a la izquierda del resultado
        binario = str(residuo) + binario
    return binario


def binario_a_decimal(binario):
    posicion = 0
    decimal = 0
    # Invertir la cadena porque debemos recorrerla de derecha a izquierda
    # https://parzibyte.me/blog/2019/06/26/invertir-cadena-python/
    binario = binario[::-1]
    for digito in binario:
        # Elevar 2 a la posición actual
        multiplicador = 2**posicion
        decimal += int(digito) * multiplicador
        posicion += 1
    return decimal


El programa principal del conversor en Python consiste en solicitar al usuario los siguientes datos: desde qué base convertir, cuál número convertir y a qué base convertirlo. Luego, la función devuelve estos tres datos como una tupla si son válidos.

def solicitar_datos_a_usuario():
    bases_soportadas = ["2", "8", "10", "16", ]
    base_origen = input("""
2 - Binario
8 - Octal
10 - Decimal
16 - Hexadecimal
Elige la base desde donde conviertes: [2, 8, 10, 16]: """)
    if base_origen not in bases_soportadas:
        print("La base que ingresaste no está soportada")
        return
    numero = input(
        f"Ok, vas a convertir desde la base {base_origen}. Ingresa el número a convertir: ")
    base_destino = input("""
2 - Binario
8 - Octal
10 - Decimal
16 - Hexadecimal
Elige la base a la que conviertes: [2, 8, 10, 16]: """)
    if base_destino not in bases_soportadas:
        print("La base de destino no está soportada")
        return
    return (base_origen, numero, base_destino)




Ahora veamos la función que va a convertir el número a decimal, pues recuerda que todos los números serán convertidos a decimal, y desde decimal, a otras bases. Esto con el fin de ahorrarnos funciones. Entonces la función queda así:

def obtener_numero_decimal(base_origen, numero):
    if base_origen == "2":
        return conversiones.binario_a_decimal(numero)
    elif base_origen == "8":
        return conversiones.octal_a_decimal(numero)
    elif base_origen == "10":
        return int(numero)
    elif base_origen == "16":
        return conversiones.hexadecimal_a_decimal(numero)
view raw
obtener_numero_decimal.py hosted with ❤ by GitHub

Finalmente veamos la función que hace la conversión de acuerdo a la base:
def convertir(numero, base_destino):
    if base_destino == "2":
        return conversiones.decimal_a_binario(numero)
    elif base_destino == "8":
        return conversiones.decimal_a_octal(numero)
    elif base_destino == "10":
        return int(numero)
    elif base_destino == "16":
        return conversiones.decimal_a_hexadecimal(numero)

view raw
convertir.py hosted with ❤ by GitHub

Esta función va a devolver la conversión a la base numérica que el usuario haya elegido.
Poniendo todo junto

Así que el programa principal queda de la siguiente manera:

import conversiones


# Si todo va bien, regresa una tupla con la base de origen, el número a convertir y la base de destino
def solicitar_datos_a_usuario():
    bases_soportadas = ["2", "8", "10", "16", ]
    base_origen = input("""
2 - Binario
8 - Octal
10 - Decimal
16 - Hexadecimal
Elige la base desde donde conviertes: [2, 8, 10, 16]: """)
    if base_origen not in bases_soportadas:
        print("La base que ingresaste no está soportada")
        return
    numero = input(
        f"Ok, vas a convertir desde la base {base_origen}. Ingresa el número a convertir: ")
    base_destino = input("""
2 - Binario
8 - Octal
10 - Decimal
16 - Hexadecimal
Elige la base a la que conviertes: [2, 8, 10, 16]: """)
    if base_destino not in bases_soportadas:
        print("La base de destino no está soportada")
        return
    return (base_origen, numero, base_destino)


def obtener_numero_decimal(base_origen, numero):
    if base_origen == "2":
        return conversiones.binario_a_decimal(numero)
    elif base_origen == "8":
        return conversiones.octal_a_decimal(numero)
    elif base_origen == "10":
        return int(numero)
    elif base_origen == "16":
        return conversiones.hexadecimal_a_decimal(numero)


def convertir(numero, base_destino):
    if base_destino == "2":
        return conversiones.decimal_a_binario(numero)
    elif base_destino == "8":
        return conversiones.decimal_a_octal(numero)
    elif base_destino == "10":
        return int(numero)
    elif base_destino == "16":
        return conversiones.decimal_a_hexadecimal(numero)


if __name__ == '__main__':
    datos = solicitar_datos_a_usuario()
    # Comprobamos si los datos son correctos
    if datos:
        base_origen, numero, base_destino = datos
        # Para ahorrarnos código, vamos a convertir el número a decimal (sin importar la base de origen) y luego ese número
        # lo convertimos a la base de destino
        numero_decimal = obtener_numero_decimal(base_origen, numero)
        # Y a ese decimal lo convertimos a la base deseada
        resultado = convertir(numero_decimal, base_destino)
        print(resultado)


Recuerda que necesitas el archivo de conversiones que ya vimos anteriormente. En mi caso lo he probado con los siguientes tests unitarios:
import conversiones
import conversor
import unittest


class TestConversiones(unittest.TestCase):
    def test_binario_decimal(self):
        esperado = 7
        actual = conversiones.binario_a_decimal("111")
        self.assertEqual(actual, esperado)

    def test_decimal_binario(self):
        esperado = "111"
        actual = conversiones.decimal_a_binario(7)
        self.assertEqual(actual, esperado)

    def test_octal_decimal(self):
        esperado = 123
        actual = conversiones.octal_a_decimal("173")
        self.assertEqual(actual, esperado)

    def test_decimal_octal(self):
        esperado = "173"
        actual = conversiones.decimal_a_octal(123)
        self.assertEqual(actual, esperado)

    def test_hexadecimal_decimal(self):
        esperado = 255
        actual = conversiones.hexadecimal_a_decimal("ff")
        self.assertEqual(actual, esperado)

    def test_decimal_hexadecimal(self):
        esperado = "ff"
        actual = conversiones.decimal_a_hexadecimal(255)
        self.assertEqual(actual, esperado)

    def test_obtener_numero_decimal(self):
        valores = [
            {
                "base": "2",
                "numero": "111",
                "esperado": 7,
            },
            {
                "base": "8",
                "numero": "173",
                "esperado": 123,
            },
            {
                "base": "16",
                "numero": "f",
                "esperado": 15,
            },
        ]
        for valor in valores:
            esperado = valor["esperado"]
            actual = conversor.obtener_numero_decimal(
                valor["base"], valor["numero"])
            self.assertEqual(actual, esperado)


if __name__ == "__main__":
    unittest.main()

Recuerda que debes guardar los archivos en la misma carpeta. e instalar pip unittest.

Conversor de bases numéricas (binario, octal, decimal y hexadecimal) en Python

Funciona perfectamente. En este caso ejemplifiqué las conversiones con datos solicitados por teclado, aunque bien podrías ponerlo en una API, agregar una interfaz gráfica con tkinter o Qt, etcétera.


Estoy disponible para trabajar en tu proyecto o realizar tu tarea pendiente, no dudes en ponerte en contacto conmigo.
Si el post fue de tu agrado muestra tu apoyo compartiéndolo, suscribiéndote al blog, siguiéndome. 

En resumen, el conversor de bases numéricas es una herramienta valiosa para cualquiera que trabaje con números en el mundo de la tecnología y la informática. Además, el conocimiento de las diferentes bases numéricas y sus usos específicos es esencial para entender cómo funciona el conversor y cómo puede ser utilizado en diferentes situaciones. Si estás interesado en aprender más sobre este tema, ¡no dudes en explorar más recursos y comenzar a practicar hoy mismo!"