En un tutorial anterior, hablamos sobre las  matrices NumPy  y vimos cómo hace que el proceso de leer, analizar y realizar operaciones con datos numéricos sea un juego de niños. En este tutorial, discutiremos el método loadtxt de NumPy que se usa para analizar datos de archivos de texto y almacenarlos en una matriz NumPy n-dimensional.

Entonces podemos realizar todo tipo de operaciones en él que son posibles en una matriz NumPy.

np.loadtxt ofrece mucha flexibilidad en la forma en que leemos los datos de un archivo al especificar opciones como el tipo de datos de la matriz resultante, cómo distinguir una entrada de datos de las demás a través de delimitadores, omitir / incluir filas específicas, etc. Veremos cada una de esas formas en el siguiente tutorial.

Especificando la ruta del archivo

Veamos cómo podemos especificar la ruta del archivo desde el que queremos leer los datos.

Usaremos un archivo de texto de muestra para nuestros ejemplos de código, que enumera los pesos (en kg) y las alturas (en cm) de 100 individuos, cada uno en una fila.

Usaré varias variantes en este archivo para explicar las diferentes características de la función loadtxt.

Comencemos con la representación más simple de los datos en un archivo de texto. Tenemos 100 líneas (o filas) de datos en nuestro archivo de texto, cada una de las cuales consta de 2 números de punto flotante separados por un espacio.

El primer número en cada fila representa el peso y el segundo número representa la altura de un individuo.

Aquí hay un pequeño vistazo del archivo:

110,90 146,03
44,83 211,82
97,13 209,30
105,64 164,21

Este archivo se almacena como " weight_height_1.txt ".
Nuestra tarea es leer el archivo y analizar los datos de una manera que podamos representar en una matriz NumPy.
Importaremos el paquete NumPy y llamaremos al método loadtxt, pasando la ruta del archivo como valor al primer parámetro filePath.

1
2
3
import numpy as np
 
data = np.loadtxt("./weight_height_1.txt")

Aquí asumimos que el archivo está almacenado en la misma ubicación desde donde se ejecutará nuestro código Python ('./' representa el directorio actual). Si ese no es el caso, necesitamos especificar la ruta completa del archivo (por ejemplo: "C: //Users/John/Desktop/weight_height_1.txt")

También debemos asegurarnos de que cada fila del archivo tenga el mismo número de valores.

La extensión del archivo puede ser cualquier otra que no sea .txt siempre que el archivo contenga texto, también podemos pasar un generador en lugar de una ruta de archivo (más sobre esto más adelante)

La función devuelve una matriz NumPy n-dimensional de valores encontrados en el texto.

Aquí nuestro texto tenía 100 filas y cada fila tiene 2 valores flotantes, por lo que los datos del objeto devuelto serán una matriz NumPy de forma (100, 2) con el tipo de datos flotante.

Puede verificar esto marcando el atributo 'shape' y 'dtype' de los datos devueltos:

1
2
3
print("shape of data:",data.shape)
 
print("datatype of data:",data.dtype)

Salida:

Especificar delimitadores

Un delimitador es un carácter o una cadena de caracteres que separa valores individuales en una línea.

Por ejemplo, en nuestro archivo anterior, teníamos los valores separados por un espacio, por lo que en ese caso, el delimitador era un carácter de espacio (”“).

Sin embargo, algunos otros archivos pueden tener un delimitador diferente, por ejemplo, los archivos CSV generalmente usan una coma (",") como delimitador. Otro archivo puede tener un punto y coma como delimitador.

Por lo tanto, necesitamos que nuestro cargador de datos sea lo suficientemente flexible para identificar dichos delimitadores en cada fila y extraer los valores correctos de ellos.

Esto se puede lograr pasando nuestro delimitador como parámetro a la función np.loadtxt.

Consideremos otro archivo ' weight_height_2.txt ', tiene el mismo contenido de datos que el anterior, pero esta vez los valores en cada fila están separados por una coma:

