Historial de los últimos códigos añadidos

Juego de Tres en raya en pantalla de texto.

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.

app contable para redes inalámbricas y pantallas táctiles.

Juego de tres raya para Gwbasic o Qbasic en pantalla de texto.

****************************************************************************************************************
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

El siguiente código muestra un grid en pantalla por el que se puede desplazar usando los botones de dirección:

Botón de dirección derecha: Desplazamiento hacia la derecha.
Botón de dirección izquierdo: Desplazamiento a la izquierda.
Botón de dirección superior: Desplazamiento hacia adelante.
Botón de dirección inferior: Desplazamiento hacia atrás.
Botones 'o', 'p', 'k' y 'l': Desplazamientos en diagonal.

Api para desarrolladores de consulta de CI y Ruc Ecuador

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.

La aplicación de línea de comandos es un ejemplo de uso de la librería Java.

La librería se basa en la librería de pdfbox, y funciona buscando el layout de cada página seleccionada del pdf, y buscando estructuras de tabla.

Tras la llamada a la librería (a la que hay que pasar el archivo de pdf, y el rango de páginas), el resultado es una List<PdfTextElement>.

PdfTextElement es una interfaz que tiene dos implementaciones.
* Un texto básico (fuera de las tablas)
* Y un PdfTextTabulaElement, para estructura de tablas.
Esta implementación permite leer las dimensiones de la tabla y el texto de cada celda de la tabla.

Es sólo una versión beta.
Si no te funciona con alguna tabla de tus PDFs, puedes escribir un comentario, y lo vemos

Cx es un programa para Windows.
Sirve para gestionar la contabilidad.
Produce: libro diario, auxiliar,
balanzas, recapitulación, estados financieros,
balance general, estado de pérdidas y ganancias,
estado de resultados y estados de cuentas.
Servosistema que administra
la oficina sin papeles.
Multiusuario cliente/servidor, red inalámbrica.
Código abierto. Trabajo a distancia.
Adjunto Cx Guía del rey de la creación

El siguiente script muestra en tiempo real las cotizaciones en bolsa, de acciones e índices bursátiles.
El programa utiliza un bucle en el que va realizando sucesivas peticiones de datos, usando 'yfinance'. Entre una petición y la siguiente, media un tiempo en segundos que viene determinado por la opción '-delay/--time_delay', teniendo un valor por defecto de 5 segundos y no pudiendo ser inferior a 0.5
Para detener la obtención de datos, pulsar la barra espaciadora. Al hacerlo, el programa mostrará el texto 'wait until application ends..' ya que tendrá que esperar el tiempo que quede restante del especificado por '-delay/--time_delay'. Finalizando definitivamente, transcurrido dicho tiempo restante.

ARGUMENTOS:
'-tick/--ticker' : Ticker o símbolo del valor cuya cotización se quiere obtener.
'-delay/--time_delay': Periodicidad, en segundos, entre una petición de datos y la siguiente.
'-clr/--color': Mostrar precio de cierre en color, en función de su fluctuación respecto del valor anterior.
'-uind/--use_index': Incluir esta opción para obtener cotizaciones de índices bursátiles (ej: ^IXIC, ^DJI..)

La petición de valores se interrumpe pulsando la barra espaciadora.
PARA CUALQUIER DUDA U OBSERVACIÓN, UTILICEN LA SECCIÓN DE COMENTARIOS.

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.

Aplicación en Java para chatear con la I.A. generativa Llama3.

* El usuario puede hablar al micrófono (speechToText), editar el texto reconocido y enviárselo a la I.A.

* La I.A. responde y el servidor va devolviendo esa respuesta en tiempo real, y las frases convertidas a audio (textToSpeech), y la aplicación las emite por el altavoz.

La aplicación está preparada para que únicamente haya un usuario ocupando los recursos del servidor, por lo que si el servidor está ocupado, en teoría no te dejará conectar.

Hay un vídeo de demostración que muestra el funcionamiento:

https://frojasg1.com:8443/resource_counter/resourceCounter?operation=countAndForward&url=https%3A%2F%2Ffrojasg1.com%2Fdemos%2Faplicaciones%2Fchat%2F20240815.Demo.Chat.mp4%3Forigin%3Dlawebdelprogramador&origin=web

Hola a todos aqui les dejo un generador de contraseñas que escribi en php, boostrap, css y javascript

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.

Programa para mostrar el precio de cierre, apertura, máximo y mínimo de las acciones de un activo para un determinado periodo de tiempo. También incluye representación de 'bandas de bollinger' y la media movil de 20 sesiones. Para mostrar la gráfica correspondiente a la información deseada, hacer click en el botón 'SHOW GRAPH'. Para cualquier duda u observación, utilicen la sección de comentarios.

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

Aula_26_Tecnología.py
******************************

Realizamos en lenguaje python. En un hipotetico espacio de Hilbert. La multiplicacion de dos ondas acusticas, con estos parámetros que os pongo a continuación:

Parámetros de las ondas:
frecuencia1 = 38 # Frecuencia de la primera onda (A4)
frecuencia2 = 36 # Frecuencia de la segunda onda (E5)
duracion = 12.0 # Duración en segundos
fs = 47100 # Frecuencia de muestreo

Mostraremos el resultado final graficamente. Al mismo tiempo deberemos guardar el archivo
resultante de sonido en (Debes de modificarla en tu caso) en esta ruta: /home/margarito/python/Mi_Archivo.wav.
Tambien se ejecutará el archivo de sonido incluyendo el código en el propio programa python.


Resumen del Ejercicio

En este ejercicio, hemos creado un programa en Python que realiza las siguientes tareas:

Definición de Parámetros:

Se definen dos frecuencias (38 Hz y 36 Hz), una duración de 12 segundos y una frecuencia de muestreo de 47100 Hz.

Generación de Ondas:

Se generan dos ondas sinusoidales (onda1 y onda2) con las frecuencias especificadas utilizando numpy.

Multiplicación de Ondas:

Las dos ondas generadas se multiplican para obtener una onda resultante (resultado).

Guardado de la Onda Resultante:

La onda resultante se guarda en un archivo de sonido WAV, usando soundfile.

Visualización Gráfica:

Se muestran gráficas de las dos ondas originales y la onda resultante en una figura con tres subgráficos utilizando matplotlib.

Reproducción del Sonido:

El archivo de sonido resultante se reproduce utilizando sounddevice.

----------------------------------------------------------------
Ejercicio realizado bajo Linux, con Ubuntu 20.04.6 LTS.
Editado con Sublime text. Ejecutado bajo consola Linux.


Para que todo funcione, deberemos instalar sounddevice.
Abre una terminal y ejecuta el siguiente comando para instalar portaudio:


sudo apt-get install portaudio19-dev
Paso 2: Instalar sounddevice usando pip.
Si pip no lo tienes instalado deberás instalarlo.

sudo apt-get install python3-pip
Luego, instala sounddevice:

pip3 install sounddevice

-------------------------------------------
Ejecución del ejercicio, bajo consola linux:
python3 Aula_26_Tecnología.py

--------------------------------------------------------------------------------------------------------------
**********************************************************************************************


Fourier_Aula_28_Junio_24.py
**********************************

Antes de empezar,queridos alunmnos, vamos a explicar, para entendernos lo mejor posible, que es una serie de Fourier:

Imagina que tienes una onda compuesta por varias frecuencias mezcladas, como la melodía de una canción. Las series de Fourier son como una herramienta matemática que te permite descomponer esa onda compleja en sus partes más simples: ondas sinusoidales (ondas de seno y coseno) de diferentes frecuencias.

Es como si tuvieras un prisma que descompone la luz blanca en los colores del arcoíris. Las series de Fourier hacen lo mismo con las ondas: las descomponen en sus "colores" individuales, que son las ondas sinusoidales de diferentes frecuencias.

En resumen:
**************

¿Qué son? Las series de Fourier: son una forma de representar funciones periódicas (que se repiten a lo largo del tiempo) como una suma de ondas sinusoidales más simples.

Y te preguntarás ¿Para qué sirven? Sirven para analizar y comprender mejor las funciones periódicas, como las ondas de sonido, las señales de audio o las vibraciones.

¿Cómo funcionan? Descomponen la función periódica en una suma infinita de ondas sinusoidales de diferentes frecuencias. Cada onda sinusoidal tiene una amplitud y una frecuencia específica, y juntas reconstruyen la función original.

Un ejemplo sencillo:
*************************
Imagina una onda triangular, como la de los dientes de una sierra. Las series de Fourier la descompondrían en una suma de ondas sinusoidales, una con la frecuencia fundamental de la onda triangular (la frecuencia más baja), y otras con frecuencias que son múltiplos de la fundamental (2 veces, 3 veces, 4 veces...). Cada onda sinusoidal tendría una amplitud específica, y juntas recrearían la forma de la onda triangular original.

Aplicaciones:
*****************
Las series de Fourier tienen muchas aplicaciones en diversos campos, como:

*Procesamiento de señales:
*******************************
Se utilizan para analizar y modificar señales de audio, video e imágenes.

*Comunicaciones:
*******************
Se utilizan para transmitir señales de forma eficiente a través de canales de comunicación.

*Física:
*******
Se utilizan para modelar fenómenos como la vibración, la onda y la transferencia de calor.

*Matemáticas:
***************
Se utilizan para estudiar la convergencia de series infinitas y la teoría de las funciones.

En resumen, las series de Fourier son una herramienta matemática poderosa para analizar y comprender funciones periódicas. Son esenciales en muchos campos, desde la ingeniería hasta la física y la música.
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
EJERCICIO PROPUESTO.
-----------------------------------

El ejercicio propuesto lo llamaremos: Fourier_Aula_28_Junio_24.py.
A continuación os hago un pequeño resumen del mismo. No obstante, en la próxima clase podremos solucionar las dudas surgidas. El ejercicio, como véis, esta desarrollado en python.

Resumen del ejercicio:

Objetivo:
********
Este código en Python genera una onda sonora compuesta por la suma de armónicos de una frecuencia base, la visualiza y la guarda como un archivo de audio tipo .wav.

Explicación paso a paso:
---------------------------------
Importación de librerías:

numpy: Para realizar operaciones matemáticas con arrays.
matplotlib.pyplot: Para crear gráficos.
IPython.display.Audio: Para reproducir audio en el notebook (opcional).
scipy.io.wavfile: Para guardar la señal como un archivo de audio .wav.
pydub (opcional): Para reproducir el archivo de audio guardado (requiere instalación).

Definición de parámetros:

frecuencia_base: Frecuencia base de la onda (en Hz, por ejemplo, 440 Hz para la nota A4).
num_armonicos: Número de armónicos a sumar (por ejemplo, 10).
duracion: Duración total de la señal en segundos (por ejemplo, 4 segundos).
frecuencia_muestreo: Frecuencia de muestreo en Hz (determina la calidad del audio, 44100 Hz es común).

Creación del vector de tiempo:

t: Un array de numpy que contiene valores de tiempo desde 0 hasta duracion con frecuencia_muestreo muestras por segundo.

Inicialización de la señal:

señal: Un array de numpy inicializado con ceros del mismo tamaño que t.

Sumar armónicos:

Se realiza un bucle for desde 1 hasta num_armonicos.
Dentro del bucle, se calcula la frecuencia de cada armónico (frecuencia_n).
Se suma a la señal una onda sinusoidal con la frecuencia frecuencia_n y amplitud 1.

Normalizar la señal:

Se divide la señal por su valor máximo absoluto para que la amplitud esté entre -1 y 1.

Graficar la señal:

Se crea una figura de matplotlib.
Se grafica un segmento de la señal (t[:1000]) vs su amplitud (senal[:1000]).
Se añade un título, etiquetas de eje y se muestra el gráfico.

Reproducir el audio en el notebook (opcional):

Se crea un objeto Audio de IPython con la señal y la frecuencia de muestreo.
Se reproduce el sonido utilizando el objeto Audio.
Guardar la señal como un archivo de audio .wav:

Se utiliza la función write de scipy.io.wavfile para guardar la señal multiplicada por 32767 (para valores de audio de 16 bits) como un archivo .wav llamado serie_fourier.wav.

Reproducir el archivo de audio guardado (esto lo hacemos opcional, requiere pydub):
También podemos ejecutar el archivo una vez guardado.

Se importa AudioSegment y play de pydub.
Se carga el archivo de audio como un objeto AudioSegment.
Se reproduce el audio utilizando la función play.
En resumen, este código genera una onda sonora rica en armónicos a partir de una frecuencia base, la visualiza y la guarda en un formato de audio estándar (.wav) para que pueda ser escuchada.


*************************************************************************
Ejercicio realizado bajo linux.
Con Ubuntu 20.04.6 LTS.
Editado con Sublime text.
Ejecutado bajo consola con el sieguiente comando:
python3 Fourier_Aula_28_Junio_24.py
-------------------------------------------------------------------------
Para el correcto funcionamiento del ejercicio, deberemos de tener instalado en nuestro
sistema las siguientes librerías:

import numpy as np
import matplotlib.pyplot as plt
from IPython.display import Audio

También deberemos de tener instalados estos módulos,
instalańdolos bajo consola de linux, con los siguientes comandos:

sudo apt-get install ffmpeg
pip install pydub
----------------------------------------------------------

****************************************************************************************
-----------------------------------------------------------------------------------------------------


Gráfica_integral_Aula_28.py
********************************
Por petición de varios alumnos del Aula 28. Proponemos hoy el siguiente ejercicio en python, donde explicamos el concepto de la integración, como contrario a la derivación, mostrando gráficamente los resultados. Con el mismo, pretendemos que los alumnos, repasen este concepto matématico, y al mismo tiempo, se familiaricen con los gráficos en el potente lenguaje python, de los mejores en este aspecto.

Básicamente dentro del cálculo matemático, podemos decir, de la forma más sencilla posible que:

La integración en matemáticas es una operación que permite calcular el área bajo una curva o función. En términos sencillos, imagina que tienes un gráfico y quieres saber el espacio que ocupa una parte de él, por ejemplo, el área entre la curva y el eje horizontal (el eje x). La integración te ayuda a encontrar ese área de forma precisa.

Por ejemplo, si tienes una función que describe la velocidad de un coche a lo largo del tiempo, la integración de esa función te dirá la distancia total que ha recorrido el coche en ese periodo de tiempo.

La integración es la inversa de la derivación. Mientras que la derivada de una función te da la pendiente o la tasa de cambio de esa función, la integral te da el acumulado de esa tasa de cambio.

La integración es un concepto fundamental del cálculo y del análisis matemático. Se puede pensar en ella como la operación inversa a la derivación.

Interpretaciones geométricas:
Área bajo la curva: La integral definida de una función f(x) entre a y b representa el área encerrada entre la gráfica de f(x), el eje x y las líneas verticales x = a y x = b.

Acumulación:
La integral definida de una función f(x) entre a y b puede interpretarse como la acumulación de la cantidad f(x) a lo largo del intervalo [a, b].

Definición formal:
Integral indefinida: La integral indefinida de una función f(x) se define como la función F(x) cuya derivada es f(x). Se escribe como ∫ f(x) dx.

Integral definida:
La integral definida de una función f(x) entre a y b se define como el límite de las sumas de Riemann cuando el número de subintervalos tiende a infinito. Se escribe como ∫_a^b f(x) dx.

Aplicaciones:
La integración tiene una gran variedad de aplicaciones en matemáticas, física, ingeniería y otras áreas. Entre ellas se encuentran:

*Cálculo de áreas, volúmenes y longitudes de curvas.
*Estudio del movimiento de objetos.
*Análisis de circuitos eléctricos.
*Probabilidad y estadística.
*etc

BREVE DESCRIPCIÓN DE LO QUE HACE EL EJERCICIO.
********************************************************************

Aunque el código va siendo explicado en cada paso del ejercicio.Para no redundar a continuación os pongo los pasos más importantes del código.

*Definimos una función que vamos a integrar.
*Calculamos el área bajo la curva de esa función entre dos puntos.
*Generamos puntos para dibujar la función.
*Dibujamos la función en una gráfica.
*Sombreamos el área bajo la curva para mostrar visualmente la integral.
*Añadimos una etiqueta que muestra el área total calculada.
*Dividimos el área en pequeños segmentos y calculamos el área de cada uno.
*Etiquetamos los segmentos en la gráfica para mostrar sus áreas individuales.
*El gráfico final muestra la función, el área total bajo la curva y las áreas de pequeños segmentos, ayudando a entender cómo se suma el área total.

***********************************************************************************************************
-----------------------------------------------------------------------------------------------------------------------------
Proponemos este sencillo código: Aula_28_orbital.py . Con el fin de familiarizarmos con los entornos gráficos de Python.

