List Comprehension en Nested For Loop

Ejemplo de for loop anidado de la forma tradicional y mismo ejemplo en formato "list comprehension":

script:

familia = {
            'hermanas': ['sofi','flor'],
            'hermanos': ['pablo', 'pedro'], 
            }

# TRADICIONAL
nombres = []
for grupo in familia: 
    for nombre in familia[grupo]: 
        nombres.append(nombre)
print(nombres)

# LIST COMPREHENSION
nombres = [nombres for grupo in familia for nombres in familia[grupo]] 
print(nombres)

Igualdad en Decimales

Si se evalúa la igualdad de números decimales en Python, se puede encontrar con diferencias como:

(0.1 + 0.1 + 0.1) == 0.3  --> False

Esto pasa porque algunos decimales no pueden ser representados en formato binario, es decir en base 2.

Varias soluciones simples pueden implementarse según el escenario, como usar la función round.

Una forma más general es usar la función isclose de la librería math que usa los parámetros de tolerancia abs_tol y rel_tol.

Para documentación de la librería math, ver Referencia No.1, y el PEP-485 en la Referencia No.2

script:

import math

a = 0.1 + 0.1 + 0.1
b = 0.3
print(math.isclose(a, b, abs_tol=0.0001, rel_tol=0.0001))
#True

a = 99999999.01
b = 99999999.02
print(math.isclose(a, b, abs_tol=0.0001, rel_tol=0.0001))
#True

a = 0.01
b = 0.02
print(math.isclose(a, b, abs_tol=0.0001, rel_tol=0.0001))
#False

Referencias 1. https://docs.python.org/3/library/math.html 2. https://www.python.org/dev/peps/pep-0485/

Funcion para cargar un dataset

El siguiente script crea un pandas.DataFrame evaluando el tipo de dato que recibe (bytes, str, path) y luego lo lee usando pandas.read_csv.

script:

import os
from io import StringIO
import pandas as pd


def load_data(data):
    if isinstance(data, pd.DataFrame):
        return data
    elif isinstance(data, bytes):
        return pd.read_csv(StringIO(str(data, 'utf-8')), encoding='utf-8', sep=',')
    elif len(data) <= 260 and os.path.exists(str(data)):
        return pd.read_csv(data, encoding='utf-8', sep=',')
    elif isinstance(data, str):
        return pd.read_csv(StringIO(data), encoding='utf-8', sep=',')

Consultar clima con openweathermap

El siguiente script consulta el clima en el servicio openweathermap y lo guarda en una base postgresql. El script sigue estos pasos:

1. Si es la primera ejecución, consulta latitud y longitud al servicio ipinfo.io y guarda este dato en un archivo geopoint.yaml. Si no es la primera vez, levanta el archivo geopoint.yaml.

2. Usando la latitud y longitud, consulta la temperatura y humedad al servicio openwathermap, que es suministrada en formato json

3. Guarda los datos en una base potgresql

NOTAS:
- Para ejemplo de una REST Api que guarda info en postgresql, ver nota publicada AQUI.
- Este script requiere una api_id provista por https://openweathermap.org/

REST Api con Python y Flask

El siguiente script crea una REST Api de ejemplo usando la librería Flask de Python. Esta Api tiene dos metodos:

1.
postJsonHandler():
Con el metodo POST, esta función permite recibir informacion en formato json y la guarda en un tabla de postgresql. El body del post es así:
{
    "device_id": 4,
    "temperature":17,
    "humidity": 23,
    "occupied":1
}


2.
GetJsonHandler():
Con el metodo GET esta función permite recuperar el ultimo registro guardado en la tabla en formato json.

NOTA: Para consultar el clima usando la api OPenWeatherMap ver nota publicada AQUI

Conceptualmente el flujo de la api es así:

Generar CUIL Random

El siguiente script genera CUIL random válidos en Argentina. El parámetro g refiere al genero, donde m=masculino, f=femenino. Función desarrollada por Juan Cruz Sosa.

pyhton script:

import random
def choose_cuil(g='f'):
 g = 20 if g == 'm' else 27
 cuil = '{}{}'.format(g, random.randint(10000000, 59999999))
 cuil = list(map(int, cuil))
 assert(len(cuil) == 10)
 base = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
 aux = (-sum(c*b for c, b in zip(cuil, base))) % 11
 if aux == 10:
  return choose_cuil(g)
 return '{}-{}-{}'.format(''.join(map(str, cuil[0:2])), ''.join(map(str, cuil[2:])), aux)

choose_cuil('m')
# Resultado:
# '27-17188949-4'

Referencia
https://es.wikipedia.org/wiki/Clave_%C3%9Anica_de_Identificaci%C3%B3n_Tributaria

Leer datos de Neo4j

El siguiente script lee datos de Neo4j  de los últimos 10 dias, y lo guarda en un CSV

script:

from py2neo import Graph
import pandas as pd

def neo_conect():
 srv = "http://mi_server.com:7474"
 auth = ("mi_user", "mi_pass")
 return srv, auth

def get_ndata(srv, auth, days=10):
 dt_from = (datetime.date.today() - datetime.timedelta(days=days))
 dt_from = round(datetime.datetime.fromordinal(dt_from.toordinal()).timestamp())
 graph = Graph(srv, auth=auth)
 q = "MATCH (u:user)-[r:RELACION]->(i:item) WHERE r.date >=" +str(dt_from)+ " RETURN u.id as user_id, i.id as item_id, r.date as fecha"
 df = graph.run(q).to_data_frame()
 return df

def main():
 srv, auth = neo_conect()
 df = get_ndata(srv, auth, days=10)
 df.to_csv('neo4j_data.csv', encoding='utf-8', index=False)

if __name__ == '__main__':
 main()

Referencia:
https://medium.com/neo4j/py2neo-v4-2bedc8afef2

Encontrar lambda de Box-Cox

El siguiente script calcula el valor lambda que hace que una variable, al ser elevada a este valor, tenga una distribucion mas cercana a una distribucion normal, segun tecnica Box-Cox. Esto con el objetivo de identificar cuales son las variables de un dataset que no tienen una distribución normal y que pueden transformarse para obtener mayor información de ellas.

NOTA: Este script es un ejemplo de busqueda, existe una funcion para esto en la librería scipy. Ver Referencia 1.

El script sigue estos paso:
1. carga el dataset boston.csv desde dropbox
2. crea la funcion is_not_normal que devuelve True si la asimetria de la variable es menor a -1 o mayor a 1, y si ademas el coeficiente de variacion (std/avg) es mayor a 1.
3. crea la funcion find_lambda que recibe el dataset en formato pandas.DataFrame y busca las variables que no son normales (usando la funcion is_not_normal) para luego imprimir los valores lambda de esas variables no normales.



Conceptualmente, la busqueda de el valor lambda seria así:

las formas generales de exponentes son estas:

Para el dataset boston, una de las variables que no tiene una distribucion normal es crim,
y la salida del script seria algo así:

si graficamos la variable crim vs la crim^-0.05, queda así: