Удаление строк в датафрейме – одна из часто используемых операций при обработке данных в Python. В библиотеке Pandas для этих целей предусмотрено несколько методов, которые позволяют эффективно исключать ненужные данные, будь то строки с пропущенными значениями, дубликаты или строки, удовлетворяющие определённым условиям.
Для удаления строк можно использовать метод drop(), который удаляет строки по индексу. Важно помнить, что по умолчанию этот метод не изменяет исходный датафрейм, а возвращает новый. Если нужно внести изменения в исходный объект, следует указать параметр inplace=True.
Пример 1: Удаление строки по индексу:
import pandas as pd
df = pd.DataFrame({
'A': [1, 2, 3],
'B': [4, 5, 6]
})
df.drop(index=1, inplace=True) # Удаляем строку с индексом 1
print(df)Если необходимо удалить строки, удовлетворяющие определённому условию, можно использовать фильтрацию с последующим вызовом метода drop() или метод loc для создания нового датафрейма без этих строк.
Пример 2: Удаление строк с пропущенными значениями:
df.dropna(inplace=True) # Удаляем все строки с пропущенными значениями
print(df)Когда требуется удалить дубликаты, метод drop_duplicates() позволяет избавиться от строк с одинаковыми значениями по всем или определённым столбцам.
Пример 3: Удаление дубликатов:
df.drop_duplicates(inplace=True) # Удаление всех дубликатов
print(df)Эти методы дают широкие возможности для работы с данными в Pandas, делая процесс анализа более гибким и удобным.
Как удалить строки по индексу в pandas
Для удаления строк по индексу в pandas используется метод drop(). Он позволяет удалять как один, так и несколько рядов, указывая их индексы в параметре index.
Пример 1: Удаление строки с конкретным индексом
import pandas as pd
# Создание датафрейма
df = pd.DataFrame({
'A': [1, 2, 3, 4],
'B': [5, 6, 7, 8]
})
# Удаление строки с индексом 1
df = df.drop(index=1)
print(df)
В этом примере строка с индексом 1 будет удалена, а остальные останутся. Важно: drop() возвращает новый датафрейм, изменения не происходят в исходном, если не указать параметр inplace=True.
Пример 2: Удаление нескольких строк по индексам
# Удаление строк с индексами 1 и 3 df = df.drop(index=[1, 3]) print(df)
В данном примере строки с индексами 1 и 3 удаляются из датафрейма.
Пример 3: Удаление строк с индексами, которые не существуют в датафрейме
# Попытка удалить строки с несуществующими индексами df = df.drop(index=[10, 20], errors='ignore') print(df)
Параметр errors='ignore' позволяет избежать ошибки, если указанные индексы не найдены в датафрейме.
Пример 4: Удаление строк по индексу с изменением оригинального датафрейма
# Удаление строки с индексом 0 на месте df.drop(index=0, inplace=True) print(df)
Параметр inplace=True выполняет операцию удаления непосредственно в оригинальном датафрейме без необходимости присваивать результат в новую переменную.
Примечание: Удаление строк по индексу может быть полезно, если индексы датафрейма уникальны. Если индексы повторяются, pandas будет искать строки по указанным индексам, но результат может отличаться от ожидаемого, так как индексы могут быть не уникальными.
Удаление строк, содержащих NaN значения в определённых столбцах
Для удаления строк, в которых присутствуют NaN значения в конкретных столбцах DataFrame, можно использовать метод dropna() с параметром subset. Этот параметр позволяет указать, в каких столбцах проверять на NaN. Метод удалит только те строки, где NaN встречается хотя бы в одном из указанных столбцов.
Пример удаления строк, где в столбце «Age» или «Salary» присутствуют NaN значения:
import pandas as pd
data = {'Name': ['Alice', 'Bob', 'Charlie', 'David'],
'Age': [25, None, 30, None],
'Salary': [50000, 60000, None, 45000]}
df = pd.DataFrame(data)
# Удаление строк с NaN в столбцах 'Age' или 'Salary'
df_cleaned = df.dropna(subset=['Age', 'Salary'])
print(df_cleaned)
Результат выполнения этого кода будет следующий:
Name Age Salary
0 Alice 25.0 50000.0
1 Bob NaN 60000.0
2 Charlie 30.0 NaN
3 David NaN 45000.0
В результате остаются только строки, где значения в столбцах «Age» и «Salary» не равны NaN. Если требуется удалить строки с NaN в любом столбце, параметр subset можно опустить.
Для удаления строк с NaN в нескольких столбцах одновременно можно использовать комбинированное условие. Например, чтобы удалить строки, где NaN есть в любом из столбцов «Age», «Salary», или «Name», можно воспользоваться следующим кодом:
df_cleaned = df.dropna(subset=['Age', 'Salary', 'Name'])
Также можно настроить метод dropna() на удаление строк, если NaN встречается везде в столбце. Для этого используется параметр how='all':
df_cleaned = df.dropna(how='all')
Такой подход позволяет контролировать удаление строк по определённым столбцам, эффективно очищая данные без потери информации в других столбцах.
Фильтрация строк на основе условий значений
Простой пример фильтрации строк по одному условию:
import pandas as pd
data = {'Имя': ['Аня', 'Влад', 'Петя', 'Ирина'],
'Возраст': [25, 30, 22, 29],
'Город': ['Москва', 'Санкт-Петербург', 'Москва', 'Новосибирск']}
df = pd.DataFrame(data)
# Фильтрация по возрасту
df_старше_25 = df[df['Возраст'] > 25]
print(df_старше_25)
Этот код выберет все строки, где значение в столбце «Возраст» больше 25.
Можно использовать несколько условий одновременно. Например, чтобы выбрать людей старше 25 лет, живущих в Москве:
df_старше_25_в_москве = df[(df['Возраст'] > 25) & (df['Город'] == 'Москва')] print(df_старше_25_в_москве)
Важный момент: для соединения условий используется символ & для «и» и | для «или». Также не забудьте заключить каждое условие в скобки.
Фильтрация строк с использованием метода query():
df_старше_25_в_москве_query = df.query('Возраст > 25 and Город == "Москва"')
print(df_старше_25_в_москве_query)
Метод query() позволяет формулировать условия как строковые выражения, что может быть удобно в случае сложных фильтров или динамических запросов.
В случае с пропущенными значениями можно фильтровать их с помощью метода isnull(). Пример фильтрации строк, где значение в столбце «Город» не задано:
df_с_пропущенным_городом = df[df['Город'].isnull()] print(df_с_пропущенным_городом)
Если требуется выбрать только строки, где столбец не имеет пропущенных значений, можно использовать notnull():
df_без_пропусков_в_городе = df[df['Город'].notnull()] print(df_без_пропусков_в_городе)
Для более сложных случаев можно комбинировать фильтрацию по нескольким столбцам и условиям, например, выбрать людей младше 30 лет, проживающих в Москве или Санкт-Петербурге:
df_моложе_30_в_москве_или_спб = df[(df['Возраст'] < 30) & (df['Город'].isin(['Москва', 'Санкт-Петербург']))] print(df_моложе_30_в_москве_или_спб)
Использование метода isin() полезно, когда необходимо отфильтровать строки по множеству значений, например, по списку городов.
Удаление дубликатов строк в датафрейме
Пример простого удаления дубликатов:
import pandas as pd
# Создание датафрейма
data = {'A': [1, 2, 2, 3, 4, 4],
'B': ['a', 'b', 'b', 'c', 'd', 'd']}
df = pd.DataFrame(data)
# Удаление дубликатов
df_cleaned = df.drop_duplicates()
print(df_cleaned)
По умолчанию метод удаляет все дубликаты, оставляя только первое вхождение. Если необходимо удалить дубликаты, оставляя последнее вхождение, можно использовать параметр keep='last':
df_cleaned = df.drop_duplicates(keep='last')
print(df_cleaned)
Для удаления дубликатов по определённым столбцам можно передать список столбцов в параметр subset:
df_cleaned = df.drop_duplicates(subset=['A'])
print(df_cleaned)
Если требуется удалить все дубликаты, включая те, которые имеют одинаковые значения в отдельных столбцах, используйте subset с нужным набором столбцов.
Кроме того, метод drop_duplicates() позволяет изменять оригинальный датафрейм, если установить параметр inplace=True. Это полезно, если не требуется создавать новый объект:
df.drop_duplicates(inplace=True)
Метод drop_duplicates() также позволяет учитывать или игнорировать NaN значения. Для этого используйте параметр ignore_index=True при необходимости перезаписать индексы после удаления дубликатов.
Как удалить строки по маске с использованием метода .loc
Метод .loc в pandas позволяет фильтровать данные и изменять DataFrame с помощью масок. Для удаления строк по маске, можно использовать логическое условие внутри .loc, передав в него обратную выборку.
Пример 1: Удаление строк, где значения в столбце 'age' больше 30.
import pandas as pd
data = {'name': ['Anna', 'Ivan', 'Maria', 'Petr'],
'age': [25, 35, 28, 40]}
df = pd.DataFrame(data)
# Создание маски для строк, где возраст меньше или равен 30
mask = df['age'] <= 30
# Удаление строк по маске
df = df.loc[mask]
print(df)
В этом примере создается маска, которая выбирает только те строки, где значение в столбце 'age' меньше или равно 30. Важно, что метод .loc не изменяет DataFrame на месте, а возвращает новый DataFrame, удовлетворяющий условию.
Пример 2: Удаление строк с пропущенными значениями в столбце 'age'.
import pandas as pd
import numpy as np
data = {'name': ['Anna', 'Ivan', 'Maria', 'Petr'],
'age': [25, np.nan, 28, np.nan]}
df = pd.DataFrame(data)
# Маска для строк без пропущенных значений в столбце 'age'
mask = df['age'].notna()
# Применение маски
df = df.loc[mask]
print(df)
В данном примере маска .notna() выбирает строки, где в столбце 'age' нет пропущенных значений. В результате удаляются строки с NaN в этом столбце.
Важно отметить, что при удалении строк с помощью маски, вы можете сохранять DataFrame только с нужными данными, избегая манипуляций с лишними строками.
Удаление строк на основе регулярных выражений в столбцах
Для удаления строк в датафрейме на основе регулярных выражений в столбцах можно использовать метод str.contains(), который позволяет фильтровать данные с помощью паттернов регулярных выражений.
Пример удаления строк, содержащих заданное регулярное выражение в одном из столбцов:
import pandas as pd
# Пример датафрейма
data = {'Название': ['apple', 'banana', 'cherry', 'date'],
'Цена': [5, 7, 6, 4]}
df = pd.DataFrame(data)
# Удаление строк, где в столбце 'Название' содержится буква 'a'
df = df[~df['Название'].str.contains('a')]
print(df)
Результат выполнения кода:
Название Цена
1 banana 7
2 cherry 6
В приведённом примере строки, в которых столбец "Название" содержит букву "a", удаляются. Оператор ~ используется для инверсии результата, чтобы оставить строки, не удовлетворяющие регулярному выражению.
Для более сложных паттернов можно использовать флаг regex=True. Например, для поиска строк, содержащих несколько символов или определённую последовательность:
# Удаление строк, содержащих числа в столбце 'Название'
df = df[~df['Название'].str.contains(r'\d', regex=True)]
print(df)
Этот код удаляет все строки, где в столбце "Название" содержатся цифры.
Регулярные выражения могут включать различные конструкции, такие как:
\d– любая цифра.\w– любая буква или цифра.\s– пробельный символ.^– начало строки.$– конец строки.
Метод str.contains() также позволяет учитывать или игнорировать регистр с помощью флага case:
# Удаление строк с учётом регистра
df = df[~df['Название'].str.contains('banana', case=True)]
Этот код удаляет строки, в которых точно содержится "banana". Если установить case=False, поиск будет регистронезависимым.
Если нужно удалить строки, где в столбце встречается несколько регулярных выражений, можно комбинировать паттерны с использованием логических операторов:
# Удаление строк, где встречаются либо 'apple', либо 'banana'
df = df[~df['Название'].str.contains('apple|banana', regex=True)]
Такой подход позволяет фильтровать строки на основе нескольких условий одновременно.
Загрузка...