El código genera gráficos 3D de orbitales atómicos utilizando matplotlib y mpl_toolkits.mplot3d.
Este tipo de visualización es excelente para representar la forma de los orbitales s, p y d en tres dimensiones.

Aquí está el análisis del código y una revisión para asegurarnos de que funcione correctamente:

Importar módulos:

mpl_toolkits.mplot3d se importa para poder crear gráficos 3D.
matplotlib.pyplot se importa como plt para funciones de trazado.
numpy se importa como np para cálculos numéricos.

Crear la figura y los subgráficos:

Se crea una figura (fig) con tamaño de 15x5 pulgadas.
Se crean tres subgráficos (ax1, ax2, ax3) con proyección 3D.

Definir los datos de los orbitales:

Para el orbital s, se utilizan coordenadas esféricas.
Para el orbital p, se utilizan coordenadas que representan la forma lobular.
Para el orbital d, se utilizan coordenadas que representan una forma de doble lóbulo.

Trazar superficies:

Cada subgráfico (ax1, ax2, ax3) utiliza plot_surface para trazar la forma del orbital en el espacio 3D.
Se ajustan los límites de los ejes (set_xlim, set_ylim, set_zlim) para asegurar que todos los gráficos tengan la misma escala y sean comparables.

Configuración de etiquetas y títulos:

Se establecen etiquetas para los ejes (set_xlabel, set_ylabel, set_zlabel) y títulos (set_title) para cada subgráfico.

Mostrar el gráfico:

plt.show() se utiliza al final para mostrar la figura completa con los tres subgráficos.
El código parece estar bien estructurado para visualizar los orbitales s, p y d en 3D.
-----------------------------------------------------------------------------------------------------------------------
Asegúrate de tener matplotlib y numpy instalados en tu entorno de Python para que funcione correctamente.

-------------------------------------------------------------------------------------------------------
El ejercicio fue realizado en un entorno Linux.
Plataforma Ubuntu 20.04.6 LTS.
Editado con Sublime txt.

