Redondear decimales en Pandas con round y decimal

En esta ocasión hablare del uso de round() y decimal().

Ya en antes, he hablado, de lo que significa, y cómo aplicar el redondeo de la mejor forma posible en Python.

Sabemos, que existen múltiples ocasiones, en las que podemos necesitar sustituir un valor de tipo entero, por otro con una cantidad de decimales dada;  o directamente asignar solo una cantidad de decimales a todos los valores dentro de una dataframe.

Veamos un ejemplo para mostrar las diferentes opciones.

Primero importamos las librerías.

Importamos el dataframe

Usando round() en Pandas

Es una función que  redondea un número de coma flotante, al número de lugares decimales proporcionados como segundo argumento de la función.

Su sintaxis es round(value, numero de decimales)

En este ejemplo redondeamos la columna 2 de un dataframe

Primero aplicamos la función series() de Pandas, definimos la función round() con los espacios que deseamo, para luego aplicar un bucle for, para recorrer la columna.  

En este caso la labor de round(), es colocar una coma flotante, y dejar la cantidad de decimales que le indicamos al redondear, como segundo parámetro.

Format() como apoyo

Otra forma, es utilizar format(), pero como su nombre indica, por si sola, no redondea, sino que formatea la salida de la cadena, dandole la estructura que deseamos.

format() es una propiedad de string, o sea trabaja con una cadenas, y por lo tanto no debe confundirse con valores numéricos

La sintaxis es algo como lo que sigue, cuando la usamos en solitario, aunque existen multiples combinaciones para aplicar formato.

En este caso estamos formateando la salida de un valor a porcentaje con solo dos decimales.

df['columna3'] = pd.str(["{0:.2f}%".format(val * 100) for val in df[' columna3']])

El formato de cadena le permite representar los números como desee. Puede cambiar el número de lugares decimales que se muestran cambiando el número antes de la f.  

Usando Decimal

Cuando necesitamos una adecuada precisión es recomendable usar decimal, ya que es mucho mas adecuado que round(), si buscamos exactitud.

Puedes ver este articulo sobre la diferencia entre round() y decimal()

La construcción de la sintaxis es como se ve en el ejemplo:

En el primer caso, solo ejecutamos una división, donde obtenemos un número de coma flotante.

En los ejemplos siguientes, lo que hacemos en indicarle a Python que estamos esperando un resultado en formato decimal.

En el segundo tomamos algunas de las propiedades del contexto y le decimos a Decimal que tipo de redondeo queremos.

En el tercer y ultimo calculo, solo tomamos el contexto predeterminado e indicamos el nivel de precision que deseamos.

En todos los casos hemos redondeado a dos espacios pero podríamos haber fijado cualquier cantidad de dígitos, que necesitáramos.

..se me ha olvidado ya el lugar de donde vengo, y puede que no exista el sitio adonde voy…

J.Sabina

Pickle. serializar datos con Python

logo python

Al manejar datos, de gran volumen, que necesitamos por ejemplo guardar en archivos, para manejarlos con mayor facilidad, lo màs adecuado es serializarlos. 

El modulo pickle de Python, de que hablaré en ese post,  lo que hace es, serializar objetos para que puedan guardarse en un archivo y tener la opción de volver a cargarlos más adelante.

pickle() se utiliza para serializar y deserializar estructuras de objetos de Python,  esta acción es también conocida cómo clasificación o aplanamiento de los datos.

La serialización, en su explicación más simple no es otra cosa que  convertir un objeto que tenemos en la memoria, en un flujo de bytes que se puede almacenar en el disco o enviar a través de una red,  y que puede ser posteriormente recuperado, transformándolo nuevamente en un objeto Python deserializado.

Las ventajas de serializar nuestros datos, no es solamente que se puedan guardar en el disco para continuar trabajando con ellos, y que podamos también enviar nuestros datos a otros por TCP, o una conexión de socket.

Pickle es igualmente poderosa porque a través de ella podemos almacenar objetos de Python en una base de datos.

Sobre todo cuando trabajamos con algoritmos de aprendizaje automático, conocer su uso nos evitará tener que reescribir todo o entrenar el modelo nuevamente, ya que podemos guardarlos y recuperarlos cuando queramos.   

Datos

Pickle(), nos permite  serializar los siguientes datos:

Cadenas,

Listas,

Tuplas

Enteros

Flotadores

Booleanos,

Números complejos,

Diccionarios que contienen objetos serializables.

Dataframes

 Pickle(), también puede serializar las clases y funciones, incluso las lambdas.  En el caso de estas últimas se usa dill(), un paquete adicional diseñado para ello, a partir de un fork de multiprocessing(), el paquete de multiprocesamiento de Python

A pesar de su capacidad, elementos como los dict predeterminados, las clases internas, o los generadores pueden tener problemas para ser serializados.

Los dicts predeterminados, necesitan ser creados con una función a nivel de módulo.

Serializando archivos

Importamos pickle()  

import pickle

Creamos un diccionario  y luego estructuramos un archivo de salida llamado alumnos_dic.

#escribimos un diccionario sencillo
alumnos_dict = {'Jose': 7,'Arnoldo': 8,'Mario': 5, 'Maria': 78,'Amara': 50,'Rolando': 67,'Hemeregildo': 78,'Prudencio': 79,'Zoraida': 0}

Abrimos un archivo utilizando la función open(), para poder escribirlo en formato binario. En este articulo, puede leerse un poco mas sobre las opciones para usar open().

#abrimos nuestro archivo para escribir en formarto binario
alumnos_pick= open('alumnos', 'wb')

Serializamos el archivo inicial y obtenemos un nuevo objeto file, luego cerramos la conexión

#usamos dump para serializar
pickle.dump(alumnos_dict, alumnos_pick)
alumnos_pick.close()

Deserializar nuestro archivo

El proceso de volver a cargar un archivo serializado en Python, no es complejo.

Usaremos la función open () nuevamente, pero esta vez con 'rb' como segundo argumento.

alumnos_pick.close()

Lo que haremos será leer el formato binario con que serializamos anteriormente.

#usamos dump para serializar
pickle.dump(alumnos_dict, alumnos_pick)
alumnos_pick.close()

Asignamos su valor  a infile.

infile = open('alumnos','rb')

Para cargar el archivo utilizamos pickle.load (), con infile como argumento, al que asignaremos  a nuevo_alumnos.

nuevo_alumnos = pickle.load(infile)

El contenido del archivo ahora está asignado a esta nueva variable.

Nuevamente,  cerramos  el archivo al final.

infile.close()
nuevo_alumnos
output:{'Jose': 7, 'Arnoldo': 8, 'Mario': 5, 'Maria': 78, 'Amara': 50, 'Rolando': 67, 'Hemeregildo': 78, 'Prudencio': 79, 'Zoraida': 0}

Comparamos los archivos.

#comparamos ambos archivos
print(nuevo_alumnos==alumnos_dict)
print(type(nuevo_alumnos))
output: True 
<class 'dict'>

Comprimir archivos

Si el tamaño del archivo es grande, por ejemplo datasets, voluminosos, podemos ahorrar espacio comprimiendo, el archivo deserializado.

Hay diferentes vías, dos de ellas son bzip2 y gzip.  Puede ver otras en este articulo.

Su diferencia en esencia, radica en que  gzip  es más rápido, pero los archivos que crea bzip2, ocupan  la mitad de espacio que los que crea gzip.

Una cuestión importante y que puede tender a confundir es que deserializar, no es lo mismo que comprimir.  

La deserialización es la conversión de un objeto de una representación (datos en la memoria de acceso aleatorio (RAM)) a otra (texto en el disco); mientras que la compresión es el proceso de codificación de datos con menos bits, para ahorrar espacio en el disco.

Lo primero es importar bz2

import bz2

Luego como primer parámetro del método BZ2File, pasaremos el nuevo nombre del nuevo archivo compactado que se creará al ejecutarse el script

sfile = bz2.BZ2File('compress_alumnos', 'w')
pickle.dump(alumnos_dict, sfile)

Multiproceso

Pickle es especialmente sensible al multiprocesamiento, pues hay elementos como las funciones lambda que no pueden ser fácilmente serializadas.

Cuando necesitamos realizar tareas complejas que ocupan mucho espacio de memoria, es común distribuir esta tarea en varios procesos.

El multiprocesamiento, es la subdivisión de un proceso en varios que se ejecutan simultáneamente, generalmente en varias Unidades Centrales de Procesamiento (CPU) o núcleos de CPU, ahorrando tiempo, como es el caso de operaciones de entrenamiento de modelos de aprendizaje automático, la creación de redes neuronales, todos ellos procesos intensivos.

En Python, esto se hace usando el paquete de multiprocesamiento multiprocessing().

La ventaja de trabajar de esta forma, es que los procesos en que se divide una tarea no comparten espacio de memoria, y comparten datos entre ellos serializados 

En el ejemplo lo que haremos será crear una especie de abstracción llamada pool, para que trabaje en segundo plano procesando una tarea, y al que indicaremos cuantos procesadores empleará para ello.

#trabajando con multiprocesamiento
#importamos el modulo y creamos con la la funcion cos una tarea
import multiprocessing as mp
from math import cos
p = mp.Pool(2)
p.map(cos, range(10))
output:[1.0, 0.5403023058681398, -0.4161468365471424, -0.9899924966004454, -0.6536436208636119, 0.2836621854632263, 0.9601702866503661, 0.7539022543433046, -0.14550003380861354, -0.9111302618846769]

Si quisiéramos ejecutar en vez de cos() un lambda, nos lanzara un error, indicando que Pickle no puede serializar un lambda.

p.map(lambda x: 2**x, range(10))
output: .......
PicklingError: Can't pickle <function <lambda> at 0x7fe84683a830>: attribute lookup <lambda> on __main__ failed

Afortunadamente existe un modulo para resolver esto dill(), que pertenece a un fork, llamado pathos.multiprocessing

Pathos esta en desarrollo aun, y debe ser instalado desde github, según recomendaciones de su creador. Puedes ver este articulo en stackoverflow

El amor siempre empieza soñando y termina en insomnio

R.Arjona

Trabajando con el modulo re() de Python

logo python

Python tiene un módulo llamado re para trabajar con las RegEx.

Pueden ver un articulo que escribí hace un tiempo, sobre ello.

En Python, existen herramientas especificas, que funcionan como auxiliares y modificadores para el trabajo con las RegEx.

Me refiero tanto al uso del modulo re() , como al empleo de r o R antes de una RegEx como prefijo.

Cuando se escribe una expresión regular y se coloca el \ delante de ella, este equivale a un escape del carácter que le sigue, de este modo \n o \r provocará que el lenguaje escape estos caracteres; sin embargo cuando colocamos r delante, estos serán considerados y tratados como un carácter normal.

La sintaxis para esto, es por ejemplo r’[\n\r]’

Veamos como usar re()

re.findall()

Nos devuelve una lista de todas las cadenas que contienen la coincidencias

import re

cadena = 'Cuanto hice hasta hoy, y haré, es para eso. En silencio ha tenido que ser y como indirectamente, porque hay cosas que para lograrlas han de andar ocultas, y de proclamarse en lo que son levantarían dificultades demasiado recias para alcanzar sobre ellas el fin.'
pattern = '\D+'
buscamos todos aquellos caracteres que no sean digitos con re.findall()
coincid = re.findall(pattern, cadena)
coincid
ouput:['Cuanto hice hasta hoy, y haré, es para eso. En silencio ha tenido que ser y como indirectamente, porque hay cosas que para lograrlas han de andar ocultas, y de proclamarse en lo que son levantarían dificultades demasiado recias para alcanzar sobre ellas el fin.']

pattern = '\d+'
output:[]

re.split()

Separa las cadenas donde existen las coincidencias y retorna una lista de  cadenas donde hay coincidencias.

pattern = '\D+'
cadena = 'amigos 12345 45:67'
#separamos las palabras de la cadena con re.split()
coincid = re.split(pattern, cadena)
coincid
output: ['', '12345', '45', '67']
pattern = '\d+'
output:cadena = 'amigos 12345 45:67'

#separamos las palabras de la cadena con re.split()
coincid = re.split(pattern, cadena)
coincid
output:['amigos ', ' ', ':', '']

Como se ve en el ejemplo se puede usar maxsplit para determinar el numero máximo de separaciones que deseamos que ocurran.

#utilizamos maxsplit 1
pattern = '\D+'
cadena = 'amigos 12345 45:67'
coincid = re.split(pattern, cadena, 1)
coincid
output:['', '12345 45:67']

#utilizamos maxsplit 3
pattern = '\D+'
cadena = 'amigos 12345 45:67'
coincid = re.split(pattern, cadena, 3)
coincid
output:['', '12345', '45', '67']

Re.sub()

Devuelve la cadena donde existe coincidencia y reemplaza el contenido con el valor de la variable replace.

#sustituimos en la cadena los valores con re.sub()
cadena = 'Cuanto hice hasta hoy, y haré, es para eso. En silencio ha tenido que ser y como indirectamente, porque hay cosas que para lograrlas han de andar ocultas, y de proclamarse en lo que son levantarían dificultades demasiado recias para alcanzar sobre ellas el fin.'
pattern = '\s+'
replace = ','
nueva_cadena = re.sub(pattern, replace, cadena)
nueva_cadena
out:'Cuanto,hice,hasta,hoy,,y,haré,,es,para,eso.,En,silencio,ha,tenido,que,ser,y,como,indirectamente,,porque,hay,cosas,que,para,lograrlas,han,de,andar,ocultas,,y,de,proclamarse,en,lo,que,son,levantarían,dificultades,demasiado,recias,para,alcanzar,sobre,ellas,el,fin.'

Podemos contar  utilizando count() como cuarto parámetro, para determinar cuántos reemplazosharenmos.

Si omitiéramos el valor sub(), reemplazará todas las coincidencias.

#añadiendo count() como parametro
string = 'Cuanto hice hasta hoy, y haré, es para eso. En silencio ha tenido que ser y como indirectamente, porque hay cosas que para lograrlas han de andar ocultas, y de proclamarse en lo que son levantarían dificultades demasiado recias para alcanzar sobre ellas el fin.'
pattern = '\s+'
replace = ','
nueva_cadena = re.sub(pattern, replace, string, 5)
nueva_cadena
output:'Cuanto,hice,hasta,hoy,,y,haré, es para eso. En silencio ha tenido que ser y como indirectamente, porque hay cosas que para lograrlas han de andar ocultas, y de proclamarse en lo que son levantarían dificultades demasiado recias para alcanzar sobre ellas el fin.'

re.subn()

Es similar a sub(), pero devuelve una tupla con contiene la nueva cadena y la cantidad de sustitucones realizadas.

#empleamos re.subn(), para obgener una tupla que contiene la nueva cadena y la cantidad de substituciones realizadas
cadena = 'Cuanto hice hasta hoy, y haré, es para eso. En silencio ha tenido que ser y como indirectamente, porque hay cosas que para lograrlas han de andar ocultas, y de proclamarse en lo que son levantarían dificultades demasiado recias para alcanzar sobre ellas el fin.'
pattern = '\s+'
replace = ','
nueva_cadena = re.subn(pattern, replace, cadena)
nueva_cadena
output: ('Cuanto,hice,hasta,hoy,,y,haré,,es,para,eso.,En,silencio,ha,tenido,que,ser,y,como,indirectamente,,porque,hay,cosas,que,para,lograrlas,han,de,andar,ocultas,,y,de,proclamarse,en,lo,que,son,levantarían,dificultades,demasiado,recias,para,alcanzar,sobre,ellas,el,fin.', 44)

re.search()

Se emplea para la búsqueda de coincidencias directamente, utilizando dos argumentos, el patrón a buscar y la cadena donde buscarlo.

Su resultado es un objeto match, si no hubiera coincidencia retornaría None.

#empleamos re.search(), para hallar la subcadena silencio
sustituimos en la cadena los valores con re.sub()
cadena = 'Cuanto hice hasta hoy, y haré, es para eso. En silencio ha tenido que ser y como indirectamente, porque hay cosas que para lograrlas han de andar ocultas, y de proclamarse en lo que son levantarían dificultades demasiado recias para alcanzar sobre ellas el fin.'
busqueda = re.search('silencio',cadena)
busqueda
output:<re.Match object; span=(47, 55), match='silencio'>

El objeto que nos devuelve la variable búsqueda es del tipo match, con el cual podemos hacer también varias operaciones.

#operando con el resultado, ahora buscamos silencio al final de una cadena y hacemos algo
adena = 'Cuanto hice hasta hoy, y haré, es para eso. En silencio ha tenido que ser y como indirectamente, porque hay cosas que para lograrlas han de andar ocultas, y de proclamarse en lo que son levantarían dificultades demasiado recias para alcanzar sobre ellas el fin.'
busqueda = re.search('\Zsilencio',cadena)
if busqueda:
pass
else:
print('no se halló nada')
output:no se halló nada

Con re(), podemos buscar utilizando re.match(), que  recibe dos parámetros: los patrones que buscamos y el texto donde los buscamos.

match.group()

Nos permite agrupar los resultados en subcadenas.

#buscamos con match.group() el grupo de letras seguidas por una r
cadena = 'Cuanto hice hasta hoy, y haré, es para eso. En silencio ha tenido que ser y como indirectamente, porque hay cosas que para lograrlas han de andar ocultas, y de proclamarse en lo que son levantarían dificultades demasiado recias para alcanzar sobre ellas el fin.'
pattern = '(a|e|i)r'
match = re.search(pattern, cadena)
if match:
print(match.group())
else:
print('no se halló nada')
output:ar

#buscamos un grupo que tiene dos digitos separados por un espacio de una cadena no digital de seis caracteres
cadena = '234 567896 10 acceso dni color de los ojos'
pattern = '(\d{2}) (\D{6})'
match = re.search(pattern, cadena)
if match:
print(match.group())
else:
print('no se halló nada')
output: 10 acceso

Podemos condicionar cuantas subcadenas queremos y sus posiciones

#imprimiendo solo el primer subgrupo
match = re.search(pattern, cadena)
if match:
print(match.group(1))
else:
print('no se halló nada')
output:10

#obteniendo la posicion donde comienza el grupo, donde termina y una tupla con ambos valores
match = re.search(pattern, cadena)
if match:
print(match.start(), match.end(), match.span())
else:
print('no se halló nada')
output:11 20 (11, 20)

Match.string

Nos devuelve la cadena.

match.string
output:'234 567896 10 acceso dni color de los ojos'

«En total oscuridad cualquier cosa, puede ser luz»

Programación lineal. Conceptos básicos.

Haciendo un ligero esbozo histórico, diré que la programación lineal, es una técnica que surgió en el primer tercio del siglo XX, y fue desarrollada, aplicándola a situaciones reales  para resolver problemas relacionados, con la programación, el transporte, y logística en los años, de la segunda guerra mundial.

Su creador fue el matemático ruso L. Kantorovich, y su aplicación inicial tuvo que ver con una optimización de los programas de  fabricación.

Sin embargo su aceptación, se extendió rápidamente a la economía y para 1950  el matemático estadounidense George Dantzig creó el primer algoritmo.

La programación lineal en esencia, es una función compleja que intenta determinar a partir de un conjunto de variables conocida, su influencia optima en determinados resultados.

Componentes de un problema de programación lineal

Las variables de decisión:

Son las cantidades, volúmenes o comportamientos, que se intentan estimar, como resultado.

La función objetivo:

Es la expresión matemática que intenta optimizar (maximizar o minimizar), algún valor numérico que representa ganancias, costos, cantidad de producción, volumen de inversión, etc;

Su razón de ser es evaluar, en qué medida cada variable de decisión contribuye al valor neto de una actividad económica especifica.

Coeficiente de la función:

Expresa la cantidad en la que el valor de la función objetivo cambiaría cuando se modifica una unidad de una variable de decisión, viene dada por el coeficiente de función objetivo correspondiente.

Restricciones:

Las restricciones son ecuaciones que limitan o definen la cantidad total de un recurso particular, que es necesario o requerido para llevar a cabo las actividades que decidirían el nivel de optimización de las variables de decisión.

Restricciones no negativas.

Una condición obligatoria de este tipo de restricciones, es que tienen que ser positivas con independencia, de que el objetivo de la función sea maximizar o minimizar el valor.

La solución óptima de un problema de programación lineal, es aquella que satisfaga mejor las restricciones.

Esto quiere decir que de todas las soluciones factibles, será óptima aquella que en el caso de una necesidad de maximización, el valor de la función objetivo sea el mayor posible, o sea el máximo.

Por el contrario, si nos encontramos ante un problema de minímización , la solución más adecuada será aquella donde la función objetivo ofrezca el mínimo.

Recursos disponibles

Constituyen los materiales, recursos, o elementos que participan en la ecuación y sobre los que se aplica la misma

Coeficientes tecnológicos

Cuando intentamos prever el futuro a través de la programación lineal, es importante considerar las limitaciones técnicas que nos impone la realidad objetiva y el entorno.

Los coeficientes tecnológicos, son elementos de referencia que conocemos y sobre los que se mueve el fenómeno que necesitamos estimar.  

La estructura de un problema de programación lineal debería ser algo como esto

Maximize  20* vd1 + 18*vd2; subject to
0.25*vd1 + 1*vd2  ≤60
1.40*vd1  + 0.5*vd2 ≤ 90 where vd1 & vd2 ≥ 0

Aquí podemos identificar los diferentes componentes:

vd1 y vd2 son las variables de decisión

Maximize  20* vd1 + 18*vd2 es la función objetivo

20* vd1  y  18*vd2 son los coeficientes de la función

0.25*vd1 + 1*vd2  ≤  60 es la primera restricción

1.40*vd1  + 0.5*vd2  ≤  90 es la segunda restricción

vd1 & vd2  ≥ 0 es la restricción negativa

0.25, 1, 1.40, 0.5 son los coeficientes tecnológicos

65, 90 es la disponibilidad de recursos

Elementos importantes

Potenciación

Partimos de considerar que las variables de decisión, siempre tienen una potencia de uno.

La condición critica

Para poder aplicar un problema  de programación lineal, es necesario tener definidas: la función objetivo, la disponibilidad de recursos y las variables de decisión positivas relacionadas entre sí.

Dualidad

Todo problema de programación lineal, puede convertirse a  su par correspondiente,  capaz de dar la misma solución factible de la función objetivo.

Esto lo puede hacer de modo automático el programa con el que trabajemos, pero conocer su esencia es importante.

Cuando se trata, por ejemplo de un problema de maximización, por lógica todas las restricciones asociadas con su función objetivo serán del tipo «menor que igual a» la disponibilidad de recursos dada, (podría ser solo «igual a», en el caso de una   restricción en particular restringida)

Si eso no sucediese y alguna restricción fuera del tipo «mayor que igual a» lo recomendable es convertir la solución a una forma canónica (multiplicar por un «menos») para que la restricción del problema de maximización se transforme en «menor que igual a» .

Por oposición si fuera un problema de minimización, entonces todas las restricciones asociadas con la función objetivo deben tener restricciones «mayor que igual a» a la disponibilidad de recursos considerada, a menos que exista alguna restricción que particularmente no esté restringida (tipo «igual a»), lo adecuado es multiplicar por -1, para convertirlas. 

Antes de la dualidad

Antes de proceder con un ejercicio de dualidad es necesario que las variables de decisión sean igual  mayor que cero, de no ser asi necesitan ser transformadas de forma canonical.

En Python podemos trabajar los problemas de programación lineal con Ipsolve.

Por ultimo, decir que la programación lineal, se basa en la creación de modelos cuando el problema que necesitamos resolver tiene solo funciones lineales, esto es :

Tenemos variables de decisión conocidas y queremos saber que influyen en un problema dado.

Dicho de otro modo: el concepto programación lineal  no se enmarca dentro de la programación de computadoras, sino que se refiere a escoger una vía de solución cuando el modelo matemático del problema contiene solo funciones lineales

Este articulo, pretende solo ser un esbozo de los conceptos más básicos de la solución a problemas de programación lineal.

Espero modestamente que este artículo, sirva de ayuda a alguien.

Gracias

«… y yo tenia respuesta a todas sus preguntas, incluso a las que aún no se ha hecho.»

Y

TypeError: argument of type ‘NoneType’ is not iterable. Python

logo python

Este error que Python lanza, obedece, según mi experiencia, a casos en que una función con una declaración  condicional (if, else, case, etc) no devuelve un resultado o lo  devuelve vacío.

Si esto sucede, Python devuelve un valor por defecto que es None, el cual no es iterable, por tanto en la próxima iteración lanzara un error.

La solución a esto, es detener la iteración en casos donde pueda haber un valor vacío (por ejemplo utilizando break), o añadiendo acciones (por ejemplo con while), de modo que se solucione o detenga la iteración.

«Puedo absorber tus pecados, pero no vivir tu vida.»

Y

Espero modestamente que este artículo, sirva de ayuda a alguien.

Gracias

Open.Abrir archivos en Python

logo python

Para abrir documentos en Python tenemos diferentes formas, la más común es open(), intentaré explicar en este post, su uso. 

Python nos ofrece open(), que es una función que devuelve un objeto del tipo file.

La sintaxis de la función open() es:

open(file, mode)

El parámetro file, ofrece la ubicación del archivo que intentamos abrir, ya sea una url o una uri.

mode nos permite definir que haremos con ese objeto.

'r'    Read: nos permite leer el documento. Viene dado como parámetro por defecto, abre el file o nos lanza un error si este no existe

'a'   Append: Abre el archivo para añadirlo y lo crea si este no existe.

'w'  Write: Abre el archivo para escribir sobre el, y al igual que a crea el archivo si este no existe.

'x'   Create: Crea el archivo indicado y devolverá un error si este no existe.

't'   Text: nos permite indicar que usaremos el archivo en modo texto, y es el valor por defecto de la función.

'b'   Binary: Nos permite manejar el archivo en modo binario, por ejemplo para trabajar con imágenes.

El formato más común de apertura utilizando open() es:

variable = open('archivo_prueba.txt')

Como los valores 'r' y 't' del parámetro mode, están establecidos por defecto, el ejemplo anterior, sería lo mismo que escribir:

variable = open('archivo_prueba.txt', 'rt')

Si pudiera detenerme a ver pasar el tiempo,… pues no sabría que hacer con el

Y

Usando hashlib en Python

logo python

Python nos ofrece multiples librerías con valor incalculable para todo el tema de criptografía, una de ellas la librería hashlib, que nos va a permitir trabajar con un tipo de encriptado conocido como SHA

Su nombre proviene del inglés, ( Secure Hash Algorithms ), y su labor consiste en crear estructuras seguras, mediante funciones de encriptado, que puedan ser utilizados por diferentes lenguajes de modo transversal.

