Los códigos más visitados de Python

Juego de la serpente con pyGame

Una calculadora creado con python

Programa para realizar filtrado de imagen en archivos de vídeo (preferiblemente de corta duración) utilizando el algoritmo de 'filtrado bilateral' pudiendo especificar los valores sigma de espacio y color y el diámetro del vecindario para cada pixel. Los vídeos filtrados se generan, por defecto, conservando su sonido, aunque se pueden generar sin este introduciendo el argumento '-ae'/'--exclude_audio'.

ARGUMENTOS:
-src/--source: Nombre del vídeo original (OBLIGATORIO)
-dest/--destination: Nombre del video a generar ('NewFilteredVid.mp4' por defecto)
-sgc/--sigma_color: Valor sigma para espacio de color (75 por defecto)
-sgs/--sigma_space: Valor sigma espacial (75 por defecto)
-pd/--pixel_diameter: Diámetro de la vecindad de píxeles (9 por defecto)
-ae/--exclude_audio: Excluir audio y generar video sin sonido (OPCIONAL)

PARA CUALQUIER DUDA U OBSERVACIÓN UTILIZEN LA SECCIÓN DE COMENTARIOS

Simple código que muestra como calcular el factorial de un número utilizando una función recursiva.

Esta es una calculadora hecha en Python 3 que responde a las necesidades de sumar, restar, multiplicar, dividir, etc.

(Se admiten sugerencias, críticas, felicitaciones, agradecimientos...)

Aplicación para codificar y decodificar mensajes de texto en imágenes.

La imagen se selecciona mediante el botón "SEARCH".
En el modo "Encode" el texto a ocultar se introduce en el espacio superior. (el programa generará un nuevo archivo de imagen cuyo nombre tendrá el prefijo "encoded_" delante del título del archivo original.
En el modo "Decode" el texto oculto se muestra en el espacio superior.

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


Repositorio en GitHub:
https://github.com/antonioam82/Steganography

Ejemplo que muestra como calcular los múltiplos de un número dado utilizando el resto de una división.
Para este ejemplo, se devuelven los múltiplos de 3 y 5 de entre los números 1 y 100

En este código, se define una lista de palabras para el juego de Wordle. Luego, se selecciona una palabra al azar de la lista. El jugador tiene un máximo de 5 intentos para adivinar la palabra secreta de 6 letras.

La función verificar_palabra compara la palabra ingresada por el jugador con la palabra secreta y devuelve True si son iguales. Si no son iguales, cuenta las letras correctas y las muestra al jugador.

La función principal jugar_wordle maneja el flujo del juego, solicita al jugador que ingrese una palabra y verifica si es correcta o no. Si el jugador adivina la palabra, se muestra un mensaje de felicitaciones. Si el jugador agota los intentos, se muestra la palabra secreta.

Puedes modificar la lista de palabras (palabras) según tus preferencias o agregar más lógica al juego, como restricciones adicionales o pistas.

Escribir un programa que pida al usuario un número entero y muestre por pantalla un triángulo como el de más abajo, de altura el número introducido.

El código está diseñado de forma que el programa le da la bienvenida al usuario; a continuación, le pide que ingrese los datos de las coordenadas x e y para dos puntos, los cuales serán los se utilizan para los cálculos.

A continuación se le presenta al usuario una interfaz de menú en el que aparecen tres opciones (que el usuario seleccionará introduciendo el número correspondiente de la opción):

1 - Calcular la distancia entre los puntos
2 - Calcular el punto medio entre los puntos
3 - Salir

En caso de que el usuario seleccione la opción 1 o la opción 2 se volverá a desplegar el menú. No obstante, si el usuario selecciona la tercera opción, el menú se cerrará y el programa terminará con una frase dándole las gracias al usuario por haber usado el programa.

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").

El código permite jugar al usuario contra el ordenador al mítico juego de piedra, papel o tijeras.

Muestra al usuario un menú donde debe elegir entre 'p' (piedra), 'h' (papel) o 't' (tijeras). Para ganar el juego, el usuario deberá de ganar 3 de 5 partidas. Si el usuario gana una partida se almacena en una lista de conteo de sus victorias, de la misma forma se realiza con las victorias del ordenador.

Programa para convertir cantidades de moneda a otras divisas (el programa muestra la tasa de cambio y el equivalente en la otra moneda) usando datos actualizados.


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

Implementación del clásico juego del Tetris, usando la librería de desarrollo de videojuegos 2D PyGame

El código muestra al usuario la simulación de una barra de carga.

La barra simula el movimiento con los siguientes elementos: '-', '\\', '|', '/': presenta una longitud de 24. La animación se realiza cada 0.2 segundos y, además, si ponemos 'i:=<' la barra gira de izquierda a derecha; si ponemos'i:=>', lo hará de derecha a izquierda y si ponmos 'i:=^' lo hará del centro hacia los extremos.

Espero que les guste :)

Este simple código es un ejemplo para visualizar como se puede crear un menú con varias opciones de manera sencilla.

Este código es una versión de la barra de carga que he publicado anteriormente.

La barra combina - y # para simular la parte que ya ha sido completada, y al final de la barra aparece el porcentaje que la barra lleva cubierto.

es un código simple pero que se puede usar para algún otro proyecto en el que se desee mostrar al usuario que el programa está cargando (por ejemplo).

Espero que les guste.

Un saludo programadores

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.

Nueva version de un punto de venta, la interfaz cambio respecto a la version anterior.

- se incorporan nuevos metodos de control.
- encriptacion en las contraseñas.
- implementacion de nuevas barras de menu.
- ahora es posible realizar ventas simultaneas (hasta 8).
- exportacion de ventas realizadas en el dia y por fecha en formato pdf.
- implementacion de menu contextual (click derecho) para agilizar el manejo del almacen.
- los datos de los productos solo son para ver el funcionamiento del programa.
- se pueden dar de baja productos temporalmente.
- se implementan atajos de teclado para mayor rapidez.
- no se adjunta la BD ya que se trata de que las personas que lo utilizan vayan llenando la BD con los productos que necesitan.


-esta version fue probada y desarrollada en linux, en teoria deberia funcionar en windows pero no estoy seguro.

Nueva versión del Juego de la Serpiente, en la que se ha incluido sonido y 3 archivos de audio (incluidos en la carpeta). Para usar el programa adecuadamente, simplemente hay que descomprimir la carpeta en la que se encuentra.
BOTONES:
Mover serpiente: Botónes de dirección
Pause y reanudar partida pausada : Barra espaciadora.
Finalizar partida: tecla "q"
PARA CUALQUIER PROBLEMA, NO DUDEN EN COMUNICÁRMELO.

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.

Valida RUT Chile

Una simple función que obtiene un rut y devuelve True o False según validación del rut.

Una calculadora de conversor de diferentes monedas de 3 paises: Euro a Dólar, Dólar a Euro, Peso Dominicano a Euro, Euro a peso dominicano.

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.

Aula_28_Recordatorio_Mayo.py
************************************

Bien, dada una matriz, con 8 característica, y 20 muestras.
Como la siguiente:

[[1.234 0.567 2.345 1.890 0.123 3.456 2.345 1.234]
[0.987 1.234 1.890 0.345 2.567 0.890 1.234 2.345]
[3.456 1.890 0.567 2.345 1.234 0.890 2.567 1.890]
[2.567 1.890 0.123 1.234 2.345 0.567 1.890 3.456]
[0.890 1.890 2.345 0.567 1.234 3.456 0.890 1.234]
[1.890 2.345 1.234 0.567 2.345 0.123 1.234 0.567]
[1.234 2.345 0.567 1.890 0.123 2.567 0.890 1.234]
[2.345 1.890 3.456 0.890 1.234 0.567 1.890 2.567]
[0.567 1.234 1.890 0.567 1.234 0.890 2.345 0.123]
[0.890 1.890 0.123 1.234 0.567 3.456 1.234 1.890]
[1.890 0.567 1.234 0.890 2.567 1.234 2.345 0.567]
[1.234 2.567 0.890 1.890 0.123 1.890 0.567 1.234]
[0.567 1.234 2.345 1.890 0.567 2.345 1.234 0.890]
[1.890 0.123 1.234 0.567 2.345 1.890 0.567 1.234]
[0.890 1.234 0.567 1.890 1.234 2.345 3.456 0.890]
[1.234 0.567 2.345 0.890 2.345 1.234 0.567 1.890]
[2.567 1.890 0.890 1.234 0.567 1.890 2.345 0.123]
[0.567 2.345 1.234 0.567 1.890 0.123 1.890 0.567]
[1.234 1.890 0.567 3.456 2.567 1.234 0.890 1.234]
[0.567 2.345 1.234 0.890 1.890 0.567 1.234 2.567]]