El programa tiene como objeto principal, la lectura, haciendo uso de la cámara web, de códigos QR. Para ello, simplemente pulsaremos el botón "INICIAR LECTURA POR CAMARA" (que desplegará el visor de la cámara) y colocaremos el código a leer, delante de la cámara. A su vez, también podremos leer códigos QR, en formato "png" y "jpg" almacenados en nuestra computadora (para lo que usaremos la opción "CARGAR ARCHIVO". Finalmente, también podremos leer, directamente, un código que se encuentre visible en pantalla (botón "DETECTAR EN PANTALLA").

Laboratory Lite es un sistema para manejar o administrar analisis de laboratorio, personalizable se pueden crear los examenes y agregarle parametros , ver reportes y mas.

El sistema Laboratory Lite es gratis y open source, esta creada con la plantilla Core ui y bootstrap 5.

Tambien esta desarrollada usando PHP 8 y retrocompatible con PHP 7.

Entre los modulos del sistema cuenta con los siguientes:

Usuarios
Pruebas de laboratorio
Parametros para las pruebas de laboratorio
Examenes (Asignacion Prueba de Lab y paciente.)
Ventas (Lista de Examenes)
Pacientes
Usuarios

https://evilnapsis.com/2024/06/11/laboratory-lite-sistema-de-gestion-de-analisis-de-laboratorio/

***********************************************************************************************************************
------------------------------------------------------------------------------------------------------------------------------------------






Aula_28_Aprendizaje_RedNeuronal_CNN.py
-----------------------------------------------------------
**************************************************

Pretendemos alojar en esta ruta de mi ordenador:/home/margarito/python/PetImages, el directorio PetImages, que a su vez contiene otros dos directorios con el nombre cat y dog. Los mismos contienen imagenes de gatos y perros. Vamos a construir una red neuronal convolucional, que dada la imagen en esta ruta:/home/margarito/python/imagen.jpeg, determine si pertenece a un gato, o a un perro. También s deberá mostrar la imagen.

Lo primero que debemos hacer es el código que descargará los datos.

# Descargar el archivo de datos
url = "https://download.microsoft.com/download/3/E/1/3E1C3F21-ECDB-4869-8368-6DEBA77B919F/kagglecatsanddogs_5340.zip"
filename = "kagglecatsanddogs_5340.zip"
r = requests.get(url)
with open(filename, 'wb') as f:
f.write(r.content).
------------------------------------------------------------------------------------------------------------------------
Las partes del ejercicio a resaltar, son las siguientes:

En general, este ejercicio describe el proceso completo de implementación de una red neuronal convolucional (CNN) usando TensorFlow para clasificar imágenes de gatos y perros. A continuación se presenta un resumen de las partes más importantes:

1. Configuración Inicial y Descarga de Datos.
---------------------------------------------------------------
Se importa TensorFlow y otras bibliotecas necesarias.
Se descarga el dataset de gatos y perros desde una URL proporcionada y se descomprime en el directorio de trabajo.

2. Preparación de los Datos.
------------------------------------
Verificación de Imágenes: Se recorren las carpetas de imágenes para verificar que no haya archivos corruptos y se eliminan los que no son válidos.
Organización del Directorio: Se aseguran que las carpetas para las categorías cat y dog existan en el directorio base.

3. Preprocesamiento de los Datos.
---------------------------------------------
Se utiliza ImageDataGenerator para realizar una reescalado de las imágenes y dividir el conjunto de datos en entrenamiento y validación.
Generadores de Datos: Se crean generadores de datos para el conjunto de entrenamiento y de validación, especificando
el tamaño de las imágenes, el tamaño del batch, y el modo de clasificación binaria.

4. Construcción del Modelo CNN.
-------------------------------------------
Se define una arquitectura secuencial de la red neuronal con capas de:
Convolución: Tres capas convolucionales con activación ReLU.
Max-Pooling: Después de cada capa convolucional.
Flatten: Para convertir los mapas de características 2D a un vector 1D.
Densa: Una capa densa con 512 neuronas y activación ReLU.
Dropout: Con una tasa del 50% para reducir el sobreajuste.
Salida: Una capa de salida con activación sigmoide para la clasificación binaria.

5. Compilación del Modelo.
-----------------------------------
El modelo se compila utilizando el optimizador Adam y la función de pérdida de binary_crossentropy, con métrica de precisión.

6. Entrenamiento del Modelo.
------------------------------------------
El modelo se entrena durante 10 épocas utilizando los generadores de datos creados anteriormente.
Se calculan los pasos por época basados en el tamaño del conjunto de entrenamiento y validación.

7. Evaluación del Modelo.
--------------------------------------
Se evalúa el modelo usando el conjunto de validación y se imprime la precisión de validación.

8. Predicción de Nuevas Imágenes.
----------------------------------------------
Se carga una nueva imagen, se preprocesa y se realiza una predicción utilizando el modelo entrenado.
Se muestra la imagen junto con la predicción (gato o perro).

9- Características del EQUIPO donde se realizó el ejercicio.
----------------------------------------------------------------------------------
El ejercicio fue realizado en una plataforma Linux.
Con el sistema operativo Ubuntu 20.04.6 LTS.
Editado con Sublime text.

El adware del mismo es:
------------------------------------
Intel® Core™ i5-10400 CPU @ 2.90GHz × 12
Intel® UHD Graphics 630 (CML GT2)

Para llegar a esta exactitud o accuracy
157/157 [==============================] - 9s 56ms/step - loss: 0.8151 - accuracy: 0.8177
Validation accuracy: 81.77%, tardamos 2258.9 segundos.

Como se puede apreciar, mucho tiempo de ejecución, y muy forzado el equipo a dedicación completa.

------------------------------------------------------------------------------------------------
Ejecución bajo consola Linux:
python3 Aula_28_Aprendizaje_RedNeuronal_CNN.py.
Quien desee salvar el modelo, para experimentar con él
puede hacerlo añadiendo esta línea de código
a continuación del proceso de compilación:
# Guardar el modelo
model.save('modelo_cnn_gatos_perros.h5')
# Guarda en formato HDF5, indicando la ruta de tu ordenador donde se desee salvarlo.

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

Repaso-matplotlib-Aula-38-uranio-235.py
------------------------------------------------------
Con la idea de repasar la librería matplotlib, propongo este sencillo ejercicio de la representación aleatoria de un átomo de Uranio-235.
El ejercicio es de ejecución sencilla, y puede el alunno jugar con sus datos de entrada.
La librería matplotlib, es de uso habitual en todos los programas graficados, incluidos
los de inteligencia artificial.
----------------------------------------------------------------------------------------
Vamos a dar una pequeña descripción de Física cuántica, con el fin de entender este desarrollo.
********************************************************************************************
En la física cuántica, la idea de electrones orbitando alrededor del núcleo en trayectorias definidas, como planetas alrededor del sol, es incorrecta y ha sido reemplazada por un modelo más complejo y preciso.

En el modelo cuántico, los electrones no tienen órbitas definidas. En cambio, se describen mediante funciones de onda, que son soluciones a la ecuación de Schrödinger. Estas funciones de onda no nos dicen la trayectoria exacta de un electrón, sino la probabilidad de encontrar un electrón en una determinada región del espacio alrededor del núcleo. Esta región donde es más probable encontrar al electrón se llama "orbital".

Los orbitales tienen diferentes formas y tamaños, y cada uno corresponde a un nivel de energía específico. Los orbitales son esféricos, los p tienen forma de mancuerna, los d y f son más complejos. La densidad de probabilidad, que es la interpretación de la función de onda, nos da una "nube electrónica" donde la densidad de esta nube es mayor en las regiones donde es más probable encontrar al electrón.

En resumen:

Modelo Cuántico: En lugar de órbitas definidas, los electrones existen en "nubes de probabilidad" llamadas orbitales.
Funciones de Onda: Describen la probabilidad de encontrar un electrón en una determinada región del espacio.
Orbitales: Las diferentes formas (s, p, d, f) corresponden a diferentes distribuciones de probabilidad y niveles de energía.
Así que, efectivamente, los electrones están en un estado de movimiento continuo y no podemos determinar su posición exacta, sino solo la probabilidad de encontrarlo en un lugar determinado en un momento dado.


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

Podemos crear una visualización simple utilizando la biblioteca matplotlib en Python para representar el núcleo atómico y una nube de electrones en movimiento aleatorio. A continuación, os presento el código Repaso-matplotlib-Aula-38-uranio-235.py
para crear esta simulación:

Este código hace lo siguiente:

Configuración inicial: Define el número de electrones y el límite del espacio donde se moverán.
Posiciones iniciales: Genera posiciones iniciales aleatorias para los electrones dentro de un cubo centrado en el núcleo.
Gráfico: Configura el gráfico 3D utilizando matplotlib.
Núcleo y electrones: Dibuja el núcleo en el centro y los electrones en sus posiciones iniciales.
Función de actualización: Mueve los electrones aleatoriamente en cada fotograma, asegurándose de que permanezcan dentro de los límites definidos.
Animación: Utiliza FuncAnimation de matplotlib para animar el movimiento de los electrones.
Este es un modelo simplificado y no representa fielmente la mecánica cuántica, pero da una buena visualización de un núcleo y una nube de electrones moviéndose aleatoriamente alrededor
de él.

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

Umbral de órbita extrema: Se define una variable umbral_extremo que establece el límite a partir del cual consideramos que un electrón está en la órbita extrema.
Función de actualización:
Se calcula la distancia de cada electrón al núcleo usando np.linalg.norm.
Se separan los electrones en dos grupos: normales y extremos, según la distancia calculada.
Se limpian y vuelven a dibujar todos los elementos del gráfico en cada fotograma.
Se plotean los electrones normales en azul y los extremos en rosa.
Esto resaltará los electrones que están a punto de salirse de la órbita con un color rosa en la animación.

********************************************************************************************
Realizado en Linux, ubuntu.
Ejecución.
python3 Repaso-matplotlib-Aula-38-uranio-235.py

Definí un lenguaje Xml para generar salidas por la impresora, así como también un programa que lea los archivos Xml e imprima los mismos. Quizá pueda resultar útil para alguien que desee hacer salidas por impresora sin escribir código C#, sino escribiendo un archivo Xml y utilizando una librería que se incluye en el código (PrintFramework.dll). El programa tan sólo es una utilización de esa librería para poder apreciar cómo funciona la misma. Dentro del archivo comprimido está el código escrito en SharpDevelop y también un archivo de texto con las instrucciones para escribir los archivos xml para ser parseados por la librería, así como una reseña acerca del uso de la misma.