Códigos Fuente de Python

Mostrando del 1 al 10 de 770 registros
<<>>
Imágen de perfil
Val: 712
Bronce
Ha aumentado 1 puesto en Python (en relación al último mes)
Gráfica de Python
Actualizado

Visor de gráficos financieros (nueva versión)


Python

estrellaestrellaestrellaestrellaestrella(1)
Actualizado el 24 de Julio del 2024 por Antonio (76 códigos) (Publicado el 18 de Abril del 2022)
3.835 visualizaciones desde el 18 de Abril del 2022
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.
fg
Imágen de perfil
Val: 712
Bronce
Ha aumentado 1 puesto en Python (en relación al último mes)
Gráfica de Python
Actualizado

Generador de gifs a partir de video, en línea de comandos.


Python

estrellaestrellaestrellaestrellaestrella(6)
Actualizado el 24 de Julio del 2024 por Antonio (76 códigos) (Publicado el 9 de Diciembre del 2022)
9.921 visualizaciones desde el 9 de Diciembre del 2022
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.

mk
Imágen de perfil
Val: 712
Bronce
Ha aumentado 1 puesto en Python (en relación al último mes)
Gráfica de Python

Vista 'grid' (demo)


Python

Actualizado el 30 de Junio del 2024 por Antonio (76 códigos) (Publicado el 31 de Julio del 2023)
4.497 visualizaciones desde el 31 de Julio del 2023
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.

grid
Imágen de perfil

Espacio Hilbert. Suma de dos ondas.


Python

Publicado el 28 de Junio del 2024 por Hilario (132 códigos)
240 visualizaciones desde el 28 de Junio del 2024
*********************************************************************************************************

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
Figure_1
Imágen de perfil

Series de Fourier.


Python

Publicado el 24 de Junio del 2024 por Hilario (132 códigos)
181 visualizaciones desde el 24 de Junio del 2024
Figure_1

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


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
----------------------------------------------------------
Imágen de perfil

Graficado Integrales matemáticas.


Python

Publicado el 22 de Junio del 2024 por Hilario (132 códigos)
188 visualizaciones desde el 22 de Junio del 2024
Figure_1
Figure_2

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


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.
Imágen de perfil

Orbitales


Python

Publicado el 15 de Junio del 2024 por Hilario (132 códigos)
205 visualizaciones desde el 15 de Junio del 2024
Figure_1

***********************************************************************************************************
-----------------------------------------------------------------------------------------------------------------------------
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.
Imágen de perfil
Val: 712
Bronce
Ha aumentado 1 puesto en Python (en relación al último mes)
Gráfica de Python

Lector, por cámara, de códigos "QR"


Python

estrellaestrellaestrellaestrellaestrella(12)
Actualizado el 14 de Junio del 2024 por Antonio (76 códigos) (Publicado el 22 de Abril del 2020)
43.218 visualizaciones desde el 22 de Abril del 2020
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").

qrcc
qrcm1
Imágen de perfil

Red Neuronal CNN, selección de características.


Python

Publicado el 3 de Junio del 2024 por Hilario (132 códigos)
319 visualizaciones desde el 3 de Junio del 2024
imagen
Figure_1

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






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.
Imágen de perfil

Repaso graficos con matplotlib


Python

Publicado el 29 de Mayo del 2024 por Hilario (132 códigos)
223 visualizaciones desde el 29 de Mayo del 2024
Figure_1


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

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