Página de Seraph

Reactivando el blog

2025-08-12T19:10:00-04:00

Reactivando el blog

Luego de casi dos años sin publicar nada, volvemos a reactivar el blog.

Principalmente uno de los problemas era la actualización del generador estático de Pelican.

Hoy lo que hice fue salir de poetry tomando las dependencias y usar de cero uv.

Logré generar la salida html sin errores.

Así que ya estoy listo para volver a publicar.

Manejo de calendario en python con la librería calendar

2023-03-18T11:22:00-04:00

Manejo de calendario en python con la librería calendar

El artículo se basa en el artículo en inglés de: * Python Engineer

La librería calendar permite desplegar meses de un año, lo primero que tenemos que hacer es importar la librería.

import calendar

Desplegar el calendario del año y mes:

Se define las variables aÑo y mes, se llama a calendar al método month pasando estas variables, devuelve el calendario del mes y año definido.

year = 2023
month = 3
print(calendar.month(year, month))

     March 2023
Mo Tu We Th Fr Sa Su
       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

Desplegar el calendario del año 2023:

Se define el aÑo del calendario y luego se muestra todos los meses.

year = 2023 
print(calendar.calendar(year))

2023

      January                   February                   March
Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
                   1             1  2  3  4  5             1  2  3  4  5
 2  3  4  5  6  7  8       6  7  8  9 10 11 12       6  7  8  9 10 11 12
 9 10 11 12 13 14 15      13 14 15 16 17 18 19      13 14 15 16 17 18 19
16 17 18 19 20 21 22      20 21 22 23 24 25 26      20 21 22 23 24 25 26
23 24 25 26 27 28 29      27 28                     27 28 29 30 31
30 31

       April                      May                       June
Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
                1  2       1  2  3  4  5  6  7                1  2  3  4
 3  4  5  6  7  8  9       8  9 10 11 12 13 14       5  6  7  8  9 10 11
10 11 12 13 14 15 16      15 16 17 18 19 20 21      12 13 14 15 16 17 18
17 18 19 20 21 22 23      22 23 24 25 26 27 28      19 20 21 22 23 24 25
24 25 26 27 28 29 30      29 30 31                  26 27 28 29 30

        July                     August                  September
Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
                1  2          1  2  3  4  5  6                   1  2  3
 3  4  5  6  7  8  9       7  8  9 10 11 12 13       4  5  6  7  8  9 10
10 11 12 13 14 15 16      14 15 16 17 18 19 20      11 12 13 14 15 16 17
17 18 19 20 21 22 23      21 22 23 24 25 26 27      18 19 20 21 22 23 24
24 25 26 27 28 29 30      28 29 30 31               25 26 27 28 29 30
31

      October                   November                  December
Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
                   1             1  2  3  4  5                   1  2  3
 2  3  4  5  6  7  8       6  7  8  9 10 11 12       4  5  6  7  8  9 10
 9 10 11 12 13 14 15      13 14 15 16 17 18 19      11 12 13 14 15 16 17
16 17 18 19 20 21 22      20 21 22 23 24 25 26      18 19 20 21 22 23 24
23 24 25 26 27 28 29      27 28 29 30               25 26 27 28 29 30 31
30 31

Clase Calendar

La clase calendar permite crear un objecto calendario, el cual permite obtener información del calendario y darle formato de salida.

Como usar la clase calendar:

El método iterweekdays():

Permite iterar sobre los días de la semana, el método devuelve un iterador que itera sobre los días de la semana, el primer día de la semana es el lunes, el último es el domingo.

import calendar

cal = calendar.calendar()
for dia in cal.iterweekdays():
    print(dia,end=' ')

0 1 2 3 4 5 6

Entonces devuelve lunes, martes, miércoles, jueves, viernes, sábado y domingo.

El método monthdayscalendar():

El método permite iterar sobre todo el mes, los días de cada semana.

cal = calendar.Calendar()
for mes in cal.monthdayscalendar(2023,3):
    print(mes)

[0, 0, 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, 0, 0]

Clase TextCalendar

Esta es una clase que se usa para generar calendarios en formato texto.

El método formatmonth():

Generada la salida del mes en formato calendario pero en texto.

textcal = calendar.TextCalendar()
year = 2023
month = 3
w = 4 # ancho de cada columna
l = 2 # número de líneas por semana
print(textcal.formatmonth(year, month, w, l))

     March 2023
Mo Tu We Th Fr Sa Su
       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

El método prmonth():

Este método imprime el mes en formato calendario retornado por el método formatmonth. Toma los mismos argumentos del método formatmonth.

textcal.prmonth(year,month,6,3)

March 2023


 Mon    Tue    Wed    Thu    Fri    Sat    Sun


                 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

Clase HTMLCalendar

Se usa para generar los calendarios en formato html.

El método formatmonth():

htmlcal = calendar.HTMLCalendar()
print(htmlcal.formatmonth(2023, 3))

<table border="0" cellpadding="0" cellspacing="0" class="month">
<tr><th colspan="7" class="month">March 2023</th></tr>
<tr><th class="mon">Mon</th><th class="tue">Tue</th><th class="wed">Wed</th><th class="thu">Thu</th><th class="fri">Fri</th><th class="sat">Sat</th><th class="sun">Sun</th></tr>
<tr><td class="noday">&nbsp;</td><td class="noday">&nbsp;</td><td class="wed">1</td><td class="thu">2</td><td class="fri">3</td><td class="sat">4</td><td class="sun">5</td></tr>
<tr><td class="mon">6</td><td class="tue">7</td><td class="wed">8</td><td class="thu">9</td><td class="fri">10</td><td class="sat">11</td><td class="sun">12</td></tr>
<tr><td class="mon">13</td><td class="tue">14</td><td class="wed">15</td><td class="thu">16</td><td class="fri">17</td><td class="sat">18</td><td class="sun">19</td></tr>
<tr><td class="mon">20</td><td class="tue">21</td><td class="wed">22</td><td class="thu">23</td><td class="fri">24</td><td class="sat">25</td><td class="sun">26</td></tr>
<tr><td class="mon">27</td><td class="tue">28</td><td class="wed">29</td><td class="thu">30</td><td class="fri">31</td><td class="noday">&nbsp;</td><td class="noday">&nbsp;</td></tr>
</table>

Al tomar el código y pasarlo por codepen se tiene:

Esta librería facilita la visualización de calendarios anual y/o por mes.

Principios S.O.L.I.D. - 5. Principio de inversión de la dependencia. (DIP - Dependency inversion principle)

2022-05-14T14:00:00-04:00

En ingeniería de software existe el principio S.O.L.I.D. Los principios SOLID son guías que pueden ser aplicadas en el desarrollo de software para eliminar malos diseños provocando que el programador tenga que refactorizar hasta que sea legible y extensible.

Sus principios son:

Single responsability principle - Principio de responsabilidad única.
Open/closed principle - Principio abierto/cerrado.
Liskov substitution principle - Principio de sustitución Liskov.
Interface segregation principle - Principio de segregación de la interfaz.
Dependency inversion principle - Principio de inversión de la dependencia.

A continuación dejo un vídeo de ArjanCodes que explica con código python los principios S.O.L.I.D:

Los artículos anteriores: * Principio de responsabilidad única. * Principio abierto/cerrado. * Principio de sustitución Liskov. * [Principio de segregación de la interfaz](https://www.seraph.to/python_solid4.html#python_solid4.

El Principio de inversión de la dependencia es una forma específica de desacoplar módulos de software. Al seguir el principio, las relaciones de dependencia convencionales establecidas desde los módulos de alto nivel de establecimiento de políticas a los módulos de depencia de bajo nivel se invierten, lo que hace que los módulos de alto nivel sean independientes de los detalles de implementación del módulo de bajo nivel, el principio establece:

Los módulos de alto nivel no deberían depender de los módulos de bajo nivel. Ambos deberían depender de abstracciones (p.ej., interfaces).
Las abstracciones no deberían depender de los detalles. Los detalles (implementaciones concretas) deben depender de abstracciones.

La dependencia debe estar en abstracciones, no en concreciones. Los módulos de alto nivel no deben depender de módulos de bajo nivel. Tanto las clases de nivel bajo como las de alto nivel deberían depender de las mismas abstracciones. Las abstracciones no deberían depender de los detalles. Los detalles deben depender de abstracciones.

Se tiene el código del artículo anterior sobre el Principio de segregación de interfaz. Con solución usando composición.

En este caso, al pasar como argumento de un método un objeto, ya viola este principio.

class SMSAuth:
    authorized = False

    def verify_code(self,code):
        print(f"Verifying code {code}")
        self.authorized = True

    def is_authorized(self) -> bool:
        return self.authorized 

# Clase abstracta procesamiento de pago con método pay.
class PaymentProcessor(ABC):
    @abstractmethod
    def pay(self,order):
        pass 

# Clase procesamiento pago por tarjeta de debito que hereda de la clase abstracta.
# el método init recibe como argumentos el código de seguridad y la clase SMSAuth para autorizar el pago.
class DebitPaymentProcessor(PaymentProcessor):

    def __init__(self,security_code, authorizer: SMSAuth):

        self.authorizer = authorizer
        self.security_code = security_code

    def pay(self,order):
        # Se consulta si no está autorizado el pago
        # al no tener autorización devuelve una excepción.
        if not self.authorizer.is_authorized():
            raise Exception("Not authorized")
        print("Processing debit payment type")
        print(f"Verifying security code: {self.security_code}")
        order.status = "paid"

# Clase de procesamiento de pago con TC, que hereda de la clase abstracta.
# En este caso no se necesita la clase SMSAuth, sólo el código de seguridad.
class CreditPaymentProcessor(PaymentProcessor):

    def __init__(self,security_code):
        self.security_code = security_code


    def pay(self,order):
        print("Processing credit payment type")
        print(f"Verifying security code: {self.security_code}")
        order.status = "paid"

# Clase de procesamiento de pago vía paypal, hereda de la misma clase abstracta.
# El init recibe de argumentos dirección de correo y el objecto SMSAuth.
class PaypalPaymentProcessor(PaymentProcessor):

    def __init__(self,email_address,authorizer:SMSAuth):
        self.authorizer = authorizer
        self.email_address = email_address
        self.verified = False


    def pay(self,order):
        # Se valida si se tiene autorización para realizar el pago.
        if not self.authorizer.is_authorized():
            raise Exception("Not authorized")
        print("Processing paypal payment type")
        print(f"Verifying email address: {self.email_address}")
        order.status = "paid"

# Ahora se instancia la clase Order, y se agrega los items a comprar en la orden.

order = Order()
order.add_item("Teclado", 1, 50)
order.add_item("Memoria", 1, 150)
order.add_item("Cable USB", 2, 5)

# Imprime el precio total de la orden
print(order.total_price())

# Se define el autorizador.
authorizer = SMSAuth()

# Se define el método de pago debito
# ahora se le pasa el código y el autorizador.

processor = DebitPaymentProcessor("0372846",authorizer)
# Se verifica el pago
authorizer.verify_code(454545)

# Realiza el pago de la orden.
processor.pay(order)

# Se define el método de pago TC
# Para este caso se mantiene igual.
processor = CreditPaymentProcessor("0372846")
processor.pay(order)



# Se define el método de pago paypal
# Se le pasa el correo y el autorizador.
processor = PaypalPaymentProcessor("h@h.com",authorizer)
# Se realiza el pago de la orden.
processor.pay(order)

La salida de está ejecución es la siguiente:

210
Verifying code 454545
Processing debit payment type
Verifying security code: 0372846

Processing debit payment type
Verifying security code: 0372846

Processing credit payment type
Verifying security code: 0372846

Processing paypal payment type
Verifying email address: h@h.com

Solución

Para cumplir el principio de la inversión de la dependencia se crea una clase abstracta que maneje si se verifica la autenticación junto con la clase AuthSMS, en las respectivas clases del procesamiento de pago que se necesite verificar por SMS, en vez de pasar como argumento el objeto, se pasa la clase abstracta.

A continuación el código:

from abc import ABC, abstractmethod

# La clase Order 
class Order:

    def __init__(self):
        self.items = []
        self.quantities = []
        self.prices = []
        self.status = "open"

    def add_item(self, name, quantity, price):
        self.items.append(name)
        self.quantities.append(quantity)
        self.prices.append(price)

    def total_price(self):
        total = 0
        for i in range(len(self.prices)):
            total += self.quantities[i] * self.prices[i]
        return total

# Clase abstracta authorizer con método que devuelve si está autorizado o no. 
class Authorizer(ABC):
    @abstractmethod
    def is_authorized(self) ->bool:
        pass


# Clase abstracta de procesamiento de pago
class PaymentProcessor(ABC):
    @abstractmethod
    def pay(self,order):
        pass 

# Clase SMSAutho que hereda de la clase abstracta authorizer
class SMSAuth(Authorizer):
    authorized = False

    def verify_code(self,code):
        print(f"Verifying code {code}")
        self.authorized = True

    def is_authorized(self) -> bool:
        return self.authorized

# clase pago por tarjeta de debito que recibe en el init authorizer que es la clase abstracta.
class DebitPaymentProcessor(PaymentProcessor):

    def __init__(self,security_code, authorizer: Authorizer):

        self.authorizer = authorizer
        self.security_code = security_code

    def pay(self,order):
        # Se consulta si no está autorizado el pago
        # al no tener autorización devuelve una excepción.
        if not self.authorizer.is_authorized():
            raise Exception("Not authorized")
        print("Processing debit payment type")
        print(f"Verifying security code: {self.security_code}")
        order.status = "paid"

# La clase de procesamiento de TC se mantiene igual.
class CreditPaymentProcessor(PaymentProcessor):

    def __init__(self,security_code):
        self.security_code = security_code


    def pay(self,order):
        print("Processing credit payment type")
        print(f"Verifying security code: {self.security_code}")
        order.status = "paid"


# clase dde procesamiento de pago por paypal
# Se le pasa como argumento la clase abstracta.
class PaypalPaymentProcessor(PaymentProcessor):

    def __init__(self,email_address,authorizer:Authorizer):
        self.authorizer = authorizer
        self.email_address = email_address
        self.verified = False


    def pay(self,order):
        # Se valida si se tiene autorización para realizar el pago.
        if not self.authorizer.is_authorized():
            raise Exception("Not authorized")
        print("Processing paypal payment type")
        print(f"Verifying email address: {self.email_address}")
        order.status = "paid"

# Ahora se instancia la clase Order, y se agrega los items a comprar en la orden.

order = Order()
order.add_item("Teclado", 1, 50)
order.add_item("Memoria", 1, 150)
order.add_item("Cable USB", 2, 5)

# Imprime el precio total de la orden
print(order.total_price())

# Se define el autorizador.
authorizer = SMSAuth()

# Se define el método de pago debito
# ahora se le pasa el código y el autorizador.

processor = DebitPaymentProcessor("0372846",authorizer)
# Se verifica el pago
authorizer.verify_code(454545)

# Realiza el pago de la orden.
processor.pay(order)

# Se define el método de pago TC
# Para este caso se mantiene igual.
processor = CreditPaymentProcessor("0372846")
processor.pay(order)



# Se define el método de pago paypal
# Se le pasa el correo y el autorizador.
processor = PaypalPaymentProcessor("h@h.com",authorizer)
# Se realiza el pago de la orden.
processor.pay(order)

La salida es la siguiente:

210
Verifying code 454545
Processing debit payment type
Verifying security code: 0372846

Processing debit payment type
Verifying security code: 0372846

Processing credit payment type
Verifying security code: 0372846

Processing paypal payment type
Verifying email address: h@h.com

Lo que se logro es ocultar la implementación de la composición que se pasa como argumento en los procesadores de pago que tiene que validar vía SMS.

En próximo artículo

Referencias:

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Principios S.O.L.I.D. - 4. Principio de segregación de la interfaz. (ISP - Interface segregation principle)

2022-05-08T14:00:00-04:00

Sus principios son:

Single responsability principle - Principio de responsabilidad única.
Open/closed principle - Principio abierto/cerrado.
Liskov substitution principle - Principio de sustitución Liskov.
Interface segregation principle - Principio de segregación de la interfaz.
Dependency inversion principle - Principio de inversión de la dependencia.

A continuación dejo un vídeo de ArjanCodes que explica con código python los principios S.O.L.I.D:

Los artículos anteriores: * Principio de responsabilidad única. * Principio abierto/cerrado. * Principio de sustitución Liskov.

El Principio de segregación de la interfaz establece que los clientes de un programa dado solo deberían conocer de este aquellos métodos que realmente usan y no aquellos que no necesitan usar. El ISP se aplica a una interfaz amplia y compleja para escindirla en otras más pequeñas y específicas, de tal forma que cada cliente use solo aquella que necesite, pudiendo así ignorar al resto. A este tipo de interfaz reducida se le llama interfaces de rol.

El Principio de Segregación de Interfaz establece que los clientes no deberían ser forzados a depender de métodos que no utilizan y, por tanto, sugiere la creación de interfaces o clases específicas para dichos clientes.

Del principio de sustitución de Livkov se tiene el códgio de procesamiento de pagos. A continuación el código.

from abc import ABC, abstractmethod

# La clase Order se mantiene igual así que en el siguiente código no se mostrará.
class Order:

    def __init__(self):
        self.items = []
        self.quantities = []
        self.prices = []
        self.status = "open"

    def add_item(self, name, quantity, price):
        self.items.append(name)
        self.quantities.append(quantity)
        self.prices.append(price)

    def total_price(self):
        total = 0
        for i in range(len(self.prices)):
            total += self.quantities[i] * self.prices[i]
        return total


# La clase abstracta con el método de pago que ya no maneja el código de seguridad.
class PaymentProcessor(ABC):
    @abstractmethod
    def pay(self,order):
        pass 


# Se define las clases de pago a debito y crédito y se le define el código de seguridad.
class DebitPaymentProcessor(PaymentProcessor):

    def __init__(self,security_code):
        self.security_code = security_code

    def pay(self,order):
        print("Processing debit payment type")
        print(f"Verifying security code: {self.security_code}")
        order.status = "paid"

class CreditPaymentProcessor(PaymentProcessor):

    def __init__(self,security_code):
        self.security_code = security_code

    def pay(self,order):
        print("Processing credit payment type")
        print(f"Verifying security code: {self.security_code}")
        order.status = "paid"

# Para el caso de paypal se define el correo electrónico.
class PaypalPaymentProcessor(PaymentProcessor):

    def __init__(self,email_address):
        self.email_address = email_address


    def pay(self,order):
        print("Processing paypal payment type")
        print(f"Verifying email address: {self.email_address}")
        order.status = "paid"

# Ahora se instancia la clase Order, y se agrega los items a comprar en la orden.

order = Order()
order.add_item("Teclado", 1, 50)
order.add_item("Memoria", 1, 150)
order.add_item("Cable USB", 2, 5)

# Imprime el precio total de la orden
print(order.total_price())


# Se define el método de pago debito

processor = DebitPaymentProcessor("0372846")
processor.pay(order)

# Se define el método de pago TC

processor = CreditPaymentProcessor("0372846")
processor.pay(order)



# Se define el método de pago paypal
processor = PaypalPaymentProcessor("h@h.com")
processor.pay(order)

La salida genera lo siguiente:

210
Processing debit payment type
Verifying security code: 0372846

Processing debit payment type
Verifying security code: 0372846

Processing credit payment type
Verifying security code: 0372846

Processing paypal payment type
Verifying email address: h@h.com

Primera mejora

Para cumplir con el método de segregación la mejora que se hará es en la clase abstracta, en vez de tener un sólo método (pago), ahora tendrá uno de autenticación vía SMS.

A continuación el código:

from abc import ABC, abstractmethod


# La clase abstracta de procesamiento de pago
# tiene los métodos pay y auth_sms

class PaymentProcessor(ABC):
    @abstractmethod
    def pay(self,order):
        pass 
    @abstractmethod
    def auth_sms(self,code):
        pass 


# La clase DebitPaymentProcessor hereda de la clase abstracta.
class DebitPaymentProcessor(PaymentProcessor):

    def __init__(self,security_code):
        self.security_code = security_code
        self.verified = false

    def pay(self,order):
        if not self.verified:
            raise Exception("Not authorized")
        print("Processing debit payment type")
        print(f"Verifying security code: {self.security_code}")
        order.status = "paid"

    def auth_sms(self,code):
        print(f"Verifying SMS code {code}")
        self.verified = True


# La clase CreditPaymentProcessor hereda de la clase abstracta
# El problema acá es que pago con TC no necesita enviar un SMS de autenticación
# pero toca usarlo por la clase abstracta, al enviar un mensaje de error, pero 
# al hacer esto se está violando el principio de sustitución de Liskov. 
class CreditPaymentProcessor(PaymentProcessor):

    def __init__(self,security_code):
        self.security_code = security_code


    def pay(self,order):
        print("Processing credit payment type")
        print(f"Verifying security code: {self.security_code}")
        order.status = "paid"

    # Esta es una violacion del principio de sustitución de Liskov
    def auth_sms(self,code):
        raise Exception("Credit card payments don't support SMS code authorizations")

# La clase de procesamiento de pago por paypal hereda de la clase abstracta.
class PaypalPaymentProcessor(PaymentProcessor):

    def __init__(self,email_address):
        self.email_address = email_address
        self.verified = False


    def pay(self,order):
        if not self.verified:
            raise Exception("Not authorized")
        print("Processing paypal payment type")
        print(f"Verifying email address: {self.email_address}")
        order.status = "paid"


    def auth_sms(self,code):
        print(f"Verifying SMS code {code}")
        self.verified = True

Segunda mejora

Para resolver el incumplimiento del principio de sustitución de Liskov se va a crear 2 clases abstractas, una para autenticación vía SMS y otra para validar lo que no usan SMS.

# Clase abstracta procesador de pago que ahora sólo tiene el método pay
class PaymentProcessor(ABC):
    @abstractmethod
    def pay(self,order):
        pass 


# Ahora se tiene una clase abstracta de procesamiento de pago SMS que hereda de
# la clase anterior. 
# Con sólo el método de auth_sms por que ya el de pago lo hereda de la clase abstracta anterior.
class PaymentProcessor_SMS(PaymentProcessor):

    @abstractmethod
    def auth_sms(self,code):
        pass 


# Clase procesamiento de tarjeta de debito que hereda de la 
# clase abstracta de pago SMS.
class DebitPaymentProcessor(PaymentProcessor_SMS):

    def __init__(self,security_code):
        self.security_code = security_code
        self.verified = false

    def pay(self,order):
        if not self.verified:
            raise Exception("Not authorized")
        print("Processing debit payment type")
        print(f"Verifying security code: {self.security_code}")
        order.status = "paid"

    def auth_sms(self,code):
        print(f"Verifying SMS code {code}")
        self.verified = True


# Clase de procesamiento de TC que hereda de la clase raíz.
class CreditPaymentProcessor(PaymentProcessor):

    def __init__(self,security_code):
        self.security_code = security_code


    def pay(self,order):
        print("Processing credit payment type")
        print(f"Verifying security code: {self.security_code}")
        order.status = "paid"


# Clase de procesamiento vía paypal que hereda de la Clase abstracta 
# que soporta SMS

class PaypalPaymentProcessor(PaymentProcessor_SMS):

    def __init__(self,email_address):
        self.email_address = email_address
        self.verified = False


    def pay(self,order):
        if not self.verified:
            raise Exception("Not authorized")
        print("Processing paypal payment type")
        print(f"Verifying email address: {self.email_address}")
        order.status = "paid"


    def auth_sms(self,code):
        print(f"Verifying SMS code {code}")
        self.verified = True

Ya se tiene las diferentes clases con sólo los métodos que necesitan bien separados cumpliendo con el principio de segregación.

Existe otra solución y es usando commposición, se creará la clase SMSAuth que tendrá el método de verificación de código SMS y si está autorizado. La clase abstracta de procesamiento de pago sólo tendrá el método pay,

class SMSAuth:
    authorized = False

    def verify_code(self,code):
        print(f"Verifying code {code}")
        self.authorized = True

    def is_authorized(self) -> bool:
        return self.authorized 

# Clase abstracta procesamiento de pago con método pay.
class PaymentProcessor(ABC):
    @abstractmethod
    def pay(self,order):
        pass 

# Clase procesamiento pago por tarjeta de debito que hereda de la clase abstracta.
# el método init recibe como argumentos el código de seguridad y la clase SMSAuth para autorizar el pago.
class DebitPaymentProcessor(PaymentProcessor):

    def __init__(self,security_code, authorizer: SMSAuth):

        self.authorizer = authorizer
        self.security_code = security_code

    def pay(self,order):
        # Se consulta si no está autorizado el pago
        # al no tener autorización devuelve una excepción.
        if not self.authorizer.is_authorized():
            raise Exception("Not authorized")
        print("Processing debit payment type")
        print(f"Verifying security code: {self.security_code}")
        order.status = "paid"

# Clase de procesamiento de pago con TC, que hereda de la clase abstracta.
# En este caso no se necesita la clase SMSAuth, sólo el código de seguridad.
class CreditPaymentProcessor(PaymentProcessor):

    def __init__(self,security_code):
        self.security_code = security_code


    def pay(self,order):
        print("Processing credit payment type")
        print(f"Verifying security code: {self.security_code}")
        order.status = "paid"

# Clase de procesamiento de pago vía paypal, hereda de la misma clase abstracta.
# El init recibe de argumentos dirección de correo y el objecto SMSAuth.
class PaypalPaymentProcessor(PaymentProcessor):

    def __init__(self,email_address,authorizer:SMSAuth):
        self.authorizer = authorizer
        self.email_address = email_address
        self.verified = False


    def pay(self,order):
        # Se valida si se tiene autorización para realizar el pago.
        if not self.authorizer.is_authorized():
            raise Exception("Not authorized")
        print("Processing paypal payment type")
        print(f"Verifying email address: {self.email_address}")
        order.status = "paid"

# Ahora se instancia la clase Order, y se agrega los items a comprar en la orden.

order = Order()
order.add_item("Teclado", 1, 50)
order.add_item("Memoria", 1, 150)
order.add_item("Cable USB", 2, 5)

# Imprime el precio total de la orden
print(order.total_price())

# Se define el autorizador.
authorizer = SMSAuth()

# Se define el método de pago debito
# ahora se le pasa el código y el autorizador.

processor = DebitPaymentProcessor("0372846",authorizer)
# Se verifica el pago
authorizer.verify_code(454545)

# Realiza el pago de la orden.
processor.pay(order)

# Se define el método de pago TC
# Para este caso se mantiene igual.
processor = CreditPaymentProcessor("0372846")
processor.pay(order)



# Se define el método de pago paypal
# Se le pasa el correo y el autorizador.
processor = PaypalPaymentProcessor("h@h.com",authorizer)
# Se realiza el pago de la orden.
processor.pay(order)

La salida de está ejecución es la siguiente:

210
Verifying code 454545
Processing debit payment type
Verifying security code: 0372846

Processing debit payment type
Verifying security code: 0372846

Processing credit payment type
Verifying security code: 0372846

Processing paypal payment type
Verifying email address: h@h.com

Lo bueno de la composición es que se elimina la creación de una clase abstracta adicional.

Referencias:

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Principios S.O.L.I.D. - 3. Principio de sustitución Liskov. (LSP - Liskov substitution principle)

2022-05-08T13:00:00-04:00

Sus principios son:

Single responsability principle - Principio de responsabilidad única.
Open/closed principle - Principio abierto/cerrado.
Liskov substitution principle - Principio de sustitución Liskov.
Interface segregation principle - Principio de segregación de la interfaz.
Dependency inversion principle - Principio de inversión de la dependencia.

A continuación dejo un vídeo de ArjanCodes que explica con código python los principios S.O.L.I.D:

Los artículos anteriores: * Principio de responsabilidad única. * Principio abierto/cerrado

El principio de sustitución de Liskov se define como: Cada clase que hereda de otra puede usarse como su padre sin necesidad de conocer las diferencias entre ellas.

La idea principal detrás del principio de sustitución de Liskov es que, para cualquier clase, un cliente debería poder usar cualquiera de sus subtipos de manera indistinguible, sin siquiera darse cuenta y, por lo tanto, sin comprometer el comportamiento esperado en tiempo de ejecución. Esto significa que los clientes están completamente aislados y desconocen los cambios en la jerarquía de clases.

Del principio de abierto y cerrado se creo una clase abstracta y se crearon diferentes clases que heredan de esa clase abstracta para cada proceso de pago. A continuación el código.

from abc import ABC, abstractmethod

# La clase Order se mantiene igual:

class Order:

    def __init__(self):
        self.items = []
        self.quantities = []
        self.prices = []
        self.status = "open"

    def add_item(self, name, quantity, price):
        self.items.append(name)
        self.quantities.append(quantity)
        self.prices.append(price)

    def total_price(self):
        total = 0
        for i in range(len(self.prices)):
            total += self.quantities[i] * self.prices[i]
        return total


# Se crea una clase abstracta del proceso de pago:
class PaymentProcessor(ABC):
    @abstractmethod
    def pay(self,order,security_code):
        pass 


# Se crea la clase de pago con debito que hereda de la clase abstracta
class DebitPaymentProcessor(PaymentProcessor):
    def pay(self,order,security_code):
        print("Processing debit payment type")
        print(f"Verifying security code: {security_code}")
        order.status = "paid"

# Se crea la clase de pago con TC que hereda de la clase abstracta
class CreditPaymentProcessor(PaymentProcessor):
    def pay(self,order,security_code):
        print("Processing credit payment type")
        print(f"Verifying security code: {security_code}")
        order.status = "paid"


# Se crea el método de pago paypal
class PaypalPaymentProcessor(PaymentProcessor):
    def pay(self,order,security_code):
        print("Processing paypal payment type")
        print(f"Verifying security code: {security_code}")
        order.status = "paid"


# Ahora se instancia la clase Order, y se agrega los items a comprar en la orden.

order = Order()
order.add_item("Teclado", 1, 50)
order.add_item("Memoria", 1, 150)
order.add_item("Cable USB", 2, 5)

# Imprime el precio total de la orden
print(order.total_price())


# Se define el método de pago debito

processor = DebitPaymentProcessor()
processor.pay(order, "0372846")

# Se define el método de pago TC

processor = CreditPaymentProcessor()
processor.pay(order, "0372846")



# Se define el método de pago paypal
processor = PaypalPaymentProcessor()
processor.pay(order, "0372846")

La salida es la siguiente:

210
Processing debit payment type
Verifying security code: 0372846

Processing debit payment type
Verifying security code: 0372846

Processing credit payment type
Verifying security code: 0372846

Processing paypal payment type
Verifying security code: 0372846

Se tiene un error cuando se creo la clase de proceso de pago de paypal. Para paypal no es necesario un código de seguridad, se necesita un correo electrónico, pero al modificar el método de pago de la clase paypal se estaría violando el principio de sustitución de Liskov.

Para solucionarlo, se elimina el argumento del código de seguridad y se coloca al inicializar el método de pago respectivo.

A continuación el código:

from abc import ABC, abstractmethod

class Order:

    def __init__(self):
        self.items = []
        self.quantities = []
        self.prices = []
        self.status = "open"

    def add_item(self, name, quantity, price):
        self.items.append(name)
        self.quantities.append(quantity)
        self.prices.append(price)

    def total_price(self):
        total = 0
        for i in range(len(self.prices)):
            total += self.quantities[i] * self.prices[i]
        return total


# La clase abstracta con el método de pago que ya no maneja el código de seguridad.
class PaymentProcessor(ABC):
    @abstractmethod
    def pay(self,order):
        pass 


# Se define las clases de pago a debito y crédito y se le define el código de seguridad.
class DebitPaymentProcessor(PaymentProcessor):

    def __init__(self,security_code):
        self.security_code = security_code

    def pay(self,order):
        print("Processing debit payment type")
        print(f"Verifying security code: {self.security_code}")
        order.status = "paid"

class CreditPaymentProcessor(PaymentProcessor):

    def __init__(self,security_code):
        self.security_code = security_code

    def pay(self,order):
        print("Processing credit payment type")
        print(f"Verifying security code: {self.security_code}")
        order.status = "paid"

# Para el caso de paypal se define el correo electrónico.
class PaypalPaymentProcessor(PaymentProcessor):

    def __init__(self,email_address):
        self.email_address = email_address


    def pay(self,order):
        print("Processing paypal payment type")
        print(f"Verifying email address: {self.email_address}")
        order.status = "paid"

# Ahora se instancia la clase Order, y se agrega los items a comprar en la orden.

order = Order()
order.add_item("Teclado", 1, 50)
order.add_item("Memoria", 1, 150)
order.add_item("Cable USB", 2, 5)

# Imprime el precio total de la orden
print(order.total_price())


# Se define el método de pago debito

processor = DebitPaymentProcessor("0372846")
processor.pay(order)

# Se define el método de pago TC

processor = CreditPaymentProcessor("0372846")
processor.pay(order)



# Se define el método de pago paypal
processor = PaypalPaymentProcessor("h@h.com")
processor.pay(order)

La salida genera lo siguiente:

210
Processing debit payment type
Verifying security code: 0372846

Processing debit payment type
Verifying security code: 0372846

Processing credit payment type
Verifying security code: 0372846

Processing paypal payment type
Verifying email address: h@h.com

Generación de código QR.

Del artículo sobre el principio de abierto/cerrado se tiene el siguiente código:

from abc import ABC, abstractmethod
import qrcode as qrc
from MyQR import myqr

# Clase abstracta
class GenerateQR(ABC):
    @abstractmethod
    def generate(self,my_qr,text,save_name,**kwargs):
        pass 


# Clase para la librería MyQR que hereda de la clase abstracta.
class GenerateMyQR(GenerateQR):

    def __init__(self, version):
        self.version = version

    def generate(self,my_qr,text,save_name,**kwargs):
        # colorize,save_dir,picture=None
        colorize = kwargs.get("colorize", True)
        save_dir = kwargs.get("save_dir","./")
        picture = kwargs.get("picture",None)
        if not picture: 
            return myqr.run(words=text, version=self.version, save_name=save_name,
                            save_dir=save_dir, colorized=colorize, contrast=1.0, brightness=1.0)

        return myqr.run(words=text, version=my_qr.version, save_name=save_name, picture=picture,
                        save_dir=save_dir, colorized=colorize, contrast=1.0, brightness=1.0)

# Clase de la librería qr_code que hereda de la clase abstracta.
class GenerateQRCode(GenerateQR):

    def __init__(self, version):
        self.version = version

    def generate(self,my_qr,text,save_name,**kwargs):
        # box_size,border,fit,fill,back_color
        box_size = kwargs.get("box_size",10)
        border = kwargs.get("border",5)
        fit = kwargs.get("fit",True)
        fill = kwargs.get("fill","black")
        back_color = kwargs.get("back_color","white")
        self.qr = qrc.QRCode(
            version=self.version,
            box_size=box_size,
            border=border
        )
        self.qr.add_data(text)
        self.qr.make(fit=fit)
        self.img = self.qr.make_image(
            fill=fill, back_color=back_color)
        self.img.save(save_name)

# Se crea la instancia de la clase pasandole la versión del código QR que se quiere usar 
# para la librería MyQR y luego para qr_code
gen_qr = GenerateMyQR(version=1)
gen_qr.generate(my_qr,"Hola mundo","hola1c.png")

gen_qrcode = GenerateQRCode()
gen_qrcode.generate(my_qr,"Hola mundo","hola2c.png")

El cambio que permitirá cumplir con este principio sería el de inicializar las clases con los kwargs en vez de tenerlo en el método de pago.

from abc import ABC, abstractmethod
import qrcode as qrc
from MyQR import myqr

class GenerateQR(ABC):
    @abstractmethod
    def generate(self,text):
        pass 

class GenerateMyQR(GenerateQR):

    def __init__(self,version,**kwargs):
        self.version = version
        self.colorize = kwargs.get("colorize", True)
        self.save_dir = kwargs.get("save_dir","./")
        self.picture = kwargs.get("picture",None)
        self.save_name = kwargs.get("save_name","hola1e.png")

    def generate(self,text):

        if not self.picture: 
            return myqr.run(words=text, version=my_qr.version, save_name=self.save_name,
                            save_dir=self.save_dir, colorized=self.colorize, contrast=1.0, brightness=1.0)

        return myqr.run(words=text, version=self.version, save_name=self.save_name, picture=self.picture,
                        save_dir=self.save_dir, colorized=self.colorize, contrast=1.0, brightness=1.0)


class GenerateQRCode(GenerateQR):

    def __init__(self,version,**kwargs):
        self.version = version
        self.save_name = kwargs.get("save_name","hola2e.png")
        self.box_size = kwargs.get("box_size",10)
        self.border = kwargs.get("border",5)
        self.fit = kwargs.get("fit",True)
        self.fill = kwargs.get("fill","black")
        self.back_color = kwargs.get("back_color","white")

    def generate(self,text,):
        # box_size,border,fit,fill,back_color

        self.qr = qrc.QRCode(
            version=self.version,
            box_size=self.box_size,
            border=self.border
        )
        self.qr.add_data(text)
        self.qr.make(fit=self.fit)
        self.img = self.qr.make_image(
            fill=self.fill, back_color=self.back_color)
        self.img.save(self.save_name)


gen_qr = GenerateMyQR(version=1,{"save_name":"hola2.png"})
gen_qr.generate("Hola mundo")

gen_qr = GenerateQRCode(version=1,{"save_name":"hola2.png"})
gen_qr.generate("Hola mundo")

Referencias:

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Principios S.O.L.I.D. - 2. Principio abierto/cerrado. (OCP - Open/closed principle)

2022-05-07T13:00:00-04:00

Sus principios son:

Single responsability principle - Principio de responsabilidad única.
Open/closed principle - Principio abierto/cerrado.
Liskov substitution principle - Principio de sustitución Liskov.
Interface segregation principle - Principio de segregación de la interfaz.
Dependency inversion principle - Principio de inversión de la dependencia.

A continuación dejo un vídeo de ArjanCodes que explica con código python los principios S.O.L.I.D:

El artículo anterior sobre el principio de responsabilidad única.

El principio abierto/cerrado establece que una entidad de software (clase, módulo, función, etc) debe quedarse abierta para su extensión, pero cerrado para su modificación. Es decir, se debe poner extender el comportamiento de tal entidad pero sin modificar su código fuente.

En otros términos, el código debería estar escrito de tal manera que, a la hora de añadir nuevas funcionalidades, no se deba modificar el código escrito previamente, que pueda estar siendo utilizado por otros usuarios

Del principio de responsabilidad única se tiene el siguiente código, donde se separo la clase Order de la clase PaymentProcess:

# Ahora se tiene una clase que sólo manejará métodos de la orden y se separa el método de pago en otra clase llamada PaymentProcessor


class Order:

    def __init__(self):
        self.items = []
        self.quantities = []
        self.prices = []
        self.status = "open"

    def add_item(self, name, quantity, price):
        self.items.append(name)
        self.quantities.append(quantity)
        self.prices.append(price)

    def total_price(self):
        total = 0
        for i in range(len(self.prices)):
            total += self.quantities[i] * self.prices[i]
        return total


# Clase PaymentProcessor con los métodos: pago con debito y pago a credito. 

class PaymentProcessor:
    def pay_debit(self, order, security_code):
        print("Processing debit payment type")
        print(f"Verifying security code: {security_code}")
        order.status = "paid"

    def pay_credit(self, order, security_code):
        print("Processing credit payment type")
        print(f"Verifying security code: {security_code}")
        order.status = "paid"



# Ahora se instancia la clase Order, y se agrega los items a comprar en la orden.

order = Order()
order.add_item("Teclado", 1, 50)
order.add_item("Memoria", 1, 150)
order.add_item("Cable USB", 2, 5)

# Imprime el precio total de la orden
print(order.total_price())

# Instancia la clase de procesador de pago y se llama al método pagar con debito pasando como argumento la orden y el código de seguridad de la tarjeta.

processor = PaymentProcessor()
processor.pay_debit(order, "0372846")

La salida es la siguiente:

210
Processing debit payment type
Verifying security code: 0372846

Para cumplir con el principio de abierto/cerrado, se usará una clase Abstracta que define el Proceso de pago, y se crean clases por cada tipo de pago que hereda de esa clase abstracta, ahora se separa los métodos del proceso de pago en clases con un sólo método.

from abc import ABC, abstractmethod

# La clase Order se mantiene igual:

class Order:

    def __init__(self):
        self.items = []
        self.quantities = []
        self.prices = []
        self.status = "open"

    def add_item(self, name, quantity, price):
        self.items.append(name)
        self.quantities.append(quantity)
        self.prices.append(price)

    def total_price(self):
        total = 0
        for i in range(len(self.prices)):
            total += self.quantities[i] * self.prices[i]
        return total


# Se crea una clase abstracta del proceso de pago:
class PaymentProcessor(ABC):
    @abstractmethod
    def pay(self,order,security_code):
        pass 


# Se crea la clase de pago con debito que hereda de la clase abstracta
class DebitPaymentProcessor(PaymentProcessor):
    def pay(self,order,security_code):
        print("Processing debit payment type")
        print(f"Verifying security code: {security_code}")
        order.status = "paid"

# Se crea la clase de pago con TC que hereda de la clase abstracta
class CreditPaymentProcessor(PaymentProcessor):
    def pay(self,order,security_code):
        print("Processing credit payment type")
        print(f"Verifying security code: {security_code}")
        order.status = "paid"


# Se crea el método de pago paypal
class PaypalPaymentProcessor(PaymentProcessor):
    def pay(self,order,security_code):
        print("Processing paypal payment type")
        print(f"Verifying security code: {security_code}")
        order.status = "paid"


# Ahora se instancia la clase Order, y se agrega los items a comprar en la orden.

order = Order()
order.add_item("Teclado", 1, 50)
order.add_item("Memoria", 1, 150)
order.add_item("Cable USB", 2, 5)

# Imprime el precio total de la orden
print(order.total_price())


# Se define el método de pago debito

processor = DebitPaymentProcessor()
processor.pay(order, "0372846")

# Se define el método de pago TC

processor = CreditPaymentProcessor()
processor.pay(order, "0372846")



# Se define el método de pago paypal
processor = PaypalPaymentProcessor()
processor.pay(order, "0372846")

La salida es la siguiente:

210
Processing debit payment type
Verifying security code: 0372846

Processing debit payment type
Verifying security code: 0372846

Processing credit payment type
Verifying security code: 0372846

Processing credit payment type
Verifying security code: 0372846

Ahora cuando se requiera un nuevo método de pago simplemente se crea una clase de ese método que hereda de la clase abstracta, ya no se necesita tocar las clases o métodos del resto de los métodos de pago.

Generación de código QR.

Del artículo sobre el principio de responsabilidad única se tiene el siguiente código:

class GenerateQR:

    def __init__(self,version):
        self.version = version

    def myqr(self,my_qr,text,save_name,colorize,save_dir,picture=None):
        if not picture: 
            return myqr.run(words=text, version=my_qr.version, save_name=save_name,
                            save_dir=save_dir, colorized=colorize, contrast=1.0, brightness=1.0)

        return myqr.run(words=text, version=my_qr.version, save_name=save_name, picture=picture,
                        save_dir=save_dir, colorized=colorize, contrast=1.0, brightness=1.0)


    def qrcode(self,my_qr,text,save_name,box_size,border,fit,fill,back_color):
        self.qr = qrc.QRCode(
            version=my_qr.version,
            box_size=box_size,
            border=border
        )
        self.qr.add_data(text)
        self.qr.make(fit=fit)
        self.img = self.qr.make_image(
            fill=fill, back_color=back_color)
        self.img.save(save_name)

gen_qr = GenerateQR(version=1)
# Generar QR con myqr
gen_qr.myqr(my_qr,"hola mundo!","hola.png",True,"./")
# generar qr con qrcode
gen_qr.qrcode(my_qr,"hola mundo2!",'hola2.png',10,5,True,'black','white')

Se tiene una sóla clase con un método para cada librería, pero si se quiere agregar una nueva librería toca modificar la clase y esto rompe el principio. Para evitarlo se crea la clase abstracta y una clase por cada librería que hereda de la clase abstracta, así si se tiene una nueva librería, lo que se hace es crear una clase nueva sin necesitar modificar las clases ya existentes.

from abc import ABC, abstractmethod
import qrcode as qrc
from MyQR import myqr

# Clase abstracta
class GenerateQR(ABC):
    @abstractmethod
    def generate(self,my_qr,text,save_name,**kwargs):
        pass 


# Clase para la librería MyQR que hereda de la clase abstracta.
class GenerateMyQR(GenerateQR):

    def __init__(self, version):
        self.version = version

    def generate(self,my_qr,text,save_name,**kwargs):
        # colorize,save_dir,picture=None
        colorize = kwargs.get("colorize", True)
        save_dir = kwargs.get("save_dir","./")
        picture = kwargs.get("picture",None)
        if not picture: 
            return myqr.run(words=text, version=self.version, save_name=save_name,
                            save_dir=save_dir, colorized=colorize, contrast=1.0, brightness=1.0)

        return myqr.run(words=text, version=my_qr.version, save_name=save_name, picture=picture,
                        save_dir=save_dir, colorized=colorize, contrast=1.0, brightness=1.0)

# Clase de la librería qr_code que hereda de la clase abstracta.
class GenerateQRCode(GenerateQR):

    def __init__(self, version):
        self.version = version

    def generate(self,my_qr,text,save_name,**kwargs):
        # box_size,border,fit,fill,back_color
        box_size = kwargs.get("box_size",10)
        border = kwargs.get("border",5)
        fit = kwargs.get("fit",True)
        fill = kwargs.get("fill","black")
        back_color = kwargs.get("back_color","white")
        self.qr = qrc.QRCode(
            version=self.version,
            box_size=box_size,
            border=border
        )
        self.qr.add_data(text)
        self.qr.make(fit=fit)
        self.img = self.qr.make_image(
            fill=fill, back_color=back_color)
        self.img.save(save_name)

# Se crea la instancia de la clase pasandole la versión del código QR que se quiere usar 
# para la librería MyQR y luego para qr_code
gen_qr = GenerateMyQR(version=1)
gen_qr.generate(my_qr,"Hola mundo","hola1c.png")

gen_qrcode = GenerateQRCode()
gen_qrcode.generate(my_qr,"Hola mundo","hola2c.png")

Como se explico, ya no es necesario tocar el código de las clases de las librerías existentes, y si se tiene una nueva librería sólo se necesita crear una nueva clase heredando de la clase abstracta.

Referencias:

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Principios S.O.L.I.D. - 1. Principio de responsabilidad única (SRP - Single Responsible Principle)

2022-05-07T12:00:00-04:00

Sus principios son:

Single responsability principle - Principio de responsabilidad única.
Open/closed principle - Principio abierto/cerrado.
Liskov substitution principle - Principio de sustitución Liskov.
Interface segregation principle - Principio de segregación de la interfaz.
Dependency inversion principle - Principio de inversión de la dependencia.

A continuación dejo un vídeo de ArjanCodes que explica con código python los principios S.O.L.I.D:

El principio de responsabilidad única estable que cada módulo o clase debe tener una responsabilidad sobre una sola parte de la funcionalidad proporcionada, y esta responsabilidad debe estar encapsulada en su totalidad por la clase. Todos sus servicios deben estar estrechamente alineados con esa responsabilidad.

Voy a usar el ejemplo de código de Arjan y luego muestro un código de un generador de código QR en python y como cumpliendo el principio S.O.L.I.D. se va mejorando su legilibilidad y extensibilidad.

Clase Order que tiene items, quantities, precios y estatus. Con métodos add_item (agregar item), total_price (precio total) y pay (pago).

class Order:

    def __init__(self):

        self.items = []
        self.quantities = []
        self.prices = []
        self.status = "open"

    def add_item(self, name, quantity, price):
        # Agrega un item con la cantidad y precio a la orden.
        self.items.append(name)
        self.quantities.append(quantity)
        self.prices.append(price)

    def total_price(self):
        # Retorna el precio total a pagar.
        total = 0
        for i in range(len(self.prices)):
            total += self.quantities[i] * self.prices[i]
        return total

    def pay(self, payment_type, security_code):
        # Genera el pago según la forma de pago, debito o crédito.
        if payment_type == "debit":
            print("Processing debit payment type")
            print(f"Verifying security code: {security_code}")
            self.status = "paid"
        elif payment_type == "credit":
            print("Processing credit payment type")
            print(f"Verifying security code: {security_code}")
            self.status = "paid"
        else:
            raise Exception(f"Unknown payment type: {payment_type}")


# Se instancia la orden con los items, sus cantidades y precios.
order = Order()
order.add_item("Teclado", 1, 50)
order.add_item("Memoria", 1, 150)
order.add_item("Cable USB", 2, 5)

# Imprime el precio total de la orden
print(order.total_price())

# Se define la forma de pago.
order.pay("debit", "0372846")

La salida que se genera es el monto total a pagar y luego la forma de pago:

210
Processing debit payment type
Verifying security code: 0372846

En la clase order se tiene el inconveniente que si se quiere incorporar otra forma de pago, toca modificar dicha clase que es de la orden, que ha dicha clase no debería importarle el método de pago, simplemente debe generar la Orden.

Para mejorar esto, se va a crear una clase llamada PaymentProcessor (procesador de pago), el cual es el que manejará las diferentes formas de pago.

A continuación el código:

# Ahora se tiene una clase que sólo manejará métodos de la orden y se separa el método de pago en otra clase llamada PaymentProcessor


class Order:

    def __init__(self):
        self.items = []
        self.quantities = []
        self.prices = []
        self.status = "open"

    def add_item(self, name, quantity, price):
        self.items.append(name)
        self.quantities.append(quantity)
        self.prices.append(price)

    def total_price(self):
        total = 0
        for i in range(len(self.prices)):
            total += self.quantities[i] * self.prices[i]
        return total


# Clase PaymentProcessor con los métodos: pago con debito y pago a credito. 

class PaymentProcessor:
    def pay_debit(self, order, security_code):
        print("Processing debit payment type")
        print(f"Verifying security code: {security_code}")
        order.status = "paid"

    def pay_credit(self, order, security_code):
        print("Processing credit payment type")
        print(f"Verifying security code: {security_code}")
        order.status = "paid"



# Ahora se instancia la clase Order, y se agrega los items a comprar en la orden.

order = Order()
order.add_item("Teclado", 1, 50)
order.add_item("Memoria", 1, 150)
order.add_item("Cable USB", 2, 5)

# Imprime el precio total de la orden
print(order.total_price())

# Instancia la clase de procesador de pago y se llama al método pagar con debito pasando como argumento la orden y el código de seguridad de la tarjeta.

processor = PaymentProcessor()
processor.pay_debit(order, "0372846")

Esto devuelve lo mismo que en el código anterior.

210
Processing debit payment type
Verifying security code: 0372846

La ventaja que da esta nueva versión es que si se necesita incorporar un nuevo método de pago, por ejemplo pago con criptomonedas o por paypal, no es necesario tocar la clase Order, si no la clase PaymentProcessor.

Generador de código QR.

Se tiene librerías para generar código QR: MyQR, qrcode y amzqr.

from MyQR import myqr
import qrcode as qrc
from amzqr import amzqr

class GenQR:
    def __init__(self, version, *args, **kwargs):
        self.__version = version
        self.__box_size = kwargs.get("box_size", None)
        self.__border = kwargs.get("border", None)
        self.__fit = kwargs.get("fit", None)
        self.__fill = kwargs.get("fill", None)
        self.__back_color = kwargs.get("back_color", None)
        self.__colorize = kwargs.get("colorize", None)
        self.__picture = kwargs.get("picture", None)
        self.__save_dir = kwargs.get("save_dir", None)

    def generate(self, library="MyQR", text, save_name):
        # Genera código QR y lo guarda en un archivo
        #Se genera el código dependiendo de la librería.
        if library == "MyQR":
            if not self.__picture:
                resp = myqr.run(words=text, version=self.__version, save_name=save_name,
                                save_dir=self.__save_dir, colorized=self.__colorize, contrast=1.0, brightness=1.0, save_format='PNG')
            else:
                resp = myqr.run(words=text, version=self.__version, save_name=save_name, picture=self.__picture,
                                save_dir=self.__save_dir, colorized=self.__colorize, contrast=1.0, brightness=1.0, save_format='PNG')
            return resp

        self.__qr = qrc.QRCode(
            version=self.__version,
            )
        self.__qr.add(text)
        self.__qr.make(fit=self.__fit)
        self.__img = self.__qr.make_image(
            fill=self.__fill, back_color=self.__back_color)
        self.__img.save(save_name)

# Se crea la instancia 

genqr = GenQR(version=1)
genqr.generate(library='MyQR',text='Hola mundo!',save_name='hola.png')

Acá el inconveniente es que se tiene un método que depende de la librería que se use se genera el código QR, pero si toca agregar una nueva librería, toca probablemente modificar los argumentos que se reciben y agregar código para la nueva librería en ese método. La solución es crear métodos para cada librería.

class GenerateQR:

    def __init__(self,version):
        self.version = version

    def myqr(self,my_qr,text,save_name,colorize,save_dir,picture=None):
        if not picture: 
            return myqr.run(words=text, version=my_qr.version, save_name=save_name,
                            save_dir=save_dir, colorized=colorize, contrast=1.0, brightness=1.0)

        return myqr.run(words=text, version=my_qr.version, save_name=save_name, picture=picture,
                        save_dir=save_dir, colorized=colorize, contrast=1.0, brightness=1.0)


    def qrcode(self,my_qr,text,save_name,box_size,border,fit,fill,back_color):
        self.qr = qrc.QRCode(
            version=my_qr.version,
            box_size=box_size,
            border=border
        )
        self.qr.add_data(text)
        self.qr.make(fit=fit)
        self.img = self.qr.make_image(
            fill=fill, back_color=back_color)
        self.img.save(save_name)

gen_qr = GenerateQR(version=1)
# Generar QR con myqr
gen_qr.myqr(my_qr,"hola mundo!","hola.png",True,"./")
# generar qr con qrcode
gen_qr.qrcode(my_qr,"hola mundo2!",'hola2.png',10,5,True,'black','white')

Otra opción es crear una clase para cada librería.

En el siguiente artículo se explicará el principio abierto/cerrado.

Referencias:

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Introducción a anotación y tipos en Python

2022-01-22T12:00:00-04:00

Artículos anteriores se tocó el tema de uso de dataclass, pydantic y orjson y como usar el tipado, en este artículo se explicará las mejores prácticas:

La verificación de tipos aparte de ayudar a entender mejor el código facilita la detección de errores rapidamente y automáticamente usando por ejemplo mypy. La verificación de tipos se incorporó en Python desde la versión 3.5.

Este artículo se basa en el artículo en inglés: Improving Your Python Projects With Type Hints

Sintaxis de tipado

Python soporta anotaciones de tipos para variables básicas soportadas por el lenguaje str, int, float, bool y None. Viene incorporada en la librería typing.

Anotación de variables

Se puede indicar el tipo de una variable al usar los dos puntos ":". Por ejemplo:

from typing import List

nombre: str = 'Pedro'
edad: int = 24
altura_mts: float = 1.7
colegas: List[str] = ['Jane', 'John']

Se define el tipo y el valor que tendrá esa variable.

Anotación en las funciones

En el caso de las funciones se puede colocar anotaciones en las variables de los argumentos, así como en la salida de la función.

from typing import Dict, List
import math 

def calc_area_circulo(radio: float) -> float:
    return math.pi*(radio**2)

def send_email(
    subject: str,
    body: str,
    recipients: List[str],
    cache: Dict[str, str]
) -> bool:

    # .... 
    # Devuelve True o False el envío de un correo

    return True

En la primera función se pasa como argumento el radio de tipo flotante y devuelve el resultado del área del circulo que es flotante también.

EN el siguiente ejemplo se define una función que recibe subject (string), body (string),recipients (lista de string), cache (diccionario que tiene llaves de string y valores de string) y la función devuelve boleano.

Usar tipos especiales

Existe una serie de tipos que complementan a los básicos:

Any:
Literal:
Union
TypeDict
NoReturn
Final

Any

Una variable tipo Any es compatible con todas los tipos básicos.

from typing import Any

resultado: Any = "Procesado"

resultado = 10

estatus: str = "Pendiente"

estatus = resultado

En el primer caso se define la variable resultado tipo Any que se le asigna un string, luego se le asigna un entero, el cual no es problema por que el tipo Any lo soporta. Luego se define la variable estatus de tipo string y asignando un string, luego sin problemas se asigna resultado a la variable estatus; esto tampoco es problema por que resultado es tipo any.

Literal

El tipo literal se usa para indicar que tiene un valor igual a los valores indicados (tipos).

from typing import Literal


GENERO = Literal["hombre", "mujer", "no especificado"]

def crear_usuario(
    nombre: str,
    apellido: str,
    genero: GENERO,
) -> Dict[str, str]:
    return {
        "nombre": nombre,
        "apellido": apellido,
        "genero": genero
    }

crear_usuario("John", "Doe", "hombre")

{'nombre': 'John', 'apellido': 'Doe', 'genero': 'hombre'}

Se define una lista para el genero de tipo literal, y el tipo es uno de los definidos (hombre, mujer, no especificado).

Union

Algunas variables a veces necesitan dos tipos básicos.

from typing import Union


def get_temperatura() -> Union[int, float]:
    return 20.8  # funciona también con 20.

Se define una función que devuelve entero o flotante, esto se logra usando Union.

TypedDict

TypedDict permite definir un tipo de dato diccionario.

from typing import TypedDict, Union


class Card(TypedDict):
    rank: Union[str, int]
    suit: str

# The Card class now has behaviours of both TypedDict and dict classes

# Card can be used to annotate a variable
ace_of_spade: Card = {'rank': 'A', 'suit': '♤'}

# or can be instantiated
ace_of_spade = Card(rank='A', suit='♤')

print(ace_of_spade)

{'rank': 'A', 'suit': '♤'}

NoReturn

NoReturn es similar to void en otros lenguajes de programación, en mi caso antes usaba None cuando una función no devuelve nada.

from typing import NoReturn

def hola1() -> None:
    print("Hola Mundo!")

def hola2() -> NoReturn:
    print("Hola Mundo!")

Se definen dos funciones hola, la primera como None y la segunda como NoReturn, que es como debe definirse una función que no devuelve un valor.

Final

Este tipo de dato se define para no redefinir un valor.

from typing import Final


MIN_NOMBRE_LONG: Final = 2

# mypy reporta error por que se le está asignando un nuevo valor a la
# variable
MIN_NOMBRE_LONG += 1


class Validador(object):
    MIN_NOMBRE_LONG: Final[int] = 4

class UserValidador(Validador):
    # El interprete marca una bandera en esta línea
    MIN_NOMBRE_LONG = 3

Uso de verificadores de tipo

Uno de los más usados verificadores de tipos es mypy. Se puede instalar usando pip:

pip install mypy

Para usarlo simplemente se llama a mypy y se le pasa el archivo a verificar.

El código a validar se muestra a continuación:

#!/usr/bin/env python3

from typing import Literal, Dict


GENERO = Literal["hombre", "mujer", "no especificado"]


def crear_usuario(
    nombre: str,
    apellido: str,
    genero: GENERO,
) -> Dict[str, str]:
    return {
        "nombre": nombre,
        "apellido": apellido,
        "genero": genero
    }


crear_usuario("John", "Doe", "hombre")
crear_usuario("Jane", "Doe", "mujer")
crear_usuario("John", "Doe", "x")

Este código devolverá error al intentar crear un usuario con genero x.

mypy   pruebas_typing.py
content/code/pruebas_typing.py:23: error: Argument 3 to "crear_usuario" has incompatible type "Literal['x']"; expected "Union[Literal['hombre'], Literal['mujer'], Literal['no especificado']]"
Found 1 error in 1 file (checked 1 source file)

Este es el mensaje de error que devuelve al intentar colocar un valor x en el genero.

La notación de tipo y la verificación nos facilita validar que una variable tenga un tipo de datos siempre y no cambie, a mí me paso hace poco que hice una función que devolvía una lista, tiempo después un desarrollador cambio la lista por un diccionario, y la función funcionaba, pero al pasarle mypy.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Introducción a orjson

2022-01-20T20:20:00-04:00

ORJSON es una librería alternativa al soporte de json de Python que permite trabajar con dataclasses, datetimes y numpy.

Características de orjson:

Serializar dataclass.
Serializar objetos datetime, numpy.ndarray y UUID nativamente.
Serializar a byte en vez de string.
Serializar string sin escapado de unicode a ASCII.
Más rápido para serializar y desserializar.
No tiene load() y dump() para leer o escribir de o a un archivo.

Instalación

Para instalar se usará pip:

pip install orjson

Implementación

Primero se importa el módulo:

import orjson
from datetime import datetime
import uuid

Aparte se importa datetime y uuid.

Definir los datos.

dato = {
    "emoji_lagrimas": "😂",
    "emoji_reloj": "⏰",
    "entero": 123,
    "flotante": 10.4,
    "boleano": False,
    "lista": ["element1", "element2"],
    "diccionario": {"key1": "value1", "key2": "value2"},
    "ruso": "Привет",
    "chino": "您好",
    "japones": "こんにちは",
    "datetime": datetime.now(),
    "uuid": uuid.uuid1()
}

print(data)

{'emoji_tears': '😂', 'emoji_clock': '⏰', 'integer': 123, 'float': 10.4, 'boolean': False, 'list': ['element1', 'element2'], 'dict': {'key1': 'value1', 'key2': 'value2'}, 'russian': 'Привет', 'chinese': '您好', 'japanese': 'こんにちは', 'datetime': datetime.datetime(2022, 1, 20, 19, 25, 28, 555227), 'uuid': UUID('40d49edc-7a48-11ec-865d-9078414427c1')}

Se tiene un diccionario con varios tipos de datos y string.

Al imprimir el dato se muestra el objeto UUID y datetime.

Serializar y retornar un binario en vez de un string

json_byte = orjson.dumps(data)

print(json_byte)

b'{"emoji_tears":"\xf0\x9f\x98\x82","emoji_clock":"\xe2\x8f\xb0","integer":123,"float":10.4,"boolean":false,"list":["element1","element2"],"dict":{"key1":"value1","key2":"value2"},"russian":"\xd0\x9f\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82","chinese":"\xe6\x82\xa8\xe5\xa5\xbd","japanese":"\xe3\x81\x93\xe3\x82\x93\xe3\x81\xab\xe3\x81\xa1\xe3\x81\xaf","datetime":"2022-01-20T19:20:56.518677","uuid":"9f8d3b92-7a47-11ec-865d-9078414427c1"}'

Como se muestra en la salida, ahora no se tiene un string si no un binario. El campo datetime y uuid ya no son objetos.

Usar el módulo json

Al intentar convertir a json el diccionario data. Este devolverá error.

Deserializar json_byte

json_data = orjson.loads(json_byte)

print(json_data)

{'emoji_tears': '😂',
 'emoji_clock': '⏰',
 'integer': 123,
 'float': 10.4,
 'boolean': False,
 'list': ['element1', 'element2'],
 'dict': {'key1': 'value1', 'key2': 'value2'},
 'russian': 'Привет',
 'chinese': '您好',
 'japanese': 'こんにちは',
 'datetime': '2022-01-20T19:25:28.555227',
 'uuid': '40d49edc-7a48-11ec-865d-9078414427c1'}

 ```

Al desserializar ya los objetos son string. 


### Argumentos adicionales para serialización 

Se puede pasar los siguientes parámetros:

* default: Un invocable que devuelve un tipo compatible.
* option: Para modificar cómo se serializan los datos a través de una constante entera en orjson.

#### Default

Si se tiene una entrada de dato tipo Decimal.

```python

import decimal
orjson.dumps(decimal.Decimal("3.141592653"))

El intento de convertir un decimal devuelve error:

TypeError: Type is not JSON serializable. decimal.Decimal

Esto se soluciona usando el parámetro Default.

import decimal
import math 
def default(obj):
    if isinstance(obj, decimal.Decimal):
        return str(obj)
    raise TypeError
orjson.dumps(decimal.Decimal(f"{math.pi}"), default=default)

b'"3.141592653589793"'

En este caso se pasa un string que dentro pasa el valor de pi usando la librería math, se pasa como argumento default con una función que evalua si es un decimal, este lo convierte en un string, si no devuelve error.

Al final en vez de devolver error, devuelve un binario con el valor de pi.

Option

Permite definir el método de serialización.

import orjson
import datetime
import numpy as np
data = {
"datetime": datetime.datetime.now(),
"numpy": np.array([[1, 2], [3, 4]])
}
json_byte = orjson.dumps(data, option=orjson.OPT_NAIVE_UTC | orjson.OPT_SERIALIZE_NUMPY)
print(json_byte)

print(orjson.loads(json_byte))

b'{"datetime":"2022-01-20T19:48:45.924867+00:00","numpy":[[1,2],[3,4]]}'

{'datetime': '2022-01-20T19:48:45.924867+00:00', 'numpy': [[1, 2], [3, 4]]}

En este caso se pasa como opcion: * orjson.OPT_NAIVE_UTC: para facilitar la conversión del datetime. * orjson.OPT_SERIALIZE_NUMPY: para facilitar la conversión de numpy.

Detalles:

OPT_APPEND_NEWLINE — Agrega \n .
OPT_INDENT_2 — Identa a 2 espacios la salida .
OPT_NAIVE_UTC — Serializa objetos datetime.datetime objects sin tzinfo como UTC.
OPT_SERIALIZE_NUMPY — Serializa instancias de numpy.ndarray.

Dataclass

ORJSON serializa dataclass como maps, con cada atributo serializado.

import dataclasses, orjson, typing
@dataclasses.dataclass
class Person:
    id: int
    name: str
    status: bool = dataclasses.field(default=True)
@dataclasses.dataclass
class Class:
    id: int
    name: str
    students: typing.List[Person]
data = Class(1, "Class A", [Person(1, "John Doe", False), Person(2, "Mary Sue")])
json_byte = orjson.dumps(data)
print(json_byte)
print(orjson.loads(json_byte))


b'{"id":1,"name":"Class A","students":[{"id":1,"name":"John Doe","status":false},{"id":2,"name":"Mary Sue","status":true}]}'
{'id': 1,
 'name': 'Class A',
 'students': [{'id': 1, 'name': 'John Doe', 'status': False},
  {'id': 2, 'name': 'Mary Sue', 'status': True}]}

En este ejemplo se define la clase Person con tres argumentos id (entero), name (string) y status (boleano), para el estatus se define el valor True por defecto.

También se define la clase Class con id (entero), name (string) y students (que es una lista de personas).

Luego se define la variable data que es una instancia de Class con sus datos.

Luego se serializa y desserializa.

Escritura/Lectura de archivos

Para escribir a un archivo se tiene la variable data del ejemplo anterior.

with open("example.json", "wb") as f:
    f.write(orjson.dumps(data))

Al abrir el archivo se muestra el json:

Para leer el archivo json:

with open("example.json", "rb") as f:
    json_data = orjson.loads(f.read())

print(json_data)

{'id': '1',
 'name': 'Class A',
 'students': [{'id': 1, 'name': 'John Doe', 'status': False},
  {'id': 2, 'name': 'Mary Sue', 'status': True}]}

Para concluir, lo más útil de orjson es que permite o facilita el manejo de objetos datetime, uuid, facilita la conversión de tipo de datos decimal sin que genere error en la conversión como lo hace el módulo json de python.

Referencias:

Choosing a faster JSON library for Python
orjson — A fast json parser for python (artículo en inglés en el que se baso este artículo)
Rendimiento de orjson
Repositorio github

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Validación de datos con Pydantic

2022-01-18T21:03:00-04:00

En el artículo anterior se explico como validar datos usando una clase de python normal, luego usando dataclass, y el beneficio de usarlo.

Ahora se explicará la validación usando pydantic, su documentación la pueden encontrar en el siguiente enlace

Pydantic es una herramienta de validación de datos y gestión de configuración usando notación de tipos en Python. Se puede usar en Python a partir de la versión 3.6.

Para instalar pydantic se usa pip:

pip install pydantic

Pydantic vs Dataclasses vs clase regular de python

Clase regular de python

Como se explico en el artículo anterior, se define los atributos de la clase en este caso producto:

class Producto():
  def __init__(self, titulo, descripcion, precio, publicado, id):
    self.titulo = titulo
    self.descripcion = descripcion
    self.precio = precio
    self.publicado = publicado 
    self.id = id

Python dataclase

from dataclasses import dataclass 
@dataclass 
class Producto:
  titulo: str
  descripcion: str
  precio: int
  publicado: bool
  id: int

Pydantic

Para el caso de pydantic se importa BaseModel de pydantic y Optional de typing.

from pydantic import BaseModel
from typing import Optional 
from random import  randrange 

class Producto(BaseModel):
    titulo: str
    descripcion: str
    precio: int
    publicado: Optional[bool]= True 
    id: Optional[int]= None

A diferencia de dataclass, con pydantic se puede definir si un dato es opcional o no, y su valor por defecto. En el caso del campo publicado es boleano, opcional y valor True por defecto, en el caso del id es un entero opcional, con valor por defecto None.

Se define dato de ejemplo:

dato = {
    "titulo": "Xiaomi Mi 10T",
    "descripcion": "Xiaomi",
    "precio": 300, 
    "id": randrange(0, 100000000) 
}

Se valida el dato con la clase Producto y se imprime el contenido:

producto = Producto(**dato)

print(producto)

titulo='Xiaomi Mi 10T' descripcion='Xiaomi' precio=300 publicado=True id=59872935

Pydantic da más versatilidad en la validación de los datos, gracias a Pydantic se podrá validar las entradas de datos de un endpoint de un API, en próximo artículo se explicará como usando FastAPI.

Este artículo se basa en los siguientes artículos:

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Dataclases en Python

2022-01-16T15:45:00-04:00

Los artículos en que se basa este artículo son:

Data clases en python permiten escribir menos código, y está soportado en python a partir de la versión 3.7.

Clases regulares

Se comenzará con una clase simple en Python llamada perro, con un método init donde se toma los argumentos de la clase como atributos:

Nombre: Tipo string.
Raza: Tipo string.
Edad: Tipo entero.

class Perro:
    nombre: str
    raza: str
    edad: int

    def __init__(self, nombre, raza, edad):
        self.nombre = nombre
        self.raza = raza
        self.edad = edad

Se instancia tres mascotas con la clase Perro:

mascota1 = Perro('RUDY', 'Terrier Australiano', 2)
mascota2 = Perro('TEDDY', 'bichón frisé', 2)
mascota3 = Perro('TEDDY', 'bichón frisé', 2)

Se compara la mascota 2 con al 3:

mascota2 == mascota3

False

A pesar que ambas mascotas tienen los mismos datos en sus atributos, si se hace una comparación devuelve falso.

Una opción es usar un método para la comparación atributo por atributo.

Se imprime el contenido de la mascota2:

print(mascota2)


<__main__.Perro object at 0x7f9c104e7640>

Lo que se muestra es el id en memoria de la instancia de Perro.

Para mostrar el contenido se toma cada atributo:

print(mascota2.nombre,mascota2.raza,mascota2.edad)

TEDDY bichón frisé 2

Data clases

Para poder usar dataclass se tiene que instalar vía pip:

pip install dataclasses

Se tomara la misma clase de Perro, esta vez usando un decorador de dataclass.

Importar dataclass:

from dataclasses import dataclass

Se define la clase Perro con los mismos atributos de la clase anterior:

@dataclass
class Perro:
    nombre: str
    raza: str
    edad: int

Se define la clase y cada atributo se le define el tipo y nada más.

Ahora se crean las mascotas:

mascota1 = Perro('RUDY', 'Terrier Australiano', 2)
mascota2 = Perro('TEDDY', 'bichón frisé', 2)
mascota3 = Perro('TEDDY', 'bichón frisé', 2)

Ahora al comparar la mascota 2 y 3, no devolverá falso:

print(mascota2 == mascota3)

True

A continuación se imprime el contenido de la mascota2:

print(mascota2)

Perro(nombre='TEDDY', raza='bichón frisé', edad=2)

Ahora no devuelve el Id, devuelve la clase perro con los valores del atributo que se le asignaron a la mascota2.

También se puede acceder a los datos de los atributos:

print(mascota2.nombre,mascota2.raza,mascota2.edad)

TEDDY bichón frisé 2

Se puede agregar el método repr a la clase para que de información en un string formateado:

@dataclass
class Perro:
    nombre: str
    raza: str
    edad: int

    def __repr__(self):
        return f"{self.nombre} {self.raza} ({self.edad})"


mascota1 = Perro('RUDY', 'Terrier Australiano', 2)
mascota2 = Perro('TEDDY', 'bichón frisé', 2)
mascota3 = Perro('TEDDY', 'bichón frisé', 2)


print(mascota2)

TEDDY bichón frisé (2)

Aparte de comparar si son iguales, se puede comparar si la mascota1 es mayor que la 2.

print(mascota1  > mascota2)

Esto devuelve error, esta comparación no está soportada:

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
/tmp/ipykernel_603591/468771088.py in <module>
----> 1 mascota1  > mascota2

TypeError: '>' not supported between instances of 'Perro' and 'Perro'

Para poder compararlos es necesario usar el método post_init. El atributo para la comparación será la edad, el código quedará así:

from dataclasses import dataclass, field

@dataclass
class Perro:
    sort_index: int = field(init=False)
    nombre: str
    raza: str
    edad: int

    def __repr__(self):
        return f"{self.sort_index} {self.nombre} {self.raza} ({self.edad})"  

    def __post_init__(self):
      self.sort_index = self.edad

Se muestra los argumentos:

mascota1 = Perro('RUDY', 'Terrier Australiano', 3)
mascota2 = Perro('TEDDY', 'bichón frisé', 2)
print(mascota2)

#2 TEDDY bichón frisé (2)


print(mascota2.sort_index,mascota2.nombre,mascota2.raza,mascota2.edad)

#2 TEDDY bichón frisé 2

Se intenta comparar de nuevo:

print(mascota1 > mascota2)

Devuelve error:

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
/tmp/ipykernel_603591/4142115589.py in <module>
----> 1 mascota1 > mascota2

TypeError: '>' not supported between instances of 'Perro' and 'Perro'

Clases de solo lectura

Se puede crear clases de sólo lectura para evitar que se modifique sus valores iniciales.

Para poder resolver este error se usa el argumento order en el decorador, y se define sólo lectura:

@dataclass(order=True, frozen=True)
class Perro:
    sort_index: int = field(init=False)
    nombre: str
    raza: str
    edad: int

    def __post_init__(self):
      object.__setattr__(self, 'sort_index', self.edad)

mascota1 = Perro('RUDY', 'Terrier Australiano', 3)
mascota2 = Perro('TEDDY', 'bichón frisé', 2)

Ahora se hace la comparación y no devuelve error:

print(mascota1  > mascota2)

True

Se muestra el contenido de la mascota 2:

print(mascota2)


Perro(sort_index=2, nombre='TEDDY', raza='bichón frisé', edad=2)

Si se intenta asignar un valor a la edad de la mascota 2, devolverá error:

mascota2.edad = 4

---------------------------------------------------------------------------
FrozenInstanceError                       Traceback (most recent call last)
/tmp/ipykernel_603591/927787478.py in <module>
----> 1 mascota2.edad = 4

<string> in __setattr__(self, name, value)

FrozenInstanceError: cannot assign to field 'edad'

Como se puede ver las dataclasses puede facilitar en la validación de datos de los atributos de los objetos que se definan. En próximo artículo se verá el módulo pydantic que extiende esta característica de validación de datos.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Crear entorno de desarrollo con pyenv y poetry

2022-01-16T09:49:00-04:00

¿Qué es Pyenv?

Es una herramienta para instalar y manejar multiples versiones de Python. Permite a los desarrolladores ganar acceso rápido a nuevas versiones de Python y mantener su sistema limpio y libre de paquetes innecesarios.

Actualización e instalación de dependencias.

En ubuntu lo primero que se tiene que tener es el sistema actualizado para poder instalar las dependencias necesarias para pyenv:

sudo apt update -y

Instalación de dependencias:

apt install -y make build-essential libssl-dev zlib1g-dev libbz2-dev libreadline-dev libsqlite3-dev wget curl llvm libncurses5-dev libncursesw5-dev xz-utils tk-dev libffi-dev liblzma-dev python-openssl git

Clonar el repositorio de pyenv

Para tener la última versión de pyenv se clona el repositorio git de pyenv:

git clone https://github.com/pyenv/pyenv.git ~/.pyenv

Configure el entorno

Se definen las siguientes variables:

Si se usa bash:

echo 'export PYENV_ROOT="$HOME/.pyenv"' >> ~/.bashrc
echo 'export PATH="$PYENV_ROOT/bin:$PATH"' >> ~/.bashrc
echo -e 'if command -v pyenv 1>/dev/null 2>&1; then\n eval "$(pyenv init -)"\nfi' >> ~/.bashrc

Si se usa zsh:

echo 'export PYENV_ROOT="$HOME/.pyenv"' >> ~/.zshrc
echo 'export PATH="$PYENV_ROOT/bin:$PATH"' >> ~/.zshrc
echo -e 'if command -v pyenv 1>/dev/null 2>&1; then\n eval "$(pyenv init -)"\nfi' >> ~/.zshrc

Activar pyenv

Para activar pyenv se reinicia el shell: 1. Reejecutar el shell:

exec "$SHELL"

O hacer source:

Para bash:

source .bashrc

Para zsh:

source .zshrc

Verificar la instalación

Para verificar la instalación de pyenv se puede ver la versión que se tiene instalada:

❯ pyenv --version
pyenv 2.2.2-10-g943c5f99

Listar las versiones de Python instaladas

Para ver las versiones de Python que se puede instalar se ejecuta:

pyenv install --list

Esto devuelve la lista de versiones de Python:

Available versions:
  2.1.3
  2.2.3
  2.3.7
  2.4.0
  2.5.0
  2.6.0
  2.7.0
  3.0.1
  3.1.0
  3.2.0
  3.3.0
  3.4.0
  3.5.0
  3.6.0
  3.7.0
  3.8.0
  3.9.0
  3.10.0
  3.11.0a3
  activepython-2.7.14
  anaconda3-2021.05
  graalpython-21.3.0
  ironpython-2.7.7
  jython-2.7.2
  mambaforge-4.10.3-10
  micropython-1.17
  miniconda3-4.7.12
  miniforge3-4.10.3-10
  pypy3.8-7.3.7
  pyston-2.3.1
  stackless-3.7.5

Nota: Se muestra un pequeño conjunto de toda la lista.

Para ver la versión de Python que se está usando:

❯ pyenv versions
  system
* 3.9.9 (set by /home/ernesto/.python-version)

En mi equipo estoy usando la versión 3.9.9.

Para instalar una versión

En mi caso voy a cambiar a la versión 3.10

❯ pyenv install 3.10.0
Downloading Python-3.10.0.tar.xz...
-> https://www.python.org/ftp/python/3.10.0/Python-3.10.0.tar.xz
Installing Python-3.10.0...
patching file aclocal.m4
patching file configure
Hunk #5 succeeded at 10537 (offset -15 lines).
python-build: use readline from homebrew
python-build: use zlib from homebrew
Installed Python-3.10.0 to /home/ernesto/.pyenv/versions/3.10.0

Ahora se tiene incorporado la versión 3.10.0 pero no por defecto:

pyenv versions
  system
  3.10.0
* 3.9.9 (set by /home/ernesto/.python-version)

Usar una versión de Python:

pyenv local 3.10.0

Ahora se tiene la 3.10.0:

pyenv versions
  system
* 3.10.0 (set by /home/ernesto/.python-version)
  3.9.9

Al ejecutar Python se tiene esa versión:

❯ python
Python 3.10.0 (default, Dec 26 2021, 15:25:54) [GCC 11.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

Se puede usar global en vez de local, lo que hace es que ahora la versión de python es para todo.

Ya con esto, se puede pasar a la instalación de poetry.

Poetry

Es una herramienta de manejo de instalación de dependencias como construcción y emmpaquetado de Python.

Instalación

Para Linux se ejecuta lo siguiente:

curl -sSL https://raw.githubusercontent.com/python-poetry/poetry/master/get-poetry.py | python -

Esto descarga el script get-poetry y lo ejecuta.

Para validar que está instalado poetry, revisamos la versión:

❯ poetry --version
Poetry version 1.1.12

Ya en este punto se puede usar poetry para crear un entorno virtual de manejo de dependencias de un proyecto.

Para habilitar la completación:

Para bash:

poetry completions bash > /etc/bash_completion.d/poetry.bash-completion

Para zsh:

poetry completions zsh > ~/.zfunc/_poetry

Para oh my zsh:

mkdir $ZSH_CUSTOM/plugins/poetry
poetry completions zsh > $ZSH_CUSTOM/plugins/poetry/_poetry

Usar poetry en un proyecto.

En este caso se usará el proyecto donde se genera el código de los contenidos de este blog.

En el directorio del proyecto, se ejecuta poetry init:

❯ poetry init

This command will guide you through creating your pyproject.toml config.

Package name [ecrespo.github.io]:  
Version [0.1.0]:  
Description []:  
Author [Ernesto Crespo <ecrespo@gmail.com>, n to skip]:  
License []:  
Compatible Python versions [^3.9]:  ^3.10.0 

Would you like to define your main dependencies interactively? (yes/no) [yes] no
Would you like to define your development dependencies interactively? (yes/no) [yes] no
Generated file

[tool.poetry]
name = "ecrespo.github.io"
version = "0.1.0"
description = ""
authors = ["Ernesto Crespo <ecrespo@gmail.com>"]

[tool.poetry.dependencies]
python = "^3.10.0"

[tool.poetry.dev-dependencies]

[build-system]
requires = ["poetry-core>=1.0.0"]
build-backend = "poetry.core.masonry.api"


Do you confirm generation? (yes/no) [yes] yes

Esto genera un archivo pyproject.toml con el siguiente contenido:

[tool.poetry]
name = "ecrespo.github.io"
version = "0.1.0"
description = ""
authors = ["Ernesto Crespo <ecrespo@gmail.com>"]

[tool.poetry.dependencies]
python = "^3.9.0"

[tool.poetry.dev-dependencies]

[build-system]
requires = ["poetry-core>=1.0.0"]
build-backend = "poetry.core.masonry.api"

Para activar el entorno se ejecuta poetry shell:

poetry shell
The virtual environment found in /home/ernesto/proyectos/ecrespo.github.io/.venv seems to be broken.
Recreating virtualenv ecrespo.github.io in /home/ernesto/proyectos/ecrespo.github.io/.venv
Spawning shell within /home/ernesto/proyectos/ecrespo.github.io/.venv

Para el caso de este proyecto, que es el blog, usa como motor de generador de contenido estático pelican. Para instalarlo se ejecuta:

❯ poetry add pelican
Using version ^4.7.1 for pelican

Updating dependencies
Resolving dependencies... (17.7s)

Writing lock file

Package operations: 14 installs, 0 updates, 0 removals

  • Installing colorama (0.4.4)
  • Installing commonmark (0.9.1)
  • Installing markupsafe (2.0.1)
  • Installing pygments (2.10.0)
  • Installing pytz (2021.3)
  • Installing six (1.16.0)
  • Installing blinker (1.4)
  • Installing docutils (0.18.1)
  • Installing feedgenerator (2.0.0)
  • Installing jinja2 (3.0.3)
  • Installing python-dateutil (2.8.2)
  • Installing rich (10.16.1)
  • Installing unidecode (1.3.2)
  • Installing pelican (4.7.1)

Esto hace que el archivo pyproject.toml incorpore el paquete:

[tool.poetry]
name = "ecrespo.github.io"
version = "0.1.0"
description = ""
authors = ["Ernesto Crespo <ecrespo@gmail.com>"]

[tool.poetry.dependencies]
python = "^3.9.0"
pelican = "^4.7.1"

[tool.poetry.dev-dependencies]

[build-system]
requires = ["poetry-core>=1.0.0"]
build-backend = "poetry.core.masonry.api"

Para salirse del entorno se ejecuta exit.

Con esto se tiene poetry funcionando.

Referencias:

Los enlaces que se usaron para hacer el artículo son los siguientes:

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Generar datos falsos con Faker

2021-07-11T20:49:00-04:00

Este artículo toma partes de lo explicado en un artículo del año 2012 Abstracción del motor de Base de Datos con el ORM Sqlalchemy y python, donde se explica el uso de sqlalchemy y sqlite3 con Python.

La documentación completa de faker la pueden encontrar en el enlace. Esta librería permite generar datos falsos como lo son nombre, telefono, trabajo, país entre otros.

Este articulo toma la idea de un artículo de Towards Data Science, Generating Random Data into a Database Using Python.

Instalación de paquetes necesarios e importar librerías.

Se tiene que instalar Faker y sqlalchemy.

pip install Faker sqlalchemy

Explicación del código

Importar librerías Faker y sqlalchemy

from sqlalchemy import *
from faker import Faker

2. Se crea la base de datos sqlite contactos.db y su tabla con los campos necesarios

La tabla se crea con los campos: 
* id: Id del dato insertado tipo entero, clave primaria.
* nombre: Nombre completo, tipo string.
* telefono: Telefono, tipo string.
* pais: País, tipo string. 
* fecha_nacimiento: Fecha de nacimiento, tipo string.  
* trabajo: Trabajo, tipo string.  
* correo: Correo, tipo string. 

```python 

db = create_engine('sqlite:///contactos.db')
#Se deshabilita el verbose de las ejecuciones. 
db.echo = False
# Se define la metadata
metadata = MetaData(db)
# Se crea la tabla contactos con sus campos.
contactos = Table('contactos',metadata,
    Column('id',Integer,primary_key=True),
    Column('nombre', Unicode(100)),
    Column('telefono',String(11)),
    Column('pais',String(50)),
    Column('fecha_nacimiento',String(20)),
    Column('trabajo',String(50)),
    Column('correo',String(50)))

# Se crea la tabla en la base de datos. 
metadata.create_all()

Se generan los datos aleatorios y se insertan en la base de datos.

# A continuación se define la instancia de faker con datos localizados para España, Mexico, Italia y Estados Unidos.
fake = Faker(['it_IT', 'en_US', 'es_ES','es_MX'])

# Se crea la instancia para insertar los datos en la tabla contactos.
u = contactos.insert()

# Se generan 300 datos aleatorios falsos. 
# Nombre, telefono, id, país, fecha de nacimiento, trabajo y correo.
for i in range(300):
    u.execute(nombre=fake.name(),
              telefono=fake.phone_number(),
              id=i,
             pais=fake.country(),
             fecha_nacimiento=fake.date_of_birth(),
             trabajo=fake.job(),
             correo=fake.ascii_free_email())

Consultar la base de datos.

Luego de terminar de insertar los datos, se puede realizar un select para listarlos:

# Se crea el select para contactos y se ejecuta.
s = contactos.select()
rs = s.execute()
# Se recorre las filas
for fila in rs:
    print (fila)

La salida sería algo así:

(0, 'Ing. Luz Cantú', '(592)035-0771', 'Irlanda', '1941-07-16', 'Cartographer', 'eloy53@yahoo.com')
(1, 'Alexander Rogers', '+39 2741 04213055', 'China', '1981-01-07', 'Lobbyist', 'avilesdelia@gmail.com')
(2, 'William Mata', '+98(4)6812081105', 'Nueva Zelandia', '2014-07-27', 'Administrator, charities/voluntary organisations', 'bustoszeferino@yahoo.com')
(3, 'Victor Manuel de Riquelme', '+34868799533', 'United States of America', '1920-08-07', 'Therapist, speech and language', 'alarconvictor@hotmail.com')
(4, 'Desiderio Tudela Hurtado', '+39 826 2913339', 'República Democrática Popular Lao', '2003-02-25', 'Dance movement psychotherapist', 'teodorosantacruz@gmail.com')
(5, 'Héctor Figueroa', '+39 430 26536170', 'Saint Helena', '1949-09-30', 'Historic buildings inspector/conservation officer', 'gabrielabenavides@hotmail.com')
(6, 'Alison Fernandez', '060.424.1361x63279', 'Nicaragua', '1923-06-10', 'Operations geologist', 'sergiomesa@yahoo.com')
(7, 'Kike Alberdi Solé', '1-944-411-9964x56873', 'México', '2011-10-23', 'Automotive engineer', 'nmontanari@hotmail.it')
(8, 'Giuliano Proietti', '(221)607-8605', 'Vietman', '2002-10-31', 'Horticulturist, amenity', 'barbarasotelo@gmail.com')
(9, 'Jessica Lynch', '(499)715-7365x432', 'Kiribati', '1954-04-25', 'Further education lecturer', 'ponsrolando@gmail.com')
(10, 'Mtro. Inés Santillán', '1-940-806-7100x5576', 'Mongolia', '1989-09-11', 'Occupational psychologist', 'stephanie03@gmail.com')
(11, 'Melania Granatelli', '+34 680 838 256', 'India', '1991-05-03', 'Advertising account planner', 'eserrano@hotmail.com')
(12, 'Amanda Ariasso', '+34744 273 170', 'Isole Vergini Britanniche', '1926-06-12', 'Clinical scientist, histocompatibility and immunogenetics', 'thompsongeorge@hotmail.com')
...
(299, 'Verónica Palomo Pavón', '+39 3517 3948391', 'Bahamas', '1949-04-13', 'Product designer', 'felipeolivo@yahoo.com')

Se puede ver también vía sqlitebrowser.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Instalación de Airflow en Ubuntu

2021-05-02T12:01:00-04:00

Este proceso de instalación se hace desde Ubuntu usando anaconda.

Este artículo se basa de un artículo en inglés Apache Airflow Installation on Ubuntu y la página oficial de Airflow.

Preparación

1. Actualización de pip:

Lo primero que se hará es actualizar pip:

pip install --upgrade pip

2. Instalación de la base de datos postgreSQL:

El proceso de instalación es a lo Debian:

sudo apt-get install postgresql postgresql-contrib

3. Creación de una base de datos para Airflow

Creación de un usuario airflow:

sudo adduser airflow
Añadiendo el usuario `airflow' ...
Añadiendo el nuevo grupo `airflow' (1004) ...
Añadiendo el nuevo usuario `airflow' (1003) con grupo `airflow' ...
Creando el directorio personal `/home/airflow' ...
Copiando los ficheros desde `/etc/skel' ...
Nueva contraseña: 
Vuelva a escribir la nueva contraseña: 
passwd: contraseña actualizada correctamente
Cambiando la información de usuario para airflow
Introduzca el nuevo valor, o presione INTRO para el predeterminado
    Nombre completo []: 
    Número de habitación []: 
    Teléfono del trabajo []: 
    Teléfono de casa []: 
    Otro []: 
¿Es correcta la información? [S/n] s

Agregar el usuario airflow al grupo

sudo usermod -aG sudo airflow

Se cambia al shell del usuario airflow

su - airflow

Se cambia al usuario postgres para crear un role para airflow

sudo -u postgres psql

Salida es:

[sudo] contraseña para airflow: 
Lo sentimos, vuelva a intentarlo.
[sudo] contraseña para airflow: 
psql (12.6 (Ubuntu 12.6-0ubuntu0.20.04.1))
Type "help" for help.

postgres=#

Crear el usuario para airflow:

CREATE USER airflow PASSWORD 'a1rfl0w';
CREATE ROLE
CREATE DATABASE airflow;
GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA public TO airflow

Verificar que la base de datos existe:

psql -d airflow -h localhost -U airflow
psql (12.3, server 12.6 (Ubuntu 12.6-0ubuntu0.20.04.1))
SSL connection (protocol: TLSv1.3, cipher: TLS_AES_256_GCM_SHA384, bits: 256, compression: off)
Type "help" for help.

airflow=> \conninfo
You are connected to database "airflow" as user "airflow" on host "localhost" (address "127.0.0.1") at port "5432".
SSL connection (protocol: TLSv1.3, cipher: TLS_AES_256_GCM_SHA384, bits: 256, compression: off)

Configurar pg_hba.conf:

sudo vim /etc/postgresql/12/main/pg_hba.conf

Cambiar a 0.0.0.0/0 y el método IPv4 a trust:

# IPv4 local connections:
host all all 0.0.0.0/0 trust

Reiniciar postgresql:

sudo service postgresql restart

Instalación de airflow

Configurar el home de airflow:

export AIRFLOW_HOME=~/airflow

Instalar airflow con varios componentes:

pip install "apache-airflow[async,postgres,google,celery,rabbitmq,docker,amazon]"

Iniciar base de datos de airflow:

airflow initdb

El comando generará un archivo airflow.cfg en el directorio home del usuario airflow.

Configurar airflow.cfg

Agregar el executor en este caso se usará celery:

executor = CeleryExecutor

Se crean las tablas en la base de datos al configurar airflow.cfg:

sql_alchemy_conn = postgresql+psycopg2://airflow@localhost:5432/airflow

Salvar y se ejecuta airflow initdb.

Deshabilitando ejemplos:

Se edita airflow.cfg:

load_examples = False

Iniciar el servidor web de Airflow:

airflow webserver

Para acceder a la aplicación web se abre https://localhost:8080 .

Se muestra una captura de pantalla del servidor:

En próximos artículos se mostrará tutoriales sobre airflow.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Desarrollar código limpio de Python

2020-11-15T12:01:00-04:00

En artículo anterior (Herramientas de Python para desarrollar código seguro y de calidad) se tocó el tema de herramientas que facilitan a cumplir el PEP8 de Python, mejoras de seguridad del código y formateo del mismo, en este caso se usa circle-ci para las evaluaciones.

En este artículo se usará la evaluación antes de subir código a un repositorio de git. El artículo se basa en los siguientes artículos:

Se volvera a tocar las herramientas que se explicaron en el artículo anterior.

El código que se usará para evaluar es el siguiente (no cumple con las comprobaciones):

import numpy as np
from scipy import signal as sp
import matplotlib.pylab as plt
import scipy.signal as signal
import scipy.stats as stats
import streamlit as st


def u(amplitud, t):
    """Función escalón unitario

    Args:
        amplitud (int): Amplitud del escalon
        t (list): Lista de tiempo

    Returns:
        list: Lista de valores
    """
    return amplitud*np.piecewise(t, [t < 0.0, t >= 0.0], [0, 1])


def OndaCuadrada(amplitud, t, fs=1):
    """Función  de Onda Cuadrada

    Args:
        amplitud (int): Amplitud de la segnal
        t (list): Lista de valores de tiempo
        fs (int, optional): Frecuencia.. Defaults to 1.

    Returns:
        list: Lista de valores
    """
    return ((sp.square(2 * fs*t)) * (amplitud / 2.0)) + (amplitud / 2.0)


def segnal_triangular(amplitud, simetria, t, fs=1):
    """Señal triangular 

    Args:
        amplitud (int): Amplitud de la señal
        simetria (float): simetria de la señal
        t (list): Lista de valores que definen el tiempo.
        fs (int, optional): Frecuencia de la señal. Defaults to 1.

    Returns:
        list: Lista de valores de la señal
    """
    return amplitud*(signal.sawtooth(2 * np.pi * fs * t, simetria))


def seno(amplitud, t, fs=1):
    """ Onda Seno

    Args:
        amplitud (int): Amplitud de la señal
        t (list): Lista de valores de tiempo
        fs (int, optional): Frecuencia de la señal. Defaults to 1.

    Returns:
        list: Lista de valores de la señal de seno
    """
    return amplitud*np.sin(fs*t)


def coseno(amplitud, t, fs=1):
    """Señal de coseno

    Args:
        amplitud (int): Amplitud de la señal
        t (list): lista de valores para generar la señal
        fs (int, optional): Frecuencia de la señal. Defaults to 1.

    Returns:
        list: Lista de valores de la señal
    """
    return amplitud*np.cos(fs*t)


def tiempo(lim_inf, lim_sup, n):
    """Lista de valores que definen el tiempo de la señal

    Args:
        lim_inf (int): Límite inferior del tiempo 
        lim_sup (int): Límite superior del tiempo
        n (int): Cantidad de valores a generar del tiempo

    Returns:
        list: Lista de valores del tiemmpo
    """
    return np.linspace(lim_inf, lim_sup, n)


def plot_signal(xi, xf, yi, yf, t, titulo, etiqueta, values):
    """Generación de la gráfica de la señal.

    Args:
        xi (int): x inicial
        xf (int): x final
        yi (int): y inicial
        yf (int): y final
        t (list): lista de valores de tiempo
        titulo (str): Título de la gráfica
        etiqueta (str): Etiqueta de la señal.
        values (list): Valores de la señal 
    """
    plot(t, values, 'k', label=etiqueta, lw=2)
    xlim(xi, xf)


def main():
    # Definir título
    st.title("Generación de gráficas de señales")
    st.sidebar.header("Entradas:")
    segnales = ["Escalon Unitario", "Onda Cuadrada",
                "Onda triangular", "Seno", "Coseno"]

    resp = st.sidebar.selectbox("Tipo de señal", segnales)

    st.sidebar.header("Definición del tiempo:")
    st.sidebar.subheader("Rango")
    # SelectBox
    t0 = int(st.sidebar.selectbox(
        "", range(0, 10)
    ))
    ti = 0
    tf = t0
    n = 10000
    t = tiempo(ti, tf, n)
    st.sidebar.subheader("Amplitud de la señal")
    amplitud = int(st.sidebar.selectbox(
        "", range(1, 10)
    ))

    # numpy.ndarray
    if resp == "Escalon Unitario":
        ti = -tf
        resultado = u(amplitud, t)
    elif resp == "Onda Cuadrada":
        st.sidebar.subheader("Frecuencia de la señal")
        fs = int(st.sidebar.selectbox(
            "", range(1, 11)
        ))
        resultado = OndaCuadrada(amplitud, t, fs)
    elif resp == "Onda triangular":
        simetria = 0.5
        st.sidebar.subheader("Frecuencia de la señal")
        fs = int(st.sidebar.selectbox(
            "", range(1, 11)
        ))
        resultado = segnal_triangular(amplitud, simetria, t, fs)
    elif resp == "Seno":
        st.sidebar.subheader("Frecuencia de la señal")
        fs = int(st.sidebar.selectbox(
            "", range(1, 11)
        ))
        resultado = seno(amplitud, t, fs)
    elif resp == "Coseno":
        st.sidebar.subheader("Frecuencia de la señal")
        fs = int(st.sidebar.selectbox(
            "", range(1, 11)
        ))
        resultado = coseno(amplitud, t, fs)
    else:
        resultado = 0
        st.error("Error")

    fig = plt.figure()
    ax = fig.add_subplot(111)
    st.header(f"Gráfica de {resp}")
    ax.plot(t, resultado)
    ax.set_xlim(ti, tf)
    ax.set_xlabel("Tiempo")
    ax.set_ylabel("f(t)")
    ax.set_ylim(2*amplitud*-1, 2*amplitud)
    st.pyplot(fig)


if __name__ == "__main__":
    main()

Su archivo de requerimientos es el siguiente:

streamlit==0.70.0
scipy==1.5.4
numpy==1.19.3
matplotlib==3.3.3

Su estructura inicial de archivos es la siguiente (incluyendo archivos ocultos):

signals_fft_streamlit
├── .git
│   ├── branches
│   ├── config
│   ├── description
│   ├── HEAD
│   ├── hooks
│   │   ├── applypatch-msg.sample
│   │   ├── commit-msg.sample
│   │   ├── fsmonitor-watchman.sample
│   │   ├── post-update.sample
│   │   ├── pre-applypatch.sample
│   │   ├── pre-commit.sample
│   │   ├── pre-merge-commit.sample
│   │   ├── prepare-commit-msg.sample
│   │   ├── pre-push.sample
│   │   ├── pre-rebase.sample
│   │   ├── pre-receive.sample
│   │   └── update.sample
│   ├── index
│   ├── info
│   │   └── exclude
│   ├── logs
│   │   ├── HEAD
│   │   └── refs
│   │       ├── heads
│   │       │   └── main
│   │       └── remotes
│   │           └── origin
│   │               └── HEAD
│   ├── objects
│   │   ├── info
│   │   └── pack
│   │       ├── pack-a6d9863d11286fbea66f5aafa93a9dbafaf3f4fc.idx
│   │       └── pack-a6d9863d11286fbea66f5aafa93a9dbafaf3f4fc.pack
│   ├── packed-refs
│   └── refs
│       ├── heads
│       │   └── main
│       ├── remotes
│       │   └── origin
│       │       └── HEAD
│       └── tags
├── .gitignore
├── LICENSE
├── README.md
├── requirements.txt
└── src
    └── app.py

Dentro de los hooks se puede definir ejecuciones antes de hacer commit usando pre-commit, que se verá más adelante.

Validación de código

Linters

Los linters son herramientas de programación que realizan la comprobación de cualquier lenguaje de programamción.

Flake8

Herramienta que permite comprobar que el código cumple con el PEP-8 de Python.

Se puede instalar vía pip:

pip install flake8

Se ejecuta flake8 al archivo app.py:

python -m flake8 src/app.py
src/app.py:5:1: F401 'scipy.stats' imported but unused
src/app.py:22:6: N802 function name 'OndaCuadrada' should be lowercase
src/app.py:37:20: W291 trailing whitespace
src/app.py:83:50: W291 trailing whitespace
src/app.py:104:43: W291 trailing whitespace
src/app.py:106:5: F821 undefined name 'plot'
src/app.py:107:5: F821 undefined name 'xlim'

La salida del comando muestra las líneas de código donde hay error, el tipo de error y una descripción del mismo.

pep8-naming

Adicional a flake se puede usar pep8-naming para cumplir con las normas de definición de nombres de PEP8.

Para instalarlo se usa pip:

pip install pep8-naming

Se ejecuta el mismo comando de flake8, el mensaje de error es :

src/app.py:22:6: N802 function name 'OndaCuadrada' should be lowercase

Que ya apareció en la ejecución anterior.

pycodestyle

Es otra herramienta de validación del PEP-8. png

Se instala:

pip install pycodestyle

Se ejecuta:

pycodestyle src/app.py

En este caso como ya se arreglaron los mensajes de error de flake8, no devuelve mensajes.

pylint

Se instala:

pip install pylint

Se ejecuta:

pylint src/app.py

Formateador de código

Permite reformatear el código para que cumpla una serie de estándar.

isort

Reordena los imports de la siguiente forma:

Librería estándar
Librerías de terceros
Librerías local

Se instala:

pip install isort

Se usa de la siguiente forma:

isort src/app.py 
Fixing /home/ernesto/proyectos/signals_fft_streamlit/src/app.py

Anteriormente las importaciones estaban así:

import numpy as np
from scipy import signal as sp
import matplotlib.pylab as plt
import scipy.signal as signal
import scipy.stats as stats
import streamlit as st

Ahora:

import matplotlib.pylab as plt
import numpy as np
import scipy.signal as signal
import streamlit as st
from scipy import signal as sp

Para solo chequear el orden de la importación sin realizar el cambio se puede ejecutar:

python -m isort src/app.py --check-only

Para ver los cambios sin aplicarlos se puede usar:

python -m isort src/app.py --diff

Black

Formateador de código que se usa para reformatear código basado en Black code style que es muy cercano al PEP-8.

Para instalarlo:

pip install black

Para chequear el código sin modificarlo:

python -m black src/app.py --check  
would reformat src/app.py
Oh no! 💥 💔 💥
1 file would be reformatted.

Para ver las diferencias sin modificarlo (sólo se muestra una parte del código):

--- src/app.py  2020-11-15 01:20:29.525556 +0000
+++ src/app.py  2020-11-15 01:29:54.278851 +0000
@@ -13,11 +13,11 @@
         t (list): Lista de tiempo

     Returns:
         list: Lista de valores
     """
-    return amplitud*np.piecewise(t, [t < 0.0, t >= 0.0], [0, 1])
+    return amplitud * np.piecewise(t, [t < 0.0, t >= 0.0], [0, 1])

Para realizar las modificaciones:

python -m black src/app.py       
reformatted src/app.py
All done! ✨ 🍰 ✨
1 file reformatted.

El código cambio a (se muestra una parte del código):

def u(amplitud, t):
    """Función escalón unitario

    Args:
        amplitud (int): Amplitud del escalon
        t (list): Lista de tiempo

    Returns:
        list: Lista de valores
    """
    return amplitud * np.piecewise(t, [t < 0.0, t >= 0.0], [0, 1])

Otras herramientas parecidas son YAPF y autopep8

Escaneo de vulnerabilidades de seguridad

Hay herramientas que evaluan las vulnerabilidades de seguridad del código y de sus dependencias.

Bandit

Bandit Es una herramienta diseñada para encontrar problemas de seguridad en código Python.

Se instala:

pip install bandit

Se ejecuta de la siguiente forma:

bandit -r src/app.py 
[main]  INFO    profile include tests: None
[main]  INFO    profile exclude tests: None
[main]  INFO    cli include tests: None
[main]  INFO    cli exclude tests: None
[main]  INFO    running on Python 3.8.3
Run started:2020-11-15 01:44:06.048642

Test results:
    No issues identified.

Code scanned:
    Total lines of code: 119
    Total lines skipped (#nosec): 0

Run metrics:
    Total issues (by severity):
        Undefined: 0.0
        Low: 0.0
        Medium: 0.0
        High: 0.0
    Total issues (by confidence):
        Undefined: 0.0
        Low: 0.0
        Medium: 0.0
        High: 0.0
Files skipped (0):

Por lo que se pueded ver, no tiene problemas de seguridad el código.

Safety

Safety es una herramienta que verifica problemas de seguridad de las dependencias de la aplicación.

Se instala:

pip install safety

Se ejecuta de la siguiente forma:

safety check
+==============================================================================+
|                                                                              |
|                               /$$$$$$            /$$                         |
|                              /$$__  $$          | $$                         |
|           /$$$$$$$  /$$$$$$ | $$  \__//$$$$$$  /$$$$$$   /$$   /$$           |
|          /$$_____/ |____  $$| $$$$   /$$__  $$|_  $$_/  | $$  | $$           |
|         |  $$$$$$   /$$$$$$$| $$_/  | $$$$$$$$  | $$    | $$  | $$           |
|          \____  $$ /$$__  $$| $$    | $$_____/  | $$ /$$| $$  | $$           |
|          /$$$$$$$/|  $$$$$$$| $$    |  $$$$$$$  |  $$$$/|  $$$$$$$           |
|         |_______/  \_______/|__/     \_______/   \___/   \____  $$           |
|                                                          /$$  | $$           |
|                                                         |  $$$$$$/           |
|  by pyup.io                                              \______/            |
|                                                                              |
+==============================================================================+
| REPORT                                                                       |
| checked 136 packages, using default DB                                       |
+==============================================================================+
| No known security vulnerabilities found.                                     |
+==============================================================================+

Para verificar solamente la lista de paquetes que tiene requirements.txt se ejecuta:

safety check -r requirements.txt
+==============================================================================+
|                                                                              |
|                               /$$$$$$            /$$                         |
|                              /$$__  $$          | $$                         |
|           /$$$$$$$  /$$$$$$ | $$  \__//$$$$$$  /$$$$$$   /$$   /$$           |
|          /$$_____/ |____  $$| $$$$   /$$__  $$|_  $$_/  | $$  | $$           |
|         |  $$$$$$   /$$$$$$$| $$_/  | $$$$$$$$  | $$    | $$  | $$           |
|          \____  $$ /$$__  $$| $$    | $$_____/  | $$ /$$| $$  | $$           |
|          /$$$$$$$/|  $$$$$$$| $$    |  $$$$$$$  |  $$$$/|  $$$$$$$           |
|         |_______/  \_______/|__/     \_______/   \___/   \____  $$           |
|                                                          /$$  | $$           |
|                                                         |  $$$$$$/           |
|  by pyup.io                                              \______/            |
|                                                                              |
+==============================================================================+
| REPORT                                                                       |
| checked 4 packages, using default DB                                         |
+==============================================================================+
| No known security vulnerabilities found.                                     |
+==============================================================================+

Verificación de tipado estático

Cómo a partir de Python 3.7 , python soporta a manera de documentación la definición de tipos de la salida de una función y sus argumentos, se tiene ahora herramientas que verifica el tipado estático.

Mypy

Mypy es un verificador de tipo estático opcional para Python que tiene como objetivo combinar los beneficios de la escritura dinámica (o "duck") y la escritura estática.

Se instala:

pip install mypy

Se usa:

mypy src/app.py 
src/app.py:1: error: No library stub file for module 'matplotlib.pylab'
src/app.py:1: note: (Stub files are from https://github.com/python/typeshed)
src/app.py:1: error: No library stub file for module 'matplotlib'
src/app.py:2: error: No library stub file for module 'numpy'
src/app.py:3: error: No library stub file for module 'scipy.signal'
src/app.py:3: error: No library stub file for module 'scipy'
src/app.py:4: error: Cannot find module named 'streamlit'
src/app.py:4: note: See https://mypy.readthedocs.io/en/latest/running_mypy.html#missing-imports

Para ignorar estos errores se usa # type: ignore, como se muestra a continuación:

import matplotlib.pylab as plt  # type: ignore
import numpy as np  # type: ignore
import scipy.signal as signal  # type: ignore
import streamlit as st  # type: ignore
from scipy import signal  # type: ignore

Se vuelve a ejecutar y ya no aparecen esos errores iniciales.

Un ejemplo de tipado estático se muestra a continuación:

def u(amplitud: int, t: np.ndarray) -> np.ndarray:
    """Función escalón unitario

    Args:
        amplitud (int): Amplitud del escalon
        t (np.ndarray): Lista de tiempo

    Returns:
        np.ndarray: Lista de valores
    """
    return amplitud * np.piecewise(t, [t < 0.0, t >= 0.0], [0, 1])

def onda_cuadrada(amplitud: int, t: np.ndarray, fs: int = 1) ->np.ndarray:
    """Función  de Onda Cuadrada

    Args:
        amplitud (int): Amplitud de la segnal
        t (list): Lista de valores de tiempo
        fs (int, optional): Frecuencia.. Defaults to 1.

    Returns:
        list: Lista de valores
    """
    return ((sp.square(2 * fs * t)) * (amplitud / 2.0)) + (amplitud / 2.0)

Otra forma de ignorar todos los errores es la siguiente:

#!/usr/bin/env python 
#-*- coding: utf-8 -*-
# mypy: ignore-errors

Validación de la documentación

pydocstyle

pydocstyleEs una herramienta que permite validar el formato de la documentación.

Se instala:

pip install pydocstyle

Se utiliza:

pydocstyle src/app.py 
src/app.py:1 at module level:
        D100: Missing docstring in public module
src/app.py:9 in public function `u`:
        D400: First line should end with a period (not 'o')
src/app.py:22 in public function `onda_cuadrada`:
        D400: First line should end with a period (not 'a')
src/app.py:36 in public function `segnal_triangular`:
        D205: 1 blank line required between summary line and description (found 0)
src/app.py:36 in public function `segnal_triangular`:
        D400: First line should end with a period (not 'r')
src/app.py:50 in public function `seno`:
        D400: First line should end with a period (not 'o')
src/app.py:64 in public function `coseno`:
        D400: First line should end with a period (not 'o')
src/app.py:78 in public function `tiempo`:
        D205: 1 blank line required between summary line and description (found 0)
src/app.py:78 in public function `tiempo`:
        D400: First line should end with a period (not 'l')
src/app.py:90 in public function `main`:
        D103: Missing docstring in public function

Complejidad Ciclomática, número de líneas del código

Existen herramientas para validar la complejidad ciclomática, como lo son:

En este caso se probará con wily

Wily

Wily es una aplicación para trazar la complejidad de código Python y aplicaciones.

Se instala:

pip install wily

Se necesita indexar el proyecto ejecutando:

wily build src/
Found 1 revisions from 'git' archiver in '/home/ernesto/proyectos/signals_fft_streamlit'.
Running operators - maintainability,raw,cyclomatic,halstead
Processing |################################| 4/4
Completed building wily history, run `wily report <file>` or `wily index` to see more.

Para generar el reporte de app.py se ejecuta:

wily report src/app.py 
Using default metrics ['maintainability.mi', 'raw.loc', 'cyclomatic.complexity', 'halstead.h1']
-----------History for ['maintainability.mi', 'raw.loc', 'cyclomatic.complexity', 'halstead.h1']------------
╒════════════╤════════════════╤════════════╤═════════════════════════╤═════════════════╤═════════════════════════╤═══════════════════╕
│ Revision   │ Author         │ Date       │ Maintainability Index   │ Lines of Code   │ Cyclomatic Complexity   │ Unique Operands   │
╞════════════╪════════════════╪════════════╪═════════════════════════╪═════════════════╪═════════════════════════╪═══════════════════╡
│ f2679c6    │ Ernesto Crespo │ 2020-11-14 │ 68.1377 (0)             │ 153 (0)         │ 12 (0)                  │ 7 (0)             │
╘════════════╧════════════════╧════════════╧═════════════════════════╧═════════════════╧═════════════════════════╧═══════════════════╛

En el reporte se puede pasar metricas específicas:

wily report src/app.py loc sloc comments --message
-----------History for ('loc', 'sloc', 'comments')------------
╒════════════╤════════════════╤════════════════╤════════════╤═════════════════╤═══════════════════╤═══════════════════════╕
│ Revision   │ Message        │ Author         │ Date       │ Lines of Code   │ S Lines of Code   │ Multi-line comments   │
╞════════════╪════════════════╪════════════════╪════════════╪═════════════════╪═══════════════════╪═══════════════════════╡
│ f2679c6    │ Initial commit │ Ernesto Crespo │ 2020-11-14 │ 153 (0)         │ 71 (0)            │ 8 (0)                 │
╘════════════╧════════════════╧════════════════╧════════════╧═════════════════╧═══════════════════╧═══════════════════════╛

Complejidad Ciclomática

Según publicación de The Software Engineering Institute at Carnegie Mellon defines donde define los rangos de complejidad: * 1-10: Bajo riesgo, programa simple. * 11-20: Riesgo moderado, programa más complejo. * 21-50: Riesgo alto, programa muy dificil. * >50: Riesgo muy alto, programa inestable.

Indice de mantenibilidad

Para este caso: * <65: Fuertemente mantenible. * 65-85: Moderadamente mantenible. * >85: Fácil de mantener.

En el caso de app.py tiene un riesgo moderado y es moderadamente mantenible.

Para más información sobre la complejidad ciclomática pueden revisar Simplify your Python Code: Automating Code Complexity Analysis with Wily o el pdf de The Software Engineering Institute at Carnegie Mellon defines.

Juntando todo con pre-commit

pre-commit

Pre-commit es un framework para manejar git hooks.

Para instalarlo:

pip install pre-commit

Para inicializar pre-commit se ejecuta:

$pre-commit install
pre-commit installed at .git/hooks/pre-commit

Verificación de Yaml

Para formatear yaml se puede usar la siguiente configuración:

  - repo: https://github.com/pre-commit/pre-commit-hooks
    rev: v2.4.0
    hooks:
      - id: trailing-whitespace
      - id: end-of-file-fixer
      - id: check-added-large-files
      - id: check-yaml
        exclude: (template|ci).*\.(json|yml|yaml)$

isort

Para validar con isort se tiene lo siguiente:

  - repo: https://github.com/asottile/seed-isort-config
    rev: v1.9.3
    hooks:
      - id: seed-isort-config
  - repo: https://github.com/pre-commit/mirrors-isort
    rev: v4.3.21
    hooks:
      - id: isort

Para Wily

  - repo: local
    hooks:
      - id: wily
        name: wily
        entry: wily diff
        verbose: true
        language: python
        additional_dependencies: [wily]

Safety

  - repo: git://github.com/Lucas-C/pre-commit-hooks-safety
    rev: v1.1.3
    hooks:
      - id: python-safety-dependencies-check

Black

  - repo: https://github.com/ambv/black
    rev: stable
    hooks:
      - id: black
        language_version: python3.8

Pylint

  - repo: https://github.com/PyCQA/pylint
    rev: "pylint-2.6.0"
    hooks:
      - id: pylint
        args: ["--disable=similarities"]

Mypy

  - repo: https://github.com/pre-commit/mirrors-mypy
    rev: v0.790
    hooks:
      - id: mypy
        exclude: ^testing/resources/

Pyupgrade

  - repo: https://github.com/asottile/pyupgrade
    rev: v2.7.3
    hooks:
      - id: pyupgrade
        args: [--py36-plus]

Flake8

  - repo: https://gitlab.com/pycqa/flake8
    rev: 3.8.4
    hooks:
      - id: flake8
        additional_dependencies: [flake8-typing-imports==1.10.0]

Autopep8

  - repo: https://github.com/pre-commit/mirrors-autopep8
    rev: v1.5.4
    hooks:
      - id: autopep8

Blacken

  - repo: https://github.com/asottile/blacken-docs
    rev: v1.8.0
    hooks:
      - id: blacken-docs
        additional_dependencies: [black==20.8b1]

Bandit

  - repo: git://github.com/Lucas-C/pre-commit-hooks-bandit
    rev: v1.0.4
    hooks:
      - id: python-bandit-vulnerability-check
        exclude: /home/ernesto/proyectos/magnetic_fields/.virtualenvs/*

pydoctstyle

  - repo: local
    hooks:
      - id: pydocstyle
        name: pydocstyle
        entry: pydocstyle
        files: src/app.py
        verbose: true
        language: python
        additional_dependencies: [pydocstyle]

Archivo completo

El archivo completo de .pre-commit-config.yaml contiene los siguiente:

# See https://pre-commit.com for more information
# See https://pre-commit.com/hooks.html for more hooks
repos:
  - repo: https://github.com/pre-commit/pre-commit-hooks
    rev: v2.4.0
    hooks:
      - id: trailing-whitespace
      - id: end-of-file-fixer
      - id: check-added-large-files
      - id: check-yaml
        exclude: (template|ci).*\.(json|yml|yaml)$
  - repo: https://github.com/asottile/seed-isort-config
    rev: v1.9.3
    hooks:
      - id: seed-isort-config
  - repo: https://github.com/pre-commit/mirrors-isort
    rev: v4.3.21
    hooks:
      - id: isort
  - repo: local
    hooks:
      - id: wily
        name: wily
        entry: wily diff
        verbose: true
        language: python
        additional_dependencies: [wily]
  - repo: local
    hooks:
      - id: pydocstyle
        name: pydocstyle
        entry: pydocstyle
        files: src/app.py
        verbose: true
        language: python
        additional_dependencies: [pydocstyle]
  - repo: git://github.com/Lucas-C/pre-commit-hooks-safety
    rev: v1.1.3
    hooks:
      - id: python-safety-dependencies-check
  - repo: https://github.com/ambv/black
    rev: stable
    hooks:
      - id: black
        language_version: python3.8
  - repo: https://github.com/PyCQA/pylint
    rev: "pylint-2.6.0"
    hooks:
      - id: pylint
        args: ["--disable=similarities"]
  - repo: https://github.com/pre-commit/mirrors-mypy
    rev: v0.790
    hooks:
      - id: mypy
        exclude: ^testing/resources/
  - repo: https://github.com/asottile/pyupgrade
    rev: v2.7.3
    hooks:
      - id: pyupgrade
        args: [--py36-plus]
  - repo: https://gitlab.com/pycqa/flake8
    rev: 3.8.4
    hooks:
      - id: flake8
        additional_dependencies: [flake8-typing-imports==1.10.0]
  - repo: https://github.com/pre-commit/mirrors-autopep8
    rev: v1.5.4
    hooks:
      - id: autopep8
  - repo: https://github.com/asottile/blacken-docs
    rev: v1.8.0
    hooks:
      - id: blacken-docs
        additional_dependencies: [black==20.8b1]
  - repo: git://github.com/Lucas-C/pre-commit-hooks-bandit
    rev: v1.0.4
    hooks:
      - id: python-bandit-vulnerability-check
        exclude: /home/ernesto/proyectos/magnetic_fields/.virtualenvs/*

Se puede ejecutar el siguiente comando para la verificación:

pre-commit run --all-files

Este devuelve los mensajes como se muestra en la siguiente imagen:

Desde ahora que se quiere hacer un commit pre-commit evaluará los hooks y se tiene que corregir los errores hasta no tener ninguno, y es allí que se realizará el commit.

Estructura de archivos final.

ignals_fft_streamlit
├── .bandit
├── .git
│   ├── branches
│   ├── COMMIT_EDITMSG
│   ├── config
│   ├── description
│   ├── HEAD
│   ├── hooks
│   │   ├── applypatch-msg.sample
│   │   ├── commit-msg.sample
│   │   ├── fsmonitor-watchman.sample
│   │   ├── post-update.sample
│   │   ├── pre-applypatch.sample
│   │   ├── pre-commit
│   │   ├── pre-commit.sample
│   │   ├── pre-merge-commit.sample
│   │   ├── prepare-commit-msg.sample
│   │   ├── pre-push.sample
│   │   ├── pre-rebase.sample
│   │   ├── pre-receive.sample
│   │   └── update.sample
│   ├── index
│   ├── info
│   │   └── exclude
│   ├── logs
│   │   ├── HEAD
│   │   └── refs
│   │       ├── heads
│   │       │   ├── feat
│   │       │   │   └── validado
│   │       │   └── main
│   │       └── remotes
│   │           └── origin
│   │               └── HEAD
│   ├── ORIG_HEAD
│   ├── packed-refs
│   └── refs
│       ├── heads
│       │   ├── feat
│       │   │   └── validado
│       │   └── main
│       ├── remotes
│       │   └── origin
│       │       └── HEAD
│       └── tags
├── .gitignore
├── .isort.cfg
├── LICENSE
├── .pre-commit-config.yaml
├── .pylintrc
├── README.md
├── requirements.txt
└── src
    └── app.py

El archivo final de app.py quedó de la siguiente manera:

"""WebApp with streamlit graph signals."""
import matplotlib.pylab as plt  # type: ignore
import numpy as np  # type: ignore
import streamlit as st  # type: ignore
from scipy import signal  # type: ignore # pylint: disable=import-error


def u(amplitud: int, t: np.ndarray) -> np.ndarray:
    """Función escalón unitario.

    Args:
        amplitud(int): Amplitud del escalon
        t(np.ndarray): Lista de tiempo

    Returns:
        np.ndarray: Lista de valores
    """
    return amplitud * np.piecewise(t, [t < 0.0, t >= 0.0], [0, 1])


def onda_cuadrada(amplitud: int, t: np.ndarray, fs: int = 1) -> np.ndarray:
    """Función  de Onda Cuadrada.

    Args:
        amplitud(int): Amplitud de la segnal
        t(list): Lista de valores de tiempo
        fs(int, optional): Frecuencia.. Defaults to 1.

    Returns:
        list: Lista de valores
    """
    return ((signal.square(2 * fs * t)) * (amplitud / 2.0)) + (amplitud / 2.0)


def segnal_triangular(
    amplitud: int, simetria: float, t: np.ndarray, fs: int = 1
) -> np.ndarray:
    """Señal triangular.

    Args:
        amplitud(int): Amplitud de la señal
        simetria(float): simetria de la señal
        t(np.ndarray): Lista de valores que definen el tiempo.
        fs(int, optional): Frecuencia de la señal. Defaults to 1.

    Returns:
        np.ndarray: Lista de valores de la señal
    """
    return amplitud * (signal.sawtooth(2 * np.pi * fs * t, simetria))


def seno(amplitud: int, t: np.ndarray, fs: int = 1) -> np.ndarray:
    """Onda Seno.

    Args:
        amplitud(int): Amplitud de la señal
        t (np.ndarray): Lista de valores de tiempo
        fs (int, optional): Frecuencia de la señal. Defaults to 1.

    Returns:
        np.ndarray: Lista de valores de la señal de seno
    """
    return amplitud * np.sin(fs * t)


def coseno(amplitud: int, t: np.ndarray, fs: int = 1) -> np.ndarray:
    """Señal de coseno.

    Args:
        amplitud (int): Amplitud de la señal
        t (np.ndarray): lista de valores para generar la señal
        fs (int, optional): Frecuencia de la señal. Defaults to 1.

    Returns:
        np.ndarray: Lista de valores de la señal
    """
    return amplitud * np.cos(fs * t)


def tiempo(lim_inf: int, lim_sup: int, n: int) -> np.ndarray:
    """Lista de valores que definen el tiempo de la señal.

    Args:
        lim_inf (int): Límite inferior del tiempo
        lim_sup (int): Límite superior del tiempo
        n (int): Cantidad de valores a generar del tiempo

    Returns:
        np.ndarray: Lista de valores del tiemmpo
    """
    return np.linspace(lim_inf, lim_sup, n)


def main():
    """Ejecución Streamlit webApp."""
    st.title(  # pylint: disable=no-value-for-parameter
        "Generación de gráficas de señales"
    )  # pylint: disable=no-value-for-parameter
    st.sidebar.header("Entradas:")  # pylint: disable=no-value-for-parameter
    segnales = [
        "Escalon Unitario",
        "Onda Cuadrada",
        "Onda triangular",
        "Seno",
        "Coseno",
    ]

    resp = st.sidebar.selectbox("Tipo de señal", segnales)

    st.sidebar.header("Definición del tiempo:")
    st.sidebar.subheader("Rango")
    # SelectBox
    t0 = int(st.sidebar.selectbox("", range(0, 10)))
    ti = 0
    tf = t0
    n = 10000
    t = tiempo(ti, tf, n)
    st.sidebar.subheader("Amplitud de la señal")
    amplitud = int(st.sidebar.selectbox("", range(1, 10)))

    # numpy.ndarray
    if resp == "Escalon Unitario":
        ti = -tf
        resultado = u(amplitud, t)
    elif resp == "Onda Cuadrada":
        st.sidebar.subheader("Frecuencia de la señal")
        fs = int(st.sidebar.selectbox("", range(1, 11)))
        resultado = onda_cuadrada(amplitud, t, fs)
    elif resp == "Onda triangular":
        simetria = 0.5
        st.sidebar.subheader("Frecuencia de la señal")
        fs = int(st.sidebar.selectbox("", range(1, 11)))
        resultado = segnal_triangular(amplitud, simetria, t, fs)
    elif resp == "Seno":
        st.sidebar.subheader("Frecuencia de la señal")
        fs = int(st.sidebar.selectbox("", range(1, 11)))
        resultado = seno(amplitud, t, fs)
    elif resp == "Coseno":
        st.sidebar.subheader("Frecuencia de la señal")
        fs = int(st.sidebar.selectbox("", range(1, 11)))
        resultado = coseno(amplitud, t, fs)
    else:
        resultado = 0
        st.error("Error")

    fig = plt.figure()
    ax = fig.add_subplot(111)
    st.header(f"Gráfica de {resp}")
    ax.plot(t, resultado)
    ax.set_xlim(ti, tf)
    ax.set_xlabel("Tiempo")
    ax.set_ylabel("f(t)")
    ax.set_ylim(2 * amplitud * -1, 2 * amplitud)
    st.pyplot(fig)


if __name__ == "__main__":
    main()

El respositorio donde pueden ver los archivos se encuentra en github

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Tutorial introductorio de streamlit.

2020-10-31T18:55:00-04:00

En el artículo anterior sobre visualización de campos magnéticos con streamlit se menciona que en el siguiente artículo (este), se dara un tutorial de streamlit básico.

Este artículo se basa en en artículo Streamlit Python Tutorial(Crash Course) de jesse_jcharis.

El código de este artículo lo pueden revisar en el repositorio de github tutorial de streamlit.

Tutorial de Streamlit

A continuación se muestra el código que muestra cada componente de streamlit (se encuentra en el archivo app.py).

import datetime
import time

import pandas as pd
import streamlit as st
from PIL import Image

# Permite definir que la función este en cache.


@st.cache
def run_fxn(n: int) -> list:
    return range(n)


def main():
    """Generación de la webapp con streamlit"""
    # Definir título
    st.title("Título: Tutorial de Streamlit")

    # Definir Header/Subheader
    st.header("Este es un header")
    st.subheader("Este es un subheader")

    # Definir un Texto
    st.text("Texto: Hola Streamlit")

    # Definición de Markdown
    st.markdown("# Este es un markdown h1 \n ## Este es un h2 \n ### Este es un h3")

    st.header("Colores de texto y mensajes de error")
    st.success("Successful")
    st.info("Información!")
    st.warning("warning")
    st.error("Error")
    st.exception("NameError('no está definido')")

    st.header("Obtener información de ayuda de Python")
    st.help(range)

    st.header("Widgets:")
    st.subheader("Checkbox")
    # Checkbox
    if st.checkbox("Show/Hide"):
        st.text("Mostrar u ocultar Widget")

    st.subheader("Radio buttons")
    # Radio Buttons
    status = st.radio("Cual es su estatus", ("Activo", "Inactivo"))

    if status == "Activo":
        st.success("Estas activo")
    else:
        st.warning("Inactivo")

    st.subheader("SelectBox")
    # SelectBox
    occupation = st.selectbox(
        "Tu Ocupación", ["Programador", "Cientifico de datos", "Doctor", "Emprendedor"]
    )
    st.write("Opción seleccionada:", occupation)

    st.subheader("MultiSelect")
    # MultiSelect
    location = st.multiselect(
        "Donde trabajas?",
        ("Londres", "Nueva York", "Accra", "Kiev", "Nepal", "Buenos Aires", "Caracas"),
    )
    st.write("Seleccionó:", len(location), "locaciones")

    st.subheader("Slider")
    # Slider
    level = st.slider("Cual es tu nivel?", 1, 5)
    st.write("Nivel:", level)

    st.subheader("Buttons")
    # Buttons
    if st.button("Acerca"):
        st.text("Streamlit es Cool")
    else:
        st.text("")

    st.header("Como recibir una entrada y procesarla con streamlit?")
    st.subheader("Recibiendo texto")
    # Recibiendo texto
    firstname = st.text_input("Escriba su nombre:")
    if st.button("Aceptar"):
        result = firstname.title()
        st.success(result)

    st.subheader("Área de texto")
    # Text Area
    message = st.text_area("Escriba un mensaje")
    if st.button("Aceptar "):
        result = message.title()
        st.success(result)

    st.subheader("Entrada de fecha")
    # Date Input
    today = st.date_input("Hoy es", datetime.datetime.now())
    st.text(f"{today}")

    st.subheader("Entrada de tiempo")
    # Time
    the_time = st.time_input("La hora es:", datetime.time())
    st.text(f"{the_time}")

    st.header("Trabajar con archivos de imágenes, audio o vídeos")
    # Images

    st.subheader("Archivo de imagen")
    img = Image.open("example.jpg")
    st.image(img, width=300, caption="Simple Imagen")

    st.subheader("Archivo de vídeo")
    # Videos
    vid_file = open("Streamlit Campo magnético-uRDO3trlSG8.mp4", "rb").read()
    # vid_bytes = vid_file.read()
    st.video(vid_file)

    st.subheader("Archivo de audio")
    # Audio
    audio_file = open("040-data-science-year-in-review.mp3", "rb").read()
    st.audio(audio_file, format="audio/mp3")

    st.header("Otras opciones que permite la función write")
    # Writing Text/Super Fxn
    st.subheader("Texto con write")
    st.write("Texto con write")
    st.write(range(10))

    st.header("Desplegando código puro y json")
    st.subheader("Código puro")
    st.code("import numpy as np")
    with st.echo():

        df = pd.DataFrame()

    st.subheader("Desplegando json")
    st.text("Mostrando JSON")
    st.json({"nombre": "Jhon", "apellido": "Doe", "genero": "masculino"})

    st.header("Mostrar barra de progreso, spinner y balloons")
    st.subheader("Barra de progreso")
    my_bar = st.progress(0)
    for p in range(10):
        my_bar.progress(p + 1)

    st.subheader("Spinner")
    with st.spinner("Espere .."):
        time.sleep(5)
        st.success("Finalizó!")

    st.subheader("Balloons")
    # Balloons
    st.balloons()

    st.header("Trabajando con data science")
    df = pd.read_csv("Venezuela.csv", index_col=0)

    st.subheader("Dataframe")
    st.dataframe(df)

    st.subheader("tabla")
    st.table(df.head())

    st.subheader("gráfica")
    st.line_chart((df))

    # mostrar barra lateral
    st.sidebar.header("Acerca")
    st.sidebar.text("Tutorial de streamlit ")

    st.header("Trabajando con funciones")
    st.write(list(run_fxn(10)))


if __name__ == "__main__":
    main()

Para correrlo se ejecuta:

streamlit run app.py

Esto abre el navegador en el url http://localhost:8501.

Se puede ver una captura de pantalla:

Se puede ver la demostración de uso desde el vídeo en youtube:

En próximo artículo se mostrará componentes de streamlit más complejos.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Visualización de campo magnético usando streamlit.

2020-10-25T13:55:00-04:00

Este artículo muestra una introducción del framework Streamlit usando un viejo post Graficar líneas de campo eléctrico con matplotlib y Python.

Streamlit

Streamlit es un framework que será la forma más rápida de crear y compartir aplicaciones de datos.

Su documentación la pueden encontrar en el siguiente enlace.

Instalación

Para instalar streamlit se usa pip y se ejecuta un ejemplo base:

pip install streamlit
streamlit hello

Al ejecutar streamlit se levanta un servidor web en el puerto 8501 como se muestra a continuación:

Al abrir el enlace se tiene una página inicial como la que se muestra a continuación:

Y tiene varios demos como el siguiente:

Visualización de Campo magnético con Python y Streamlit

Como se mencionó antes, este post se basa en un artículo anterior sobre la visualización de campo magnético con Python y matplotlib. El código fuente lo puede ver en github o el notebook.

En próximo artículo se dará una introducción de los distintos componentes de Streamlit, por lo pronto se mostrará el código de visualización de campo magnético como webapp de la manera más sencilla posible.

La estructura de archivos del repositorio es la siguiente:

.
├── app.py
├── LICENSE
├── README.md
└── requirements.txt

El código de app.py se muestra a continuación:

import matplotlib.pyplot as plt
import numpy as np
import streamlit as st
from matplotlib.patches import Circle

# https://github.com/ecrespo/codigo_blog/blob/master/graficacion/campoelectric/graficar%2Bcampo%2Belectrico.ipynb
# https://github.com/ecrespo/codigo_blog/blob/master/graficacion/campoelectric/graficar%2Bcampo%2Belectrico.py
# https://www.seraph.to/graficar-lineas-de-campo-electrico-con-matplotlib-y-python.html#graficar-lineas-de-campo-electrico-con-matplotlib-y-python


@st.cache(allow_output_mutation=True)
def magnetic_field_e(q, r0, x, y) -> tuple:
    """Retorna el vector de campo eléctrico E=(Ex,Ey) de una carga q en r0"""
    den = np.hypot(x - r0[0], y - r0[1]) ** 3
    return q * (x - r0[0]) / den, q * (y - r0[1]) / den


@st.cache(allow_output_mutation=True)
def magnetic_field_vector(n: int, axis_x: int, axis_y: int) -> dict:
    """Cálculo del campo electromagnetico según la cantidad de dipolos.

    Args:
        n (int): Número de cargas para definir el dipolo

    Returns:
        dict: x,y,charges,Ex,Ey
    """
    # # puntos de los ejes x e y.
    nx, ny = 128, 128
    x = np.linspace(-axis_x, axis_x, nx)
    y = np.linspace(-axis_y, axis_y, ny)
    X, Y = np.meshgrid(x, y)
    # # Crear un multipolo con nq cargas
    # count = número de q. En ese caso es 1 dipolo
    count = n
    nq = 2 ** int(count)
    charges = [
        (i % 2 * 2 - 1, (np.cos(2 * np.pi * i / nq), np.sin(2 * np.pi * i / nq)))
        for i in range(nq)
    ]

    # # Vector de campo eléctrico como componentes separados (Ex,Ey)
    Ex, Ey = np.zeros((ny, nx)), np.zeros((ny, nx))
    for charge in charges:
        ex, ey = magnetic_field_e(*charge, x=X, y=Y)
        Ex += ex
        Ey += ey

    return {"x": x, "y": y, "charges": charges, "Ex": Ex, "Ey": Ey}


def main():
    """Generación de la webapp con streamlit"""
    # Definir título
    st.title("Magnetic fields")
    # Entrada de datos en el sidebar.
    st.sidebar.header("Inputs:")
    # min: 1, max: 5, default: 1
    n = int(st.sidebar.slider("Charges", 1, 10, 1))
    # SelectBox en sidebar
    min_max_scale = int(
        st.sidebar.selectbox("min,max value in graph", list(range(11, 21)))
    )
    # Graficar usando matplotlib
    fig = plt.figure()
    ax = fig.add_subplot(111)
    # Se realiza el cálculod el vector de campo magnético.
    res = magnetic_field_vector(n, min_max_scale, min_max_scale)
    # Muestra la cantidad de polos que se definen en la entrada de datos.
    st.header(f"{2*n} Polos")
    # Dibujar las líneas de flujo con mapa de colores y estilos apropiados.
    color = 2 * np.log(np.hypot(res["Ex"], res["Ey"]))
    ax.streamplot(
        res["x"],
        res["y"],
        res["Ex"],
        res["Ey"],
        color=color,
        linewidth=1,
        cmap=plt.cm.inferno,
        density=2,
        arrowstyle="->",
        arrowsize=1.5,
    )
    # Agregar circulos para las cargas.
    charge_colors = {True: "#aa0000", False: "#0000aa"}

    for q, pos in res["charges"]:
        ax.add_artist(Circle(pos, 0.05, color=charge_colors[q > 0]))

    # Graficar
    ax.set_xlabel("$x$")
    ax.set_ylabel("$y$")
    ax.set_xlim(-min_max_scale, min_max_scale)
    ax.set_ylim(-min_max_scale, min_max_scale)
    ax.set_aspect("equal")
    # plt.show()
    st.pyplot(fig)


if __name__ == "__main__":
    main()

Al ejecutar streamlit con el nombre del archivo:

streamlit run app.py

Se tiene la siguiente imagen del arranque:

Imagen de la página:

Se puede ver la demostración de uso desde el vídeo en youtube:

En próximo artículo se muestra en detalle de los distintos componentes html que tiene Streamlit.

El repositorio donde pueden encontrar el código del artículo lo pueden ver en github

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Generación de esquema JSON de un archivo XML con genson,lxml y xmltodict.

2020-06-28T10:55:00-04:00

La página de genson es la siguiente y en github. Lo primero que se hará es instalar genson , así como lxml y xmltodict .

Instalación

Se instala genson, lxml y xmltodict:

pip install genson lxml xmltodict

CLI Tool

Genson puede ser usado como un comando para generar un esquema json. A continuación se muestra la salida de su ayuda:

$ genson --help

usage: genson.py [-h] [-d DELIM] [-i SPACES] [-s SCHEMA] [-$ URI] ...

Generate one, unified JSON Schema from one or more JSON objects and/or JSON
Schemas. It's compatible with Draft 6 and above.

positional arguments:
  object                files containing JSON objects (defaults to stdin if no
                        arguments are passed)

optional arguments:
  -h, --help            show this help message and exit
  -d DELIM, --delimiter DELIM
                        set a delimiter - Use this option if the input files
                        contain multiple JSON objects/schemas. You can pass
                        any string. A few cases ('newline', 'tab', 'space')
                        will get converted to a whitespace character. If this
                        option is omitted, the parser will try to auto-detect
                        boundaries
  -i SPACES, --indent SPACES
                        pretty-print the output, indenting SPACES spaces
  -s SCHEMA, --schema SCHEMA
                        file containing a JSON Schema (can be specified
                        multiple times to merge schemas)
  -$ URI, --schema-uri URI
                        the value of the '$schema' keyword (defaults to
                        'http://json-schema.org/schema#' or can be specified
                        in a schema with the -s option). If 'NULL' is passed,
                        the "$schema" keyword will not be included in the
                        result.

GenSON Python API

Ahora se mostrará el uso del API de genSON para Python.

Ejemplos

Para todos los ejemplos se importará una lista de módulos de Python:

json
lxml parse
lxml XMLParse
xmltodict
genson SchemaBuilder

import json
from lxml.etree import parse
from lxml.etree import XMLParser
import xmltodict
import genson
from genson import SchemaBuilder

Una lista de diccionarios

Se tiene una lista de diccionarios de la siguiente forma:

templist = [{
 'name':'Sam',
},
{
 'name':'Jack',
}]

templist
[{'name': 'Sam'}, {'name': 'Jack'}]

Convertir a JSON la lista:

jsonf = json.dumps(templist)
jsonf 

'[{"name": "Sam"}, {"name": "Jack"}]'

Se crea la instancia del SchemaBuilder, se agrega el objeto y se muestra el esquema de ese objecto:

builder = SchemaBuilder()
builder.add_object(json.loads(jsonf))
builder.to_schema()

{'$schema': 'http://json-schema.org/schema#',
 'type': 'array',
 'items': {'type': 'object',
  'properties': {'name': {'type': 'string'}},
  'required': ['name']}}

El esquema muestra que el objeto es de tipo arreglo, que tiene items que son del tipo object, y que tiene un campo requerido como nombre, y ese nombre es de tipo string.

Diccionarios agregados como objetos individuales

Se agregarán dos diccionarios que tiene como clave "hi" con diferentes valores (tipo string y entero):

builder = SchemaBuilder()
builder.add_object({"hi": "there"})
builder.add_object({"hi": 5})
builder.to_schema()

{'$schema': 'http://json-schema.org/schema#',
 'type': 'object',
 'properties': {'hi': {'type': ['integer', 'string']}},
 'required': ['hi']}

Ahora el esquema devuelve que es de tipo objeto, y que tiene un campo requerido con nombre "hi", pero de tipo entero y string.

Se tiene una lista con dos items de distinto tipo (String, entero)

builder = SchemaBuilder()
builder.add_object(['one', 1])
builder.to_schema()

{'$schema': 'http://json-schema.org/schema#',
 'type': 'array',
 'items': {'type': ['integer', 'string']}}

El esquema que genera es de tipo arreglo, con item de dipo entero y string.

Caso real datos de la NASA

En el siguiente enlace encontrarán el data set de la NASA convertido en archivo plano en xml. El archivo xml lo pueden descargar directamente desde acá.

No se va a procesar o restructurar los datos, ya que sería necesario conocer el modelo de datos de la investigación.

Los pasos son los siguientes:

Creación del parser xml con encoding UTF-8

parser = XMLParser(encoding='UTF-8')

Leer los datos xml del archivo y convertirlos en un diccionario:

with open("../datos/nasa.xml", "r") as f:
  xx = xmltodict.parse(f.read())

Crear la instancia de SchemaBuilder, pasarle el diccionario y generar el esquema:

sb = genson.SchemaBuilder()
sb.add_object(xx)
sb.to_schema()

{'$schema': 'http://json-schema.org/schema#',
 'type': 'object',
 'properties': {'datasets': {'type': 'object',
   'properties': {'dataset': {'type': 'array',
     'items': {'type': 'object',
      'properties': {'@subject': {'type': 'string'},
       '@xmlns:xlink': {'type': 'string'},
       'title': {'type': 'string'},
       'altname': {'type': 'array',
        'items': {'type': 'object',
         'properties': {'@type': {'type': 'string'},
          '#text': {'type': 'string'}},
         'required': ['#text', '@type']}},
       'reference': {'type': 'object',
................

Sólo se muestra una parte del esquema, lo que se hará a continuación es eliminar el "@" que en algunos datos aparecen.

Para ello se tiene una función de postprocesamiento:

def postprocessor(path,key,value):
    try: 
        if key.startswith("@"):
            key = "_" + key[1:]
        return key,value 
    except (ValueError, TypeError):
        return key,value

Toma las claves del diccionario y los que comiencen por "@" los cambia por "_".

Se vuelve a leer los datos del archivo xml pasando la función:

with open("../datos/nasa.xml", "r") as f:
    xx = xmltodict.parse(f.read(),encoding="utf-8",postprocessor=postprocessor)

Se crea la instancia de SchemaBuilder, se agrega el diccionario y se genera el esquema:

sb = genson.SchemaBuilder()
sb.add_object(xx)
sb.to_schema()

{'$schema': 'http://json-schema.org/schema#',
 'type': 'object',
 'properties': {'datasets': {'type': 'object',
   'properties': {'dataset': {'type': 'array',
     'items': {'type': 'object',
      'properties': {'_subject': {'type': 'string'},
       '_xmlns:xlink': {'type': 'string'},
       'title': {'type': 'string'},
       'altname': {'type': 'array',
        'items': {'type': 'object',
         'properties': {'_type': {'type': 'string'},
          '#text': {'type': 'string'}},
         'required': ['#text', '_type']}}

..................

Ahora se nota que cambiaron algunas claves con un "_".

Con xmltodict, lxl y genson se puede procesar conjunto de datos y restructurarlos a lo que se requiere para facilitar su análisis.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Descargar libros de Data Science de la editorial Springer usando Python.

2020-05-01T15:33:00-04:00

La editorial Springer ha liberado libros en pdf. En el enlace explican como descargar todos los libros en pdf usando una hoja de cálculo que contiene los libros, convierten en un dataframe de pandas y luego el script en sí de descarga de cada libro. Pero, en este caso hay otro enlace donde se tiene sólo los libros dedicados a Data Science y Machine Learning, dandole clic a cada enlace de la página.

Este artículo se basa en el script de descarga de los libros usando la hoja de cálculo pero en vez de usar la hoja de cálculo se descargarán los libros que están en el segundo enlace que son los dedicados a Data Science y Machine Learning. La diferencia es usar web scraping en vez de leer una hoja de cálculo y convertirla en un DataFrame.

Antes de empezar con el código, unas aclaraciones:

Este script y artículo se basa en el artículo en ingles de descargas de los libros de Springer, usando Python.
Los libros que descarga el script se encuentran en el artículo de descargas dedicadas a Data Science y Machine Learning.
Investigando un poco los libros se podrán descargar hasta finales de Julio por lo que leí en Hipertextual
Así que el script a continuación dejará de funcionar luego que la editorial los bloquee para descarga gratis. Si quedan libros que pueden descargarse luego de la fecha, es responsabilidad de la editorial (Springer).

Para utilizar el script es necesario tener Python 3.7 o superior e instalado request y wget:

pip install request wget

A continuación se muestra el código:

import requests, wget
from bs4 import *
from pathlib import Path

def ls3(path):
    """
    Toma el path y lista los archivos que se encuentran en ese path.
    :param: path: Ruta donde se encuentran los archivos a listar.
    :return: list: Retoran la lista de archivos en el path.
    """
    return [obj.name for obj in Path(path).iterdir() if obj.is_file()]


def main(url,path):
    """     
    Descarga los libros pasando el url de la página que contiene los enlaces.
    :param: url: URL del sitio donde se encuentran los enlaces de los libros a descargar.
    :param: path: Ruta donde se descargan los libros.
    """

    pattern = "springer"

    #Se realiza el get del URL inicial y se usa bs4.
    html = requests.get(url)
    soup = BeautifulSoup(html.text,features='lxml')
    #Se captura los tags a
    tags = soup('a')

    #Se obtienen los enlaces de las descargas de los libros.
    links = [str(tag.get('href',None)) for tag in tags if (str(tag.get('href',None)).find(pattern) != -1) and (str(tag.get('href',None)).find("link") != -1)]

    #Se recorre cada enlace.
    for i,link in enumerate(links):
        #Se realiza el get del enlace
        r = requests.get(link)
        #Con bs4 se obtiene el nombre del libro a descargar
        soup = BeautifulSoup(r.text,features='lxml')
        ref = soup("h1")
        name = str(ref).split("<h1>")[-1].split("</h1>")[0]

        #Se define el url de descarga.
        download_url = f"{r.url.replace('book','content/pdf')}.pdf"
        #Se verifica que el libro ya no se ha descargado antes.
        # Si no se ha descargado antes se descarga usando wget.  
        if f"{name}.pdf" not in ls3(path):   
            print(f"{i+1},downloading {name}.pdf ")
            wget.download(download_url, f"./descargas/{name}.pdf")
            print(f" downloaded {name}.pdf")

    print("Download completed")

if __name__ == "__main__":
    url = "https://towardsdatascience.com/springer-has-released-65-machine-learning-and-data-books-for-free-961f8181f189"

    path = "/home/ernesto/desarrollo/springer/descargas/"

    main(url,path)

A continuación se muestra una imagen del proceso de descarga de los libros:

Les dejo el enlace del repositorio en github del script enlace.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Explorando datos del Covid19 con pandas.

2020-03-14T15:33:00-04:00

Existen varios sitios que muestran un dashboard de la información del Covid-19, por ejemplo arcgis, o para el caso de Venezuela se tiene covid19-venezuela.

Este artículo se basa en el artículo de Learning pandas by Exploring COVID-19 Data, el CDC de la Unión Europea ECDC, otra fuente de datos Coronavirus Source Data, el repositorio Universidad Johns Hopkins; el cual se basa las fuentes de datos de este artículo.

La forma de acceder a los datos localmente es haciendo clone y luego pull:

git clone https://github.com/CSSEGISandData/COVID-19.git

Para actualizar:

cd COVID-19
git pull origin master

Se necesita instalar pandas, csv y matplotlib:

pip3 install pandas csv matplotlib

Al descargarlo, el proceso sería el siguiente:

Lectura de csv
Procesar datos
Gráficar

A continuación el código:

# In[1]:


import pandas as pd
import datetime
import requests
from pathlib import Path
import matplotlib.pyplot as plt
%matplotlib inline

Ruta de los archivos csv

# In[2]:
path = "./COVID-19/csse_covid_19_data/csse_covid_19_daily_reports"

Función de listar archivos

# In[3]:
def ls3(path):
    """
    Retorna una lista de archivos de una ruta (path) dada.
    :param path: Ruta del directorio donde se encuentran los archivos a listar
    :return filenames
    """
    return [obj.name for obj in Path(path).iterdir() if obj.is_file()]

Función de obtención de datos

# In[4]:
def getData(country="Venezuela",date="03-13-2020",path=path,encoding="ISO-8859-1"):
    """
    Obtiene los datos desde una fecha y para un país, de la ruta definida de archivos csv.
    :param country: País que se quiere generar el dataframe
    :param date: Fecha desde que se va a tomar los datos para el dataframe
    :param path: Ruta donde se encuentran los archivos csv
    :param encoding: Codificación a la que se encuentran los archivos csv.
    :return df: Dataframe con los datos extraídos de los csv desde una fecha dada y para un país.
    """
    # Se obtiene los nombres de los archivos.
    lista = [file for file in ls3(path) if file.split(".")[-1] == "csv"]
    # Se lee los archivos csv y se convierten en varios dataframe en un diccionario ordenados por fecha.
    df = {item.split(".")[0]:pd.read_csv(path+ "/" +item,encoding=encoding) for item in lista}
    # Se lista las fechas
    dates = [item.split(".")[0] for item in lista]
    # Se renombras las columnas de los dataframes.
    for i,date in enumerate(dates):
        if "Country_Region" in list(df[date].columns) or "Province_State" in list(df[date].columns) or "Last_Update" in list(df[date].columns):
            df[date].rename(columns={"Country_Region": 'Country/Region',"Last_Update":"Last Update","Province_State": "Province/State"},inplace=True)
    # Se convierten las fechas en datetime y se ordenan
    dates2 = sorted([datetime.datetime.strptime(date,"%m-%d-%Y") for date in dates])
    # Se ordena los dataframes en una lista
    data = [df[d.strftime("%m-%d-%Y")][df[d.strftime("%m-%d-%Y")]["Country/Region"] == country] for d in dates2 if d >= datetime.datetime.strptime(date,"%m-%d-%Y")]
    #Se concatena los dataframes en uno sólo y se retorna
    data_df = pd.concat(data)
    return data_df

Función de agregar columna rate

# In[5]:
def AddColumnRate(df,column_name):
    """
    Agrega una columna al dataframe, dicha columna es la diferencia entre la próxima row y el row actual
    :param df: DataFrame a agregar la columna.
    :param column_name: Columna a la que se quiere calcular la diferencia.
    :return df: Retorna un dataframe con la columna adicional que tiene la diferencia por día.
    """
    elements = []
    # Se recorre el dataframe
    for i in range(len(df)):
        # Si es la fila inicial se toma su valor
        if i == 0:
            elements.append(df.iloc[0][column_name])
        else:
            # Si no es el inicial se calcula la diferencia de su valor actual con el anterior
            elements.append(df.iloc[i][column_name] - df.iloc[i-1][column_name])
    # Se agrega la lista al dataframe
    df.insert(4,f"rate_{column_name}",elements)
    return df

Función de procesar datos

# In[6]:
def DataProcessor(df):
    """
    Se remueve columnas del dataframe, se define el index, se reemplaza los NA y se agrega dos columnas.
    :param df: Dataframe a procesar
    :return df: DataFrame procesado
    """
    # Se obtiene el nombre de una columna a remover
    remove = list(df.columns)[0]
    # Se remueve la lista de columnas
    df.drop(labels=["Province/State","Latitude","Longitude","Admin2","Lat","Long_","Combined_Key","FIPS",remove],axis=1,inplace=True)
    df.drop(labels=[df.columns[-2]],axis=1,inplace=True)
    # Se reemplaza NA por 0.
    df.fillna(0,inplace=True)
    # Se conviernte las fechas que son string a datetime
    df['Last Update']= pd.to_datetime(df['Last Update'])
    # Se define las fechas como indice
    df.set_index("Last Update",inplace=True)
    # Se calcula los rate de confirmados y muertes
    df = AddColumnRate(df,"Confirmed")
    df = AddColumnRate(df,"Deaths")
    return df

Función de crear gráficas

# In[7]:
def PlotData(df,column,title):
    """
    Gráfica una columna del dataframe
    :param df: Dataframe a gráficar
    :param column: Columna a graficar
    :param title: Título de la gŕafica
    """
    # Se recorre los países de la lista
    for i,country in enumerate(countries):
        if i == 0:
            # Si es el primer país se define el título de la gráfica
            df[country][column].plot(label=country,figsize=(16,8),title=title)
        else:
            df[country][column].plot(label=country,figsize=(16,8))
    plt.legend();

Obtención y procesamiento de los datos

# # Obtención de datos

# In[8]:
# Paises a analizar
countries = ["Venezuela","Chile"]


# In[9]:
# Fecha de extracción de datos
date= "02-20-2020"


# In[10]:
# Construcción de los dataframes
df = {country: getData(country=country,date=date) for country in countries}

# In[11]:
# Procesar los datos
df2 = {country: DataProcessor(df[country]) for country in countries}

DataFrame

DataFrame de Venezuela:

df2["Venezuela"]

Generar gráficos

Casos Confirmados

# In[12]:
PlotData(df2,"Confirmed","Casos Confirmados")

Tasa de Confirmados

# In[13]:
PlotData(df2,"rate_Confirmed","Tasa de confirmados")

Muertes

# In[14]:
PlotData(df2,"Deaths","Muertes")

Recuperados

# In[15]:
PlotData(df2,"Recovered","Recuperados")

El notebook del procesamiento de los datos lo pueden encontrar en github

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Herramientas de Python para desarrollar código seguro y de calidad.

2020-03-14T15:33:00-04:00

Este artículo se basa en Top Python Tools for Developing Secure, Quality Code. Se creará una aplicación básica (Hola mundo) en flask, donde se incorporará una serie de herramientas que permitirá evaluar el código cumpliendo entre otras cosas el PEP8 de Python, evaluar la seguridad del código, las herramientas y sus enlaces se muestran a continuación:

Pipenv: Pipenv es una herramienta que tiene como objetivo llevar al mundo de Python lo mejor de todos los mundos de empaque (bundler,composer,npm, cargo,yarn, etc. Crea y gestiona automáticamente un virtualenv para sus proyectos, así como también agrega / elimina paquetes de su Pipfile a medida que instala / desinstala paquetes.

pip install pipenv

Safety:Safety verifica sus dependencias para detectar vulnerabilidades de seguridad conocidas (Ochrona es el recomendado en el artículo original, pero como no se tiene detalles para instalar se usará Safety).

pip install safety

Bandit: Bandit es una herramienta diseñada para encontrar problemas de seguridad comunes en el código Python.

pip3 install bandit

Black: El formateador de código Python intransigente (cumpliendo el Pep-8).

pip install black

Mypy: Mypy es un verificador de tipo estático opcional para Python que tiene como objetivo combinar los beneficios de la escritura dinámica (o "duck") y la escritura estática.

pip install mypy

pylint: Verifica el cumplimiento del PEP8.

pip install pylint

pycodestyle: Pycodestyle es una herramienta para verificar su código de Python contra algunas de las convenciones de estilo en PEP 8.

pip install pycodestyle

El código fuente que se usa en el artículo lo pueden ver en Github.

Juntando todo

En el artículo se usará como herramienta de Integración Continua a Travis-CI, aunque se puede usar cualquier otra herramienta de integración continua. Para más información sobre Travis-CI les dejo un enlace al tutorial.

Estructura de archivos:

tutorialci/
├── app.py
├── .gitignore
├── Pipfile
├── .pylintrc
├── README.md
├── requirements.txt
└── .travis.yml

Los archivos necesarios son los siguientes:

app.py: Aplicación en Flask.
.gitignore: Archivo que permite ignorar archivos o directorios en git.
PipFile: Archivo pipenv.
.pylintrc: Archivo de configuración de pylint.
README.md: Archivo readme en markdown.
requirements.txt: Archivo de requerimientos para ser usado con pip (pip install -r requirements.txt).
.travis.yml: Archivo yml para configurar travis-ci del proyecto.

Archivo app.py

Este archivo crea una página web que muestra hola mundo.

from flask import Flask

app = Flask(__name__)

@app.route('/<nombre>')
def hola_mundo(nombre: str) -> str:
    return hola_nombre(nombre)

def hola_nombre(nombre: str) -> int:
    return f"hola, {nombre}"

if __name__ == '__main__':
    app.run(debug=True)

Nota: Este código tiene errores a propósito para ver el funcionamiento de la integración continua.

Archivo Pipfile:

El archivo Pipfile tiene el siguiente contenido:

[[source]]
name = "pypi"
url = "https://pypi.org/simple"
verify_ssl = true

[dev-packages]
bandit = "*"
v = {editable = true,version = "*"}
black = "*"
mypy = "*"
safety = "*"
pycodestyle = "*"
pylint = "*"

[packages]
flask = "==0.12.2"
[requires]
python_version = "3.7"

Allí se define el nombre del paquete, los paquetes para desarrollar (están incorporados los que se mencionan anteriormente), luego los paquetes requeridos para el funcionamiento de la aplicación junto con la versión de python requerida.

Archivo .pylintrc

Al inicio el archivo estará vacío, pero el contenido al final será:

[MASTER]
disable=
    C0111,

Archivo .travis.yml

El archivo travis es el encargado del flujo de integración continua, a continuación su contenido:

language: python
python:
  - 3.7
install:
  - pip install -U pip
  - pip install pipenv
  #- pip install -r requirements.txt
  - pipenv install --dev
script:
  - bandit ./*
  - black --check .
  - safety check -r requirements.txt
  - mypy .
  - pylint app.py
  - pycodestyle app.py

Se define el lenguaje de programación y su versión, luego el procedimiento de instalación de paquetes (notar que se usa pipenv install --dev para instalar los paquetes definidos en Pipfile).

Repositorio Github

Se tiene el repositorio github:

Conexión del repositorio github con Travis-CI

Se tiene conectado el repositorio github con Travis-ci, explicación del proceso en la documentación de travis-ci.

Proceso de Integración

El proceso de inicio de integración continua se muestra a continuación:

errores

Al hacer commit y luego push a github se tiene lo siguiente en Travis-ci un error en las versiones de paquetes, se resuelve con el siguiente cambio en Pipfile:

PipFile

Bandit

El error que devuelve bandit es con respecto a que flask está corriendo en modo debug, con colocarlo en False se tiene resuelto.

Safety

Safety no devolvió error.

mypy

Los errores de Mypy son de declaración de tipos.

Los errores son en la línea 7 y 10. Hay que cambiar int en la línea 9 por str que sería la salida correcta.

Errores de PEP8

Black: Devuelve error.

Dice que no cumple con el formato de PEP8.

pylint

Se tiene errores en las líneas 13,1, 3,6 y 9.

Los errores en las líneas 1, 6 y 9 se resuelven colocando el código C0111 en el archivo .pylintrc, como se muestra en su sección.

pycodestyle

Se tienen errores en las líneas 5,9,12 y 13.

Al corregir los errores la integración no devuelve errores:

El archivo final de app.py se tiene a continuación con sus cambios:

Como se puede ver, las herramientas ayudan a tener código de calidad y sin problemas de seguridad.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Sustituir ciclos con map, filter y reduce.

2020-02-07T15:33:00-04:00

Este artículo se basa en el artículo en medium, How To Replace Your Python For Loops with Map, Filter, and Reduce.

El artículo tendrá 3 faces, la primera será la de mostrar la lógica de los ejemplos usando ciclos, luego se usará list comprehension y por último map, filter y reduce.

Ciclos

En esta primera parte se generará una lista con 100 números (se que no es necesario un ciclo para generar está primera lista), luego a esa lista se calculará los números pares, luego se generará una lista con el cuadrado de los números generados al inicio y por último se calculará la suma total de los números de la última lista.

Generación de números en una lista

In [1]:

numeros = [] 
for i in range(0,100): 
    numeros.append(i)
print(numeros)

[0, 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, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]

Otra forma de hacerlo: In [2]:

numeros = list(range(100))
print(numeros)

[0, 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, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]

Filtrar números pares de la lista

In[3]:

numeros_pares = [] 
for numero in numeros:
    if numero % 2 == 0: 
        numeros_pares.append(numero) 
print(numeros_pares)

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98]

Calcular el cuadrado de los números pares

In[4]:

numeros_pares_cuadrados = []
for numero in numeros_pares:
    numeros_pares_cuadrados.append(numero ** 2)
print(numeros_pares_cuadrados)

[0, 4, 16, 36, 64, 100, 144, 196, 256, 324, 400, 484, 576, 676, 784, 900, 1024, 1156, 1296, 1444, 1600, 1764, 1936, 2116, 2304, 2500, 2704, 2916, 3136, 3364, 3600, 3844, 4096, 4356, 4624, 4900, 5184, 5476, 5776, 6084, 6400, 6724, 7056, 7396, 7744, 8100, 8464, 8836, 9216, 9604]

Calcular la suma total de los números pares pares

In[5]:

# calculate total
total = 0
for numero in numeros_pares_cuadrados:
   total += numero
print(total)

161700

Usando list comprehension

Ahora se repitirán los cáculos usando list comprehension en vez de ciclos.

Filtrar números pares de la lista

In[6]:

numeros_pares = [numero for numero in numeros if numero % 2 == 0] 
print(numeros_pares)

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98]

Calcular el cuadrado de los números pares

In[7]:

numeros_pares_cuadrados = [numero ** 2 for numero in numeros_pares]
print(numeros_pares_cuadrados)

Calcular la suma total de los números pares pares

In[8]:

# calculate total
total = sum([numero for numero in numeros_pares_cuadrados])
print(total)

161700

Usando map, filter y reduce

Definiciones

map: Aplicar el mismo conjunto de pasos a cada elemento, almacenando el resultado. map(función,lista)
filter: aplicar criterio de validación y almacene elementos que evalúen True ese criterio. filter(función,lista)
reduce: devuelve un valor que se pasa de un elemento a otro. reduce(función,lista)

Para el caso de la función que se le pasa es necesario mencionar que se usará a lambda.

Acá coloco un ejemplo sencillo de lambda que calcula la suma de dos números: In[9]:

suma = lambda x,y: x+y 
print(suma(1,2))

Filtrar números pares de la lista

Se tiene un lambda que se le pasa de argumento x, y se evalua si es un número par, a filter se le pasa el lambda y la lista de números a filtrar.

In[10]:

numeros_pares = list(filter(lambda x: (x % 2 == 0), numeros))
print(numeros_pares)

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98]

Calcular el cuadrado de los números pares

En este caso se usa map, el cual se tiene un lambda que tiene de argumento x, y se calcula el cuadrado de x, a map se le pasa la lista de números pares.

In[11]:

numeros_pares_cuadrados = list(map(lambda x: (x ** 2), numeros_pares))
print(numeros_pares_cuadrados)

Calcular la suma total de los números pares pares

Para este caso se tiene que importar reduce de la biblioteca functools.

El lambda requiere un acumulador y un valor n, la cual se suman. A reduce se le pasa el lambda y la lista de números pares cuadrados.

In[12]:

from functools import reduce

total = reduce(lambda acc, n: acc + n, numeros_pares_cuadrados)
print(total)

161700

Como se muestra en la serie de ejemplos, puede ser innecesario, dependiendo del caso que se necesite usar for o while para crear una lista o tener un resultado de una lista, se puede usar list comprehension o filter, map y reduce. Esto hace que pueda ser más rápido el código que se esté desarrollando.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Usar memcached para tener datos a la mano

2019-09-22T10:33:00-04:00

En este artículo se explicará la razón de uso de memcached, como se instala y como se usa desde Python.

En la siguiente figura se muestra una aplicación que obtiene los datos de una base de datos (lenta), acá se tiene el problema cuando se consulta la base de datos y dependiendo de la cantidad de consultas puede ser que en algún momento la consulta llegue vacía. Lo otro es que si tienes que traer los mismos datos varias veces, para ello en ambos casos se hace necesario usar memcached.

En la siguiente figura se muestra la incorporación de memcached y usarlo junto a la base de datos, para "cachear" los datos de la base de datos.

Este artículo se basa en un artículo de memcached de realpython.

Instalación de memcached

Para el caso de Debian y derivados de Debian se usa apt para instalar memcached:

apt-get install memcached

En el caso de Redhat, Fedora, Centos se tiene:

yum install memcached

Instalación de la librería para Python, para este caso se usa pip:

pip install pymemcache

Se ejecuta memcached:

memcached

El código

A continuación se muestra el código de ejemplo de uso de pymemcache:

#!/usr/bin/env python3

#Se importa el cliente de memcached
from pymemcache.client import base


#Se conecta al servidor memcached
client = base.Client(('localhost', 11211))

#Se almacena en memcached una variable y un valor
client.set('variable', 'valor')

#Se almacena otro valor
client.set("entero",1)

#Se almacena otro
client.set("booleano",True)
variable = str(client.get('variable'))
entero = int(client.get('entero'))
booleano = bool(client.get('booleano'))

#se ve el tipo de las variables
print(type(client.get('variable')))
print(type(client.get('entero')))
print(type(client.get('booleano')))


#Se muestra el resultado tomando los datos de memcached
print(f"variable: {type(variable)}, {variable}")
print(f"entero: {type(entero)}, {entero}")
print(f"booleano: {type(booleano)},{booleano}")

Resultado

La salida del script (mem1.py), se mostró anteriormente se muestra a continuación:

<class 'bytes'>
<class 'bytes'>
<class 'bytes'>
variable: <class 'str'>, b'valor'
entero: <class 'int'>, 1
booleano: <class 'bool'>,True

Como se muestra en la salida, las variables almacenadas en memcached, al obtener sus valores son todos del tipo bytes, toca convertirlos para que sea manipulados en el código.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Crear entorno de desarrollo para Ciencia de Datos con Anaconda, Jupyter, git y cookiecutter

2019-07-28T12:20:00-04:00

Desde hace un tiempo he trabajado manipulando datos y es un lío tener los archivos de los datos organizados, tanto la entrada de datos, archivos de datos intermedios y los datos definitivos, además de tener versionado los notebooks de jupyter. La idea de este artículo es dar una guía de organizar los datos y los notebooks, así como las herramientas necesarias, en próximos artículos se tocará el tema de integración continua y el de la gestión de pipeline de datos (Data Pipeline management).

Lo primero que se tiene que hacer es crear un repositorio en github (artículo de como crear repositorio).

Creando repositorio datadev:

Repositorio datadev creado:

Se clona el repositorio (este paso se descarta al usar cookiecutter):

git clone git@github.com:ecrespo/datadev.git

Instalar Anaconda

Anaconda es una distribución de Python dedicada al computo científico o ciencia de datos. Para el caso de Linux se puede descargar del siguiente enlace Python 3.7.

Para instalar se ejecuta el siguiente comando:

bash Anaconda3-2019.07-Linux-x86_64.sh

Crear el entorno de trabajo de anaconda

Se crea un entorno llamado datadev:

conda create -n datadev

Para activar el entorno se ejecuta:

conda activate datadev

Para desactivarlo:

conda deactivate

Al activarlo se tiene el siguiente prompt:

(datadev) ernesto@jewel:~/proyectos/datadev$

Se agrega el canal conda-forge:

conda config --env --add channels conda-forge

Verificar que el canal se ha agregado:

conda config --show channels
channels:
  - conda-forge
  - defaults

Instalar paquetes básicos:

conda install pandas scikit-learn matplotlib notebook jupyter numpy

Instalar paquetes que no se encuentran en conda-forge:

conda install -c plotly plotly_express

Se inicia jupyter notebook:

jupyter notebook

Esto abre el navegador en el jupyter notebook:

Se instala cookiecutter

Se ejecuta el instalador de anaconda para instalar cookiecutter.

 conda install cookiecutter

Se crea el proyecto de ciencia de datos:

Se ejecuta fuera del repositorio datadev, con nombre datadev.

 cookiecutter https://github.com/drivendata/cookiecutter-data-science

Esto genera unas preguntas para crear los directorios:

Esto crea la siguiente estructura de directorios y archivos:

.
├── data
│   ├── external                          <- Data de fuentes de 3eras partes
│   ├── interim                           <- Datos intermedios que han sido transformados
│   ├── processed                         <- Datos procesados, que serán usados para el modelo
│   └── raw                               <- Data cruda, datos descargados sin modificar
├── docs                                  <- Default proyecto sphinx
│   ├── commands.rst
│   ├── conf.py
│   ├── getting-started.rst
│   ├── index.rst
│   ├── make.bat
│   └── Makefile
├── LICENSE                               
├── Makefile                              <- Archivo makefile con comandos como make data o make train
├── models                                <- Modelos entrados o serializados, predicciones
├── notebooks                             <- Notebooks de jupyter
├── README.md         
├── references                            <- Diccionario de datos, manuales, y cualquier otro material explicativo
├── reports                               <- análisis generados como pdf, html, latex, etc
│   └── figures                           <- Gráficas generadas a hacer usados en los reportes
├── requirements.txt                      <- lista de paquetes requeridos para reproducir el entorno, pip freeze > requirements.txt
├── setup.py                              <- Hace este proyecto instalable con pip install -e
├── src                                   <- Código fuente de este proyecto
│   ├── data                              <-Scripts para descargar o generar datos
│   │   ├── __init__.py
│   │   └── make_dataset.py
│   ├── features                          <- Scripts para convertir la data cruda a datos para el modelo
│   │   ├── build_features.py
│   │   └── __init__.py
│   ├── __init__.py
│   ├── models                            <- Scripts para entrenar el modelo y luego hacer predicciones
│   │   ├── __init__.py
│   │   ├── predict_model.py
│   │   └── train_model.py
│   └── visualization                     <- Scripts para crear exploración y resultados orientados a la visualización
│       ├── __init__.py
│       └── visualize.py
├── test_environment.py
└── tox.ini                               <- Archivo tox con configuraciones para correr tox

Instalar requerimientos adicionales:

pip install -r requirements.txt

Crear archivo yml del entorno Anaconda

Para crear el archivo yml se ejecuta el siguiente comando:

conda env export > environment.yml

Esto genera un archivo yml con el contenido del entorno datadev:

name: datadev
channels:
  - plotly
  - conda-forge
  - defaults
dependencies:
  - _libgcc_mutex=0.1=main
  - arrow=0.14.3=py37_0
  - asn1crypto=0.24.0=py37_1003
  - attrs=19.1.0=py_0
  - backcall=0.1.0=py_0
  - binaryornot=0.4.4=py_1
  - bleach=3.1.0=py_0
  - bzip2=1.0.8=h516909a_0
  - ca-certificates=2019.6.16=hecc5488_0
  - certifi=2019.6.16=py37_1
  - cffi=1.12.3=py37h8022711_0
  - chardet=3.0.4=py37_1003
  - click=7.0=py_0
  - cookiecutter=1.6.0=py37_1000
  - cryptography=2.7=py37h72c5cf5_0
  - cycler=0.10.0=py_1
  - dbus=1.13.6=he372182_0
  - decorator=4.4.0=py_0
  - defusedxml=0.5.0=py_1
  - entrypoints=0.3=py37_1000
  - expat=2.2.5=he1b5a44_1003
  - fontconfig=2.13.1=h86ecdb6_1001
  - freetype=2.10.0=he983fc9_0
  - future=0.17.1=py37_1000
  - gettext=0.19.8.1=hc5be6a0_1002
  - glib=2.58.3=h6f030ca_1002
  - gst-plugins-base=1.14.5=h0935bb2_0
  - gstreamer=1.14.5=h36ae1b5_0
  - icu=64.2=he1b5a44_0
  - idna=2.8=py37_1000
  - ipykernel=5.1.1=py37h5ca1d4c_0
  - ipython=7.7.0=py37h5ca1d4c_0
  - ipython_genutils=0.2.0=py_1
  - ipywidgets=7.5.0=py_0
  - jedi=0.14.1=py37_0
  - jinja2=2.10.1=py_0
  - jinja2-time=0.2.0=py_2
  - joblib=0.13.2=py_0
  - jpeg=9c=h14c3975_1001
  - json5=0.8.5=py_0
  - jsonschema=3.0.1=py37_0
  - jupyter=1.0.0=py_2
  - jupyter_client=5.3.1=py_0
  - jupyter_console=6.0.0=py_0
  - jupyter_core=4.4.0=py_0
  - jupyterlab=1.0.4=py37_0
  - jupyterlab_server=1.0.0=py_1
  - kiwisolver=1.1.0=py37hc9558a2_0
  - libblas=3.8.0=10_openblas
  - libcblas=3.8.0=10_openblas
  - libffi=3.2.1=he1b5a44_1006
  - libgcc-ng=9.1.0=hdf63c60_0
  - libgfortran-ng=7.3.0=hdf63c60_0
  - libiconv=1.15=h516909a_1005
  - liblapack=3.8.0=10_openblas
  - libopenblas=0.3.6=h6e990d7_5
  - libpng=1.6.37=hed695b0_0
  - libsodium=1.0.17=h516909a_0
  - libstdcxx-ng=9.1.0=hdf63c60_0
  - libuuid=2.32.1=h14c3975_1000
  - libxcb=1.13=h14c3975_1002
  - libxml2=2.9.9=hee79883_2
  - markupsafe=1.1.1=py37h14c3975_0
  - matplotlib=3.1.1=py37_1
  - matplotlib-base=3.1.1=py37he7580a8_1
  - mistune=0.8.4=py37h14c3975_1000
  - nbconvert=5.5.0=py_0
  - nbformat=4.4.0=py_1
  - ncurses=6.1=hf484d3e_1002
  - notebook=6.0.0=py37_0
  - numpy=1.16.4=py37h95a1406_0
  - openblas=0.3.6=h6e990d7_5
  - openssl=1.1.1c=h516909a_0
  - pandas=0.25.0=py37hb3f55d8_0
  - pandoc=2.7.3=0
  - pandocfilters=1.4.2=py_1
  - parso=0.5.1=py_0
  - patsy=0.5.1=py_0
  - pcre=8.41=hf484d3e_1003
  - pexpect=4.7.0=py37_0
  - pickleshare=0.7.5=py37_1000
  - pip=19.2.1=py37_0
  - plotly=4.0.0=py_0
  - plotly_express=0.4.0=py_0
  - poyo=0.5.0=py_0
  - prometheus_client=0.7.1=py_0
  - prompt_toolkit=2.0.9=py_0
  - pthread-stubs=0.4=h14c3975_1001
  - ptyprocess=0.6.0=py_1001
  - pycparser=2.19=py37_1
  - pygments=2.4.2=py_0
  - pyopenssl=19.0.0=py37_0
  - pyparsing=2.4.1.1=py_0
  - pyqt=5.9.2=py37hcca6a23_0
  - pyrsistent=0.15.4=py37h516909a_0
  - pysocks=1.7.0=py37_0
  - python=3.7.3=h33d41f4_1
  - python-dateutil=2.8.0=py_0
  - pytz=2019.1=py_0
  - pyzmq=18.0.2=py37h1768529_2
  - qt=5.9.7=h0c104cb_3
  - qtconsole=4.5.2=py_0
  - readline=8.0=hf8c457e_0
  - requests=2.22.0=py37_1
  - retrying=1.3.3=py_2
  - scikit-learn=0.21.2=py37hcdab131_1
  - scipy=1.3.0=py37h921218d_1
  - send2trash=1.5.0=py_0
  - setuptools=41.0.1=py37_0
  - sip=4.19.8=py37hf484d3e_1000
  - six=1.12.0=py37_1000
  - sqlite=3.29.0=hcee41ef_0
  - statsmodels=0.10.1=py37hc1659b7_0
  - terminado=0.8.2=py37_0
  - testpath=0.4.2=py_1001
  - tk=8.6.9=hed695b0_1002
  - tornado=6.0.3=py37h516909a_0
  - traitlets=4.3.2=py37_1000
  - urllib3=1.25.3=py37_0
  - wcwidth=0.1.7=py_1
  - webencodings=0.5.1=py_1
  - wheel=0.33.4=py37_0
  - whichcraft=0.6.0=py_0
  - widgetsnbextension=3.5.0=py37_0
  - xorg-libxau=1.0.9=h14c3975_0
  - xorg-libxdmcp=1.1.3=h516909a_0
  - xz=5.2.4=h14c3975_1001
  - zeromq=4.3.2=he1b5a44_2
  - zlib=1.2.11=h516909a_1005
  - pip:
    - alabaster==0.7.12
    - awscli==1.16.207
    - babel==2.7.0
    - botocore==1.12.197
    - colorama==0.3.9
    - coverage==4.5.3
    - docutils==0.15.1
    - flake8==3.7.8
    - imagesize==1.1.0
    - jmespath==0.9.4
    - mccabe==0.6.1
    - packaging==19.0
    - pyasn1==0.4.5
    - pycodestyle==2.5.0
    - pyflakes==2.1.1
    - python-dotenv==0.10.3
    - pyyaml==5.1
    - rsa==3.4.2
    - s3transfer==0.2.1
    - snowballstemmer==1.9.0
    - sphinx==2.1.2
    - sphinxcontrib-applehelp==1.0.1
    - sphinxcontrib-devhelp==1.0.1
    - sphinxcontrib-htmlhelp==1.0.2
    - sphinxcontrib-jsmath==1.0.1
    - sphinxcontrib-qthelp==1.0.2
    - sphinxcontrib-serializinghtml==1.1.3
prefix: /home/ernesto/anaconda3/envs/datadev

Lo bueno es que este archivo maneja los paquetes instalados por anaconda como por pip.

Para usar el archivo yml se ejecuta:

conda env create -f environment.yml -p /home/user/anaconda3/envs/env_name

Donde la opción -p es para definir la ruta donde se instala el entorno.

Git

Para terminar el artículo se asocia el directorio datadev al repositorio que se creó en github o gitlab.

Se ejecuta git init dentro del directorio de datadev:

git init

Se agrega el repositorio al repo local:

bash git remote add origin https://github.com/ecrespo/datadev.git

Se define la rama master y repositorio origin a subir:

bash git push --set-upstream origin master

Con esto se tiene un entorno de trabajo, en siguientes artículos se irá mostrando otras herramientas a usar en el entorno.

Al final el repositorio en github queda como se muestra a continuación:

Referencias:

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Validando un API rest asíncrono con Cerberus

2019-06-08T19:33:00-04:00

En este artículo se mostrará como crear un API rest asincrono usando aiohttp, se usará un script para acceder a la base de datos NoSQL RethinkDB de manera asíncrona, y 2 formas de validar la entrada de datos del API, la primera evaluando cada variable, la segunda se usará cerberus donde se tiene un esquema de la entrada de datos y por último la tercera, usará cerberus pero el esquema estará guardado en rethinkdb.

El repositorio del código completo de este tutorial se encuentra en github.

Este artículo se basa en el artículo Using Data Validation for Robust APIs y en el artículo How to create REST API using aiohttp, donde se explica como hacer un API rest sincrónico con aiohttp.

La documentación de cerberus la pueden ver en el siguiente cerberus.

Se tiene la siguiente estructura de directorios y archivos del API rest:

async-api-rest-example
├── app.py
├── README.md
├── resources
│   ├── api_resources.py
│   ├── home.py
│   ├── __init__.py
│   └── rethink_async.py
└── run.py

Descripción de los archivos:

app.py: Se definen las rutas de los endpoint del API rest.
run.py: Script que permite correr el API rest.
resources/rethin_async.py: Módulo que permite acceder de manera asíncrona a rethinkdb.
resources/home.py: Página de inicio del API rest.
resources/api_resources.py: Donde se define los métodos HTTP del API rest.

Script run.py

Este script permite iniciar el API rest, a continuación el código:

#!/usr/bin/env python3

#Se importa aiohttp
from aiohttp import web

#Se importa las rutas de los endpoint
from app import setup_routes



async def init_app():
    #Se instancia la aplicación
    app = web.Application()
    #A la aplicación se le pasa las rutas
    setup_routes(app)
    #Se retorna la aplicación
    return app


def main():
    #Se define la dirección del host, el puerto y se corre la Ap en dicha IP y puerto
    host = '0.0.0.0'
    port = 5000
    app = init_app()

    web.run_app(app,host=host, port=port)



if __name__ == '__main__':
    main()

Script app.py

Este script define las rutas y URLs de los endpoint del API rest. A continuación el código:

#Se importa los recursos del api rest y el home .
from resources.api_resources import Student
from resources.home import getIndex





def setup_routes(app):
    student = Student()
    #Se tiene 3 endpoints, el primero validación clásica,
    # el segundo validando con cerberus, y el 3ero con cerberus
    #pero guardando el esquema de validación en una base de datos
    app.router.add_post('/api/v1/student1',student.getData1)
    app.router.add_post('/api/v1/student2',student.getData2)
    app.router.add_post('/api/v1/student3',student.getData3)
    #Por seguridad no se permite ingresar a la raiz del API rest
    app.router.add_get('/api/v1/', getIndex)
    app.router.add_get('/', getIndex)

Script rethink_async.py

#!/usr/bin/env python3

import rethinkdb as r
import asyncio
from datetime import datetime


r.set_loop_type("asyncio")


async def createDB(server,port,database):
    """
    Create DB to database server.

    Parameters
    ----------
    server: IP server to connect
    port: Port server to connect
    database: Database name to create

    """
    conn = await r.connect(server, port)
    if database not in await r.db_list().run(conn):
        return await r.db_create(database).run(conn)



async def createTable(server,port,database,table):
    """
    Create Table in database.

    Parameters
    ----------
    server: IP server to connect
    port: Port server to connect
    database: Database name to connect
    """
    conn = await r.connect(server, port)
    return await r.db(database).table_create(table).run(conn)


async def listdb(server,port):
    """
    List all database in database server.


    Parameters
    ----------
    server: IP server to connect
    port: Port server to connect
    """
    conn = await r.connect(server, port)
    return await r.db_list(conn)


async def listtables(server,port,database):
    """
    Lista tables from database.

    Parameters
    ----------
    server: IP server to connect
    port: Port server to connect
    database: Database name to list tables
    """
    conn = await r.connect(server, port)
    return await r.db(database).table_list().run(conn)


async def insert(server,port,database,table,data):
    """
    Insert dictionary  in table.

    Parameters
    ----------
    server: IP server to connect
    port: Port server to connect
    database: Database name to connect
    table: table to insert Dictionary
    data: Dictionary data to insert
    """
    conn = await r.connect(server, port)
    result = await r.db(database).table(table).insert(data).run(conn)
    await conn.close()
    return result




async def getAll(server,port,database,table,pattern=None):
    """
    Get All documents from pattern search

    Parameters
    ----------
    server: IP server to connect
    port: Port server to connect
    database: Database name to connect
    table: table name to search
    pattern: Dictionary with pattern search
    """
    conn = await r.connect(server, port)
    if pattern == None:
        cursor = await r.db(database).table(table).run(conn)
    else:
        cursor = await r.db(database).table(table).filter(pattern).run(conn)
    elements = list()

    while (await cursor.fetch_next()):
        item = await cursor.next()
        elements.append(item)

    await conn.close()

    return elements


async def getFirst(server, port, database, table, pattern = None):
    """
    Get first document from pattern search

    Parameters
    ----------
    server: IP server to connect
    port: Port server to connect
    database: Database name to connect
    table: table name to search
    pattern: Dictionary with pattern search
    """
    conn = await r.connect(server, port)
    if pattern == None:
        cursor = await r.db(database).table(table).run(conn)
    else:
        cursor = await  r.db(database).table(table).filter(pattern).run(conn)
    elements = list()

    while (await  cursor.fetch_next()):
        item = await cursor.next()
        elements.append(item)
        break
    await conn.close()
    return elements


async def delete(server,port,database,table,pattern):
    """
    Delete a  document from pattern search

    Parameters
    ----------
    server: IP server to connect
    port: Port server to connect
    database: Database name to connect
    table: table name to search
    pattern: Dictionary with pattern search
    """
    conn = await r.connect(server, port)
    result =  await r.db(database).table(table).filter(pattern).delete().run(conn)
    await conn.close()
    return result


async def update(server,port,database,table,data,pattern=None):
    """
    Update a document from pattern search

    Parameters
    ----------
    server: IP server to connect
    port: Port server to connect
    database: Database name to connect
    table: table name to search
    pattern: Dictionary with pattern search
    """
    conn = await r.connect(server, port)
    if (type(data) == type(dict())):
        if pattern == None :
            result = await r.db(database).table(table).update(data).run(conn)
            await conn.close()
            return result
        else:
            result =  await r.db(database).table(table).filter(pattern).update(data).run(conn)
            await conn.close()
            return result

Script api_resouces.py

En el script se tienen 3 métodos:

getData1: Este método válida cada una de las entrada de datos.
getData2: Este método válida la entrada de datos con un esquema validando con cerberus.
getData3: Este método vuelve a usar cerberus pero ahora tomando el esquema a validar usando rethinkdb.

A continuación se muestra el código:

import json
from aiohttp import web
from cerberus import Validator
import rethinkdb as r

from .rethink_async import *

__version__ = '0.0.1'


student_schema = {
    'uid': {
        'required': True,
        'type': 'integer',
    },
    'age': {
        'required': True,
        'type': 'integer',
        'min': 18,
        'max': 35,
    },
    'name': {
        'required': True,
        'type': 'string',
        'maxlength': 50,
    },
    'grade': {
        'required': False,
        'type': 'string',
        'allowed': ['A', 'B', 'C'],
    }
}


class Student(object):

    def __init__(self):
        pass

    async def getData1(self,request):

        #Se convierte el json a un diccionario

        try:
            data = json.loads(await request.text())
        except json.JSONDecodeError:
            response_obj = {'status': 'failed', 'reason': "Ill-formed JSON"}
            return web.Response(text=json.dumps(response_obj), status=205)

        #Se valida los datos de entrada
        try:
            uid = int(data['uid'])
        except (KeyError, ValueError):
            response_obj = {'status': 'failed', 'reason': "Expecting uid:int"}
            return web.Response(text=json.dumps(response_obj), status=205)

        try:
            age = int(data['age'])
            if not 18 < age < 35:
                raise ValueError('Bad age')
        except (KeyError, ValueError):
            response_obj = {'status': 'failed', 'reason': "Expecting age:int within the range [18:35]"}
            return web.Response(text=json.dumps(response_obj), status=205)

        try:
            name = str(data['name'])
            if len(name) > 50:
                raise ValueError('Max limit 50')
        except (KeyError, ValueError):
            response_obj = {'status': 'failed', 'reason': "Expecting name:str within the range [0:50]"}
            return web.Response(text=json.dumps(response_obj), status=205)

        try:
            grade = data.get('grade')
            if grade is None:
                grade = 'A'
            if grade not in ('A', 'B', 'C'):
                response_obj = {'status': 'failed', 'reason': "A, B or C expected"}
                return web.Response(text=json.dumps(response_obj), status=205)
        except (KeyError, ValueError):
            response_obj = {'status': 'failed', 'reason': "Expecting grade:str A, B or C expected"}
            return web.Response(text=json.dumps(response_obj), status=205)

        #Luego de validar se construye el diccionario de salida de datos como json

        data_output = dict()
        data_output['uid'] = data['uid']
        data_output['age'] = data['age']
        data_output['name'] = data['name']
        data_output['grade'] = data.get('grade', 'A')

        response_obj = {
            'status': 'success',
            'data': data_output
        }
        return web.Response(text=json.dumps(response_obj), status=200, content_type='application/json')



    async def getData2(self,request):

        #Se convierte el json del post en un diccionario
        try:
            data = json.loads(await request.text())
        except json.JSONDecodeError:
            response_obj = {'status': 'failed', 'reason': "Ill-formed JSON"}
            return web.Response(text=json.dumps(response_obj), status=205)

        #Con la variable que contiene el esquema se realiza la validación del json
        student_validator = Validator(student_schema)
        if not student_validator.validate(data):
            msg = student_validator.errors
            response_obj = {'status': 'failed', 'reason': msg}
            return web.Response(text=json.dumps(response_obj), status=205)

        #Se construye el diccionario de la salida de los datos vía json
        data_output = dict()
        data_output['uid'] = data['uid']
        data_output['age'] = data['age']
        data_output['name'] = data['name']
        data_output['grade'] = data.get('grade', 'A')

        response_obj = {
            'status': 'success',
            'data': data_output
        }
        return web.Response(text=json.dumps(response_obj), status=200, content_type='application/json')


    async def getData3(self,request):

        #Se convierte el json en un diccionario
        try:
            data = json.loads(await request.text())
        except json.JSONDecodeError:
            response_obj = {'status': 'failed', 'reason': "Ill-formed JSON"}
            return web.Response(text=json.dumps(response_obj), status=205)

        #Si yo se, no debería tener  la configuración de la base de datos acá,
        #pero era para no alargar el código de ejemplo
        #Se definen el servidor, puerto, base de datos, la tabla y el patrón de busqueda
        server = "localhost"
        port = 28015
        db = "student"
        table = "student_schema"
        pattern = {"endpoint": "student3"}

        #Se realiza la consulta a rethinkdb de manera asincrona
        student_schemadb = await getFirst(server, port, db, table, pattern)

        #Se quitan del diccionario el id y el endpoint a fin de realizar la evaluación del esquema
        student_schema = {item: student_schemadb[0][item] for item in list(student_schemadb[0].keys()) if item != 'id'}
        student_schema = {item: student_schema[item] for item in list(student_schema.keys()) if item != 'endpoint'}

        #Se valida el esquema con los datos suministrados vía post
        student_validator = Validator(student_schema)
        if not student_validator.validate(data):
            msg = student_validator.errors
            response_obj = {'status': 'failed', 'reason': msg}
            return web.Response(text=json.dumps(response_obj), status=205)

        #Se toman los datos y se colocan en el diccionario para el json de salida
        data_output = dict()
        data_output['uid'] = data['uid']
        data_output['age'] = data['age']
        data_output['name'] = data['name']
        data_output['grade'] = data.get('grade', 'A')

        response_obj = {
            'status': 'success',
            'data': data_output
        }
        return web.Response(text=json.dumps(response_obj), status=200, content_type='application/json')

Base de datos rethinkdb con el esquema para cerberus

Para que el método getData3 funcione es necesario tener almacenado en la base de datos rethinkdb el esquema.

El proceso de instalación de rethinkDB vía docker, se deja en el siguiente artículo de platzi.

Para insertar los datos se ejecuta en el dashboard de rethinkDB (http://localhost:8080) el siguiente comando:

r.db("student").table("student_schema").insert({id:1,endpoint: 'student3',uid: {
        'required': true,
        'type': 'integer'},
    age: {
        'required': true,
        'type': 'integer',
        'min': 18,
        'max': 35
    },
    name: {
        'required': true,
        'type': 'string',
        'maxlength': 50
    },
    grade: {
        'required': false,
        'type': 'string',
        'allowed': ['A', 'B', 'C']
  }})

De esa forma se inserta los datos en la tabla.

Para consultar la tabla vía dashboard se ejecuta:

r.db("student").table("student_schema")

A continuación se muestra la tabla:

Iniciar el API rest.

Para iniciar el API rest se tiene que tener instalado la librería rethinkdb y aiohttp:

pip install rethinkdb aiohttp

Luego de instalada se ejecuta el script run.py:

python run.py

Si se tiene la siguiente salida el API rest está corriendo sin problemas:

======== Running on http://0.0.0.0:5000 ========
(Press CTRL+C to quit)

Consultas al API rest

Para consultar el API rest se puede usar insomia o postman, ambos son clientes API rest.

Se tienen 3 endpoint todos vía método post que se le pasará un json como el siguiente:

{
  "uid": 42,
  "age": 25,
  "name": "John Doe",
  "grade": "A"
}

Los urls son los siguientes:

http://localhost:5000/api/v1/student1 : Usa el método getData1.
http://localhost:5000/api/v1/student2 : Usa el método getData2.
http://localhost:5000/api/v1/student3 : Usa el método getData3.

Primer endpoint:

Se realiza la consulta con el json mostrado anteriormente:

Ahora se modifica por ejemplo la variable grade a X:

En este caso el valor X para la variable grade no es válido.

Segundo endpoint:

En este caso se usa cerberus y la variable que contiene el esquema para validar:

Se realiza la consulta con el json original:

Ahora se realiza la consulta modificando la variable grade con el valor de Z:

El mensaje es más genérico no es el que se definió en el primer método.

Tercer endpoint:

Acá no se verán cambios significativos en la consulta, lo interesante es que, al tener muchos endpoint con distintas entradas de datos, lo mejor es usar una base de datos donde se tenga almacenada cada esquema por endpoint.

Así que el resultado sería el mismo que los del segundo endpoint.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Cómo usar el API de wikipedia con Python

2019-06-08T11:33:00-04:00

Retomando la escritura de artículos, ahora usando pelican y github pages.

Hoy se tocará el tema de como acceder a la Wikipedia vía su API desde Python.

Este artículo se basa del artículo de Stack Abuse Getting Started with Python's Wikipedia API.

Instalación y prueba del API de Wikipedia

Lo primero que se tiene que hacer es realizar la instalación de la librería de wikipedia para Python:

pip install wikipedia

Para probar que funciona el API, desde la consola de python se importa wikipedia:

import wikipedia

Consultas al API

Por defecto el API de Wikipedia realiza las busquedas en inglés.

Para empezar, se puede realizar una busqueda de una palabra, por ejemplo Venezuela:

print(wikipedia.search("Venezuela"))
['Venezuela', 'Venezuelans', 'Economy of Venezuela', 'Caracas', 'Venezuela national football team', 'President of Venezuela', 'Crisis in Venezuela', 'Mestizos in Venezuela', 'List of Presidents of Venezuela', 'Crime in Venezuela']

Devuelve una lista con una serie de palabras o frases sobre Venezuela.

Se puede limitar el resultado de la busqueda a por ejemplo 3:

print(wikipedia.search("Venezuela", results=3))
['Venezuela', 'Venezuelans', 'Economy of Venezuela']

Ahora se puede buscar sobre Linux:

print(wikipedia.search("Linux"))
['Linux', 'Linux kernel', 'Linux distribution', 'List of Linux distributions', 'Kali Linux', 'Astra Linux', 'Linux Mint', 'Red Hat Enterprise Linux', 'Ubuntu', 'Arch Linux']

Existe el método suggest que ayuda a la busqueda si colocamos mal la palabra de busqueda, por ejemplo, se puede buscar "Simon Boliva" y método devolverá el nombre correcto "Simón Bolivar":

>>> print(wikipedia.suggest("Simon Boliva"))
simon bolivar

Extraer un resumen de un artículo de wikipedia

Para extraer un resumen de un artículo se usa el método summary:

print(wikipedia.summary("Debian"))  
Debian () is a Unix-like operating system consisting entirely of free software. Ian Murdock founded the Debian Project on August 16, 1993. Debian 0.01 was released on September 15, 1993, and the first stable version, 1.1, was released on June 17, 1996. The Debian Stable branch is the most popular edition for personal computers and network servers, and is used as the basis for many other Linux distributions.
Debian is one of the earliest operating systems based on the Linux kernel. The project is coordinated over the Internet by a team of volunteers guided by the Debian Project Leader and three foundational documents: the Debian Social Contract, the Debian Constitution, and the Debian Free Software Guidelines. New distributions are updated continually, and the next candidate is released after a time-based freeze.
Debian has been developed openly and distributed freely according to the principles of the GNU Project. Because of this, the Free Software Foundation sponsored the project from November 1994 to November 1995. The popular Linux operating system Ubuntu was also released based on Debian. When the sponsorship ended, the Debian Project formed the nonprofit Software in the Public Interest to continue financially supporting development.

Se puede delimitar la cantidad de texto que se muestre con la opción sentences, que en este caso lo colocaremos en 3:

print(wikipedia.summary("Debian", sentences=3))  
Debian () is a Unix-like operating system consisting entirely of free software. Ian Murdock founded the Debian Project on August 16, 1993. Debian 0.01 was released on September 15, 1993, and the first stable version, 1.1, was released on June 17, 1996.

Noten que el contenido del artículo está en Inglés, si se quiere traer la información en otro idioma se cambia la configuración del API de la siguiente forma:

wikipedia.set_lang("es")

Ahora se vuelve a realizar la consulta anterior:

print(wikipedia.summary("Debian", sentences=3))
Debian o Proyecto Debian,[1] (en inglés, Debian Project) [2] es una comunidad conformada por desarrolladores y usuarios, que mantiene un sistema operativo GNU basado en software libre. El sistema se encuentra precompilado, empaquetado y en formato deb para múltiples arquitecturas de computador y para varios núcleos.
El proyecto Debian fue anunciado inicialmente 1993 por Ian Murdock.

Para listar los idiomas que se soporta se ejecuta el método languages(), este devuelve un diccionario con todos los lenguajes soportados en el API:

print(wikipedia.languages())
{'aa': 'Qafár af', 'ab': 'Аҧсшәа', 'abs': 'bahasa ambon', 'ace': 'Acèh', 'ady': 'адыгабзэ', 'ady-cyrl': 'адыгабзэ', 'aeb': 'تونسي/Tûnsî', 'aeb-arab': 'تونسي', 'aeb-latn': 'Tûnsî', 'af': 'Afrikaans', 'ak': 'Akan', 'aln': 'Gegë', 'als': 'Alemannisch', 'am': 'አማርኛ', 'an': 'aragonés', 'ang': 'Ænglisc', 'anp': 'अङ्गिका', 'ar': 'العربية', 'arc': 'ܐܪܡܝܐ', 'arn': 'mapudungun', 'arq': 'جازايرية', 'ary': 'Maġribi', 'arz': 'مصرى', 'as': 'অসমীয়া', 'ase': 'American sign language', 'ast': 'asturianu', 'atj': 'Atikamekw', 'av': 'авар', 'avk': 'Kotava', 'awa': 'अवधी', 'ay': 'Aymar aru', 'az': 'azərbaycanca', 'azb': 'تۆرکجه', 'ba': 'башҡортса', 'ban': 'Basa Bali', 'bar': 'Boarisch', 'bat-smg': 'žemaitėška', 'bbc': 'Batak Toba', 'bbc-latn': 'Batak Toba', 'bcc': 'جهلسری بلوچی', 'bcl': 'Bikol Central', 'be': 'беларуская', 'be-tarask': 'беларуская (тарашкевіца)\u200e', 'be-x-old': 'беларуская (тарашкевіца)\u200e', 'bg': 'български', 'bgn': 'روچ کپتین بلوچی', 'bh': 'भोजपुरी', 'bho': 'भोजपुरी', 'bi': 'Bislama', 'bjn': 'Bahasa Banjar', 'bm': 'bamanankan', 'bn': 'বাংলা', 'bo': 'བོད་ཡིག', 'bpy': 'বিষ্ণুপ্রিয়া মণিপুরী', 'bqi': 'بختیاری', 'br': 'brezhoneg', 'brh': 'Bráhuí', 'bs': 'bosanski', 'btm': 'Batak Mandailing', 'bto': 'Iriga Bicolano', 'bug': 'ᨅᨔ ᨕᨘᨁᨗ', 'bxr': 'буряад', 'ca': 'català', 'cbk-zam': 'Chavacano de Zamboanga', 'cdo': 'Mìng-dĕ̤ng-ngṳ̄', 'ce': 'нохчийн', 'ceb': 'Cebuano', 'ch': 'Chamoru', 'cho': 'Choctaw', 'chr': 'ᏣᎳᎩ', 'chy': 'Tsetsêhestâhese', 'ckb': 'کوردی', 'co': 'corsu', 'cps': 'Capiceño', 'cr': 'Nēhiyawēwin / ᓀᐦᐃᔭᐍᐏᐣ', 'crh': 'qırımtatarca', 'crh-cyrl': 'къырымтатарджа (Кирилл)\u200e', 'crh-latn': 'qırımtatarca (Latin)\u200e', 'cs': 'čeština', 'csb': 'kaszëbsczi', 'cu': 'словѣньскъ / ⰔⰎⰑⰂⰡⰐⰠⰔⰍⰟ', 'cv': 'Чӑвашла', 'cy': 'Cymraeg', 'da': 'dansk', 'de': 'Deutsch', 'de-at': 'Österreichisches Deutsch', 'de-ch': 'Schweizer Hochdeutsch', 'de-formal': 'Deutsch (Sie-Form)\u200e', 'din': 'Thuɔŋjäŋ', 'diq': 'Zazaki', 'dsb': 'dolnoserbski', 'dtp': 'Dusun Bundu-liwan', 'dty': 'डोटेली', 'dv': 'ދިވެހިބަސް', 'dz': 'ཇོང་ཁ', 'ee': 'eʋegbe', 'egl': 'Emiliàn', 'el': 'Ελληνικά', 'eml': 'emiliàn e rumagnòl', 'en': 'English', 'en-ca': 'Canadian English', 'en-gb': 'British English', 'eo': 'Esperanto', 'es': 'español', 'es-419': 'español de América Latina', 'es-formal': 'español (formal)\u200e', 'et': 'eesti', 'eu': 'euskara', 'ext': 'estremeñu', 'fa': 'فارسی', 'ff': 'Fulfulde', 'fi': 'suomi', 'fit': 'meänkieli', 'fiu-vro': 'Võro', 'fj': 'Na Vosa Vakaviti', 'fo': 'føroyskt', 'fr': 'français', 'frc': 'français cadien', 'frp': 'arpetan', 'frr': 'Nordfriisk', 'fur': 'furlan', 'fy': 'Frysk', 'ga': 'Gaeilge', 'gag': 'Gagauz', 'gan': '贛語', 'gan-hans': '赣语（简体）\u200e', 'gan-hant': '贛語（繁體）\u200e', 'gcr': 'kriyòl gwiyannen', 'gd': 'Gàidhlig', 'gl': 'galego', 'glk': 'گیلکی', 'gn': "Avañe'ẽ", 'gom': 'गोंयची कोंकणी / Gõychi Konknni', 'gom-deva': 'गोंयची कोंकणी', 'gom-latn': 'Gõychi Konknni', 'gor': 'Bahasa Hulontalo', 'got': '𐌲𐌿𐍄𐌹𐍃𐌺', 'grc': 'Ἀρχαία ἑλληνικὴ', 'gsw': 'Alemannisch', 'gu': 'ગુજરાતી', 'gv': 'Gaelg', 'ha': 'Hausa', 'hak': '客家語/Hak-kâ-ngî', 'haw': 'Hawaiʻi', 'he': 'עברית', 'hi': 'हिन्दी', 'hif': 'Fiji Hindi', 'hif-latn': 'Fiji Hindi', 'hil': 'Ilonggo', 'ho': 'Hiri Motu', 'hr': 'hrvatski', 'hrx': 'Hunsrik', 'hsb': 'hornjoserbsce', 'ht': 'Kreyòl ayisyen', 'hu': 'magyar', 'hu-formal': 'magyar (formal)\u200e', 'hy': 'հայերեն', 'hyw': 'Արեւմտահայերէն', 'hz': 'Otsiherero', 'ia': 'interlingua', 'id': 'Bahasa Indonesia', 'ie': 'Interlingue', 'ig': 'Igbo', 'ii': 'ꆇꉙ', 'ik': 'Iñupiak', 'ike-cans': 'ᐃᓄᒃᑎᑐᑦ', 'ike-latn': 'inuktitut', 'ilo': 'Ilokano', 'inh': 'ГӀалгӀай', 'io': 'Ido', 'is': 'íslenska', 'it': 'italiano', 'iu': 'ᐃᓄᒃᑎᑐᑦ/inuktitut', 'ja': '日本語', 'jam': 'Patois', 'jbo': 'la .lojban.', 'jut': 'jysk', 'jv': 'Jawa', 'ka': 'ქართული', 'kaa': 'Qaraqalpaqsha', 'kab': 'Taqbaylit', 'kbd': 'Адыгэбзэ', 'kbd-cyrl': 'Адыгэбзэ', 'kbp': 'Kabɩyɛ', 'kg': 'Kongo', 'khw': 'کھوار', 'ki': 'Gĩkũyũ', 'kiu': 'Kırmancki', 'kj': 'Kwanyama', 'kjp': 'ဖၠုံလိက်', 'kk': 'қазақша', 'kk-arab': 'قازاقشا (تٴوتە)\u200f', 'kk-cn': 'قازاقشا (جۇنگو)\u200f', 'kk-cyrl': 'қазақша (кирил)\u200e', 'kk-kz': 'қазақша (Қазақстан)\u200e', 'kk-latn': 'qazaqşa (latın)\u200e', 'kk-tr': 'qazaqşa (Türkïya)\u200e', 'kl': 'kalaallisut', 'km': 'ភាសាខ្មែរ', 'kn': 'ಕನ್ನಡ', 'ko': '한국어', 'ko-kp': '조선말', 'koi': 'Перем Коми', 'kr': 'Kanuri', 'krc': 'къарачай-малкъар', 'kri': 'Krio', 'krj': 'Kinaray-a', 'krl': 'karjal', 'ks': 'कॉशुर / کٲشُر', 'ks-arab': 'کٲشُر', 'ks-deva': 'कॉशुर', 'ksh': 'Ripoarisch', 'ku': 'kurdî', 'ku-arab': 'كوردي (عەرەبی)\u200f', 'ku-latn': 'kurdî (latînî)\u200e', 'kum': 'къумукъ', 'kv': 'коми', 'kw': 'kernowek', 'ky': 'Кыргызча', 'la': 'Latina', 'lad': 'Ladino', 'lb': 'Lëtzebuergesch', 'lbe': 'лакку', 'lez': 'лезги', 'lfn': 'Lingua Franca Nova', 'lg': 'Luganda', 'li': 'Limburgs', 'lij': 'Ligure', 'liv': 'Līvõ kēļ', 'lki': 'لەکی', 'lmo': 'lumbaart', 'ln': 'lingála', 'lo': 'ລາວ', 'loz': 'Silozi', 'lrc': 'لۊری شومالی', 'lt': 'lietuvių', 'ltg': 'latgaļu', 'lus': 'Mizo ţawng', 'luz': 'لئری دوٙمینی', 'lv': 'latviešu', 'lzh': '文言', 'lzz': 'Lazuri', 'mai': 'मैथिली', 'map-bms': 'Basa Banyumasan', 'mdf': 'мокшень', 'mg': 'Malagasy', 'mh': 'Ebon', 'mhr': 'олык марий', 'mi': 'Māori', 'min': 'Baso Minangkabau', 'mk': 'македонски', 'ml': 'മലയാളം', 'mn': 'монгол', 'mni': 'মেইতেই লোন্', 'mnw': 'ဘာသာ မန်', 'mo': 'молдовеняскэ', 'mr': 'मराठी', 'mrj': 'кырык мары', 'ms': 'Bahasa Melayu', 'mt': 'Malti', 'mus': 'Mvskoke', 'mwl': 'Mirandés', 'my': 'မြန်မာဘာသာ', 'myv': 'эрзянь', 'mzn': 'مازِرونی', 'na': 'Dorerin Naoero', 'nah': 'Nāhuatl', 'nan': 'Bân-lâm-gú', 'nap': 'Napulitano', 'nb': 'norsk bokmål', 'nds': 'Plattdüütsch', 'nds-nl': 'Nedersaksies', 'ne': 'नेपाली', 'new': 'नेपाल भाषा', 'ng': 'Oshiwambo', 'niu': 'Niuē', 'nl': 'Nederlands', 'nl-informal': 'Nederlands (informeel)\u200e', 'nn': 'norsk nynorsk', 'no': 'norsk', 'nov': 'Novial', 'nqo': 'ߒߞߏ', 'nrm': 'Nouormand', 'nso': 'Sesotho sa Leboa', 'nv': 'Diné bizaad', 'ny': 'Chi-Chewa', 'nys': 'Nyunga', 'oc': 'occitan', 'olo': 'Livvinkarjala', 'om': 'Oromoo', 'or': 'ଓଡ଼ିଆ', 'os': 'Ирон', 'pa': 'ਪੰਜਾਬੀ', 'pag': 'Pangasinan', 'pam': 'Kapampangan', 'pap': 'Papiamentu', 'pcd': 'Picard', 'pdc': 'Deitsch', 'pdt': 'Plautdietsch', 'pfl': 'Pälzisch', 'pi': 'पालि', 'pih': 'Norfuk / Pitkern', 'pl': 'polski', 'pms': 'Piemontèis', 'pnb': 'پنجابی', 'pnt': 'Ποντιακά', 'prg': 'Prūsiskan', 'ps': 'پښتو', 'pt': 'português', 'pt-br': 'português do Brasil', 'qu': 'Runa Simi', 'qug': 'Runa shimi', 'rgn': 'Rumagnôl', 'rif': 'Tarifit', 'rm': 'rumantsch', 'rmy': 'romani čhib', 'rn': 'Kirundi', 'ro': 'română', 'roa-rup': 'armãneashti', 'roa-tara': 'tarandíne', 'ru': 'русский', 'rue': 'русиньскый', 'rup': 'armãneashti', 'ruq': 'Vlăheşte', 'ruq-cyrl': 'Влахесте', 'ruq-latn': 'Vlăheşte', 'rw': 'Kinyarwanda', 'sa': 'संस्कृतम्', 'sah': 'саха тыла', 'sat': 'ᱥᱟᱱᱛᱟᱲᱤ', 'sc': 'sardu', 'scn': 'sicilianu', 'sco': 'Scots', 'sd': 'سنڌي', 'sdc': 'Sassaresu', 'sdh': 'کوردی خوارگ', 'se': 'davvisámegiella', 'sei': 'Cmique Itom', 'ses': 'Koyraboro Senni', 'sg': 'Sängö', 'sgs': 'žemaitėška', 'sh': 'srpskohrvatski / српскохрватски', 'shi': 'Tašlḥiyt/ⵜⴰⵛⵍⵃⵉⵜ', 'shi-latn': 'Tašlḥiyt', 'shi-tfng': 'ⵜⴰⵛⵍⵃⵉⵜ', 'shn': 'ၽႃႇသႃႇတႆး ', 'shy-latn': 'tachawit', 'si': 'සිංහල', 'simple': 'Simple English', 'sk': 'slovenčina', 'skr': 'سرائیکی', 'skr-arab': 'سرائیکی', 'sl': 'slovenščina', 'sli': 'Schläsch', 'sm': 'Gagana Samoa', 'sma': 'Åarjelsaemien', 'sn': 'chiShona', 'so': 'Soomaaliga', 'sq': 'shqip', 'sr': 'српски / srpski', 'sr-ec': 'српски (ћирилица)\u200e', 'sr-el': 'srpski (latinica)\u200e', 'srn': 'Sranantongo', 'ss': 'SiSwati', 'st': 'Sesotho', 'stq': 'Seeltersk', 'sty': 'cебертатар', 'su': 'Basa Sunda', 'sv': 'svenska', 'sw': 'Kiswahili', 'szl': 'ślůnski', 'ta': 'தமிழ்', 'tay': 'Tayal', 'tcy': 'ತುಳು', 'te': 'తెలుగు', 'tet': 'tetun', 'tg': 'тоҷикӣ', 'tg-cyrl': 'тоҷикӣ', 'tg-latn': 'tojikī', 'th': 'ไทย', 'ti': 'ትግርኛ', 'tk': 'Türkmençe', 'tl': 'Tagalog', 'tly': 'толышә зывон', 'tn': 'Setswana', 'to': 'lea faka-Tonga', 'tpi': 'Tok Pisin', 'tr': 'Türkçe', 'tru': 'Ṫuroyo', 'ts': 'Xitsonga', 'tt': 'татарча/tatarça', 'tt-cyrl': 'татарча', 'tt-latn': 'tatarça', 'tum': 'chiTumbuka', 'tw': 'Twi', 'ty': 'reo tahiti', 'tyv': 'тыва дыл', 'tzm': 'ⵜⴰⵎⴰⵣⵉⵖⵜ', 'udm': 'удмурт', 'ug': 'ئۇيغۇرچە / Uyghurche', 'ug-arab': 'ئۇيغۇرچە', 'ug-latn': 'Uyghurche', 'uk': 'українська', 'ur': 'اردو', 'uz': 'oʻzbekcha/ўзбекча', 'uz-cyrl': 'ўзбекча', 'uz-latn': 'oʻzbekcha', 've': 'Tshivenda', 'vec': 'vèneto', 'vep': 'vepsän kel’', 'vi': 'Tiếng Việt', 'vls': 'West-Vlams', 'vmf': 'Mainfränkisch', 'vo': 'Volapük', 'vot': 'Vaďďa', 'vro': 'Võro', 'wa': 'walon', 'war': 'Winaray', 'wo': 'Wolof', 'wuu': '吴语', 'xal': 'хальмг', 'xh': 'isiXhosa', 'xmf': 'მარგალური', 'xsy': 'saisiyat', 'yi': 'ייִדיש', 'yo': 'Yorùbá', 'yue': '粵語', 'za': 'Vahcuengh', 'zea': 'Zeêuws', 'zgh': 'ⵜⴰⵎⴰⵣⵉⵖⵜ ⵜⴰⵏⴰⵡⴰⵢⵜ', 'zh': '中文', 'zh-classical': '文言', 'zh-cn': '中文（中国大陆）\u200e', 'zh-hans': '中文（简体）\u200e', 'zh-hant': '中文（繁體）\u200e', 'zh-hk': '中文（香港）\u200e', 'zh-min-nan': 'Bân-lâm-gú', 'zh-mo': '中文（澳門）\u200e', 'zh-my': '中文（马来西亚）\u200e', 'zh-sg': '中文（新加坡）\u200e', 'zh-tw': '中文（台灣）\u200e', 'zh-yue': '粵語', 'zu': 'isiZulu'}

Se puede también consultar por cierta página de wikipedia:

wikipedia.page("Debian")  
<WikipediaPage 'Debian'>

Y ver si contenido (se mostrará el final del contenido de la wikipedia sobre Debian):

print(wikipedia.page("Debian").content)

== Distribuciones derivadas ==
En la actualidad, como Debian es una distro que ha demostrado su estabilidad y utilidad, muchos desarrolladores la han tomado para crear a partir de ella nuevas distribuciones. Se las conoce como distribuciones basadas en Debian.
En septiembre de 2010 existen 121 distribuciones activas basadas en Debian; según el buscador de DistroWatch, además Debian posee en su sitio web una lista oficial de sus distribuciones descendientes.[25]


== Comunidades ==
Existen muchas y variadas comunidades relacionadas con el Proyecto Debian. Algunas de ellas:

Brasil,[26]
Colombia,[27]
Costa Rica,[28]
Chile,[29]
España,[30]
México,[31]
Nicaragua,[32]
Venezuela[33]


== Véase también ==
 Portal:Software libre. Contenido relacionado con Software libre.
Distribuciones basadas en Debian


=== Adaptaciones a otros núcleos ===
Debian GNU/Linux
Debian GNU/Hurd
Debian GNU/NetBSD
Debian GNU/kFreeBSD


=== Filosofía ===
Manifiesto Debian
Directrices de software libre de Debian
Contrato Social de Debian


=== Varios ===
Debconf


== Referencias ==


== Enlaces externos ==
 Wikimedia Commons alberga una galería multimedia sobre Debian.
 Wikinoticias tiene noticias relacionadas con Debian.
Sitio web oficial de Debian

Se puede también consultar por el URL de la página sobre el tema que se está consultando:

print(wikipedia.page("Debian").url)  
https://es.wikipedia.org/wiki/Debian

O consultar sus referencias (se trae los urls en una lista):

print(wikipedia.page("Debian").references)
['http://www.debianchile.cl/', 'http://maslinux.es/debian-8-jessie-ha-alcanzado-el-fin-del-soporte-de-seguridad/', 'http://www.debian.mx/', 'http://www.debian.org.ni/', 'http://web.archive.org/web/20070408162722/http://www.us.debian.org/News/2005/20050606', 'http://web.archive.org/web/20071011203303/http://www.us.debian.org/News/2002/20020719', 'http://web.archive.org/web/20071013115846/http://www.us.debian.org/News/2000/20000815', 'http://web.archive.org/web/20080511183553/http://www.us.debian.org/News/2007/20070408', 'http://web.archive.org/web/20080706192105/http://www.us.debian.org/News/1999/19990309', 'http://web.archive.org/web/20080723214102/http://www.us.debian.org/News/1997/19970602', 'http://web.archive.org/web/20080724051253/http://www.us.debian.org/News/1998/19980724', 'http://lists.debian.org/debian-devel-announce/2008/09/msg00000.html', 'http://lists.debian.org/debian-devel-announce/2013/04/msg00006.html', 'http://www.us.debian.org/News/1997/19970602', 'http://www.us.debian.org/News/1998/19980724', 'http://www.us.debian.org/News/1999/19990309', 'http://www.us.debian.org/News/2000/20000815', 'http://www.us.debian.org/News/2002/20020719', 'http://www.us.debian.org/News/2005/20050606', 'http://www.us.debian.org/News/2007/20070408', 'http://www.debian.org/', 'http://www.debian.org/News/2009/20090214', 'http://www.debian.org/devel/join/newmaint', 'http://www.debian.org/doc/manuals/project-history/ch-intro.en.html', 'http://www.debian.org/donations.es.html#money_donations', 'http://www.debian.org/misc/children-distros.html', 'http://www.debianbrasil.org/', 'http://www.debianchile.org/', 'http://www.esdebian.org/', 'http://www.ibiblio.org/pub/historic-linux/distributions/debian-0.91/ChangeLog', 'https://web.archive.org/web/20070203111437/http://www.debiancolombia.org/', 'https://web.archive.org/web/20070307094321/http://www.debianbrasil.org/', 'https://web.archive.org/web/20070406065849/http://cr.debian.net/', 'https://web.archive.org/web/20070929040145/http://www.debian.org.ve/', 'https://web.archive.org/web/20110816182444/http://www.jus.uio.no/sisu/debian_constitution_v1.2/opendocument.es.odt', 'https://web.archive.org/web/20180621121330/http://maslinux.es/debian-8-jessie-ha-alcanzado-el-fin-del-soporte-de-seguridad/', 'https://web.archive.org/web/20181221235131/https://www.debian.org/intro/about.en.html', 'https://web.archive.org/web/20181221235714/https://www.debian.org/intro/about.es.html', 'https://lists.debian.org/debian-devel-announce/2012/07/msg00004.html', 'https://lists.debian.org/debian-devel-announce/2014/11/msg00003.html', 'https://lists.debian.org/debian-devel-announce/2015/03/msg00016.html', 'https://lists.debian.org/debian-security-announce/2014/msg00082.html', 'https://www.debian.org/', 'https://www.debian.org/News/2014/20140424', 'https://www.debian.org/News/2017/20170617', 'https://www.debian.org/doc/manuals/project-history/ch-releases.en.html', 'https://www.debian.org/intro/about.en.html', 'https://www.debian.org/intro/about.es.html']

Se puede consultar el título de la página:

print(wikipedia.page("Debian").title)  
Debian

También se puede consultar las categorías en la que aparece la consulta que se está realizando:

print(wikipedia.page("Debian").categories)  
['Categoría:Debian', 'Categoría:Organizaciones de Linux', 'Categoría:Proyectos', 'Categoría:Sistemas operativos PowerPc', 'Categoría:Software de 1993', 'Categoría:Wikipedia:Artículos sin coordenadas', 'Categoría:Wikipedia:Páginas que utilizan Timeline']

Se puede consultar los enlaces que tiene la página:

print(wikipedia.page("Debian").links)
['17 de junio', '1993', '1994', '1995', '1996', '1997', '1998', '1999', '2000', '2001', '2002', '2003', '2005', '2006', '2007', '2008', '2009', '2010', '2013', '2015', '2016', '2017', '2019', 'Acrónimo', 'Advanced Packaging Tool', 'Alemania', 'Anthony Towns', 'Arquitectura de computador', 'Arquitectura de computadores', 'Asociación voluntaria', 'Australia', 'Austria', 'Bdale Garbee', 'Ben Collins', 'BitTorrent', 'Branden Robinson', 'Bruce Perens', 'Cargador de arranque', 'Chris Lamb', 'Comunidad', 'Contrato Social de Debian', 'Corel Linux', 'Código fuente', 'Deb', 'Debconf', 'Debian GNU/Hurd', 'Debian GNU/Linux', 'Debian GNU/NetBSD', 'Debian GNU/kFreeBSD', 'Desarrollador de software', 'Directrices de software libre de Debian', 'Distribución GNU/Linux', 'Distribución Linux', 'DistroWatch', 'Empresa', 'Error de software', 'Estados Unidos', 'Francia', 'FreeBSD', 'Free Software Foundation', 'Freenode', 'GNOME', 'GNU', 'GNU GRUB', 'GNU Hurd', 'Gestor de paquetes', 'Gnome', 'Hurd', 'IRC', 'Ian Jackson', 'Ian Murdock', 'Ibiblio', 'Idioma inglés', 'Inglaterra', 'Internet', 'Italia', 'Jigdo', 'KDE', 'Kfreebsd', 'LXDE', 'Licencia de software', 'Linux', 'Linux (núcleo)', 'Lista de correo', 'Lucas Nussbaum', 'Manifiesto Debian', 'Manifiesto de Debian', 'Martin Michlmayr', 'Mehdi Dogguy', 'Movimiento del software libre', 'Mozilla Firefox', 'Método Schulze', 'Neil McGovern', 'NetBSD', 'Núcleo (informática)', 'Open Source', 'Organización', 'Organización sin ánimo de lucro', 'Paquete de software', 'Paquetes de software', 'Países Bajos', 'Plataforma (informática)', 'SQL', 'Sam Hartman', 'Sam Hocevar', 'Servidor', 'Sistema operativo', 'Software', 'Software in the Public Interest', 'Software libre', 'Software no libre', 'Sources.list', 'Stefano Zacchiroli', 'Steve McIntyre', 'Stormix', 'Systemd', 'Tar', 'Toy Story', 'Túnez', 'USB en vivo', 'Universidad Purdue', 'Usuario', 'Usuario root', 'Wayback Machine', 'Wichert Akkerman', 'Wikimedia Commons', 'Wikinoticias', 'Xfce']

Se puede averiguar cuantas imágenes tiene la página de wikipedia del tema seleccionado:

len(wikipedia.page("Debian").images)
15

Y para ver el URL de la primera imágen:

print(wikipedia.page("Debian").images[0])
https://upload.wikimedia.org/wikipedia/commons/4/4a/Commons-logo.svg

Para terminar se puede obtener el html de la página del tema consultado:

print(wikipedia.page("Debian").html())

Salida:

<div class="mw-parser-output"><div class="rellink noprint"> Para el sistema operativo que usa el núcleo <a href="/wiki/Linux_(n%C3%BAcleo)" class="mw-redirect" title="Linux (núcleo)">Linux</a> y las herramientas <a href="/wiki/GNU" title="GNU">GNU</a>, véase <a href="/wiki/Debian_GNU/Linux" title="Debian GNU/Linux">Debian GNU/Linux</a>.</div>
<table class="infobox" style="width:22.7em; line-height: 1.4em; text-align:left; padding:.23em;"><tbody><tr><th colspan="3" class="cabecera organización" style="text-align:center;background-color:#DDD;color:black;"><b>Debian</b></th></tr><tr><td colspan="3" style="text-align:center;font-size:95%;;">
<a href="/wiki/Archivo:Debian-OpenLogo.svg" class="image"><img alt="Debian-OpenLogo.svg" src="//upload.wikimedia.org/wikipedia/commons/thumb/4/4a/Debian-OpenLogo.svg/245px-Debian-OpenLogo.svg.png" decoding="async" importance="high" elementtiming="thumbnail-high" width="245" height="324" srcset="//upload.wikimedia.org/wikipedia/commons/thumb/4/4a/Debian-OpenLogo.svg/368px-Debian-OpenLogo.svg.png 1.5x, //upload.wikimedia.org/wikipedia/commons/thumb/4/4a/Debian-OpenLogo.svg/490px-Debian-OpenLogo.svg.png 2x" data-file-width="109" data-file-height="144" /></a></td></tr><tr><th scope="row" style="text-align:left;font-size:95%;;">Tipo</th><td colspan="2" style="font-size:95%;;">
<a href="/wiki/Comunidad" title="Comunidad">comunidad</a> y <a href="/wiki/Organizaci%C3%B3n" title="Organización">organización</a></td></tr><tr><th scope="row" style="text-align:left;font-size:95%;;">Fundación</th><td colspan="2" style="font-size:95%;;">
<a href="/wiki/1993" title="1993">1993</a></td></tr><tr><th scope="row" style="text-align:left;font-size:95%;;">Fundador(es)</th><td colspan="2" style="font-size:95%;;">
<a href="/wiki/Ian_Murdock" title="Ian Murdock">Ian Murdock</a></td></tr><tr><th scope="row" style="text-align:left;font-size:95%;;">Dependiente de</th><td colspan="2" style="font-size:95%;;">
<a href="/wiki/Software_in_the_Public_Interest" title="Software in the Public Interest">Software in the Public Interest</a></td></tr><tr><th scope="row" style="text-align:left;font-size:95%;;">Sitio web</th><td colspan="2" style="font-size:95%;;">

El API es muy útil tanto para bajar contenido del wiki como traerse enlaces, urls de imágenes o el código html completo, útil para webscraping.

En próximo artículo se volverá a usar el API de Wikipedia para hacer análisis de lenguaje natural NLP con Python.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Visualizando estadisticas de pokemon usando plotly ( gráfica de radar)

2018-12-01T09:00:00-04:00

Luego de un tiempo sin escribir, retomo los artículos sobre Ciencia de Datos, ahora con visualización de datos. Para ello se usará la estadística de un repositorio de datos sobre los pokemon.

El gráfico radar es un gráfico que consiste en una secuencia de radios equi-angulares, llamados radios, y cada radio representa una de las variables. La longitud de los datos de un radio es proporcional a la magnitud de la variable para el punto de datos en relación con la longitud máxima de la variable en todos los puntos de datos. Se dibuja una línea que conecta con los valores de los datos para cada radio. Esto le da a la trama una apariencia de estrella (wikipedia). Pueden ver un ejemplo en la siguiente figura:

La idea es mostrar múltiples variables sobre la información que se tiene de los pokemons. El repositorio de datos de donde se obtienen los datos para trabajar es el sitio de kaggle.

La librería de Python que se usará en este artículo para visualizar los datos usando la gráfica radar se llama plotly, en el siguiente enlace podrán ver una galería de gráficas usando python, ya que dicha librería se puede usar también en el Lenguaje R y en Javascript. Lo bueno de plotly es que maneja más interactividad o dinamismo a las gráficas, no son simples gráficas estáticas. Plotly se puede usar en línea o desconectado.

La idea de hacer este artículo sobre visualizando estadísticas de pokemon usando plotly fue de un artículo donde usan la gráfica radar pero con matplotlib.

El tutoral básico de como usar la gráfica radar en plotly lo pueden ver en el siguiente enlace.

Este artículo se basa en un notebook que se encuentra en kaggle.

La información que contiene el repositorio es la siguiente:

: ID de cada pokemon.
Name: Nombre de cada pokemon.
Type 1: Cada pokemon tiene un tipo, esto determina su debilidad/resistencia a ataques.
Type 2: Algunos pokemon tienen dos tipos.
Total: Suma de todas las estadísticas.
HP: Hit point, o health.
Defense: Nivel de resistencia a los ataques.
SP Atk: ataque especial.
SP Def: Resistencia contra ataques especiales.
Speed: Velocidad en el ataque.

Visualización de estadística de pokemon usando gráfica de radar

Enlaces de interés

Se importan las librerías necesarias

In [1]:

import pandas as pd
import numpy as np
import plotly.plotly as py
import plotly.graph_objs as go
import plotly

import matplotlib.pyplot as plt
from plotly import tools
from plotly.offline import init_notebook_mode, iplot
init_notebook_mode(connected=True)
import plotly.figure_factory as ff
from IPython.display import HTML, Image
Se lee y convierte el archivo csv de los datos de pokemon en un dataframe

In [2]:

df=pd.read_csv("./datos/Pokemon.csv")
Se muestra las 5 primeras filas de datos

In [3]:

df.head()

Out[3]:

	#	Name	Type 1	Type 2	Total	HP	Attack	Defense	Sp. Atk	Sp. Def	Speed	Generation	Legendary
0	1	Bulbasaur	Grass	Poison	318	45	49	49	65	65	45	1	False
1	2	Ivysaur	Grass	Poison	405	60	62	63	80	80	60	1	False
2	3	Venusaur	Grass	Poison	525	80	82	83	100	100	80	1	False
3	3	VenusaurMega Venusaur	Grass	Poison	625	80	100	123	122	120	80	1	False
4	4	Charmander	Fire	NaN	309	39	52	43	60	50	65	1	False

Se muestra el tipo de dato de cada columna que maneja el dataframe.

In [4]:

df.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 800 entries, 0 to 799
Data columns (total 13 columns):
#             800 non-null int64
Name          800 non-null object
Type 1        800 non-null object
Type 2        414 non-null object
Total         800 non-null int64
HP            800 non-null int64
Attack        800 non-null int64
Defense       800 non-null int64
Sp. Atk       800 non-null int64
Sp. Def       800 non-null int64
Speed         800 non-null int64
Generation    800 non-null int64
Legendary     800 non-null bool
dtypes: bool(1), int64(9), object(3)
memory usage: 75.9+ KB

Se visualiza los datos de un sólo pokemon In [5]:

#Se busca los datos del pokemon Charizard
x = df[df["Name"] == "Charizard"]
#Se crea la grafica scatterpolar donde se le pasa  las variables que se quiere graficar. HP, Ataque, defensa, SP atk, 
#Sp def, velocidad y se define los nombres de los ejes.
data = [go.Scatterpolar(
  r = [x['HP'].values[0],x['Attack'].values[0],x['Defense'].values[0],x['Sp. Atk'].values[0],x['Sp. Def'].values[0],x['Speed'].values[0],x["HP"].values[0]],
  theta = ['HP','Attack','Defense','Sp. Atk','Sp. Def','Speed','HP'],
  fill = 'toself'
)]

# se crea el layout, donde se le pasa un diccionario  donde se define los ejes de los radios, que son visibles y
#su rango en este caso desde 0 a 250, no se muestra legenda, y el título de la gráfica.

layout = go.Layout(
  polar = dict(
    radialaxis = dict(
      visible = True,
      range = [0, 250]
    )
  ),
  showlegend = False,
  title = "Stats of {}".format(x.Name.values[0])
)
#Se crea la instancia fig donde se pasa los datos y el layout.
fig = go.Figure(data=data, layout=layout)
#Se gràfica la gráfica
iplot(fig, filename = "Single Pokemon stats")

![](./images/visualizandoestadisticasdepokemonusandoplotlygraficaderadar-2.png)

Comparación de 2 pokemons In [6]:

# Se crea una función donde se hace la comparación vía gráfica de la estadística de dos pokemons.
def compare2pokemon(x,y):
    #Se  captura los datos de los dos pokemons
    x = df[df["Name"] == x]
    y = df[df["Name"] == y]

    #Se define lo que se quiere gráficar del primer y segundo pokemon.
    trace0 = go.Scatterpolar(
      r = [x['HP'].values[0],x['Attack'].values[0],x['Defense'].values[0],x['Sp. Atk'].values[0],x['Sp. Def'].values[0],x['Speed'].values[0],x["HP"].values[0]],
      theta = ['HP','Attack','Defense','Sp. Atk','Sp. Def','Speed','HP'],
      fill = 'toself',
      name = x.Name.values[0]
    )

    trace1 = go.Scatterpolar(
      r = [y['HP'].values[0],y['Attack'].values[0],y['Defense'].values[0],y['Sp. Atk'].values[0],y['Sp. Def'].values[0],y['Speed'].values[0],y["HP"].values[0]],
      theta = ['HP','Attack','Defense','Sp. Atk','Sp. Def','Speed','HP'],
      fill = 'toself',
      name = y.Name.values[0]
    )

    #se define data como una lista que contiene los datos de los dos pokemon
    data = [trace0, trace1]

    #Se define el layout como en la gráfica anterior.
    layout = go.Layout(
      polar = dict(
        radialaxis = dict(
          visible = True,
          range = [0, 200]
        )
      ),
      showlegend = True,
      title = "{} vs {}".format(x.Name.values[0],y.Name.values[0])
    )
    #Se crea la instancia donde se pasa los datos y el layout
    fig = go.Figure(data=data, layout=layout)
    #Se crea la grafica.
    iplot(fig, filename = "Two Pokemon stats")

In [7]:

# Se compara primeape y muk
compare2pokemon("Primeape", "Muk")

En siguientes artículos se seguirá mostrando ejemplos de usos de la galería de gráficas de plotly.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Analizando datos del cambio climático y niveles de CO2 en la atmosfera con Python y pandas.

2018-10-14T09:00:00-04:00

Continuando con los artículos sobre ciencia de datos, esta vez se analizará datos sobre información del clima global y por países, así como los niveles de CO2.

Estos datos y proyecto los encontré en el sitio kaggle, este sitio es para publicar proyectos de ciencia de datos. Los datos para este artículo lo encuentran en el siguiente enlace.

El código de este artículo se basa en el artículo que se encuentra en kaggle sobre el tema en inglés Climate Change and CO2 levels in atmosphere.

En este artículo se explora los cambios globales de la temperatura media y el incremento de la concentración del CO2 en la atmosfera.

Los datos se obtienen de los siguientes archivos:

GlobalLandTemperaturesByCountry.csv: Contiene la información de la temperatura por país.
GlobalTemperatures.csv: Contiene la información global de la temperatura.
archive.csv: Contiene la información de los niveles de CO2 en la atmosfera.

A continuación se muestra el notebook:

https://www.kaggle.com/derevirn/data-analysis-on-climate-change/notebook https://www.kaggle.com/derevirn/data-analysis-on-climate-change/data

Se importan las librerías de pandas, matplotlib y seaborn.

In [1]:

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

Se crea los dataframes a partir de los archivos csv.

In [2]:

# Se crea el dataframe data_pais, data_vzla, data_global y co2_ppm

data_pais = pd.read_csv("./datos/GlobalLandTemperaturesByCountry.csv")
#Se crea una copia del dataframe obteniendo solo la información de Venezuela.
data_vzla = data_pais[data_pais["Country"] == "Venezuela"].copy()
data_vzla["dt"] = pd.to_datetime(data_vzla["dt"])

#Se crea una copia del dataframe obteniendo solo la información de Argentina.
data_arg = data_pais[data_pais["Country"] == "Argentina"].copy()
data_arg["dt"] = pd.to_datetime(data_arg["dt"])

#Se crea una copia del dataframe obteniendo solo la información de USA.
data_canada = data_pais[data_pais["Country"] == "Canada"].copy()
data_canada["dt"] = pd.to_datetime(data_canada["dt"])

#Se crea una copia del dataframe obteniendo solo la información de Mexico.
data_mexico = data_pais[data_pais["Country"] == "Mexico"].copy()
data_mexico["dt"] = pd.to_datetime(data_mexico["dt"])

#Se crea una copia del dataframe obteniendo solo la información de Brasil.
data_brasil = data_pais[data_pais["Country"] == "Brazil"].copy()
data_brasil["dt"] = pd.to_datetime(data_brasil["dt"])

#Se crea una copia del dataframe obteniendo solo la información de Venezuela.
data_chile = data_pais[data_pais["Country"] == "Chile"].copy()
data_chile["dt"] = pd.to_datetime(data_chile["dt"])

#Se crea el dataframe de la temperatura global. 
data_global = pd.read_csv("./datos/GlobalTemperatures.csv")
#Se modifica la fecha y hora como datetime.
data_global["dt"] = pd.to_datetime(data_global["dt"])
#Se crea el dataframe del co2.
co2_ppm = pd.read_csv("./datos/archive.csv")

Los dataframes creados.

In [3]:

data_pais.head()

Out[3]:

ID	dt	Average Temperature	Average Temperature Uncertainty	Country
0	1743-11-01	4.384	2.294	Åland
1	1743-12-01	NaN	NaN	Åland
2	1744-01-01	NaN	NaN	Åland
3	1744-02-01	NaN	NaN	Åland
4	1744-03-01	NaN	NaN	Åland

Como se puede observar, se tiene la fecha, la temperatura promedio, la temperatura promedio de incertidumbre y país. In [4]:

data_pais.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 577462 entries, 0 to 577461
Data columns (total 4 columns):
dt                               577462 non-null object
AverageTemperature               544811 non-null float64
AverageTemperatureUncertainty    545550 non-null float64
Country                          577462 non-null object
dtypes: float64(2), object(2)
memory usage: 17.6+ MB

Los tipos de datos de las columnas son dt objeto, temperatura promedio y temperatura promedio de incertidumbre son float64 y country como objeto

Venezuela

In [5]:

data_vzla.head()

Out[5]:

ID	dt	Average Temperature	Average Temperature Uncertainty	Country
562339	1824-01-01	24.613	0.824	Venezuela
562340	1824-02-01	24.670	2.017	Venezuela
562341	1824-03-01	25.527	1.065	Venezuela
562342	1824-04-01	25.732	1.771	Venezuela
562343	1824-05-01	24.999	1.157	Venezuela

Se tiene la misma información anterior pero sólo de Venezuela. In [6]:

data_vzla.describe().T

Out[6]:

	count	mean	std	min	25%	50%	75%	max
AverageTemperature	2086.0	25.025686	0.703189	22.777	24.52325	24.9825	25.49525	27.807
AverageTemperatureUncertainty	2086.0	0.586000	0.398460	0.084	0.31000	0.4540	0.76000	4.120

Se tienen 2086 datos, los cuales la temperatura promedio es 25.025 grados, y la incertidumbre es de 0.586, la desviación de la temperatura promedio es de 0.703, y de la incertidumbre es de 0.398, la mínima temperatura fue de 22.77, la máxima de 27.807. In [7]:

data_vzla.corr()

Out[7]:

	AverageTemperature	AverageTemperatureUncertainty
AverageTemperature	1.000000	-0.319882
AverageTemperatureUncertainty	-0.319882	1.000000

Las dos variables tienen una correlación contraria en cierta manera. Argentina In [8]:

data_arg.head()

Out[8]:

ID	dt	Average Temperature	Average Temperature Uncertainty	Country
25466	1855-05-01	10.745	1.499	Argentina
25467	1855-06-01	6.995	2.073	Argentina
25468	1855-07-01	6.901	1.568	Argentina
25469	1855-08-01	9.097	1.412	Argentina
25470	1855-09-01	11.316	1.384	Argentina

In [9]:

data_arg.describe().T

Out[9]:

	count	mean	std	min	25%	50%	75%	max
AverageTemperature	1900.0	14.621194	4.846885	4.796	10.13225	14.6305	19.27875	23.290
AverageTemperatureUncertainty	1900.0	0.527338	0.465652	0.083	0.20900	0.3035	0.74525	2.974

Brasil

In [10]:

data_brasil.head()

Out[10]:

ID	dt	Average Temperature	Average Temperature Uncertainty	Country
77110	1832-01-01	24.935	1.372	Brazil
77111	1832-02-01	24.505	1.953	Brazil
77112	1832-03-01	24.617	1.359	Brazil
77113	1832-04-01	23.990	2.013	Brazil
77114	1832-05-01	23.124	1.592	Brazil

In [11]:

data_brasil.describe().T

Out[11]:

	count	mean	std	min	25%	50%	75%	max
AverageTemperature	2164.0	24.699256	0.978787	21.797	24.02250	24.8295	25.44975	27.151
AverageTemperatureUncertainty	2164.0	0.572940	0.411794	0.060	0.24375	0.4160	0.84000	3.353

Chile

In [12]:

data_chile.head()

Out[12]:

ID	dt	AverageTemperature	AverageTemperatureUncertainty	Country
108248	1855-05-01	7.152	1.296	Chile
108249	1855-06-01	4.257	1.641	Chile
108250	1855-07-01	4.113	1.313	Chile
108251	1855-08-01	5.508	1.168	Chile
108252	1855-09-01	6.684	1.153	Chile

In [13]:

data_chile.describe().T

Out[13]:

	count	mean	std	min	25%	50%	75%	max
AverageTemperature	1900.0	9.383474	3.179081	3.206	6.502	9.3815	12.37775	15.493
AverageTemperatureUncertainty	1900.0	0.572654	0.418011	0.114	0.281	0.3825	0.80300	2.408

Mexico

In [14]:

data_mexico.head()

Out[14]:

ID	dt	AverageTemperature	AverageTemperatureUncertainty	Country
338438	1835-01-01	15.810	1.484	Mexico
338438	1835-01-01	15.810	1.484	Mexico
338439	1835-02-01	14.911	1.579	Mexico
338440	1835-03-01	16.826	1.858	Mexico
338441	1835-04-01	19.925	1.966	Mexico
338442	1835-05-01	22.037	1.609	Mexico

In [15]:

data_mexico.describe().T

Out[15]:

	count	mean	std	min	25%	50%	75%	max
AverageTemperature	2145.0	20.567558	3.753343	12.064	17.109	21.050	24.164	26.926
AverageTemperatureUncertainty	2145.0	0.638233	0.547605	0.091	0.226	0.398	0.970	3.699

Canadá

In [16]:

data_canada.head()

Out[16]:

ID	dt	AverageTemperature	AverageTemperatureUncertainty	Country
97255	1768-09-01	5.257	3.107	Canada
97256	1768-10-01	-3.393	2.981	Canada
97257	1768-11-01	-12.829	3.967	Canada
97258	1768-12-01	-20.582	4.622	Canada
97259	1769-01-01	-24.756	4.722	Canada

In [17]:

data_canada.describe().T

Out[17]:

	count	mean	std	min	25%	50%	75%	max
AverageTemperature	2504.0	-5.216659	12.878074	-28.736	-17.7025	-4.7285	7.41275	14.796
AverageTemperatureUncertainty	2504.0	1.256211	1.046127	0.123	0.2870	0.8980	2.12025	5.275

Se nota que las variaciones de la temperatura promedio de incertidumbre es mayor en Brasil, Venezuela, Mexico y Canadá en ese orden, con respecto a Chile y Argentina.

Incremento anual de la temperatura promedio global

In [18]:

annual_mean_global = data_global.groupby(data_global["dt"].dt.year).mean()
reference_temperature_global = annual_mean_global.loc[1951:1980].mean()["LandAndOceanAverageTemperature"]
annual_mean_global["Anomaly"] = annual_mean_global["LandAndOceanAverageTemperature"] - reference_temperature_global

In [19]:

plt.figure()
plt.style.use("fivethirtyeight")
annual_mean_global.loc[1960:2015]["Anomaly"].plot(figsize = (10,5), grid=True, legend=True)
plt.title("Anomalia anual de la temperatura promedio global")
plt.xlabel('')
plt.ylabel('Anomalia de la temperatura')
plt.show()

![](./images/analizandodatosdelcambioclimaticoynivelesdeco2enlaatmosferaconpythonypandas-1.png)

Se nota que anualmente el incremento de la temperatura tiene una tendencia ascendente que ha aumentado en los últimos años, este incremento en el año 2015 fue de 0.75 grados que es consistente con el cambio climático.

Venezuela.

Se hace el mismo cálculo para el caso de Venezuela. In [20]:

annual_mean_vzla = data_vzla.groupby(data_vzla["dt"].dt.year).mean()
reference_temperature_vzla = annual_mean_vzla.loc[1951:1980].mean()["AverageTemperature"]
annual_mean_vzla["Anomaly"] = annual_mean_vzla["AverageTemperature"] - reference_temperature_vzla

In [21]:

annual_mean_vzla.head()

Out[21]:

dt	AverageTemperature	AverageTemperatureUncertainty	Anomaly
1824	24.896545	1.516091	-0.420966
1825	25.071583	1.552083	-0.245928
1826	24.871900	1.440800	-0.445611
1827	25.156273	1.474182	-0.161238
1828	24.751818	1.516727	-0.565693

In [22]:

annual_mean_vzla.tail()

Out[22]:

dt	AverageTemperature	AverageTemperatureUncertainty	Anomaly
2009	26.084917	0.353917	0.767406
2010	26.150250	0.341333	0.832739
2011	25.677333	0.336750	0.359822
2012	25.688583	0.401417	0.371072
2013	25.912875	0.484500	0.595364

El último registro es del año 2013, el cual el incremento fue de 0.595 grados, hubo un pico en el año 2010 de 0.8332 grados. In [23]:

plt.figure()
plt.style.use("fivethirtyeight")
annual_mean_vzla.loc[1960:2012]["Anomaly"].plot(figsize = (10,5), grid=True, legend=True)
plt.title("Variación promedio anual de la temperatura de Venezuela")
plt.xlabel('')
plt.ylabel('Incremento de la temperatura')
plt.show()

![](./images/analizandodatosdelcambioclimaticoynivelesdeco2enlaatmosferaconpythonypandas-2.png)

Argentina

In [24]:

annual_mean_arg = data_arg.groupby(data_arg["dt"].dt.year).mean()
reference_temperature_arg = annual_mean_arg.loc[1951:1980].mean()["AverageTemperature"]
annual_mean_arg["Anomaly"] = annual_mean_arg["AverageTemperature"] - reference_temperature_arg

In [25]:

annual_mean_arg.head()

Out[25]:

dt	AverageTemperature	AverageTemperatureUncertainty	Anomaly
1855	11.729250	1.711875	-3.090742
1856	13.998750	1.553167	-0.821242
1857	14.221083	1.993417	-0.598908
1858	14.015667	1.770750	-0.804325
1859	14.414583	1.635583	-0.405408

In [26]:

annual_mean_arg.tail()

Out[26]:

dt	AverageTemperature	AverageTemperatureUncertainty	Anomaly
2009	15.534417	0.215750	0.714425
2010	15.078833	0.218917	0.258842
2011	15.339667	0.219833	0.519675
2012	15.689000	0.265750	0.869008
2013	14.457125	0.276500	-0.362867

In [27]:

plt.figure()
plt.style.use("fivethirtyeight")
annual_mean_arg.loc[1960:2012]["Anomaly"].plot(figsize = (10,5), grid=True, legend=True)
plt.title("Variación promedio anual de la temperatura de Argentina")
plt.xlabel('')
plt.ylabel('Incremento de la temperatura')
plt.show()

![](./images/analizandodatosdelcambioclimaticoynivelesdeco2enlaatmosferaconpythonypandas-3.png)

Para el caso de Argentina la pendiente de la tendencia de incremento de la temperatura es menos pronunciada.

Brasil

In [28]:

annual_mean_brasil = data_brasil.groupby(data_brasil["dt"].dt.year).mean()
reference_temperature_brasil = annual_mean_brasil.loc[1951:1980].mean()["AverageTemperature"]
annual_mean_brasil["Anomaly"] = annual_mean_brasil["AverageTemperature"] - reference_temperature_brasil

In [29]:

annual_mean_brasil.head()

Out[29]:

dt	AverageTemperature	AverageTemperatureUncertainty	Anomaly
1832	23.858583	1.734500	-1.072247
1833	24.517833	1.450083	-0.412997
1834	24.346750	1.498083	-0.584081
1835	23.537500	1.298583	-1.393331
1836	23.921167	1.426083	-1.009664

In [30]:

annual_mean_brasil.tail()

Out[30]: | dt | AverageTemperature | AverageTemperatureUncertainty | Anomaly |
|:---- | :---------------: | :--------------------------: | :-------: |
| 2009 | 25.600583 | 0.185667 | 0.669753 | | 2010 | 25.812417 | 0.158000 | 0.881586 | | 2011 | 25.428917 | 0.204833 | 0.498086 | | 2012 | 25.717083 | 0.231000 | 0.786253 | | 2013 | 25.348125 | 0.262250 | 0.417294 |

In [31]:

plt.figure()
plt.style.use("fivethirtyeight")
annual_mean_brasil.loc[1960:2012]["Anomaly"].plot(figsize = (10,5), grid=True, legend=True)
plt.title("Variación promedio anual de la temperatura de Brasil")
plt.xlabel('')
plt.ylabel('Incremento de la temperatura')
plt.show()

![](./images/analizandodatosdelcambioclimaticoynivelesdeco2enlaatmosferaconpythonypandas-4.png)

En el caso de Brasil se nota un fuerte incremento en la decada de los 90s con un pico de más de 1 grado, luego la tendencia se ha estabilizado en 0.79 grados.

Chile

In [32]:

annual_mean_chile = data_chile.groupby(data_chile["dt"].dt.year).mean()
reference_temperature_chile = annual_mean_chile.loc[1951:1980].mean()["AverageTemperature"]
annual_mean_chile["Anomaly"] = annual_mean_chile["AverageTemperature"] - reference_temperature_chile

In [33]:

annual_mean_chile.head()

Out[33]:

dt	AverageTemperature	AverageTemperatureUncertainty	Anomaly
1855	7.070125	1.424125	-2.510742
1856	8.664083	1.319250	-0.916783
1857	8.645917	1.439250	-0.934950
1858	8.810250	1.428333	-0.770617
1859	9.245583	1.376917	-0.335283

In [34]:

annual_mean_chile.tail()

Out[34]:

dt	AverageTemperature	AverageTemperatureUncertainty	Anomaly
2009	9.994417	0.281917	0.413550
2010	9.712833	0.340000	0.131967
2011	10.032250	0.322250	0.451383
2012	10.272583	0.384583	0.691717
2013	9.877375	0.393875	0.296508

In [35]:

plt.figure()
plt.style.use("fivethirtyeight")
annual_mean_chile.loc[1960:2012]["Anomaly"].plot(figsize = (10,5), grid=True, legend=True)
plt.title("Variación promedio anual de la temperatura de Chile")
plt.xlabel('')
plt.ylabel('Incremento de la temperatura')
plt.show()

![](./images/analizandodatosdelcambioclimaticoynivelesdeco2enlaatmosferaconpythonypandas-5.png)

La variación no supera el 0.8 grados de temperatura, con un aumento fuerte entre los 70s y 80s y luego un pico en los 90s.

Mexico

In [36]:

annual_mean_mexico = data_mexico.groupby(data_mexico["dt"].dt.year).mean()
reference_temperature_mexico = annual_mean_mexico.loc[1951:1980].mean()["AverageTemperature"]
annual_mean_mexico["Anomaly"] = annual_mean_mexico["AverageTemperature"] - reference_temperature_mexico

In [37]:

annual_mean_mexico.head()

Out[37]:

dt	AverageTemperature	AverageTemperatureUncertainty	Anomaly
1835	18.993250	1.684083	-1.745911
1836	19.587167	1.695333	-1.151994
1837	19.671083	1.647667	-1.068078
1838	19.337000	1.862417	-1.402161
1839	19.785833	1.603000	-0.953328

In [38]:

annual_mean_mexico.tail()

Out[38]:

dt	AverageTemperature	AverageTemperatureUncertainty	Anomaly
2009	21.546083	0.205917	0.806922
2010	20.852917	0.217750	0.113756
2011	21.599333	0.245333	0.860172
2012	21.652417	0.324500	0.913256
2013	22.219222	0.365111	1.480061

In [39]:

plt.figure()
plt.style.use("fivethirtyeight")
annual_mean_mexico.loc[1960:2012]["Anomaly"].plot(figsize = (10,5), grid=True, legend=True)
plt.title("Variación promedio anual de la temperatura de Mexico")
plt.xlabel('')
plt.ylabel('Incremento de la temperatura')
plt.show()


![](./images/analizandodatosdelcambioclimaticoynivelesdeco2enlaatmosferaconpythonypandas-6.png)

Se nota la tendencia al alsa de la temperatura en Mexico pasando el año 2013 a estar por 1.48 grados por encima del promedio.

Canadá

In [40]:

annual_mean_canada = data_canada.groupby(data_canada["dt"].dt.year).mean()
reference_temperature_canada = annual_mean_canada.loc[1951:1980].mean()["AverageTemperature"]
annual_mean_canada["Anomaly"] = annual_mean_canada["AverageTemperature"] - reference_temperature_canada

In [41]:

annual_mean_canada.head()

Out[41]:

dt	AverageTemperature	AverageTemperatureUncertainty	Anomaly
1768	-7.886750	3.66925	-2.969253
1769	-3.427875	3.50550	1.489622
1770	NaN	NaN	NaN
1771	NaN	NaN	NaN
1772	NaN	NaN	NaN

In [42]:

annual_mean_canada.tail()

Out[42]:

dt	AverageTemperature	AverageTemperatureUncertainty	Anomaly
2009	-4.135083	0.231833	0.782414
2010	-1.887917	0.218583	3.029581
2011	-3.557083	0.232583	1.360414
2012	-3.176833	0.300083	1.740664
2013	-1.640667	0.533667	3.276831

In [43]:

plt.figure()
plt.style.use("fivethirtyeight")
annual_mean_canada.loc[1960:2012]["Anomaly"].plot(figsize = (10,5), grid=True, legend=True)
plt.title("Variación promedio anual de la temperatura de Canadá")
plt.xlabel('')
plt.ylabel('Incremento de la temperatura')
plt.show()

![](./images/analizandodatosdelcambioclimaticoynivelesdeco2enlaatmosferaconpythonypandas-7.png)

Se nota la tendencia al alsa de la temperatura en Canadá y lo preocupante es que la variación pase los 3 grados de temperatura en el año 2013.

Niveles anuales de CO2 en la Atmosfera

In [44]:

plt.figure()
plt.style.use("fivethirtyeight")
annual_co2_ppm = co2_ppm.groupby(co2_ppm["Year"]).mean()
annual_co2_ppm.loc[1960:2015]["Carbon Dioxide (ppm)"].plot(figsize = (10,5), grid=True, legend=True)
plt.title("Nivel anual global de CO2 en la Atmosfera")
plt.ylabel("CO2 partes por millón")
plt.show()

![](./images/analizandodatosdelcambioclimaticoynivelesdeco2enlaatmosferaconpythonypandas-8.png)

Se nota el incremento anual con tendencia al alza.

Se cálcula la relación del CO2 con la temperatura.

In [45]:

annual_co2_temp = pd.merge(annual_mean_global.loc[1960:2015], annual_co2_ppm.loc[1960:2015], left_index=True, right_index=True)
annual_co2_temp = annual_co2_temp[["LandAndOceanAverageTemperature", "Anomaly", "Carbon Dioxide (ppm)"]].copy()
annual_co2_temp.corr()

Out[45]:

	LandAndOceanAverageTemperature	Anomaly	Carbon Dioxide (ppm)
LandAndOceanAverageTemperature	1.000000	1.000000	0.923603
Anomaly	1.000000	1.000000	0.923603
Carbon Dioxide (ppm)	0.923603	0.923603	1.000000

In [46]:

sns.heatmap(annual_co2_temp.corr())

Out[46]:

<matplotlib.axes._subplots.AxesSubplot at 0x7fcacea9cdd8>

In [47]:

plt.figure(figsize=(10,8))
sns.scatterplot(x="Anomaly",y="Carbon Dioxide (ppm)", data=annual_co2_temp)

Out[47]:

<matplotlib.axes._subplots.AxesSubplot at 0x7fcace8d6c50>

Con la gráfica de calor y la scatter, se nota la relación practicamente lineal del incremento de la temperatura y del Dioxido de Carbono. Ambas están relacionadas en el Cambio climático. In [ ]:

En el sitio donde se almacenan los datos hay más archivos, temperatura por ciudad por ejemplo para ir más a detalle de la situación por ciudad. También pueden seguir buscando info de otros países, en el artículo original se hizo el de Grecia, y acá probé con Argentina, Brasil, Chile, Canadá, México y Venezuela.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Generar gráficos animados de burbuja a lo Gapminer con Python

2018-10-06T09:00:00-04:00

En febrero de 2013 creé un artículo sobre Cómo hacer gráficos de burbujas con matplotlib, la idea era ver como se generaba una gráfica al estilo de la presentación de Hans Rosling (por cierto, murió en Febrero de 2017).

A continuación el vídeo que explica la historia de 200 países en 200 años, la esperanza de vida y calidad de vida.

https://youtu.be/P2QHAbl45jc

O su charla TED sobre sobre las mejores estadísticas que nunca haz visto:

https://youtu.be/hVimVzgtD6w

En el artículo que menciono se usó el conjunto de datos de la rata de criminalidad por estado de Estados Unidos del año 2005. Pero sólo mostraba la información y no la variación en el tiempo.

Este artículo se basa en el siguiente tutorial Python Gapminer Animation.

A continuación se muestra el código del script vía notebook de jupyter:

https://python-graph-gallery.com/341-python-gapminder-animation/

In [1]:

#Se importa las librerias matplitlib, numpy, pandas, seaborn
import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns
sns.set_style("white")
import pandas as pd
my_dpi=96

In [2]:

# Se obtiene los datos en formato csv  y se convierte en un dataframe
url = 'https://python-graph-gallery.com/wp-content/uploads/gapminderData.csv'
data = pd.read_csv(url)

In [3]:

#Se muestra el data frame
data.head()

Out[3]:

	country	year	pop	continent	lifeExp	gdpPercap
0	Afghanistan	1952	8425333.0	Asia	28.801	779.445314
1	Afghanistan	1957	9240934.0	Asia	30.332	820.853030
2	Afghanistan	1962	10267083.0	Asia	31.997	853.100710
3	Afghanistan	1967	11537966.0	Asia	34.020	836.197138
4	Afghanistan	1972	13079460.0	Asia	36.088	739.981106

Tiene las columnas países, año, población, contienen, esperanza de vida y pib percapita In [4]:

#Se revisa los tipos de datos de las columnas
data.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1704 entries, 0 to 1703
Data columns (total 6 columns):
country      1704 non-null object
year         1704 non-null int64
pop          1704 non-null float64
continent    1704 non-null object
lifeExp      1704 non-null float64
gdpPercap    1704 non-null float64
dtypes: float64(3), int64(1), object(2)
memory usage: 80.0+ KB

Se observa que la columna continente es del tipo objeto. Se necesita convertir en un tipo categoria. In [5]:

# Transformar los datos de la columna continente a categoria.
data['continent']=pd.Categorical(data['continent'])
data.head()

Out[5]:

	country	year	pop	continent	lifeExp	gdpPercap
0	Afghanistan	1952	8425333.0	Asia	28.801	779.445314
1	Afghanistan	1957	9240934.0	Asia	30.332	820.853030
2	Afghanistan	1962	10267083.0	Asia	31.997	853.100710
3	Afghanistan	1967	11537966.0	Asia	34.020	836.197138
4	Afghanistan	1972	13079460.0	Asia	36.088	739.981106

In [6]:

#Se vuelve a revisar los tipos de las columnas y ahora se tiene que contienen es categoria
data.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1704 entries, 0 to 1703
Data columns (total 6 columns):
country      1704 non-null object
year         1704 non-null int64
pop          1704 non-null float64
continent    1704 non-null category
lifeExp      1704 non-null float64
gdpPercap    1704 non-null float64
dtypes: category(1), float64(3), int64(1), object(1)
memory usage: 68.5+ KB

Ahora se generará las gráficas por año de experanza de vida y PIB por año, cada gráfica se almacena con su nombre y año a fin de que luego con Image Magick se convierta en un gif animado In [7]:

# Por cada año
for i in data.year.unique():
    # inicializa la figura
    fig = plt.figure(figsize=(680/my_dpi, 480/my_dpi), dpi=my_dpi)
    # se cambia de color con c y alpha, se mapea el color del eje X.
    tmp=data[ data.year == i ]
    plt.scatter(tmp['lifeExp'], tmp['gdpPercap'] , s=tmp['pop']/200000 , c=tmp['continent'].cat.codes, cmap="Accent", alpha=0.6, edgecolors="white", linewidth=2)
    # Se agrega el título, y los ejes.
    plt.yscale('log')
    plt.xlabel("Experanza de vida")
    plt.ylabel("PIB per capita")
    plt.title("Año: "+str(i) )
    plt.ylim(0,100000)
    plt.xlim(30, 90)

    # Se salva el archivo como png, cada archivo por año.
    filename='Gapminder_step'+str(i)+'.png'
    plt.savefig(filename, dpi=96)
    plt.gca()

Se muestra una imagen de las generadas:

Para convertir las imágenes generadas en gif se ejecuta el siguiente comando de image magick:

 convert -delay 80 Gapminder*.png animated_gapminder.gif

El gif resultante se muestra a continuación:

En próximo artículo espero encontrar el conjunto de datos del artículo mencionado al inicio para hacerle una animación como el realizado en este artículo.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Contar palabras de un texto usando Spark con PySpark

2018-07-03T09:00:00-04:00

En el artículo anterior se explicó el procedimiento de instalación de Spark usando Docker. En este artículo se usará un texto tomado de la página de la ONU, de ahí se extrae las líneas y se cuentan las palabras.

A continuación el texto que se va a utilizar (lo pueden bajar desde el repositorio gitlab):

1942: La Declaración de las Naciones Unidas
Representantes de 26 Estados que lucharon contra las potencias del Eje Roma-Berlín-Tokio manifestaron su apoyo a la Carta del Atlántico mediante su firma de la « Declaración de las Naciones Unidas ». En este trascendental documento, los signatarios se comprometían a poner su máximo empeño en la guerra y a no firmar una paz por separado. 


Declaración de las Naciones Unidas prometiendo "emplear todos sus recursos, militares o económicos" en "la lucha por la victoria sobre el hitlerismo".
El día de año nuevo de 1942, el señor presidente Roosevelt y los señores Winston Churchill, Maxim Litvinov, de la Unión Soviética, y T. V. Soong, de China, firmaron un breve documento que luego se conocería como la Declaración de las Naciones Unidas. Al día siguiente se sumaron los representantes de otras 22 naciones más. En este trascendental documento, los signatarios se comprometían a poner su máximo empeño en la guerra y a no firmar una paz por separado.

La Declaración de las Naciones Unidas
La alianza completa a que se llegó en esta forma concordaba con los principios enunciados en la Carta del Atlántico, y la primera cláusula de la declaración de las Naciones Unidas reza que los países signatarios 

« . . . han suscrito un programa común de propósitos y principios enunciados en la declaración conjunta del presidente de los Estados Unidos de América y del primer ministro del Reino Unido de la Gran Bretaña e Irlanda del Norte, fechada el 14 de agosto de 1941, y conocida como la Carta del Atlántico. ».

Cuando tres años después se iniciaban los preparativos para la conferencia de San Francisco, únicamente se invitó a participar a aquellos estados que, en marzo de 1945, habían declarado la guerra a Alemania y al Japón y que habían firmado la Declaración de las Naciones Unidas.

Signatarios Originales de la Declaración de la ONU
Los 26 signatarios originales fueron: Los Estados Unidos de América, el Reino Unido de la Gran Bretaña e Irlanda del Norte, la Unión de Repúblicas Socialistas Soviéticas, China, Australia, Bélgica, Canadá, Costa Rica, Checoeslovaquia, El Salvador, Grecia, Guatemala, Haití, Honduras, India, Luxemburgo, Nicaragua, Noruega, Nueva Zelandia, Países Bajos, Panamá, Polonia, República Dominicana, Unión Sudafricana, Yugoeslavia .

Los firmantes posteriores
Más tarde se adhirieron a la Declaración los siguientes países (en el orden de las firmas): México, Colombia, Iraq, Irán, Liberia, Paraguay, Chile, Uruguay, Egipto, Siria, Francia, Filipinas, Brasil, Bolivia, Etiopía, Ecuador, Perú, Venezuela, Turquía, Arabia Saudita, Líbano.

A continuación se muestra la ejecución del código (si quieren bajar el archivo jupyter notebook lo pueden descargar desde gitlab):

In [1]:

#Se importa SparkContext y SparkConf
from pyspark import SparkContext, SparkConf

In [2]:

#Se crea la instancia de la configuración con el nombre de la aplicación contador
conf1 = SparkConf().setAppName("contador").setMaster("local[3]")

In [3]:

#Se crea el contexto pasando la instancia de la configuración
sc = SparkContext(conf = conf1)

In [4]:

#Se extrae las líneas del texto 
lineas = sc.textFile("data/declaracion_onut.text")

In [6]:

#Se extrae las palabras del texto y se cuentan
contarPalabras = lineas.flatMap(lambda linea: linea.split(" ")).countByValue()

In [7]:

#Se muestra las palabras con la cantidad de veces que tiene su aparición
for palabra, contador in contarPalabras.items():
    print("{} : {}".format(palabra, contador))

1942: : 1
La : 3
Declaración : 8
de : 29
las : 9
Naciones : 7
Unidas : 5
Representantes : 1
26 : 2
Estados : 3
que : 5
lucharon : 1
contra : 1
potencias : 1
del : 9
Eje : 1
Roma-Berlín-Tokio : 1
manifestaron : 1
su : 4
apoyo : 1
a : 10
la : 21
Carta : 3
Atlántico : 1
mediante : 1
firma : 1
« : 2
». : 2
En : 2
este : 2
trascendental : 2
documento, : 2
los : 9
signatarios : 4
se : 8
comprometían : 2
poner : 2
máximo : 2
empeño : 2
en : 7
guerra : 3
y : 10
no : 2
firmar : 2
una : 2
paz : 2
por : 3
separado. : 2
 : 9
prometiendo : 1
"emplear : 1
todos : 1
sus : 1
recursos, : 1
militares : 1
o : 1
económicos" : 1
"la : 1
lucha : 1
victoria : 1
sobre : 1
el : 5
hitlerismo". : 1
El : 2
día : 2
año : 1
nuevo : 1
1942, : 1
señor : 1
presidente : 2
Roosevelt : 1
señores : 1
Winston : 1
Churchill, : 1
Maxim : 1
Litvinov, : 1
Unión : 3
Soviética, : 1
T. : 1
V. : 1
Soong, : 1
China, : 2
firmaron : 1
un : 2
breve : 1
documento : 1
luego : 1
conocería : 1
como : 2
Unidas. : 2
Al : 1
siguiente : 1
sumaron : 1
representantes : 1
otras : 1
22 : 1
naciones : 1
más. : 1
alianza : 1
completa : 1
llegó : 1
esta : 1
forma : 1
concordaba : 1
con : 1
principios : 2
enunciados : 2
Atlántico, : 1
primera : 1
cláusula : 1
declaración : 2
reza : 1
países : 2
. : 4
han : 1
suscrito : 1
programa : 1
común : 1
propósitos : 1
conjunta : 1
Unidos : 2
América : 1
primer : 1
ministro : 1
Reino : 2
Unido : 2
Gran : 2
Bretaña : 2
e : 2
Irlanda : 2
Norte, : 2
fechada : 1
14 : 1
agosto : 1
1941, : 1
conocida : 1
Atlántico. : 1
Cuando : 1
tres : 1
años : 1
después : 1
iniciaban : 1
preparativos : 1
para : 1
conferencia : 1
San : 1
Francisco, : 1
únicamente : 1
invitó : 1
participar : 1
aquellos : 1
estados : 1
que, : 1
marzo : 1
1945, : 1
habían : 2
declarado : 1
Alemania : 1
al : 1
Japón : 1
firmado : 1
Signatarios : 1
Originales : 1
ONU : 1
Los : 3
originales : 1
fueron: : 1
América, : 1
Repúblicas : 1
Socialistas : 1
Soviéticas, : 1
Australia, : 1
Bélgica, : 1
Canadá, : 1
Costa : 1
Rica, : 1
Checoeslovaquia, : 1
Salvador, : 1
Grecia, : 1
Guatemala, : 1
Haití, : 1
Honduras, : 1
India, : 1
Luxemburgo, : 1
Nicaragua, : 1
Noruega, : 1
Nueva : 1
Zelandia, : 1
Países : 1
Bajos, : 1
Panamá, : 1
Polonia, : 1
República : 1
Dominicana, : 1
Sudafricana, : 1
Yugoeslavia : 1
firmantes : 1
posteriores : 1
Más : 1
tarde : 1
adhirieron : 1
siguientes : 1
(en : 1
orden : 1
firmas): : 1
México, : 1
Colombia, : 1
Iraq, : 1
Irán, : 1
Liberia, : 1
Paraguay, : 1
Chile, : 1
Uruguay, : 1
Egipto, : 1
Siria, : 1
Francia, : 1
Filipinas, : 1
Brasil, : 1
Bolivia, : 1
Etiopía, : 1
Ecuador, : 1
Perú, : 1
Venezuela, : 1
Turquía, : 1
Arabia : 1
Saudita, : 1
Líbano. : 1

Como se puede ver, se logra obtener la cantidad de veces que aparecen las palabras en el texto.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Como correr Apache Spark desde una imagen Docker

2018-07-02T09:00:00-04:00

En este artículo se explicará la ejecución de Apache Spark usando un contenedor Docker, en vez de usar el procedimiento de instalación de Spark (instalar java, scala y spark).

Apache Spark proporciona una interfaz para la programación de clusters completos con paralelismos de Datos implicito y tolerancia a fallos. Tiene la base de su arquitectura en el llamado RDD (Resilient Distributed Dataset, set de sólo lectura de datos distribuídos a lo largo de un cluster de máquinas que se mantiene en un entorno tolerante a fallos).

Se puede considerar un sistema de computación en clúster de propósito general y orientado a la velocidad, proporciona APIs en Java, Scala, Python y R. También proporciona un motor optimizado que soporta la ejecución de grafos.

También soporta una serie de herramientas de alto nivel como lo son:

Spark SQL ( para el procesamiento de datos estructurados basada en SQL).
MLlib para implementar machine learning.
GraphX para el procesamirnto de grafos.
Spark Streaming.

Más información en wikipedia.

La imagen docker que se va a usar es la de gettyimages/spark y de github.

Bajar la imagen docker:

docker pull gettyimages/spark

Bajar del repositorio github el repositorio de gettyimages/spark para usar docker-compose:

git clone https://github.com/gettyimages/docker-spark.git

Se cambia al directorio docker-sparck:

cd docker-spark

4 Archivo Dockerfile:

FROM debian:stretch
MAINTAINER Getty Images "https://github.com/gettyimages"

RUN apt-get update \
 && apt-get install -y locales \
 && dpkg-reconfigure -f noninteractive locales \
 && locale-gen C.UTF-8 \
 && /usr/sbin/update-locale LANG=C.UTF-8 \
 && echo "en_US.UTF-8 UTF-8" >> /etc/locale.gen \
 && locale-gen \
 && apt-get clean \
 && rm -rf /var/lib/apt/lists/*

# Users with other locales should set this in their derivative image
ENV LANG en_US.UTF-8
ENV LANGUAGE en_US:en
ENV LC_ALL en_US.UTF-8

RUN apt-get update \
 && apt-get install -y curl unzip \
    python3 python3-setuptools \
 && ln -s /usr/bin/python3 /usr/bin/python \
 && easy_install3 pip py4j \
 && apt-get clean \
 && rm -rf /var/lib/apt/lists/*

# http://blog.stuart.axelbrooke.com/python-3-on-spark-return-of-the-pythonhashseed
ENV PYTHONHASHSEED 0
ENV PYTHONIOENCODING UTF-8
ENV PIP_DISABLE_PIP_VERSION_CHECK 1

# JAVA
ARG JAVA_MAJOR_VERSION=8
ARG JAVA_UPDATE_VERSION=131
ARG JAVA_BUILD_NUMBER=11
ENV JAVA_HOME /usr/jdk1.${JAVA_MAJOR_VERSION}.0_${JAVA_UPDATE_VERSION}

ENV PATH $PATH:$JAVA_HOME/bin
RUN curl -sL --retry 3 --insecure \
  --header "Cookie: oraclelicense=accept-securebackup-cookie;" \
  "http://download.oracle.com/otn-pub/java/jdk/${JAVA_MAJOR_VERSION}u${JAVA_UPDATE_VERSION}-b${JAVA_BUILD_NUMBER}/d54c1d3a095b4ff2b6607d096fa80163/server-jre-${JAVA_MAJOR_VERSION}u${JAVA_UPDATE_VERSION}-linux-x64.tar.gz" \
  | gunzip \
  | tar x -C /usr/ \
  && ln -s $JAVA_HOME /usr/java \
  && rm -rf $JAVA_HOME/man

# HADOOP
ENV HADOOP_VERSION 3.0.0
ENV HADOOP_HOME /usr/hadoop-$HADOOP_VERSION
ENV HADOOP_CONF_DIR=$HADOOP_HOME/etc/hadoop
ENV PATH $PATH:$HADOOP_HOME/bin
RUN curl -sL --retry 3 \
  "http://archive.apache.org/dist/hadoop/common/hadoop-$HADOOP_VERSION/hadoop-$HADOOP_VERSION.tar.gz" \
  | gunzip \
  | tar -x -C /usr/ \
 && rm -rf $HADOOP_HOME/share/doc \
 && chown -R root:root $HADOOP_HOME

# SPARK
ENV SPARK_VERSION 2.3.0
ENV SPARK_PACKAGE spark-${SPARK_VERSION}-bin-without-hadoop
ENV SPARK_HOME /usr/spark-${SPARK_VERSION}
ENV SPARK_DIST_CLASSPATH="$HADOOP_HOME/etc/hadoop/*:$HADOOP_HOME/share/hadoop/common/lib/*:$HADOOP_HOME/share/hadoop/common/*:$HADOOP_HOME/share/hadoop/hdfs/*:$HADOOP_HOME/share/hadoop/hdfs/lib/*:$HADOOP_HOME/share/hadoop/hdfs/*:$HADOOP_HOME/share/hadoop/yarn/lib/*:$HADOOP_HOME/share/hadoop/yarn/*:$HADOOP_HOME/share/hadoop/mapreduce/lib/*:$HADOOP_HOME/share/hadoop/mapreduce/*:$HADOOP_HOME/share/hadoop/tools/lib/*"
ENV PATH $PATH:${SPARK_HOME}/bin
RUN curl -sL --retry 3 \
  "https://www.apache.org/dyn/mirrors/mirrors.cgi?action=download&filename=spark/spark-${SPARK_VERSION}/${SPARK_PACKAGE}.tgz" \
  | gunzip \
  | tar x -C /usr/ \
 && mv /usr/$SPARK_PACKAGE $SPARK_HOME \
 && chown -R root:root $SPARK_HOME

WORKDIR $SPARK_HOME
CMD ["bin/spark-class", "org.apache.spark.deploy.master.Master"]

El archivo docker-compose.yml:

master:
  image: gettyimages/spark
  command: bin/spark-class org.apache.spark.deploy.master.Master -h master
  hostname: master
  environment:
    MASTER: spark://master:7077
    SPARK_CONF_DIR: /conf
    SPARK_PUBLIC_DNS: localhost
  expose:
    - 7001
    - 7002
    - 7003
    - 7004
    - 7005
    - 7006
    - 7077
    - 6066
  ports:
    - 4040:4040
    - 6066:6066
    - 7077:7077
    - 9080:8080
  volumes:
    - ./conf/master:/conf
    - ./data:/tmp/data

worker:
  image: gettyimages/spark
  command: bin/spark-class org.apache.spark.deploy.worker.Worker spark://master:7077
  hostname: worker
  environment:
    SPARK_CONF_DIR: /conf
    SPARK_WORKER_CORES: 2
    SPARK_WORKER_MEMORY: 1g
    SPARK_WORKER_PORT: 8881
    SPARK_WORKER_WEBUI_PORT: 8081
    SPARK_PUBLIC_DNS: localhost
  links:
    - master
  expose:
    - 7012
    - 7013
    - 7014
    - 7015
    - 7016
    - 8881
  ports:
    - 8081:8081
  volumes:
    - ./conf/worker:/conf
    - ./data:/tmp/data

Se ejecuta docker-compose up:

docker-compose up

A continuación se muestra la ejecución del contenedor:

Ver los procesos:

docker-compose ps

A continuación el resultado:

Se tiene dos contenedores ejecutandose, uno es el master, que tiene el puerto 4040 abierto, entre otros puertos, y el otro contenedor es el worker.

Se abre el navegador en http://localhost:9080, a continuación una captura del navegador:

Ejecutar pyspark ejecuando dentro el contenedor master:

docker exec -it dockerspark_master_1 /bin/bash

11.1 Dentro del contenedor ejecutar pyspark:

bin/pyspark

A continuación se muestra la ejecución:

11.2 Al abrir el navegador se tiene una aplicación corriendo en el spark:

Para terminar se ejecuta SparkPi desde el contenedor master:

12.1 Se ingresa al contenedor de master:

docker exec -it dockerspark_master_1 /bin/bash

12.2 Se ejecuta SparkPi

bin/run-example SparkPi 10

12.3 Se muestra la ejecución de la aplicación de SparkPi:

En próximo artículo se usará el spark por medio de pyspark.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Visualización de Árbol de decisión

2018-06-17T09:00:00-04:00

Como en Noviembre del año pasado, escribí un artículo sobre árboles de decisión con Python, donde se tenía una serie de datos de entrada (altura, peso y talla) y de salida si era hombre o mujer. Para este artículo lo que se va a agregar es la visualización del árbol de decisión, para ello se usarán dos librerías de Python pydot y graphviz.

Se da por sentado que ya se tiene instalado scikit-learn, se instala entonces pydot y graphviz:

#pip3 install pydot
#pip3 install graphviz

Ahora se muestra el código:

Ahora toca la visualización del árbol:

Para terminar se muestra el grafo del árbol:

Este grafo se genera a partir de la instancia de la clase que se usa para ingresar los datos, se entrena, y se usa para predecir con nuevos datos. La información que muestra cada nodo de decisión:

Samples: La cantidad de muestras que se maneja.
gini: Es un indice que indica el costo de la evaluación de separar los datos.
value: Es un valor que se está evaluando en ese momento.

El código de este artículo lo pueden ver en el notebook que se encuentra en el repositorio de gitlab.

En próximo artículo se hará otro ejemplo ya con un mayor conjunto de datos.

Sí tienes algun pregunta u observación, puedes hacerlo en los comentarios del post.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Análisis de Sentimiento de tweets con Python, TextBlob y tweepy

2018-06-10T09:00:00-04:00

Existe el área de análisis de redes sociales, puedes hacer gráficos de tendencias, lograr cual fue el origen de un tweet. La idea es usar la librería tweepy para conectase a Twitter y de allí capturar los tweets para luego realizar un análisis de sentimiento y graficar el resultado.

El análisis de sentimiento se refiere al uso de procesamiento de lenguaje natural, análisis de texto y lingüistica computacional para identificar y extraer información subjetiva de los recursos (más información en wikipedia).

Se puede realizar análisis de sentimiento a cualquier texto, puede ser de correos, de páginas web, de publicaciones en redes sociales como twitter, facebook, google+, entre otros. Con ello se puede lograr un aproximado de la evaluación emocional que tiene un tema o persona en algún momento en las redes sociales o contenidos evaluados.

La idea es obtener el tráfico de twitter sobre un tema o persona, aplicarle análisis de sentimiento y graficar los resultados.

Este artículo se basa en un artículo en inglés publicado en freecodecamp con título Basic data analysis on Twitter with Python. Este artículo se desarrolla una aplicación gráfica en TK para obtener la información y luego realizar la captura, cálculos y gráficos. El código fuente de la aplicación del artículo se encuentra en github.

Para tener acceso al API de twitter se tiene que crear una cuenta en la página para las aplicaciones que lo requieran.

Para autenticarse se usará el siguiente código:

consumer_key = 'consumer key'
consumer_secret = 'consumer secrets'
access_token = 'access token'
access_token_secret = 'access token secret'

auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)
api = tweepy.API(auth)

En este caso se usará jupyter lab para mostrar la aplicación con ajustes en el código para su reutilización, por ejemplo, que realice el análisis en Español o Inglés.

La librería a usar será tweepy, la librería para análisis de texto TextBlob y matplotlib.

Para instalar tweepy se usará pip3:

pip3 install tweepy textblob

Revisemos primero las tendencias en twitter para Valencia (Venezuela), a continuación una imagen de las tendencias.

Se buscará el análisis de sentimiento de la tendencia Rafael Nadal, se buscará en 200 tweets y en español.

A continuación el código fuente:

El código fuente en el repositorio de gitlab lo pueden ver en el enlace.

#!/usr/bin/env python3



#Se importa la librería tweepy

import tweepy

#Se importa sleep, datetime, TextBlob y matplotlib

from time import sleep

from datetime import datetime

from textblob import TextBlob 

import matplotlib.pyplot as plt 



#Se define las variables para el acceso al API de twitter

consumer_key = ''

consumer_secret = ''

access_token = ''

access_token_secret = ''



#Se autentica en twitter

auth = tweepy.OAuthHandler(consumer_key, consumer_secret)

auth.set_access_token(access_token, access_token_secret)

api = tweepy.API(auth)



#se verifica que el usuario conectado en twitter es de uno

print(api.me().name)



#Se pregunta por la palabra a preguntar

palabra = input("Buscar: ")



#Se define la cantida de tweets a capturar

numero_de_Tweets = int(input(u"Número de tweets a capturar: "))



#Se define el idioma de los tweets a analizar

lenguaje = input("Idioma [es/en]:")





def ObtenerTweets(palabra="Trump",times=100,leguanje="en"):

    #Se define las listas que capturan la popularidad

    popularidad_list = []

    numeros_list = []

    numero = 1

    for tweet in tweepy.Cursor(api.search, palabra, lang=lenguaje).items(numero_de_Tweets):

        try:

            #Se toma el texto, se hace el analisis de sentimiento

            #y se agrega el resultado a las listas

            analisis = TextBlob(tweet.text)

            analisis = analisis.sentiment

            popularidad = analisis.polarity

            popularidad_list.append(popularidad)

            numeros_list.append(numero)

            numero = numero + 1



        except tweepy.TweepError as e:

            print(e.reason)



        except StopIteration:

            break

    return (numeros_list,popularidad_list,numero)





def GraficarDatos(numeros_list,popularidad_list,numero):

    axes = plt.gca()

    axes.set_ylim([-1, 2])



    plt.scatter(numeros_list, popularidad_list)

    popularidadPromedio = (sum(popularidad_list))/(len(popularidad_list))

    popularidadPromedio = "{0:.0f}%".format(popularidadPromedio * 100)

    time  = datetime.now().strftime("A : %H:%M\n El: %m-%d-%y")

    plt.text(0, 1.25, 

             "Sentimiento promedio:  " + str(popularidadPromedio) + "\n" + time, 

             fontsize=12, 

             bbox = dict(facecolor='none', 

                         edgecolor='black', 

                         boxstyle='square, pad = 1'))



    plt.title("Sentimientos sobre " + palabra + " en twitter")

    plt.xlabel("Numero de tweets")

    plt.ylabel("Sentimiento")

    plt.show()





numeros_list,popularidad_list,numero = ObtenerTweets(palabra,numero_de_Tweets,lenguaje)

GraficarDatos(numeros_list,popularidad_list,numero)

Al ejecutar el programa se tiene la siguiente gráfica.

Para el caso de Nadal, tiene un valor promedio positivo, habrá casos donde el sentimiento sea de un valor negativo, pero para este caso, lo mejor es ampliar la cantidad de tweets a capturar para tener una mejor aproximación del sentimiento de la gente de lo que habla en twitter de Nadal.

Sí tienes alguna pregunta u observación, puedes hacerlo en los comentarios del post.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Visualizando series de tiempo de precios del mercado con pandas y matplotlib

2018-06-06T09:00:00-04:00

En este artículo la fuente de datos se usará la librería de Quandl directamente. La idea es obtener los precios de mercado de 3 Aerolineas (Delta con código DAL, Jet Blue con código JBLU y Southwest con código LUV). Se gráfica el historico de los precios de cierre, el volumen de ventas y movimientos promedios de estas tres aerolineas.

Continuando con los artículos sobre Pandas y Ciencia de Datos Data Science, en el artículo anterior se mostró como trabajar con Series de tiempo obteniendo datos desde Quandl.

Este artículo se basa en un artículo en inglés que se títula Visualizing Time Series Data of Stock Prices (en este artículo usan la librería pandas_datareader, pero está dando errores, así que se usará la librería Quandl).

El código del ejercicio se muestra a continuación:

Visualizando

Graficar Ajuste de precio de cierre

Se va a graficar el Ajuste de precio de cierre de las 3 aerolineas.

Graficar el Volumen (Volume)

Se puede notar que la aerolinea Delta tiene un pico muy alto en algún momento del año 2013. Para obtener la fecha se usa el método idxmax.

Movimientos promedios MA

Los movimientos promedios se usan para detectar oportunidades de trading. Este cálculo se toma de la media o promedio de los pasados precios (se llama movimientos promedio por que los datos están continuamente moviéndose). Dependiendo del tipo de inversor (alto riesgo vs bajo riesgo, corto término vs largo término), se pueden ajustar los movimientos promedio a 10 días, 20 días, 50 días, 200 días, 1 año, 5 años, etc. Para este caso se calculará el movimiento promedio a 50 días y a 200 días.

El raw del notebook lo pueden bajar del repositorio gitlab.

Si tienes alguna sugerencia o idea de como se puede aplicar este artículo, lo puedes dejar en los comentarios.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Como obtener datos Financieros de Quandl con Python y Pandas

2018-05-25T09:00:00-04:00

La idea de este artículo es explicar de manera básica el uso de Pandas para obtener datos financieros, en este caso el valor de las divisas de Países como Argentina, Brasil, Chile, Mexico y Venezuela. Quandl es una plataforma financiera y económica de datos alternativos que sirve para inversores profesionales. El API de Quandl permite el acceso a sus datos por medio de Lenguaje R, Python, Matlab, Maple y Stata. Más información en wikipedia y en su página.

Para este caso se accederá a los datos vía Python y se visualizará por medio de Pandas y matplotlib.

La información de Quandl para los países:
- Venezuela : Dicom y Dolar Today
- Argentina
- Brasil
- Chile
- México

El proceso sería el siguiente:

Importar librerías
Acceso a los datos de los países en Quandl
Ordenar las columnas, eliminar NaN.
Crear portafolio
Visualizar los datos

Los códigos para acceder a los datos los pueden ver por ejemplo para México en la siguiente imagen.

Página de Quandl de la información del Dolar para México

Se importan las librerías pandas, quandl y matplotlib

Se definen las fechas de inicio y fin del analísis

Obtener datos de quandl

Se visualizan los datos de Dicom y Dolar today

Se crea el portafolio donde se agrupa todas las cotizaciones

Se descartan los campos NaN y se renombran las columnas

Se gráfican todas las cotizaciones

Gráfica de Argentina

Gráfica de Brasil

Gráfia de Chile

Gráfica de México

Gŕafica de Venezuela

Gráfica Dicom y Dolar Today por separado

El notebook lo pueden ver completo en:
ecrespo/articulos-cienciadedatos Contribute to articulos-cienciadedatos development by creating an account on GitHub.github.com

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Algoritmo de Clasificación con scikit-learn

2018-04-21T09:00:00-04:00

Continuando con los artículos sobre Inteligencia Artificial con Python.

La serie de artículos sobre Scikit-Learn han sido:

Árbol de decisión hecho con Python (esté tendrá una segunda parte).
Una red neuronal para aprendizaje supervisado usando scikit-learn.
Funciones de activación para un perceptron.

El ejercicio que se explicará será el de algoritmo de clasificación usando scikit-learn por medio del ejemplo de la resolución de la tabla de la verdad de un Or exclusivo (XOR).

Scikit-learn es una librería de Machine Learning para Python que soporta algoritmos de clasificación, regresión y clustering (wikipedia).

A continuación el notebook de jupyter:

Se creará una red neuronal para clasificación

Se usará la tabla de la verdad de XOR x y Salida 0 0 0
0 1 1
1 0 1
1 1 0

Para instalar scikit-learn se usa pip

pip3 install scikit-learn

In [4]:

##Se importa Numpy, MLPCCLassifier y KNeighborsClassifier
import numpy as np
from sklearn.neural_network import MLPClassifier
from sklearn.neighbors import KNeighborsClassifier

In [5]:

#un Arreglo con la tabla de la verdad
# 0 0
# 0 1
# 1 0
# 1 1
xs = np.array([
    0, 0,
    0, 1,
    1, 0,
    1, 1
]).reshape(4, 2)
xs

Out[5]:

array([[0, 0],
       [0, 1],
       [1, 0],
       [1, 1]])

In [6]:

#Se muestra un arreglo con el resultado de hacer un XOR
ys = np.array([0, 1, 1, 0]).reshape(4,)
ys

Out[6]:

array([0, 1, 1, 0])

In [7]:

#Se crea el clasificador con la función de activación relu,con 10k iteraciones y tiene capaz ocultas 4,2
model = MLPClassifier(activation='tanh', max_iter=10000, hidden_layer_sizes=(4,2))
model

Out[7]:

MLPClassifier(activation='tanh', alpha=0.0001, batch_size='auto', beta_1=0.9,
       beta_2=0.999, early_stopping=False, epsilon=1e-08,
       hidden_layer_sizes=(4, 2), learning_rate='constant',
       learning_rate_init=0.001, max_iter=10000, momentum=0.9,
       nesterovs_momentum=True, power_t=0.5, random_state=None,
       shuffle=True, solver='adam', tol=0.0001, validation_fraction=0.1,
       verbose=False, warm_start=False)

In [8]:

#Se entrena la red neuronal pasando los arreglos de entrada y de salida
model.fit(xs, ys)

Out[8]:

MLPClassifier(activation='tanh', alpha=0.0001, batch_size='auto', beta_1=0.9,
       beta_2=0.999, early_stopping=False, epsilon=1e-08,
       hidden_layer_sizes=(4, 2), learning_rate='constant',
       learning_rate_init=0.001, max_iter=10000, momentum=0.9,
       nesterovs_momentum=True, power_t=0.5, random_state=None,
       shuffle=True, solver='adam', tol=0.0001, validation_fraction=0.1,
       verbose=False, warm_start=False)

In [9]:

print('prediccion:', model.predict(xs)) # salida 0110
prediccion: [0 1 1 0]

In [10]:

print('Se espera:', np.array([0, 1, 1, 0]))
Se espera: [0 1 1 0]

Otro ejercicio Entrada Salida 001 0
111 1
101 1
011 0
100 ?

In [11]:

#Se importa de numpy array
from numpy import array

In [12]:

#Datos de entrada y de salida
datos_entrada = array([[0, 0, 1], [1, 1, 1], [1, 0, 1], [0, 1, 1]]).reshape(4, 3)
datos_salida = array([[0, 1, 1, 0]]).reshape(4, )
print(datos_entrada)
print ("-"*4)
print(datos_salida)
[[0 0 1]
 [1 1 1]
 [1 0 1]
 [0 1 1]]
----
[0 1 1 0]

In [13]:

#En este caso se usa KNeighborsClassifier con 2 capaz
KNC = KNeighborsClassifier(n_neighbors= 2)

In [14]:

KNC.fit(datos_entrada,datos_salida)

Out[14]:

KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',
           metric_params=None, n_jobs=1, n_neighbors=2, p=2,
           weights='uniform')

In [15]:

#Se predice el valor de 1,0,0 que da como resultado el mismo del artículo anterior.
print(KNC.predict([[1, 0,0]]))
[1]

In [16]:

#Se crea la red de nuevo pero ahora con PLPCCLassifier.
#Se crea el clasificador con la función de activación relu,con 10k iteraciones y tiene capaz ocultas 4,2
KNC = MLPClassifier(activation='tanh', max_iter=10000, hidden_layer_sizes=(4,2))

In [17]:

#Se entrena la red neuronal pasando los arreglos de entrada y de salida
KNC.fit(datos_entrada, datos_salida)

Out[17]:

MLPClassifier(activation='tanh', alpha=0.0001, batch_size='auto', beta_1=0.9,
       beta_2=0.999, early_stopping=False, epsilon=1e-08,
       hidden_layer_sizes=(4, 2), learning_rate='constant',
       learning_rate_init=0.001, max_iter=10000, momentum=0.9,
       nesterovs_momentum=True, power_t=0.5, random_state=None,
       shuffle=True, solver='adam', tol=0.0001, validation_fraction=0.1,
       verbose=False, warm_start=False)

In [18]:

#Se predice el valor de 1,0,0 que da como resultado el mismo del artículo anterior.
print(KNC.predict([[1, 0,0]]))
[1]

En el siguiente artículo se explicará otro ejemplo de Árbol de decisión usando scikit-learn.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

WebScraping (extracción de datos) de wikipedia con Pandas

2018-04-19T09:00:00-04:00

Continuando con la serie de artículos sobre Pandas, en este artículo se muestra un proceso de extracción de datos web de la página que contiene información sobre los Estados de Venezuela de Wikipedia.

En los procesos anteriores de WebScraping se trabajaba practicamente a mano para indentificar las secciones del código html donde se encuentra la información útil, para el caso con Pandas este abstrae ese proceso.

A continuación se muestra una captura de pantalla de la página donde se quiere extraer la información:

La información que maneja la página son los estados con sus capitales, densidad poblacional, superficie, año de admisión, población, densidad, región y código ISO, la parte de la bandera ni del mapa no se muestra por que son imágenes y no se obtiene información útil de ellas.

A continuación todo el proceso de extracción de información de la página:

In [1]:

#Se importa pandas como pd
import pandas as pd
#Se lee los datos de wikipedia de los estados de venezuela, este devuelve una lista
estados=   pd.read_html('https://es.wikipedia.org/wiki/Estados_de_Venezuela') 
estados

Out[1]:

[    0                                                  1
 0 NaN  Este artículo o sección necesita referencias q...,
                                                    0
 0                     Estados Federales de Venezuela
 1  Bolívar Amazonas Apure Zulia Táchira Barinas M...,
           0                       1                       2           3  \
 0   Bandera         Entidad federal                 Capital  Código ISO   
 1       NaN                Amazonas         Puerto Ayacucho        VE-Z   
 2       NaN              Anzoátegui               Barcelona        VE-B   
 3       NaN                   Apure   San Fernando de Apure        VE-C   
 4       NaN                  Aragua                 Maracay        VE-D   
 5       NaN                 Barinas                 Barinas        VE-E   
 6       NaN                 Bolívar          Ciudad Bolívar        VE-F   
 7       NaN                Carabobo                Valencia        VE-G   
 8       NaN                 Cojedes              San Carlos        VE-H   
 9       NaN           Delta Amacuro                Tucupita        VE-Y   
 10      NaN        Distrito Capital                 Caracas        VE-A   
 11      NaN                  Falcón                    Coro        VE-I   
 12      NaN                 Guárico  San Juan de Los Morros        VE-J   
 13      NaN                    Lara            Barquisimeto        VE-K   
 14      NaN                  Mérida                  Mérida        VE-L   
 15      NaN                 Miranda              Los Teques        VE-M   
 16      NaN                 Monagas                 Maturín        VE-N   
 17      NaN           Nueva Esparta             La Asunción        VE-O   
 18      NaN              Portuguesa                 Guanare        VE-P   
 19      NaN                   Sucre                  Cumaná        VE-R   
 20      NaN                 Táchira           San Cristóbal        VE-S   
 21      NaN                Trujillo                Trujillo        VE-T   
 22      NaN                  Vargas               La Guaira        VE-X   
 23      NaN                 Yaracuy              San Felipe        VE-U   
 24      NaN                   Zulia               Maracaibo        VE-V   
 25      NaN  Dependencias Federales              Gran Roque        VE-W   

                   4                                 5  \
 0   Año de admisión              Población (2011)[2]   
 1              1992    &&&&&&&&&0161844.&&&&&0161 844   
 2              1909  &&&&&&&&02179838.&&&&&02 179 838   
 3              1864    &&&&&&&&&0501404.&&&&&0501 404   
 4              1909  &&&&&&&&01819630.&&&&&01 819 630   
 5              1937    &&&&&&&&&0853949.&&&&&0853 949   
 6              1901  &&&&&&&&02069064.&&&&&02 069 064   
 7              1865  &&&&&&&&02342665.&&&&&02 342 665   
 8              1864    &&&&&&&&&0367020.&&&&&0367 020   
 9              1992    &&&&&&&&&0180363.&&&&&0180 363   
 10             1999  &&&&&&&&04033186.&&&&&04 033 186   
 11             1872  &&&&&&&&01064615.&&&&&01 064 615   
 12             1864    &&&&&&&&&0746174.&&&&&0746 174   
 13             1909  &&&&&&&&01892439.&&&&&01 892 439   
 14             1909    &&&&&&&&&0903955.&&&&&0903 955   
 15             1909  &&&&&&&&03112851.&&&&&03 112 851   
 16             1909    &&&&&&&&&0938185.&&&&&0938 185   
 17             1909    &&&&&&&&&0525139.&&&&&0525 139   
 18             1909    &&&&&&&&&0897104.&&&&&0897 104   
 19             1909    &&&&&&&&&0892990.&&&&&0892 990   
 20             1899  &&&&&&&&01277241.&&&&&01 277 241   
 21             1864    &&&&&&&&&0901239.&&&&&0901 239   
 22             1998    &&&&&&&&&0419928.&&&&&0419 928   
 23             1899    &&&&&&&&&0645688.&&&&&0645 688   
 24             1864  &&&&&&&&04694856.&&&&&04 694 856   
 25             1938       &&&&&&&&&&&02155.&&&&&02155   

                                  6                              7  \
 0                 Superficie (km²)             Densidad (hab/km²)   
 1   &&&&&&&&&0177617.&&&&&0177 617    &&&&&&&&&&&&&&00.9900000,99   
 2    &&&&&&&&&&043300.&&&&&043 300    &&&&&&&&&&&&&033.90000033,9   
 3    &&&&&&&&&&076500.&&&&&076 500     &&&&&&&&&&&&&&06.&&&&&06,0   
 4      &&&&&&&&&&&07014.&&&&&07014   &&&&&&&&&&&&0235.600000235,6   
 5    &&&&&&&&&&035200.&&&&&035 200    &&&&&&&&&&&&&023.20000023,2   
 6   &&&&&&&&&0240528.&&&&&0240 528    &&&&&&&&&&&&&&07.8700007,87   
 7      &&&&&&&&&&&04650.&&&&&04650  &&&&&&&&&&&&0713.&10000713,01   
 8    &&&&&&&&&&014800.&&&&&014 800    &&&&&&&&&&&&&021.80000021,8   
 9    &&&&&&&&&&040200.&&&&&040 200    &&&&&&&&&&&&&&04.6500004,65   
 10      &&&&&&&&&&&&0433.&&&&&0433  &&&&&&&&&&&07246.4000007246,4   
 11   &&&&&&&&&&024800.&&&&&024 800    &&&&&&&&&&&&&036.40000036,4   
 12   &&&&&&&&&&064986.&&&&&064 986    &&&&&&&&&&&&&011.50000011,5   
 13   &&&&&&&&&&019800.&&&&&019 800    &&&&&&&&&&&&&089.60000089,6   
 14   &&&&&&&&&&011300.&&&&&011 300    &&&&&&&&&&&&&092.80000092,8   
 15     &&&&&&&&&&&07950.&&&&&07950   &&&&&&&&&&&&0336.500000336,5   
 16   &&&&&&&&&&028900.&&&&&028 900    &&&&&&&&&&&&&031.30000031,3   
 17     &&&&&&&&&&&01150.&&&&&01150  &&&&&&&&&&&&0480.&10000480,01   
 18   &&&&&&&&&&015200.&&&&&015 200    &&&&&&&&&&&&&057.70000057,7   
 19   &&&&&&&&&&011800.&&&&&011 800    &&&&&&&&&&&&&076.&&&&&076,0   
 20   &&&&&&&&&&011100.&&&&&011 100   &&&&&&&&&&&&0105.300000105,3   
 21     &&&&&&&&&&&07400.&&&&&07400    &&&&&&&&&&&&&092.80000092,8   
 22     &&&&&&&&&&&01497.&&&&&01497   &&&&&&&&&&&&0235.800000235,8   
 23     &&&&&&&&&&&07100.&&&&&07100    &&&&&&&&&&&&&084.60000084,6   
 24   &&&&&&&&&&063100.&&&&&063 100    &&&&&&&&&&&&&073.70000073,7   
 25      &&&&&&&&&&&&0120.&&&&&0120    &&&&&&&&&&&&&018.&&&&&018,0   

                     8     9  
 0              Región  Mapa  
 1             Guayana   NaN  
 2      Nor - Oriental   NaN  
 3              Llanos   NaN  
 4             Central   NaN  
 5              Andina   NaN  
 6             Guayana   NaN  
 7             Central   NaN  
 8             Central   NaN  
 9             Guayana   NaN  
 10            Capital   NaN  
 11  Centro-Occidental   NaN  
 12             Llanos   NaN  
 13  Centro-Occidental   NaN  
 14             Andina   NaN  
 15            Capital   NaN  
 16     Nor - Oriental   NaN  
 17            Insular   NaN  
 18  Centro-Occidental   NaN  
 19     Nor - Oriental   NaN  
 20             Andina   NaN  
 21             Andina   NaN  
 22            Capital   NaN  
 23  Centro-Occidental   NaN  
 24            Zuliana   NaN  
 25            Insular   NaN  ]

In [2]:

#Tipo de los estados
type(estados)

Out[2]:

list

In [3]:

#Tipo del primer elemento es un dataframe
type(estados[0])

Out[3]:

pandas.core.frame.DataFrame

In [4]:

#Se listan del dataframe estados y capitales (elementos 1 y 2 del dataframe, y se recorre)
for i in range(1,26):
    print(estados[2][1][i],estados[2][2][i])
Amazonas Puerto Ayacucho
Anzoátegui Barcelona
Apure San Fernando de Apure
Aragua Maracay
Barinas Barinas
Bolívar Ciudad Bolívar
Carabobo Valencia
Cojedes San Carlos
Delta Amacuro Tucupita
Distrito Capital Caracas
Falcón Coro
Guárico San Juan de Los Morros
Lara Barquisimeto
Mérida Mérida
Miranda Los Teques
Monagas Maturín
Nueva Esparta La Asunción
Portuguesa Guanare
Sucre Cumaná
Táchira San Cristóbal
Trujillo Trujillo
Vargas La Guaira
Yaracuy San Felipe
Zulia Maracaibo
Dependencias Federales Gran Roque

In [5]:

#Ahora se crea una lista de diccionarios donde estará la información de cada estado
lista = []
for i in range(1,26):
    lista.append({'Estado':estados[2][1][i],
                  'Capital': estados[2][2][i],
                  'codigo_iso': estados[2][3][i],
                  u'año_admision': estados[2][4][i],
                  'Poblacion': int(estados[2][5][i].split(".")[0].split("&")[-1]),
                  'Superficie': int(estados[2][6][i].split(".")[0].split("&")[-1]),
                  'Densidad': float(estados[2][7][i].split(",")[0].split("&")[-1]),
                  'Region': estados[2][8][i]
                 })

print(lista)
[{'Region': 'Guayana', 'Densidad': 0.99, 'Superficie': 177617, 'Estado': 'Amazonas', 'codigo_iso': 'VE-Z', 'Poblacion': 161844, 'Capital': 'Puerto Ayacucho', 'año_admision': '1992'}, {'Region': 'Nor - Oriental', 'Densidad': 33.90000033, 'Superficie': 43300, 'Estado': 'Anzoátegui', 'codigo_iso': 'VE-B', 'Poblacion': 2179838, 'Capital': 'Barcelona', 'año_admision': '1909'}, {'Region': 'Llanos', 'Densidad': 6.0, 'Superficie': 76500, 'Estado': 'Apure', 'codigo_iso': 'VE-C', 'Poblacion': 501404, 'Capital': 'San Fernando de Apure', 'año_admision': '1864'}, {'Region': 'Central', 'Densidad': 235.600000235, 'Superficie': 7014, 'Estado': 'Aragua', 'codigo_iso': 'VE-D', 'Poblacion': 1819630, 'Capital': 'Maracay', 'año_admision': '1909'}, {'Region': 'Andina', 'Densidad': 23.20000023, 'Superficie': 35200, 'Estado': 'Barinas', 'codigo_iso': 'VE-E', 'Poblacion': 853949, 'Capital': 'Barinas', 'año_admision': '1937'}, {'Region': 'Guayana', 'Densidad': 7.8700007, 'Superficie': 240528, 'Estado': 'Bolívar', 'codigo_iso': 'VE-F', 'Poblacion': 2069064, 'Capital': 'Ciudad Bolívar', 'año_admision': '1901'}, {'Region': 'Central', 'Densidad': 10000713.0, 'Superficie': 4650, 'Estado': 'Carabobo', 'codigo_iso': 'VE-G', 'Poblacion': 2342665, 'Capital': 'Valencia', 'año_admision': '1865'}, {'Region': 'Central', 'Densidad': 21.80000021, 'Superficie': 14800, 'Estado': 'Cojedes', 'codigo_iso': 'VE-H', 'Poblacion': 367020, 'Capital': 'San Carlos', 'año_admision': '1864'}, {'Region': 'Guayana', 'Densidad': 4.6500004, 'Superficie': 40200, 'Estado': 'Delta Amacuro', 'codigo_iso': 'VE-Y', 'Poblacion': 180363, 'Capital': 'Tucupita', 'año_admision': '1992'}, {'Region': 'Capital', 'Densidad': 7246.4000007246, 'Superficie': 433, 'Estado': 'Distrito Capital', 'codigo_iso': 'VE-A', 'Poblacion': 4033186, 'Capital': 'Caracas', 'año_admision': '1999'}, {'Region': 'Centro-Occidental', 'Densidad': 36.40000036, 'Superficie': 24800, 'Estado': 'Falcón', 'codigo_iso': 'VE-I', 'Poblacion': 1064615, 'Capital': 'Coro', 'año_admision': '1872'}, {'Region': 'Llanos', 'Densidad': 11.50000011, 'Superficie': 64986, 'Estado': 'Guárico', 'codigo_iso': 'VE-J', 'Poblacion': 746174, 'Capital': 'San Juan de Los Morros', 'año_admision': '1864'}, {'Region': 'Centro-Occidental', 'Densidad': 89.60000089, 'Superficie': 19800, 'Estado': 'Lara', 'codigo_iso': 'VE-K', 'Poblacion': 1892439, 'Capital': 'Barquisimeto', 'año_admision': '1909'}, {'Region': 'Andina', 'Densidad': 92.80000092, 'Superficie': 11300, 'Estado': 'Mérida', 'codigo_iso': 'VE-L', 'Poblacion': 903955, 'Capital': 'Mérida', 'año_admision': '1909'}, {'Region': 'Capital', 'Densidad': 336.500000336, 'Superficie': 7950, 'Estado': 'Miranda', 'codigo_iso': 'VE-M', 'Poblacion': 3112851, 'Capital': 'Los Teques', 'año_admision': '1909'}, {'Region': 'Nor - Oriental', 'Densidad': 31.30000031, 'Superficie': 28900, 'Estado': 'Monagas', 'codigo_iso': 'VE-N', 'Poblacion': 938185, 'Capital': 'Maturín', 'año_admision': '1909'}, {'Region': 'Insular', 'Densidad': 10000480.0, 'Superficie': 1150, 'Estado': 'Nueva Esparta', 'codigo_iso': 'VE-O', 'Poblacion': 525139, 'Capital': 'La Asunción', 'año_admision': '1909'}, {'Region': 'Centro-Occidental', 'Densidad': 57.70000057, 'Superficie': 15200, 'Estado': 'Portuguesa', 'codigo_iso': 'VE-P', 'Poblacion': 897104, 'Capital': 'Guanare', 'año_admision': '1909'}, {'Region': 'Nor - Oriental', 'Densidad': 76.0, 'Superficie': 11800, 'Estado': 'Sucre', 'codigo_iso': 'VE-R', 'Poblacion': 892990, 'Capital': 'Cumaná', 'año_admision': '1909'}, {'Region': 'Andina', 'Densidad': 105.300000105, 'Superficie': 11100, 'Estado': 'Táchira', 'codigo_iso': 'VE-S', 'Poblacion': 1277241, 'Capital': 'San Cristóbal', 'año_admision': '1899'}, {'Region': 'Andina', 'Densidad': 92.80000092, 'Superficie': 7400, 'Estado': 'Trujillo', 'codigo_iso': 'VE-T', 'Poblacion': 901239, 'Capital': 'Trujillo', 'año_admision': '1864'}, {'Region': 'Capital', 'Densidad': 235.800000235, 'Superficie': 1497, 'Estado': 'Vargas', 'codigo_iso': 'VE-X', 'Poblacion': 419928, 'Capital': 'La Guaira', 'año_admision': '1998'}, {'Region': 'Centro-Occidental', 'Densidad': 84.60000084, 'Superficie': 7100, 'Estado': 'Yaracuy', 'codigo_iso': 'VE-U', 'Poblacion': 645688, 'Capital': 'San Felipe', 'año_admision': '1899'}, {'Region': 'Zuliana', 'Densidad': 73.70000073, 'Superficie': 63100, 'Estado': 'Zulia', 'codigo_iso': 'VE-V', 'Poblacion': 4694856, 'Capital': 'Maracaibo', 'año_admision': '1864'}, {'Region': 'Insular', 'Densidad': 18.0, 'Superficie': 120, 'Estado': 'Dependencias Federales', 'codigo_iso': 'VE-W', 'Poblacion': 2155, 'Capital': 'Gran Roque', 'año_admision': '1938'}]

In [6]:

#Luego se crea un dataframe de la lista de diccionarios
df = pd.DataFrame(lista)
df

Out[6]: | ID | Capital | Densidad | Estado | Poblacion | Region | Superficie | año_admision | codigo_iso | | :- | :----------------: | :----------: | :------------- | :------: | :-------------: | :------- | :-----: | :-------: | | 0 | Puerto Ayacucho | 9.900000e-01 | Amazonas | 161844 | Guayana | 177617 | 1992 | VE-Z | | 1 | Barcelona | 3.390000e+01 | Anzoátegui | 2179838 | Nor - Oriental | 43300 | 1909 | VE-B | | 2 | San Fernando de Apure | 6.000000e+00 | Apure | 501404 | Llanos | 76500 | 1864 | VE-C | | 3 | Maracay | 2.356000e+02 | Aragua | 1819630 | Central | 7014 | 1909 | VE-D | | 4 | Barinas | 2.320000e+01 | Barinas | 853949 | Andina | 35200 | 1937 | VE-E | | 5 | Ciudad Bolívar | 7.870001e+00 | Bolívar | 2069064 | Guayana | 240528 | 1901 | VE-F | | 6 | Valencia | 1.000071e+07 | Carabobo | 2342665 | Central | 4650 | 1865 | VE-G | | 7 | San Carlos | 2.180000e+01 | Cojedes | 367020 | Central | 14800 | 1864 | VE-H | | 8 | Tucupita | 4.650000e+00 | Delta Amacuro | 180363 | Guayana | 40200 | 1992 | VE-Y | | 9 | Caracas | 7.246400e+03 | Distrito Capital| 4033186 | Capital | 433 | 1999 | VE-A | | 10 | Coro | 3.640000e+01 | Falcón | 1064615 |Centro-Occidental | 24800 | 1872 | VE-I | | 11 | San Juan de Los Morros| 1.150000e+01 | Guárico | 746174 | Llanos | 64986 | 1864 | VE-J | | 12 | Barquisimeto | 8.960000e+01 | Lara | 1892439 | Centro-Occidental| 19800 | 1909 | VE-K | | 13 | Mérida | 9.280000e+01 | Mérida | 903955 | Andina | 11300 | 1909 | VE-L | | 14 | Los Teques | 3.365000e+02 | Miranda | 3112851 | Capital | 7950 | 1909 | VE-M | | 15 | Maturín | 3.130000e+01 | Monagas | 938185 | Nor - Oriental | 28900 | 1909 | VE-N | | 16 | La Asunción | 1.000048e+07 | Nueva Esparta | 525139 | Insular | 1150 | 1909 | VE-O | | 17 | Guanare | 5.770000e+01 | Portuguesa | 897104 | Centro-Occidental| 15200 | 1909 | VE-P | | 18 | Cumaná | 7.600000e+01 | Sucre | 892990 | Nor - Oriental | 11800 | 1909 | VE-R | | 19 | San Cristóbal | 1.053000e+02 | Táchira | 1277241 | Andina | 11100 | 1899 | VE-S | | 20 | Trujillo | 9.280000e+01 | Trujillo | 901239 | Andina | 7400 | 1864 | VE-T | | 21 | La Guaira | 2.358000e+02 | Vargas | 419928 | Capital | 1497 | 1998 | VE-X | | 22 | San Felipe | 8.460000e+01 | Yaracuy | 645688 | Centro-Occidental| 7100 | 1899 | VE-U | | 23 | Maracaibo | 7.370000e+01 | Zulia | 4694856 | Zuliana | 63100 | 1864 | VE-V | | 24 | Gran Roque | 1.800000e+01 | D. Federales |2155 | Insular | 120 | 1938 | VE-W |

In [7]:

#Si se quiere la información de Carabobo
mascara = df["Estado"] == "Carabobo"
df[mascara]

Out[7]: | ID | Capital | Densidad | Estado | Poblacion | Region | Superficie | año_admision | codigo_iso | | :- | :----------------: | :----------: | :------------- | :------: | :-------------: | :------- | :-----: | :-------: | | 6 | Valencia | 1.000071e+07 | Carabobo | 2342665 | Central | 4650 | 1865 | VE-G |

In [8]:

#Otra forma de traer la información de Carabobo
df.iloc[6]
Out[8]:
Capital            Valencia
Densidad        1.00007e+07
Estado             Carabobo
Poblacion           2342665
Region              Central
Superficie             4650
año_admision           1865
codigo_iso             VE-G
Name: 6, dtype: object

In [9]:

#Para obtener la capital del estado
df.iloc[6]["Capital"]

Out[9]:

'Valencia'

In [ ]:

El proceso de eliminar la basura dentro del texto de algunos campos no se muestra, pero se usa en la construcción del diccionario.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

PDF Scraping para Pandas usando tabula-py

2018-04-15T07:00:00-04:00

Hace un tiempo quería hacer pruebas de extracción de datos de PDF que publica la Administración Pública en Venezuela, ya que el concepto de Datos Abiertos no está muy claro por acá, lo más que se logra son documentos en PDF donde pegan gráficas y tablas como capturas de pantalla.

Artículos sobre webscraping.

Por cierto, existe un evento del día de los datos abiertos. Ese día fue el 3 de Marzo en este año. si le dan click al mapa, aparece la lista de eventos de ese día por países.

Este artículo se basa en un artículo en inglés publicado en Medium sobre tabula-py.

Para el caso de Venezuela, no aparece en la lista de eventos de la fecha del 3 de Marzo.

Alianza para el gobierno Abierto.

https://youtu.be/QbGDoV_HoFY

Iniciativas de sitios de Datos Abiertos.

https://youtu.be/oh3g-iYAaDo

Que tal que pueda hacer un scrapping y de una usar Pandas (Introducción a pandas) para Ciencia de Datos.

Existe una librería para Python llamada tabula-py, en el github de tabula-py se encuentra un archivo llamado data.pdf, ese será el archivo pdf que se va a extraer la información.

Para usar tabula-py se puede instalar vía pip:

pip install tabula-py

A continuación se muestra en jupyter como usar tabula-py:

In [1]:

#Se importa read_pdf de tabula
from tabula import read_pdf

In [2]:

#Se lee el archivo data.pdf y se muestra el encabezado del dataframe
df = read_pdf('./Data/data.pdf')
df.head()

Out[2]:

ID	Unnamed: 0	mpg	cyl	disp	hp	drat	wt	qsec	vs	am	gear	carb
0	Mazda RX4	21.0	6	160.0	110	3.90	2.620	16.46	0	1	4	4
1	Mazda RX4 Wag	21.0	6	160.0	110	3.90	2.875	17.02	0	1	4	4
2	Datsun 710	22.8	4	108.0	93	3.85	2.320	18.61	1	1	4	1
3	Hornet 4 Drive	21.4	6	258.0	110	3.08	3.215	19.44	1	0	3	1
4	Hornet Sportabout	18.7	8	360.0	175	3.15	3.440	17.02	0	0	3	2

In [3]:

#También se puede mostrar los datos en formato json
js = read_pdf('./Data/data.pdf',output_format='json')

In [4]:

#También se puede guardar un archivo en JSON, CSV,TSV
from tabula import convert_into
convert_into('./Data/data.pdf',"./Data/data.json",output_format='json')
#!cat ./Data/data.json

In [5]:

convert_into('./Data/data.pdf',"./Data/data.tsv",output_format='tsv')
#!cat ./Data/data.tsv

In [6]:

convert_into('./Data/data.pdf',"./Data/data.csv",output_format='csv')
#!cat ./Data/data.csv

A continuación se muestra la figura del editor que muestra data.csv:

Ahora se muestra el contenido del archivo data.tsv:

Al tener los datos en un dataframe se puede realizar toda la analítica de datos que se puede hacer con Pandas.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Obtener cotización de criptomonedas y almacenarlas en un archivo csv por medio de pandas

2018-03-11T10:00:00-04:00

En el artículo anterior se obtuvo la cotización de bitcoin del sitio coinmarketcap por medio de request o directamente de una librería que accede al API.

En este artículo se obtiene la información de las primeras 100 criptomonedas que cotizan en coinmarketcap, y se manejará dicha información por medio de pandas. Luego de ordenar la información de las monedas se van a almacenar en un archivo csv.

Este artículo se basa en un artículo en inglés Importing Altcoin Data with Python and the CoinmarketCap API.

Si quieren pueden repasar lo que pueden hacer con pandas revisando los siguientes artículos:

A continuación el código en formato jupyter notebook:

In [1]:

#Se importa coinmarketcap, json, pandas y time
import coinmarketcap
import json
import pandas as pd
import time

In [2]:

#SE instancia la clase Market y se consulta la cotización de ethereum.
market = coinmarketcap.Market()
coin = market.ticker("ethereum")

In [3]:

#Se muestra el tipo de la variable coin
type(coin)

Out[3]:

list

In [4]:

#Se muestra que la lista tiene 1 elemento.
print(len(coin))
1

In [5]:

#Se muestra el tipo del primer elemento de la lista
type(coin[0])

Out[5]:

dict

In [6]:

#Se muestra el primer elemento de la lista el cual es un diccionario
print (coin[0])
{'symbol': 'ETH', 'price_btc': '0.0758447', 'price_usd': '725.008', 'cached': False, 'market_cap_usd': '71145122811.0', 'available_supply': '98130121.0', '24h_volume_usd': '1559710000.0', 'percent_change_1h': '0.22', 'percent_change_24h': '6.39', 'name': 'Ethereum', 'id': 'ethereum', 'total_supply': '98130121.0', 'rank': '2', 'last_updated': '1520813352', 'max_supply': None, 'percent_change_7d': '-16.25'}

In [7]:

#Se muestra los datos de la variable coin, identado, y ordenada las claves.
print(json.dumps(coin, indent=4, sort_keys=True))
[
    {
        "24h_volume_usd": "1559710000.0",
        "available_supply": "98130121.0",
        "cached": false,
        "id": "ethereum",
        "last_updated": "1520813352",
        "market_cap_usd": "71145122811.0",
        "max_supply": null,
        "name": "Ethereum",
        "percent_change_1h": "0.22",
        "percent_change_24h": "6.39",
        "percent_change_7d": "-16.25",
        "price_btc": "0.0758447",
        "price_usd": "725.008",
        "rank": "2",
        "symbol": "ETH",
        "total_supply": "98130121.0"
    }
]

In [8]:

#Ahora se usa panda series, se toma la cotización de ethereum y se guarda en 
#la variable ether
ether = pd.Series(market.ticker("ethereum")[0])

In [9]:

#Se muestra el valor de la variable ether
print(ether)
24h_volume_usd         1559710000.0
available_supply         98130121.0
cached                         True
id                         ethereum
last_updated             1520813352
market_cap_usd        71145122811.0
max_supply                     None
name                       Ethereum
percent_change_1h              0.22
percent_change_24h             6.39
percent_change_7d            -16.25
price_btc                 0.0758447
price_usd                   725.008
rank                              2
symbol                          ETH
total_supply             98130121.0
dtype: object

In [10]:

#Se muestra la descripción de la serie
print(ether.describe)
<bound method NDFrame.describe of 24h_volume_usd         1559710000.0
available_supply         98130121.0
cached                         True
id                         ethereum
last_updated             1520813352
market_cap_usd        71145122811.0
max_supply                     None
name                       Ethereum
percent_change_1h              0.22
percent_change_24h             6.39
percent_change_7d            -16.25
price_btc                 0.0758447
price_usd                   725.008
rank                              2
symbol                          ETH
total_supply             98130121.0
dtype: object>

In [11]:

#Se guardan otras monedas alternativas en el arreglo de pandas
wowcoin = pd.Series(market.ticker("wowcoin")[0])
bitcoin = pd.Series(market.ticker("bitcoin")[0])
coinArray = pd.DataFrame([ether,bitcoin,wowcoin]).set_index("id")

In [12]:

#Se muestra los datos del arreglo panda
print(coinArray)
         24h_volume_usd available_supply  cached last_updated market_cap_usd  \
id                                                                             
ethereum   1559710000.0       98130121.0    True   1520813352  71145122811.0   
bitcoin    6292920000.0       16913662.0   False   1520813365   162866556360   
wowcoin         106.405             None   False   1520813347           None   

          max_supply      name percent_change_1h percent_change_24h  \
id                                                                    
ethereum        None  Ethereum              0.22               6.39   
bitcoin   21000000.0   Bitcoin              0.42               9.61   
wowcoin         None   Wowcoin              3.01               4.04   

         percent_change_7d    price_btc     price_usd  rank symbol  \
id                                                                   
ethereum            -16.25    0.0758447       725.008     2    ETH   
bitcoin             -15.97          1.0       9629.29     1    BTC   
wowcoin              -78.7  0.000000002  0.0000163877  1467    WOW   

         total_supply  
id                     
ethereum   98130121.0  
bitcoin    16913662.0  
wowcoin          None

In [13]:

#Ahora se extrae las cotizaciones de 100 cryptomonedas
coins = market.ticker()

In [14]:

#El tamaño de la lista es 100
len(coins)

Out[14]:

In [15]:

#Se almacena las 100 monedas en un dataframe de pandas a partir de una serie panda
coinArray2 = pd.DataFrame([pd.Series(coins[i]) for i in range(100)]).set_index('id')

In [17]:

#Obtengo los primeros 3 criptomonedas
coinArray2.head(3)

Out[17]:

| ID | 24h_volume_usd | available_supply | cached | last_updated | market_cap_usd | max_supply | name | percent_change_1h | percent_change_24h |percent_change_7d | price_btc | price_usd | rank | symbol | total_supply | | :------: | :------: | :-----: | :-----: | :------: | :-----: | :-------: | :-----: | :-----: | :-------: | :------: | :-----: | :-------: | :------: | :-----: | | bitcoin | 6292920000.0 | 16913662.0 | False | 1520813365 | 162866556360 | 21000000.0 | Bitcoin 0.42 | 9.61 | -15.97 | 1.0 | 9629.2 | 1 | BTC | 16913662.0 | |ethereum | 1559710000.0 | 98130121.0 | False | 1520813352 | 71145122811.0 | None | Ethereum 0.22 | 6.39 | -16.25 | 0.0758447 | 725.008 | 2 | ETH | 98130121.0 | |ripple | 471767000.0 | 39091956706.0 | False | 1520813341 | 32612386698.0 | 100000000000| Ripple 0.33 | 5.49 | -14.76 | 0.00008727 | 0.834248 | 3 | XRP | 99992520283.0|

In [18]:

#Se define almacenar los datos en un archivo csv que maneje el tiempo en que se creo el
#archivo como nombre del archivo
location = 'Data/'+str(time.time())+'.csv'

In [19]:

#Se almacenan los datos en formato csv
coinArray2.to_csv(location)

In [20]:

#Ahora se repiten las instrucciones anteriores con 3 ciclos de cada 2 min
coins = market.ticker()
for i in range(3):
    coinArray = pd.DataFrame([pd.Series(coins[i]) for i in range(100)]).set_index('id')
    location = 'Data/'+str(time.time())+'.csv'
    coinArray.to_csv(location)
    time.sleep(2*60)

Al terminar de ejecutar el programa se tienen 4 archivos en formato csv:

En siguientes artículos se utilizarán los datos almacenados para hacer analítica de datos con Pandas.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Obtener cotización de bitcoin de coinmarketcap con Python

2018-03-11T09:00:00-04:00

Este artículo mostrará dos formas de obtener la cotización en tiempo real de Bitcoin del sitio coinmarketcap, la primera forma es usando la librería request, la segunda es utilizando una librería de python para acceder al API de Coinmarketcap.

Coinmarketcap es un sitio que muestra la capitalización de las distintas criptomonedas existentes en tiempo real, a continuación se muestra una captura de pantalla del sitio:

Este artículo se basa del artículo en Real Python "Python Project for Beginners: Bitcoin Price Notifications" y de la documentación de la librería coinmarketcap.

Para usar la librería de coinmarketcap primero se instalará vía pip3:

pip3 install coinmarketcap

A continuación se muestra el ejercicio de acceder a la API de coinmarketcap desde request y desde la librería que accede al API:

In [1]:

#Se importa la librería request
import requests

In [2]:

#Se guarda el url del api para bitcoin
bitcoin_api_url = 'https://api.coinmarketcap.com/v1/ticker/bitcoin/'
#Se guarda la consulta al url de bitcoin
respuesta = requests.get(bitcoin_api_url)
#Se obtiene el json de la respuesta
resp_json = respuesta.json()

In [3]:

#cual es el tipo de dato de resp_json
type(resp_json)

Out[3]:

list

In [4]:

#El tipo de datos de resp_json es una lista, se muestra el primer elemento de la lista
resp_json[0]

Out[4]:

{'24h_volume_usd': '6324610000.0',
 'available_supply': '16913212.0',
 'id': 'bitcoin',
 'last_updated': '1520799265',
 'market_cap_usd': '162063750441',
 'max_supply': '21000000.0',
 'name': 'Bitcoin',
 'percent_change_1h': '-0.64',
 'percent_change_24h': '5.74',
 'percent_change_7d': '-15.57',
 'price_btc': '1.0',
 'price_usd': '9582.08',
 'rank': '1',
 'symbol': 'BTC',
 'total_supply': '16913212.0'}

In [5]:

#Se tiene un json con los datos de la cotización actual de Bitcoin BTC.

In [6]:

#Ahora se usa la libreria coinmarketcap y la clase Market.
from coinmarketcap import Market

In [7]:

#Se crea la instancia de la clase
coinmarketcap = Market()

In [8]:

#Se obtiene la cotizacion de bitcoin
coinmarketcap.ticker("bitcoin")
Out[8]:
[{'24h_volume_usd': '6323720000.0',
  'available_supply': '16913337.0',
  'cached': False,
  'id': 'bitcoin',
  'last_updated': '1520799866',
  'market_cap_usd': '161323467507',
  'max_supply': '21000000.0',
  'name': 'Bitcoin',
  'percent_change_1h': '-1.11',
  'percent_change_24h': '5.47',
  'percent_change_7d': '-16.0',
  'price_btc': '1.0',
  'price_usd': '9538.24',
  'rank': '1',
  'symbol': 'BTC',
  'total_supply': '16913337.0'}]

Se tienen dos formas de obtener la información del sitio coinmarketcap, una es usando request y otra la librería que accede directamente al API, queda de parte de uno cual es la mejor opción a usar.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Funciones de activación para un perceptron

2018-02-13T09:00:00-04:00

En el artículo (introducción al perceptron), se muestra el perceptron con la función de activación que en la figura es una onda cuadrada, pero puede ser también otro tipo de función.

En el artículo (construir una red neuronal en pocos minutos), se muestra la función de activación llamada sigmoide.

Y en el artículo (Una red Neuronal para aprendizaje supervisado usando Scikit-learn) se usa la función tanh.

Scikit-learn para multi-layer perceptron maneja varios tipos de funciones de activación (documentación) como lo son:

identity: La función de activación es f(x)=x.
logistic: La función de activación es la función sigmoide f(x)=1/(1+exp(-x)).
tanh: La función de activación es la función tangente hiperbolico f(x)=tanh(x).
relu: La función de activación es función rectificada de recta unitaria f(x)=max(0,x).

El código mostrará las distintas funciones y sus gráficas, luego se toma la red neuronal del artículo Una red Neuronal para aprendizaje supervisado usando Scikit-learn, usando distintas funciones de activación, se entrena a la neurona con cada función de activación y se busca predecir el resultado.

A continuación el código:

In [1]:

#Se importa numpy y matplotlib
import matplotlib.pyplot as plt
import numpy as np
%matplotlib inline

In [2]:

#Se define el rango de valores
z = np.linspace(-10,10,100)

In [3]:

#Onda cuadrada
def cuadrada(z):
    return 1*(z>0)

In [4]:

#Se calcula la onda cuadrada a partir del rango de valores
a = cuadrada(z)

In [5]:

#Se gráfica la onda cuadrada
plt.plot(z,a)

Out[5]:

[<matplotlib.lines.Line2D at 0x7f90ba52c278>]

In [6]:

#Se define la función Identidad
def identidad(z):
    return z

In [7]:

#Se calcula la función identidad a partir del rango de valores
b = identidad(z)

In [8]:

#Se gráfica.
plt.plot(z,b)

Out[8]:

[<matplotlib.lines.Line2D at 0x7f90ba49e7f0>]

In [9]:

#Función ReLU
def ReLU(z):
    return z * (z > 0)

In [10]:

#Se calcula la función ReLU a partir del rango de valores
c = ReLU(z)

In [11]:

#Se gráfica la función
plt.plot(z,c)

Out[11]:

[<matplotlib.lines.Line2D at 0x7f90ba46c6d8>]

In [12]:

#Función tangente hiperbolico
def tanh(z):
    return(np.exp(z)-np.exp(-z))/(np.exp(z)+np.exp(-z))

In [13]:

#Se calcula la tangente hiperbolica a partir del rango de valores
d = tanh(z)

In [14]:

#Se gráfica
plt.plot(z,d)

Out[14]:

[<matplotlib.lines.Line2D at 0x7f90ba42e550>]

In [15]:

#Función sigmoide
def sigmoide(z):
    return 1/(1+np.exp(-z))

In [16]:

#Se calcula la sigmoide a partir del rango de valores
e = sigmoide(z)

In [17]:

#Se gráfica la función
plt.plot(z,e)

Out[17]:

[<matplotlib.lines.Line2D at 0x7f90ba3f0be0>]

La diferencia entre las funciones de activación es lo suavizada o no de cada curva. Osea, que tan abrupta es su pendiente, o la derivada de la función.

A continuación se crea una red neuronal usando scikit-learn

In [18]:

#Se importa de la red neuronal MLPClassifier
from sklearn.neural_network import MLPClassifier

In [19]:

#Se definen los datos de entrada
datos_entrada = np.array([
    0, 0,
    0, 1,
    1, 0,
    1, 1
]).reshape(4, 2)

In [20]:

#Se definen los datos de salida
datos_salida = np.array([0, 1, 1, 0]).reshape(4,)

In [21]:

#Se crea la red neuronal con función de activación relu y 100 mil iteraciones
model = MLPClassifier(activation='relu', max_iter=100000, hidden_layer_sizes=(4,2))

In [22]:

#Se entrena a la red neuronal
model.fit(datos_entrada,datos_salida)

Out[22]:

MLPClassifier(activation='relu', alpha=0.0001, batch_size='auto', beta_1=0.9,
       beta_2=0.999, early_stopping=False, epsilon=1e-08,
       hidden_layer_sizes=(4, 2), learning_rate='constant',
       learning_rate_init=0.001, max_iter=100000, momentum=0.9,
       nesterovs_momentum=True, power_t=0.5, random_state=None,
       shuffle=True, solver='adam', tol=0.0001, validation_fraction=0.1,
       verbose=False, warm_start=False)

In [23]:

#Se hace la predicción
print('prediccion:', model.predict(datos_entrada))

prediccion: [0 1 0 1]

El resultado que devuelve la red neuronal debería ser [0,1,1,0] y devuelve [0,1,0,1] el cual es errado. Se repite la construcción de la red neuronal, pero ahora usando la función de activación identity.

In [24]:

model = MLPClassifier(activation='identity', max_iter=100000, hidden_layer_sizes=(4,2))

In [25]:

#Se entrena a la red neuronal
model.fit(datos_entrada,datos_salida)

Out[25]:

MLPClassifier(activation='identity', alpha=0.0001, batch_size='auto',
       beta_1=0.9, beta_2=0.999, early_stopping=False, epsilon=1e-08,
       hidden_layer_sizes=(4, 2), learning_rate='constant',
       learning_rate_init=0.001, max_iter=100000, momentum=0.9,
       nesterovs_momentum=True, power_t=0.5, random_state=None,
       shuffle=True, solver='adam', tol=0.0001, validation_fraction=0.1,
       verbose=False, warm_start=False)

In [26]:

#Se hace la predicción
print('prediccion:', model.predict(datos_entrada))

prediccion: [0 0 0 0]

El resultado que devuelve la red neuronal debería ser [0,1,1,0] y devuelve [0,0,0,0] el cual es errado. Se repite la construcción de la red neuronal, pero ahora usando la función de activación sigmoide (logistic).

In [27]:

model = MLPClassifier(activation='logistic', max_iter=100000, hidden_layer_sizes=(4,2))

In [28]:

#Se entrena a la red neuronal
model.fit(datos_entrada,datos_salida)

Out[28]:

MLPClassifier(activation='logistic', alpha=0.0001, batch_size='auto',
       beta_1=0.9, beta_2=0.999, early_stopping=False, epsilon=1e-08,
       hidden_layer_sizes=(4, 2), learning_rate='constant',
       learning_rate_init=0.001, max_iter=100000, momentum=0.9,
       nesterovs_momentum=True, power_t=0.5, random_state=None,
       shuffle=True, solver='adam', tol=0.0001, validation_fraction=0.1,
       verbose=False, warm_start=False)

In [29]:

#Se hace la predicción
print('prediccion:', model.predict(datos_entrada))

prediccion: [1 1 1 1]

El resultado que devuelve la red neuronal debería ser [0,1,1,0] y devuelve [1,1,1,1] el cual es errado. Se repite la construcción de la red neuronal, pero ahora usando la función de activación tanh.

In [33]:

model = MLPClassifier(activation='tanh', max_iter=100000, hidden_layer_sizes=(4,2))

In [34]:

#Se entrena a la red neuronal
model.fit(datos_entrada,datos_salida)

Out[34]:

MLPClassifier(activation='tanh', alpha=0.0001, batch_size='auto', beta_1=0.9,
       beta_2=0.999, early_stopping=False, epsilon=1e-08,
       hidden_layer_sizes=(4, 2), learning_rate='constant',
       learning_rate_init=0.001, max_iter=100000, momentum=0.9,
       nesterovs_momentum=True, power_t=0.5, random_state=None,
       shuffle=True, solver='adam', tol=0.0001, validation_fraction=0.1,
       verbose=False, warm_start=False)

In [35]:

#Se hace la predicción
print('prediccion:', model.predict(datos_entrada))

prediccion: [0 1 1 0]

El resultado que devuelve la red neuronal debería ser [0,1,1,0] y devuelve [0,1,1,0] el cual es el resultado esperado. Esto demuestra que es muy importante seleccionar la función de activación correcta a la hora de definir una red neuronal y entrenarla.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Visualización de objetos Graph con Tensorboard

2018-02-12T12:00:00-04:00

Continuando con los artículos sobre TensorFlow, en este caso se mostrará como se visualiza el objeto Graph por medio de TensorBoard.

Los artículos de la serie de TensorFlow los pueden revisar a continuación:

Este artículo se basa en el tutorial en inglés Visualization y la documentación de la página de TensorFlow.

Se va a tener dos formas de realizar el mismo ejercicio, el primero simplemente identificando las operaciones en el Objeto Graph, suma, multiplicación y división, luego se guarda el log de la sesión y se visualizará.

En el siguiente ejercicio, se harán las mismas operaciones, pero ahora se identifica los Objetos Graph con scopes, esto permitirá visualizar mejor dichos objetos y sus operaciones.

A continuación el primer ejercicio:

In [1]:

#Se importa Tensorflow
import tensorflow as tf

In [2]:

#Se suma 1+2
a = tf.add(1, 2,name="Suma_estos_numeros")

In [3]:

#Se multiplica el valor de la suma anterior por 3
b = tf.multiply(a, 3)

In [4]:

#se suma 4+5
c = tf.add(4, 5,name="Suma_estos")

In [5]:

#Se multiplica el resultado de la suma anterior por 6
d = tf.multiply(c, 6,name="Multiplica_estos_numeros")

In [6]:

#Se multiplica 4*5
e = tf.multiply(4, 5,name="B_suma")

In [7]:

#Se divide el resultado de la suma de 4+5 entre 6
f = tf.div(c, 6,name="B_mul")

In [8]:

#Se suma la multiplicación de a*3 más la multiplicación de c*6
g = tf.add(b, d)

In [9]:

#Se multiplica el resultado de la suma de b+d con el resultado de la división de c/6
h = tf.multiply(g, f)

In [10]:

#Se crea la sesión y se corre el resultado del objeto h y se salva en el directorio output.
with tf.Session() as sess:
    writer = tf.summary.FileWriter("output", sess.graph)
    print(sess.run(h))
    writer.close()

In [ ]:

Ahora se ejecutará tensorboard, pasandole el directorio output donde se guardó el log de la sesión con sus operaciones.

tensorboard --logdir=./output/

El comando iniciará una sesión web de la aplicación tensorboard como lo muestra la siguiente figura:

Al abrir el navegador en localhost:6006 se tiene lo que muestra la siguiente figura:

Allí se visualizan las operaciones realizadas en la sesión y en el objeto Graph.

Pero, se puede agrupar los objetos Graph, y las operaciones para facilitar la visualización de los Objetos y sus operaciones.

A continuación la re-escritura del mismo ejercicio:

In [1]:

import tensorflow as tf

In [2]:

#Se define el nombre del objeto graph y los scopes A,B y C.
with tf.name_scope("GrupoOperacion"):
    with tf.name_scope("Scope_A"):
        a = tf.add(1, 2, name="Suma_estos_numeros")
        b = tf.multiply(a, 3)
    with tf.name_scope("Scope_B"):
        c = tf.add(4, 5, name="Y_estos")
        d = tf.multiply(c, 6, name="Multiplica_estos_numeros")

with tf.name_scope("Scope_C"):
    e = tf.multiply(4, 5, name="B_suma")
    f = tf.div(c, 6, name="B_mult")
g = tf.add(b, d)
h = tf.multiply(g, f)

In [3]:

#Se crea la sesión y se corre el resultado del objeto h
with tf.Session() as sess:
    writer = tf.summary.FileWriter("output2", sess.graph)
    print(sess.run(h))
    writer.close()

Se vuelve a ejecutar tensorboard, pero en este caso abriendo el directorio output2:

tensorboard --logdir=./output2/

En la siguiente imagen se muestra los distintos Graph y cada operación que maneja cada uno.

De esta manera se tiene una mejor visualización de cada Objeto Graph y sus operaciones.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Una red Neuronal para aprendizaje supervisado usando Scikit-learn

2018-02-12T11:00:00-04:00

Continuando con los artículos sobre Redes Neuronales, en este caso se usará la librería Scikit-learn.

Lo primero es instalar scikit-learn en Linux con pip:

pip3 install  scikit-learn

Se tendrán dos ejemplos, el primero es entrenar la red neuronal con la tabla de la verdad de XOR y ver que devuelve la red, el segundo ejercicio es tomando los datos del artículo anterior (construir una red neuronal en pocos minutos) y ver si se logra el mismo resultado.

La resolución de XOR se hará con el algoritmo de K nearest neighbor algorithm y también se usará multi-layer perceptron Classifier con backpropagation (redes neuronales supervisadas).

Se crea una red neuronal clasificador para evaluar la tabla de la verdad para XOR

In [1]:

#Se importa Numpy, MLPCCLassifier y KNeighborsClassifier
import numpy as np
from sklearn.neural_network import MLPClassifier
from sklearn.neighbors import KNeighborsClassifier

In [2]:

#un Arreglo con la tabla de la verdad
# 0 0
# 0 1
# 1 0
# 1 1
xs = np.array([
    0, 0,
    0, 1,
    1, 0,
    1, 1
]).reshape(4, 2)

In [3]:

# Se muestra el arreglo
xs

Out[3]:

array([[0, 0],
       [0, 1],
       [1, 0],
       [1, 1]])

In [4]:

#Se muestra un arreglo conel resultado de hacer un XOR
ys = np.array([0, 1, 1, 0]).reshape(4,)

In [5]:

ys

Out[5]:

array([0, 1, 1, 0])

In [6]:

#Se crea el clasificador con la función de activación relu,con 10k iteraciones y tiene capaz ocultas 4,2
model = MLPClassifier(activation='tanh', max_iter=10000, hidden_layer_sizes=(4,2))

In [7]:

#Se entrena la red neuronal pasando los arreglos de entrada y de salida
model.fit(xs, ys)

Out[7]:

MLPClassifier(activation='tanh', alpha=0.0001, batch_size='auto', beta_1=0.9,
       beta_2=0.999, early_stopping=False, epsilon=1e-08,
       hidden_layer_sizes=(4, 2), learning_rate='constant',
       learning_rate_init=0.001, max_iter=10000, momentum=0.9,
       nesterovs_momentum=True, power_t=0.5, random_state=None,
       shuffle=True, solver='adam', tol=0.0001, validation_fraction=0.1,
       verbose=False, warm_start=False)

In [8]:

print('prediccion:', model.predict(xs)) # salida 0110

prediccion: [0 1 1 0]

In [9]:

print('Se espera:', np.array([0, 1, 1, 0]))

Se espera: [0 1 1 0]

Datos de entrada y salida del artículo anterior

Entrada     Salida
001     0
111     1
101     1
011     0
100     ?

In [10]:

#Se importa de numpy array
from numpy import array

In [11]:

#Datos de entrada y de salida
datos_entrada = array([[0, 0, 1], [1, 1, 1], [1, 0, 1], [0, 1, 1]]).reshape(4, 3)
datos_salida = array([[0, 1, 1, 0]]).reshape(4, )

In [12]:

#En este caso se usa KNeighborsClassifier con 2 capaz
KNC = KNeighborsClassifier(n_neighbors= 2)

In [13]:

KNC.fit(datos_entrada,datos_salida)

Out[13]:

KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',
           metric_params=None, n_jobs=1, n_neighbors=2, p=2,
           weights='uniform')

In [14]:

#Se predice el valor de 1,0,0 que da como resultado el mismo del artículo anterior.
print(KNC.predict([[1, 0,0]]))

[1]

In [15]:

#Se crea la red de nuevo pero ahora con PLPCCLassifier.
#Se crea el clasificador con la función de activación relu,con 10k iteraciones y tiene capaz ocultas 4,2
KNC = MLPClassifier(activation='tanh', max_iter=10000, hidden_layer_sizes=(4,2))

In [16]:

#Se entrena la red neuronal pasando los arreglos de entrada y de salida
KNC.fit(datos_entrada, datos_salida)

Out[16]:

MLPClassifier(activation='tanh', alpha=0.0001, batch_size='auto', beta_1=0.9,
       beta_2=0.999, early_stopping=False, epsilon=1e-08,
       hidden_layer_sizes=(4, 2), learning_rate='constant',
       learning_rate_init=0.001, max_iter=10000, momentum=0.9,
       nesterovs_momentum=True, power_t=0.5, random_state=None,
       shuffle=True, solver='adam', tol=0.0001, validation_fraction=0.1,
       verbose=False, warm_start=False)

In [17]:

print(KNC.predict([[1, 0,0]]))

[1]

El resultado es el mismo usando dos tipos distintas de redes neuronales, para el caso del multi-layer perceptron se usó la función de activación tanh.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Construir una red neuronal en pocos minutos

2018-02-11T12:00:00-04:00

En el artículo anterior se mostró una red neuronal que clasificaba unos datos(Introducción al perceptron).

Como lo dice el vídeo de como construir una red neuronal en 4 minutos, los pasos para trabajar con Machine Learning son:

Construir
Entrenar
Probar

El vídeo a continuación de la explicación de la red neuronal:

https://youtu.be/h3l4qz76JhQ

Este artículo como el del vídeo se basa en un artículo publicado en medium que se llama How to build a simple neural network in 9 lines of Python code y en el artículo A Neural Network in 11 lines of Python (Part 1).

La idea es que se tiene una entrada de datos de 1 y 0 y se tiene una salida el cual es un 1 o un 0, esta muestra de datos se usarán para entrenar a la red neuronal, luego al terminar el aprendizaje y se ajusten los pesos de la red neuronal, se le pasará un nuevo escenario de datos de entrada y la red calculará el valor de salida.

A continuación una imagen de las muestras de datos de entrada, la salida que se genera y el nuevo escenario de datos que se recibirá.

La ecuación para calcular la salida de una neurona es:

Como función de activación de la red neuronal se usará un sigmoide:

Su ecuación es:

Y la gráfica:

Al sustituir la ecuación de la sumatoria con la función de la sigmoide se tiene la salida de una neurona:

A continuación el código de la construcción de la red neuronal, del entrenamiento y de la prueba:

In [1]:

# Datos de entrada y de salida

Entradas    Salida
001     0
111     1
101     1
011     0
100     ?

In [2]:

#Se importan:
# exp: valor e
# array: manejo de arreglos
#random: números aleatorios
#dot: multiplicación de matrices.
from numpy import exp, array, random, dot

In [3]:

class RedNeuronal(object):
    def __init__(self,seed=1):
        # Seed el generador de números aleatorios, generará los mismos números
        #cada vez que el programa corra.
        random.seed(seed)

        # se modelará una simple neurona con 3 entradas y una salida.

        # se asignan pesos aleatorios a una matrix 3x1 con valores en el rango de -1 a 1
        # y media de cero
        self.pesos_sinaptico = 2 * random.random((3, 1)) - 1

    # La función sigmoid, describe una curva S.
    #Se pasa la suma de los pesos de las entradas a esta función
    # se normaliza entre 0 y 1.
    def __sigmoide(self, x):
        return 1 / (1 + exp(-x))

    # La derivada de la función sigmoid es el gradiente de la curva sigmoide
    def __derivada_sigmoide(self, x):
        return x * (1 - x)


    # Se entrena la red neuronal desde un proceso de ensayo y error
    # ajustando los pesos de las sinapcis cada vez
    def entrenar(self, datos_entrenamiento_entrada, datos_entrenamiento_salida, numero_iteraciones):
        for iteracion in range(numero_iteraciones):
            # Se para  los datos de entrenamiento a la red neuronal (una neurona)
            salida = self.pensar(datos_entrenamiento_entrada)

            # calculo del error (la diferencia entre la salida deseada y la que se predice
            error = datos_entrenamiento_salida - salida

            # multiplicar el error por la entrada y de nuevo por el gradiente de la curva sigmoide
            # Esto significa menos presos cercanos son ajustados más
            # esto significa las entradas las cuales son ceros, no causan
            # cambios a los pesos.
            ajuste = dot(datos_entrenamiento_entrada.T, error * self.__derivada_sigmoide(salida))

            # se ajustan los pesos
            self.pesos_sinaptico += ajuste

    # la neurona piensa.se le pasa las entradas.
    def pensar(self, entradas):
        # pasas las entradas a la red neuronal, se devuelve la función de activación(sigmoide)
        #se hace el producto punto de las entradas junto con los pesos.
        return self.__sigmoide(dot(entradas, self.pesos_sinaptico))

In [4]:

#Se inicializa una neurona de la red neuronal.
red_neuronal = RedNeuronal()

print ("Pesos iniciales de la sinaptic:\n {}".format(red_neuronal.pesos_sinaptico))

# Conjunto de datos de entradas y salidas para el entrenamiento de la neurona.
#se tienen 4 muestras, cada consiste de 3 valores de entrada y 1 no de salida
datos_entrada = array([[0, 0, 1], [1, 1, 1], [1, 0, 1], [0, 1, 1]])
datos_salida = array([[0, 1, 1, 0]]).T

# Se entrena a la red neuronal con el conjunto de datos
#Se entrena unas 10 mil veces y se hace un pequeño ajuste cada vez
red_neuronal.entrenar(datos_entrada, datos_salida, 100000)

print ("Nuevos pesos sinapticos luego del entrenamiento:\n{}".format(red_neuronal.pesos_sinaptico))

# Se prueba la red neuronal con un nuevo escenario de datos
print ("Considere la nueva situación [1, 0, 0] -> ?: {}".format(red_neuronal.pensar(array([1, 0, 0]))))

Pesos iniciales de la sinaptic:

 [[-0.16595599]
 [ 0.44064899]
 [-0.99977125]]

Nuevos pesos sinapticos luego del entrenamiento:

[[12.00870061]
 [-0.2044116 ]
 [-5.8002822 ]]

Considere la nueva situación [1, 0, 0] -> ?: [0.99999391]

El resultado para el caso de [1,0,0] es 1.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Objeto Graph de TensorFlow

2018-02-11T11:00:00-04:00

Continuando con la serie de artículos sobre Tensorflow, en este caso se explicará el significado y uso de Grapg.

Antes de continuar les dejo la lista de artículos de esta serie:

tf.Graph: Cada computo en Tensorflow es representado por un Grafo de flujo de datos, este tiene dos elementos:

Un objeto tf.Operation, que representa la unidad de computo.
Un objeto tf.Tensor, que representa unidades de datos, que se necesita para las operaciones.

A continuación se muestra una figura de la representación de un Grafo:

A continuación se muestra el uso de Graph:

In [1]:

#Se importa tensorflow
import tensorflow as tf

In [2]:

#Se define dos constantes
n1 = tf.constant(10)
n2 = tf.constant(20)

In [3]:

#Se realiza la suma de las dos constantes
n3 = n1+n2

In [4]:

#Se instancia la sesión y se ejecuta almacenando el resultado de n3 que se muestra

with tf.Session() as sess:
    result = sess.run(n3)
print (result)

30

In [5]:

#Se imprime la constante n3, es una suma, y de tipo int32
print(n3)

Tensor("add:0", shape=(), dtype=int32)

In [6]:

#Se obtiene el valor por defecto del grafo en memoria
print (tf.get_default_graph())

<tensorflow.python.framework.ops.Graph object at 0x7f1026aa1cf8>

In [7]:

#Se instancia el objeto grafo 
g = tf.Graph()

In [8]:

#Se imprime su valor, los valores en memoria serán distintos del por defecto al creado.
print(g)

<tensorflow.python.framework.ops.Graph object at 0x7f1026ad00b8>

In [9]:

#Se define graph1 como el grafo por defecto
graph1 = tf.get_default_graph()

In [10]:

#Se imprime graph1, será el valor por defecto en memoria
print(graph1)

<tensorflow.python.framework.ops.Graph object at 0x7f1026aa1cf8>

In [11]:

#Se instancia el grafo2
graph2 = tf.Graph()

In [12]:

#Se muestra el valor de grafo2
print(graph2)

<tensorflow.python.framework.ops.Graph object at 0x7f1026ad0390>

In [13]:

#Se define el grafo2 como si fuera  por defecto y se muestra si en verdad es por defecto 
with graph2.as_default():
    print(graph2 is tf.get_default_graph())

True

In [14]:

#Se evalua si grafo 2, es el de por defecto
print(graph2 is tf.get_default_graph())

False

Otro ejemplo de Grafo

In [15]:

#Se define el grafo
grafo = tf.Graph()

In [16]:

#Se define la sesión pasandole el grafo
with tf.Session(graph=grafo) as sess:
    #Se define las constantes x y y que son arreglos
    x = tf.constant([11,13,16])
    y = tf.constant([10,10,10])
    #Se realiza la operación de suma de x+y
    op = tf.add(x,y)
    #Se ejecuta la operación en la sesión
    resultado = sess.run(fetches=op)
    print(resultado)

[21 23 26]

In [ ]:

Si quiere investigar más sobre Graph puede revisar su documentación en tensorflow (documentación del api y guía para los progamadores), pueden revisar el artículo en medium Tensorflow in a nutshell-Part 1: Basics, también pueden revisar el tutorial de la gente de datacamp Tensorflow tutorial for beginners.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Variables y placeholders en Tensorflow

2018-02-10T09:00:00-04:00

Continuando con la serie sobre Tensorflow, se tienen los siguientes artículos:

El objeto Variable de Tensorflow permite definir una variable (almacenar un estado en un objeto Graph con un valor inicial), en cambio, el objeto placeholder se usa para agregar datos externos dentro de un Objeto Graph, pero los datos a agregar no se agregan al crear el placeholder, para ello se usa la inicialización de las variables.

A continuación el ejemplo de uso de variables y placeholder desde jupyter notebook:

In [1]:

#Se importa tensofflow
import tensorflow as tf

In [2]:

#Se crea una sesión interactiva ( útil cuando se usa jupyter notebook)
sess = tf.InteractiveSession()

In [3]:

#Se crea tensor como un número uniforme aleatorio, una matrix de 4x4, de elementos
#de valores entre 0 a 1.
tensor = tf.random_uniform((4,4),0,1)

In [4]:

#tensor es un objeto Tensor, de números aleatorios uniformes, de una matrix 4x4 y de typo float32.
tensor

Out[4]:

<tf.Tensor 'random_uniform:0' shape=(4, 4) dtype=float32>

In [5]:

#se crea variable como un objeto variable que se le pasa como valor inicial el objeto tensor.
variable = tf.Variable(initial_value=tensor)

In [6]:

#Se imprime el valor de la variable, 
#esta devuelve tipo Variable, con una matriz 4x4 con elementos de tipo float32
print(variable)

<tf.Variable 'Variable:0' shape=(4, 4) dtype=float32_ref>

In [7]:

#Se inicializa las variables con init
init = tf.global_variables_initializer()

In [8]:

#Se corre la inicialización
sess.run(init)

In [9]:

#Se muestra el valor de la variable corriendo la sesión, se nota los elementos
#entre 0 a 1 y de tipo float32
sess.run(variable)

Out[9]:

array([[0.05263364, 0.94140494, 0.4843645 , 0.36463213],
       [0.9149779 , 0.01328921, 0.3837136 , 0.7204586 ],
       [0.5955255 , 0.70812213, 0.19933975, 0.40913558],
       [0.359192  , 0.82358146, 0.1225971 , 0.24963093]], dtype=float32)

In [10]:

#Se crea el placeholder, lo cual reserva el espacio, pero no tiene datos como una variable.
ph = tf.placeholder(tf.float32,shape=(None,5))

In [11]:

#Se muestra el objeto placeholder, sólo tiene definido el tipo de datos el cual es float32
print(ph)

Tensor("Placeholder:0", shape=(?, 5), dtype=float32)

In [ ]:

En próximo artículo se explicará el uso de Graph.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Matemáticas básicas con TensorFlow

2018-02-04T15:00:00-04:00

En el artículo anterior se explicó la instalación y mostrar un "hola mundo" desde TensorFlow.

En este artículo se explicará el uso de constantes y variables, al principio con un arreglo de 1 dimensión de 4 elementos, como se convierte un arreglo numpy a un objeto TensorFlow y mostrar sus elementos; luego se muestra como manejar la ecuación y = x+1 con x = 9.

Manejo de un arreglo de una dimensión con tensorflow In [1]:

#Se importa numpy y tensorflow
import numpy as np
import tensorflow as tf

In [2]:

#Se crea un arreglo de una dimensión
tensor_1d = np.array([5.7, 2, 8.0, 25.99])

In [3]:

#Se imprime el arreglo
print (tensor_1d)
[  5.7    2.     8.    25.99]

In [4]:

#Se imprime el último elemento del arreglo -> 25.99
print (tensor_1d[-1])
25.99

In [5]:

#Dimensiones del arreglo -> 1 dimensión
tensor_1d.ndim

Out[5]:

In [6]:

#Cantidad de elementos del arreglo -> 4 elementos
tensor_1d.shape

Out[6]:

(4,)

In [7]:

#Tipo de los elementos que contiene el arreglo ->float64
tensor_1d.dtype

Out[7]:

dtype('float64')

In [8]:

#Convierte el arreglo a un objeto tensorflow
tf_tensor=tf.convert_to_tensor(tensor_1d,dtype=tf.float64)

In [9]:

# tipo tensor, constante, 4 elementos y de tipo float64
tf_tensor

Out[9]:

<tf.Tensor 'Const:0' shape=(4,) dtype=float64>

In [10]:

# Se inicia sesión tensorflow y se corre la la impresión de los elementos
with tf.Session() as sess:
    print (sess.run(tf_tensor))
    print (sess.run(tf_tensor[-1]))
[  5.7    2.     8.    25.99]
25.99

Ahora se va a realizar un cálculo de una ecuación con unas variables:

x = 1  
y = x + 9  
print(y)  
import tensorflow as tf  
x = tf.constant(1,name='x')  
y = tf.Variable(x+9,name='y')  
print(y)

In [13]:

#Se define el valor de la constante x = 1
x = tf.constant(1,name='x')

In [14]:

#Se define el valor de la variable y = x+9
y = tf.Variable(x+9,name='y')

In [16]:

#Se imprime el valor de y, que devuelve el tipo de objeto tensor flow, la variable y, no tiene elementos
#y es de tipo int32.
print(y)
<tf.Variable 'y:0' shape=() dtype=int32_ref>

Para que funcione se tiene que crear la sesión y ejecutar run

In [20]:

# Inicializa todas las variables
model = tf.global_variables_initializer()

In [22]:

#Se inicia la sesión, se corre model y luego y. El resultado es y -> 10
with tf.Session() as session:
    session.run(model)
    print(session.run(y))
10

In [ ]:

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Manejo de matrices con TensorFlow

2018-02-04T09:00:00-04:00

Los artículos anteriores sobre TensorFlow son:

En este artículo se explica algunas operaciones con matrices, y funciones que se pueden utilizar con matrices, en el siguiente enlace se encuentra la documentación de funciones con matrices en TensorFlow.

A continuación se muestran los ejemplos usando jupyter notebook:

In [1]:

# Se importa numpy y tensorflow
import numpy as np
import tensorflow as tf

In [2]:

#Se crea una matriz de 4x4
tensor_2d=np.array([(4,3,2,1),(4,5,6,7),(11,10,9,8),(12,13,14,15)])

In [3]:

#Se imprime la matriz
print(tensor_2d)
[[ 4  3  2  1]
 [ 4  5  6  7]
 [11 10  9  8]
 [12 13 14 15]]

In [4]:

#Se muestra el elemento 3,3 de la matriz
tensor_2d[3][3]

Out[4]:

In [5]:

#Se muestra una sub matriz
tensor_2d[0:2,0:2]

Out[5]:

array([[4, 3],
       [4, 5]])

In [6]:

#Se crean dos matrices 3x3 de tipo int32
matriz1 = np.array([(2,2,2),(2,2,2),(2,2,2)],dtype='int32')
matriz2 = np.array([(1,1,1),(1,1,1),(1,1,1)],dtype='int32')

In [7]:

#Se muestra la matriz 1
print ("Matriz 1-> \n{}".format(matriz1))
Matriz 1-> 
[[2 2 2]
 [2 2 2]
 [2 2 2]]

In [8]:

#Se muestra la matriz 2
print ("Matriz 2-> \n{}".format(matriz2))
Matriz 2-> 
[[1 1 1]
 [1 1 1]
 [1 1 1]]

In [9]:

#Se define las 2 matrices como objeto tensorflow
matriz1 = tf.constant(matriz1)
matriz2 = tf.constant(matriz2)

In [10]:

# Se calcula el producto y la suma de dos matrices
matriz_prod = tf.matmul(matriz1, matriz2)
matriz_suma = tf.add(matriz1,matriz2)

In [11]:

#Se crea una matriz 3x3
matriz3 = np.array([(2,7,2),(1,4,2),(9,0,2)],dtype='float32')

In [12]:

#Se imprime la matriz3
print ("Matriz 3-> \n{}".format(matriz3))
Matriz 3-> 
[[ 2.  7.  2.]
 [ 1.  4.  2.]
 [ 9.  0.  2.]]

In [13]:

#Se calcula la matriz determinante
matriz_det = tf.matrix_determinant(matriz3)

In [14]:

#Se crea la sesión y se ejecuta las matrices calculadas
with tf.Session() as sess:
    res1 = sess.run(matriz_prod)
    res2 = sess.run(matriz_suma)
    res3 = sess.run(matriz_det)

In [15]:

#Se imprime el producto de las matrices
print ("matriz1*matriz2-> \n{}".format(res1))
matriz1*matriz2-> 
[[6 6 6]
 [6 6 6]
 [6 6 6]]

In [16]:

##Se imprime la suma de las matrices
print ("matriz1+matriz2-> \n{}".format(res2))
matriz1+matriz2-> 
[[3 3 3]
 [3 3 3]
 [3 3 3]]

In [17]:

# Se imprime el determinante de la matriz 3
print ("det(matriz3)-> {}".format(res3))
det(matriz3)-> 56.00001907348633

In [18]:

#Se muestra la dimensión de la matriz1
matriz1.shape

Out[18]:

TensorShape([Dimension(3), Dimension(3)])

In [19]:

#Se crea un arreglo
a = np.array([[1,2,3],[4,5,6],[7,8,9]])

In [20]:

#Se muestra el arreglo
a

Out[20]:

array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])

In [21]:

#Se muestra el elemento [0,1] 
a[0,1]

Out[21]:

In [22]:

#Se muestra el elemento a[0][1], 2 que es igual a a[0,1]
a[0][1]
Out[22]:
2

In [23]:

#Se crea el objeto tensorflow del arreglo a
a1 = tf.constant(a)

In [24]:

#Se muestra el objeto tensorflow
a1

Out[24]:

<tf.Tensor 'Const_2:0' shape=(3, 3) dtype=int64>

In [25]:

#Se muestra los valores del arreglo
with tf.Session() as sess:
    print(sess.run(a1))
[[1 2 3]
 [4 5 6]
 [7 8 9]]

In [26]:

#Se crea un arreglo input, se define como objeto tensorflow
input = np.array([[1, 0, 0, 0],[0, 2, 0, 0],[0, 0, 3, 0],[0, 0, 0, 4]])
with tf.Session() as sess:
    print(sess.run(tf.constant(input)))
[[1 0 0 0]
 [0 2 0 0]
 [0 0 3 0]
 [0 0 0 4]]

In [27]:

#Se calcula la matriz diagonal
diag = tf.diag_part(input)

In [28]:

#Se muestra la matriz diagonal
with tf.Session() as sess:
    print(sess.run(diag))
[1 2 3 4]

In [29]:

#Se muestra la suma de la matriz diagonal
with tf.Session() as sess:
    print(sess.run(tf.trace(input)))
10

In [30]:

#Se crea un arreglo y se calcula la traspuesta
b = np.array([[1,2,3],[4,5,6]])
with tf.Session() as sess:
    print(sess.run(tf.transpose(b)))
[[1 4]
 [2 5]
 [3 6]]

In [31]:

#Matriz identidad
i = tf.eye(3)
with tf.Session() as sess:
    print(sess.run(i))
[[ 1.  0.  0.]
 [ 0.  1.  0.]
 [ 0.  0.  1.]]

In [32]:

#Se crea una matriz 
diagonal = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])

In [33]:

#Se muestra las dimensiones de la matriz
diagonal.shape

Out[33]:

(2, 4)

In [34]:

#Se muestra la matriz diagonal
with tf.Session() as sess:
    print(sess.run(tf.matrix_diag(diagonal)))
[[[1 0 0 0]
  [0 2 0 0]
  [0 0 3 0]
  [0 0 0 4]]

 [[5 0 0 0]
  [0 6 0 0]
  [0 0 7 0]
  [0 0 0 8]]]

In [35]:

#Se crea una matriz 
input = np.array([[[1, 0, 0, 0],[0, 2, 0, 0],[0, 0, 3, 0],[0, 0, 0, 4]],
                  [[5, 0, 0, 0],[0, 6, 0, 0],[0, 0, 7, 0],[0, 0, 0, 8]]])

In [36]:

#Se muestra las dimensiones de la matriz input
input.shape

Out[36]:

(2, 4, 4)

In [37]:

#Se muestra la matriz diagonal y sus dimensiones
with tf.Session() as sess:
    res = sess.run(tf.matrix_diag_part(input))
print(res)
print(res.shape)
[[1 2 3 4]
 [5 6 7 8]]
(2, 4)

In [38]:

#Se crea una matriz 3x3 y se define como tensorflow de tipo int32
a = np.array([[1,2,3],[4,5,6],[7,8,9]])
a.shape
a = tf.constant(a,shape=[3,3],dtype="int32")
a

Out[38]:

<tf.Tensor 'Const_4:0' shape=(3, 3) dtype=int32>

In [39]:

#Se crea otra matriz 3x3
b = tf.constant(np.array([[9,8,7],[6,5,4],[3,2,1]]),shape=[3,3],dtype="int32")
b

Out[39]:

<tf.Tensor 'Const_5:0' shape=(3, 3) dtype=int32>

In [40]:

#Se realiza la multiplicación de las matrices a y b
c = tf.matmul(a, b)

In [41]:

#Se muestra el resultado de la multiplicación y las dimensiones de la nueva matriz
with tf.Session() as sess:
    res = sess.run(c)
print(res)
print(res.shape)
[[ 30  24  18]
 [ 84  69  54]
 [138 114  90]]
(3, 3)

In [42]:

#Se define la matriz 3x3 como objeto tensorflow de tipo float32
input = tf.constant(np.array([[1,0,0],[-1,2,3],[0,1,2]]),shape=[3,3],dtype="float32")

In [43]:

#Se calcula la matriz inversa de la matriz anterior
inverse = tf.matrix_inverse(input)

In [44]:

#Se muestra el objeto tensorflow de la matriz inversa.
inverse

Out[44]:

<tf.Tensor 'MatrixInverse:0' shape=(3, 3) dtype=float32>

In [45]:

#Se muestra los elementos de la matriz inversa calculada de la matriz input
with tf.Session() as sess:
    print(sess.run(inverse))
[[ 1.  0.  0.]
 [ 2.  2. -3.]
 [-1. -1.  2.]]

In [46]:

#Se crea una matriz 4x4 con puros números 10.
fill_mat = tf.fill((4,4),10)

In [47]:

#Se muestra la matriz
with tf.Session() as sess:
    print(sess.run(fill_mat))
[[10 10 10 10]
 [10 10 10 10]
 [10 10 10 10]
 [10 10 10 10]]

In [48]:

#Se crea una matriz 4x4 de ceros
ceros_mat = tf.zeros((4,4))

In [49]:

#Se muestra la matriz
with tf.Session() as sess:
    print(sess.run(ceros_mat))
[[ 0.  0.  0.  0.]
 [ 0.  0.  0.  0.]
 [ 0.  0.  0.  0.]
 [ 0.  0.  0.  0.]]

In [50]:

#Se crea una matriz 4x4 de puros 1s.
unos_mat = tf.ones((4,4))

In [51]:

#Se muestra la matriz
with tf.Session() as sess:
    print(sess.run(unos_mat))
[[ 1.  1.  1.  1.]
 [ 1.  1.  1.  1.]
 [ 1.  1.  1.  1.]
 [ 1.  1.  1.  1.]]

In [52]:

#Se crea una matriz 4x4 de números aleatorios
random = tf.random_normal((4,4),mean=0,stddev=1.0)

In [53]:

#Se muestra la matriz
with tf.Session() as sess:
    print(sess.run(random))
[[ 0.48763195 -0.30092272  0.19232044  0.31226188]
 [-0.41430238  0.42101797  1.77855754  0.07280751]
 [-1.41810405 -0.58018923 -0.43785188 -0.41393659]
 [ 1.32442439 -0.78680986 -0.47751999  0.87710148]]

In [54]:

#Se crea una matriz 4x4 de números aleatorios uniformes,con valor mínimo 0 y un valor máximo 1s. 
ramdonu = tf.random_uniform((4,4),minval=0,maxval=1)

In [55]:

#Se muestra la matriz
with tf.Session() as sess:
    print(sess.run(ramdonu))
[[ 0.89437163  0.44275856  0.09911788  0.81197321]
 [ 0.60750782  0.93167293  0.31275058  0.85452628]
 [ 0.36725163  0.51979959  0.61648357  0.43575656]
 [ 0.26617634  0.65706372  0.2386142   0.88543487]]

In [56]:

#Se crea una lista de los objetos tensorflow.
operaciones = [fill_mat,ceros_mat,unos_mat,random,ramdonu]

In [57]:

#Se crea una sesión interactiva, se usa normalmente con jupyter.
sess = tf.InteractiveSession()

In [58]:

#Se muestra las matrices
for op in operaciones:
    print(sess.run(op))
    print("\n")
[[10 10 10 10]
 [10 10 10 10]
 [10 10 10 10]
 [10 10 10 10]]


[[ 0.  0.  0.  0.]
 [ 0.  0.  0.  0.]
 [ 0.  0.  0.  0.]
 [ 0.  0.  0.  0.]]


[[ 1.  1.  1.  1.]
 [ 1.  1.  1.  1.]
 [ 1.  1.  1.  1.]
 [ 1.  1.  1.  1.]]


[[-0.58866209  0.9165706   0.80280447  0.49312767]
 [ 1.59473944  0.52477682  2.11727142  1.67061532]
 [ 0.02045015 -0.41936889 -0.86903268 -0.41808063]
 [ 0.68307805  1.5401181  -0.66720027 -0.79585057]]


[[ 0.17621791  0.11907017  0.93286264  0.74120772]
 [ 0.11641097  0.11936057  0.59562981  0.13035727]
 [ 0.87772381  0.30514657  0.91652596  0.08015275]
 [ 0.41316867  0.63185382  0.94313562  0.97722518]]

In [59]:

#Se muestra las matrices usando eval
for op in operaciones:
    print(op.eval())
    print("\n")
[[10 10 10 10]
 [10 10 10 10]
 [10 10 10 10]
 [10 10 10 10]]


[[ 0.  0.  0.  0.]
 [ 0.  0.  0.  0.]
 [ 0.  0.  0.  0.]
 [ 0.  0.  0.  0.]]


[[ 1.  1.  1.  1.]
 [ 1.  1.  1.  1.]
 [ 1.  1.  1.  1.]
 [ 1.  1.  1.  1.]]


[[-1.56096065 -0.07210996 -0.25554755  0.4873071 ]
 [-1.46382582  1.37537384 -0.5594331  -0.14968663]
 [-0.38434446  1.24772871  0.90822452 -0.72924012]
 [ 0.85642397  0.3183746  -0.10567457 -1.39979196]]


[[ 0.57379103  0.7317698   0.02952981  0.26845372]
 [ 0.95550442  0.10524487  0.68452525  0.94136262]
 [ 0.17415774  0.6024276   0.51809859  0.86097646]
 [ 0.0080744   0.9969902   0.47532237  0.76927459]]

Continuaré con la serie de artículos sobre TensorFlow.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Hola Mundo desde TensorFlow

2018-02-04T08:00:00-04:00

TensorFlow es una biblioteca de código abierto para aprendizaje automático (Machine Learning) a través de un rango de tareas y desarrollado por Google para satisfacer sus necesidades de sistemas capaces de construir y entrenar redes neuronales para detectar y descifrar patrones y correlaciones, análogos al aprendizaje y razonamientos usados por los humanos (más información en wikipedia).

Para instalar en Linux se usa pip:

pip3 install TensorFlow

El primer ejercicio que se hará es el de escribir un Hola mundo desde TensorFlow (se usa jupyter notebook).

In [1]:

#Se importa tensorflow
import tensorflow as tf

In [2]:

#Se crea una constante en la variable hola, donde se le pasa un string
hola = tf.constant("Hola mundo desde TensorFlow!")

In [3]:

#Veamos que devuelve la variable hola
print(hola)
Tensor("Const:0", shape=(), dtype=string)

Devuelve un objeto tensor, con una constante de tipo string

In [4]:

hola

Out[4]:

<tf.Tensor 'Const:0' shape=() dtype=string>

In [5]:

#Se crea la sesión de tensorflow
sess=tf.Session()

In [6]:

#Se corre la sesión pasandole la variable hola
print(sess.run(hola))
b'Hola mundo desde TensorFlow!'

In [ ]:

Como se puede ver, para poder visualizar el valor de una constante de TensorFlow se tiene que crear la sesión y ejecutar en la sesión la constante.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Introducción al Perceptron con Python

2018-01-07T17:00:00-04:00

Este artículo se basa en un artículo en inglés The Perceptron .

Un perceptron es un clasificador y uno de los más simples de la Red Neuronal Artificial . Lo que se busca es tomar las características de una red neuronal biológica, y replicarla como un algoritmo.

En la siguiente figura se muestra una red neuronal de dos entradas, cada entrada tiene su peso, luego se suman y la función de activación genera una salida.

La ecuación mátemática sería algo como:

y = FuncionActivacion(x1*w1+x2*w2)

La función de activación para una onda cuadrada es:

Donde la función de activación puede ser una onda cuadrada (hay más funciones de activación).

Acá otro perceptron con 5 señales de entrada.

A continuación se muestra el código:

#!/usr/bin/env python3

# coding: utf-8



# # Importar librerías

from pylab import rand,plot,show,norm

# # Clase Perceptron

class Perceptron:

 def __init__(self):

  """ inicialización del perceptron  """

  self.w = rand(2)*2-1 # pesos

  self.tasaAprendizaje = 0.1 



 def respuesta(self,x):

  """ saldia del perceptron """

  y = x[0]*self.w[0]+x[1]*self.w[1] # producto punto entre w y x

  if y >= 0:

   return 1

  else:

   return -1



 def actualizarPesos(self,x,iterError):

  """

  Actualizar estatus de los pesos, w en un tiempo t+1 es w(t+1)= w(t) + learningRate*(d-r)*x

  donde d es la salida deseada y r la respuesta del perceptro, iteError es la diferencia entre

  d y r (d-r).

  """

  self.w[0] += self.tasaAprendizaje*iterError*x[0]

  self.w[1] += self.tasaAprendizaje*iterError*x[1]



 def entrenamiento(self,data):

  """ 

  Entra todo el vector en los datos, cada vector en los datos debe tener 3 elementos,

  el tercer elemento (x[2]) debe ser etiquetado (salida deseada)

  """

  learned = False

  iteration = 0

  while not learned:

   globalError = 0.0

   for x in data: # por cada muestra

    r = self.respuesta(x)    

    if x[2] != r: # si tenemos un respuesta equivocada

     iterError = x[2] - r # respuesta deseada-respuesta actual

     self.actualizarPesos(x,iterError)

     globalError += abs(iterError)

   iteration += 1

   if globalError == 0.0 or iteration >= 100: # detiene por el criterio

    print ('iterations {}'.format(iteration))

    learned = True # detiene el aprendizaje





def datosGenerados(n):

    """

    genera un conjunto de datos, de dos dimensiones,  linealmente separados con

    n muestras. El tercer elemento de la muestra es la etiqueta.

    """

    xb = (rand(n)*2-1)/2-0.5

    yb = (rand(n)*2-1)/2+0.5

    xr = (rand(n)*2-1)/2+0.5

    yr = (rand(n)*2-1)/2-0.5

    inputs = []

    for i in range(len(xb)):

        inputs.append([xb[i],yb[i],1])

        inputs.append([xr[i],yr[i],-1])

    return inputs



trainset = datosGenerados(30) # generación de datos para entrenar

perceptron = Perceptron()   # Instancia del perceptron

perceptron.entrenamiento(trainset)  # Entrenamiento con el conjunto de datos

testset = datosGenerados(20)  # conjunto de datos para el test.



# Prueba del perceptron

for x in testset:

 r = perceptron.respuesta(x)

 if r != x[2]: # Si la respuesta no es correcta

  print ('error')

 if r == 1:

  plot(x[0],x[1],'ob')  

 else:

  plot(x[0],x[1],'or')



# Se gráfica una línea de separación, la cual es ortogonal a w.

n = norm(perceptron.w)

ww = perceptron.w/n

ww1 = [ww[1],-ww[0]]

ww2 = [-ww[1],ww[0]]

plot([ww1[0], ww2[0]],[ww1[1], ww2[1]],'--k')

show()





# ##

Al ejecutar el script se tiene la siguiente gráfica:

Los puntos azules pertenecen a la primera clase y los rojos pertenecen a la segunda. La línea punteada es la línea de separación que el perceptrón aprendió durante el entrenamiento.

En siguientes artículos se seguirá trabajando con el perceptron pero usando librerías como scikit-learn y tensorflow.

El script en python y el notebook de jupyter lo pueden descargar de github.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Introducción a Pandas

2018-01-07T16:00:00-04:00

Pandas es una librería de python para analizar datos, permite multiples entrada de datos.

El artículo se basa en un artículo en inglés Building a neural network with python, y en un tutorial de pandas.

Para este tutorial se usará un conjunto de datos en formato csv sobre vinos (análisis químico para saber el origen de los vinos).

A continuación de describe paso a paso la forma de manejar los datos a partir del archivo wine_data.csv.

El archivo Pandas.py y el Pandas.ipynb lo pueden descargar de github.

Se importa Pandas como pd:

>>> import pandas as pd

Se extraen los datos del archivo csv y se define el nombres de las columnas:

>>> wine = pd.read_csv('wine_data.csv', names = ["Cultivator", "Alchol", "Malic_Acid", "Ash", "Alcalinity_of_Ash", "Magnesium", "Total_phenols", "Falvanoids", "Nonflavanoid_phenols", "Proanthocyanins", "Color_intensity", "Hue", "OD280", "Proline"])

Se muestran los primeros datos:

>>> wine.head()

Se muestran las dimensiones de la tabla:

>>> wine.shape
(178, 14)

Se tienen 178 filas y 14 columnas.

Se muestran las 2 primeras filas de la tabla:

wine.loc[[0,1]]

Se muestran las dos primeras filas y las columnas Cultivator y Alchol

>>> wine.loc[[0,1]][["Cultivator","Alchol"]]

Está introducción es necesaria ya que en futuros artículos se trabajará mucho con la librería pandas.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Graficar líneas de campo eléctrico con matplotlib y Python

2018-01-07T15:00:00-04:00

Este artículo se basa en un artículo en inglés del blog scipython, con nombre Visualizing a vector field with matplotlib.

Matplotlib provee una función llamada streamplot, para crear flujos que puede usarse para representar vectores de campo. El código python muestra la representación de un campo eléctrico a partir de multiples cargas. Las multiples cargas son seleccionadas como potencia de 2 (1 dipolo, 2 cuadrupolo, etc).

Se tiene una variable count la cual define la cantidad de cargas, en el primer caso vale 1 (dipolo).

A continuación el código:

#!/usr/bin/env python3

# coding: utf-8


# # Se importan los módulos necesarios para la graficación

import numpy as np

import matplotlib.pyplot as plt

from matplotlib.patches import Circle



# # Función que retorna el campo Eléctrico.

def E(q, r0, x, y):

    """Retorna el vector de campo eléctrico E=(Ex,Ey) de una carga q en r0"""

    den = np.hypot(x-r0[0], y-r0[1])**3

    return q * (x - r0[0]) / den, q * (y - r0[1]) / den



# # puntos de los ejes x e y.

nx, ny = 64, 64

x = np.linspace(-2, 2, nx)

y = np.linspace(-2, 2, ny)

X, Y = np.meshgrid(x, y)



# # Crear un multipolo con nq cargas

# count = número de q. En ese caso es 1 dipolo

count = 1

nq = 2**int(count)

charges = []

for i in range(nq):

    q = i%2 * 2 - 1

    charges.append((q, (np.cos(2*np.pi*i/nq), np.sin(2*np.pi*i/nq))))



# # Vector de campo eléctrico como componentes separados (Ex,Ey)

Ex, Ey = np.zeros((ny, nx)), np.zeros((ny, nx))

for charge in charges:

    ex, ey = E(*charge, x=X, y=Y)

    Ex += ex

    Ey += ey



fig = plt.figure()

ax = fig.add_subplot(111)





# # Dibujar las líneas de flujo con mapa de colores y estilos apropiados.

color = 2 * np.log(np.hypot(Ex, Ey))

ax.streamplot(x, y, Ex, Ey, color=color, linewidth=1, cmap=plt.cm.inferno,

              density=2, arrowstyle='->', arrowsize=1.5)





# # Agregar circulos para las cargas.

charge_colors = {True: '#aa0000', False: '#0000aa'}

for q, pos in charges:

    ax.add_artist(Circle(pos, 0.05, color=charge_colors[q>0]))





# # Graficar

ax.set_xlabel('$x$')

ax.set_ylabel('$y$')

ax.set_xlim(-2,2)

ax.set_ylim(-2,2)

ax.set_aspect('equal')

plt.show()

Al ejecutar el código se tiene la siguiente gráfica:

La siguiente gráfica es con count con valor a 4, osea 8 polos:

Y la última gráfica es con count con 10, osea 20 polos:

El código python y el notebook de jupyter lo pueden obtener de un repositorio en github.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Gráfica de curvas en 3D con Python

2018-01-07T14:00:00-04:00

El artículo de hoy se explicará como crear una gráfica 3D con Python.

Este artículo se basa en el artículo en inglés 3D Stem plot.

Para este caso se tiene dos archivos en un repositorio en github, uno python y otro un notebook de jupyter.

Se generará una variable x que define el eje del tiempo de dos gráficas (seno y coseno) para luego graficarlo en forma de gráfica 3D.

A continuación el código:

#!/usr/bin/env python3



# # Se importan las librerías necesarias



from numpy import linspace, sin, cos

from pylab import figure, show

from mpl_toolkits.mplot3d import Axes3D





# # generando algunos datos

x = linspace(-10,10,100);

y = sin(x);

z = cos(x);





# # Se crea la instancia de la figura y se asocia a la figura 3D

fig = figure()

ax = Axes3D(fig)





# # graficando los datos

for i in range(len(x)):

  ax.plot([x[i], x[i]], [y[i], y[i]], [0, z[i]], 

          '--', linewidth=2, color='b', alpha=.5)





# # graficando un circulo en el tope de cada curva

# plotting a circle on the top of each stem

ax.plot(x, y, z, 'o', markersize=8, 

        markerfacecolor='none', color='b',label='ib')

ax.set_xlabel('x')

ax.set_ylabel('y')

ax.set_zlabel('z')

show()

Al ejecutar el script se tiene la siguiente gráfica.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Árbol de decisión hecho en Python

2017-11-19T09:00:00-04:00

Tenía algo de tiempo sin escribir (la situación en Venezuela no está facil).

Voy a ir retomando poco a poco los artículos en el blog, tengo algunas cosas sobre Inteligencia Artificial (Redes Neuronales, Lógica Difusa, machine learning y deep learning), patrones de diseño con Python.

Este artículo trata de un modeo de predicción llamado árbol de decisión, según wikipedia es: Es un modelo de predicción utilizado en diversos ámbitos que van desde la inteligencia artificial hasta la economía. Dado un conjunto de datos se fabrican diagramas de construcciones lógicas, muy similares a los sistemas de predicción basados en reglas, que sirven para representar y categorizar una serie de condiciones que ocurren de forma sucesiva, para la resolución de un problema.

En youtube hay un canal dedicado a la ciencia de datos principalmente con Python, el youtuber es Siraj Raval . En el siguiente vídeo explica como hacer un clasificador de género hecho con un Árbol de decisión, el vídeo lo pueden ver en el siguiente enlace.

El código fuente del ejercicio del vídeo se puede ver en github.

La idea es tener los datos de altura, peso y talla de zapato y si es hombre o mujer, se construye el árbol de decisión, se pasa los datos y de ahí al pasar otro dato se genera una salida de si es hombre o mujer.

A continuación el código:

#!/usr/bin/env python

"""

https://www.youtube.com/watch?v=T5pRlIbr6gg

https://github.com/llSourcell/gender_classification_challenge/blob/master/demo.py



"""

#Se importa la librería sklearn el módulo tre

from sklearn import tree



#Se crea la instancia del árbol de decisión.

clf = tree.DecisionTreeClassifier()



#[altura, peso, talla de zapato]

X = [[181, 80, 44], [177, 70, 43], [160, 60, 38], [154, 54, 37], [166, 65, 40],

     [190, 90, 47], [175, 64, 39],

     [177, 70, 40], [159, 55, 37], [171, 75, 42], [181, 85, 43]]



#La salida donde se dice si es hombre o mujer

Y = ['hombre', 'hombre', 'mujer', 'mujer', 'hombre', 'hombre', 'mujer', 'mujer',

     'mujer', 'hombre', 'hombre']



#Se le pasa los datos  X y Y

clf = clf.fit(X, Y)



#Se definen los datos 1 y 2

dato1 = [190, 70, 43]

dato2 = [185, 62, 37]

prediction = clf.predict([dato1])

#Se muestra el resultado de la predicción de dato1

print(prediction)



prediction = clf.predict([dato2])


#Se muestra el resultado de la predicción de dato 2
print(prediction)

Al ejecutar el script se tiene:

python3 arboldecision.py 
['hombre']
['mujer']

Significa que, para una altura de 1.90 mts, peso 70 kilograms, y talla de 43, el resultado es que es un hombre, y para altura de 1.85 mts, peso 62 kilogramos y talla de 37, el resultado es que es una mujer.

Recomiendo ver el vídeo completo para tener una mejor explicación del funcionamiento del árbol de decisión.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Almacenar los datos de los eventos sismológicos de Funvisis con Python3

2017-07-24T09:00:00-04:00

En el artículo sobre la captura de datos de eventos sismológicos de funvisis solamente se trabajó el orenamiento de los datos, pero hace falta almacenar la información en una base de datos, este es el tema del artículo.

Ahora se tienen varios módulos:

sismux_getdata.py: Es el módulo que hace el webscraping de la página de funvisis.
sismux_mongo.py: Es el módulo que implementa un CRUD para mongoDB a MongoLab.
sismux_main.py: Es el módulo principal que consulta cada 5 min la página de Funvisis para guardar la información en la base de datos si no existe.
sismux_apirest.py: Es el módulo que implementa un API rest(próximo artículo).
sismux_graphql.py: Es el módulo que implementa un API con GraphQL (próximo artículo).

Del artículo anterior artículo anterior se muestra el código de sismux_getdata.py:

#!/usr/bin/env python3





#Se importa beautifulSoup

from bs4 import BeautifulSoup

#Se importa la fecha

import datetime

import requests

import sys

import json



class Sismo(object):

    def __init__(self,url="http://www.funvisis.gob.ve/",home="index.php",referer='http://www.cantv.com.ve'):

        headers = {'User-agent': 'Mozilla/5.0',\

            'SSL_VERIFYHOST': 'False',\

            'FRESH_CONNECT':'True',\

            'RETURNTRANSFER':'True',\

            'SSL_VERIFYPEER': 'False',\

            'Referer': referer

            }

        self.__url = url

        self.__home = home

        self.__urlhome = self.__url + self.__home

        self.__session = requests.Session()

        self.__session.headers.update(headers)



    def GetData(self):

        #Se  obtiene la pagina por medio de session.

        try:

            self.__r = self.__session.get(self.__urlhome)

            self.__page = self.__r.content

        except (requests.exceptions.SSLError):

            print("SSL Error")

            sys.exit(0)

        except (requests.exceptions.ConnectionError):

            print("Connection Error")

            sys.exit(0)

        #Se le pasa la pagina a beautifulsoup usando lxml de parser.

        self.__soup = BeautifulSoup(self.__page,"lxml")

        #Se crea el diccionario que almacena los datos

        self.__sismo = {}



        #SE obtiene el primer  div que tengan class module

        for row in self.__soup('div', {'class': 'module'})[0]:

            #Se obtiene el tag a para luego obtener el href y tener el url

            #del gif del sitio de funvisis que tiene la imagen del sitio donde

            #fue el sismo.

            trs = row.find('a')

            if trs == -1:

                continue

            self.__sismo['urlref'] = self.__url  + trs.get('href',None)



            trs = row.find('tr')

            if trs == -1:

                continue

            #Obtiene los datos del sismo del sitio de funvisis

            datos = trs.find('td').getText().split('&nbsp;')[0].split('\n\t')

            self.__sismo['fecha'] = datos[0].split('\xa0')[1]

            date = self.__sismo['fecha'].split("/")

            self.__sismo['hora'] = datos[2].split(" ")[-2]

            time= self.__sismo['hora'].split(":")

            self.__sismo['datetime'] = datetime.datetime(int(date[2]),int(date[1]),int(date[0]), int(time[0]), int(time[1]))

            self.__sismo['magnitud'] = datos[4].split(" ")[-1]

            mag = datos[6].split(" ")[-1].split('\xa0')

            self.__sismo['profundidad'] = mag[0] + " "+ mag[1]

            lat = datos[8].split(" ")

            self.__sismo["latitud"] = lat[-2] + " " + lat[-1]

            lon =  datos[10].split(" ")

            self.__sismo['longitud'] = lon[-2] + " "+ lon[-1]

            self.__sismo['epicentro'] = datos[11].split(":")[1].split('\xa0')[-1]

            self.__sismo['loc'] = {'type':'Point','coordinates' : [ float(lat[-2]) , float(lon[-2]) ]}

        return self.__sismo

El código del módulos sismux_mongo.py se muestra a continuación:

#!/usr/bin/env python3
import pymongo

from pymongo import MongoClient


#Se define el uri de la conexion a mongolab

uri = 'mongodb://usuario:clave@ds045064.mlab.com:45064/basedatos'

#Se define la base de datos y la cole

#ccion


basedatos = "sismux"

coleccion = "sismos"


#Se crea la clase BaseDatos que simplemente implemente un crud.
class BaseDatos(object):

    #Se define la intancia de mongoclient, se define la base de datos y

    #la coleccion

    def __init__(self,uri=uri,basedatos=basedatos,coleccion=coleccion):

        self.__client = MongoClient(uri)

        self.__db = self.__client[basedatos]

        self.__coleccion = self.__db[coleccion]


  def ConsultarTodos(self):

        #Traer todos los elementos de la consulta.

        elementos = []

        for i in self.__coleccion.find():

            elementos.append(i)

        return i


  def Consultar(self,patron):

        #Se devuelve la consulta de un elemento

        return self.__coleccion.find_one(patron)


  def Insertar(self,documento):

        #Se inserta un documento

        self.__coleccion.insert(documento)


  def Finalizar(self):

        #Se cierra la conexion con la base de datos
        self.__client.close()

A continuación se muestra sismux_main.py:

#!/usr/bin/env python3
from sismux_getdata import Sismo
import json
import time
import sys

from sismux_mongo import BaseDatos
import datetime
import logging

bd = BaseDatos()
sismo  = Sismo()
datos = sismo.GetData()
#bd.Insertar(datos)
#datos['datetime']
datime = datetime.datetime(2017,5,25, 20, 51)
#print(bd.Consultar({'datetime': datie}m))
def main():

   #Se crea la instancia a la base de datos
   bd = BaseDatos()
   #Se crea la instancia del webscraping
   sismo = Sismo()
   #Se optiene los datos de la pagina de funvisis
   datos = sismo.GetData()
   #Se consulta si ya existe el dato guardado en la base de datos
   query1 = bd.Consultar({'datetime': datos['datetime']})
   query2 = bd.Consultar({'loc': {'coordinates': datos['loc']['coordinates']}})
   if (query1 != None):
        return False
   else:
       #Si no existe se inserta en la base de datos.
       bd.Insertar(datos)
       return True

#Se crea un ciclo para consultar cada 5 min

def ciclo(tim=300):
    #Se define el log
    logging.basicConfig(filename="sismux.log",level=logging.DEBUG,format='%(asctime)s %(message)s')



while True:
        #Se ejecuta main.
       result = main()
       #Se guarda el resultado de main en el log
       logging.info(result)
       #Se espera 5 min (por defecto)
       time.sleep(tim)



if __name__ == '__main__':
   #Se ejecuta la funcion ciclo
   ciclo()

Para ejecutar el programa se corre:

python3 sismux_main.py

Al ejecutarlo se crea un archivo log y en el se tiene lo siguiente:

tail -f sismux.log 
2017-07-24 11:42:43,149 Starting new HTTP connection (1): www.funvisis.gob.ve
2017-07-24 11:42:43,821 http://www.funvisis.gob.ve:80 "GET /index.php HTTP/1.1" 200 14319
2017-07-24 11:42:56,560 False
2017-07-24 11:47:56,637 Starting new HTTP connection (1): www.funvisis.gob.ve
2017-07-24 11:47:57,466 http://www.funvisis.gob.ve:80 "GET /index.php HTTP/1.1" 200 14319
2017-07-24 11:48:12,086 False
2017-07-24 11:53:12,209 Starting new HTTP connection (1): www.funvisis.gob.ve
2017-07-24 11:53:12,976 http://www.funvisis.gob.ve:80 "GET /index.php HTTP/1.1" 200 14319
2017-07-24 11:53:18,516 False
2017-07-24 11:58:18,605 Starting new HTTP connection (1): www.funvisis.gob.ve
2017-07-24 11:58:30,984 http://www.funvisis.gob.ve:80 "GET /index.php HTTP/1.1" 200 14319
2017-07-24 11:58:57,034 False

Como muestra el log ya se tiene el último sismo en la base de datos.

En la siguiente figura se muestra un documento almacenado en la base de datos:

Para el siguiente artículo se desarrollará el API.

Nota: En un futuro artículo se muestra la creación de un demonio y como ponerlo a funcionar con SystemD y el empaquetado de todo los módulos desarrollados.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Consultar DNS por medio de Scapy

2017-07-16T09:00:00-04:00

Hace unos años escribí un artículo sobre descubrir equipos de una red local con python usando ipcalc y scapy, ahora muestro el uso de scapy para consultar DNS a un servidor de DNS determinado.

El programa es muy sencillo, es una función que se le pasa el servidor y el url a consultary devuelve la IP del url. A continuación se muestra el código:

#!/usr/bin/env python3


from scapy.all import *


def consulta(dns="8.8.8.8",dominio="www.google.com"):
    dnsServer = dns
    domconsulta= dominio
    #Se define la estructura del paquete de consulta de DNS, que es un paquete UDP
    #Que va por el puerto 53, se le pasa el servidor y el url.
    paquete_dns= IP(dst=dnsServer)/UDP(dport=53)/DNS(rd=1,qd=DNSQR(qname=domconsulta))
    #Se hace la consulta y se devuelve el resultado
    request_pqt = sr1(paquete_dns,verbose=0)
    return request_pqt[DNS].summary()

if __name__ == "__main__":
    print (consulta("8.8.8.8","www.debian.org"))

Al ejecutar el script se tiene el siguiente resultado:

sudo python3 pydns1.py
WARNING: No route found for IPv6 destination :: (no default route?). This affects only IPv6
DNS Ans "'128.31.0.62'"

Como se puede notar, la IP de www.debian.org es la 128.31.0.62.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Instalar Docker en Debian Stretch (actualización 2017).

2017-07-09T09:00:00-04:00

El primer artículo de la serie de artículos sobre Docker fue, el de la Instalación de Docker en Debian Jessie, ahora explicaré el proceso de instalación de Docer CE para Debian Stretch. La guía en inglés de instalación de docker para Debian la pueden encontrar en el siguiente enlace.

El procedimiento es el siguiente:

Instalación de paquetes necesarios para soporte de https en apt-get:

#apt-get install apt-transport-https ca-certificates curl gnupg2 software-properties-common

Agregar llave gpg oficial de Docker:

# curl -fsSL https://download.docker.com/linux/debian/gpg |  apt-key add -
OK

Si devuelve "OK" se bajo la llave y la agregó sin problemas.

Verificar la llave:

# apt-key fingerprint 0EBFCD88
pub   rsa4096 2017-02-22 [SCEA]
      9DC8 5822 9FC7 DD38 854A  E2D8 8D81 803C 0EBF CD88
uid           Docker Release (CE deb) <docker@docker.com>
sub   rsa4096 2017-02-22 [S]

Se agrega el repositorio Estable para la versión de Debian que se tiene en el equipo:

add-apt-repository \
>    "deb [arch=amd64] https://download.docker.com/linux/debian \
>    $(lsb_release -cs) \
>    stable"

Se actualiza la lista de paquetes:

#apt-get update

Se instala docker-ce:

# apt-get install docker-ce

Se verifica que docker-ce se instaló correctamente:

# docker run hello-world
Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
b04784fba78d: Pull complete 
Digest: sha256:f3b3b28a45160805bb16542c9531888519430e9e6d6ffc09d72261b0d26ff74f
Status: Downloaded newer image for hello-world:latest

Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
 https://cloud.docker.com/

For more examples and ideas, visit:
 https://docs.docker.com/engine/userguide/

Instalar docker-compose:

#apt-get install  docker-compose

Manejar docker como un usuario normal:

Crear el grupo docker:

$sudo groupadd docker

Agregar el usuario al grupo docker:

$sudo usermod -aG docker $USER

Verificar que se puede usar docker desde el usuario:

$ docker run hello-world

Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
 https://cloud.docker.com/

For more examples and ideas, visit:
 https://docs.docker.com/engine/userguide/

Configurar Docker para que inicie en el arranque del equipo:

Habilitar Docker:

$ sudo systemctl enable docker
Synchronizing state of docker.service with SysV service script with /lib/systemd/systemd-sysv-install.
Executing: /lib/systemd/systemd-sysv-install enable docker

Si requieren detalles de configuración lo pueden ver en la documentación de docker.

Para terminar se prueba el arranque de cloud9 ya explicado en un artículo anterior.

$docker run -it -d -p 9080:80 -v /home/ernesto/worksplace/:/workspace/ kdelfour/cloud9-docker
99cfe3af5bf4480ac456ec43916612317a49da111ab27e32a361639984eb2128

La siguiente captura de pantalla muestra cloud9 en funcionamiento:

En el diectorio worksplace se guarda los proyectos que se editan desde cloud9.

$ tree worksplace
worksplace
├── hola.py
├── New Folder
│   ├── mvc1.py
│   ├── New Folder
│   └── usuario.py
└── trabajo.txt

2 directories, 4 files

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Desarrollar un API con GraphQL en Flask

2017-06-25T09:00:00-04:00

Continuando con los artículos sobre Flask, donde el último artículo fue de como crear un API Restful con Flask y MongoDB .

En este artículo se toca el uso de GraphQL para crear un API. GraphQL es un lenguaje de consulta de datos desarrollado por Facebook, es una alternativa a Rest (más información en wikipedia).

La librería para Flask de GraphQL lo pueden ver en el siguiente enlace. El artículo explicará el ejemplo que aparece en la página oficial de graphQL para Flask .

Instalación:

#pip3 install flask graphene flask-graphql

Script servidor (server.py):

#!/usr/bin/env python3

#Se importa flask, graphene y graphql.

from flask import Flask

from graphene import ObjectType, String, Schema

from flask_graphql import GraphQLView



#Se crea la clase Query que hereda de graphene ObjectType.

class Query(ObjectType):

    #Se define la descripcion

    hello = String(description='Hello')

    #Se define la funcion resolve_hello, se le pasa args, context e info.

    def resolve_hello(self, args, context, info):

        return 'World'



#Se define la funcion de la vista.

#que se le pasa el esquema con la clase Query.

view_func = GraphQLView.as_view('graphql', schema=Schema(query=Query))



#Se crea la app como instancia de la clase Flask.

app = Flask(__name__)

#Se define el url donde se le pasa la funcion de la vista

app.add_url_rule('/', view_func=view_func)



if __name__ == '__main__':

    #Se ejecuta flask.

    app.run()

Al ejecutar el script:

Se consulta usando curl:

curl -H 'Content-type: application/graphql' -d '{hello}' http://localhost:5000/

Y este devuelve:

{"data":{"hello":"World"}}

Desde un script en python:

Instalación de librerías necesarias:

#pip3 install gql requests

El script cliente.py:

#!/usr/bin/env python3



#Se importa json

import json

#se importa ggl

from gql import gql, Client

from gql.transport.requests import RequestsHTTPTransport



#Se define el transport, se conecta el cliente.

transport = RequestsHTTPTransport('http://localhost:5000/')

client = Client(transport=transport)

#Se realiza una consulta buscando la  variable hello

response = client.execute(gql('{hello}'))



#muestra en pantalla la respuesta como un json.

print(json.dumps(response))

Se ejecuta el script:

python3 cliente.py 
{"hello": "World"}

En un artículo en genbetadev comparan API Restful con GraphQL y por que es necesario dejar de usar API Restful. En futuros artículos se ampliará el uso de GraphQL.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Base de datos InfluxDB en Debian Stretch

2017-06-24T12:00:00-04:00

InfluxDB es una base de datos opensource de series de tiempo, para manejo de eventos,monitoreo, métricas, Internet de las cosas y Analítica en tiempo real. Desarrollada por InfluxData en Lenguaje Go. Pueden ver más información en wikipedia.

Para instalar en Debian simplemente se usa apt-get:

# apt-cache search influxdb 
golang-github-influxdb-enterprise-client-dev - Golang client for speaking to the InfluxDB Enterprise application
golang-github-influxdb-usage-client-dev - library for speaking to the InfluxDB Anonymous Usage Reporting API
golang-gopkg-alexcesaro-statsd.v1-dev - simple and efficient Golang StatsD client
golang-github-influxdb-influxdb-dev - Scalable datastore for metrics, events, and real-time analytics. Dev package
influxdb - Scalable datastore for metrics, events, and real-time analytics
influxdb-client - command line interface for InfluxDB
influxdb-dev - Transitional package for golang-github-influxdb-influxdb-dev
ruby-influxdb - library for InfluxDB

Para instalar:

# apt-get install influxdb influxdb-client

Para probar que está en funcionamiento:

# influx
Visit https://enterprise.influxdata.com to register for updates, InfluxDB server management, and monitoring.
Connected to http://localhost:8086 version 1.0.2
InfluxDB shell version: 1.0.2
>

Para crear una base de datos llamada mydb:

> create database mydb

Listar las bases de datos:

> show databases
name: databases
---------------
name
_internal
mydb

Insertar datos y consultarlos en la base de datos mydb:

> use mydb
Using database mydb
> INSERT cpu,host=ServerA,region=us_west value=0.64
> SELECT host, region, value FROM cpu
name: cpu
---------
time                   host         region value
1498340879346347895 ServerA us_west 0.64

Por lo que se ve, la clave primaria de los datos siempre es el tiempo.

Ahora una pequeña prueba con Python.

Para instalar la librería en Python:

# pip3 install influxdb

Se tiene el siguiente script:

#!/usr/bin/env python3





#Se importa influxdb


from influxdb import InfluxDBClient





#Se define un json con los datos a insertar


json_body = [


    {


        "measurement": "cpu_load_short",


        "tags": {


            "host": "server01",


            "region": "us-west"


        },


        "time": "2009-11-10T23:00:00Z",


        "fields": {


            "value": 0.64


        }


    },


    {


        "measurement": "cpu_load_short",


        "tags": {


            "host": "server02",


            "region": "us-west"


        },


        "time": "2009-12-10T23:00:00Z",


        "fields": {


            "value": 0.65


        }


    }


]


#Se conecta a la base de datos


client = InfluxDBClient('localhost', 8086, 'root', 'root', 'mydb')


#Se crea la base de datos mydb


client.create_database('mydb')





#Se inserta los datos


client.write_points(json_body)


#Se consulta y se muestra en pantalla


result = client.query('select value from cpu_load_short;')


print("Result: {0}".format(result))

Al ejecutar el script, este devuelve lo siguiente:

./prueba-influxdb.py 
Result: ResultSet({'('cpu_load_short', None)': [{'value': 0.64, 'time': '2009-11-10T23:00:00Z'}, {'value': 0.65, 'time': '2009-12-10T23:00:00Z'}]})

O desde el cliente de influxdb:

> use mydb
Using database mydb
> select value from cpu_load_short;
name: cpu_load_short
--------------------
time   value
1257894000000000000 0.64
1260486000000000000 0.65

Como se muestra, la clave que maneja las consultas es el tiempo.

Para más información se tienen los siguientes enlaces:

Grafana, influxdb y python.
influxdb-python y su documentación.
Documentación de influxdata.
Plataforma de Influxdata

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Obtener datos de eventos sismológicos de Funvisis con Python3 (segunda versión)

2017-06-24T11:00:00-04:00

El primer artículo sobre obtener los datos sismológicos de Funvisis con Python, se usó la librería python-mechanize, en este caso se usará la librería request y Python 3.*.

El código se muestra a continuación:

#!/usr/bin/env python3


#Se importa beautifulSoup

from bs4 import BeautifulSoup

#Se importa la fecha

from datetime import datetime

import requests

import sys

import json



class Sismo(object):

    def __init__(self,url="http://www.funvisis.gob.ve/",home="index.php",referer='http://www.cantv.com.ve'):

        headers = {'User-agent': 'Mozilla/5.0',\

            'SSL_VERIFYHOST': 'False',\

            'FRESH_CONNECT':'True',\

            'RETURNTRANSFER':'True',\

            'SSL_VERIFYPEER': 'False',\

            'Referer': referer

            }

        self.__url = url

        self.__home = home

        self.__urlhome = self.__url + self.__home

        self.__session = requests.Session()

        self.__session.headers.update(headers)



    def GetData(self):

        #Se  obtiene la pagina por medio de session.

        try:

            self.__r = self.__session.get(self.__urlhome)

            self.__page = self.__r.content

        except (requests.exceptions.SSLError):

            print("SSL Error")

            sys.exit(0)

        except (requests.exceptions.ConnectionError):

            print("Connection Error")

            sys.exit(0)

        #Se le pasa la pagina a beautifulsoup usando lxml de parser.

        self.__soup = BeautifulSoup(self.__page,"lxml")

        #Se crea el diccionario que almacena los datos

        self.__sismo = {}



        #SE obtiene el primer  div que tengan class module

        for row in self.__soup('div', {'class': 'module'})[0]:

            #Se obtiene el tag a para luego obtener el href y tener el url

            #del gif del sitio de funvisis que tiene la imagen del sitio donde

            #fue el sismo.

            trs = row.find('a')

            if trs == -1:

                continue

            self.__sismo['urlref'] = self.__url  + trs.get('href',None)



            trs = row.find('tr')

            if trs == -1:

                continue

            #Obtiene los datos del sismo del sitio de funvisis

            datos = trs.find('td').getText().split('&nbsp;')

            self.__sismo['fecha'] = datos[0].split('\n\t')[0].split('\xa0')[1]

            self.__sismo['hora'] = datos[0].split('\n\t')[2].split(" ")[-2]

            self.__sismo['magnitud'] = datos[0].split('\n\t')[4].split(" ")[-1]

            mag = datos[0].split('\n\t')[6].split(" ")[-1].split('\xa0')

            self.__sismo['profundidad'] = mag[0] + " "+ mag[1]

            lat = datos[0].split('\n\t')[8].split(" ")

            self.__sismo["latitud"] = lat[-2] + " " + lat[-1]

            lon =  datos[0].split('\n\t')[10].split(" ")

            self.__sismo['longitud'] = lon[-2] + " "+ lon[-1]

            self.__sismo['epicentro'] = datos[0].split('\n\t')[11].split(":")[1].split('\xa0')[-1]

        return self.__sismo


  def ToJSON(self):

        self.__sismojson = json.dumps(self.GetData())

        return self.__sismojson





if __name__ == '__main__':

sismo = Sismo(

)

print


(

sismo.ToJSON())

Al ejecutar el script se tiene de resultado:

{"epicentro": "30 Km al sur de Guiria", "hora": "07:51", "latitud": "10.39 \u00baN", "longitud": "-62.32 \u00baO", "fecha": "24/06/2017", "magnitud": "2.8", "urlref": "http://www.funvisis.gob.ve/images/reportes/2017/06/reporte_7489.gif", "profundidad": "9.1 km"}

El código se puede ver en el repositorio en gitlab .

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Fabric como un ssh con esteroides en Debian Stretch

2017-06-10T09:00:00-04:00

Fabric es una librería y herramienta de línea de comandos que genera un flujo de tareas para la automatización de despliegues y tareas administrativas de manera remota.

Este artículo se basa en un vídeo de youtube de una introducción a Fabric.

https://youtu.be/bY2U4ikgezk

Se tienen 3 equipos:

192.168.1.3: Equipo con Debian Stretch y donde se tiene fabric instalado.
192.168.1.2: Equipo con Debian Stretch.
192.168.1.6: Equipo con Debian Jessie.

Sólo se necesita un equipo con Fabric, se usa Debian Stretch por que en esta versión de Debian no es tan complicado de instalar Fabric, en Debian Jessie me ha dado algo de problemas, se logra instalar pero da errores en la ejecución (por lo que he investigado, el problema es la librería paramiko).

Instalación de Fabric: Con pip:

#pip install fabric

Ahora se crea un archivo fabfile.py co el siguiente contenido:

#!/usr/bin/env python

#de la api de fabric de importa run, sudo, task, get y put

from fabric.api import run,sudo,task,get, put



#Se define la tareta cmdrun que ejectua el argumento

@task

def cmdrun(arg):

    run(arg)



#Se define la tarea sudorun que ejecuta el argumento vía sudo

@task

def sudorun(arg):

    sudo(arg)



#Se define la tarea download que se le pasa un argumento que se descarga en /tmp/

@task

def download(arg):

    get(remote_path=arg,local_path="/tmp/",use_sudo=True)



#Se define la tarea upload que se le pasa dos argumentos

#local_path y remote_path.

@task

def upload(arg1,arg2):

    put(local_path=arg1,remote_path=arg2,use_sudo=True)



#Se define la tarea host_type que ejecuta uname.

@task

def host_type():

        run('uname -s')

Para ejecutar las tareaas se usa el comando fab (se define una variable de entorno llamada clave la cual maneja la clave del usuario):

Ejecución de ps en dos equipos en paralelo:

fab -H 192.168.1.2,192.168.1.6 -p $clave -P cmdrum:"ps -ef|wc -l"

Devuelve la ejecución del ps y la cantidad de líneas que resulta en cada equipo.

Se averigua el tipo de host de cada equipo remoto con host_type:

fab -H 192.168.1.2,192.168.1.6 -p $clave   host_type

Acá se muestra de manera secuencial la ejecución de los comandos en los equipos, para que sea de manera paralela se usa la opción -P.

fab -H 192.168.1.2,192.168.1.6 -p $clave  -P host_type

Ya la ejecución no se hace de manera secuencial en cada equipo.

Se ejecuta fdisk por medio de sudo:

fab -H 192.168.1.2,192.168.1.6 -p $clave -P sudo:"fdisk -l| grep sda"

El comando devuelve las particiones sda que tiene cada equipo.

Se sube un arhivo sources.list al equipo 192.168.1.2, por medio de upload y se pasa como argumento el archivo local y la ruta remota:

fab -h 192.168.1.2 -p $clave upload:"sources.list","/tmp/"

La figura muestra que la subida del archivo se realizó sin problemas, ahora se revisa en el directorio /tmp/: La figura muestra que el archivo sources.list se encuentra en /tmp/

Se baja el archivo prueba.txt del equipo 192.168.1.2, por medio de download, pasando la ruta remota del archivo, este archivo se descarga por defecto en /tmp/:

fab -H 192.168.1.2 -p $clave upload:"sources.list","/tmp/"

En este caso se descargo el archivo /home/ernesto/prueba.txt a /tmp/, luego se listo localmente el archivo para verificar que se encuentra en dicho directorio.

Un tutorial más completo sobre Fabric lo pueden encontrar en su sitio.

Otros vídeos de sobre fabric:

https://youtu.be/4qav2EuXsGU

https://youtu.be/bTXert2uRco

https://youtu.be/ZpZkKbZwPoA

https://youtu.be/VmcGuKPpWH8

https://youtu.be/g4rCFMWAwgo

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Mejorar las respuestas de consultas de DNS con dnsmasq usando DNSCrypt

2017-06-06T11:00:00-04:00

He usado dnsmasq como dns cache de las consultas de opendns o de los DNS de Google.

Los artículos anteriores que hablan de dnsmasq son:

Y ahora se usará DNSCrypt como lo muestra los siguientes artículos:

Para iniciar se instalará dnsmasq:

#apt-get install dnsmasq

DNSCrypt escucha en la IP 127.0.2.1 en el puerto 53, para el caso de dnsmasq, este escuchará desde la IP 127.0.0.1 y el puerto 53 para evitar conflictos entre ambas aplicaciones.

Se edita el archivo /etc/dnsmasq.conf :

#vim /etc/dnsmasq.conf

#Realizar consultas de dominios completos solamente.
domain-needed
#Evitar busquedas internas de dominios locales
bogus-priv
#Habilita dnssec en dnsmasq
proxy-dnssec
#No tomar en cuenta el contenido del archivo /etc/resolv.conf
no-resolv
#Se escucha el servidor de nombres de dnscrypt
server=127.0.2.1
#Evitar ataques de dns rebinding
stop-dns-rebind
#evitar que servidores resuelvan consultas localhost
rebind-localhost-ok
#Se reciben consultas a dnsmasq en 127.0.0.1
listen-address=127.0.0.1
#No se habilita las interfaces para dhcp
no-dhcp-interface=wlp1s0,enp2s0,lo
#Sólo se realizan busquedas de direcciones que está resolviendo.
bind-interfaces
#No tomar en cuenta los hosts del archivo /etc/hosts
no-hosts
#Se define un cache de 500k
cache-size=500

Se salva el archivo y se reinicia dnsmasq:

#systemctl status dnsmasq.service
● dnsmasq.service - dnsmasq - A lightweight DHCP and caching DNS server
   Loaded: loaded (/lib/systemd/system/dnsmasq.service; enabled; vendor preset: enabled)
   Active: active (running) since Sun 2017-06-04 18:10:08 -04; 2 days ago
  Process: 851 ExecStartPost=/etc/init.d/dnsmasq systemd-start-resolvconf (code=exited, status=0/SUCCESS)
  Process: 814 ExecStart=/etc/init.d/dnsmasq systemd-exec (code=exited, status=0/SUCCESS)
  Process: 793 ExecStartPre=/usr/sbin/dnsmasq --test (code=exited, status=0/SUCCESS)
 Main PID: 842 (dnsmasq)
    Tasks: 1 (limit: 4915)
   Memory: 844.0K
      CPU: 7.042s
   CGroup: /system.slice/dnsmasq.service
           └─842 /usr/sbin/dnsmasq -x /run/dnsmasq/dnsmasq.pid -u dnsmasq -r /run/dnsmasq/resolv.conf -7 /etc/dnsmasq.d,.d

jun 04 18:10:08 grievous systemd[1]: Starting dnsmasq - A lightweight DHCP and caching DNS server...
jun 04 18:10:08 grievous dnsmasq[793]: dnsmasq: revisión de sintaxis OK.
jun 04 18:10:08 grievous dnsmasq[842]: iniciado, versión 2.76 tamaño de caché 500
jun 04 18:10:08 grievous dnsmasq[842]: opciones de compilación: IPv6 GNU-getopt DBus i18n IDN DHCP DHCPv6 no-Lua TFTP conn
jun 04 18:10:08 grievous dnsmasq[842]: advertencia: ignorando opción resolv-file porque no-resolv está fijado
jun 04 18:10:08 grievous dnsmasq[842]: usando nombre de servidor 127.0.2.1#53
jun 04 18:10:08 grievous dnsmasq[842]: el caché fue liberado
jun 04 18:10:08 grievous dnsmasq[851]: Too few arguments.
jun 04 18:10:08 grievous systemd[1]: Started dnsmasq - A lightweight DHCP and caching DNS server.

Por lo que se ve dnsmasq trabajando sin problemas.

Se revisa el archivo /etc/resolv.conf y se tiene lo siguiente:

cat /etc/resolv.conf
# Generated by resolvconf
#nameserver 127.0.2.1
nameserver 127.0.0.1

Se están usando tanto dnscrypt como dnsmasq para resolver las consultas de DNS.

Al consultar un dominio por medio de dig se tiene lo siguiente:

# dig www.google.com

; <<>> DiG 9.10.3-P4-Debian <<>> www.google.com
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 41085
;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 4096
;; QUESTION SECTION:
;www.google.com.   IN A

;; ANSWER SECTION:
www.google.com.  190 IN A 172.217.22.164

;; Query time: 300 msec
;; SERVER: 127.0.0.1#53(127.0.0.1)
;; WHEN: Tue Jun 06 20:08:50 -04 2017
;; MSG SIZE  rcvd: 59

# dig www.google.com

; <<>> DiG 9.10.3-P4-Debian <<>> www.google.com
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 49000
;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 4096
;; QUESTION SECTION:
;www.google.com.   IN A

;; ANSWER SECTION:
www.google.com.  189 IN A 172.217.22.164

;; Query time: 0 msec
;; SERVER: 127.0.0.1#53(127.0.0.1)
;; WHEN: Tue Jun 06 20:08:51 -04 2017
;; MSG SIZE  rcvd: 59

Al realizar la segunda consulta se nota que el tiempo de respuesta pasa de 300mseg a 0mseg.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Usar tor desde privoxy en Debian Stretch

2017-06-06T09:00:00-04:00

Privoxy es un proxy web que se usa normalmente con tor.

En el artículo anterior se explica como instalar tor. Ahora se usará privoxy como proxy para tor.

Para instalar simplemente se usa apt:

#apt-get install privoxy

En privoxy se define el sock forward quien será el puerto e IP donde se está ejecutando tor (localhost y puerto 9050), se edita el archivo /etc/privoxy/config y se agrega la siguiente línea:

forward-socks4a / localhost:9050 .

Se reinicia privoxy:

# /etc/init.d/privoxy restart
[ ok ] Restarting privoxy (via systemctl): privoxy.service.

Se revisa que esté funcionando:

# /etc/init.d/privoxy status
● privoxy.service - Privacy enhancing HTTP Proxy
   Loaded: loaded (/lib/systemd/system/privoxy.service; enabled; vendor preset: enabled)
   Active: active (running) since Tue 2017-06-06 22:50:00 -04; 1s ago
     Docs: man:privoxy(8)
           https://www.privoxy.org/user-manual/
  Process: 20044 ExecStopPost=/bin/rm -f $PIDFILE (code=exited, status=0/SUCCESS)
  Process: 20082 ExecStart=/usr/sbin/privoxy --pidfile $PIDFILE --user $OWNER $CONFIGFILE (code=exited, status=0/SUCCESS)
 Main PID: 20083 (privoxy)
    Tasks: 1 (limit: 4915)
   Memory: 1.3M
      CPU: 8ms
   CGroup: /system.slice/privoxy.service
           └─20083 /usr/sbin/privoxy --pidfile /var/run/privoxy.pid --user privoxy /etc/privoxy/config

jun 06 22:49:59 grievous systemd[1]: Starting Privacy enhancing HTTP Proxy...
jun 06 22:50:00 grievous systemd[1]: Started Privacy enhancing HTTP Proxy.

En firefox se instala foxy proxy standar:

Se configura para usar el proxy localhost y puerto 8118:

Al verificar con la siguiente URL el uso de tor https://check.torproject.org/?lang=es_AR, se tiene lo siguiente:

Al lado izquierdo de la caja de busqueda está el icono de foxyproxy, el cual se encuentra activo al momento de verificar si se está usando tor.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Navegar de manera anónima con tor en Debian Stretch

2017-06-05T09:00:00-04:00

En el artículo anterior expliqué como consultar DNS de manera cifrada , ahora vamos a utilizar tor para navegar de manera anónima.

Se tiene dos opciones, una es bajar el tar.xz de tor-browser en la página oficial y la otra es instalar tor a lo Debian. Ese será el caso de este artículo.

El artículo se basa en la documentación de instalación de tor para Debian.

Se crea el archivo /etc/apt/sources.list.d/torbrowser.list con los siguientes repositorios:

deb http://deb.torproject.org/torproject.org stretch main
deb-src http://deb.torproject.org/torproject.org stretch main

Se descarga la llave gpg de los paquetes:

$gpg --keyserver keys.gnupg.net --recv A3C4F0F979CAA22CDBA8F512EE8CBC9E886DDD89

Se exporta la llave y se agrega al juego de llaves que tiene apt.

Comando como root:

#gpg --export A3C4F0F979CAA22CDBA8F512EE8CBC9E886DDD89 |  apt-key add -

Comando usando sudo:

$gpg --export A3C4F0F979CAA22CDBA8F512EE8CBC9E886DDD89 | sudo apt-key add -

Se actualiza la lista de paquetes:

#apt-get update

Se instala tor:

#apt-get install tor deb.torproject.org-keyring

Desde mozilla firefox se da clicñ a preferencias, luego a avanzado, red y configuración. Ahí se selecciona configuración manual de proxy y en servidor socks se coloca localhost y el puerto 9050, con socks_v5. Como se muestra en la siguiente figura:

Ahora se abre el navegador en whatismyip.org:

La imagen muestra la IP que se está utilizando que es el 178.151.224.153.

Ahora se verifica que se esté usando tor con https:/check.torproject.org/?lang=es_AR y se tiene la siguiente figura:

En la figura se muestra que ya se está usando tor desde el navegador.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Cifrar el tráfico de DNS en Debian 9 Stretch (actualización 2017)

2017-06-03T09:00:00-04:00

En el año 2012 preocupado por la lentitud y seguridad en las comunicaciones de las consultas de DNS escribí un artículo sobre DNSCrypt.

Este artículo se basa en el artículo Comprobar que DNSCrypt funciona correctamente y cifra el tráfico .

Para esa época la instalación se hacía bajando un archivo .deb, pero en Debian Stretch ya viene incorporado en los repositorios, así que para instalar es con un simple apt-get.

apt-get install dnscrypt-proxy dnscrypt-proxy-plugins

Revisar que DNSCrypt esté activo:

# systemctl status dnscrypt-proxy.socket
● dnscrypt-proxy.socket - dnscrypt-proxy listening socket
   Loaded: loaded (/lib/systemd/system/dnscrypt-proxy.socket; enabled; vendor preset: enabled)
   Active: active (running) since Sat 2017-06-03 00:26:02 -04; 18h ago
     Docs: man:dnscrypt-proxy(8)
   Listen: 127.0.2.1:53 (Stream)
           127.0.2.1:53 (Datagram)

jun 03 00:26:02 grievous systemd[1]: Listening on dnscrypt-proxy listening socket.

Como se ve DNSCrypt está activo, para el caso de que no esté activo se ejecuta:

# systemctl start dnscrypt-proxy.socket

Para que DNSCrypt se ejecute automáticamente se ejecuta:

# systemctl enable dnscrypt-proxy.socket

La lista de servidores DNSCrypt lo pueden ver en /usr/share/dnscrypt-proxy/dnscrypt-resolvers.csv . En la siguiente imagen se muestra algo del contenido del archivo:

Ahora se consulta el puerto y la IP que está usando DNSCrypt:

# cat /etc/systemd/system/sockets.target.wants/dnscrypt-proxy.socket
[Unit]
Description=dnscrypt-proxy listening socket
Documentation=man:dnscrypt-proxy(8)
Wants=dnscrypt-proxy-resolvconf.service

[Socket]
ListenStream=127.0.2.1:53
ListenDatagram=127.0.2.1:53

[Install]

WantedBy=sockets.target

La dirección IP que está usando DNSCrypt es la 127.0.2.1 y el puerto 53.

Este archivo se modifica si se está usano SystemD, para el caso de usar init.d se modifica el archivo que se describe a continuación.

Se edita el archivo /etc/dnscrypt-proxy/dnscrypt-proxy.conf :

vim /etc/dnscrypt-proxy/dnscrypt-proxy.conf

# cat dnscrypt-proxy.conf 
# A more comprehensive example config can be found in
# /usr/share/doc/dnscrypt-proxy/examples/dnscrypt-proxy.conf

ResolverName random
Daemonize yes

# LocalAddress only applies to users of the init script. systemd users must
# change the dnscrypt-proxy.socket file.
LocalAddress 127.0.2.1:53

Con la opción random garantiza que se use cualquier servidor de DNSCrypt de la lista ya mencionada.

Al levantar el servicio de DNSCrypt este cambia la configuración de /etc/resolv.conf para que use la IP 127.0.2.1, a continuación se muestra el contenido del archivo

# cat /etc/resolv.conf

# Generated by resolvconf
nameserver 127.0.2.1

Al iniciar el servicio se puede revisar el log de syslog para ver si funciona el servicio:

Como se puede ver en el syslog, al inicio el servicio espera por un certificado digital y luego es que empieza a funcionar.

Al consultar con el comando host se tiene:

host www.google.com
www.google.com has address 216.58.209.68
www.google.com has IPv6 address 2a00:1450:401b:801::2004

Ahora se instalarán unas herramientas de consultas:

apt-get install dnsutils

Se realiza una consulta con el comando dig:

dig www.google.com

; <<>> DiG 9.10.3-P4-Debian <<>> www.google.com
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 6930
;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 4096
;; QUESTION SECTION:
;www.google.com.   IN A

;; ANSWER SECTION:
www.google.com.  7 IN A 216.58.209.68

;; Query time: 266 msec
;; SERVER: 127.0.2.1#53(127.0.2.1)
;; WHEN: Sat Jun 03 20:26:08 -04 2017
;; MSG SIZE  rcvd: 59

Para verificar el funcionamiento del cifrado en DNSCrypt se usará wireshark-gtk, primero se instala y luego se ejecuta:

#apt-get install wireshark wireshark-gtk

Para averiguar la IP del servidor DNSCrypt que se está usando se usa dnsleaktest, al abrir la página muestra que la IP del equipo se encuentra en Barquisimeto, Venezuela y la IP es 186.185.180.136.

Se le da click a standard test:

La IP del servidor es 81.2.237.32.

Se inicia wireshark capturando paquetes de la interface wlp1s0 que es ahora como se llama wlan0 en Debian Strech. Se inicia la captura de paquetes y se filtra ip.addr == 81.2.237.32. El resultado se muestra a continuación:

El protocolo que se usa en la comunicación es QUIC el cual es un experimental que cifra la comunicación. Se selecciona el primer paquete y con el botón derecho se le da clic a follow udp steam obteniendo lo que se muestra en la siguiente figura:

Al ejecutar esa acción se realiza la construcción de los diferentes paquetes en este caso de UDP en formato crudo, como se puede ver la comunicación no muestra información en texto plato.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Obtener datos de eventos sismológicos de Funvisis con Python

2017-05-19T09:00:00-04:00

Este artículo es gracias al código desarrollado por William Cabrera, donde en su blog menciona que creó un Canal en Telegram sobre los Sismos en Venezuela. El código fuente de sus scripts en php fueron la base para el código Python que se muestra en este artículo.

Gracias William por esta herramienta de información que es el Canal en Telegram.

Se usará mechanize y BeautifulSoup para obtener la información del sitio de funvisis por medio de WebScraping. La información que se quiere obtener se muestra en un recuadro en la siguiente figura:

Para ver cual sección del código html se tiene que buscar, se le da boton derecho a inspeccionar elemento y la siguiente figura muestra el resultado:

Ahí se ve claramente el tag html que es necesario buscar.

A continuación se muestra el código de la aplicación:

#!/usr/bin/env python





#Se importa mechanize y cookielib

import mechanize

import cookielib

#Se importa beautifulSoup

from BeautifulSoup import BeautifulSoup





def Sismo():

    br = mechanize.Browser()

    #Se crea una instancia para la Cookie

    cj = cookielib.LWPCookieJar()

    #Se asocia la instancia del cookie con el navegador.

    br.set_cookiejar(cj)

    #Se deshabilita el manejo de robots.txt

    br.set_handle_robots(False)

    #Se define el tiempo de refrescamiento

    br.set_handle_refresh(mechanize._http.HTTPRefreshProcessor(), max_time=1)

    #Se pasa el url del sitio timeanddate con la informacion

    url = "http://www.funvisis.gob.ve/"



    urlhome = url + "index.php"

    #de la salida y ocultamiento del sol en Venezuela.

    #Se define las cabeceras del navegador, en este caso se le esta diciendo

    # que el navegador es un firefox desde Linux Debian

    br.addheaders = [('SSL_VERIFYHOST', False),\

        ('FRESH_CONNECT',True),\

        ('RETURNTRANSFER',True),\

        ('SSL_VERIFYPEER', False),\

        ('Referer', 'http://www.cantv.com.ve'),\

        ('User-agent','Mozilla/5.0 (X11; U; Linux i686; es-VE; rv:1.9.0.1)Gecko/2008071615 Debian/6.0 Firefox/9')]

    #Se abre el url

    r = br.open(urlhome)

    #Se lee el htmml de la pagina

    html = br.response().read()

    #Se crea una instancia de BeautifulSoup pasando el html

    #a verificar

    soup = BeautifulSoup(html)

    sismo = {}



    #SE obtiene el primer  div que tengan class module

    for row in soup('div', {'class': 'module'})[0]:

        #Se obtiene el tag a para luego obtener el href y tener el url

        #del gif del sitio de funvisis que tiene la imagen del sitio donde

        #fue el sismo.

        trs = row.find('a')

        if trs == -1:

            continue

        sismo['urlref'] = url  + trs.get('href',None)



        trs = row.find('tr')

        if trs == -1:

            continue

        #Obtiene los datos del sismo del sitio de funvisis

        datos = trs.find('td').getText()

        sismo['fecha'] = datos.split('&nbsp;')[1][:-5]

        sismo['hora'] =  datos.split('&nbsp;')[2][-20:-14]

        sismo['magnitud'] = datos.split('&nbsp;')[3][-16:-12]

        sismo['profundidad'] = datos.split('&nbsp;')[4][-6:] + " " + datos.split('&nbsp;')[5][-11:-8]

        sismo['latitud'] = datos.split('&nbsp;')[6].split('&ordm;')[0][-9:] +datos.split('&nbsp;')[6][-10:-9]

        linea = datos.split('&nbsp;')[7].split('&ordm;')

        sismo['longitud'] = linea[0][-9:]+ linea[1][0]

        sismo['epicentro'] = datos.split('&nbsp;')[8]

        return sismo



def EventoSismoJSON():

    #Devuelve los datos del sismo en formato JSON

    import json

    return json.dumps(Sismo())



if __name__ == '__main__':

    print Sismo()

    print EventoSismoJSON()

A ejecutar el Script devuelve el diccionario con la información del evento sismológico.

python sismux_getdata.py 
{'hora': u'16:13 ', 'latitud': u'   11.73 N', 'epicentro': u'52 Km al sur de Curazao', 'profundidad': u'  40.6 km', 'fecha': u'19/05/2017', 'urlref': u'http://www.funvisis.gob.ve/images/reportes/2017/05/reporte_7415.gif', 'magnitud': u' 3.0', 'longitud': u'  -68.93 O'}
{"hora": "16:13 ", "latitud": "   11.73 N", "epicentro": "52 Km al sur de Curazao", "profundidad": "  40.6 km", "fecha": "19/05/2017", "urlref": "http://www.funvisis.gob.ve/images/reportes/2017/05/reporte_7415.gif", "magnitud": " 3.0", "longitud": "  -68.93 O"}

El código fuente del script lo pueden ver en el repositorio de gitlab.

El siguiente artículo será subir la información en una base de datos mongoDB en mongolab y consultar si el evento sismográfico ya no está registrado.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Cálculo de Pi por el método MonteCarlo usando Python.

2017-05-08T09:00:00-04:00

El método MonteCarlo es un método estadístico numérico que se usa para aproximar expresiones matemáticas complejas y costosas de evaluar conexactitud. Para más información pueden revisar wikipedia.

La expresión matemática que se va a resolver es el cálculo de Pi.

En este artículo mostraré dos versiones del uso del Método MonteCarlo.

El primer ejemplo el algoritmo fue tomado de un código en Pascal y llevado a Python. A continuación el código:

#!/usr/bin/env python

#Se importa el modulo random

import random



#Se define la funcion

def Pi(limite=10000000):

    dentro = 0

    contador = 0

    #Se hace un ciclo hasta que contador sea igual al limite

    while contador < limite:

        #Se calcula  que los puntos esten dentro del radio del circulo

        #Si es asi se incrementa la variable dentro. y luego se incrementa

        #contador para pasar al siguiente ciclo.

        if ((random.random()**2 + random.random()**2) <= 1):

            dentro += 1

        contador += 1

    #Se retorna el resultado de la cantida de puntos dentro del circulo

    #entre el limite por 4.

    return 4.0*float(dentro)/limite



if __name__ == "__main__":

    n = (10000, 1000000,100000000)

    for i in n:

        print ("El valor de pi es: {0:2.8f} para n {1}".format(Pi(i),i))

Al ejecutar el código se tiene:

El valor de pi es: 3.14960000 para n 10000
El valor de pi es: 3.14308000 para n 1000000
El valor de pi es: 3.14141900 para n 100000000

Al aumentar el valor de n se logra tener un número más preciso del valor de PI, claro también se llevará más tiempo en calcular.

En el siguiente ejemplo se basa en un articulo en inglés publicado en Medium que se llama Day 9: Monte Carlo Pi y el código del mismo se encuentra en github.

El código se muestra a continuación:

#!/usr/bin/env python

#Se importa el modulo numpy

import numpy as np





def pi(n, batch=1000):

    t = 0

    for i in range(n // batch):

        p = np.random.rand(batch, 2)

        p = (p * p).sum(axis=1)

        t += (p <= 1).sum()

    return 4 * float(t) / n





if __name__ == "__main__":

    print ("El valor de pi es: {0:2.8f} para n {1}".format(pi(10**8),10**8))

Al ejecutarlo se obtiene:

El valor de pi es: 3.14146076 para n 100000000

Como ven la última versión es menos la cantidad de líneas de código y más rápida.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Reestructuración del blog.

2017-05-07T09:00:00-04:00

Tengo varios días sin escribir algo en el blog, primero está la situación local, y lo otro es que ando pensando hacer una reestructuración de los blogs que tengo.

Los blogs que tengo son:

ernestocrespo.blogspot.com: Blog en inglés que lo tengo algo descuidado. Este blog lo pienso migrar de primero al url http://blog2.crespo.org.ve y usaré pelican para el contenido.
blog.crespo.org.ve: Versión en Español del blog, que tiene más de 300 posts. Como este blog es el que tiene más contenido, la migración será por etapas teniendo una versión beta con nombre blog3.crespo.org.ve, cuando esté lista la migración pasará a ser blog.crespo.org.ve.
Medium: Este blog será para temas generales no técnicos o algunos técnicos (muy pocos).
ernestocrespo13.wordpress.com: Este normalmente es un respaldo del blog en Español, ahora manejará los posts de ambos blogs en inglés y español como respaldo.

En un futuro dejaré de publicar en blogspot y wordpress dejando sólo los blogs en pelican.

Otro actividad que tengo es levantar www.crespo.org.ve, y que los dos blogs junto con el de Medium estén enlazaos allí.

El otro punto es que voy a empezar a utilizar acortadores de URL que permitan monetizar el blog, así como ya he colocado enlaces para recibir donaciones vía Billetera Bitcoin o paypal.

A continuación les dejo una imagen donde se encierra en un recuadro negro la billetera bitcoin y el formulario para donar por medio de paypal.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera:

Entorno de Desarrollo en la nube Cloud9

2017-04-10T09:00:00-04:00

Cloud9 es un Entorno Integrado de Desarrollo en línea, publicado como OpenSource desde la versión 3.0.

Acá les dejo otros enlaces de artículos sobre docker.

La aplicación la pueden acceder en c9.io .

A continuación se muestra una imagen del sitio:

Es desarrollado enteramente en javascript, node.js como backend, los espacios de trabajo se contruyen por medio de Docker.

Soporta varios lenguajes de programación, entre los principales se tiene:

C/C++
PHP
Ruby
Perl
Python
Javascript
Go

Como cloud9 es OpenSource a parte de usarlo desde su sitio web, se puede montar un servidor, su código fuente se encuentra en github. El procedimiento de instalación lo encuentrán en el siguiente enlace.

En este caso se usará una imagen Docker para montarlo como servidor local. La imagen que se usará la pueden revisar en el siguiente enlace.

Para correr cloud9 como contenedor se ejecuta:

docker run -it -d -p 9080:80 -v /home/ernesto/worksplace/:/workspace/ kdelfour/cloud9-docker

En este caso se corre la aplicación desde el puerto 9080 y se usará como directorio de trabajo workspace.

Al hacer un docker ps se tiene lo siguiente:

CONTAINER ID        IMAGE                    COMMAND                  CREATED             STATUS              PORTS                            NAMES
f4d06af60205        kdelfour/cloud9-docker   "supervisord -c /etc/"   38 seconds ago      Up 33 seconds       3000/tcp, 0.0.0.0:9080->80/tcp   condescending_gates

Ahora se abre el navegador en el puerto 9080, a continuación se muestra la imagen:

Imagen mientras carga cloud9:

Entorno de trabajo y muestra de un Hola mundo!:

Como se puede ver, ya no es necesario usar la herramienta desde la web, ya puede usarse desde un servidor local usando una imagen Docker.

¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV

O Escaneando el código QR desde la billetera: