SoftwareLibre

Ubunlog Curso de programación en Python usando Linux. Séptima parte https://ubunlog.com/wp-content/uploads/2026/04/python.jpg En el artículo anterior de nuestro curso de programación en Python usando Linux (Enlace al final del artículo) comenzamos a hablar de los componentes que se usan para construir los programas. Aunque pueda parecer un tema excesivamente básico, son la base con la que pueden construirse cosas más complejas. Habíamos definido a las variables como contenedores en los que pueden almacenarse todo tipo de datos no permanentes, aora continuaremos explorando cuáles son las mejores prácticas para utilizarlas. Curso de programación en Python usando Linux Más sobre las variables Salvo la lista de palabras no permitidas que dimos en el artículo anterior, Python nos ofrece bastante flexibilidad a la hora de elegir nombres de variables. Incluso podemos tener nombres similares utilizando distintas combinaciones de mayúsculas y minúsculas. Sin embargo, es bueno disfrutar de esa libertad con un poco de autoregulación. Teniendo en cuenta que nosotros u otra persona tengamos que revisar ese código para corregir errores y actualizarlo es importante que utilicemos nombres que sean significativos y descriptivos de los datos que vamos a almacenar en ellos. Por ejemplo, si vas a almacenar marcas de auto lo ideal sería marca o marca_auto en lugar de por ejemplo una letra o el nombre de uno de los personajes de los Simpson’s.  Si el nombre de la variable va a ser largo, por ejemplo usando dos o más palabras, se pueden separar con guiones bajos o alternando mayúsculas y minúsculas: marca_auto o MarcaAuto. Si recuerdas el código de ejemplo de los artículos anteriores habrás observado que el nombre de algunas variables empezaban con «-» esto es una convención que indica que esas variables son para uso interno de la clase. Tipos de datos Aunque no es necesario declarar que tipos de datos va a almacenar una variable al principio del programa, si al momento de asignarles un valor se debe escribir la instrucción de manera específica según el tipo. Python trabaja con los siguientes tipos de datos: Número entero (int) Son números positivos y negativos sin parte decimal que pueden usarse para realizar operaciones aritméticas. año = 2026 Número decimal (float) Son números que contienen una parte fraccionaria separada para un punto. Se usan para reflejar valores con una mayor precisión: Precio = 2.99 Cadena de caracteres (str) Almacena conjuntos de letras. Son los datos que se usan para almacenar texto. Nota que el texto a almacenar a entre comillas Nombre = "Diego" Booleano (bool) Este tipo de datos solo admite dos valores: Verdadero (True) o Falso (False) es_mayor_ que = True es_menor_que = False Es posible hacer la conversión entre tipos de datos Entero a decimal entero = 25 decimal = float(entero) Decimal a entero decimal = 5.25 entero = int(decimal) Conversión de números a cadena de caracteres siglo= 21 mensaje = "Estamos en el siglo" + str(edad) Conversión de cadenas numéricas a números cadena_texto = "2025" numero = int(cadena_numerica) Conversión de booleano a formato numérico Dijimos que los datos booleanos solo admiten dos valores:  verdadero (True) y Falso (0) Es_verdadero = True Es_falso = False print(int(E_verdadero)) print(int(Es_falso)) Conversor de dato numérico a booleano valor = 0 print(bool(valor)) valor = 1 print(bool(valor)) Operadores de comparación Los operadores de comparación, como su nombre lo indica, permite comparar valores devolviendo un dato booleano (Verdadero o falso) Son: * ==; Si, son dos signos iguales para no confundir con el de asignación de valores a las variables. Determina si dos e[...]

MuyLinux Bazzite 44: el nuevo referente del gaming en Linux sigue evolucionando https://www.muylinux.com/wp-content/uploads/2026/04/bazzite.png Bazzite 44 es la nueva versión de una de las distribuciones enfocadas en el gaming más destacadas del panorama, a la que hemos mencionado en unas cuantas ocasiones, a pesar de que nunca le hayamos dedicado un artículo en exclusiva. Pues bien, esto cambia desde ya, porque el proyecto lo vale, y se le está reconociendo así. De hecho, aunque Bazzite apunta a un nicho muy concreto, lo ha trascendido en cierta medida, al punto de convertirse en una de las distribuciones más populares a lo largo del último año. Dos muestras de esta tendencia se observan en Distrowatch, donde ha escalado posiciones hasta casi tocar el top diez; y en nuestra encuesta de fin de año, donde —pese a no haber hablado de ella nunca, cabe repetir— hizo lo propio, logrando una decimosegunda posición y superando a opciones tan asentadas como MX Linux, elementary OS o Deepin. No alcanza el nivel de CachyOS, pero tampoco juega exactamente en la misma liga, ni se dirige del todo al mismo tipo de usuario. Y eso que sí coinciden en muchos aspectos, como el fuerte enfoque en el gaming, o el contar —en ambos casos— con ediciones de escritorio y específicas para dispositivos de mano o, más en concreto, la Steam Deck, entre otras. Sin embargo, mientras que CachyOS se distingue por priorizar las optimizaciones en favor del rendimiento, la principal característica de Bazzite es ofrecer una experiencia más accesible. De la idiosincrasia de Bazzite, o de cómo se crea esta distribución, nos explayamos recientemente con el artículo que le dedicamos a Universal Blue: otra forma de entender Linux que cada día va ganando más adeptos y que va más allá de Bazzite, aunque por el momento este sea su mayor exponente. Hablamos de una distro para jugar, con el aliciente de estar basada en Fedora Atomic Desktops y de aplicar un modelo inmutable, así como un ciclo de lanzamientos convencional. https://www.muylinux.com/wp-content/uploads/2026/04/Bazzite.jpg En cuanto a Bazzite 44, se basa en Fedora 44, lanzada esta misma semana, e incluye entre sus novedades más destacadas las mismas que su distro madre, léase Linux 6.19, systemd 259 y Mesa 26.0.5, junto con la renovación de los entornos de escritorio con GNOME 50 y KDE Plasma 6.6, que marcan el salto generacional en la experiencia de usuario y el conjunto del sistema. A esto se suma que Bazzite emplea el kernel OGC 6.19.x, con la previsión de dar el salto a Linux 7.0 en breve, incluyendo el parche de VRAM de Valve. Otras novedades exclusivas de Bazzite 44 son la reorganización de sus imágenes, que se reducen en tamaño al externalizar componentes como QEMU y ROCm hacia Bazzite-DX; la eliminación de Ptyxis en favor de Konsole con soporte para contenedores en las ediciones con KDE; la introducción de un nuevo instalador para Sunshine mediante ujust, dejando de venir preinstalado; así como la incorporación de mejoras en la cadena de seguridad, con SBOMs, build attestation, escaneo con OpenSSF e imágenes firmadas. A ello se suman detalles más específicos, como el soporte integrado para capturadoras Elgato 4K o el acceso a los últimos parches de ASUS Linux para su uso con ASUSCtl (una herramienta para gestionar funciones específicas de portátiles ASUS en Linux, como perfiles de energía, ventiladores o iluminación). En lo que respecta a los usuarios de Bazzite 43, la actualización a la nueva versión será progresiva, debido a la magnitud de los cambios introducidos, especialmente en dispositivos como Steam Deck, cuyas compilaciones entrarán primero en fase de pruebas para asegurar que la transición se realiza sin sobresaltos. Más datos en el anuncio oficial de Bazzite 44 y la descarga, en el sitio oficial. La entrada Bazzite 44: el nuevo referente del gaming en Linux sigue evolucionando es original de MuyLinux

as), 3): Genera series de números de tres en tres. Esto es porque se almacenan 3 parámetros por cada instancia del objeto sistemas operativos. Supongamos que tenemos 3 sistemas (9 parámetros) range(0, 9, 3) → 0, 3, 6 i=0 → líneas 0, 1, 2 → primer sistema i=3 → líneas 3, 4, 5 → segundo sistema i=6 → líneas 6, 7, 8 → tercer sistema if i + 2 < len(lineas): Esto es por seguridad. Se verifica que un grupo tenga 3 parámetros antes de hacer la lectura. Si no hay un grupo de 3 no hace la lectura. https://ubunlog.com/wp-content/uploads/2026/04/archivos.png Python dispone varias opciones para leer y escribir archivos. Crea el objeto Sistemas sistema = Sistemas() Incorpora los datos de las líneas que corresponde lineas[i], lineas[i + 1], lineas[i + 2] Por ejemplo i=0: lineas[0] → «Ubuntu» → nombre lineas[1] → «26.04» → version lineas[2] → «Debian» → derivada i=3: lineas[3] → «Manjaro» → nombre lineas[4] → «44» → version lineas[5] → «Arch Linux»→ derivada i=6: lineas[6] → «Linux Mint» → nombre lineas[7] → «22» → version lineas[8] → «Ubuntu»→ derivada sistemas.append(sistema) Agrega el objeto recién creado a la lista Sistemas. El bucle finaliza cuando se incorporen todos los objetos reconstruidos del archivo. for s in sistemas: Recorre el archivo recién creado. s.mostrar_info() Llama al método para mostrar los parámetros de cada objeto. Hasta ahora estuvimos tocando de oído usando instrucciones cuyo uso no tenemos del todo claro. Llegó el momento  de ocuparnos de ellos. Operaciones matemáticas básicas con Python En los programas creados en Python pueden usarse las siguientes operaciones matemáticas * Suma: a = 5 + 3 Asigna a la variable el valor 8 * Resta: b = 10 – 2 Asigna a la variable el valor 8 * Multiplicación: c = 4 * 2 ¿A que no adivinas el valor de la variable? * Division:  d = 5 /  3 Asigna a la variable el valor 1,6666… * División sin decimales: e = 21 // 7 Da como resultado 3. * Cálculo del resto de la división: f  =  5 % 3 Asigna a la variable el valor 2. * Potencia: g  =  2 ** 4 Le asigna a la variable el valor 16. Es posible hacer operaciones más complejas pero será necesario introducir el concepto de módulo del que hablaremos más adelante. Variables Tanto en los programas que usamos como ejemplo como en la lista que dimos recién de operaciones matemáticas, usamos variables. Las variables son contenedores en el que se almacenan datos que pueden ser introducidos por el código o en forma externa, modificarse y mostrarse cuando se necesite.  A diferencia de otros lenguajes de programación, en Python no es necesario declarar previamente a que tipo pertenece cada variable antes de usarlas. Una variable se declara así Nombre = "Diego" Donde nombre es el nombre de la variable y el texto entre comillas a la derecha del igual le asigna el valor Diego. Es posible asignar el valor a distintas variables  en una sola línea de código nombre, apellido, edad  = «Diego», «González», 55 Reglas para el nombre de las variables * Caracteres permitidos: SI bien se pueden usar letras, signos de puntuación y guiones bajos, el nombre debe empezar siempre con una letra o un guión bajo. No importan si las letras son mayúsculas o minúsculas. * Sensibilidad a mayúsculas y minúsculas: El sistema diferencia palabras escritas con mayúsculas o minúsculas por lo que deben escribirse exactamente igual a como fueron declaradas. * Palabras reservadas: Existen una serie de palabras que no pueden usarse porque se las reserva el intérprete Las palabra reservadas son: False await else import pass None break except in raise True class finally is return and continue for lambda try as def from nonlocal while assert del global not with async elif if or yield match case En el próximo artículo continuaremos con los componentes del lenguaje de programación Python

Ubunlog Curso de programación en Python usando Linux. Parte 6 https://ubunlog.com/wp-content/uploads/2026/04/micropython.png Estamos haciendo un pequeño curso de programación en Python usando Linux. Este lenguaje de programación multiplataforma es ideal para iniciarse en el mundo de la programación, y seguirse usando a medida que vayamos adquiriendo conocimientos avanzados porque también es útil para la creación de aplicaciones más complejas. En la actualidad, Pyhton es el lenguaje preferido para el uso de aplicaciones en Ciencias de datos, Inteligencia Artificial e incluso la propia Microsoft lo está usando  para reemplazar su propio lenguaje de macros en la planilla de cálculos Excel Curso de programación en Python usando Linux Nos habíamos quedado en el post anterior con los parámetros del comando open() cuando se trabajan con archivos.  Dependiendo del  tipo de archivos es conveniente indicarle al intérprete de Python como debe actuar con los caracteres especiales que indican salto de línea. open("archivo.txt", newline=None) Transforma \r\n y \r a \n (por defecto) open("archivo.txt", newline="") No hace ninguna transformación open("archivo.txt", newline="\n") Solo hace el salto de línea cuando detecta el caracter especial \n (Usado por Linux) open("archivo.txt", newline="\r\n") Solo hace el sato de línea cuando detecta el caracter especial \r\n (Usado por Windows) Para resumir los parámetros  de la instrucción open() * * File: Indica el nombre del archivo (Si está en la misma carpeta) o la ruta donde encontrarlo. * Mode: Parámetro opcional, indica si el archivo se abre en modo de lectura, escritura, ambos y si se borrará el contenido cuando se escriba nuevo. * Buffering: Parámetro Opcional, determina el tamaño del buffer de memoria. >Encoding: Parámetro Opcional, Indica la codificaicón del texto, por defecto se usa la del sistema operativo. Muy útil si se van a hacer aplicaciones para otros que utilicen caracteres especiales. * Errors: Indica como actuar en caso de que se detecten errores de codificación. También es un parámetro opcional. * Newline: Determina como manejar los saltos de línea. También es un parámetro opcinal. Veamos el siguiente programa class Sistemas: Definimos la clase Sistemas que servirá para crear los objetos que representarán a los sistemas operativos. def __init__(self, nombre, version, derivada): Iniciamos el constructor y establecemos los parámetros. self.nombre = nombre self.version = version self.derivada = derivada Estás 3 líneas tomarán los valores a medida que ingresan y los almacenarán el el objeto. def mostrar_info(self): Establece cómo se mostrarán los datos print(f"Nombre: {self.nombre}") print(f"Versión: {self.version}") print(f"Derivada: {self.derivada}") print("-" * 20) Imprime los parámetros y al final de cada grupo imprime guiones. nombre = input("Nombre del sistema: ") version = input("Versión: ") derivada = input("Derivada: ") Aquí se le indica al usuario que ingrese datos distribuciones. with open("sistemas.txt", "a") as archivo: Este comando comprueba si existe un archivo llamado sistemass.txt, lo crea si no existe y agrega los datos al final de los que están escritos. archivo.write(nombre + "\n") archivo.write(version + "\n") archivo.write(derivada + "\n") Imprime los datos almacenados con un salto de línea. with open("sistemas.txt", "r") as archivo Abre el archivo en modo de lectura- lineas = [linea.strip() for linea in archivo.readlines()] Esta instrucción lee todas las líneas del archivo y elimina los caracteres especiales que indican salto de línea. sistemas = [] Crea la lista vacía donde se guardan los objetos que se reconstruyan. for i in range(0, len(line[...]

) La función open() viene predefinida dentro de Python y requiere los siguientes parámetros: File Es obligatorio y le indica al programa donde buscar el archivo. Si está dentro de la misma carpeta del programa solo se indica el nombre del archivo y la extensión. SI no es necesario también indicar la ruta de donde está almacenada. open("archivo.txt") Cuando el archivo está en la carpeta actual. open("carpeta/archivo.txt") Cuando el archivo está dentro de otra carpeta. open("/home/usuario/archivo.txt") Se indica la carpeta dentro de la carpeta personal de un usuario específico. open(3); Se indica un archivo por el identificador que le asigna el sistema operativo. Mode Es un parámetro opcional que indica la forma con la que se trabaja con el archivo. * * r: Modo de solo lectura. Da error si el archivo no fue creado previamente. >w: Escribe el archivo y lo crea si no está. Borra el contenido existente. * a: Crea el archivo si no existe. SI hay contenido escribe al final de este. * x: Crea el archivo. Da error si no existe. * r+: Lee y escribe el archivo, da error si no se creo previamente. * w+: Lee y escribe el archivo. Borra el contenido existente. * a+: Lee y escribe al final del contenido. * t: Es la opción por defecto, trabaja con cadenas de texto. * b: Trabaja con bytes. Es ideal para el trabajo con imágenes o pdf. buffering Es el control de la memoria temporal antes de escribir un archivo. No es necesario especificarlo, pero en algunos casos puede se rútil. * 0: Sin buffer, se escribe directo a disco. Ideal para trabajar con el modo b. * 1; Es el modo por defecto.  Almacena el dato cargado hasta encontrar un salto de línea y entonces lo escribe en la variable. Se usa solo en el modo de texto. * =: Despues del igual se establece un valor en bytes para indicar el tamaño que debe tener el buffer. * -1: El sistema operativo determina el tamaño del buffer. Algunos ejemplos open("archivo.txt", buffering=0) No crea el buffer ya que estamos trabajando con el modo binario. open("archivo.txt", buffering=1)  El buffer trabaja con saltos de línea open("archivo.txt", buffering=4096) Establece un buffer de 4096 bytes open("archivo.txt", buffering=-1) Utiliza el buffer por defecto del sistema operativo. encoding Establece la codificación de caracteres del proyecto. Si no se especifica se utiliza la del sistema. errors Otro parámetro opcional. Define que hacer cuando se encuentran errores de codificación. * Strict: Indica un error cuando lo encuentra. * Ignore: Omite los caracteres que no puede decodificar. * Replace: Sustituye los caracteres no identificados por signos de pregunta. * backslashreplace: Sustituye los caracteres que ignora por la secuencia \xNN Newline Otro parámetro opcional pero que puede resultar útil cuando se trabaja con archivos generados por diferentes sistemas operativos.  Un salto de línea es un carácter invisible que le indica al sistmea operativo que terminó una línea y comienza la siguiente. Continuaremos desarrollando este tema y explicando nuevas instrucciones en el próximo artículo.

Ubunlog Curso de programación en Python usando Linux Quinta parte https://ubunlog.com/wp-content/uploads/2026/04/stocksnap-coding-924920_1280.jpg En esta serie de post del curso de programación en Python usando Linux decidimos probar con un enfoque diferente. En lugar de empezar conlos conceptos básicos  (los ladrillos, por llamarlo de alguna manera)  empezamos por el edificio completo para después ocuparnos de sus partes. En este caso el edificio es el paradigma conocido como Programación Orientada a Objetos.  Para terminar con esta parte del curso analizaremos los conceptos claves  del paradigma aplicados a la programación en Python. Recuerda que el enlace al post anterior está al final del artículo. Curso de programación en Python usando Linux Conceptos clave de la Programación Orientada a Objetos aplicados a Python Clase Es la plantilla con la cuál se construyen los objetos. Se ocupa de definir cómo será un objeto y lo que puede hacer. Es algo así como una receta de cocina. Se define con el comando : class Nombre_de_la_clase Atributos Son las características que describen a un objeto.  Actúan como variables pertenecientes exclusivamente a la clase. Constructor Es un método especial que se ejecuta en forma automática al crear un objeto, Se encarga de inicializar los atributos del mismo. Métodos Son funciones definidas dentro de una clase que determinan el comportamiento del objeto. Herencia Es la capacidad de una clase de tomar las características y comportamientos de otras que ya existen añadiendo y modificando lo que ya existen. La clase de la que se toman las características se llama clase padre y la que lo recibe, con una falta de originalidad enorme, clase hija. Polimorfismo Hablando de falta de originalidad, esta característica significa que clases diferentes pueden tener métodos con el mismo nombre pero con comportamientos diferentes Manejando archivos en Python En los ejemplos que proporcionamos anteriormente, la información se incluía dentro del código. Se trata de un método poco práctico ya que hay que modificarlo cada vez que haya que agregar o borrar una información. Por suerte, hay otras formas de hacerlo como la lectura de los datos dese un archivo. Creamos un archivo de texto simple con el título sistema.txt y el contenido Ubuntu 26.04 Debian Ahora veamos el programa. class Sistemas: Definimos una clase con el nombre SIstemas como habíamos hecho antes. def __init__(self, nombre, version, derivada): Iniciamos el constructor automático que se ocupa de asignar los parámetros. self.nombre = nombre self.version = version self.derivada = derivada Con estas líneas se guardan los atributos recibidos como valores dle objeto. def mostrar_info(self): Define la forma cómo se mostrara la información de los atributos. print(f"Nombre: {self.nombre}") print(f"Versión: {self.version}") print(f"Derivada: {self.derivada}") Instrucciones para imprimir en pantalla los atributos del objeto. Las llaves insertan el valor de las variables dentro del texto. with open("sistema.txt", "r") as archivo: Este comando abre el archivo en modo de lectura y lo cierra una vez que se termina el bloque lineas = archivo.readlines() Lee todas las líneas de un archivo y las guarda en una lista. Hablaremos de las lsitas en archivos posteriores. nombre = lineas[0].strip() version = lineas[1].strip() derivada = lineas[2].strip() Accede a cada línea por su posición y elimina saltos de línea y espacios con el comando strip. sistema = Sistemas(nombre, version, derivada) Crea una instancia del objeto de la clase Sistemas con los parámetros que leyó del archivo. sistema.mostrar_info() Llama al método encargado de imprimir en pantalla La función open([...]

e manera no verificada. La entrada Zed 1.0: nueva versión del editor de código Open Source y orientado a la IA es original de MuyLinux

