Blog

Actualización de Fedora 25 a Fedora 26

con la nueva actualización que nos brinda Fedora ofrece un método de línea de comandos para actualizar Fedora 25 a Fedora 26. La estación de trabajo Fedora 25 también tiene un método de actualización gráfica.

Ahora pasaremos a actualizar nuestro Fedora.

Poco después del tiempo de liberación, aparece una notificación que indica que hay una actualización disponible. Puede hacer clic en la notificación para iniciar la aplicación de software de GNOME . O puede elegir Software de GNOME Shell. una vez ya hecho la descarga lo instalamos y reiniciamos, esto tardará un momento.

Captura de pantalla de 2017-07-16 01-26-17

Uso de la línea de comandos.

Si has actualizado desde versiones anteriores de Fedora, es probable que estés familiarizado con el complemento de actualización dnf. Este método es el método recomendado y soportado para actualizar Fedora 25 a Fedora 26. El uso de este complemento hará que su actualización a Fedora 26 sea sencilla y fácil.

sudo dnf upgrade –refresh
sudo dnf install dnf-plugin-system-upgrade
sudo dnf system-upgrade download –releasever=26

Captura de pantalla de 2017-07-16 01-46-40Captura de pantalla de 2017-07-16 01-38-08

Captura de pantalla de 2017-07-16 01-39-52

reiniciamos y listo ya tendremos Fedora 26 con nueva visualización más animada y nuevas características.

Captura de pantalla de 2017-07-16 01-50-41

Aquí están los nuevos cambios importantes en Fedora 26:

  • Entorno de escritorio predeterminado GNOME 3.24.2 trae luz nocturna a Fedora.
  • Información del tiempo es en el área de notificación.
  • Kernel de Linux 4.11.9-300.
    Captura de pantalla de 2017-07-16 02-02-25
  • GCC 7 (aunque no todos los paquetes han sido compilados con GCC 7)
  • Otras actualizaciones de paquetes principales: DNF 2.5, Python 3.6, Golang 1.8, Ruby 2.4, Impulso 1.63, OpenSSL 1.1.0
  • Nuevo Vuelta de Fedora basada en Lxqt
  • Aula de Python: Un especial giro de Fedora para los maestros y profesores a usar Fedora en sus aulas o talleres para la enseñanza de Python
  • Integración systemd mejora
    Systemd-on-fedora
  • Rápido de almacenamiento en caché de SSSD está ahora activado por defecto
  • muchas mejoras bajo el capó, como mejor almacenamiento en caché de
  • información del usuario y de grupo y mejor manejo de información de depuración

Aprendiendo PyGTK

PyGTK es un binding de la biblioteca gráfica GTK para el lenguaje de programación Python. La biblioteca GTK se usa para desarrollar el entorno gráfico GNOME, así como sus aplicaciones, a la vez que algunos otros entornos gráficos. La biblioteca GTK permite el desarrollo sencillo de interfaces gráficas y su uso conjunto con Python permite el desarrollo rápido de aplicaciones gráficas potentes.

import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk

En el principio, tenemos que importar el módulo Gtk para poder acceder a las clases y funciones GTK + ‘s. Dado que el sistema de un usuario puede tener varias versiones de GTK + instaladas al mismo, queremos asegurarnos de que cuando importamos GTK que se refiere a GTK + 3 y no cualquier otra versión de la biblioteca, que es el propósito de la declaración.

La siguiente línea crea una ventana vacía.

win = Gtk.Window()

Seguido de la conexión a evento de borrado de la ventana para asegurarse de que se termina la aplicación si hacemos clic en la X para cerrar la ventana.

win.connect("delete-event", Gtk.main_quit)

En el siguiente paso mostramos la ventana.

win.show_all()

Por último, se comienza el bucle de procesamiento + GTK que dejar de fumar cuando la ventana está cerrada (véase la línea 5).

Gtk.main()

Para ejecutar el programa, abrir un terminal, cambie al directorio del archivo, e introduzca:

python simple_main.py

 

import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk

win = Gtk.Window()
win.connect("delete-event", Gtk.main_quit)
win.show_all()
Gtk.main()

captura-de-pantalla-de-2017-06-14-15-56-47.png

ahora crearemos una ventana con título (Titulo) con nombre del botón (boton) y que cada vez que hagamos clic salga (hola mundo).

import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk

class MyWindow(Gtk.Window):

    def __init__(self):
        Gtk.Window.__init__(self, title="Titulo :)")

        self.button = Gtk.Button(label="boton")
        self.button.connect("clicked", self.on_button_clicked)
        self.add(self.button)

    def on_button_clicked(self, widget):
        print("hola mundo")

