viernes, 2 de enero de 2026

Python para ciencia de datos. Limpieza de datos. (Articulo).

 

Cómo limpiar tus datos en Python


Traducción: Google

Una guía detallada sobre cómo limpiar tus datos para poner en marcha tus proyectos personales

                                                                  Foto de Towfiqu barbhuiya en Unsplash

Cuando participé en el programa de lectura dirigida de mi universidad (un mini programa de investigación donde los estudiantes universitarios reciben tutoría de estudiantes de posgrado), Solo había tomado 2 cursos de estadística en R. Si bien estas clases me enseñaron mucho sobre cómo manipular datos, crear visualizaciones de datos y extraer análisis, trabajar en mi primer proyecto personal en el programa me hizo me doy cuenta de que nunca había trabajado con "datos desordenados". Esos cursos implicaban conjuntos de datos previamente limpiados y procesados, pero No enseñó a los estudiantes cómo limpiar conjuntos de datos cual Crea una barrera para comenzar con proyectos personales. Por lo tanto, espero que este artículo sirva como punto de partida para usted Aprenda a limpiar sus datos de manera eficiente y Poner en marcha tus proyectos personales.

Para este artículo, trabajaré con el Conjunto de datos de programas de televisión y películas de Netflix que presenta muchas inconsistencias y datos faltantes.

Tabla de contenidos

  1. Revisa tus datos
  2. Mira la proporción de datos faltantes
  3. Comprueba el tipo de datos de cada columna
  4. Si tiene columnas de cadenas, verifique espacios en blanco finales
  5. Cómo afrontar los valores faltantes (Valores de NaN)
  6. Extraer más información de su conjunto de datos para obtener más variables
  7. Comprueba el valores únicos de columnas

Todas las imágenes, a menos que se indique lo contrario, son del autor.

Paso 1: Revisa tus datos

Antes incluso de realizar cualquier limpieza o manipulación de su conjunto de datos, debe echar un vistazo a sus datos para comprenderlos con qué variables estás trabajando, cómo se estructuran los valores en función de la columna en la que se encuentran y tal vez puedas tener una idea aproximada de las inconsistencias que necesitarás abordar o serán engorrosas en la fase de análisis. Aquí también podrás eliminar ciertas columnas que no necesitarás dependiendo del análisis que quieras realizar.

1. Imprima las primeras filas de su conjunto de datos

Aquí imprimí las primeras 7 filas de mi conjunto de datos, pero puedes imprimir 5 o 10. Recomiendo mantenerlo en menos de 10 o de lo contrario será demasiado abrumador para lo que estás tratando de hacer actualmente –un vistazo rápido del conjunto de datos.

>># importing dataset
>>netflix_titles = pd.read_csv("/Users/huongngo/Desktop/PERSONAL PROJECTS/zuckflix_meta/Data/netflix_titles.csv")
>># printing the first 5 rows of dataset
>>netflix_titles.head()
view rawcode.py hosted with ❤ by GitHub
NOTA de PPI: El autor del articulo esta dando por sentado la importación de la librería pandas y omitió la instrucción >>import pandas as pd

Hacer esto le dará una buena idea de con qué tipos de datos podría estar tratando, qué columnas necesita para realizar transformaciones o limpieza y otros datos que podría extraer.

Antes de analizar esto más de cerca, realicemos el siguiente paso.

2. Guarde las variables en una lista

Quieres hacer esto para tener Fácil acceso a las diferentes columnas del conjunto de datos, especialmente cuando desea realizar las mismas transformaciones en diferentes subconjuntos de columnas.

# getting the columns of the dataset
columns = list(netflix_titles.columns)
columns
"""
Output:
['show_id',
'type',
'title',
'director',
'cast',
'country',
'date_added',
'release_year',
'rating',
'duration',
'listed_in',
'description']
"""
view rawcode_1.py hosted with ❤ by GitHub

3. Anote los posibles problemas que deberá abordar en cada columna.

Para mantenerse organizado, tenga en cuenta los problemas que ve en su conjunto de datos (echando un vistazo a su conjunto de datos como en el Paso 1).

Esta imagen de arriba representa lo que puedo ver con solo echar un vistazo al conjunto de datos y es algo que Deberías pensar en ello cuando mires tu conjunto de datos. Aquí hay algunas cosas que me llaman la atención:

  • Hay algunas columnas a las que les faltan valores. Esto podría causar muchos problemas de análisis y trazado si no se aborda y resuelve al principio del proceso.
  • Hay columnas con palabras y números, como date_added y duration. Esto puede ser un problema si queremos hacer gráficos de series temporales por la fecha, o otros gráficos para explorar la relación de la duración con otras variables.
  • Hay 2 columnas con varias palabras distintas unidas por una coma. Este es un problema si queremos hacerlo parcelas que exploran la distribución de listed_in (género) o los actores de Netflix.
  • Es posible que a otras columnas les falten valores. El siguiente paso analiza el camino a seguir compruebe qué columnas tienen valores faltantes y cuántos datos faltantes tienen.

Paso 2: Observa la proporción de datos faltantes

>># examining missing values
>>print("Missing values distribution: ")
>>print(netflix_titles.isnull().mean())
>>print("")
>>>
"""
Output:
Missing values distribution:
show_id 0.000000
type 0.000000
title 0.000000
director 0.299080
cast 0.093675
country 0.094357
date_added 0.001135
release_year 0.000000
rating 0.000454
duration 0.000341
listed_in 0.000000
description 0.000000
dtype: float64
"""
view rawcode_2.py hosted with ❤ by GitHub

A partir de este fragmento de código, puede observar fácilmente la distribución de los valores faltantes en el conjunto de datos para tener una buena idea de con qué columnas deberá trabajar para resolver el problema de los valores faltantes.

A partir del resultado, estos son los conocimientos que puede obtener:

  • directorLa columna tiene el mayor porcentaje de datos faltantes ~ 30%
  • cast y country La columna también tiene un porcentaje considerable de datos faltantes ~ 9%
  • date_added, rating y duration no faltan tantos datos ~ 0% – 0,1%
  • Afortunadamente, la mayoría de las demás columnas no están vacías.

Tu próxima pregunta probablemente sea: ¿Cómo manejo estas columnas con valores faltantes?

Hay algunas formas de abordarlo:

  1. Elimina la columna por completo. Si la columna no es tan importante para su análisis, simplemente elimínela.
  2. Mantén la columna. En este caso, porque el director, cast y country Las columnas son bastante importantes para mi análisis, los conservaré.
  3. Imputación – el proceso de reemplazar datos faltantes con valores sustituidos. Aquí no es posible hacerlo porque la mayoría de los datos son valores de cadena y no valores numéricos. Sin embargo, escribiré un artículo que habla más sobre la imputación en detalle, por qué y cuándo se debe utilizar y cómo se puede utilizar en R y Python con la ayuda de algunos paquetes.

Antes de continuar, plantearé la cuestión de los valores faltantes a través de filas.

En algunos casos, es posible que desees examinar el distribución de valores faltantes en todas las filas de su conjunto de datos (dado que su conjunto de datos no tiene una gran cantidad de observaciones/filas). Desde aquí, puedes Elija entre las opciones anteriores dependiendo de qué tan importantes sean las filas para su análisis. Por ejemplo, su conjunto de datos contiene datos registrados de algo que cambia con el tiempo. Aunque una fila puede contener valores faltantes, es posible que no desees eliminarla porque hay información de tiempo importante que deseas conservar.

Continuemos con el paso 3 antes de mostrarles cómo manejar los valores de NaN incluso después de mantener las columnas.

Paso 3: Verifique el tipo de datos de cada columna

>># check datatype in each column
>>print("Column datatypes: ")
>>print(netflix_titles.dtypes)
>>>
"""
Output:
Column datatypes:
show_id object
type object
title object
director object
cast object
country object
date_added object
release_year int64
rating object
duration object
listed_in object
description object
dtype: object
"""
view rawcode_3.py hosted with ❤ by GitHub

Aquí puedes ver que todas las columnas tienen object como su tipo de datos aparte de release_year. En pandas, objeto significa cadena o tipo mixto (tipo numérico y no numérico mixto). Y a partir de nuestro conjunto de datos, podrá saber qué columnas son estrictamente de cadena y de tipo mixto.

Paso 4: Si tiene columnas de cadenas, verifique los espacios en blanco finales

Una vez que sepamos con qué tipos de datos estamos tratando, asegurémonos de eliminar los caracteres finales y los espacios en blanco strip .

>># getting all the columns with string/mixed type values
>>str_cols = list(netflix_titles.columns)
>>str_cols.remove('release_year')
>># removing leading and trailing characters from columns with str type
>>for i in str_cols:
>> netflix_titles[i] = netflix_titles[i].str.strip()
view rawcode_4.py hosted with ❤ by GitHub

Paso 5: Cómo lidiar con los valores faltantes (valores NaN)

Volviendo a las columnas de valores faltantes, echemos un vistazo a las columnas: director, cast, country, date_added, rating, duration. Podemos segmentar estas columnas según sean de tipo cadena o mixto.

Cadena: director, cast, country, rating (aquí es una cadena y no está mezclada porque los valores numéricos no tendrán ningún significado si se separan)

Mixto: date_added, duration

NaN significa No es un número en pandas. Es un valor especial de punto flotante que es diferente de NoneType en Python. NaN Puede resultar molesto trabajar con valores, especialmente cuando desea filtrarlos para gráficos o análisis. Para hacernos la vida más fácil, reemplace estos valores de NaN con otra cosa.

Para valores de tipo cadena, podemos reemplazarlos NaN valores con "" o "Ninguno" o cualquier cadena que pueda indicarle que no hay ningún valor en esa entrada. Aquí, elegí reemplazarlo con "" usando el fillna función. Como no es una función in situ, reasigné los valores modificados a la columna del conjunto de datos.

>># names of the columns
>>columns = ['director', 'cast', 'country', 'rating', 'date_added']
>># looping through the columns to fill the entries with NaN values with ""
>>for column in columns:
>> netflix_titles[column] = netflix_titles[column].fillna("")
view rawcode_5.py hosted with ❤ by GitHub

Aquí debes haber notado que omití la columna de duración. Esto se debe a que haremos algo con esa columna más adelante.

Paso 6: Vea si hay otras variables que pueda obtener extrayéndolas de otras variables

Para valores de tipo mixto, antes de abordar el problema del valor faltante, veamos si podemos extraer algún dato para enriquecer nuestro análisis o facilitar el proceso.

Mirando date_added, podemos ver que contiene el mes, la fecha y el año en que se agregó la película/programa. En lugar de tener toda esta información en una columna, ¿por qué no intentar separarla? De esa manera, podemos optar por aislar cómo el mes o el año interactúa con las otras variables en lugar de mirar date_added donde su granularidad dificultará el descubrimiento de cualquier tendencia.

A continuación, escribí código no solo para separar la información en otras 2 columnas, sino que también filtré las filas con NaN valores y los reemplazó con 0, tal como se hizo antes con "".

>># examining rows with null values for date_added column
>>rows = []
>>for i in range(len(netflix_titles)):
>> if netflix_titles['date_added'].iloc[i] == "":
>> rows.append(i)
>># examine those rows to confirm null state
>>netflix_titles.loc[rows, :]
>># extracting months added and years added
>>month_added = []
>>year_added = []
>>for i in range(len(netflix_titles)):
>> # replacing NaN values with 0
>> if i in rows:
>> month_added.append(0)
>> year_added.append(0)
>> else:
>> date = netflix_titles['date_added'].iloc[i].split(" ")
>> month_added.append(date[0])
>> year_added.append(int(date[2]))
>>
>># turning month names into month numbers
>>for i, month in enumerate(month_added):
>> if month != 0:
>> datetime_obj = datetime.strptime(month, "%B")
>> month_number = datetime_obj.month
>> month_added[i] = month_number
>># checking all months
>>print(set(month_added))
>>print(set(year_added))
>># inserting the month and year columns into the dataset
>>netflix_titles.insert(7, "month_added", month_added, allow_duplicates = True)
>>netflix_titles.insert(8, "year_added", year_added, allow_duplicates = True)netflix_titles.head()
view rawcode_6.py hosted with ❤ by GitHub

Ahora, el nuevo conjunto de datos contiene el month_added y year_added columnas. Esto nos permitirá realizar algún análisis de tendencias más adelante.

Mirando duration, además de ser de tipo mixto, también hay 2 unidades de tiempo diferentes en esta columna. Esto es un problema porque estamos tratando con dos tipos diferentes de contenido que se miden de manera diferente en función del tiempo. Así, haciendo gráficos para durationSerá bastante difícil de interpretar si los mantenemos como están. Lo bueno es que hay muchas maneras de abordar este problema. La forma en que he elegido afrontarlo es mediante separando el tipo de contenido en 2 conjuntos de datos diferentes y, naturalmente, la columna de duración será simplemente numérica y tendrá solo 1 tipo de unidad de tiempo. De esta manera, puedes Trazar fácil y claramente utilizando los valores.

# separating original dataset to tv show and movie dataset respectively
shows = []
films = []
# looping through the dataset to identify rows that are TV shows and films
for i in range(len(netflix_titles)):
if netflix_titles['type'].iloc[i] == "TV Show":
shows.append(i)
else:
films.append(i)
# grouping rows that are TV shows
netflix_shows = netflix_titles.loc[shows, :]
#grouping rows that are films
netflix_films = netflix_titles.loc[films, :]
# reseting the index of the new datasets
netflix_shows = netflix_shows.set_index([pd.Index(range(0, len(netflix_shows)))])
netflix_films = netflix_films.set_index([pd.Index(range(0, len(netflix_films)))])
view rawcode_7.py hosted with ❤ by GitHub

Porque el duration La columna tiene cadenas y números, También tendré que crear una función para extraer el número de esa columna para que pueda insertarse en las columnas de los 2 nuevos conjuntos de datos.

# get length of movie or number of seasons of show
def getDuration(data):
count = 0
durations = []
for value in data:
# filling in missing values
if type(value) is float:
durations.append(0)
else:
values = value.split(" ")
durations.append(int(values[0]))
return durations
# inserting new duration type column for shows (renamed column)
netflix_shows.insert(11, 'seasons', getDuration(netflix_shows['duration']))
netflix_shows = netflix_shows.drop(['duration'], axis = 1)
netflix_shows.head()
# inserting new duration type column for films (renamed column)
netflix_films.insert(11, 'length', getDuration(netflix_films['duration']))
netflix_films = netflix_films.drop(['duration'], axis = 1)
netflix_films.head()
view rawcode_8.py hosted with ❤ by GitHub

Paso 7: Verifique los valores únicos de las columnas

Más allá de los valores potencialmente faltantes, podría haber valores corruptos con los que puede encontrarse una vez que realice el análisis. Para comprobar esto, podemos comprobar valores únicos para algunas de las columnas. Tomemos como punto de partida las primeras 5 filas de los conjuntos de datos.

Puede que no sea estratégico comprobar los valores únicos de todas las columnas, especialmente el título, el director y el elenco, ya que podría haber una gran cantidad de valores únicos para examinar. En lugar de ello, centrémonos en una lista de posibles valores únicos que podrían ser más fáciles e importantes de comprobar, dado que podrían ser más esclarecedores para análisis futuros. De un vistazo a los conjuntos de datos, las columnas country, rating, listed_in son probablemente los de interés. Examinemos primero la columna de calificación, ya que parece ser la menos complicada de abordar.

Puede obtener fácilmente los valores únicos de una columna como la calificación utilizando la función incorporada de Python unique. ¡Probemos eso!

# getting the unique ratings for films
netflix_films['rating'].unique()
"""
Output:
array(['PG-13', 'PG', 'TV-MA', 'TV-PG', 'TV-14', 'TV-Y', 'R', 'TV-G',
'TV-Y7', 'G', 'NC-17', '74 min', '84 min', '66 min', 'NR', '',
'TV-Y7-FV', 'UR'], dtype=object)
"""
# getting the unique ratings for shows
netflix_shows['rating'].unique()
"""
Output:
array(['TV-MA', 'TV-14', 'TV-Y7', 'TV-PG', 'TV-Y', 'TV-G', 'R', 'NR', '',
'TV-Y7-FV'], dtype=object)
"""
view rawcode_9.py hosted with ❤ by GitHub

Esto parece interesante. ¿Por qué hay 74 min, 84 min y 66 min en los tipos únicos de clasificación de películas? ¿Y por qué existen UR (sin clasificación) y NR (sin clasificación)? ¿No se supone que significan lo mismo? Investiguemos esto más a fondo extrayendo las filas que tienen estas entradas extrañas.

# printing more details of the rows that have incorrect ratings
incorrect_ratings = ['74 min', '84 min', '66 min']
for i in range(len(netflix_films)):
if netflix_films['rating'].iloc[i] in incorrect_ratings:
print(netflix_films.iloc[i])
print("")
"""
Output:
show_id s5542
type Movie
title Louis C.K. 2017
director Louis C.K.
cast Louis C.K.
country United States
date_added April 4, 2017
month_added 4
year_added 2017
release_year 2017
rating 74 min
length 0
listed_in Movies
description Louis C.K. muses on religion, eternal love, gi...
Name: 3562, dtype: object
show_id s5795
type Movie
title Louis C.K.: Hilarious
director Louis C.K.
cast Louis C.K.
country United States
date_added September 16, 2016
month_added 9
year_added 2016
release_year 2010
rating 84 min
length 0
listed_in Movies
description Emmy-winning comedy writer Louis C.K. brings h...
Name: 3738, dtype: object
show_id s5814
type Movie
title Louis C.K.: Live at the Comedy Store
director Louis C.K.
cast Louis C.K.
country United States
date_added August 15, 2016
month_added 8
year_added 2016
release_year 2015
rating 66 min
length 0
listed_in Movies
description The comic puts his trademark hilarious/thought...
Name: 3747, dtype: object
"""
view rawcode_10.py hosted with ❤ by GitHub

Usando este fragmento de código, podemos ver que 3 filas distintas contienen esta calificación extraña y que en realidad pertenece a la columna de longitud. También podemos ver el número de fila donde se encuentra el problema, que será útil utilizar para corregir las entradas.

Después de una búsqueda rápida en Google, podemos proceder a corregir estas entradas moviendo las "calificaciones incorrectas" (en realidad, duración) a la columna de longitud e ingresando las calificaciones correctas.

# getting the row indices
index = [3562, 3738, 3747]
# fixing the entries
for i in index:
split_value = netflix_films['rating'].iloc[i].split(" ")
length = split_value[0]
netflix_films['duration'].iloc[i] = length
netflix_films['rating'].iloc[i] = "NR"
# double checking the entries again
for i in index:
print(netflix_films.iloc[i])
view rawcode_11.py hosted with ❤ by GitHub

Para los valores UR y NR en la columna de calificación, debemos mantener la coherencia donde se utiliza NR en el netflix_shows conjunto de datos y cambie los valores de UR a NR.

# fixing the entries
for i in range(len(netflix_films)):
if netflix_films['rating'].iloc[i] == "UR":
netflix_films['rating'].iloc[i] = "NR"
# double checking
netflix_films['rating'].unique()
"""
array(['PG-13', 'PG', 'TV-MA', 'TV-PG', 'TV-14', 'TV-Y', 'R', 'TV-G',
'TV-Y7', 'G', 'NC-17', 'NR', '', 'TV-Y7-FV'], dtype=object)
"""
view rawcode_12.py hosted with ❤ by GitHub

Ahora que hemos limpiado el rating columna, veamos el país y listed_in columna. A estas alturas ya te habrás dado cuenta de que no es tan fácil como el rating columna para extraer valores únicos. Esto se debe a que los valores en esas columnas son palabras unidas por comas, lo que hace más difícil extraer el conjunto de palabras y luego encontrar palabras únicas de ese conjunto.

La forma en que vamos a solucionar este problema es implementando una función única para este caso especial.

Para empezar, pensemos en qué estructura de datos puede darnos valores únicos fácilmente. Si adivinaste conjuntos, ¡tienes razón! Dada su capacidad para almacenar elementos únicos del mismo tipo en orden ordenado, Es una estructura de datos adecuada para lo que queremos hacer.

Luego, para extraer aquellas palabras que están unidas por comas, podemos utilizar el split función para dividir la cadena por la coma.

# function to get unique values of a column
def getUnique(data):
unique_values = set()
for value in data:
if type(value) is float:
unique_values.add(None)
else:
values = value.split(", ")
for i in values:
unique_values.add(i)
return list(unique_values)
view rawcode_13.py hosted with ❤ by GitHub

Después de usar la función, podemos obtener fácilmente los valores únicos para el country y listed_in columnas.

# getting unique country names
unique_countries = getUnique(netflix_titles['country'])
unique_countries
"""
Output:
['',
'Czech Republic',
'Armenia',
'Belgium',
'Mozambique',
'East Germany'*,
'West Germany'*,
'Soviet Union'*,
'Burkina Faso', etc.] (shortened for article)
"""
view rawcode_14.py hosted with ❤ by GitHub

A continuación, examinemos la lista de países únicos para ver si hay inconsistencias o errores. Al hacerlo y con un poco de búsqueda en Google, podemos ver que hay algunos problemas con esta lista:

  • Están tanto la Unión Soviética como Rusia
  • Existe tanto Alemania Occidental/Este como Alemania

Podemos solucionar esto fácilmente con algunas modificaciones al conjunto de datos.

# converting soviet union to russia and east/west germany to germany
for i in range(len(netflix_titles)):
if type(netflix_titles['country'].iloc[i]) is not float:
countries = netflix_titles['country'].iloc[i].split(", ")
for j in range(len(countries)):
if "Germany" in countries[j]:
countries[j] = "Germany"
elif "Soviet Union" in countries[j]:
countries[j] = "Russia"
netflix_titles['country'].iloc[i] = ", ".join(countries)
view rawcode_15.py hosted with ❤ by GitHub

En cuanto a la lista de géneros, podemos ver que hay algunos géneros que quizás no queramos o necesitemos incluir. De esta forma, podemos eliminarlo fácilmente del conjunto de datos para que nuestro análisis sea menos confuso.

# getting unique film genres
unique_genres_films = getUnique(netflix_films['listed_in'])
unique_genres_films
"""
Output:
['International Movies',
'Children & Family Movies',
'LGBTQ Movies',
'Classic Movies',
'Action & Adventure',
'Stand-Up Comedy',
'Sports Movies',
'Documentaries',
'Movies'*,
'Music & Musicals',
'Romantic Movies',
'Anime Features',
'Comedies',
'Independent Movies',
'Dramas',
'Thrillers',
'Cult Movies',
'Faith & Spirituality',
'Horror Movies',
'Sci-Fi & Fantasy']
"""
# getting unique show genres
unique_genres_shows = getUnique(netflix_shows['listed_in'])
unique_genres_shows
"""
Output:
['TV Dramas',
'TV Comedies',
'TV Action & Adventure',
'TV Mysteries',
'Romantic TV Shows',
"Kids' TV",
'TV Horror',
'International TV Shows',
'TV Sci-Fi & Fantasy',
'Korean TV Shows',
'Spanish-Language TV Shows',
'Science & Nature TV',
'Crime TV Shows',
'TV Shows'*,
'Classic & Cult TV',
'Teen TV Shows',
'TV Thrillers',
'Stand-Up Comedy & Talk Shows',
'Docuseries',
'Reality TV',
'British TV Shows',
'Anime Series']
"""
view rawcode_16.py hosted with ❤ by GitHub

Tanto en el conjunto de datos de programas de televisión como de películas, existe un género de "programas de televisión" y "películas". Técnicamente, esto no es un género, pero podría ser una etiqueta del tipo de contenido. Para confirmar esto, debemos imprimir los recuentos de estos "géneros" que aparecen en los respectivos conjuntos de datos.

La hipótesis es que si estos "géneros" aparecen en todas las filas de los conjuntos de datos, significa que son simplemente etiquetas. De lo contrario, tendremos que investigar más a fondo qué representan esos "géneros".

# checking for TV shows
# replace netflix_shows with netflix_films to check for movies
count = 0
index = []
for i, value in enumerate(netflix_shows['listed_in']):
genres = value.split(", ")
if "TV Shows" in genres:
count += 1
index.append(i)
print("count %s" %count)
print("index %s" %index)
"""
Output:
TV shows:
count 16
index [59, 110, 272, 286, 452, 599, 991, 1432, 1548, 1808, 1840, 2107, 2160, 2190, 2465, 2559]
Movies:
count 57
index [197, 310, 456, 457, 458, 476, 477, 1906, 1938, 1941, 2146, 2165, 2621, 2711, 2758, 2862, 2863, 2867, 3036, 3137, 3138, 3139, 3140, 3141, 3142, 3225, 3226, 3228, 3232, 3517, 3562, 3652, 3694, 3722, 3738, 3747, 3789, 3824, 3883, 4271, 4273, 4543, 4544, 4784, 4910, 4911, 5006, 5178, 5259, 5290, 5292, 5293, 5295, 5476, 5477, 5478, 6092]
"""
view rawcode_17.py hosted with ❤ by GitHub

Como el recuento de los "géneros" es menor que el tamaño de los conjuntos de datos, usemos la salida del código para examinar las filas.

Dado que escribí el código para generar específicamente los índices de fila en una lista, podemos usar fácilmente esa lista y la iloc función para obtener una vista de las filas.

# printing the first 5 rows of all rows that have TV Shows as its genre
netflix_shows.iloc[index[0:5]]
# printing the first 5 rows of all rows that have Movies as its genre
netflix_films.iloc[index[0:5]]
view rawcode_18.py hosted with ❤ by GitHub

Al echar un vistazo a las filas, ahora es obvio que el género "Programas de televisión" y "Películas" se utilizó para indicar que estos contenidos no tenían un género en primer lugar. Ahora que entendemos lo que esto significa, podemos optar por excluirlo o incluirlo en nuestro análisis. Aquí he elegido incluirlo porque no afecta mi análisis.

Aunque este paso es tedioso, también es bastante importante ya que nos permite encontrar los problemas en nuestro conjunto de datos que están ocultos a primera vista.

Paso 8: Unir los conjuntos de datos limpios para crear otro conjunto de datos [Opcional]

Este paso es opcional, pero en el caso de que desee el conjunto de datos de programas de televisión y películas limpios en un solo lugar, debe concatenar ellos.

¡Y eso es todo! Has limpiado este conjunto de datos con éxito. Tenga en cuenta que cada uno tiene su metodología de limpieza de datos, y gran parte de ella se debe simplemente a que se esfuerza por comprender su conjunto de datos. Sin embargo, espero que este artículo le haya ayudado a comprender por qué los científicos de datos dedican el 80% de su tiempo a limpiar sus conjuntos de datos. Con toda seriedad, este artículo destaca la importancia de la limpieza de datos y, lo que es más importante, la necesidad de una buena metodología de limpieza de datos que le ayude a mantener su trabajo organizado y que le ayude si necesita volver a ello durante el proceso de análisis. Puedes consultar el cuaderno completo aquí.

Gracias por leer. Puedes visitarme en LinkedIn y Twitter!


Escrito por


No hay comentarios.:

Publicar un comentario

Entradas recientes

Python para ciencia de datos. Limpieza de datos. (Articulo).

  Cómo limpiar tus datos en Python Fuente: https://towardsdatascience.com/how-to-clean-your-data-in-python-8f178638b98d/ Traducción: Google ...

Entradas Populares