Google+ Seguidores

viernes, 12 de octubre de 2018

Manipulación de archivos zip con Python

Introducción:

Hola amigos de Internet, les doy la bienvenida a Mi Diario Python, el mejor blog para Aprender Python.

En este articulo aprenderemos a utilizar el modulo zipfile para manipular y manejar archivos zip con Python.

Veremos que sera muy sencillo y muy practico. Estoy seguro de que te sera de mucha utilidad.

El zipfile esta en la librería estándar de Python, así que no necesitamos descargar ningún recurso externo.

Resultado de imagen para zip file

Creación de archivos ZIP:

Para comenzar, vamos a crear un archivo ZIP utilizando zipfile, y agregar archivos dentro del zip. Veamos como hacerlo:

# importamos zipfile
import zipfile

# Utilizamos ZipFile para crear el archivo zip
with zipfile.ZipFile('archivo_comprimido.zip', 'w') as archivo_zip:
    # Con write, agregamos archivos al archivo zip
    # Solo ingresamos la ruta del archivo que queremos ingresar
    archivo_zip.write('archivo_de_texto.txt')

Muy fácil ¿No crees?.

Ahora, veamos como podemos abrir un archivo zip y leer su contenido.

with zipfile.ZipFile('archivo_comprimido.zip', 'r') as archivo_zip:
    # Guardamos la lista de archivos en una variable
    list_files = archivo_zip.namelist()
    # Mostramos los resultados
    print(list_files)

['archivo_de_texto.txt']

Con namelist() podemos obtener los nombres de los archivos dentro del ZIP. En este caso el resultado es una lista con un solo elemento, el archivo que hemos ingresado en el primer ejemplo.

Excelente, ahora veamos como leer estos archivos comprimidos:

# Abrimos el archivo ZIP
with zipfile.ZipFile('archivo_comprimido.zip','r') as archivo_zip:
    # Abrimos el archivo de texto
    with archivo_zip.open('archivo_de_texto.txt','r') as texto:
        # Leemos el archivo
        print(texto.read())

b'Este es el texto de un archivo comprimido'

Y ese seria el contenido de "archivo_de_texto.txt".


Ahora que podemos escribir archivos ZIP, es momento de aprender a extraerlos.

# Abrimos el archivo ZIP
with zipfile.ZipFile('archivo_comprimido.zip','r') as archivo_zip:
    # Utilizamos "extractall" para extraer los archivos
    # El método toma un argumento, el cual es la contraseña
    # En mi caso, no hay contraseña. Por ende, utilizo None.
    archivo_zip.extractall(pwd=None)

Y esto es suficiente para extraer los archivo comprimidos.

¿Que opinas? ¿Alguna duda? No dudes en dejar tu comentario.

Mi nombre es Luis, y fue un placer compartir mis conocimientos con todos ustedes :D.
Seguir Leyendo

lunes, 8 de octubre de 2018

Renderizar plantillas en Flask

Introducción:

Hola amigos de Internet, les doy la bienvenida a Mi Diario Python, el mejor blog para Aprender Python.

Como se que hoy en día las aplicaciones web tienen mucha demanda, quiero aumentar el numero de artículos sobre el tema de aplicaciones web con Python. 

En este articulo,  aprenderemos a renderizar y utilizar plantillas en Flask. Lo cual nos permite mostrar un cuerpo HTML que se encuentre en un archivo externo al del script Python.

Resultado de imagen para flask python html

Como veremos, sera de una manera muy sencilla.

Plantillas:

En Flask, podemos hacer lo siguiente para mostrar un encabezado simple:

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hola_mundo():
 return '<h1>Hola Mundo</h1>'

app.run()

Resultado:


El problema en utilizar etiquetas HTM de esta manera, es que es muy engorroso. Para ello Falsk configura el motor de plantilla Jinja2 automáticamente

Para renderizar plantillas, utilizaremos el método render_template() el cual recibe como argumento el nombre de la plantilla. Veamos un ejemplo:

Lo primero que haremos sera ordenar nuestros archivos. Crearemos una carpeta templates en la cual colocaremos todas las plantillas que queramos utilizar. En mi caso solo creare un archivo HTML (index.html).

Mis archivos han quedado así:

/app_flask_templates.py
/templates
    /index.html

Lo siguiente que haremos sera escribir nuestra plantilla. Yo haré una muy simple:

<!DOCTYPE html>
<html>
<head>
 <title>Usando Plantillas en Flask</title>
</head>
<body>

 <strong>
  Hola Internet!!!
 </strong>

</body>
</html>


Ahora vamos a escribir el código en nuestro archivo app_flask_templates.py, para poder renderizar esta plantilla:

# Importamos "render_template"
from flask import Flask, render_template

# Creamos la instancia de Flask
app = Flask(__name__)

# Definemos el route
@app.route("/")
def render():
 # Retornamos la plantilla "index.html"
 return render_template("index.html")

# Iniciamos la aplicación
app.run()

Muy bien, excelente, ha quedado genial. Muy fácil ¿No crees?.

En muchas ocasiones tendremos que enviar datos a través de la URL de la pagina, las palabras claves, o parámetros. Estos podemos recibirlos y tratarlos en nuestras platillas de la siguiente manera:

Todo lo que tenemos que hacer es darle un segundo argumento al método render_template(). Veamos un ejemplo:

# Importamos "render_template"
from flask import Flask, render_template

# Creamos la instancia de Flask
app = Flask(__name__)

# Definemos el route
@app.route("/")
# Un segundo route con el nombre del parametro
@app.route('/<nombre>')
def render(nombre=None): # Inicializamos "nombre"
 # Retornamos la plantilla "index.html"
 # Le pasamo el parametro a el método render_template
 return render_template("index.html", nombre=nombre)

# Iniciamos la aplicación
app.run()



Perfecto, nos ha salido muy bien.

¿Que opinas? ¿Alguna duda? No dudes en dejar tu comentario.

Mi nombre es Luis, y fue un placer compartir mis conocimientos con todos ustedes :D.
Seguir Leyendo

sábado, 6 de octubre de 2018

Analizador de Texto - Programas Python

Introducción:


Hola amigos de Internet, les doy la bienvenida a Mi Diario Python, el mejor blog para Aprender Python.

En este articulo realizaremos un programa para analizar texto. El objetivo de este articulo es fortalecer nuestros conocimientos de programación y ejercitar nuestra lógica. ¿Que opinas?

Imagen relacionada

Analizador de Texto con Python:

El proyecto consiste en lo siguiente: un analizador de archivos que analiza el texto y que nos permitirán saber que porcentaje de texto ocupa cada carácter.

Comencemos por el principio. Escribiremos una función para poder abrir los archivos de texto.

def open_file(name):
    # Abrimos el archivo con 'open'
    with open(name) as archivo:
        # Leemos el archivo y hacemos que la función lo retorne
        return archivo.read()

# Probamos la función
open_file('archivo.txt')

'Hola Amigos'

Muy bien, excelente. Ahora que podemos abrir los archivos y leer su contenido, podemos empezar con el análisis:

Como mencionamos anteriormente, queremos que el analizador nos diga el porcentaje de texto que ocupa un carácter determinado.

Para ello necesitamos saber cuantas veces aparece un carácter. Para ello escribiremos la siguiente función:

def count_char(texto, caracter):
    # Inicializamos el contador (resultado final)
    count = 0
    
    # Recorremos todo el texto
    for a in texto:
        # en cada iteración comprobamos los caracteres
        if a == caracter:
            # Si hay coincidencia, el contador aumenta
            count = count + 1
    return count

# Probamos la función
texto = open_file("archivo.txt")

# Saber cuantas veces se repita el caracter 'o'
print(count_char(texto, 'o'))

2

Excelente, muy bien, lo hemos hecho bien hasta ahora. 

Ahora nos queda un ultimo paso, saber cuanto es el porcentaje en el que el carácter ocupa en el texto:

def porcentaje_char(texto):
    # Creamos una lista con todo el abecedario
    abc = 'abcdefghijklmnñopqrstuvwxyz'
    # Recorremos la lista "abc"
    for a in abc:
        # Calculamos el pocentaje
        porcentaje = 100 * count_char(texto,a) / len(texto)
        # Formula = 100 * num_char_in_text / len_text
        
        # Mostramos los resultados
        print("{0}-{1}%".format(a,round(porcentaje, 2)))

# Probamos la función
texto = open_file('archivo.txt')        
porcentaje_char(texto)

a-9.03%
b-4.52%
c-3.23%
d-8.39%
e-0.65%
f-3.87%
g-0.0%
h-1.94%
i-3.87%
j-3.23%
k-3.87%
l-3.23%
m-3.23%
n-12.26%
ñ-0.0%
o-6.45%
p-1.29%
q-0.0%
r-1.29%
s-9.68%
t-1.94%
u-3.23%
v-5.81%
w-0.0%
x-0.0%
y-1.29%
z-0.0%

Muy bien, perfecto. He cambiado el contenido de mi archivo de "Hola amigo", a una serie de caracteres. Por ello vemos que la "n" es la predominante en este nuevo texto.

Lo que haremos ahora sera reunir todas estas funciones en un archivo, para crear un software funcional:

# Analizador de texto

def open_file(name):
    # Abrimos el archivo con 'open'
    with open(name) as archivo:
        # Leemos el archivo y hacemos que la función lo retorne
        return archivo.read()
    
def count_char(texto, caracter):
    # Inicializamos el contador (resultado final)
    count = 0
    
    # Recorremos todo el texto
    for a in texto:
        # en cada iteración comprobamos los caracteres
        if a == caracter:
            # Si hay coincidencia, el contador aumenta
            count = count + 1
    return count

def porcentaje_char(texto):
    # Creamos una lista con todo el abecedario
    abc = 'abcdefghijklmnñopqrstuvwxyz'
    # Recorremos la lista "abc"
    for a in abc:
        # Calculamos el pocentaje
        porcentaje = 100 * count_char(texto,a) / len(texto)
        # Formula = 100 * num_char_in_text / len_text
        
        # Mostramos los resultados
        print("{0}-{1}%".format(a,round(porcentaje, 2)))
        
archivo = input("Introduzca la ruta del archivo: ")
resultado = porcentaje_char(archivo)

print(resultado)

Introduzca la ruta del archivo: archivo.txt
a-9.03%
b-4.52%
c-3.23%
d-8.39%
e-0.65%
f-3.87%
g-0.0%
h-1.94%
i-3.87%
j-3.23%
k-3.87%
l-3.23%
m-3.23%
n-12.26%
ñ-0.0%
o-6.45%
p-1.29%
q-0.0%
r-1.29%
s-9.68%
t-1.94%
u-3.23%
v-5.81%
w-0.0%
x-0.0%
y-1.29%
z-0.0%

Muy bien. ¿Que opinas? 

Puedes descargar el código del programa, ingresando al siguiente enlace:https://gist.github.com/LuisAlejandroSalcedo/e51e769a6e075ff8b3f9c8f847ff0f13.

¿Alguna duda? No dudes en dejar tu comentario.

Mi nombre es Luis, y fue un placer compartir mis conocimientos con todos ustedes :D.
Seguir Leyendo

jueves, 27 de septiembre de 2018

Gráficos Interactivos con Bokeh

Introducción:

Hola amigos de Internet, bienvenidos a Mi Diario Python, el mejor blog para Aprender Python.

En este articulo le daremos un vistazo a Boken, una librería que nos permite graficar datos de manera muy interactivo.

Y al final, veremos como generar una tabla periódica con Bokeh.

Así que prepárate, sírvete una taza de café, y comencemos.

Instalación de Bokeh:

Antes de graficar nuestros datos, necesitamos instalar Bokeh. Esto lo podemos hacer de manera muy fácil a través de pip:

pip install bokeh

Y listo, ya podremos empezar con la acción.

Ejemplos con Bokeh:

Realicemos un ejemplo sencillo. Hagamos la gráfica de linea:

from bokeh.plotting import figure, output_file, show

# Preparamos los datos
x = [1, 2, 3, 4, 5]
y = [6, 7, 2, 4, 5]

# Salida estática HTML
output_file("lines.html")

# Creamos un nuevo gráfico con un titulo y dos ejes (x e y)
p = figure(title="simple line example", x_axis_label='x', y_axis_label='y')

# Agregamos la linea con los datos
p.line(x, y, legend="Temp.", line_width=2)

# Mostramos el resultado
show(p)


Muy bien, como pueden observar el resultado es un cuerpo HTML el cual podemos mover e interactuar con el.

Realicemos otro ejemplo, esta vez con más lineas:

from bokeh.plotting import figure, output_file, show

# Preparamos los datos
x = [0.1, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0]
y0 = [i**2 for i in x]
y1 = [10**i for i in x]
y2 = [10**(i**2) for i in x]

# Salida de un HTML 
output_file("log_lines.html")

# Creamos un nuevo gráfico
p = figure(
   tools="pan,box_zoom,reset,save",
   y_axis_type="log", y_range=[0.001, 10**11], title="log axis example",
   x_axis_label='sections', y_axis_label='particles'
)

# Agregamos las lineas, la cuales representaran a los datos
p.line(x, x, legend="y=x")
p.circle(x, x, legend="y=x", fill_color="white", size=8)
p.line(x, y0, legend="y=x^2", line_width=3)
p.line(x, y1, legend="y=10^x", line_color="red")
p.circle(x, y1, legend="y=10^x", fill_color="red", line_color="red", size=6)
p.line(x, y2, legend="y=10^x^2", line_color="orange", line_dash="4 4")

# Mostramos el resultado
show(p)


Como pueden observar, en este ejemplo utilizamos, ademas de "line", el método "circle" para que los datos sean representados con círculos, ademas de lineas.

Se ve bien ¿No lo crees? Pero creo que le falta un poco de color. 

Hago un ejemplo para ver como graficar datos coloridos.

import numpy as np

from bokeh.plotting import figure, output_file, show

# Preparamos los datos
N = 4000
x = np.random.random(size=N) * 100
y = np.random.random(size=N) * 100
radii = np.random.random(size=N) * 1.5
colors = [
    "#%02x%02x%02x" % (int(r), int(g), 150) for r, g in zip(50+2*x, 30+2*y)
]

# Salida de un archivo HTML
output_file("color_scatter.html", title="color_scatter.py example", mode="cdn")
# Herramientas que podremos ver en el lado derecho del gráfico)
TOOLS = "crosshair,pan,wheel_zoom,box_zoom,reset,box_select,lasso_select"

# Creamos un nuevo gráfico con las herramientas
p = figure(tools=TOOLS, x_range=(0, 100), y_range=(0, 100))

# Agregamos el circulo con colores y tamaño vectorizado
p.circle(x, y, radius=radii, fill_color=colors, fill_alpha=0.6, line_color=None)

# Mostramos los resultados
show(p)


Excelente, mucho mejor.

En muchas ocasiones se nos presentara la situación en la que tendremos que presentar más de un gráfico. Para ello vamos a utilizar el método ""ColumnDataSource", el cual nos permitirá colocar más de un gráfico en una columna. Veamos como se hace:

import numpy as np
from bokeh.plotting import *
from bokeh.models import ColumnDataSource

# Preparamos los datos
N = 300
x = np.linspace(0, 4*np.pi, N)
y0 = np.sin(x)
y1 = np.cos(x)

# Salida de una archivo HTML
output_file("linked_brushing.html")

# Creamos las columnas para compartir varios gráficos
source = ColumnDataSource(data=dict(x=x, y0=y0, y1=y1))

TOOLS = "pan,wheel_zoom,box_zoom,reset,save,box_select,lasso_select"

# Creamos el primer gráfico
left = figure(tools=TOOLS, width=350, height=350, title=None)
left.circle('x', 'y0', source=source)

# Creamos el segundo gráfico
right = figure(tools=TOOLS, width=350, height=350, title=None)
right.circle('x', 'y1', source=source)

# colocamos los sub-gráficos con gridplot
p = gridplot([[left, right]])

# Mostramos el resultado
show(p)


Muy bien, perfecto, quedo genial.

Te recomiendo ir a la pagina de Bokeh pra que te vuelvas todo un experto: https://bokeh.pydata.org.

Generando una Tabla Periódica con Bokeh:

Para terminar este articulo, he escogido uno de los mejores ejemplo. Vamos a generar una tabla periódica con Boken. Veres que es muy sencillo:

from bokeh.io import output_file, show
from bokeh.plotting import figure
from bokeh.sampledata.periodic_table import elements
from bokeh.transform import dodge, factor_cmap

output_file("periodic.html")

periods = ["I", "II", "III", "IV", "V", "VI", "VII"]
groups = [str(x) for x in range(1, 19)]

df = elements.copy()
df["atomic mass"] = df["atomic mass"].astype(str)
df["group"] = df["group"].astype(str)
df["period"] = [periods[x-1] for x in df.period]
df = df[df.group != "-"]
df = df[df.symbol != "Lr"]
df = df[df.symbol != "Lu"]

cmap = {
    "alkali metal"         : "#a6cee3",
    "alkaline earth metal" : "#1f78b4",
    "metal"                : "#d93b43",
    "halogen"              : "#999d9a",
    "metalloid"            : "#e08d49",
    "noble gas"            : "#eaeaea",
    "nonmetal"             : "#f1d4Af",
    "transition metal"     : "#599d7A",
}

TOOLTIPS = [
    ("Name", "@name"),
    ("Atomic number", "@{atomic number}"),
    ("Atomic mass", "@{atomic mass}"),
    ("Type", "@metal"),
    ("CPK color", "$color[hex, swatch]:CPK"),
    ("Electronic configuration", "@{electronic configuration}"),
]

p = figure(title="Periodic Table (omitting LA and AC Series)", plot_width=1000, plot_height=450,
           x_range=groups, y_range=list(reversed(periods)),
           tools="hover", toolbar_location=None, tooltips=TOOLTIPS)

p.rect("group", "period", 0.95, 0.95, source=df, fill_alpha=0.6, legend="metal",
       color=factor_cmap('metal', palette=list(cmap.values()), factors=list(cmap.keys())))

text_props = {"source": df, "text_align": "left", "text_baseline": "middle"}

x = dodge("group", -0.4, range=p.x_range)

r = p.text(x=x, y="period", text="symbol", **text_props)
r.glyph.text_font_style="bold"

r = p.text(x=x, y=dodge("period", 0.3, range=p.y_range), text="atomic number", **text_props)
r.glyph.text_font_size="8pt"

r = p.text(x=x, y=dodge("period", -0.35, range=p.y_range), text="name", **text_props)
r.glyph.text_font_size="5pt"

r = p.text(x=x, y=dodge("period", -0.2, range=p.y_range), text="atomic mass", **text_props)
r.glyph.text_font_size="5pt"

p.text(x=["3", "3"], y=["VI", "VII"], text=["LA", "AC"], text_align="center", text_baseline="middle")

p.outline_line_color = None
p.grid.grid_line_color = None
p.axis.axis_line_color = None
p.axis.major_tick_line_color = None
p.axis.major_label_standoff = 0
p.legend.orientation = "horizontal"
p.legend.location ="top_center"

show(p)

Increíble, es genial.

Puedes encontrar este y otros ejemplo en la galería de Bokeh: https://bokeh.pydata.org/en/latest/docs/gallery/.


¿Alguna duda? No dudes en dejar tu comentario.

Mi nombre es Luis, y fue un placer compartir mis conocimientos con todos ustedes :D.
Seguir Leyendo
Powered by Blogger .