Saltar al contenido

Cómo proteger tu servidor contra la vulnerabilidad SSLv3 de POODLE

marzo 4, 2020

 

Introducción

Pruebas de datos existe en muchas formas diferentes, desde el periodismo a los medios sociales a los correos electrónicos. Cuando analizar y visualizar datos de texto podemos traer a la luz las tendencias generales que pueden cambiar la forma en que interpretamos el texto.

En este tutorial, vamos a explorar gráfica de frecuencia de la palabra en un corpus de texto. El programa que vamos a crear va a buscar a través de un documento de texto sin formato y organizar cada palabra única con su frecuencia. a continuación, vamos a representar gráficamente los datos que encontramos usando matplotlib.

Requisitos previos

Para poder utilizar este tutorial, asegúrese de que tiene los siguientes requisitos previos:

  • Debe tener Python 3 y un entorno de programación ya instalado en su ordenador o servidor local.
  • Para obtener el máximo provecho de esta guía, usted debe estar familiarizado con Python 3 y sobre el tipo de datos de diccionario en particular.

Debe tener Python 3 y un entorno de programación ya instalado en su ordenador o servidor local.

Para obtener el máximo provecho de esta guía, usted debe estar familiarizado con Python 3 y sobre el tipo de datos de diccionario en particular.

Por último, asegúrese de que siga el Paso 1 – importación matplotlib de nuestra Cómo trazar datos en Python 3 Uso matplotlib ya que es imprescindible tener instalado matplotlib para este proyecto.

Paso 1 – Configuración del archivo de programa

Ahora que hemos instalado en nuestro ordenador matplotlib, podemos empezar a crear nuestro proyecto.

Con un editor de texto de su elección, crear un nuevo archivo de Python y lo llaman word_freq.py. Este será nuestro archivo principal.

En este programa, nos importará matplotlib y la clase que necesitamos (que es pyplot), pasándole el alias PLT. Esto declara esencialmente PLT como una variable global que se utilizará a lo largo de nuestro script.

import matplotlib.pyplot as plt

A continuación, vamos a importar algunos paquetes predeterminados en Python. Estos serán utilizados para establecer y disfrutar de las entradas de línea de comandos. El paquete importante a destacar es argparse. Esto es lo que vamos a utilizar para captar información de la línea de comandos e incluir el texto de ayuda para el usuario. importación de

dejar que los siguientes paquetes predeterminados en Python:

import matplotlib.pyplot as plt
import sys
import operator
import argparse

Por último, cree el principal método estándar y llamada. Dentro del método principal es donde vamos a escribir la mayor parte de nuestro código.

import matplotlib.pyplot as plt
import sys
import operator
import argparse

def main():

if __name__ == "__main__":
main()

Ahora que hemos importado todo y establecimos el esqueleto de nuestro proyecto, podemos pasar a usar los paquetes que hemos importado.

Paso 2 – Configuración del Analizador Argumento

Para esta parte, vamos a crear los argumentos de línea de comandos y almacenarlos en una variable para un acceso rápido.

En nuestro método principal, vamos a crear nuestra variable analizador y lo asignan a los valores predeterminados argparse constructor ofrece. A continuación, vamos a asignar el argumento esperado para la palabra vamos a estar buscando en el archivo. Por último, vamos a asignar el argumento esperado para el archivo en el que la palabra está contenida en. Este será un archivo .txt.

...
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
"word",
help="the word to be searched for in the text file."
)
parser.add_argument(
"filename",
help="the path to the text file to be searched through"
)

if __name__ == "__main__":
main()

Por ahora, el primer argumento en el método es el título de lo que esperamos en la línea de comandos. El segundo argumento ayuda = «…» se utiliza para proporcionar al usuario información sobre lo que debe ser el argumento de línea de comandos.

A continuación, vamos a guardar los argumentos dados en otra variable que llamaremos args.

...
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
"word",
help="the word to be searched for in the text file."
)
parser.add_argument(
"filename",
help="the path to the text file to be searched through"
)

args = parser.parse_args()

if __name__ == "__main__":
main()

Por si fuera poco, siempre debe comprobar nuestras entradas en caso de que haya un error en los argumentos de línea de comandos. Esto es también para evitar que el script falle bruscamente. Permiten, por tanto, de controlar los errores mediante el uso de una sentencia try.

...
def main():
...
args = parser.parser_args()

try:
open(args.filename)

except FileNotFoundError:
sys.stderr.write("Error: " + args.filename + " does not exist!")
sys.exit(1)

if __name__ == "__main__":
main()

Estamos utilizando sys.exit (1) para indicar al usuario que hay un problema con el código y no pudo completar con éxito.

Nuestro proyecto ahora será capaz de tomar argumentos de línea de comandos. El siguiente paso es analizar nuestro archivo de entrada.

Paso 3 – analizar el archivo

En este paso, se va a tomar en un archivo, leer cada palabra, registrando la frecuencia con que aparecen, y el ahorro de todo a un diccionario de tipo de datos.

Vamos a crear una función llamada word_freq () que toma dos argumentos de línea de comandos (la palabra y el nombre de archivo) y, a continuación, llamar a esa función en main ().

...
def main():
...
word_freq(args.word, args.filename)

def word_freq(word, filename):

if __name__ == "__main__":
main()

El primer paso para analizar el archivo es crear un tipo de datos de diccionario que llamaremos doc. Esto mantendrá cada palabra que se encuentra en el archivo y realizar un seguimiento del número de veces que ha aparecido.

...
def word_freq( word, filename ):
doc = {}

if __name__ == "__main__":
main()

El siguiente paso sería iterar a través del archivo dado. Esto se hace usando un anidada para el bucle.

El primer bucle está diseñado para abrir el archivo y tomar la primera línea de la misma. A continuación, toma lo que está en cada línea y la divide basa en una cadena de un carácter de espacio en blanco entre las palabras, mientras que el almacenamiento de las palabras en una matriz.

El segundo bucle for toma esta matriz, y los bucles a través de él comprobar si es o bien en el diccionario o no. Si es así, le sumamos un cargo a la misma. Si no es así, entonces se crea una nueva entrada e inicializar como 1.

...
def word_freq(word, filename):
doc = {}

for line in open(filename):
split = line.split(' ')
for entry in split:
if (doc.__contains__(entry)):
doc[entry] = int(doc.get(entry)) + 1
else:
doc[entry] = 1

if __name__ == "__main__":
main()

Ahora estamos a mitad de camino a través con el proyecto.

En resumen, nuestro método main () debe establecer nuestras entradas de línea de comandos y pasarlos a la función word_freq (). word_freq () debería tomar la palabra y el nombre de la línea de comandos y guardar cada palabra única que se encuentra en el archivo de texto.

A continuación, vamos a tomar estos datos y organizarlo para su uso en nuestro gráfico.

Paso 4 – Almacenamiento y ordenar datos

Antes de hacer el gráfico, hay que asegurarse de que la palabra es en realidad en el archivo abrimos. Podemos hacer esto con una declaración condicional si.

...
def word_freq(word, filename):
...
else:
doc[entry] = 1
if (not word in doc):
sys.stderr.write("Error: " + word + " does not appear in " + filename)
sys.exit(1)

if __name__ == "__main__":
main()

Ahora que sabemos que la palabra está en el archivo, podemos empezar a configurar los datos para nuestro gráfico.

En primer lugar tenemos que comenzar con la clasificación de nuestro diccionario tipo de datos de mayor a menos de ocurrencia y la inicialización de las variables para su uso posterior. Tenemos que ordenar nuestro diccionario de modo que se visualiza adecuadamente en el gráfico.

...
def word_freq(word, filename):
...
if (not word in doc):
sys.stderr.write("Error: " + word + " does not appear in " + filename)
sys.exit(1)

sorted_doc = (sorted(doc.items(), key = operator.itemgetter(1)))[::-1]
just_the_occur = []
just_the_rank = []
word_rank = 0
word_frequency = 0

if __name__ == "__main__":
main()

las dos variables para tomar nota Se just_the_occur que son los datos que contendrán cuántas veces ha aparecido una palabra. La otra variable es just_the_rank que es la variable que contendrá los datos relativos a la categoría de la palabra.

Ahora que tenemos el diccionario ordenada, vamos a recorrer para encontrar tanto nuestra palabra y su rango, así como rellenar nuestro gráfico con estos datos.

...
def word_freq( word, filename ):
...

sortedDoc = (sorted(doc.items(), key = operator.itemgetter(1)))[::-1]
just_the_occur = []
just_the_rank = []
word_rank = 0
word_frequency = 0

entry_num = 1
for entry in sorted_doc:
if (entry[0] == word):
word_rank = entryNum
word_frequency = entry[1]

just_the_rank.append(entry_num)
entry_num += 1
just_the_occur.append(entry[1])

if __name__ == "__main__":
main()

Aquí tenemos para asegurarse de que ambas variables just_the_occur y just_the_rank tienen la misma longitud de otro modo matplotlib no vamos a crear el gráfico.

también hemos añadido una sentencia if en el bucle de encontrar nuestra palabra (que ya sabemos que está allí) y tire de su rango y frecuencia.

Ahora tenemos todo lo que necesitamos para crear nuestro gráfico. Nuestro siguiente paso es crear finalmente.

Paso 5 – Crear el gráfico

En este punto se puede conectar en la variable PLT que hemos creado en el principio. Para crear nuestro gráfico, necesitamos un título, etiqueta de eje, etiqueta del eje x, una escala, y un tipo de gráfico.

En nuestro caso, será la creación de un registro de base 10 gráfico para organizar nuestros datos. Las etiquetas de título y ejes pueden ser cualquier cosa que usted quiere que sea, pero el más descriptivo sea el mejor será para las personas que están buscando en su gráfico.

...
def word_freq( word, filename ):
...
just_the_rank.append(entry_num)
entry_num += 1
just_the_occur.append(entry[1])

plt.title("Word Frequencies in " + filename)
plt.ylabel("Total Number of Occurrences")
plt.xlabel("Rank of word("" + word + """" is rank "" + str(word_rank) + "")"")

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *