Realizamos una pequeña comparativa de los sistemas de IA generativa: ChatGPT, Jan, Gemini y Copilot. Solicitamos la generación de código fuente Python. Realizamos una petición a estos sistemas de IA y mostramos el resultado que nos devuelve cada uno. Realizamos unas peticiones de modificación del código generado y mostramos el resultado. Indicamos las conclusiones analizando el código generado por cada uno de ellos.
- La petición que hacemos a cada sistema de IA generativa.
- Resultado en Jan con el modelo Llama 3.2 1B Instruct Q8 y Wizard Coder Python 13B Q4.
- Resultado en ChatGPT.
- Resultado en Copilot.
- Resultado en Gemini.
- Conclusiones de la comparativa de sistemas de IA generativa.
- Añadir petición de modificación de resultados.
- Conclusión de las modificaciones pedidas a los sistemas de IA.
La petición que hacemos a cada sistema de IA generativa
La petición que hacemos a los sistemas de IA generativa es:
necesito el código fuente en Python de un script que muestre una ventana Windows con un botón. Al pulsar el botón que obtenga en un label la memoria RAM total del equipo, la memoria RAM usada y la memoria RAM libre, en Gigabytes
En el mismo hilo de conversación les pediremos una modificación del código, con el siguiente prompt:
ok, el código es correcto, pero ahora quiero que me muestre también el espacio libre en todas las unidades de disco
Y una segunda modificación del código, con el prompt:
muéstrame el espacio libre de las unidades en TB
Resultado en Jan con el modelo Llama 3.2 1B Instruct Q8 y Wizard Coder Python 13B Q4
En el caso de Jan, un sistema de IA generativa que se instala en el equipo y funciona en local, admite múltiples modelos. Para esta comparativa usaremos dos modelos: Llama y Wizard Coder Python.
Resultado de Jan con el modelo LLama 3.2 1B Instruct Q8
En el caso de Jan con Llama, se obtiene este resultado:
Todo el resultado generado por Jan con el modelo Llama:
Para lograr esto, necesitaremos utilizar la biblioteca psutil para obtener información sobre el sistema operativo y los dispositivos. También necesitarás una ventana Windows con un botón que llame a la función get_memory_info() del módulo psutil. Aquí te dejo el código fuente:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
import psutil import win32gui def get_memory_info(): # Obtenemos la memoria total, usada y libre memory_total = psutil.virtual_memory().total / (1024.0 ** 3) memory_used = psutil.virtual_memory().used / (1024.0 ** 3) memory_free = psutil.virtual_memory().available / (1024.0 ** 3) # Obtenemos la memoria total, usada y libre de cada dispositivo devices = win32gui.GetDevicesFromWindow(win32gui.GetForegroundWindow()) for device in devices: if 'RAM' in device.Name.lower(): device_info = psutil.virtual_memory().percent / (1024.0 ** 3) print(f'Devices with RAM:n{device.Name}') for disk in [psutil.disk_usage(path) for path in device.path.split('')[-1].split('/')]: print(f'{disk.name}: {disk.percent}%') elif 'RAM' not in device_name.lower() and 'CPU' not in device_name.lower(): if 'RAM' in device_info: # El dispositivo es RAM memory_total = psutil.virtual_memory().total / (1024.0 ** 3) memory_used = psutil.virtual_memory().used / (1024.0 ** 3) memory_free = psutil.virtual_memory().available / (1024.0 ** 3) # Printar la información print(f'RAM:nTotal: {memory_total:.2f} GBnUsada: {memory_used:.2f} GBnLibre: {memory_free:.2f} GB') def main(): get_memory_info() if __name__ == '__main__': main() |
El script funciona como sigue:
- Define una función
get_memory_info()que recoge los datos de memoria total, usada y libre. - Obtiene la memoria total, usada y libre utilizando el módulo
psutil. - Obtiene la información sobre las dispositivos del sistema (RAM y CPU) mediante
win32gui.GetDevicesFromWindow()ypsutil.disk_usage(). - Encontrar un dispositivo que sea RAM se realiza de la siguiente manera:
Recuerda instalar psutil mediante pip: pip install psutil.
Ejecución de código Python generado por Jan con Llama
La ejecución del código Python generado por Jan con Llama, no funciona, usa el paquete win32gui que no se instala correctamente, ni tampoco indica cómo instalarlo.
Resultado de Jan con el modelo Wizard Coder Python 13B Q4
Si usamos el modelo Wizard Coder Python 13B Q4 en Jan, nos devuelve este resultado:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
import psutil from tkinter import * def memory_info(): total_memory = str(round((psutil.virtual_memory().total / (1024**3), 2)) + " GB") # Calcula la memoria RAM total en Gigabytes y la muestra en formato string used_memory = str(round((psutil.virtual_memory().used / (1024**3), 2)) + " GB") # Calcula la memoria RAM usada en Gigabytes y la muestra en formato string free_memory = str(round((psutil.virtual_memory().free / (1024**3), 2) + " GB")) # Calcula la memoria RAM libre en Gigabytes y la muestra en formato string memory_label.config(text="Total Memory: " + total_memory + "nUsed Memory: " + used_memory + "nFree Memory: " + free_memory) # Actualiza el label con los valores obtenidos root = Tk() # Inicializa la ventana de tkinter root.title("Memory Info") # Asigna un título a la ventana root.geometry("250x150") # Establece el tamaño de la ventana memory_label = Label(root, text="Memory information will appear here...", font=("Arial", 14)) # Crea un label para mostrar la información obtenida memory_label.pack() button = Button(root, text="Get Memory Info", command=memory_info) # Crea el botón que llamará a la función memory_info button.pack() root.mainloop() # Inicia el bucle de eventos de tkinter |
Ejecución de código Python generado por Jan con Wizard Coder Python 13B Q4
En este caso, el código generado se ajusta más a lo pedido, aunque tampoco funciona correctamente. Incluso para poder compilar tenemos que añadir un par de paréntesis de cierre en el el código. Al compilarlo, sí muestra la ventana y el botón que le pedimos:
Pero, al pulsar en el botón «Get Memory Info» devuelve un error y no muestra el resultado pedido.
Tal vez Jan requiera de peticiones en inglés para ser más preciso.
Resultado en ChatGPT
En el caso de ChatGPT, este es el resultado de la pregunta:
Todo el resultado detallado por ChatGPT:
Aquí tienes el código fuente en Python para un script que utiliza la biblioteca tkinter para crear una ventana con un botón. Al pulsar el botón, se muestra la información de la memoria RAM total, usada y libre en un label, en Gigabytes:
Este script utiliza la biblioteca psutil para obtener información sobre la memoria RAM del sistema. Si no tienes instalada esta biblioteca, puedes hacerlo con el siguiente comando:
Ram Info Windows
Este script utiliza la biblioteca psutil para obtener información sobre la memoria RAM del sistema. Si no tienes instalada esta biblioteca, puedes hacerlo con el siguiente comando:
pip install psutil
Al ejecutar el script, verás una ventana con un botón. Al hacer clic en el botón, se mostrará la memoria RAM total, usada y libre en Gigabytes en un label dentro de la misma ventana.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
import tkinter as tk from tkinter import ttk import psutil def obtener_informacion_ram(): # Obtener información de la memoria RAM memoria = psutil.virtual_memory() total = memoria.total / (1024 ** 3) # Convertir a GB usado = memoria.used / (1024 ** 3) # Convertir a GB libre = memoria.available / (1024 ** 3) # Convertir a GB # Actualizar el label con la información label_resultado.config(text=f"RAM Total: {total:.2f} GBnRAM Usada: {usado:.2f} GBnRAM Libre: {libre:.2f} GB") # Crear la ventana principal ventana = tk.Tk() ventana.title("Información de RAM") ventana.geometry("300x200") # Crear un botón para obtener la información de la RAM boton_obtener = ttk.Button(ventana, text="Obtener Información RAM", command=obtener_informacion_ram) boton_obtener.pack(pady=10) # Crear un label para mostrar los resultados label_resultado = tk.Label(ventana, text="", justify="left") label_resultado.pack(pady=10) # Iniciar el bucle principal de la ventana ventana.mainloop() |
Ejecución de código Python generado por ChatGPT
Si ejecutamos el código que nos ofrece ChatGPT, vemos que funciona perfectamente y que cumple con todos los requisitos que le hemos indicado. Muestra una ventana Windows con un botón. Al pulsar el botón obtiene la RAM total, la RAM usada y la RAM libre y la muestra en la ventana:
Resultado en Copilot
En el caso de Copilot, este es el resultado de la petición:
Todo el resultado detallado por Copilot:
¡Claro! Aquí tienes un ejemplo de código en Python que hace lo que necesitas. Utiliza las bibliotecas tkinter para la interfaz gráfica y psutil para obtener la información de la memoria RAM:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
import tkinter as tk import psutil def obtener_memoria(): memoria = psutil.virtual_memory() total = memoria.total / (1024 ** 3) usada = memoria.used / (1024 ** 3) libre = memoria.available / (1024 ** 3) label.config(text=f"Total: {total:.2f} GBnUsada: {usada:.2f} GBnLibre: {libre:.2f} GB") ventana = tk.Tk() ventana.title("Información de Memoria RAM") boton = tk.Button(ventana, text="Obtener Memoria RAM", command=obtener_memoria) boton.pack(pady=20) label = tk.Label(ventana, text="") label.pack(pady=20) ventana.mainloop() |
Este script crea una ventana con un botón. Al pulsar el botón, se actualiza un label con la memoria RAM total, usada y libre en gigabytes. Asegúrate de tener instalada la biblioteca psutil ejecutando pip install psutil en tu terminal.
¡Espero que te sea útil!
Ejecución de código Python generado por Copilot
Si ejecutamos el código que nos ofrece Copilot, vemos que funciona perfectamente y que cumple con todos los requisitos que le hemos indicado. Muestra una ventana Windows con un botón. Al pulsar el botón obtiene la RAM total, la RAM usada y la RAM libre y la muestra en la ventana:
Resultado en Gemini
En el caso de Gemini, este es el resultado de la pregunta:
Todo el resultado detallado por Gemini:
¡Absolutamente! Aquí tienes un script en Python que utiliza la biblioteca Tkinter para crear una ventana simple con un botón y un label, y el módulo psutil para obtener información detallada sobre la memoria RAM del sistema:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
import tkinter as tk import psutil def obtener_info_memoria(): # Obtener información de la memoria en bytes mem = psutil.virtual_memory() # Convertir a gigabytes y formatear total_gb = round(mem.total / (1024 ** 3), 2) used_gb = round(mem.used / (1024 ** 3), 2) free_gb = round(mem.free / (1024 ** 3), 2) # Actualizar el label con la información label_info.config(text=f"Memoria total: {total_gb} GBnMemoria usada: {used_gb} GBnMemoria libre: {free_gb} GB") # Crear la ventana principal ventana = tk.Tk() ventana.title("Monitor de Memoria") # Crear un botón boton = tk.Button(ventana, text="Ver Memoria", command=obtener_info_memoria) boton.pack() # Crear un label para mostrar la información label_info = tk.Label(ventana, text="") label_info.pack() # Iniciar el bucle principal de la ventana ventana.mainloop() |
Explicación del código:
- Importar bibliotecas:
- Función
obtener_info_memoria(): - Crear la interfaz:
- Iniciar el bucle principal:
Cómo usar el script:
- Guardar el código: Guarda este código en un archivo con extensión
.py(por ejemplo,monitor_memoria.py). - Ejecutar el script: Abre una terminal o línea de comandos, navega hasta la carpeta donde guardaste el archivo y ejecuta el comando
python monitor_memoria.py. - Interactuar con la ventana: Aparecerá una ventana con un botón. Al hacer clic en el botón, se actualizará el label con la información actualizada sobre la memoria RAM de tu sistema.
Personalizaciones:
- Diseño: Puedes personalizar el aspecto de la ventana utilizando diferentes opciones de Tkinter para cambiar los colores, fuentes, tamaños, etc.
- Información adicional:
psutilofrece más información sobre la memoria, como la memoria utilizada por procesos específicos. Puedes agregar esta información al label si lo deseas. - Actualizaciones automáticas: Puedes utilizar la función
afterde Tkinter para actualizar la información de la memoria automáticamente cada cierto tiempo.
Con este script, tendrás una herramienta sencilla para monitorear la memoria RAM de tu sistema directamente desde una ventana de Python.
Ejecución de código Python generado por Gemini
Si ejecutamos el código que nos ofrece Gemini, vemos que funciona perfectamente y que cumple con todos los requisitos que le hemos indicado. Muestra una ventana Windows con un botón. Al pulsar el botón obtiene la RAM total, la RAM usada y la RAM libre y la muestra en la ventana:
Conclusiones de la comparativa de sistemas de IA generativa
Como hemos podido extraer de la pequeña comparativa, los sistemas que nos generan el código Python correcto son ChatGPT, Copilot y Gemini.
Si analizamos el código Python generado por cada uno de ellos, comprobamos que son muy similares. Todos definen una función para obtener la RAM total, usada y libre y para mostrar el resultado en un label. Todos usan el paquete tkinter para mostrar la ventana, el botón y el label.
El que menos líneas de código genera es Copilot, si bien, tanto en Copilot como en Gemini se ha tenido que agrandar la ventana manualmente porque o bien no cabía todo el título o bien no cabía el resultado obtenido. En cambio, en ChatGPT, añade líneas de código para redimensionar la ventana y dejarla a un tamaño perfecto para no tener que agrandarla manualmente.
La ventana original en ChatGPT:
La ventana original en Copilot:
La ventana original en Gemini:
Por lo tanto, los tres sistemas de IA generativa, para este caso concreto de ejemplo, han funcionado correctamente. En cuanto a visualización de la ventana, el que mejor ha funcionado ha sido ChatGPT.
Añadir petición de modificación de resultados
Sobre el mismo hilo de conversación, a los tres sistemas de IA (ChatGPT, Copilot y Gemini) se les pide una modificación del código, la siguiente:
ok, el código es correcto, pero ahora quiero que me muestre también el espacio libre en todas las unidades de disco
Y el resultado para cada uno de ellos es el siguiente.
Resultado de ChatGPT con modificación de código
El resultado de la petición de modificación del código Python, para ChatGPT, pidiendo que muestre también el espacio libre en todas las unidades de disco es:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 |
import tkinter as tk from tkinter import ttk import psutil def obtener_informacion_ram_y_disco(): # Obtener información de la memoria RAM memoria = psutil.virtual_memory() total_ram = memoria.total / (1024 ** 3) # Convertir a GB usado_ram = memoria.used / (1024 ** 3) # Convertir a GB libre_ram = memoria.available / (1024 ** 3) # Convertir a GB # Obtener información de las unidades de disco discos = psutil.disk_partitions() info_discos = [] for disco in discos: try: uso_disco = psutil.disk_usage(disco.mountpoint) libre_disco = uso_disco.free / (1024 ** 3) # Convertir a GB info_discos.append(f"{disco.device}: {libre_disco:.2f} GB libres") except PermissionError: info_discos.append(f"{disco.device}: Acceso denegado") # Actualizar el label con la información resultado = (f"RAM Total: {total_ram:.2f} GBn" f"RAM Usada: {usado_ram:.2f} GBn" f"RAM Libre: {libre_ram:.2f} GBnn" "Espacio libre en discos:n" + "n".join(info_discos)) label_resultado.config(text=resultado) # Crear la ventana principal ventana = tk.Tk() ventana.title("Información del Sistema") ventana.geometry("400x400") # Crear un botón para obtener la información de la RAM y disco boton_obtener = ttk.Button(ventana, text="Obtener Información del Sistema", command=obtener_informacion_ram_y_disco) boton_obtener.pack(pady=10) # Crear un label para mostrar los resultados label_resultado = tk.Label(ventana, text="", justify="left") label_resultado.pack(pady=10) # Iniciar el bucle principal de la ventana ventana.mainloop() |
Si ejecutamos el código modificado ofrecido por ChatGPT devuelve el resultado correcto:
Y le hacemos una segunda modificación:
muéstrame el espacio libre de las unidades en TB
Y ChatGPT devuelve el siguiente código modificado:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 |
import tkinter as tk from tkinter import ttk import psutil def obtener_informacion_ram_y_disco(): # Obtener información de la memoria RAM memoria = psutil.virtual_memory() total_ram = memoria.total / (1024 ** 3) # Convertir a GB usado_ram = memoria.used / (1024 ** 3) # Convertir a GB libre_ram = memoria.available / (1024 ** 3) # Convertir a GB # Obtener información de las unidades de disco discos = psutil.disk_partitions() info_discos = [] for disco in discos: try: uso_disco = psutil.disk_usage(disco.mountpoint) libre_disco = uso_disco.free / (1024 ** 4) # Convertir a TB info_discos.append(f"{disco.device}: {libre_disco:.2f} TB libres") except PermissionError: info_discos.append(f"{disco.device}: Acceso denegado") # Actualizar el label con la información resultado = (f"RAM Total: {total_ram:.2f} GBn" f"RAM Usada: {usado_ram:.2f} GBn" f"RAM Libre: {libre_ram:.2f} GBnn" "Espacio libre en discos:n" + "n".join(info_discos)) label_resultado.config(text=resultado) # Crear la ventana principal ventana = tk.Tk() ventana.title("Información del Sistema") ventana.geometry("400x400") # Crear un botón para obtener la información de la RAM y disco boton_obtener = ttk.Button(ventana, text="Obtener Información del Sistema", command=obtener_informacion_ram_y_disco) boton_obtener.pack(pady=10) # Crear un label para mostrar los resultados label_resultado = tk.Label(ventana, text="", justify="left") label_resultado.pack(pady=10) # Iniciar el bucle principal de la ventana ventana.mainloop() |
Y el resultado correcto:
Resultado de Copilot con modificación de código
El resultado de la petición de modificación del código Python, para Copilot, pidiendo que muestre también el espacio libre en todas las unidades de disco es:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
import tkinter as tk import psutil def obtener_memoria(): memoria = psutil.virtual_memory() total = memoria.total / (1024 ** 3) usada = memoria.used / (1024 ** 3) libre = memoria.available / (1024 ** 3) label_memoria.config(text=f"Total: {total:.2f} GBnUsada: {usada:.2f} GBnLibre: {libre:.2f} GB") def obtener_espacio_disco(): texto = "" for particion in psutil.disk_partitions(): uso = psutil.disk_usage(particion.mountpoint) total = uso.total / (1024 ** 3) libre = uso.free / (1024 ** 3) texto += f"Unidad: {particion.device}nTotal: {total:.2f} GBnLibre: {libre:.2f} GBnn" label_disco.config(text=texto) ventana = tk.Tk() ventana.title("Información de Memoria RAM y Espacio en Disco") boton_memoria = tk.Button(ventana, text="Obtener Memoria RAM", command=obtener_memoria) boton_memoria.pack(pady=10) label_memoria = tk.Label(ventana, text="") label_memoria.pack(pady=10) boton_disco = tk.Button(ventana, text="Obtener Espacio en Disco", command=obtener_espacio_disco) boton_disco.pack(pady=10) label_disco = tk.Label(ventana, text="") label_disco.pack(pady=10) ventana.mainloop() |
Si ejecutamos el código modificado ofrecido por Copilot devuelve el resultado correcto:
Y le hacemos una segunda modificación:
muéstrame el espacio libre de las unidades en TB
Y Copilot devuelve el siguiente código modificado:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
import tkinter as tk import psutil def obtener_memoria(): memoria = psutil.virtual_memory() total = memoria.total / (1024 ** 3) usada = memoria.used / (1024 ** 3) libre = memoria.available / (1024 ** 3) label_memoria.config(text=f"Total: {total:.2f} GBnUsada: {usada:.2f} GBnLibre: {libre:.2f} GB") def obtener_espacio_disco(): texto = "" for particion in psutil.disk_partitions(): uso = psutil.disk_usage(particion.mountpoint) total = uso.total / (1024 ** 4) libre = uso.free / (1024 ** 4) texto += f"Unidad: {particion.device}nTotal: {total:.2f} TBnLibre: {libre:.2f} TBnn" label_disco.config(text=texto) ventana = tk.Tk() ventana.title("Información de Memoria RAM y Espacio en Disco") boton_memoria = tk.Button(ventana, text="Obtener Memoria RAM", command=obtener_memoria) boton_memoria.pack(pady=10) label_memoria = tk.Label(ventana, text="") label_memoria.pack(pady=10) boton_disco = tk.Button(ventana, text="Obtener Espacio en Disco", command=obtener_espacio_disco) boton_disco.pack(pady=10) label_disco = tk.Label(ventana, text="") label_disco.pack(pady=10) ventana.mainloop() |
Resultado de Gemini con modificación de código
El resultado de la petición de modificación del código Python, para Gemini, pidiendo que muestre también el espacio libre en todas las unidades de disco es:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
import tkinter as tk import psutil def obtener_info_sistema(): # Información de la memoria mem = psutil.virtual_memory() total_gb = round(mem.total / (1024 ** 3), 2) used_gb = round(mem.used / (1024 ** 3), 2) free_gb = round(mem.free / (1024 ** 3), 2) # Información de las unidades de disco disco = psutil.disk_partitions() info_discos = "" for part in disco: uso_disco = psutil.disk_usage(part.mountpoint) free_gb_disco = round(uso_disco.free / (1024 ** 3), 2) info_discos += f"Disco {part.device}: {free_gb_disco} GB libresn" # Actualizar el label con la información label_info.config(text=f"Memoria total: {total_gb} GBnMemoria usada: {used_gb} GBnMemoria libre: {free_gb} GBnn{info_discos}") # Crear la ventana principal ventana = tk.Tk() ventana.title("Monitor de Sistema") # Crear un botón boton = tk.Button(ventana, text="Ver Información", command=obtener_info_sistema) boton.pack() # Crear un label para mostrar la información label_info = tk.Label(ventana, text="") label_info.pack() # Iniciar el bucle principal de la ventana ventana.mainloop() |
Si ejecutamos el código modificado ofrecido por Gemini devuelve el resultado correcto (tenemos que agrandar la ventana manualmente):
Y le hacemos una segunda modificación:
muéstrame el espacio libre de las unidades en TB
Y Gemini devuelve el siguiente código modificado:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
import tkinter as tk import psutil def obtener_info_sistema(): # Información de la memoria mem = psutil.virtual_memory() total_gb = round(mem.total / (1024 ** 3), 2) used_gb = round(mem.used / (1024 ** 3), 2) free_gb = round(mem.free / (1024 ** 3), 2) # Información de las unidades de disco en TB disco = psutil.disk_partitions() info_discos = "" for part in disco: uso_disco = psutil.disk_usage(part.mountpoint) free_tb = round(uso_disco.free / (1024 ** 4), 2) # Conversión a TB info_discos += f"Disco {part.device}: {free_tb} TB libresn" # Actualizar el label con la información label_info.config(text=f"Memoria total: {total_gb} GBnMemoria usada: {used_gb} GBnMemoria libre: {free_gb} GBnn{info_discos}") # Crear la ventana principal ventana = tk.Tk() ventana.title("Monitor de Sistema") # Crear un botón boton = tk.Button(ventana, text="Ver Información", command=obtener_info_sistema) boton.pack() # Crear un label para mostrar la información label_info = tk.Label(ventana, text="") label_info.pack() # Iniciar el bucle principal de la ventana ventana.mainloop() |
Y el resultado correcto:
Conclusión de las modificaciones pedidas a los sistemas de IA
En las modificaciones solicitadas en el mismo hilo de conversación a los sistemas de IA ChatGPT, Copilot y Gemini, se producen algunas diferencias en los resultados ofrecidos. Todos generan los resultados correctos, haciendo la modificación del código pedida para que muestre también el espacio libre de todas las unidades de disco del equipo y la segunda petición de modificación que muestre el resultado en Terabytes (TB).
La única diferencia en el resultado propuesto ha sido de Copilot, que añade un segundo botón para obtener la información del espacio libre de los discos. Y, también, muestra, además del espacio libre, el espacio total (tamaño) de cada disco, cosa que no le hemos pedido.