Los algoritmos o funciones SHA con que trabaja haslib, son varios(‘sha256', 'sha384', 'sha224', 'sha512', 'sha1'), con diferentes tamaños de bloque

hashlib, posee dos funciones asociadas, que usaremos al aplicar las transformaciones:

  • encode() : Convierte las cadenas en bytes, para que la funcion hash pueda procesarla.
  • hexdigest() : Devuelve el dato codificado en formato hexadecimal.

Haremos una pequeña demostración de su uso:

Introduciremos un cadena  y la convertiremos a su equivalencia en bytes utilizando la funcion enconde(),  para que la funcion SHA  pueda manipularla, esta la codifica con hexdigest(), e imprimimos la cadena resultante

import hashlib 
import hashlib 
   
 # valor de entrada 
 str = "el comienzo de todo"
   
 result = hashlib.sha256(str.encode()) 
  
 # Imprimiendo el valor hexadecimal. 
 print("El resultado es: ") 
 print(result.hexdigest()) 
 print ("\r") 
  
 # salida: El resultado es: 
 9f78aef8f9e252913e43156c570568592f014cb0175d52a6071a5eed8959e183
    
   
 # valor de entrada 
 str = " el comienzo de todo "
  
 result = hashlib.MD5(str.encode()) 
   
 # Imprimiendo el valor hexadecimal. 
 print("El resultado es: ") 
 print(result.hexdigest())
 # salida: El resultado es: 3455ed58e2999e23fc7385207e4fb999 

Y listo esto es todo.

Espero modestamente que este artículo, sirva de ayuda a alguien.

Gracias.

…. hay que levantarse cada mañana con una esperanza y dormirse cada noche con una meta….

Diferencias entre apply, map y applymap

logo python

El uso de estas funciones, para multiples labores en Python, nos permiten obtener resultados de un modo que nos arreglan bastante la vida.

Muchas de estas veces nos apoyamos para ello en funciones lambda, por su simplicidad, veamos un poco, de que hablo.

Funciones lambda

Otro modo de aplicar redondeo es utilizar una función  lambda en un array de una dimensión, o sea para una columna o fila.

Las funciones lambdas, son una poderosa herramienta de Python, que nos permite escribir un tipo de función, que se ejecuta en un línea.

Hablo un poco sobre la funciones lambda en este articulo que escribi hace un tiempo.

Apoyándonos en ellas,  podemos redondear, utilizando diferentes funciones que trabajan a partir de elementos.

Recordemos que en Python todo son objetos, las funciones map  y applymap, se  basan ambas en este concepto.

La diferencia entre ellos es que applymap es un función basada en elementos que trabaja en el dataframe, mientras map lo hace en las series, o sea una columna o una fila.

En el ejemplo verán la aplicación de map() en una columna y applymap() en todo el dataframe, en ambos casos se combina su uso con la función format, y  una función lambda para determinar los términos del redondeo.

Existe una buena explicación de la diferencia entre estas funciones en este link


Map

Applymap

Como hemos ya modificado una columna volvemos a importar nuestro dataset y aplicamos applymap()

Diferencias entre Map, applymap, y apply

map() es una función basada en elementos que solo se aplica a series, acepta dict, series o callables.

Está diseñada para mapear valores de un dominio a otro, por lo que está optimizada para el rendimiento.

Su construcción, como vimos antes es del tipo :

df['A'].map({1:'a', 2:'b', 3:'c'}))

applymap(), es una función también basada en elementos, que  solo se aplica a Dataframes, y únicamente acepta callables.

applymap() es perfecto, para transformar de elementos en varias filas / columnas, sin que sea necesario utilizar apply()

df[['A', 'B', 'C']].applymap(str.strip))

apply(), se basa también, en elementos, pero puede tener otras complejidades y su compartamiento y resultado, depende de la función.

Se aplica, tanto a series como dataframes , y solo acepta callables

Es importante saber que se usa cuando en cualquier función que no puede ser vectorizada

Otros elementos a tener en cuenta son:

map() cuando se le pasa un diccionario o serie mapeará elementos basados ​​en sus claves Los valores faltantes se registrarán como NaN en la salida.

applymap() puede funcionar un poco más rápido que apply en algunos casos.  

map() está optimizado para mapeos y transformaciones por elementos. Las operaciones que involucran diccionarios o series permitirán a  Pandas usar rutas de código más rápidas para un mejor rendimiento.

apply() devuelve un escalar para agregar operaciones, también tiene rutas rápidas cuando se llama con ciertas funciones NumPy como mean, sum, etc.

… también en el infierno llueve sobre mojado, lo se porque he pasado, más de una noche allí…

J.Sabina

Uso de issubclass()

logo python

En Python, issubclass(), es utilizado para conocer la herencia y relación que existe entre dos o mas clases.

En el ejemplo creamos una clase llamada Planeta y una subclase que lleva el nombre de Continente.

Lo que haremos luego,  es verificar la relación que existe entre ellas

«…he olvidado ya el lugar de donde vengo y puede que no exista el sitio adonde voy…..»

J.Sabina