110.90, 146.03
44.83, 211.82
97.13, 209.30
...
...

Llamaremos a la función np.loadtxt de la misma manera que antes, excepto que ahora pasamos un parámetro adicional: 'delimitador':

1
2
3
import numpy as np
 
data = np.loadtxt("./weight_height_2.txt", delimiter = ",")

Esta función devolverá la misma matriz que antes.

  • En la sección anterior, no pasamos el valor del parámetro delimitador porque np.loadtxt () espera que el espacio "" sea el delimitador predeterminado
  • Si los valores de cada fila estuvieran separados por una pestaña, en ese caso, el delimitador se especificaría mediante el carácter de escape "\ t"

Puede verificar los resultados nuevamente verificando la forma de la matriz de datos y también imprimiendo las primeras filas:

1
2
3
print("shape of array", data.shape)
 
print("First 5 rows:\n", data[:5])

Salida:

Tratar con 2 delimitadores

Ahora puede haber una situación en la que haya más de 1 delimitadores en un archivo.

Por ejemplo, imaginemos que cada una de nuestras líneas contiene un tercer valor que representa la fecha de nacimiento del individuo en formato dd-mm-aaaa

110.90, 146.03, 3-7-1981
44.83, 211.82, 1-2-1986
97.13, 209.30, 14-2-1989

Ahora suponga que queremos extraer las fechas, meses y años como 3 valores diferentes en 3 columnas diferentes de nuestra matriz NumPy. Entonces, ¿deberíamos pasar "," como delimitador o deberíamos pasar "-"?

¡Podemos pasar solo 1 valor al parámetro delimitador en el método np.loadtxt!

No se preocupe, siempre hay una solución. Usemos un tercer archivo './ weight_height_3.txt ' para este ejemplo

Primero usaremos un enfoque ingenuo, que tiene los siguientes pasos:

  1. leer el archivo
  2. eliminar uno de los delimitadores en cada línea y reemplazarlo con un delimitador común (aquí coma)
  3. agregar la línea a una lista en ejecución
  4. pase esta lista de cadenas a la función np.loadtxt en lugar de pasar una ruta de archivo.

Escribamos el código:

1
2
3
4
5
6
7
#reading each line from file and replacing "-" by ","
with open("./weight_height_3.txt") as f_input:
 
    text = [l.replace("-", ",") for l in f_input]
 
#calling the loadtxt method with “,“ as delimiter
data = np.loadtxt(text, delimiter=",")
  • Tenga en cuenta que estamos pasando una lista de cadenas como entrada y no una ruta de archivo.
  • Al llamar a la función, seguimos pasando el parámetro delimitador con el valor "," ya que hemos reemplazado todas las instancias del segundo delimitador '-' por una coma.
  • La matriz NumPy devuelta ahora debería tener 5 columnas

Puede volver a validar los resultados imprimiendo la forma y las primeras cinco líneas:

1
2
3
print("Shape of data:", data.shape)
 
print("First five rows:\n",data[:5])

Salida:

Observe cómo tenemos 3 columnas adicionales en cada fila que indican la fecha, mes y año de nacimiento.

También observe que los nuevos valores son todos valores de punto flotante; sin embargo, la fecha, el mes o el año tienen más sentido como números enteros.
Veremos cómo manejar tales inconsistencias de tipos de datos en la próxima sección.

Un enfoque general para múltiples delimitadores

En esta sección, veremos un enfoque general para trabajar con múltiples delimitadores.

Además, aprenderemos cómo podemos usar generadores en lugar de rutas de archivo, una solución más eficiente para múltiples delimitadores que la que discutimos en la sección anterior.

El problema de leer todo el archivo a la vez y almacenarlo como una lista de cadenas es que no se escala bien. Por ejemplo, si hay un archivo con un millón de líneas, almacenarlos en una lista de una vez consumirá memoria adicional innecesaria.

Por lo tanto, utilizaremos generadores para eliminar cualquier delimitador adicional.
Un generador nos 'produce' una secuencia de valores sobre la marcha, es decir, leerá las líneas de un archivo según sea necesario en lugar de leerlas todas a la vez

Primero definamos una función generadora que tome una ruta de archivo y una lista de delimitadores como parámetro.

01
02
03
04
05
06
07
08
09
10
11
12
13
def generate_lines(filePath, delimiters=[]):
     
    with open(filePath) as f:
         
        for line in f:
             
            line = line.strip() #removes newline character from end
             
        for d in delimiters:
             
            line =line.replace(d, " ")
             
            yield line

Aquí estamos revisando cada uno de los delimitadores uno por uno en cada línea y reemplazándolos por un espacio en blanco ””, que es el delimitador predeterminado en la función np.loadtxt

Ahora llamaremos a esta función generadora y pasaremos el objeto generador devuelto al método np.loadtxt en lugar de la ruta del archivo.

1
2
3
gen = generate_lines("./weight_height_3.txt", ["-",","])
 
data = np.loadtxt(gen)

Tenga en cuenta que no necesitamos pasar ningún parámetro de delimitador adicional, ya que nuestra función generadora reemplazó todas las instancias de los delimitadores en la lista pasada por un espacio, que es el delimitador predeterminado.

Podemos ampliar esta idea y especificar tantos delimitadores como sea necesario.

Especificando el tipo de datos

A menos que se especifique lo contrario, la función np.loadtxt del paquete NumPy asume que los valores en el archivo de texto pasado son valores de punto flotante por defecto.

Entonces, si pasa un archivo de texto que tiene caracteres que no sean números, la función arrojará un error, indicando que esperaba valores de punto flotante.

Podemos superar esto especificando el tipo de datos de los valores en el archivo de texto usando el parámetro de tipo de datos.

En el ejemplo anterior, vimos que la fecha, el mes y el año se interpretaban como valores de punto flotante, sin embargo, sabemos que estos valores nunca pueden existir en forma decimal.

Veamos un nuevo archivo './ weight_height_4.txt ' que tiene solo una columna para la fecha de nacimiento de las personas en el formato dd-mm-aaaa:

13-2-1991
17-12-1990
18-12-1986

Entonces llamaremos al método loadtxt con "-" como delimitador:

1
2
3
4
5
data = np.loadtxt("./weight_height_4.txt", delimiter="-")
 
print(data[:3])
 
print("datatype =",data.dtype)

Si miramos la salida de las líneas de código anteriores, veremos que cada uno de los 3 valores se ha almacenado como valores de punto flotante de forma predeterminada y el tipo de datos de la matriz es 'float64'

Podemos alterar este comportamiento pasando el valor 'int' al parámetro 'dtype'. Esto le pedirá a la función que almacene los valores extraídos como números enteros y, por lo tanto, el tipo de datos de la matriz también será int.

1
2
3
4
5
data = np.loadtxt("./weight_height_4.txt", delimiter="-", dtype="int")
 
print(data[:3])
 
print("datatype =",data.dtype)

Salida:

Pero, ¿qué pasa si hay columnas con diferentes tipos de datos?

Digamos que tenemos las dos primeras columnas con valores flotantes y la última columna con valores enteros.

En ese caso, podemos pasar una cadena de tipo de datos separados por comas que especifique el tipo de datos de cada columna (en orden de existencia) al parámetro dtype.

Sin embargo, en tal caso, la función devolverá una matriz NumPy de tuplas de valores ya que una matriz NumPy como un todo puede tener solo 1 tipo de datos

Probemos esto en el archivo weight_height_3.txt ' donde las dos primeras columnas (peso, altura) tenían valores flotantes y los últimos 3 valores (fecha, mes, año) eran enteros:

Salida:

Ignorando encabezados

En algunos casos (especialmente archivos CSV), la primera línea del archivo de texto puede tener "encabezados" que describen lo que representa cada columna en las siguientes filas. Mientras leemos datos de dichos archivos de texto, es posible que deseemos ignorar la primera línea porque no podemos (y no debemos) almacenarlos en nuestra matriz NumPy.

En tal caso, podemos usar el parámetro 'skiprows' y pasar el valor 1, pidiendo a la función que ignore la (s) primera (s) línea (s) del archivo de texto.

Probemos esto en un archivo CSV - ' weight_height.csv ':

Peso (en Kg), Altura (en cm)
73.847017017515,241.893563180437
68.7819040458903,162.310472521300
74.1101053917849,212.7408555565

Ahora queremos ignorar la línea del encabezado, es decir, la primera línea del archivo:

1
2
3
data = np.loadtxt("./weight_height.csv", delimiter=",", skiprows=1)
 
print(data[:3])

Salida:

Asimismo, podemos pasar cualquier entero positivo n al parámetro skiprows pidiendo ignorar las primeras n filas del archivo.

Ignorando la primera columna

A veces, también es posible que deseemos omitir la primera columna porque no estamos interesados ​​en ella. Por ejemplo, si nuestro archivo de texto tiene la primera columna como "género", y si no necesitamos incluir los valores de esta columna al extraer los datos, necesitamos una forma de pedirle a la función que haga lo mismo.

No tenemos un parámetro skipcols como skiprows en la función np.loadtxt, con el cual podríamos expresar esta necesidad. Sin embargo, np.loadtxt tiene otro parámetro llamado 'usecols' donde especificamos los índices de las columnas a retener.

Entonces, si queremos omitir la primera columna, simplemente podemos proporcionar los índices de todas las columnas excepto la primera (recuerde que la indexación comienza en cero)

Basta de hablar, ¡manos a la obra!

Veamos el contenido de un nuevo archivo ' weight_height_5.txt ' que tiene una columna de género adicional que queremos ignorar.

Hombre, 110.90, 146.03
Hombre, 44.83, 211.82
...
...
Mujer, 78.67, 158.74
Hombre, 105.64, 164.21

Primero determinaremos el número de columnas en el archivo desde la primera línea y luego pasaremos un rango de índices de columna excluyendo el primero:

1
2
3
4
5
6
7
8
with open("./weight_height_5.txt") as f:
    #determining number of columns from the first line of text
 
    n_cols = len(f.readline().split(","))
 
data = np.loadtxt("./weight_height_5.txt", delimiter=",",usecols=np.arange(1, n_cols))
 
print("First five rows:\n",data[:5])

Aquí estamos proporcionando un rango de valores comenzando desde 1 (segunda columna) y extendiéndose hasta n_cols (la última columna)

Salida:

Podemos generalizar el uso del parámetro usecols pasando una lista de índices de solo aquellas columnas que queremos retener.

Cargar las primeras n filas

Así como podemos omitir las primeras n filas usando el parámetro skiprows, también podemos optar por cargar solo las primeras n filas y omitir el resto. Esto se puede lograr utilizando el parámetro max_rows del método np.loadtxt.

Supongamos que queremos leer solo las primeras 10 filas del archivo de texto 'weight_height_2.txt'. Llamaremos al método np.loadtxt junto con el parámetro max_rows y pasaremos el valor 10.

1
2
3
data = np.loadtxt("./weight_height_2.txt", delimiter=",",max_rows = 10)
 
print("Shape of data:",data.shape)

Salida:

Como podemos ver, la matriz NumPy devuelta tiene solo 10 filas que son las primeras 10 filas del archivo de texto.

Si usamos el parámetro max_rows junto con el parámetro skiprows, entonces se omitirá el número especificado de filas y se extraerán las n filas siguientes, donde n es el valor que pasamos a max_rows.

Cargar filas específicas

Si queremos que la función np.loadtxt cargue solo filas específicas del archivo de texto, ningún parámetro admite esta función.

Sin embargo, podemos lograr esto definiendo un generador que acepte índices de fila y devuelva líneas en esos índices. Luego pasaremos este objeto generador a nuestro método np.loadtxt.

Primero definamos el generador:

01
02
03
04
05
06
07
08
09
10
11
def generate_specific_rows(filePath, row_indices=[]):
 
    with open(filePath) as f:
 
        # using enumerate to track line no.
        for i, line in enumerate(f):
 
            #if line no. is in the row index list, then return that line
            if i in row_indices:
  
               yield line

Usemos ahora la función np.loadtxt para leer las líneas 2, 4 y 100 en el archivo ' weight_height_2.txt '

1
2
3
4
5
gen = generate_specific_rows("./weight_height_2.txt",row_indices = [1, 3, 99])
 
data = np.loadtxt(gen, delimiter=",")
 
print(data)

Esto debería devolver una matriz NumPy con 3 filas y 2 columnas:

Salida:

Salta la última fila

Si desea excluir la última línea del archivo de texto, puede lograrlo de varias formas. Puede definir otro generador que produzca líneas una por una y se detenga justo antes de la última, o puede usar un enfoque aún más simple: simplemente averigüe la cantidad de líneas en el archivo y pase 1 menos que ese recuento al max_rows parámetro.

Pero, ¿cómo calculará el número de líneas?
¡Seguir a lo largo!

1
2
3
4
5
with open("./weight_height_2.txt") as f:
 
    n = len(list(f))
 
print("n =", n)

Ahora n contiene el número de líneas presentes en el archivo weight_height_2.txt` , ese valor debería ser 100.

Ahora leeremos el archivo de texto como solíamos hacerlo, usando el método np.loadtxt junto con el parámetro max_rows con valor n - 1.

1
2
3
data = np.loadtxt("./weight_height_2.txt", delimiter=",",max_rows=n - 1)
 
print("data shape =",data.shape)

Salida:

Como podemos ver, el archivo de texto original tenía 100 filas, pero cuando leemos los datos del archivo, su forma es (99, 2) ya que omitió la última fila del archivo.

Omitir columnas específicas

Suponga que desea ignorar algunas de las columnas mientras carga datos de un archivo de texto especificando los índices de dichas columnas.

Si bien el método np.loadtxt proporciona un parámetro para especificar qué columnas retener (usecols), no ofrece una forma de hacer lo contrario, es decir, especificar qué columnas omitir. Sin embargo, siempre podemos encontrar una solución.

Primero definiremos los índices de las columnas que se ignorarán y luego, usándolos, obtendremos la lista de índices que se conservarán, ya que los dos conjuntos serían mutuamente excluyentes.

Luego pasaremos esta lista de índices derivados al parámetro usecols.

Aquí hay un pseudocódigo para todo el proceso:

  1. Encuentre el número de columnas en el archivo n_cols (explicado en una sección anterior)
  2. Definir la lista de índices a ignorar
  3. Cree un rango de índices de 0 a n_cols y elimine los índices del paso 2 de este rango
  4. Pase esta nueva lista al parámetro usecols en el método np.loadtxt

Creemos una función contenedora loadtext_without_columns que implemente todos los pasos anteriores:

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
dieciséis
17
18
19
def loadtext_without_columns(filePath, skipcols=[], delimiter=","):
 
    with open(filePath) as f:
  
       n_cols = len(f.readline().split(delimiter))
 
    #define a range from 0 to n_cols
    usecols = np.arange(0, n_cols)
 
    #remove the indices found in skipcols
    usecols = set(usecols) - set(skipcols)
 
    #sort the new indices in ascending order
    usecols = sorted(usecols)
 
    #load the file and retain indices found in usecols
    data = np.loadtxt(filePath, delimiter = delimiter, usecols = usecols)
 
    return data

Para probar nuestro código, trabajaremos con un nuevo archivo ` weight_height_6.txt` que tiene 5 columnas - las dos primeras columnas indican ancho y alto y las 3 restantes indican la fecha, mes y año de nacimiento de los individuos.

Todos los valores están separados por un solo delimitador: coma:

110.90, 146.03, 3,7,1981
44.83, 211.82, 1,2,1986
97.13, 209.30, 14,2,1989
...
...
105.64, 164.21, 3,6,2000

Supongamos que no estamos interesados ​​en la altura y la fecha de nacimiento del individuo, por lo que queríamos omitir las columnas en las posiciones 1 y 2.

Llamemos a nuestra función contenedora especificando nuestros requisitos:

1
2
3
4
data = loadtext_without_columns("./weight_height_6.txt",skipcols = [1, 2], delimiter = ",")
 
# print first 5 rows
print(data[:5])

Salida:

Podemos ver que nuestra función contenedora solo devuelve 3 columnas: peso, mes y año. ¡Se ha asegurado de que se hayan omitido las columnas que especificamos!

Cargar matrices 3D

Hasta ahora hemos estado leyendo el contenido del archivo como una matriz 2D NumPy. Este es el comportamiento predeterminado del método np.loadtxt y no hay ningún parámetro adicional que podamos especificar para interpretar los datos leídos como una matriz 3D.

Entonces, el enfoque más simple para resolver este problema sería leer los datos como una matriz NumPy y usar el método de remodelación de NumPy para remodelar los datos en cualquier forma de cualquier dimensión que deseemos.

Solo debemos tener cuidado de que si queremos interpretarlo como una matriz multidimensional, debemos asegurarnos de que esté almacenado en el archivo de texto de una manera apropiada y que después de remodelar la matriz, obtendremos lo que realmente deseamos.

Tomemos un archivo de ejemplo: ' weight_height_7.txt '.

Este es el mismo archivo que 'weight_height_2.txt'. La única diferencia es que este archivo tiene 90 filas y cada bloque de 30 filas representa una sección o clase diferente a la que pertenecen los individuos.

Entonces, hay un total de 3 secciones (A, B y C), cada una con 30 personas cuyos pesos y alturas se enumeran en una nueva fila.

Los nombres de las secciones se indican con un comentario justo antes del comienzo de cada sección (puede verificar esto en las líneas 1, 32 y 63).

Las declaraciones de comentarios comienzan con '#' y np.loadtxt ignora estas líneas al leer los datos. También podemos especificar cualquier otro identificador para las líneas de comentarios usando el parámetro 'comentarios'

Ahora, cuando lea este archivo e imprima su forma, se mostrará (90,2) porque así es como np.loadtxt lee los datos: organiza los datos de varias filas en matrices 2D.

Pero sabemos que hay una separación lógica entre cada grupo de 30 individuos, y nos gustaría que la forma fuera (3, 30, 2) - donde la primera dimensión indica las secciones, la segunda representa a cada uno de los individuos en ese sección y la última dimensión indica el número de valores asociados a cada uno de estos individuos (aquí 2 para peso y altura).

Usando el método de remodelación de NumPy

Por eso queremos que nuestros datos se representen como una matriz 3D.

Podemos lograr esto simplemente remodelando los datos devueltos usando el método de remodelación de NumPy.

1
2
3
4
5
6
7
8
9
data = np.loadtxt("./weight_height_7.txt",delimiter=",")
 
print("Current shape = ",data.shape)
 
data = data.reshape(3,30,2)
 
print("Modified shape = ",data.shape)
 
print("fifth individual of section B - weight, height =",data[1,4,:])

Salida:

Observe cómo imprimimos los detalles de un individuo específico usando 3 índices

El resultado devuelto pertenece a la quinta persona de la sección B; esto se puede validar a partir del texto:
# sección B 100.91
, 155.55
72.93, 150.38
116.68, 137.15
86.51, 172.15
59.85, 155.53

Comparación con alternativas

Si bien numpy.loadtxt es una utilidad extremadamente útil para leer datos de archivos de texto, ¡no es la única!

Existen muchas alternativas que pueden hacer la misma tarea que np.loadtxt, muchas de ellas son mejores que np.loadtxt en muchos aspectos. Veamos brevemente 3 de estas funciones alternativas.

numpy.genfromtxt

  1. Este es el método más discutido y más utilizado junto con np.loadtxt
  2. No hay una gran diferencia entre los dos, la única que se destaca es la capacidad de np.genfromtxt para manejar sin problemas los valores perdidos.
  3. De hecho, la documentación de NumPy describe np.loadtxt como “una función equivalente (a np.genfromtxt) cuando no faltan datos.
  4. Entonces, los dos son métodos casi similares, excepto que np.genfromtxt puede hacer un procesamiento más sofisticado de los datos en un archivo de texto.

numpy.fromfile

  1. np.fromfile se usa comúnmente cuando se trabaja con datos almacenados en archivos binarios, sin delimitadores.
  2. Puede leer archivos de texto sin formato, pero lo hace con muchos problemas (siga adelante e intente leer los archivos que discutimos usando np.fromfile)
  3. Si bien es más rápido en tiempo de ejecución que np.loadtxt, generalmente no es una opción preferida cuando se trabaja con datos bien estructurados en un archivo de texto.
  4. Además, la documentación de NumPy menciona np.loadtxt como una forma 'más flexible (que np.fromfile) de cargar datos desde un archivo de texto.

pandas.read_csv

  1. pandas.read_csv  es la opción más popular de científicos de datos, ingenieros de ML, analistas de datos, etc. para leer datos de archivos de texto.
  2. Ofrece mucha más flexibilidad que np.loadtxt o np.genfromtxt.
  3. Aunque no puede pasar un generador a pandas.read_csv como hicimos nosotros.
  4. Sin embargo, en términos de velocidad de ejecución, pandas.read_csv lo hace mejor que np.loadtxt

Manejo de valores perdidos

Como se discutió en nuestra sección comparando np.loadtxt con otras opciones, np.genfromtxt maneja los valores faltantes por defecto. No tenemos ninguna forma directa de manejar los valores perdidos en np.loadtxt

Aquí veremos una forma indirecta (y un poco sofisticada) de manejar los valores perdidos con el método np.loadtxt.

El parámetro de convertidores:

  • np.loadtxt tiene un parámetro de convertidores que se usa para especificar el preprocesamiento (si lo hay) requerido para cada una de las columnas del archivo.
  • Por ejemplo, si el archivo de texto almacena la columna de altura en centímetros y queremos almacenarlos como pulgadas, podemos definir un convertidor para la columna de alturas.
  • El parámetro converters acepta un diccionario donde las claves son índices de columna y los valores son métodos que aceptan el valor de la columna, lo 'convierten' y devuelven el valor modificado.

¿Cómo podemos usar convertidores para manejar valores perdidos?

  • Primero debemos decidir el tipo de datos predeterminado, es decir, el valor que se utilizará para completar las posiciones donde faltan los valores reales. Digamos que queremos completar los valores de altura y peso que faltan con 0, por lo que nuestro fill_value será 0.
  • A continuación, podemos definir un convertidor para cada columna en el archivo, que verifica si hay algún valor o una cadena vacía en esa columna y si es una cadena vacía, la llenará con nuestro fill_value.
  • Para hacer esto, tendremos que encontrar el número de columnas en el archivo de texto, y ya hemos discutido cómo lograrlo en una sección anterior.

Usaremos el archivo ' weight_height_8.txt ' que es el mismo que 'weight_height_2.txt' pero tiene varios valores faltantes.

, 146.03
44.83, 211.82
97.13,
69.87, 207.73
, 158.87
99.25, 195.41
...

Escribamos el código para completar las posiciones de estos valores faltantes con 0.

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
dieciséis
17
18
19
# finding number of columns in the file
with open("./weight_height_8.txt") as f:
 
    n_cols = len(f.readline().split(","))
 
print("Number of columns", n_cols)
 
# defining converters for each of the column (using 'dictionary
# comprehension') to fill each missing value with fill_value
 
fill_value = 0
 
converters = {i: lambda