Planteamos una red neuronal sin utilizar ni keras ni tensorflow. Que entrena la red con esos valores, de 8 características, y 20 muestras o ejemplos.
Y que haga una prediccion de salida de la caracteristica correspondientes, a esta muestra dada:[1.345 2.890 0.456 1.890 12.234 10.567 1.890 12.567].

El ejercicio, tendría básicamente estos pasos:

1-Definición de funciones de activación y pérdida:
*******************************************************
Se define la función de activación ReLU (relu) y su derivada (relu_derivative).
ReLU es una función de activación comúnmente utilizada en redes neuronales debido a su simplicidad y buen desempeño en muchas tareas.
Se define la función de pérdida de error cuadrático medio (mean_squared_error).
Esta función calcula la diferencia cuadrática media entre las predicciones y las etiquetas verdaderas.

2-Implementación de la red neuronal:
*****************************************
Se crea una clase NeuralNetwork que representa una red neuronal de dos capas (una capa oculta y una capa de salida).
En el método __init__, se inicializan los pesos y sesgos de la red neuronal de manera aleatoria.
En el método forward, se realiza la propagación hacia adelante, calculando las salidas de la red neuronal.
En el método backward, se realiza la retropropagación del error, calculando los gradientes de los pesos y sesgos y actualizándolos utilizando el algoritmo de descenso de gradiente.
El método train entrena la red neuronal utilizando los datos de entrada y las etiquetas verdaderas durante un número específico de épocas.
El método predict realiza predicciones utilizando la red neuronal entrenada.

3-Entrenamiento de la red neuronal:
********************************
Se definen los datos de entrada (X_train) y las etiquetas verdaderas (y_train).
Los datos se normalizan dividiéndolos por su máximo valor para asegurar que estén en el rango [0, 1].
Se crea una instancia de la red neuronal con el tamaño de entrada, tamaño oculto y tamaño de salida dados.
La red neuronal se entrena utilizando los datos de entrenamiento durante 10000 épocas con una tasa de aprendizaje de 0.01.

4-Predicción:
*****************
Se define un nuevo conjunto de datos de entrada (X_new) para realizar una predicción.
Los datos de entrada se normalizan de la misma manera que los datos de entrenamiento.
Se realiza una predicción utilizando la red neuronal entrenada.
El resultado de la predicción se desnormaliza multiplicándolo por el máximo valor de las etiquetas verdaderas.
Se muestra el resultado de la predicción.

Según vemos su desarrollo podemos decir, que este ejercicio muestra cómo implementar una red neuronal básica desde cero en Python sin utilizar bibliotecas como Keras o TensorFlow. La red neuronal se entrena utilizando el algoritmo de retropropagación y se prueba haciendo una predicción sobre nuevos datos de entrada.

El alumno podrá interactuar con el ejercicio, modificando parametros como
valores de entrada, caracteristicas y muestras, para su mejor comprensión.



UNA SALIDA DEL EJERCICIO, PODRÍA SER LA SIGUIENTE:
****************************************************************************
Epoch 0, Loss: 11.7756050562224
Epoch 1000, Loss: 0.012417106163412383
Epoch 2000, Loss: 0.004855440981664029
Epoch 3000, Loss: 0.002804630823301262
Epoch 4000, Loss: 0.0019105925868362645
Epoch 5000, Loss: 0.0013765944597636112
Epoch 6000, Loss: 0.0010168157428455883
Epoch 7000, Loss: 0.0007730551039343544
Epoch 8000, Loss: 0.0006225694864747496
Epoch 9000, Loss: 0.0005176777148262488
Predicción de salida: [[-0.55685326 -0.9034264 -1.02152184 0.87943007 0.40507882 1.91684935
0.28005875 2.23286946]]
[Finished in 701ms]

***********************************************************************
El ejercicio fue realizado bajo plataforma linux.
Ubuntu 20.04.6 LTS.
Editado con Sublime text.
Ejecución:
python3 Aula_28_Recordatorio_Mayo.py
***********************************************************************

Código que simula la opción de sacar dinero de un cajero automático, en el que determina la cantidad de billetes a devolver según cantidad solicitada.

Script para realizar sumas, restas y multiplicaciones, con matrices, o con valores numéricos.

El siguiente programa genera valores hash para una contraseña, utilizando distintos algoritmos. También permite la copia de las salidas generadas.