win = MyWindow()
win.connect("delete-event", Gtk.main_quit)
win.show_all()
Gtk.main()

Captura de pantalla de 2017-06-14 16-02-17

 

Este ejemplo se diferencia del ejemplo sencillo, ya que sub-clase Gtk.Window para definir nuestra propia MyWindow clase.

class MyWindow(Gtk.Window):

En el constructor de la clase que tenemos que llamar al constructor de la superclase. Además, le decimos que para establecer el valor de la propiedad del título de (Titulo 🙂 ).

        Gtk.Window.__init__(self, title="Titulo :)")

 

Las tres líneas siguientes se utilizan para crear un widget de botón, conectarse a su clic señal y añadirlo como niño a la ventana de nivel superior.

        self.button = Gtk.Button(label="boton")
        self.button.connect("clicked", self.on_button_clicked)
        self.add(self.button)

 

En consecuencia, el método on_button_clicked()será llamado si se hace clic en el botón.

    def on_button_clicked(self, widget):
        print("Hello World")

 

 

 

Aprendiendo Python 3.6 Básico (IV)

Lista por compresión anidadas:

creación de matriz.

>>> matriz = [
... [1, 2, 3, 4],
... [5, 6, 7, 8],
... [9, 10, 11, 12],
... ]
>>> matriz
[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
>>> [[fila[i] for fila in matriz] for i in range(4)] #transpuesta de la matriz
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

Captura de pantalla de 2017-06-12 00-57-33

ahora veremos otro caso de transpuestas.

>>> transpuesta = []
>>> for i in range(4):
... transpuesta.append([fila[i] for fila in matriz])
... 
>>> transpuesta
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

Captura de pantalla de 2017-06-12 01-00-21

algo mucho mas práctico es.

>>> list(zip(*matriz))
[(1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)]

Captura de pantalla de 2017-06-12 01-04-00

 

La instrucción

Hay una manera de quitar un ítem de una lista dado su índice en lugar de su valor: la instrucción “del”.  es diferente del método pop(), el cual devuelve un valor. La instrucción “del” también puede usarse para quitar secciones de una lista o vaciar la lista completa (lo que hacíamos antes asignando una lista vacía a la sección). Por ejemplo:

>>> a = [1, 2, 3, 4, 5, 6]
>>> del a[0]
>>> a
[2, 3, 4, 5, 6]
>>> del a[2:5]
>>> a
[2, 3]
>>> del a[:]
>>> a
[]

captura-de-pantalla-de-2017-06-12-01-16-43.png

 

Duplas y secuencias

Vimos que las listas y cadenas tienen propiedades en común. Como Python es un lenguaje en evolución, otros datos de tipo secuencia pueden agregarse. Existe otro dato de tipo secuencia estándar: la dupla. Una dupla consiste de un número de valores separados por comas, por ejemplo:

>>> t = 12345, 54321, 'hola!' #creando dupla numero y palabra
>>> t[0] # mostrando el primer valor
12345
>>> t #mostrando la dupla
(12345, 54321, 'hola!')
>>> 
>>> u =t, (1, 2, 3, 4, 5) # anidando una dupla
>>> u #mostrando anidación
((12345, 54321, 'hola!'), (1, 2, 3, 4, 5))
>>> t[0] = 888 #las duplas son inmutuables por tanto nos dará error
#Traceback (most recent call last):
 #File "<stdin>", line 1, in <module>
#TypeError: 'tuple' object does not support item assignment
>>> v = ([1, 2, 3], [3, 2, 1]) #duplas mutables
>>> v
([1, 2, 3], [3, 2, 1])

captura-de-pantalla-de-2017-06-12-01-23-18.png

Como puedes ver, en la salida las duplas siempre se encierran entre paréntesis, para que las duplas anidadas puedan interpretarse correctamente; pueden ingresarse con o sin paréntesis, aunque a menudo los paréntesis son necesarios de todas formas (si la dupla es parte de una expresión más grande). No es posible asignar a los ítems individuales de una dupla, pero sin embargo sí se puede crear duplas que contengan objetos mutables, como las listas.

 

Un problema particular es la construcción de duplas que contengan 0 o 1 ítem: la sintaxis presenta algunas peculiaridades para estos casos. Las duplas vacías se construyen mediante un par de paréntesis vacío; una dupla con un ítem se construye poniendo una coma a continuación del valor (no alcanza con encerrar un único valor entre paréntesis). Por ejemplo:

>>> vacia = ()
>>> singleton = 'hola',
>>> len(vacia)
0
>>> len(singleton)
1
>>> singleton
('hola',)

captura-de-pantalla-de-2017-06-12-01-30-49-e1497249143659.png

 

>>> x, y, z = t
>>> x
12345
>>> y
54321
>>> z
'hola!'
>>> t
(12345, 54321, 'hola!')

Captura de pantalla de 2017-06-12 01-35-58

desempaquetado de secuencias, pondremos nuevos valores que reemplazarán guardando el valor antiguo.

 

Conjuntos

Python también incluye un tipo de dato para conjuntos. Un conjunto es una colección no ordenada y sin elementos repetidos. Los usos básicos de éstos incluyen verificación de pertenencia y eliminación de entradas duplicadas. Los conjuntos también soportan operaciones matemáticas como la unión, intersección, diferencia, y diferencia simétrica.

>>> canasta = {'manzana', 'naranja', 'manzana', 'pera', 'naranja', 'banana'}
>>> canasta # se borra los duplicados
{'naranja', 'manzana', 'banana', 'pera'}
>>> 'naranja' in canasta # verificará si esta el valor en la lista
True
>>> 'hierba' in canasta
False
>>> a = set('abracadabra') # letras únicas en a
>>> b = set('alacazam')  # letras únicas en b
>>> a # mostrará las letras de a
{'r', 'b', 'c', 'a', 'd'}
>>> a - b       # mostrará la resta
{'d', 'b', 'r'}
>>> a | b        # mostrará letras en a o b
{'r', 'z', 'b', 'c', 'l', 'm', 'a', 'd'}
>>> a & b        # mostrará letras en a y b
{'a', 'c'}
>>> a ^ b        # mostrará letras en a o b pero no en ambos
{'r', 'z', 'b', 'l', 'm', 'd'}

Captura de pantalla de 2017-06-12 01-49-37

 

>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'d', 'r'}

captura-de-pantalla-de-2017-06-12-01-55-41-e1497250614575.png

Aprendiendo Python 3.6 básico (III)

Más sobre listas El tipo de dato lista tiene algunos métodos más. Aquí están todos los métodos de los objetos lista:

list.append (x) :Agrega un ítem al final de la lista.

list.extend (list) : Extiende la lista agregándole todos los ítems de la lista dada.

list.insert (i, x) : Inserta un ítem en una posición dada. El primer argumento es el índice del ítem delante del cual se insertará.

list.remove (x) : Quita el primer ítem de la lista cuyo valor sea x. Es un error si no existe tal ítem.

list.pop () : Quita y  devuelve el último ítem de la lista.

list.clear () : Quita todos los elementos de la lista.

list.index (x)  :Devuelve un índice basado en cero en la lista del primer ítem cuyo valor sea x. Levanta una excepción ValueError si no existe tal ítem.

list.count (x) : Devuelve el número de veces que x aparece en la lista.

list.sort () : Ordena los ítems de la lista en sorteo.

list.reverse () :Invierte la lista.

list.copy () : Devuelve una copia superficial de la lista. Equivalente a a[:].

>>> frutas = ['naranja', 'manzana' , 'pera' , 'banana', 'kiwi', 'manzana', 'banana']
>>> frutas.count('manzana') #cuantas palabras manzanas hay
2
>>> frutas.count('mandarina') #si no hay ninguna botará 0
0
>>> frutas.index('banana') # en que orden esta la primera banana empezando de 0 
3
>>> frutas.index('banana', 4) #en que orden esta banana contando desde la posicion 4 
6
>>> frutas.reverse() # invertirá los items de la lista
>>> frutas
['banana', 'manzana', 'kiwi', 'banana', 'pera', 'manzana', 'naranja']
>>> frutas.append('uva') #se agregará uva en nuestra lista
>>> frutas
['banana', 'manzana', 'kiwi', 'banana', 'pera', 'manzana', 'naranja', 'uva']
>>> frutas.sort()
>>> frutas
['banana', 'banana', 'kiwi', 'manzana', 'manzana', 'naranja', 'pera', 'uva']
>>> frutas.pop() #quitará un item aletorio
'uva'
>>> >>> frutas.extend(frutas) #agregará la lista.
>>> frutas
['banana', 'banana', 'kiwi', 'manzana', 'manzana', 'naranja', 'pera', 'banana', 'banana', 'kiwi', 'manzana', 'manzana', 'naranja', 'pera']
>>>

Captura de pantalla de 2017-06-11 23-13-54

Usando listas como pilas

Los métodos de lista hacen que resulte muy fácil usar una lista como una pila, donde el último elemento añadido es el primer elemento retirado. Para agregar un ítem a la cima de la pila, use append(). Para retirar un ítem de la cima de la pila, use pop() sin un índice explícito. Por ejemplo:

>>> stack = [3, 4, 5 ]
>>> stack.append(6) #agregamos el 6 a la lista
>>> stack.append(7) #agregamos el 7 a la lista
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop() # aqui nos mostrará que valor quita, por default quita el ultimo 
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop() # ahora por default quitará el 6
6
>>> stack.pop() # por default quitará el 5
5
>>> stack
[3, 4]

Captura de pantalla de 2017-06-11 23-29-32

 

Usando listas como colas

También es posible usar una lista como una cola, donde el primer elemento añadido es el primer elemento retirado; sin embargo, las listas no son eficientes para este propósito. Agregar y sacar del final de la lista es rápido, pero insertar o sacar del comienzo de una lista es lento (porque todos los otros elementos tienen que ser desplazados por uno). Para implementar una cola, usá collections.deque el cual fue diseñado para agregar y sacar de ambas puntas de forma rápida. Por ejemplo

>>> queue = deque (["Eric", "John", "Michael"])
>>> queue.append("Terry") # llega Terry 
>>> queue.append("Graham") # llega Graham 
>>> queue.popleft() # tiene la misma funcion de pop pero por izquierda
'Eric'
>>> queue.popleft() # ahora se va John
'John'
>>> queue
deque(['Michael', 'Terry', 'Graham'])
>>>

Captura de pantalla de 2017-06-11 23-47-59

Comprensión de listas

Las comprensiones de listas ofrecen una manera concisa de crear listas. Sus usos comunes son para hacer nuevas listas donde cada elemento es el resultado de algunas operaciones aplicadas a cada miembro de otra secuencia, hay diferentes formas de crear una lista ahora veremos una de cuadrados:

 >>> cuadrados = [] #primera forma de crear una lista
>>> for x in range(10):
... cuadrados.append(x**2)
... 
>>> cuadrados
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> cuadrdos = list(map(lambda x: x**2, range(10))) #segunda forma
>>> cuadrdos
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> cuadrs = [x ** 2 for x in range(10)] #tercera forma
>>> cuadrs
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Captura de pantalla de 2017-06-12 00-05-05

como logramos ver la tercera forma es la mas legible y mas resumida #la forma mas rápida.

 

Una lista de comprensión consiste de corchetes rodeando una expresión seguida de la declaración for y luego cero o más declaraciones for o if. El resultado será una nueva lista que sale de evaluar la expresión en el contexto de los for o if que le siguen. Por ejemplo, esta lista de comprensión combina los elementos de dos listas si no son iguales:

>>> [(x, y) for x in [1, 2, 3] for y in [3, 1, 4] if x != y]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
>>> dupla = [] # es lo mismo que en lo primero
>>> for x in [1, 2, 3]:
... for y in [3,1,4]:
... if x != y:
... dupla.append((x,y))
... 
>>> dupla
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

Captura de pantalla de 2017-06-12 00-16-14

Notá como el orden de los for y if es el mismo en ambos pedacitos de código. Si la expresión es una tupla (como el (x, y) en el ejemplo anterior), debe estar entre paréntesis.

 

ahora veremos : filtrar, función, llamar método, creación de duplas, importar pi.

>>> vec = [-4, -2, 0, 2, 4] #creación de lista

>>> [x * 2 for x in vec] #duplicará los valores de la lista vec
[-8, -4, 0, 4, 8]

>>> [x for x in vec if x>= 0] # solo mostrará positivos
[0, 2, 4]

>>> [abs(x) for x in vec] #aplica una función a todos los elementos
[4, 2, 0, 2, 4]

>>> frutafresca = ['banana', 'fresa', 'manzana']
>>> [arma.strip() for arma in frutafresca]
['banana', 'fresa', 'manzana']

>>> [(x, x ** 2) for x in range (6)] #creación de dupla
[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]

>>> vec = [[1,2,3], [4,5,6], [7,8,9]] # poner todo en una lista
>>> [num for elem in vec for num in elem]
[1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> from math import pi #importar pi
>>> [str(round(pi, i)) for i in range(1, 6)]
['3.1', '3.14', '3.142', '3.1416', '3.14159']

Captura de pantalla de 2017-06-12 00-32-40