Códigos Fuente de Python

************************************************////*******************************************



Aula_28_Diciembre_15_sql.py
**********************************


Programa realizado bajo paltaforma Linux, concretamente con Ubuntu 20.04.6 LTS.
Editado con Sublime text

#Ejecución.
#Bajo consola linux.
python3 Aula_28_Diciembre_15_sql.py
Alumnos, para entender mejor este ejercicio, inicialmente vamos a instalar el programa para Linux: DB Browser for SQLite
------------------------------------------//--------------------------------
Utilizaremos este comando por consola de linux, en mi caso utilizo Ubuntu.
sudo apt install sqlitebrowser

***************************************************************************************************
Vamos a realizar un ejercicio en Python, con el fin de relacionar un programa orientado a base de datos, para ir cargandolos secuencialmente en nuestra base datos y poder ver bajo genome, con el programa DB Browser for SQLite, los resultados.
Creo que es lo más sencillo que podemos hacer, queridos alumnos, para aprender sobre este importante tema, las bases SQL.

Bien, vamos a ver un poco este ejercicio.

Explicación General del Ejercicio: Aula_28_Diciembre_15_sql.py
Clase del 18 de Diciembre - Aula 28 (Mañana)

Este ejercicio tiene como objetivo enseñar a los alumnos cómo crear, gestionar y manipular una base de datos utilizando SQLite en Python. Se presenta una agenda de contactos como ejemplo práctico, con funcionalidades para agregar, buscar, eliminar y listar contactos. El archivo generado se llama Aula_28_Agenda.db y será almacenado localmente.

Conceptos Clave:
SQLite:
Es un sistema de gestión de bases de datos ligero y sin servidor. No requiere configuración previa, lo que lo hace ideal para proyectos pequeños o educativos.

Base de datos:
Un lugar donde almacenamos datos organizados en tablas. En este caso, tenemos una tabla llamada contactos que almacena:

id: Identificador único (autoincremental).
nombre: Nombre del contacto.
telefono: Número de teléfono.
ciudad: Ciudad del contacto.

Python y SQL:
Python se conecta con SQLite usando la biblioteca sqlite3. Los comandos SQL (CREATE, INSERT, SELECT, DELETE) nos permiten manipular los datos.

Estructura del Programa:

1. Inicialización de la Base de Datos:

La función inicializar_db() crea el archivo Aula_28_Agenda.db si no existe.
Dentro de este archivo, se define la tabla contactos con sus columnas (id, nombre, telefono, ciudad).
Se utiliza SQL para asegurar que la tabla se cree solo si no existe previamente.

Código relevante:

CREATE TABLE IF NOT EXISTS contactos (
id INTEGER PRIMARY KEY AUTOINCREMENT,
nombre TEXT NOT NULL,
telefono TEXT NOT NULL,
ciudad TEXT NOT NULL
)

2. Agregar Contactos

La función agregar_contacto(nombre, telefono, ciudad) permite al usuario añadir contactos a la base de datos.
Se utiliza una consulta SQL INSERT para insertar los datos proporcionados por el usuario.

INSERT INTO contactos (nombre, telefono, ciudad) VALUES (?, ?, ?)

3. Buscar Contactos

La función buscar_contacto(nombre) permite buscar contactos en la base de datos que coincidan parcialmente con un nombre.
Utiliza SELECT con una condición LIKE para encontrar coincidencias.
SELECT nombre, telefono, ciudad FROM contactos WHERE nombre LIKE ?

4. Eliminar Contactos

La función eliminar_contacto(nombre) elimina todos los contactos cuyo nombre coincida con el criterio de búsqueda.
Utiliza DELETE para borrar los registros encontrados.

DELETE FROM contactos WHERE nombre LIKE ?

5. Mostrar Todos los Contactos

La función mostrar_agenda() lista todos los contactos almacenados en la base de datos.
Utiliza SELECT para recuperar toda la información de la tabla contactos.


SELECT nombre, telefono, ciudad FROM contactos
Interacción con el Usuario
El programa incluye un menú interactivo que guía al usuario por las diferentes funcionalidades de la agenda.
Este menú permite:

Opción 1: Agregar un contacto.
Opción 2: Buscar un contacto.
Opción 3: Eliminar un contacto.
Opción 4: Mostrar todos los contactos.
Opción 5: Salir del programa.

El menú se ejecuta dentro de un bucle while hasta que el usuario elige salir.

Ejemplo Práctico
Al ejecutar el programa, se crea el archivo Aula_28_Agenda.db.
Desde el menú:
Seleccionas 1. Agregar contacto, introduces Juan, 123456789 y Madrid.
Seleccionas 2. Buscar contacto, introduces Juan y ves los detalles de ese contacto.
Seleccionas 3. Eliminar contacto, introduces Juan y confirmas que se ha eliminado.
Seleccionas 4. Mostrar todos los contactos, y verificas que no hay contactos.

Objetivos de Aprendizaje
Comprender cómo funcionan las bases de datos relacionales.
Conectar y manipular bases de datos SQLite desde Python.
Implementar operaciones básicas de bases de datos:
Crear tablas (CREATE).
Insertar datos (INSERT).
Leer datos (SELECT).
Eliminar datos (DELETE).

Desarrollar un programa estructurado y modular.
-----------------------------------------------------------------------------------------------------
Conclusión
Este ejercicio combina teoría y práctica para ayudar a los alumnos del Aula 28 a entender el manejo de bases de datos desde Python. Los conceptos aprendidos pueden ser aplicados en proyectos más complejos en el futuro.

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++



---------------------------------------------------------------------------------------------------------------------------



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


Aula_28_Nov_Eliptica_Criptografia.py
+++++++++++++++++++++++++++++



Dentro de todas las partes, digamos, técnologicas, que hemos ido estudiando y procesando. Comenzamos un tema nuevo,
para el que seguiremos utilizando el lengua Python, y un sistema operativo basado en linux.
Nos adentramos en el mundo de la criptografía y de las claves, en principio, en los sistemas más utilizados
por el secure shel SSH, en principio con un ejemplo sencillo, que intentaré explicar lo mejor posible.
Como siempre, en nuestras sucesivas clases de técnología iremos aclarando las dudas que surjan, lo que supondrá, como siempre
ocurre en nuestras clases, profundizar mucho más sobre el tema. Os pido, que dentro de lo posible, intenteis razonar el código.
Luego ya aclararemos todo lo que surja, pero es más fácil su comprensión si llevamos, digamos, trillado, un poco de lo que se trata.

EMPECEMOS:
++++++++++++++

-¿Qué es una curva elíptica?
Una curva elíptica es una curva matemática que tiene la forma general:
y2=x3+ax+b (Ya sabeis, y elevado a 2, igual a x elevado a 3, más a por x, más b)
Esta curva tiene propiedades interesantes que se aprovechan en criptografía para generar claves. En criptografía de curvas elípticas (ECC, por sus siglas en inglés), usamos puntos sobre esta curva para construir un sistema de claves.

¿Cómo se construyen las claves con una curva elíptica?
1. Selección de la curva elíptica:
◦ Primero, se elige una curva elíptica específica. La ecuación y2=x3+ax+b tiene parámetros como a, b, y un número primo p que define el campo finito (es decir, trabajamos con números que están "limitados" por un número p).
◦ Un ejemplo común de curva elíptica es la curva secp256k1, que se usa en Bitcoin.

2. Punto generador (G):
◦ Sobre la curva elíptica, hay un punto generador G que es un punto específico de la curva, que se conoce de antemano. Este punto sirve para generar las claves.

3. Clave privada:
◦ La clave privada es un número aleatorio que se elige de manera segura. Es como una "semilla" que vamos a usar para generar la clave pública.
◦ Este número privado es secreto, y nunca se debe compartir.

4. Clave pública:
◦ La clave pública se genera multiplicando el punto generador G por el número privado (clave privada). Esto se hace mediante una operación llamada multiplicación escalar.
◦ Matemáticamente, si tienes una clave privada k, la clave pública P es: P=k⋅G
◦ Aquí, P es un nuevo punto sobre la curva que depende de k y G. Es casi imposible calcular k solo a partir de P, lo que hace la curva elíptica segura para su uso en criptografía.

