python

Instalando tensorflow

Instalar Tensorflow para Python en Windows

En este corto artículo te explico cómo instalar el paquete Tensorflow para Windows, en su versión estable. Personalmente lo intenté instalar pero aparecía el error de:

Could not find a version that satisfies the requirement tensorflow (from versions: ) No matching distribution found for tensorflow

Así que investigando un poco di con la solución y decidí exponerla en este post para la instalación de Tensorflow en Windows.

Continue reading…

Programación con Python y bases de datos

En este post te muestro cómo conectar Python 3 a varios motores de bases de datos, por ejemplo, MySQL / MariaDB, SQLite, SQL Server, PostgreSQL y SQLite 3.

Las bases de datos son un aspecto fundamental en los sistemas de información, pues permiten guardar y leer información de cualquier tipo.

Python provee la interfaz DB API 2.0 para conectar a todas las bases de datos usando la misma API o interfaz de programación de aplicaciones.

Python y bases de datos como MongoDB, MySQL, PostgreSQL, SQL Server, SQLite | ejemplos de código

Existen muchos motores de bases de datos que pueden ser consumidos con Python.

Continue reading…

CRUD de MongoDB y Python con PyMongo

CRUD (create, read, update, delete) en Python y MongoDB

Siguiendo con la serie de tutoriales para consumir distintas bases de datos hoy veremos cómo conectarnos a una base de datos de MongoDB y hacer todas las operaciones para crear, leer, actualizar y eliminar desde Python.

CRUD de MongoDB y Python con PyMongo

CRUD de MongoDB y Python con PyMongo

El módulo que usaremos será PyMongo; el cual está disponible para instalarse por medio de Python y que nos permite conectarnos a MongoDB, obtener bases de datos, colecciones y todo lo relacionado a ello.

Al finalizar podremos gestionar una colección de productos de una tienda.

Continue reading…

Python y Codewars: baches en el camino

Introducción

Hay un ejercicio que aunque no es tan difícil sí que es entretenido. Se trata de contar los baches en un camino y diagnosticar si nuestro auto (suponiendo que tenemos uno) podrá llegar sano y salvo a casa.

El problema dice algo así:

Suponiendo que tenemos un auto y el amortiguador de éste sólo soporta pasar sobre 15 baches antes de romperse, escribir una función que reciba el camino como una cadena (ya veremos más adelante cómo es) y devuelva “Woohoo!” si llegaremos sanos a casa o “Car Dead” en caso contrario.

El camino es representado por _ o n, es decir, guiones bajos y letras ene. Si es un guión bajo entonces el camino está “plano” pero si encontramos una n significa que hay un bache.

Un ejemplo del camino podría ser: __n__ en donde hay 1 bache. En cambio, este: ___nn_nnn_n_n tiene 7 baches y este: _________ no tiene baches.

Solución

Muy fácil, contamos cuántas veces aparece n dentro de la cadena que recibimos. Si el conteo es menor o igual a 15, regresamos “Woohoo!” y en caso de que no, “Car Dead”. Así:

def bumps(road):
    return "Woohoo!" if road.count("n") <= 15 else "Car Dead"

Está un poco resumido, pero podría expandirse así:

def bumps(road):
    conteo = road.count("n")
    if conteo <= 15:
        return "Woohoo!"
    else:
        return "Car Dead"

Y para probar podemos hacer esto:

print(bumps("___n_n_n______________n"))# Woohoo!, pues sólo hay 4
print(bumps("n__nnnn__nn___nnnnnnnnnn________"))# Car Dead, porque hay 17
print(bumps("____nnnn___________nnnnn_______n_n_n_n_"))# Wohoo! porque hay 13

Con estos resultados:

Fue un ejercicio que me gustó mucho.

Api de binbox.io en Python

Introducción

Binbox es un servicio que permite acortar links y crear pastes, ambas cosas generan dinero para el usuario final. Desde hace mucho he querido usar su API pero no entendía nada de REST, ni de las peticiones POST, GET, etcétera.

Así que lo olvidé por unos meses o años, y ayer recordé que nunca pude hacerlo. Lo intenté de nuevo y ahora sí pude hacerlo. Además, lo implementé en Python, ya que hacerlo en Javascript es muy fácil (ellos proveen la librería y las capas de abstracción superiores).

Creando pastes

Lo que me pareció más difícil es que (y no sé la razón) los datos se deben encriptar usando la librería sjcl. Eso es fácil si estás en javascript, ¿pero y en Python? así que me puse a investigar y al final encontré una que tenía un error, el cual solucioné aquí.

Una vez teniendo la librería, tuve que decodificar los datos. Ya que la librería los devolvía con una b al inicio. Es decir, eran bytes. Por lo que regresaba algo como b’hola mundo’ en lugar de un simple ‘hola mundo’. Para solucionarlo, decodifiqué cada cosa codificada: el vector, el texto cifrado y la sal

        texto_encriptado = SJCL().encrypt(texto, sal)
        texto_encriptado['ct'] = texto_encriptado['ct'].decode('utf-8')
        texto_encriptado['iv'] = texto_encriptado['iv'].decode('utf-8')
        texto_encriptado['salt'] = texto_encriptado['salt'].decode('utf-8')

Una vez hecho eso, me enfrenté a que el objeto JSON no debería tener espacios en blanco, y debía usar comillas dobles ” en lugar de comillas simples ‘. Para ello modifiqué los separadores y los mandé como argumento a json.dumps, quedando así:

texto_encriptado_como_json = json.dumps(texto_encriptado, separators=(',', ':'))

Ahora, para terminar, tenía que codificar los datos en base64:

texto_como_json_codificado = b64encode(texto_encriptado_como_json.encode('utf-8'))

Debido a que base64 devuelve un objeto codificado, tuve que, de nuevo, decodificarlo para remover la b al inicio:

texto_base64_decodificado = texto_como_json_codificado.decode('utf-8')

Y ahora sí pude hacer la petición:

        datos = {
            'data': texto_base64_decodificado,
            'title': titulo,
        }
        peticion = requests.post(self.url_api, data = datos)

Creando links

Para crear links no encontré ningún problema, ya que los datos se mandan en texto plano.

Código

Finalmente para ahorrar dolores de cabeza a alguien que quiera usar la api desde Python, hice una pequeña clase que puede crear pastes y links acortados.

Es fácil de usar. Simplemente creas una instancia con tu nombre de usuario. Luego, puedes llamar a crear_paste o acortar_link. Ambos métodos devolverán el link del paste junto con la clave de acceso y el link acortado respectivamente.

Implementación

Para probar el código, podemos usar esto:

""" Ejemplos """
binbox = BB("parzibyte")
link_paste = binbox.crear_paste("Paste desde parzibyte.me!", "Hola. Este es un paste que fue creado en parzibyte.me/blog :)")
link_acortado = binbox.acortar_link("https://parzibyte.me/", "Link acortado desde parzibyte.me")
print("El link del paste: {}".format(link_paste))
print("El link acortado: {}".format(link_acortado))

Aquí la captura:

Si visito el link del paste, efectivamente sale el texto que mandé desde Python:

Con el link acortado pasa lo mismo:

Y así fue como pude implementar la api de binbox.io en Python, sin muchas complicaciones más que las que ofrece la librería sjcl.

Remover primer y último carácter en Python

Comenzaré a publicar algunas soluciones a algunos sencillos katas de codewars.com. En este caso, el objetivo es, dada una cadena, devolverla pero sin el primer y último carácter. La solución (claro que hay otras y mejores) es la siguiente:

def remove_char(s):
    return s[ 1:len(s) - 1]

Simplemente estamos cortando la cadena desde el 1 hasta n-1, en donde n es la longitud de la cadena. Le restamos uno a dicha longitud porque recordemos que los índices comienzan en 0, por lo que si nuestra cadena es hola, su longitud es 4 pero la última letra tiene el índice 3.

La mejor solución por votos, es esta:

def remove_char(s):
    return s[1 : -1]

 

Python 3 y SQLite 3 – Introducción y ejemplos

Introducción

En esta entrada veremos cómo crear, leer, actualizar y eliminar registros en SQLite3 usando Python 3. Es decir, haremos un CRUD con SQLite. Para ello lo único que necesitamos es instalar Python. La librería que permite gestionar la base de datos ya viene incluida.

Te invito a leer el tutorial de PHP con PDO y SQLite3 para crear CRUD

Nota: si quieres ver el código completo ve a GitHub. También he creado otros tutoriales para conectar Python con SQL Server, PostgreSQL y MySQL.

Continue reading…

Pequeña shell interactiva para sqlite3 en Python

Ayer estaba haciendo unas pruebas con sqlite3 y python, pero tenía que escribir cada sentencia, guardar el archivo y ejecutarlo… cosa que se me hizo muy tardada.

Así que decidí hacer un pequeño script interactivo muy simple pero que permite ejecutar cualquier cosa y abrir cualquier base de datos. El código se explica por sí mismo.

"""
	Abre una base de datos de sqlite3 e interactúa con ella.
	Útil para hacer pruebas

	@author parzibyte
"""
import sqlite3
while True:
	try:
		"""
			Tratar de abrir la base de datos e imprimir
			cualquier error que pase al hacerlo
			Comprobar también si el usuario quiere salir completamente
			del programa
		"""
		nombre_base_de_datos = input("Escribe el nombre de la base de datos: [-1 para salir]\t")
		if nombre_base_de_datos == "-1":
			break
		conexion = sqlite3.connect(nombre_base_de_datos)
		cursor = conexion.cursor()
		print("Base de datos abierta!")
		while True:

			"""
				Leer la entrada del usuario y salir si así lo desea.
				Si no, ejecutar la consulta, mostrar los resultados
				y si hay algún error imprimirlo
			"""
			try:
				sentencia = input("Escribe la consulta que deseas ejecutar: [-1 para cambiar la base de datos]\n\t")
				if sentencia == "-1":
					break
				resultado = cursor.execute(sentencia)
				datos = cursor.fetchall()
				conexion.commit()
				print("Los datos que trajo la consulta son: ")
				for dato in datos:
					print(dato)
			except sqlite3.OperationalError as error:
				print("Error al ejecutar la consulta: ", error)
	except sqlite3.OperationalError as error:
		print("Error al abrir la base de datos: ", error)

Aquí pongo unas pequeñas capturas de cómo se ve:

Finalmente tengo mencionar dos cosas importantes:

  • Está escrito para Python 3, y no creo que funcione en otras versiones, aunque sólo se tendrían que hacer unas pequeñas modificaciones
  • Está abierto a inyecciones de SQL ya que no usa sentencias preparadas. ¿Por qué? porque se supone que es para pruebas, es como interactuar con sqlite directamente

Aquí algunos enlaces

Documentación de sqlite3 para Python

Sitio oficial de SQLite