MuyLinux Zed 1.0: nueva versión del editor de código Open Source y orientado a la IA https://www.muylinux.com/wp-content/uploads/2024/07/zed.png El editor de código Zed, que está publicado como código abierto bajo las licencias APLGv3, GPLv3 y Apache 2, ha anunciado la publicación oficial de su versión 1.0. Los responsables avisan que realmente esto no significa que el producto esté terminado, pero nos suponemos que este lanzamiento representa al menos un punto de inflexión en el desarrollo de la aplicación. Sobre algunas de las características de Zed, sus responsables explican a modo de recuerdo que, en lugar de basar la aplicación en Electron como Visual Studio Code, decidieron crearla “como un videojuego, organizando toda la aplicación en torno a la alimentación de datos a los sombreadores que se ejecutan en la GPU. Eso significó escribir nuestro propio marco de interfaz de usuario, GPUI, desde cero en Rust”. Al contrario de lo que son las aplicaciones basadas en Electron, Zed está realmente compilada en binario y se centra en el uso de la GPU, por lo que tener un buen soporte ahí, menos que disponer de una gráfica potente, es importante para sacarle partido de verdad. Otro aspecto importante de Zed es que es un editor de código “nativo para la IA”, pudiendo el usuario “ejecutar varios agentes en paralelo y editar predicciones que sugieren su próximo cambio con granularidad de pulsaciones de teclas y con la velocidad que espera de Zed. El protocolo de cliente de agente abre Zed a un número cada vez mayor de los mejores agentes que existen, incluidos Claude Agent, Codex, OpenCode y, más recientemente, Cursor”. Vaya por delante que el uso de la IA, al menos de momento, no es obligatorio, así que la aplicación puede ser utilizada como si fuera un editor de código estándar, con las típicas ayudas de completado de sintaxis que proporciona este tipo de producto. En lo que respecta a la versión 1.0 de Zed, esta ha incluido marcadores sobre las líneas, entre los cuales se puede navegar, visualizarlos todos y limpiarlos. También están Fuzzy Nucleo para mejorar el rendimiento de la coincidencia de rutas, la corrección de un fallo de parpadeos en el soporte del modo Vim y la mejora de “la coincidencia aproximada en la paleta de comandos, el selector de ramas, el selector de pestañas y el selector de proyectos recientes para soportar consultas de varias palabras”. https://www.muylinux.com/wp-content/uploads/2026/04/Zed-1.0.png El resto de cosas que han llegado a Zed 1.0 consisten en correcciones para fallos como un operador cs de Vim que era incorrectamente identificado en las comillas simétricas en algunos contextos, el hecho de que el depurador no guardara los ficheros antes de ejecutar una tarea de compilación, la observación de archivos de enlaces simbólicos que apuntaban fuera del proyecto/directorio observado, unos métodos de objetos anidados que no aparecían en el panel de esquema para archivos JavaScript y TypeScript, el hecho de que el botón de asistencia en línea que se mostrara en la barra de herramientas de diagnóstico del proyecto cuando el agente está deshabilitado, la renderización del color en la terminal y el manejo de rutas en Windows. A todos los detalles mencionados hasta aquí se suman planes de pago con opciones que permiten hacer un uso intensivo de la IA y proporcionan análisis de datos, soporte de seguridad con garantías de privacidad y soporte premium. Todos los detalles sobre Zed 1.0 están disponibles en el anuncio oficial y en el lanzamiento que se encuentra en repositorio de GitHub. Se puede obtener la aplicación para Linux, Windows y macOS a partir de la sección de descargas del sitio web del proyecto. La vía oficial para instalar aplicación en Linux es mediante el uso del comando Curl, aunque en la documentación del proyecto es posible encontrar vías alternativas como los repositorios de algunas de las distribuciones más populares. También está en Flathub d[...]

ación de hardware y software que caracteriza a Tuxedo, algo que no siempre se replica al mismo nivel en distribuciones de terceros. La entrada Tuxedo prepara la llegada de Ubuntu 26.04 LTS a WebFAI es original de MuyLinux

MuyLinux Tuxedo prepara la llegada de Ubuntu 26.04 LTS a WebFAI https://www.muylinux.com/wp-content/uploads/2026/04/Ubuntu_WebFAI.jpg Tuxedo Computers ha anunciado la pronta disponibilidad de Ubuntu 26.04 LTS en WebFAI, su herramienta de reinstalación del sistema. Un movimiento rápido y certero a favor de lo que, con toda probabilidad, será el lanzamiento más importante del año en el ámbito de las distribuciones Linux… y no solo por lo que representa Ubuntu en sí. En términos prácticos, esto significa que los usuarios de equipos Tuxedo podrán reinstalar el sistema con la nueva LTS de Ubuntu desde WebFAI en cuanto esté disponible, sin necesidad de recurrir a imágenes externas ni configuraciones manuales, manteniendo la integración y ajustes propios de la marca. Cabe recordar que Ubuntu 26.04 LTS se convierte de facto en el nuevo buque insignia del escritorio Linux, tanto por ser la nueva versión de soporte extendido del «Linux para seres humanos» para los dos próximos años, como por ser la base sobre la que se desarrollan alternativas tan destacadas como Linux Mint, Zorin OS o elementary OS, entre otras. En lo que respecta a Ubuntu 26.04 LTS, estamos ante un lanzamiento repleto de novedades interesantes, incluyendo la actualización de componentes como el kernel Linux 7.0 o el entorno de escritorio GNOME 50, así como el soporte de cifrado de disco completo con TPM, o el de tecnologías como NVIDIA CUDA y AMD ROCm, si estás pensando en IA. Para más detalles, no te pierdas nuestra nota con todas las novedades de Ubuntu 26.04 LTS (¡y familia!). También incluimos la descarga y comentamos el aumento en los requisitos del sistema… https://www.muylinux.com/wp-content/uploads/2025/08/TWF.jpg Pero lo cierto es que si tienes o planeas tener un equipo de Tuxedo, no necesitas preocuparte por este tipo de cuestiones: incluso el modelo más modesto de la marca alemana moverá Ubuntu —o, llegado el caso, cualquier otra distribución Linux— con soltura. Y en lo relativo a la instalación, una herramienta como WebFAI marca la diferencia frente a los métodos tradicionales. En nuestro artículo dedicado a WebFAI lo dejamos claro: si tienes un equipo de Tuxedo y quieres instalar o reinstalar el sistema, y la herramienta incluye la distribución de tu preferencia, no lo dudes. Por integración, automatización y conveniencia, usar WebFAI es la mejor opción con diferencia, además de la más rápida, siempre que mantengas la utilidad actualizada. ¿Y si quieres usar una distribución que no esté incluida en WebFAI? Por lo general no tendrás problema: Linux está bastante estandarizado en lo que a componentes se refiere. En MuyLinux hemos analizado equipos con diferentes distros y la experiencia ha sido siempre positiva. Aun así, Tuxedo desarrolla controladores propios para afinar al máximo la compatibilidad, algo que se refleja sobre todo en la selección de sistemas soportados. La compañía incluye en WebFAI opciones como Ubuntu, Linux Mint, Debian y Fedora, y suele darse prisa en actualizar cuando hay nuevas versiones, aunque priorizando estabilidad e integración. Por ejemplo, Debian 13 tardó apenas un mes en estar disponible en WebFAI y Ubuntu 26.04 LTS apunta a llegar incluso antes, siguiendo la tendencia habitual de la compañía con los lanzamientos más relevantes. Cuando hablamos de Ubuntu en WebFAI, además, nos referimos también a Kubuntu, Ubuntu MATE y Xubuntu, con la posibilidad de cifrar la instalación al estilo OEM. Y si no quieres algo tan reciente, se mantienen opciones de tipo «legacy» con la LTS previa, que en el caso de Ubuntu suele ofrecer un punto extra de estabilidad sin quedarse demasiado atrás. Por último —y no menos importante— WebFAI incluye como primera opción la instalación de Tuxedo OS, la distribución desarrollada por la propia compañía y la recomendada para sacar partido a sus equipos. No solo por afinidad, sino porque es donde mejor se refleja el trabajo de integr[...]

nombre = nombre self.version = version self.derivada = derivada Estas líneas se usan para crear los atributos del objeto. Son variables específicas del objeto que actúan como variables dentro del mismo y los conservarán para cuando se necesiten. def mostrar_info(self): Este método define cómo se mostrará la información de los atributos del objeto. El parámetro self indica que solo debe usar los parámetros guardados como atributos. print(f"Nombre: {self.nombre}") print(f"Versión: {self.version}") print(f"Derivada: {self.derivada}") Estas 3 líneas indican que la forma de mostrar la información de los atributos es imprimiéndolas en pantalla. class SistemaConPeso(Sistemas): Acá es donde se modifica nuestro programa con respecto al anterior. Agregamos una nueva clase extendida construida a partir de la anterior. De ahí que al nombre de la clase se le agregue el nombre de la clase anterior entre paréntesis. def __init__(self, nombre, version, derivada, peso): Este es constructor de la clase hija, casi igual al que vimos antes pero agregando el parámetro peso. super().__init__(nombre, version, derivada) Para no repetir código le indicamos al programa con la instrucción super que la tarea de ocuparse de nombre, versión y derivada es de la clase padre. self.peso = peso Todavía teníamos que ocuparnos de guardar el atributo peso. def mostrar_info(self): Como de lo que se trata es de no escribir código de más, en lugar de crear una nueva función que muestre el dato adicional vamos a modificar la que ya teníamos. super().mostrar_info() Llama al método de la clase padre para establecer como deben mostrarse los atributos guardados en ella. print(f"Peso: {self.peso} Agrega la información sobre cómo deben mostrarse los datos de la clase actual. sistema = SistemaConPeso("Linux Mint", "22", "Ubuntu", "3GB") Crea el objeto donde se guardará la información con el nuevo parámetro agregado y lo guarda en la variable sistema. sistema.mostrar_info() Llama al método encargado de mostrar la información Por supuesto, que este programa no tiene usos prácticos reales. No tendría ningún sentido tener que introducir los valores de los atributos en el código ya que se necesitaría un programador cada vez que es necesario modificar algo. Como vimos en el ejemplo del 3 en raya, Python puede recibir y guardar información ingresada por el usuario mediante el teclado. También puede hacerlo leyendo archivos o interactuadno con bases de datos. Pero, tuvo su utilidad para hacer más claros conceptos claves de la programación orientada a objetos como clases, atributos, constructores, métodos, herencia y polimorfismo. Prometo que en el próximo artículo termino de hablar de la Programación Orientada a Objetos y empiezo a hablar de cómo se hacen las cosas en Python

Ubunlog Curso de programación en Python con Linux Parte 4 https://ubunlog.com/wp-content/uploads/2026/04/cuarto.png En los tiempos del humo generado por las empresas de Inteligencia Artificial y sus propagandistas, aprender programación sigue siendo más necesario que nunca. En esta cuarta parte del curso de programación en Python con Linux seguiremos explicando como entender el paradigma de Programación orientada a Objetos. Recuerda que el enlace a la lección anterior está al final del post. Aunque los agentes y modelos de Inteligencia Artificial sean capaces de entender y escribir código, todavía sigue siendo necesario que un humano sea capaz de darles instrucciones detalladas de lo que tiene que hacer. Para esto no solo hay que entender el problema que se quiere resolver con la aplicación sino también diseñar la solución teniendo en cuenta las características del lenguaje. Vamos a ver si dejamos en claro esto con una analogía. Los obreros construyen los rascacielos. Pero, antes de empezar la construcción se necesitan arquitectos que diseñen los planos, ingenieros que hagan los cálculos estructurales y diseñen las conexiones eléctricas, de gas y agua.  Cuando el edificio esté terminado otras personas deberán determinar el diseño de interiores . Por supuesto que, tal vez trabajadores de experiencia podrían hacer un trabajo competente, siempre que no se presenten complicaciones. Pero, en la práctica nadie quiere apostar a eso. La realidad es que el vibe coding da mejores resultados cuanto más detalladas son las instrucciones y, que grandes empresas han sufrido interrupciones de servicio y borrado bases de datos irreemplazables por agentes de Inteligencia Artificial demasiado emprendedores con instrucciones insuficientes. Curso de programación en Python con Linux Habíamos visto en los artículos anteriores que el modelo de Programación Orientada a Objetos se basa en  4 pilares: objetos, clases, métodos y atributos. Las clases son las plantillas donde se modelan los objetos o entidades sobre las cuales trabajamos. Esas plantillas indican los atributos que tendrán los objetos mientras que los métodos marcan el comportamiento del objeto. A los diferentes elementos creados con el molde establecido en las clases se lo denominan instancias. Por ejemplo, dentro de la clase Sistemas Operativos tenemos las instancias: Linux, Windows, macOS. Ahora bien, es posible que nos interese crear clases que se diferencien poco de clases ya creadas. No es necesario volver a escribir código ya que podemos aprovechar una característica de la Programación Orientada a Objetos conocida como herencia. Veamos el siguiente programa con una clase agregada. El motivo por el cual no pego el código directamente en el artículo es, como ya expliqué, es que la plataforma que usamos para publicar el blog no soporta la indentación. Esta práctica consiste en agregar espacios o tabulaciones (nota lo de o tabulaciones ya que no pueden mezclarse) haciendo que el código sea más fácil de entender. Con la indentación es más fácil estructurar el código de manera jerárquica diferenciando bloques del código como bucles, funciones o clases. Además, si no indentas adecuadamente los programas en Python no funciona. Ahora vamos al análisis del programa línea por línea. class Sistemas: Como vimos, este programa crea la plantilla sobre la cuál se van a crear las instancias de sistemas operativos. def __init__(self, nombre, version, derivada): Acá estamos construyendo la clase. La primera parte es un método automatizado que se utiliza cada vez que se crea una. Lo que está entre paréntesis son los parámetros que va a tener el objeto. Self se usa siempre y hace referencia al objeto. En todos los casos va primero.  Los otros parámetros son los que establecimos en clases anteriores, el nombre de la distribución Linux, la versión  y de cuál distribuicón es derivada. self.[...]

bunlog.com/wp-content/uploads/2022/08/imagen-resumen-2022-blog-desdelinux.jpg Resumen En resumen, si te ha gustado esta publicación sobre todos los «lanzamientos de abril de 2026» registrados por el sitio web de “DistroWatch”, u otros como “OS Watch” y “FOSS Torrent”, coméntanos tus impresiones. Y si conoces otro lanzamiento de alguna otra Distro GNU/Linux o Respin Linuxero del Linuxverso, también será un placer conocerlo a través de los comentarios, para el conocimiento y utilidad de todos. Tal como hoy hemos hecho, al destacar algunos detalles importantes de los lanzamientos de CuerdOS 2.1, Netrunner 26 y Artix Linux 20260402. Por último, recuerda compartir con otros esta divertida e interesante publicación, además de visitar el inicio de nuestro «sitio web» en español. O, en cualquier otro idioma (con solo agregar al final de nuestra URL actual, 2 letras al final, por ejemplo: ar, de, en, fr, ja, pt y ru, entre muchas otras) para conocer más contenidos actuales.