5. Uso en criptografía:
◦ En criptografía de clave pública, puedes usar la clave pública para verificar la autenticidad de un mensaje o para cifrar datos.
◦ Solo la persona que tiene la clave privada puede descifrar los datos o firmar mensajes, porque se necesita la clave privada para generar la firma o descifrar.

Ejemplo práctico en criptografía
Imagina que quieres enviar un mensaje seguro a alguien:
1. La otra persona te envía su clave pública.
2. Tú usas esa clave pública para cifrar el mensaje.
3. La otra persona usa su clave privada para descifrarlo.
Y cuando firmes un mensaje:
1. Usas tu clave privada para firmar el mensaje (de forma que solo tú puedas hacerlo).
2. Cualquier persona que tenga tu clave pública puede verificar que la firma es auténtica y que no ha sido modificada.

¿Por qué es segura?
La seguridad de este sistema se basa en que, aunque la multiplicación escalar de un número por un punto en la curva es fácil de hacer, el proceso inverso (saber la clave privada a partir de la clave pública) es extremadamente difícil. Este problema se llama el problema del logaritmo discreto, y es la base de la seguridad de las curvas elípticas.

En fin, alumnos, resumiendo:
1. Clave privada: Número secreto que eliges.
2. Clave pública: Punto en la curva generado a partir de la clave privada.
3. Suma de puntos: Usada para multiplicar el punto generador G para obtener la clave pública.
4. Seguridad: Es muy difícil calcular la clave privada a partir de la clave pública.

Este enfoque se usa en criptografía moderna para asegurar comunicaciones y transacciones, como en Bitcoin o en protocolos TLS/SSL para la navegación segura por Internet.
----------------------------------------------------------------------------------------------------------------------------------

Bien, después de esta pequeña introducción, que ampliaremos en clase, la próxima semana y sucesivas, vamos con algo más práctico:

1. Representación gráfica de la curva elíptica.
---------------------------------------------------------------
El programa comienza generando una gráfica de la curva elíptica definida por y2=x3+8x+12 sobre los números reales:
• Cálculo de y2:
La ecuación se evalúa para valores de x en un rango definido [−10,10] para obtener los valores de y2.
• Raíces cuadradas positivas y negativas:
La raíz cuadrada de y2 se toma tanto positiva como negativa (y=±y2​) para trazar ambas ramas de la curva.
• Visualización:
Usa matplotlib para graficar las ramas positiva y negativa en colores distintos. También incluye líneas de referencia para los ejes x e y, junto con una cuadrícula para mejorar la legibilidad.
Propósito:
Este gráfico permite entender visualmente la forma de una curva elíptica sobre los números reales antes de trabajar con el caso modular (campo finito).

2. Implementación de una curva elíptica modular (campo finito pequeño)
-------------------------------------------------------------------------------------------------------
En esta sección, se define una clase EllipticCurve para manejar operaciones básicas en una curva elíptica sobre un campo finito

Fp​:
• Parámetros de la curva:
La curva está definida por y2=x3+ax+bmodp, donde:
◦ a=8, b=12, y p=97 (un número primo que define el campo).
• Validación de singularidades:
Verifica que la curva no sea singular usando la condición 4a3+27b2=0modp.

• Operaciones básicas:
◦ Pertenencia a la curva: Verifica si un punto (x,y) está en la curva.
◦ Suma de puntos: Implementa la adición de puntos, considerando casos como:
▪ P+O=P (punto identidad).
▪ Suma de puntos distintos.
▪ Duplicación de un punto (derivada de la tangente).
◦ Multiplicación escalar: Repite la suma k⋅P usando el algoritmo de duplicación y adición.

• Generación de claves:
◦ Se generan todos los puntos válidos en la curva para el campo F97​.
◦ Selecciona un punto generador G (el primero de la lista).
◦ La clave privada es un entero aleatorio entre 1 y p−1.
◦ La clave pública es el resultado de k⋅G, donde k es la clave privada.

Resultados:
Imprime:
• La ecuación de la curva modular.
• El punto generador G.
• Las claves privada y pública generadas.

3. Criptografía realista con secp256k1
Esta sección introduce una curva elíptica de uso práctico en criptografía, secp256k1, utilizada por Bitcoin:
• Definición:
La curva está definida por y2=x3+7modp, donde:
◦ p es un número primo grande (2256−232−977).
◦ G es un punto generador predeterminado en la curva.
◦ n es el orden del punto generador.
• Operaciones similares:
Implementa las mismas operaciones (pertenencia, suma de puntos, multiplicación escalar) adaptadas a los parámetros de secp256k1.
• Generación de claves:
◦ La clave privada es un número aleatorio de hasta 256 bits (1≤k<n).
◦ La clave pública es k⋅G, donde G y n aseguran un espacio de claves inmenso y seguridad criptográfica.
Resultados:
Muestra:
• La ecuación de secp256k1.
• El punto generador G.
• Las claves privada y pública.


Como véis, queridos alumnos, el propósito formativo del programa es:
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1. Introducción visual a las curvas elípticas:
La gráfica inicial ayuda a entender cómo luce una curva elíptica y su simetría sobre los números reales.
2. Conceptos básicos de curvas elípticas en campos finitos:
◦ Explica cómo las curvas se definen y operan en un espacio modular, con un ejemplo simple (p=97).
◦ Introduce operaciones críticas como suma de puntos y multiplicación escalar.
3. Aplicación práctica en criptografía:
◦ Usa una curva criptográfica estándar (secp256k1) para mostrar cómo generar claves privadas y públicas.
◦ Destaca las diferencias entre un ejemplo educativo y un caso práctico con parámetros reales.

Bien, y como posibles mejoras, vamos a implementar lo siguiente:
---------------------------------------------------------------
• Implementar firmas digitales (ECDSA) como extensión práctica.
• Mostrar cómo la clave pública se convierte en un formato útil (como direcciones en Bitcoin).
• Incluir explicaciones más detalladas sobre seguridad y resistencia frente a ataques.


Comoos lo expuesto, tengo por sentado que os resultará un tanto farragoso, deseo que, como ya dije, comencéis su estudio-
Iremos puliendo dudas, y asentando conceptos los próximos días.



///////////////////////////////////////////////////////////////////////////
Como casi todos los ejercicios, este fue realizado, bajo una plataforma Linux,
en concreto con Ubuntu 20.04.6 LTS.
Fue editado con Sublime Text.
Se utilizó, Python3.
Y como smpre indico, se deberán de tener cargadas en el sistema, todas las librerias
que el código pide importar para su ejecucucíon.

Comando de ejecucuón bajo consola linux:

python3 Aula_28_Nov_Eliptica_Criptografia.py

-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Ejercicio:
<<<<<<<<<
Aula_28_Redaccion_IA.py
----------------------
Avanzando más en el tratamiento de textos, dentro de la Inteligencia Artificial. Proponemos ahora este ejercicio sencillo en el que vamos a utilizar un módulo ya entrenado en la elaboración de textos congruentes.
Como siempre trabajaremos bajo consola de Linux, con un sistema operativo Ubuntu 20.04.6 LTS. Utilizando como editor Sublime text.

Bien, queridos, alumnos. Para crear un programa que redacte textos amplios sobre un tema introducido por consola, puedemos usar modelos de lenguaje preentrenados, como los de la biblioteca transformers de Hugging.
Estos modelos son capaces de generar textos de manera coherente sobre prácticamente
cualquier tema. Es importante que el tema introducido por consola, sea descriptivo en el tema planteado, para que nuestro Módulo tenga más posibilidades de concretar la pequeña redacción resultante. En nuestro caso hemos planteado el tema de la siguiente forma:
"El mar es hermoso, pero esclavo para los pescadores que trabajan en ella"

Primero, asegúrate de tener instalada la biblioteca transformers y torch si aún no las tienes.
Puedes instalarlas ejecutando en la terminal:

pip install transformers torch

***************************************************************************************
Vamos a explicar de forma breve, en que consiste y como importamos el módulo entrenado.
----------------------------------------------------------------------------------------

Módulos Importados:

GPT2LMHeadModel:
Este es un modelo preentrenado basado en GPT-2, un tipo de modelo de lenguaje desarrollado por OpenAI que genera texto. La parte LMHead se refiere a la cabeza del modelo, que está diseñada específicamente para tareas de generación de lenguaje. El modelo puede generar nuevas secuencias de texto basadas en una entrada inicial.

GPT2Tokenizer:
Este es el tokenizador de GPT-2, encargado de convertir el texto que introduces (en formato de palabras) en un formato numérico que el modelo puede entender (tokens). Cuando quieres que el modelo genere texto o lo procese, el tokenizador traduce el texto a tokens, y después de que el modelo trabaja con ellos, el tokenizador traduce esos tokens de nuevo a texto legible.

Funcionamiento:
1. Tokenización -como recordareis ya hemos explicado este tema en un ejercicio anterior-:

El texto en lenguaje natural no puede ser entendido directamente por el modelo; necesita ser convertido a un formato que pueda procesar, llamado tokens (que son números que representan palabras o partes de palabras).
Ejemplo:
Si introduces la frase "Hola mundo", el tokenizador puede convertirla en algo como [15496, 1107], donde cada número representa una palabra o fragmento de una palabra.

2. Generación del texto:
El modelo GPT-2 toma esos tokens y predice cuál debería ser el siguiente token (o secuencia de tokens) basándose en lo que ya ha "visto". Se basa en patrones que ha aprendido de grandes cantidades de datos durante su entrenamiento.
Usando el mismo ejemplo, si das el input "Hola mundo", el modelo podría generar una continuación como "es un lugar hermoso" o cualquier secuencia plausible que siga.

3. Proceso completo:
Input: Tú introduces una frase (por ejemplo, "El cielo es azul").
Tokenización: El tokenizador convierte esta frase en tokens numéricos.
Modelo GPT-2: El modelo procesa esos tokens y genera nuevos tokens que representan la continuación del texto (basado en lo que ha aprendido).
Des-tokenización: El tokenizador traduce esos nuevos tokens de vuelta a palabras legibles, generando un texto nuevo como salida.

***************************************************************************
Explicación del código:

GPT2LMHeadModel.from_pretrained('gpt2'): Carga el modelo GPT-2 preentrenado.
tokenizador.encode(): Convierte el texto de entrada en tokens.
modelo.generate(): Genera la continuación del texto basado en los tokens de entrada.
tokenizador.decode(): Convierte los tokens generados nuevamente a texto para que puedas leer la salida.

Este enfoque permite que los modelos como GPT-2 generen texto natural en una gran variedad de tareas, como responder preguntas, redactar historias o completar oraciones. Todo esto se hace aprovechando la capacidad del modelo para aprender patrones del lenguaje y generar textos coherentes basados en un contexto previo.

**************************************************************************************
La ejecucion de este programa se realiza con el siguiente comando, bajo consola de Linux:
python3 Aula_28_Redaccion_IA.py
////////////////////////////////////////////////////////////////////////////////////////////
-------------------------------------------------------------------------------------------
Como veremos en clase, el próximo 29 de Octubre, existen muchas limitaciones en este proceso.
Revisaremos el ejercicio paso a paso, y comrobaremos cómo funciona.
He de decir que partimos de una forma básica, pero intentaremos poner las bases, para aumentar la complejidad y la efectividad con nuevos ejercicios.

Nuestras limitaciones son muchas, somos meros mortales en limitaciones tecnologicas, a continuacion
os hago un resumen de nuetras limitaciones, digamos, caseras:

Cuando ejecutas módulos como GPT2LMHeadModel y GPT2Tokenizer en un ordenador normal (casero), hay algunas limitaciones que debes tener en cuenta. Aquí te detallo las más importantes:

1. Recursos de hardware:
**********************
Memoria RAM: Los modelos como GPT-2 requieren bastante memoria. Incluso el modelo GPT-2 pequeño puede ocupar varios GB de RAM. Si tu ordenador tiene poca memoria (por ejemplo, menos de 8 GB de RAM), puede que se bloquee o funcione muy lentamente, especialmente con textos largos.
GPU (Unidad de Procesamiento Gráfico): Aunque los modelos se pueden ejecutar en CPU, los modelos como GPT-2 son mucho más rápidos si se ejecutan en una GPU. Los ordenadores caseros generalmente no tienen GPUs tan potentes como las de los servidores especializados o las tarjetas gráficas usadas para IA (como las NVIDIA de la serie RTX). Sin una GPU potente, la generación de texto puede ser extremadamente lenta.
CPU: Si no tienes una GPU, el modelo se ejecutará en la CPU, pero esto hará que el procesamiento sea mucho más lento. Procesar o generar textos largos podría tomar minutos en lugar de segundos.


2. Tamaño del modelo:
********************
Versiones grandes de GPT-2: GPT-2 tiene varios tamaños (pequeño, mediano, grande y extra grande). Los modelos más grandes requieren mucha más memoria y procesamiento, lo que los hace casi impracticables en un ordenador casero promedio. Por ejemplo, el modelo más grande (GPT-2 XL) ocupa más de 6 GB solo para cargar, y esto sin contar el procesamiento del texto.
Tiempo de carga: Incluso si tu ordenador puede manejar el tamaño del modelo, cargar el modelo en la memoria puede ser lento, y cada nueva inferencia (generación de texto) puede tomar bastante tiempo.

3. Almacenamiento:
*****************
Espacio en disco: Los modelos preentrenados de GPT-2 ocupan varios gigabytes de almacenamiento. Si tienes un disco duro pequeño o poco espacio disponible, descargar y guardar estos modelos puede ser problemático.
Actualizaciones de modelos: Los modelos mejorados o adicionales también ocupan más espacio y descargar varios de ellos podría llenar el almacenamiento disponible rápidamente.

4. Rendimiento limitado en generación de texto:
**********************************************
Latencia: En un ordenador casero, puede haber una latencia significativa entre la entrada de texto y la generación de salida. Generar texto en tiempo real o manejar peticiones rápidas no es tan fluido como en infraestructuras especializadas.
Longitud del texto: La longitud del texto que puedes procesar o generar también está limitada por los recursos de tu máquina. Textos muy largos podrían hacer que el modelo consuma más memoria de la disponible, lo que puede llevar a fallos o tiempos de procesamiento extremadamente largos.

5. Optimización limitada:
************************
Uso eficiente del hardware: Los modelos como GPT-2 están optimizados para funcionar mejor en infraestructuras de alto rendimiento, donde los recursos se pueden gestionar de manera más eficiente. En un ordenador casero, la falta de optimizaciones específicas para tu hardware (como las que se usan en servidores o clusters) hará que el rendimiento sea más bajo.

6. Entrenamiento o ajuste fino (fine-tuning):
********************************************
Imposibilidad de reentrenar: Entrenar o ajustar finamente un modelo como GPT-2 en un ordenador casero es prácticamente inviable debido a la cantidad de recursos que consume. Necesitarías GPUs especializadas y días o semanas de procesamiento para reentrenar el modelo, algo que no es posible en un equipo casero normal.
Acceso a grandes datasets: Para ajustar finamente el modelo, necesitarías un conjunto de datos extenso y adecuado, lo que no siempre es fácil de gestionar ni de almacenar en un ordenador personal.

7. Conexión a internet (si usas modelos en la nube):
***************************************************
Como recurso, os digo:
Aunque puedes ejecutar los modelos localmente, algunos prefieren usar versiones en la nube o APIs (como OpenAI GPT-3) para ahorrar recursos en el ordenador local. En estos casos, dependes de una conexión a internet rápida y estable para obtener resultados eficientes. Las conexiones lentas podrían hacer que el proceso sea menos fluido.

Como os comento, los de nuestra Aula, somos puramente terrenales.
Gracias, amigos, y a trabajar.

----------------------------------------------------------------------------------------------------------

*****************************************************************************************************************

Ejercicio:Aula_28_token_sep_24.py
*********************************
Vamos a avanzar en el Aula 28, e iniciar, el tratamiento de textos en la Inteligencia Artificial.

Empezaremos con algo muy básico, ¿Qué es la tokenización?.
--------------------------------------------------------

-¿Qué es la tokenización?
Dividir el texto: La tokenización consiste en dividir un texto en partes más pequeñas llamadas tokens. Estos tokens pueden ser palabras, frases o incluso caracteres, dependiendo de cómo quieras analizarlos.

Ejemplo: Si tienes la frase "El perro ladra", la tokenización a nivel de palabras dividiría el texto en los siguientes tokens:

"El"
"perro"
"ladra"

Importancia:
-----------
Facilita el análisis: Al descomponer el texto, es más fácil realizar análisis, como contar palabras, buscar patrones o entender el significado.
Prepara para modelos:
Muchos modelos de IA trabajan con números, no con texto. La tokenización es un primer paso para convertir texto en un formato que los modelos puedan entender.

Tipos de tokenización:
---------------------
Por palabra: Divide el texto en palabras.
Por frase: Divide el texto en oraciones o frases.
Por carácter: Divide el texto en caracteres individuales.

Como ya digimos, la tokenización es el proceso de separar el texto en unidades más pequeñas (tokens) para que puedan ser analizadas y procesadas por algoritmos de IA. Es un paso esencial para entender y trabajar con el lenguaje en aplicaciones de inteligencia artificial.

*****************************************************************************************
Como se almacenaría, por ejemplo, en una matriz del tipo Tensor.
---------------------------------------------------------------
Definición: Un tensor es una estructura de datos que puede ser vista como una generalización de matrices y vectores.

Un escalar es un tensor de orden 0 (por ejemplo, un solo número).
Un vector es un tensor de orden 1 (una lista de números).
Una matriz es un tensor de orden 2 (una tabla de números).
Un tensor de orden superior puede tener más de dos dimensiones.
Representación: En matemáticas, los tensores se utilizan para representar datos de múltiples dimensiones. Por ejemplo, una imagen puede ser representada como un tensor de 3 dimensiones (alto, ancho, canales de color).

¿Cómo se utilizan los tensores en IA y procesamiento de texto?
Representación de texto:

Después de la tokenización, los tokens (palabras o frases) deben convertirse en números para que los algoritmos de IA puedan procesarlos. Esto se hace a menudo usando técnicas de embeddings (representaciones vectoriales de palabras).
Cada token se convierte en un vector (tensor de orden 1). Por ejemplo, la palabra "perro" podría representarse como un vector de características [0.5, 0.1, 0.9, ...].
Tensores en redes neuronales:

Los tensores son fundamentales en el entrenamiento de redes neuronales, donde los datos se alimentan a través de capas de la red. Cada capa procesa los tensores de entrada y produce tensores de salida.
Por ejemplo, en un modelo de procesamiento del lenguaje natural (como Transformers), el texto tokenizado se convierte en tensores, que luego son procesados en múltiples capas para generar resultados (como predicciones de texto).
Operaciones con tensores:

Se realizan varias operaciones matemáticas sobre tensores, como la suma, la multiplicación y la transformación, para aprender patrones en los datos. Esto se hace utilizando bibliotecas de programación como TensorFlow o PyTorch, que son especialmente diseñadas para manejar tensores y operaciones sobre ellos.
Batching:

En el entrenamiento de modelos, es común agrupar múltiples ejemplos en un batch (lote). Esto se hace representando varios textos como un tensor de 2 dimensiones (batch_size, longitud del texto), donde batch_size es el número de ejemplos en el lote y longitud del texto es el número máximo de tokens por ejemplo.

Diriamos, como conclusion.
------------------------
Los tensores son estructuras de datos esenciales en IA y procesamiento de texto. Se utilizan para representar texto, imágenes y otros tipos de datos en múltiples dimensiones. En el contexto del procesamiento de texto, los tensores permiten a los modelos de IA realizar cálculos complejos y aprender patrones a partir de datos tokenizados. Su uso se ha vuelto fundamental en la mayoría de las aplicaciones modernas de inteligencia artificial y aprendizaje profundo.

***************************************************************************************
EXPLICACCION DE NUESTRO EJERCICIO.
****************************************************************************************
Vamos a desglosar el ejercicio proporcionado paso a paso para entender cómo funciona y qué hace cada parte del código.

1. Importación de bibliotecas
****************************

import nltk
from nltk.tokenize import word_tokenize
import nltk: Importa la biblioteca Natural Language Toolkit (NLTK), que es una biblioteca popular en Python para el procesamiento del lenguaje natural.
from nltk.tokenize import word_tokenize: Importa la función word_tokenize, que se utiliza para dividir un texto en palabras (tokens).

2. Definición de la función
**************************

def tokenizar_con_matriz(frase):
Aquí se define una función llamada tokenizar_con_matriz, que acepta una cadena de texto (frase) como argumento.

3. Docstring
***********

"""Tokeniza una frase y crea una matriz 2D con los tokens y sus índices.

Args:
frase: La frase a tokenizar.

Returns:
Una lista de listas donde cada sublista contiene el token y su índice.
"""
Este bloque de texto es un comentario (docstring) que describe lo que hace la función, los argumentos que recibe y lo que devuelve. Es útil para que otros programadores (o tú mismo en el futuro) entiendan el propósito de la función.

4. Tokenización
**************
tokens = word_tokenize(frase)
word_tokenize(frase): Esta función toma la frase y la divide en una lista de tokens (palabras y puntuaciones). Por ejemplo, si la entrada es "El mar, amplio y profundo", tokens podría ser ['El', 'mar', ',', 'amplio', 'y', 'profundo'].

5. Creación de la matriz de tokens
*********************************
matriz_tokens = [[token, str(indice)] for indice, token in enumerate(tokens, start=1)]
enumerate(tokens, start=1): Esta función permite iterar sobre tokens, proporcionando tanto el índice (número de posición) como el valor del token. La opción start=1 significa que los índices comenzarán desde 1 en lugar de 0.
Lista de listas: Se crea una lista llamada matriz_tokens, donde cada sublista contiene un token y su índice correspondiente. Por ejemplo, si tokens es ['El', 'mar', ',', 'amplio', 'y', 'profundo'], matriz_tokens sería:
css

[['El', '1'],
['mar', '2'],
[',', '3'],
['amplio', '4'],
['y', '5'],
['profundo', '6']]
6. Solicitar entrada al usuario
*******************************
# Solicitar al usuario que introduzca la frase
frase = input("Introduce una frase: ")
Aquí se le pide al usuario que introduzca una frase a través de la consola. Lo que escriba el usuario se almacenará en la variable frase.

7. Llamada a la función y almacenamiento del resultado
******************************************************
matriz = tokenizar_con_matriz(frase)
Se llama a la función tokenizar_con_matriz, pasando la frase que el usuario introdujo como argumento. El resultado (la matriz de tokens) se guarda en la variable matriz.

8. Impresión de la matriz
************************
# Imprimir la matriz completa
for fila in matriz:
print(fila)
Este bucle for recorre cada sublista (fila) en matriz y las imprime. Cada fila contendrá un token y su índice, mostrando el resultado de la tokenización de forma estructurada.
Ejemplo de uso
Si el usuario ingresa la frase:


El mar, amplio y profundo
La salida sería:

css

['El', '1']
['mar', '2']
[',', '3']
['amplio', '4']
['y', '5']
['profundo', '6']
Podemos decir, queridos alumnos, como esumen que:
-------------------------------------------------
Este programa tokeniza una frase ingresada por el usuario, crea una estructura de datos en forma de matriz que muestra cada token y su índice correspondiente, y luego imprime esa matriz. Este ejercicio que os propuse, es un ejemplo básico pero efectivo de cómo manipular texto en Python utilizando NLTK.

*************************************************************************************************
Este ejercicio fue ralizado bajo Linux, en sistema operativo Ubuntu,
Editado con sublime text.

EJEMPLOS DE SALIDAS POR CONSOLA LINUX.
******************************************************************************




*********************************************************************************
********************************************************************************


Ejercicio.
<<<<<<<<<
Aula_28_canales_wifi.py
*****+++++++++++++++++++++++*****


Proponemos hoy como trabajo de recuperación para el aula 28, un ejercicio en phython, que realiza la identificacion del número de los canales de cada usuario -SSID-, así como la frecuencia de emisión de cada uno.

Este ejercicio fue realizado bajo plataforma linux, en concreto con Ubuntu 20.04.6 LTS, y ejecutado bajo consola

Antes de pasar a la prática vamos a describir que son los canales de emisión de una wifi.
Para entendernos, los canales de emisión de una red WiFi son como, digamos, "caminos" por donde viajan las señales inalámbricas entre el router y los dispositivos conectados. El espectro de frecuencia del WiFi (como las bandas de 2.4 GHz y 5 GHz) se divide en varios canales, y cada uno es un rango específico de frecuencias.

En la banda de 2.4 GHz, hay 14 canales (aunque no todos se usan en todos los países), y estos canales se superponen entre sí, lo que puede causar interferencias si muchas redes están en canales cercanos.
En la banda de 5 GHz, hay más canales y están mejor separados, lo que reduce las interferencias.
El router elige un canal para transmitir, y algunos dispositivos pueden cambiar automáticamente al canal menos congestionado.

Por lo tanto, los canales de emisión de una WiFi son divisiones dentro de las bandas de frecuencia que usan los dispositivos para transmitir datos de forma inalámbrica. Las bandas más comunes, como digimos anteriormente, son 2.4 GHz y 5 GHz, cada una dividida en varios canales de ancho de banda específico.

Banda de 2.4 GHz:
*****************
Está subdividida en 14 canales de 20 MHz de ancho, aunque no todos se usan en todos los países.
Los canales se solapan, excepto los canales 1, 6 y 11 (en la mayoría de los países), que son no superpuestos, lo que significa que no interfieren entre sí.
Interferencia: Debido a la superposición de canales, el uso de canales adyacentes puede causar interferencias, reduciendo la calidad de la conexión y la velocidad.

Banda de 5 GHz:
**************
Tiene más canales y están separados en intervalos de 20 MHz (36, 40, 44, 48, etc.), lo que reduce la interferencia entre ellos.
Algunos routers permiten el uso de canales de ancho de banda más amplio (40 MHz, 80 MHz e incluso 160 MHz), lo que mejora la velocidad al aumentar la cantidad de datos que pueden transmitirse en menos tiempo, aunque también aumenta el riesgo de interferencia si hay muchas redes cercanas.
Selección de canales:
En redes congestionadas, es ideal elegir canales no superpuestos o menos ocupados.
Muchos routers tienen la capacidad de seleccionar automáticamente el mejor canal, basándose en la congestión del espectro.
Además, el estándar WiFi moderno (802.11ac y 802.11ax) optimiza el uso del espectro y la selección de canales para mejorar el rendimiento y la eficiencia de la red.

-----------------------------------------------------------------------------------------
En el ejercicio propuesto, importamos el módulo import pywifi. Que deberemos tener instalado en nuestra plataforma linux con este comando:

python3 -m pip install pywifi


Bien, ahora explicaremos poco esto, pywifi es un módulo de Python que permite interactuar con adaptadores de red WiFi en sistemas operativos compatibles, como Linux y Windows. Con pywifi, puedes gestionar conexiones inalámbricas, escanear redes WiFi cercanas y conectarte o desconectarte de redes de manera programática.

Funcionalidades principales de pywifi:
*************************************
Escaneo de redes: Puedes utilizar pywifi para escanear las redes WiFi disponibles en el área, obteniendo detalles como el nombre de la red (SSID), la calidad de la señal y el tipo de cifrado.

Conexión a redes WiFi:
*********************
Permite conectarse a una red WiFi específica proporcionando los detalles correctos como SSID y contraseña.

Desconexión:
***********
Puedes desconectarte de cualquier red WiFi conectada actualmente usando el módulo.

Control de interfaces:
**********************
El módulo permite gestionar las interfaces de red WiFi disponibles, seleccionando la que desees usar si tienes varias interfaces WiFi en tu dispositivo.

Estados de conexión:
*******************
pywifi ofrece la capacidad de consultar el estado actual de la conexión WiFi, ya sea si estás conectado, desconectado o en proceso de conexión.

Tipos de autenticación y cifrado: Soporta la autenticación con diferentes protocolos como WPA, WPA2 y los tipos de cifrado como TKIP y AES.

Clases y métodos clave:
**********************
PyWiFi(): Es la clase principal que crea una instancia de controlador WiFi.
WiFiScan(): Permite realizar escaneos para descubrir redes WiFi cercanas.
WiFiProfile(): Esta clase se usa para definir los parámetros necesarios para conectarse a una red, como SSID, modo de autenticación y la clave de cifrado.
connect() y disconnect(): Métodos para iniciar o finalizar una conexión WiFi.
*****************************************************************************************
Pasamos ahora a describir el programa:
*************************************
////////////////////////////////////
1. Importaciones:
----------------

import pywifi
import time
pywifi: Módulo que proporciona funciones para interactuar con interfaces WiFi.
time: Módulo de Python que se usa aquí para hacer pausas y permitir que el escaneo de redes se complete.

2. Función scan_wifi():
----------------------
def scan_wifi():
wifi = pywifi.PyWiFi()
iface = wifi.interfaces()[0] # Obtiene la primera interfaz WiFi
iface.scan() # Inicia el escaneo
time.sleep(2) # Espera un momento para que el escaneo se complete
scan_results = iface.scan_results() # Obtiene los resultados del escaneo
return scan_results
wifi = pywifi.PyWiFi(): Crea una instancia del controlador de WiFi.
iface = wifi.interfaces()[0]: Obtiene la primera interfaz WiFi disponible en el dispositivo (por ejemplo, la tarjeta de red WiFi).
iface.scan(): Inicia un escaneo para buscar redes WiFi cercanas.
time.sleep(2): Pausa la ejecución durante 2 segundos, lo cual es necesario para dar tiempo a que el escaneo se complete.
scan_results = iface.scan_results(): Recupera los resultados del escaneo, que incluye detalles de las redes cercanas (SSID, frecuencia, etc.).
return scan_results: Devuelve la lista de redes WiFi detectadas.

3. Función main():
-----------------
def main():
networks = scan_wifi()
print(f"Se encontraron {len(networks)} redes WiFi.")
networks = scan_wifi(): Llama a la función scan_wifi() para obtener la lista de redes WiFi disponibles.
print(f"Se encontraron {len(networks)} redes WiFi."): Imprime la cantidad de redes WiFi detectadas.

4. Inicialización de contadores para 2.4 GHz y 5 GHz:
----------------------------------------------------
count_24ghz = 0
count_5ghz = 0
Se crean dos contadores (count_24ghz y count_5ghz) para llevar la cuenta de cuántas redes operan en la banda de 2.4 GHz y cuántas en la de 5 GHz.

5. Bucle para recorrer las redes detectadas:
------------------------------------------

for network in networks:
print(f"SSID: {network.ssid}, Frecuencia: {network.freq} MHz")
for network in networks: Itera a través de cada red detectada en el escaneo.
print(f"SSID: {network.ssid}, Frecuencia: {network.freq} MHz"): Imprime el nombre de la red (SSID) y la frecuencia de operación (en MHz) de cada red.

6. Determinación de la banda y cálculo del canal:
-----------------------------------------------
if network.freq < 2500:
channel = (network.freq - 2400) // 5 + 1 # Calcular el canal para 2.4 GHz
count_24ghz += 1
else:
channel = (network.freq - 5000) // 20 + 36 # Calcular el canal para 5 GHz
count_5ghz += 1
if network.freq < 2500: Si la frecuencia es menor a 2500 MHz, se asume que la red opera en la banda de 2.4 GHz.

channel = (network.freq - 2400) // 5 + 1: Se calcula el canal correspondiente restando 2400 MHz a la frecuencia y dividiendo por 5. Este cálculo es una aproximación para determinar el canal en la banda de 2.4 GHz.
count_24ghz += 1: Se incrementa el contador de redes de 2.4 GHz.
else: Si la frecuencia es mayor o igual a 2500 MHz, se asume que la red opera en la banda de 5 GHz.

channel = (network.freq - 5000) // 20 + 36: Se calcula el canal restando 5000 MHz a la frecuencia y dividiendo por 20, ya que los canales en 5 GHz están más espaciados. El valor 36 se suma porque es el primer canal en la banda de 5 GHz.
count_5ghz += 1: Se incrementa el contador de redes de 5 GHz.
print(f"Canal: {channel}"): Imprime el canal calculado para la red actual.

7. Impresión del resumen de redes por banda:
------------------------------------------
print(f"Redes en 2.4 GHz: {count_24ghz}")
print(f"Redes en 5 GHz: {count_5ghz}")
Después de iterar sobre todas las redes, se imprime el número de redes detectadas en las bandas de 2.4 GHz y 5 GHz.

8. Ejecución del programa:
--------------------------
if __name__ == "__main__":
main()
Esta línea se asegura de que la función main() se ejecute cuando el script es ejecutado directamente (no cuando se importa como un módulo).
Resumen:
Este programa escanea las redes WiFi disponibles y muestra la cantidad de redes encontradas. Luego, para cada red, muestra su SSID (nombre), la frecuencia de operación (en MHz) y el canal correspondiente. Finalmente, cuenta y muestra cuántas redes operan en las bandas de 2.4 GHz y 5 GHz.
***********************************************************************************************

Ejecución.
*********
Para su ejecución utilizaremos este comando bajo la consola de linux. Debereis de tener en cuanta la ruta que utiliceis al directorio donde hagais vuestro programa.
Tener en cuenta que debereis ejecutarlo bajo root, utilizando sudo.
Este es el comando:

sudo -E python3 /home/margarito/python/Aula_28_canales_wifi.py

Como veis en este comando, utilizamos la opción -E, el comando lleva la orden python3, la ruta, y el nombre que le deis al programa.

----------------------------------------------------------------------------------------------------------
En este ejemplo, vamos a realizar una propuesta de estudio para el Aula 18, sobre desarrollo de programación, para crear un programa en Python que determine, qué usuarios o dispositivos están conectados a tu red Wi-Fi, en un sistema operativo Linux (como Ubuntu), podemos usar una combinación de herramientas de red disponibles en Linux, como arp-scan o nmap.

Aquí te dejo un ejemplo básico que utiliza arp-scan, una herramienta que escanea la red en busca de dispositivos conectados.
********************************************************************
En este ejemplo iremos describiendo paso a paso, el proceso de creación de
nuestro programa.
-------------------------------------------------------------------------
Pasos para instalar y usar el script:
Instalar arp-scan: Primero, debes instalar la herramienta arp-scan si no la tienes en tu sistema. Abre una terminal y ejecuta:

sudo apt-get install arp-scan
Crear el programa en Python:

Crea un archivo Python con el siguiente código, por ejemplo, llámalo Ejercicio_Aula_Sep_29.py:


Nota:
Necesitas tener privilegios de root para usar arp-scan, de ahí que el script deba ejecutarse con sudo.
Este es un método sencillo para obtener información de los dispositivos conectados a la misma red Wi-Fi.

Para incluir el nombre de la interfaz de red del terminal (como wlan0, eth0, etc.), podemos hacer que el programa detecte automáticamente la interfaz de red que está en uso para conectarse a la red Wi-Fi. Esto es necesario ya que arp-scan puede requerir que especifiques la interfaz de red correcta en lugar de asumirlo por defecto.

También podemos usar el comando ip link para listar las interfaces de red y determinar cuál está activa.

Otra cosa que podemos hacer es modificar el programa para que, cuando sea necesario ejecutar sudo, no tengas que invocar el script desde la línea de comandos con sudo. En su lugar, el propio programa pedirá la contraseña de superusuario automáticamente si no se está ejecutando con privilegios de administrador.

Python tiene una librería llamada os que permite verificar si el programa se está ejecutando como root. Si no es así, podemos utilizar sudo para ejecutar el propio script.


Verifica si el script está siendo ejecutado con permisos de superusuario usando os.geteuid().
Si no se está ejecutando con permisos de root (es decir, si el identificador de usuario efectivo no es 0), el programa se reiniciará automáticamente con sudo.
Usa subprocess.run(['sudo', 'python3'] + sys.argv) para reejecutar el script actual con sudo. Esto mantiene cualquier argumento que hayas pasado al script.
Lógica del programa:

El script primero comprueba si tiene privilegios de superusuario usando check_sudo().
Si no es así, se reinicia automáticamente con sudo para obtener los permisos necesarios y ejecutar el comando arp-scan correctamente.
Después de obtener los permisos adecuados, continúa con el flujo normal: obtener la interfaz de red y ejecutar el escaneo de dispositivos.
Ejecución del script:
Ahora puedes ejecutar el script sin tener que usar sudo manualmente:


Este enfoque es útil cuando quieres asegurarte de que el script siempre tenga privilegios adecuados para ejecutar comandos que requieren permisos elevados, como arp-scan.


Se utiliza getpass.getpass() para solicitar la contraseña de sudo al usuario de forma segura (sin que la contraseña se muestre en la pantalla).
Opción -S de sudo:

Se ha añadido la opción -S al comando sudo en subprocess.run(). Esto permite que sudo acepte la contraseña desde la entrada estándar (stdin) en lugar de solicitarla directamente a través de la terminal.
Enviar la contraseña a stdin:

La contraseña introducida por el usuario se pasa a través del parámetro input de subprocess.run(), que envía la contraseña directamente al comando sudo.

Flujo del programa:

Si el script detecta que no tiene permisos de superusuario, solicitará la contraseña y reejecutará el script automáticamente con sudo, utilizando la contraseña ingresada por el usuario.
Ejecución del script:
Puedes ejecutar el script sin sudo como antes, y se pedirá la contraseña si es necesario:


Cuando se soliciten permisos de superusuario, el script pedirá la contraseña en la terminal. Si la contraseña es correcta, se volverá a ejecutar el script con los permisos adecuados.

Nota:
Este enfoque es útil para evitar tener que ejecutar el script directamente con sudo, y también para mejorar la seguridad al no dejar la contraseña visible.


Una solución simple es asegurarse de que el script se está ejecutando directamente desde una terminal interactiva real. Pero si deseas que la entrada de la contraseña funcione correctamente en cualquier contexto, puedes usar una combinación de herramientas para evitar este error. Una opción es hacer que el propio comando sudo solicite la contraseña en lugar de gestionarla mediante getpass.


Ya no solicitamos manualmente la contraseña usando getpass. En lugar de eso, simplemente dejamos que sudo maneje la solicitud de la contraseña en la terminal.
Ejecutar con sudo:

Si el script no se está ejecutando como superusuario, se reiniciará automáticamente con sudo (sudo python3 script.py), y sudo pedirá la contraseña al usuario de manera normal. Esto evita problemas relacionados con la entrada de contraseña a través de getpass en ciertos entornos.

Flujo del programa:

El script verifica si tiene permisos de superusuario y, si no es así, se reinicia con sudo, permitiendo que sudo maneje la interacción con el usuario para la contraseña.
Ejecución del script:
Puedes ejecutar el script como de costumbre, sin sudo, y el programa pedirá la contraseña automáticamente cuando sea necesario:

Puesdes poner en el bash de tu consola
Copiar código
python3 Ejercicio_Aula_Sep_29.py
Si no tienes permisos de superusuario, sudo te pedirá la contraseña de forma normal, como lo haría en cualquier comando de terminal.

Nota:
Este enfoque garantiza que la entrada de la contraseña sea gestionada directamente por sudo, lo que evitará problemas con el manejo de la contraseña en diferentes entornos.


Cuando ejecutas el comando con sudo, el sistema te pedirá la contraseña de superusuario antes de ejecutar el script. Dado que ya estás ejecutando el script con permisos elevados, no necesitarás incluir la lógica para reiniciar el script con sudo dentro del código.

Simplificación del código si usas sudo directamente
Si prefieres siempre ejecutar el script directamente con sudo, puedes simplificar el código y eliminar la verificación de superusuario. Aquí te dejo una versión simplificada del programa, ya que no necesitas verificar si el script tiene permisos de root (esto será garantizado por el uso de sudo en la terminal):



bash
Copiar código
sudo python3 Ejercicio_Aula_Sep_29.py
Este enfoque es más sencillo si ya estás acostumbrado a ejecutar comandos que requieren permisos de superusuario.

Nota:
Importante comprobar otra vez: Asegúrate de que tienes instalada la herramienta arp-scan en tu sistema, ya que es esencial para este programa. Puedes instalarla ejecutando:


bash
Copiar código
sudo apt-get install arp-scan
Ahora que ejecutas el script con sudo desde el principio, no tendrás problemas relacionados con permisos.

En caso de problemas.
Es extraño que al ejecutar el script con sudo no obtengas ningún resultado, ya que el uso de sudo debería garantizar que arp-scan tenga los permisos necesarios para funcionar correctamente. Sin embargo, podrían estar ocurriendo algunos problemas que podemos revisar:

Posibles causas:
arp-scan no está instalado: Asegúrate de que la herramienta arp-scan está instalada. Si no lo está, puedes instalarla con:

bash
Copiar código
sudo apt-get install arp-scan
Interfaz de red incorrecta: Puede que la interfaz que el script detecta no sea la correcta (por ejemplo, si estás conectado a través de Wi-Fi pero detecta una interfaz Ethernet). Verifica que la interfaz detectada sea la que está en uso.

Para confirmar qué interfaz de red estás usando, también puedes ejecutar manualmente:

bash
Copiar código
ip link
Asegúrate de que la interfaz que está en "estado UP" (activa) es la que quieres escanear. Si no es la correcta, podemos modificar el código para especificar manualmente la interfaz.


bash
Copiar código
sudo arp-scan -I INTERFAZ -l
Reemplaza INTERFAZ por el nombre de tu interfaz de red activa (por ejemplo, wlp3s0 si es Wi-Fi).

Permisos de sudo en el script: A veces, sudo puede no pasar bien la contraseña o no funcionar adecuadamente dentro de un script. Si este es el caso, prueba ejecutando todo manualmente para asegurarte de que el problema no esté en la interacción con sudo.

Ajustes al script:
Vamos a ajustar el script para que imprima más información de depuración, lo que nos ayudará a identificar el problema exacto.


Ejecuta este código modificado para que imprima más detalles de depuración, como la salida del comando ip link. Esto nos permitirá verificar qué interfaz está detectando.

Si el script detecta la interfaz incorrecta o ninguna interfaz, revisa el comando ip link para asegurarte de que tienes la interfaz correcta en estado "UP".

Prueba arp-scan manualmente en la terminal con la interfaz correcta:

bash
Copiar código
sudo arp-scan -I INTERFAZ -l
Si arp-scan manualmente funciona bien, pero el script no, entonces es posible que haya un problema en cómo el script maneja los comandos.

Análisis adicional, con estas preguntas puedes solucionar los errores, haceroslas en el Aula, siempre se aprende:
¿El script detecta correctamente tu interfaz de red?
¿La salida de arp-scan manual te muestra resultados?
Estos pasos nos ayudarán a depurar el problema.onales.

A continuacion os pongo una salida típica del comando hecha en la consola de mi portatil, hacerlo en el Aula:
sudo arp-scan -I wlo1 -l
Interface: wlo1, type: EN10MB, MAC: 1c:4d:70:0e:0e:fc, IPv4: 192.168.0.18
Starting arp-scan 1.9.7 with 256 hosts (https://github.com/royhills/arp-scan)
192.168.0.1 3c:98:72:2e:4f:f2 Sercomm Corporation.
192.168.0.19 64:66:24:aa:34:b6 Sagemcom Broadband SAS
192.168.0.13 7e:cb:c5:38:37:f0 (Unknown: locally administered)

Dado que el comando arp-scan funciona perfectamente cuando lo ejecutas manualmente en la terminal pero no dentro del programa Python, es probable que el problema esté relacionado con cómo el script maneja la salida de arp-scan. Puede haber varios factores que están afectando la forma en que el programa ejecuta arp-scan o captura su salida.


Al eliminar la captura de salida para que puedas ver directamente los resultados en la terminal en lugar de capturarlos en el script.
Usa subprocess.Popen en lugar de subprocess.run para tener un control más fino sobre cómo se maneja la salida.

Cambios realizados:
subprocess.Popen:
Usamos subprocess.Popen en lugar de subprocess.run para ejecutar arp-scan y leer la salida en tiempo real. Esto nos da más control sobre cómo se captura y procesa la salida.
Impresión en tiempo real:
Ahora el programa imprime la salida directamente en la terminal mientras se ejecuta arp-scan, tal como sucede cuando ejecutas el comando manualmente. Esto debería darte los mismos resultados que ves cuando lo ejecutas en la terminal.
Ejecución:
Guarda este nuevo código en tu archivo Ejercicio_Aula_Sep_29.py

Ejecuta el programa con sudo:

bash
Copiar código
sudo python3 Ejercicio_Aula_Sep_29.py
Qué esperar:
Ahora, deberías ver la salida de arp-scan directamente en la terminal, tal como sucede cuando lo ejecutas manualmente. Esto debería ayudarte a identificar si hay algún problema con la captura de la salida o la ejecución dentro del programa Python.


También podemos modificar el código para que sudo lea la contraseña desde la entrada estándar (-S), lo que permitirá que el programa te pida la contraseña y la pase correctamente a sudo.


Opción sudo -S:
Ahora el comando sudo usa la opción -S, que permite que la contraseña sea leída desde la entrada estándar (stdin).
Manejo de la contraseña:
Utilizamos la función getpass.getpass() para solicitar la contraseña del usuario de forma segura sin que se muestre en pantalla.
La contraseña se pasa al proceso sudo a través de process.communicate().
Pasos para ejecutar:
Guarda el script Ejercicio_Aula_Sep_29.py

Ejecuta el script sin sudo porque el propio script manejará la contraseña:

bash
Copiar código
python3 Ejercicio_Aula_Sep_29.py

¿Qué esperar?
El programa te pedirá que ingreses tu contraseña de sudo.
Una vez ingresada la contraseña, el comando arp-scan debería ejecutarse correctamente y mostrar los dispositivos conectados a la red.
Ahora podemos probar estos, queridos alunmnos para mirar si funcionan las modificaciones.
----------------------------------------------------------------------
----------------------------------------------------------------------
VAMOS A COLOCAR AQUI EL CODIGO FINAL, DESPUES DE TODAS LAS MODIFICACIONES REALIZADAS-
******************************************************************
import subprocess
import re
import getpass

def get_network_interface():
try:
# Ejecutar 'ip link' para obtener las interfaces de red
print("Ejecutando 'ip link' para obtener la interfaz de red...")
result = subprocess.run(['ip', 'link'], capture_output=True, text=True)

if result.returncode != 0:
print("Error al ejecutar ip link:", result.stderr)
return None

# Imprimir la salida completa para depuración
print("Salida completa de 'ip link':")
print(result.stdout)

# Usar una expresión regular para encontrar interfaces que estén activas (estado UP)
interfaces = re.findall(r'\d+: (\w+):.*state UP', result.stdout)

if interfaces:
# Retornar la primera interfaz que esté en estado UP
return interfaces[0]
else:
print("No se encontraron interfaces de red activas.")
return None

except Exception as e:
print(f"Error al obtener la interfaz de red: {e}")
return None

def scan_network(interface):
try:
# Pedir la contraseña del superusuario
password = getpass.getpass("Introduce la contraseña de sudo: ")

# Ejecutar el comando 'arp-scan' especificando la interfaz con sudo -S
print(f"Ejecutando 'arp-scan' en la interfaz {interface}...")

# Usar subprocess.Popen para pasar la contraseña al comando sudo
process = subprocess.Popen(['sudo', '-S', 'arp-scan', '-I', interface, '-l'],
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
text=True)

# Pasar la contraseña al proceso
stdout, stderr = process.communicate(input=password + '\n')

# Imprimir la salida del escaneo
if process.returncode == 0:
print("Dispositivos conectados a la red:")
print(stdout)
else:
print(f"Error al ejecutar arp-scan: {stderr}")

except Exception as e:
print(f"Hubo un error al escanear la red: {e}")

if __name__ == "__main__":
print("Obteniendo la interfaz de red activa...")
interface = get_network_interface()

if interface:
print(f"Interfaz de red activa: {interface}")
print("Escaneando dispositivos conectados a la red Wi-Fi...")
scan_network(interface)
else:
print("No se encontró ninguna interfaz de red activa. Verifica tu conexión.")

********************************************************************
GRACIAS, NOS VEREMOS EN EL AULA.

****************************************************************************************************************
Aula_18_Apli_Sep_Schrodinger_Oxigeno.py
***************************************

Proponemos, para el Aula 18, dentro del tema de la ecuación de Schrödinger, una aplicación realizada en lenguaje Python, donde aplicamos la ecuación de Schrödinger, para determinar la posible posicion sobre un electrón de la primera capa en un átomo de Oxigeno.

Explicación del Código

Parámetros y constantes:
Se definen las constantes físicas necesarias como la constante de Planck reducida (hbar), la carga del electrón (e), la masa del electrón (m_e), la permitividad del vacío (epsilon_0), y el número atómico del oxígeno (Z = 8).

Malla radial: Se crea una malla en el espacio radial para resolver la ecuación diferencial utilizando el método de diferencias finitas.

Potencial coulombiano: Se calcula el potencial de Coulomb debido al núcleo, que es la parte central de la energía potencial en el sistema.

Matriz Hamiltoniana: Se construye la matriz Hamiltoniana usando diferencias finitas.
Resolución de la ecuación de Schrödinger: Se obtienen los autovalores y autovectores de la matriz Hamiltoniana. El autovalor más bajo corresponde a la energía del estado fundamental (1s).

Normalización y cálculo de la probabilidad radial: La función de onda se normaliza y se calcula la densidad de probabilidad radial.

Gráfica: Se grafica la densidad de probabilidad radial en función de la distancia radial.
Consideraciones
Este código resuelve la ecuación de Schrödinger para un electrón en un campo de Coulomb, que es una aproximación simplificada para el átomo de hidrógeno. Para el átomo de oxígeno, este modelo no considera las interacciones electrón-electrón ni la repulsión entre electrones, pero proporciona una idea básica sobre la distribución de probabilidad de un electrón en el orbital 1s.

Este programa aplica muy básicamente la ecuación Schrödinger, explicando una forma de iniciación
que resuelve la posivilidad probabilistica de encontrar la párticula, como se puede ver en el gráfico resultante.

Durante el código, explicamos lo más conciso posible los pasos más importantes. En el aula, durante la segunda semana de spetiembre trataremos de explicar el resto de las dudas, así como aumentar la complejidad del
código para acercarlo lo más posible a la realidad CUÁNTICA.

-----------------------------------------------------------------------------------------------------
Programa realizado bajo Linux, sistema operativo: Ubuntu 20.04.6 LTS.
Editor Sublime text.
Ejecución:python3 Aula_18_Apli_Sep_Schrödinger_Oxigeno.py

Propongo el sencillo ejercicio en phyton : Aula_28_Ag.24_Espectro_Masas.py. Este ejercicio elabora una pequeña simulación planteando una espectrometría de una molécula de agua. Explicaremos, previamente un poco, en que consiste las espectrometría de masas.
-----------------------------------------------------------------------------------------------------------------------------------

La espectrometría de masas (MS, por sus siglas en inglés) es una técnica analítica utilizada para medir la relación masa/carga (m/z) de los iones presentes en una muestra. En el contexto de una molécula, como la del agua (H₂O), la espectrometría de masas permite identificar y cuantificar los fragmentos iónicos que resultan de la ionización de la molécula, lo que a su vez proporciona información sobre su estructura molecular y su composición.

Principios Básicos de la Espectrometría de Masas

Ionización:
-------------
La muestra, que puede ser un sólido, líquido o gas, se introduce en el espectrómetro de masas, donde se somete a un proceso de ionización. Este proceso convierte las moléculas en iones cargados (generalmente positivos) al agregar o quitar electrones.
Existen varios métodos de ionización, como la ionización por impacto electrónico (EI), electrospray (ESI), y ionización química (CI), entre otros.

Aceleración:
---------------
Los iones generados se aceleran mediante un campo eléctrico, de modo que todos los iones con la misma carga tengan la misma energía cinética.

Deflexión:
------------
Los iones acelerados pasan a través de un campo magnético o eléctrico que los desvía en función de su relación masa/carga (m/z). Los iones más ligeros y con una mayor carga se desvían más que los iones más pesados.

Detección:
-------------
Los iones desviados impactan en un detector que mide la intensidad de la señal, la cual está relacionada con la cantidad de iones presentes. La intensidad se registra para cada valor de m/z, generando así un espectro de masas.
Interpretación del Espectro de Masas

El resultado de la espectrometría de masas es un gráfico denominado espectro de masas, donde:

Eje X: Representa la relación masa/carga (m/z) de los iones.
Eje Y: Representa la intensidad o abundancia relativa de los iones detectados.
Cada pico en el espectro corresponde a un ion con una relación m/z específica. La altura del pico indica la cantidad relativa de ese ion en la muestra.

Aplicación a la Molécula de Agua (H₂O)
-----------------------------------------------------------
Para una molécula simple como el agua, la espectrometría de masas puede revelar varios iones, dependiendo del método de ionización:
----------------------------------------------------------------------------------------------------------------------------------
H₂O⁺ (m/z = 18): Ion molecular de agua sin fragmentar.
OH⁺ (m/z = 17): Fragmento ionizado que resulta de la pérdida de un átomo de hidrógeno.
O⁺ (m/z = 16): Ion de oxígeno, que podría resultar de la fragmentación de la molécula.
H⁺ (m/z = 1): Ion de hidrógeno.
En un espectro de masas de agua, podrías ver picos en estos valores de m/z, reflejando la presencia de estos fragmentos iónicos.

Ejemplo de Uso en Química y Biología.
---------------------------------------------------
Identificación de Compuestos: Al comparar el espectro de masas de una muestra con espectros de referencia, los químicos pueden identificar compuestos desconocidos.
Determinación de Estructuras Moleculares: La forma en que una molécula se fragmenta puede proporcionar pistas sobre su estructura química.
Cuantificación de Análisis: La espectrometría de masas también se usa para cuantificar la cantidad de un compuesto en una muestra, especialmente en el análisis de mezclas complejas.
Conclusión
La espectrometría de masas es una herramienta poderosa para estudiar las propiedades de las moléculas al identificar sus fragmentos iónicos y medir sus relaciones masa/carga. En la práctica, esta técnica tiene aplicaciones en química, biología, farmacología y muchas otras disciplinas científicas.

******************************************************************************************



Simulación del Espectro de Masas
--------------------------------------------------------
El espectro de masas para una molécula de agua podría incluir los siguientes iones:

H₂O → m/z = 18 (ion molecular)
OH → m/z = 17
O → m/z = 16
H → m/z = 1



Explicación del Código:
Fragmentos y sus m/z: Definimos las relaciones m/z para diferentes fragmentos posibles de la molécula de agua (H2O+, OH+, O+, H+).

Intensidades Relativas: Asignamos intensidades relativas a estos picos basadas en la probabilidad de fragmentación.

Espectro Simulado: Generamos un espectro de masas añadiendo picos gaussianos centrados en los valores de m/z definidos.

Visualización: El gráfico muestra la relación masa/carga (m/z) en las abscisas y la intensidad relativa en las ordenadas.

Resultado:
Al ejecutar este código, obtendrás un gráfico que simula un espectro de masas para una molécula de agua, donde se visualizan los diferentes iones generados por la fragmentación de la molécula. Este es un modelo simplificado, pero proporciona una base para entender cómo se podrían visualizar los datos obtenidos en un espectrómetro de masas.
-------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------
El ejercicio fue realizado en una plataforma linux. Concretamente en: Ubuntu 20.04.6 LTS.
Fue editado con Sublime text.
Ejecutado bajo consola Linux con el siguiente comando:
python3 Aula_28_Ag.24_Espectro_Masas.py

Se deberán tener cargados los siguientes módulos:
import numpy as np
import matplotlib.pyplot as plt

Ejecutado con python en versión:3
-------------------------------------------------------

Programa para generar gifs animados a partir de vídeos, que se ejecuta en la línea de comandos.
ARGUMENTOS:
-src/--source: Nombre del vídeo original (obligatorio).
-dest/--destination: Nombre del archivo a generar (opcional).
-sz/--size: Tamaño en porcentaje del gif respecto al vídeo original (opcional).
-shw/--show: Muestra resultado en ventana emergente al finalizar el proceso de generado (opcional).
-st/--start: Segundo inicial para gif (opcional).
-e/--end: Segundo final (opcional).
-spd/--speed: Velocidad relativa de la animación (opcional)

PARA CUALQUIER DUDA U OBSERVACIÓN, USEN LA SECCIÓN DE COMENTARIOS.

Programa para reproducir archivos de audio que incorpora la posibilidad de crear una lista de favoritos.
El programa necesita de un archivo "json" que se generará al ejecutarse por primera vez.
PARA CUALQUIER DUDA U OBSERVACIÓN USEN LA SECCIÓN DE COMENTARIOS.