Este tutorial exhaustivo te guiará a través del uso de la biblioteca ctypes de Python para interactuar con la API de Windows. Aprenderás a acceder a la funcionalidad del sistema Windows, gestionar procesos y aprovechar las características específicas de Windows directamente desde Python. Al final de este laboratorio, comprenderás cómo construir aplicaciones que pueden integrarse perfectamente con el sistema operativo Windows y realizar operaciones potentes a nivel de sistema.
En este paso, exploraremos los conceptos básicos de la biblioteca ctypes de Python, que sirve como base para interactuar con la API de Windows. La biblioteca ctypes actúa como un puente entre Python y las bibliotecas nativas de C, permitiéndonos llamar a funciones directamente desde DLLs (Dynamic Link Libraries - Bibliotecas de Enlace Dinámico).
ctypes es una biblioteca de funciones externas para Python que proporciona tipos de datos compatibles con C y permite llamar a funciones en DLLs o bibliotecas compartidas. Es particularmente útil para:
Antes de empezar a escribir código, instalemos los paquetes necesarios. Abre una terminal en el WebIDE y ejecuta:
pip install pywin32-ctypesEsto instalará una biblioteca compatible que funciona con nuestro entorno.
Creemos un script de Python simple para entender cómo funciona ctypes. En el WebIDE, crea un nuevo archivo llamado ctypes_basics.py en el directorio /home/labex/project con el siguiente contenido:
import ctypes
## Load a standard C library
libc = ctypes.CDLL('libc.so.6')
## Call a simple C function
print("Random number from C library:", libc.rand())
## Find out the size of int type on this machine
print("Size of int:", ctypes.sizeof(ctypes.c_int), "bytes")
## Create and use a C-compatible string
message = ctypes.create_string_buffer(b"Hello from ctypes!")
print("C-compatible string:", message.value.decode())
print("String buffer size:", ctypes.sizeof(message), "bytes")Ejecuta el script usando:
python3 ctypes_basics.pyDeberías ver una salida similar a esta:
Random number from C library: 1804289383
Size of int: 4 bytes
C-compatible string: Hello from ctypes!
String buffer size: 19 bytesctypes proporciona envoltorios compatibles con Python para los tipos de datos C. Aquí hay una tabla de referencia de los tipos de datos C comunes y sus equivalentes ctypes:
| Tipo C | Tipo ctypes | Tipo Python |
|---|---|---|
| char | c_char | Objeto bytes de 1 carácter |
| int | c_int | int |
| unsigned int | c_uint | int |
| long | c_long | int |
| void * | c_void_p | int o None |
| char * | c_char_p | bytes o None |
| wchar_t * | c_wchar_p | str o None |
Exploremos estos tipos de datos con otro ejemplo. Crea un archivo llamado ctypes_types.py:
import ctypes
## Integer types
i = ctypes.c_int(42)
ui = ctypes.c_uint(123)
print(f"Integer: {i.value}, Unsigned Integer: {ui.value}")
## Floating point types
f = ctypes.c_float(3.14)
d = ctypes.c_double(2.71828)
print(f"Float: {f.value}, Double: {d.value}")
## Character and string types
c = ctypes.c_char(b'A')
s = ctypes.c_char_p(b"Hello, World!")
print(f"Character: {c.value.decode()}, String: {s.value.decode()}")
## Create an array of integers
int_array = (ctypes.c_int * 5)(1, 2, 3, 4, 5)
print("Array elements:", [int_array[i] for i in range(5)])Ejecuta el script:
python3 ctypes_types.pySalida esperada:
Integer: 42, Unsigned Integer: 123
Float: 3.140000104904175, Double: 2.71828
Character: A, String: Hello, World!
Array elements: [1, 2, 3, 4, 5]Esta comprensión fundamental de ctypes nos ayudará a medida que avancemos para interactuar con bibliotecas de sistema más complejas y, específicamente, con la API de Windows.
En este paso, aprenderemos a acceder a las bibliotecas del sistema y a llamar a sus funciones utilizando ctypes. Dado que estamos trabajando en un entorno Linux, nos centraremos en las bibliotecas del sistema Linux, al tiempo que explicamos los principios que también se aplican al acceso a la API de Windows.
En Python, podemos cargar bibliotecas dinámicas utilizando varios métodos proporcionados por ctypes:
CDLL - para cargar bibliotecas C estándarWinDLL - para cargar DLLs de Windows (cuando se está en Windows)OleDLL - para cargar bibliotecas COM (cuando se está en Windows)Creemos un archivo llamado system_info.py para explorar la información del sistema utilizando bibliotecas estándar:
import ctypes
import os
import platform
print(f"Python Platform: {platform.platform()}")
print(f"System: {platform.system()}")
print(f"Machine: {platform.machine()}")
print(f"Processor: {platform.processor()}")
## Load the C standard library
libc = ctypes.CDLL('libc.so.6')
## Get system information
print("\n--- System Information ---")
## Get hostname
hostname_buffer = ctypes.create_string_buffer(1024)
if libc.gethostname(hostname_buffer, ctypes.sizeof(hostname_buffer)) == 0:
print(f"Hostname: {hostname_buffer.value.decode()}")
else:
print("Failed to get hostname")
## Get user information
uid = os.getuid()
pwd = libc.getpwuid(uid)
if pwd:
print(f"Current user ID: {uid}")
else:
print(f"Current user ID: {uid} (failed to get user info)")
## Memory page size
page_size = libc.getpagesize()
print(f"Memory page size: {page_size} bytes")
## Get system uptime (if available)
try:
class timespec(ctypes.Structure):
_fields_ = [
('tv_sec', ctypes.c_long),
('tv_nsec', ctypes.c_long)
]
time_buf = timespec()
CLOCK_BOOTTIME = 7 ## Linux specific
if hasattr(libc, 'clock_gettime') and libc.clock_gettime(CLOCK_BOOTTIME, ctypes.byref(time_buf)) == 0:
uptime_seconds = time_buf.tv_sec
days, remainder = divmod(uptime_seconds, 86400)
hours, remainder = divmod(remainder, 3600)
minutes, seconds = divmod(remainder, 60)
print(f"System uptime: {days} days, {hours} hours, {minutes} minutes, {seconds} seconds")
else:
print("Could not get system uptime")
except Exception as e:
print(f"Error getting uptime: {e}")Ejecuta el script:
python3 system_info.pyDeberías ver información detallada sobre tu sistema, similar a esto:
Python Platform: Linux-5.15.0-1031-aws-x86_64-with-glibc2.35
System: Linux
Machine: x86_64
Processor: x86_64
--- System Information ---
Hostname: labex-container
Current user ID: 1000
Memory page size: 4096 bytes
System uptime: 0 days, 1 hours, 23 minutes, 45 secondsAhora, creemos una aplicación más práctica: un monitor de procesos simple que mostrará los procesos en ejecución. Crea un archivo llamado process_monitor.py:
import ctypes
import os
import time
from datetime import datetime
def list_processes():
"""List all running processes using /proc filesystem"""
processes = []
## On Linux, process information is available in the /proc filesystem
for pid in os.listdir('/proc'):
if pid.isdigit():
try:
## Read process name from /proc/[pid]/comm
with open(f'/proc/{pid}/comm', 'r') as f:
name = f.read().strip()
## Get process status
with open(f'/proc/{pid}/status', 'r') as f:
status_lines = f.readlines()
status = {}
for line in status_lines:
if ':' in line:
key, value = line.split(':', 1)
status[key.strip()] = value.strip()
## Get memory usage (VmRSS is physical memory used)
memory_kb = int(status.get('VmRSS', '0 kB').split()[0]) if 'VmRSS' in status else 0
processes.append({
'pid': int(pid),
'name': name,
'state': status.get('State', 'Unknown'),
'memory_kb': memory_kb
})
except (IOError, FileNotFoundError, ProcessLookupError):
## Process might have terminated while we were reading
continue
return processes
def display_processes(processes, top_n=10):
"""Display processes sorted by memory usage"""
## Sort processes by memory usage (highest first)
sorted_processes = sorted(processes, key=lambda p: p['memory_kb'], reverse=True)
## Display only top N processes
print(f"\nTop {top_n} processes by memory usage at {datetime.now().strftime('%H:%M:%S')}:")
print(f"{'PID':<7} {'NAME':<20} {'STATE':<10} {'MEMORY (KB)':<12}")
print("-" * 50)
for proc in sorted_processes[:top_n]:
print(f"{proc['pid']:<7} {proc['name'][:19]:<20} {proc['state']:<10} {proc['memory_kb']:<12}")
## Monitor processes continuously
print("Simple Process Monitor")
print("Press Ctrl+C to exit")
try:
while True:
processes = list_processes()
display_processes(processes)
time.sleep(3) ## Update every 3 seconds
except KeyboardInterrupt:
print("\nProcess monitoring stopped")Ejecuta el monitor de procesos:
python3 process_monitor.pyDeberías ver una salida similar a esta, que se actualizará cada 3 segundos:
Simple Process Monitor
Press Ctrl+C to exit
Top 10 processes by memory usage at 14:30:25:
PID NAME STATE MEMORY (KB)
-------------------------------------------------------
1234 python3 S (sleeping) 56789
2345 node S (sleeping) 34567
3456 code S (sleeping) 23456
...Deja que el monitor de procesos se ejecute durante unos 10 segundos, luego presiona Ctrl+C para detenerlo.
En estos ejemplos, hemos aprendido a:
ctypesEstos principios son los mismos que usarías para interactuar con la API de Windows a través de ctypes, solo con diferentes nombres de bibliotecas y llamadas a funciones.
En este paso, aprenderemos a definir y usar estructuras C en Python. Las estructuras son esenciales cuando se trabaja con APIs del sistema, ya que se utilizan comúnmente para intercambiar datos entre Python y las bibliotecas del sistema.
Las estructuras C se pueden representar en Python utilizando la clase ctypes.Structure. Esto nos permite crear estructuras de datos complejas que coinciden con el diseño de memoria esperado por las funciones C.
Creemos un archivo llamado struct_example.py para explorar cómo trabajar con estructuras:
import ctypes
## Define a simple C structure
class Point(ctypes.Structure):
_fields_ = [
("x", ctypes.c_int),
("y", ctypes.c_int)
]
## Create an instance of the Point structure
p = Point(10, 20)
print(f"Point coordinates: ({p.x}, {p.y})")
## Modify structure fields
p.x = 100
p.y = 200
print(f"Updated coordinates: ({p.x}, {p.y})")
## Create a Point from a dictionary
values = {"x": 30, "y": 40}
p2 = Point(**values)
print(f"Point from dictionary: ({p2.x}, {p2.y})")
## Get the raw memory view (pointer) of the structure
p_ptr = ctypes.pointer(p)
print(f"Memory address of p: {ctypes.addressof(p)}")
print(f"Access via pointer: ({p_ptr.contents.x}, {p_ptr.contents.y})")
## Define a nested structure
class Rectangle(ctypes.Structure):
_fields_ = [
("top_left", Point),
("bottom_right", Point),
("color", ctypes.c_int)
]
## Create a rectangle with two points
rect = Rectangle(Point(0, 0), Point(100, 100), 0xFF0000)
print(f"Rectangle: Top-Left: ({rect.top_left.x}, {rect.top_left.y}), "
f"Bottom-Right: ({rect.bottom_right.x}, {rect.bottom_right.y}), "
f"Color: {hex(rect.color)}")
## Calculate the area (demonstrating structure manipulation)
width = rect.bottom_right.x - rect.top_left.x
height = rect.bottom_right.y - rect.top_left.y
print(f"Rectangle area: {width * height}")Ejecuta el script:
python3 struct_example.pyDeberías ver una salida similar a esta:
Point coordinates: (10, 20)
Updated coordinates: (100, 200)
Point from dictionary: (30, 40)
Memory address of p: 140737345462208
Access via pointer: (100, 200)
Rectangle: Top-Left: (0, 0), Bottom-Right: (100, 100), Color: 0xff0000
Rectangle area: 10000Ahora, creemos una aplicación práctica que utiliza estructuras C para interactuar con las funciones de tiempo del sistema. Crea un archivo llamado time_utility.py:
import ctypes
import time
from datetime import datetime
## Define the timespec structure (used in Linux for high-resolution time)
class timespec(ctypes.Structure):
_fields_ = [
("tv_sec", ctypes.c_long),
("tv_nsec", ctypes.c_long)
]
## Define the tm structure (used for calendar time representation)
class tm(ctypes.Structure):
_fields_ = [
("tm_sec", ctypes.c_int), ## seconds (0 - 60)
("tm_min", ctypes.c_int), ## minutes (0 - 59)
("tm_hour", ctypes.c_int), ## hours (0 - 23)
("tm_mday", ctypes.c_int), ## day of month (1 - 31)
("tm_mon", ctypes.c_int), ## month of year (0 - 11)
("tm_year", ctypes.c_int), ## year - 1900
("tm_wday", ctypes.c_int), ## day of week (0 - 6, Sunday = 0)
("tm_yday", ctypes.c_int), ## day of year (0 - 365)
("tm_isdst", ctypes.c_int) ## is daylight saving time in effect
]
## Load the C library
libc = ctypes.CDLL("libc.so.6")
def get_system_time():
"""Get the current system time using C functions"""
## Get current time as seconds since epoch
time_t_ptr = ctypes.pointer(ctypes.c_long())
libc.time(time_t_ptr) ## time() function gets current time
## Convert to printable time string
time_val = time_t_ptr.contents.value
time_str = ctypes.string_at(libc.ctime(time_t_ptr))
return {
"timestamp": time_val,
"formatted_time": time_str.decode().strip()
}
def get_high_resolution_time():
"""Get high resolution time using clock_gettime"""
ts = timespec()
## CLOCK_REALTIME is usually 0
CLOCK_REALTIME = 0
## Call clock_gettime to fill the timespec structure
if libc.clock_gettime(CLOCK_REALTIME, ctypes.byref(ts)) != 0:
raise OSError("Failed to get time")
return {
"seconds": ts.tv_sec,
"nanoseconds": ts.tv_nsec,
"precise_time": ts.tv_sec + (ts.tv_nsec / 1_000_000_000)
}
def time_breakdown():
"""Break down the current time into its components using localtime"""
## Get current time
time_t_ptr = ctypes.pointer(ctypes.c_long())
libc.time(time_t_ptr)
## Get local time
tm_ptr = libc.localtime(time_t_ptr)
tm_struct = ctypes.cast(tm_ptr, ctypes.POINTER(tm)).contents
## Return time components
return {
"year": 1900 + tm_struct.tm_year,
"month": 1 + tm_struct.tm_mon, ## tm_mon is 0-11, we adjust to 1-12
"day": tm_struct.tm_mday,
"hour": tm_struct.tm_hour,
"minute": tm_struct.tm_min,
"second": tm_struct.tm_sec,
"weekday": tm_struct.tm_wday, ## 0 is Sunday
"yearday": tm_struct.tm_yday + 1 ## tm_yday is 0-365, we adjust to 1-366
}
## Main program
print("Time Utility using C Structures")
print("-" * 40)
## Get and display system time
sys_time = get_system_time()
print(f"System time: {sys_time['formatted_time']}")
print(f"Timestamp (seconds since epoch): {sys_time['timestamp']}")
## Get and display high-resolution time
hi_res = get_high_resolution_time()
print(f"\nHigh resolution time:")
print(f"Seconds: {hi_res['seconds']}")
print(f"Nanoseconds: {hi_res['nanoseconds']}")
print(f"Precise time: {hi_res['precise_time']}")
## Get and display time breakdown
components = time_breakdown()
print(f"\nTime breakdown:")
print(f"Date: {components['year']}-{components['month']:02d}-{components['day']:02d}")
print(f"Time: {components['hour']:02d}:{components['minute']:02d}:{components['second']:02d}")
print(f"Day of week: {components['weekday']} (0=Sunday)")
print(f"Day of year: {components['yearday']}")
## Compare with Python's datetime
now = datetime.now()
print(f"\nPython datetime: {now}")
print(f"Python timestamp: {time.time()}")Ejecuta la utilidad de tiempo:
python3 time_utility.pyDeberías ver una salida similar a esta:
Time Utility using C Structures
----------------------------------------
System time: Wed Jun 14 15:22:36 2023
Timestamp (seconds since epoch): 1686756156
High resolution time:
Seconds: 1686756156
Nanoseconds: 923456789
Precise time: 1686756156.923457
Time breakdown:
Date: 2023-06-14
Time: 15:22:36
Day of week: 3 (0=Sunday)
Day of year: 165
Python datetime: 2023-06-14 15:22:36.923499
Python timestamp: 1686756156.9234989Cuando se trabaja con ctypes y estructuras C, es importante comprender la gestión de la memoria. Creemos un ejemplo más, memory_management.py, para demostrar esto:
import ctypes
import gc ## Garbage collector module
## Define a simple structure
class MyStruct(ctypes.Structure):
_fields_ = [
("id", ctypes.c_int),
("value", ctypes.c_double),
("name", ctypes.c_char * 32) ## Fixed-size character array
]
def demonstrate_memory_management():
print("Memory Management with ctypes")
print("-" * 40)
## Create a structure instance
my_data = MyStruct(
id=1,
value=3.14159,
name=b"Example"
)
print(f"Structure size: {ctypes.sizeof(my_data)} bytes")
print(f"Memory address: {hex(ctypes.addressof(my_data))}")
## Create a pointer to the structure
data_ptr = ctypes.pointer(my_data)
print(f"Pointer value: {hex(ctypes.cast(data_ptr, ctypes.c_void_p).value)}")
## Access through pointer
print(f"Access via pointer: id={data_ptr.contents.id}, value={data_ptr.contents.value}")
## Allocate memory for a new structure
new_struct_ptr = ctypes.POINTER(MyStruct)()
new_struct_ptr = ctypes.cast(
ctypes.create_string_buffer(ctypes.sizeof(MyStruct)),
ctypes.POINTER(MyStruct)
)
## Initialize the allocated memory
new_struct = new_struct_ptr.contents
new_struct.id = 2
new_struct.value = 2.71828
new_struct.name = b"Allocated"
print(f"\nAllocated structure memory address: {hex(ctypes.addressof(new_struct))}")
print(f"Allocated structure content: id={new_struct.id}, value={new_struct.value}, name={new_struct.name.decode()}")
## Create an array of structures
StructArray = MyStruct * 3
struct_array = StructArray(
MyStruct(10, 1.1, b"First"),
MyStruct(20, 2.2, b"Second"),
MyStruct(30, 3.3, b"Third")
)
print("\nArray of structures:")
for i, item in enumerate(struct_array):
print(f" [{i}] id={item.id}, value={item.value}, name={item.name.decode()}")
## Force garbage collection
print("\nForcing garbage collection...")
gc.collect()
## Memory is automatically managed by Python
## Run the demonstration
demonstrate_memory_management()Ejecuta el script de gestión de memoria:
python3 memory_management.pyDeberías ver una salida similar a esta:
Memory Management with ctypes
----------------------------------------
Structure size: 48 bytes
Memory address: 0x7f3c2e32b040
Pointer value: 0x7f3c2e32b040
Access via pointer: id=1, value=3.14159
Allocated structure memory address: 0x7f3c2e32b0a0
Allocated structure content: id=2, value=2.71828, name=Allocated
Array of structures:
[0] id=10, value=1.1, name=First
[1] id=20, value=2.2, name=Second
[2] id=30, value=3.3, name=Third
Forcing garbage collection...En estos ejemplos, hemos aprendido a:
ctypesctypesEstas habilidades son esenciales cuando se trabaja con funciones de la API de Windows, que con frecuencia requieren estructuras de datos complejas para pasar información de un lado a otro.
En este paso final, reuniremos todos nuestros conocimientos para construir una aplicación completa de monitor del sistema. Esta aplicación utilizará ctypes para recopilar información del sistema, mostrar métricas en tiempo real y demostrar cómo estructurar una aplicación Python más grande que interactúa con las bibliotecas del sistema.
Crea un nuevo archivo llamado system_monitor.py con el siguiente contenido:
import ctypes
import os
import time
import platform
from datetime import datetime
class SystemMonitor:
"""Aplicación de monitoreo del sistema usando ctypes"""
def __init__(self):
"""Inicializa el monitor del sistema"""
self.libc = ctypes.CDLL("libc.so.6")
self.running = False
## Define a timespec structure for time-related functions
class timespec(ctypes.Structure):
_fields_ = [
("tv_sec", ctypes.c_long),
("tv_nsec", ctypes.c_long)
]
self.timespec = timespec
## Print basic system information
print(f"System Monitor for {platform.system()} {platform.release()}")
print(f"Python Version: {platform.python_version()}")
print(f"Machine: {platform.machine()}")
print("-" * 50)
def get_uptime(self):
"""Get system uptime information"""
try:
CLOCK_BOOTTIME = 7 ## Linux specific
time_buf = self.timespec()
if hasattr(self.libc, 'clock_gettime') and self.libc.clock_gettime(CLOCK_BOOTTIME, ctypes.byref(time_buf)) == 0:
uptime_seconds = time_buf.tv_sec
days, remainder = divmod(uptime_seconds, 86400)
hours, remainder = divmod(remainder, 3600)
minutes, seconds = divmod(remainder, 60)
return {
"total_seconds": uptime_seconds,
"days": days,
"hours": hours,
"minutes": minutes,
"seconds": seconds
}
return None
except Exception as e:
print(f"Error getting uptime: {e}")
return None
def get_memory_info(self):
"""Get memory usage information using /proc/meminfo"""
memory_info = {}
try:
with open('/proc/meminfo', 'r') as f:
for line in f:
if ':' in line:
key, value = line.split(':', 1)
## Remove 'kB' and convert to integer
value = value.strip()
if 'kB' in value:
value = int(value.split()[0]) * 1024 ## Convert to bytes
memory_info[key.strip()] = value
## Calculate memory usage percentage
if 'MemTotal' in memory_info and 'MemAvailable' in memory_info:
total = int(memory_info['MemTotal'])
available = int(memory_info['MemAvailable'])
used = total - available
memory_info['UsedPercentage'] = (used / total) * 100
return memory_info
except Exception as e:
print(f"Error getting memory info: {e}")
return {}
def get_cpu_info(self):
"""Get CPU information using /proc/stat"""
cpu_info = {'cpu_percent': 0}
try:
## We need two readings to calculate CPU usage
def get_cpu_sample():
with open('/proc/stat', 'r') as f:
line = f.readline()
cpu_values = [int(x) for x in line.split()[1:8]]
return sum(cpu_values), cpu_values[3] ## Return total and idle
## First sample
total1, idle1 = get_cpu_sample()
time.sleep(0.5) ## Wait for 0.5 second
## Second sample
total2, idle2 = get_cpu_sample()
## Calculate CPU usage
total_delta = total2 - total1
idle_delta = idle2 - idle1
if total_delta > 0:
cpu_info['cpu_percent'] = 100 * (1 - idle_delta / total_delta)
return cpu_info
except Exception as e:
print(f"Error getting CPU info: {e}")
return cpu_info
def get_disk_info(self):
"""Get disk usage information"""
try:
## Get disk usage for the root filesystem
stat = os.statvfs('/')
## Calculate total, free, and used space
total = stat.f_blocks * stat.f_frsize
free = stat.f_bfree * stat.f_frsize
used = total - free
return {
'total_bytes': total,
'free_bytes': free,
'used_bytes': used,
'used_percent': (used / total) * 100 if total > 0 else 0
}
except Exception as e:
print(f"Error getting disk info: {e}")
return {}
def get_process_count(self):
"""Count running processes"""
try:
return len([p for p in os.listdir('/proc') if p.isdigit()])
except Exception as e:
print(f"Error counting processes: {e}")
return 0
def format_bytes(self, bytes_value):
"""Format bytes into a human-readable format"""
for unit in ['B', 'KB', 'MB', 'GB', 'TB']:
if bytes_value < 1024 or unit == 'TB':
return f"{bytes_value:.2f} {unit}"
bytes_value /= 1024
def display_dashboard(self):
"""Display the system monitoring dashboard"""
## Clear the screen (works in most terminals)
print("\033c", end="")
## Display header
current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
print(f"System Monitor - {current_time}")
print("-" * 50)
## Display uptime
uptime = self.get_uptime()
if uptime:
print(f"Uptime: {uptime['days']} days, {uptime['hours']} hours, "
f"{uptime['minutes']} minutes, {uptime['seconds']} seconds")
## Display CPU usage
cpu_info = self.get_cpu_info()
print(f"CPU Usage: {cpu_info['cpu_percent']:.1f}%")
## Display memory information
memory_info = self.get_memory_info()
if memory_info and 'MemTotal' in memory_info:
print("\nMemory Information:")
total = int(memory_info['MemTotal'])
available = int(memory_info.get('MemAvailable', 0))
used = total - available
print(f" Total: {self.format_bytes(total)}")
print(f" Used: {self.format_bytes(used)} ({memory_info.get('UsedPercentage', 0):.1f}%)")
print(f" Available: {self.format_bytes(available)}")
if 'SwapTotal' in memory_info:
swap_total = int(memory_info['SwapTotal'])
swap_free = int(memory_info.get('SwapFree', 0))
swap_used = swap_total - swap_free
if swap_total > 0:
print(f" Swap Used: {self.format_bytes(swap_used)} "
f"({(swap_used / swap_total) * 100:.1f}%)")
## Display disk information
disk_info = self.get_disk_info()
if disk_info:
print("\nDisk Information (/):")
print(f" Total: {self.format_bytes(disk_info['total_bytes'])}")
print(f" Used: {self.format_bytes(disk_info['used_bytes'])} "
f"({disk_info['used_percent']:.1f}%)")
print(f" Free: {self.format_bytes(disk_info['free_bytes'])}")
## Display process count
process_count = self.get_process_count()
print(f"\nRunning Processes: {process_count}")
print("\nPress Ctrl+C to exit")
def start_monitoring(self, interval=2):
"""Start the system monitoring with the specified refresh interval"""
self.running = True
try:
while self.running:
self.display_dashboard()
time.sleep(interval)
except KeyboardInterrupt:
print("\nMonitoring stopped.")
self.running = False
## Create and start the system monitor
if __name__ == "__main__":
monitor = SystemMonitor()
monitor.start_monitoring()Ejecuta el monitor del sistema:
python3 system_monitor.pyEl monitor del sistema mostrará información en tiempo real sobre tu sistema, actualizándose cada 2 segundos. Deberías ver un panel con:
Deja que el monitor se ejecute durante unos momentos para observar cómo cambian las métricas, luego presiona Ctrl+C para salir.
Desglosemos los componentes clave de nuestro monitor del sistema:
Ahora, agreguemos un archivo de documentación para nuestro monitor del sistema. Crea un archivo llamado README.md:
Una aplicación completa de monitoreo del sistema construida con Python utilizando ctypes para las interacciones del sistema.
Simplemente ejecuta el script principal:
python system_monitor.py### Cómo funciona
Esta aplicación utiliza la biblioteca `ctypes` de Python para interactuar con las bibliotecas del sistema y acceder a información del sistema de bajo nivel. También utiliza el sistema de archivos `/proc` para recopilar métricas adicionales sobre el estado del sistema.
El monitoreo se realiza en tiempo real con actualizaciones cada 2 segundos (configurable).
### Arquitectura
La aplicación sigue un enfoque orientado a objetos con estos componentes clave:
1. **Clase SystemMonitor**: Clase principal que orquesta el monitoreo
2. **Métodos de recopilación de datos**: Métodos para recopilar diferentes métricas del sistema
3. **Métodos de visualización**: Métodos para formatear y mostrar los datos recopilados
### Extensión del monitor
Para agregar nuevas capacidades de monitoreo:
1. Crea un nuevo método en la clase `SystemMonitor` para recopilar los datos deseados
2. Actualiza el método `display_dashboard` para mostrar la nueva información
3. Asegúrate de un manejo de errores adecuado para la robustez
### Recursos de aprendizaje
- [Documentación de Python ctypes](https://docs.python.org/3/library/ctypes.html)
- [Documentación del sistema de archivos Linux Proc](https://man7.org/linux/man-pages/man5/proc.5.html)
### Revisión y resumen
Revisemos lo que hemos logrado en este laboratorio:
1. Aprendimos a usar la biblioteca `ctypes` de Python para interactuar con las bibliotecas del sistema
2. Exploramos los tipos de datos y estructuras C en Python
3. Creamos varias aplicaciones prácticas:
- Recuperación básica de información del sistema
- Monitoreo de procesos
- Utilidades de tiempo
- Demostración de gestión de memoria
- Monitor del sistema completo
4. Aprendimos a:
- Cargar bibliotecas dinámicas
- Llamar a funciones C desde Python
- Definir y manipular estructuras C
- Trabajar con punteros y direcciones de memoria
- Manejar errores a nivel del sistema
Estas habilidades forman la base para trabajar con la API de Windows al desarrollar en sistemas Windows. Los principios siguen siendo los mismos: cargarás bibliotecas específicas de Windows (como kernel32.dll, user32.dll, etc.) en lugar de libc, pero el enfoque para definir estructuras, llamar a funciones y manejar los datos sigue siendo consistente.En este laboratorio, has aprendido a usar la biblioteca ctypes de Python para interactuar con las bibliotecas del sistema y realizar operaciones a nivel del sistema. Si bien el laboratorio se realizó en un entorno Linux, los principios y técnicas que has aprendido también se aplican directamente a la programación de la API de Windows.
Puntos clave de este laboratorio:
Comprensión de los fundamentos de ctypes: Has aprendido a cargar bibliotecas dinámicas, definir tipos de datos C y llamar a funciones del sistema desde Python.
Trabajo con estructuras C: Has dominado la creación y manipulación de estructuras C en Python, esencial para intercambiar datos complejos con las bibliotecas del sistema.
Gestión de memoria: Has obtenido información sobre la asignación de memoria, los punteros y la gestión de memoria al trabajar con bibliotecas del sistema.
Creación de aplicaciones prácticas: Has aplicado tus conocimientos para crear aplicaciones útiles, culminando en un monitor del sistema completo.
Integración del sistema: Has visto cómo Python se puede integrar con la funcionalidad del sistema de bajo nivel a través del puente ctypes.
Estas habilidades proporcionan una base sólida para desarrollar aplicaciones que necesitan interactuar con el sistema operativo a un nivel bajo, ya sea en Linux o Windows. Al trabajar en sistemas Windows, usarías el mismo enfoque pero con bibliotecas y funciones de la API específicas de Windows.
El aprendizaje adicional podría implicar la exploración de las API específicas de Windows para la gestión de ventanas, interfaces gráficas, servicios del sistema o capacidades de red utilizando las técnicas que has aprendido en este laboratorio.
