Pandas удалить столбец: pandas — Удалить / удалить строки из DataFrame
Работа с недостающими данными в Pandas
Отсутствие данных может произойти, если не предоставлена информация для одного или нескольких элементов или для целого блока. Недостающие данные — очень большая проблема в реальной жизни. Отсутствующие данные могут также называться значениями NA
(не доступно) в пандах. В DataFrame иногда многие наборы данных просто поступают с отсутствующими данными, потому что они существуют и не были собраны или никогда не существовали. Например, предположим, что другой опрашиваемый пользователь может не делиться своим доходом, а другой пользователь может не указывать адрес таким образом, что многие наборы данных пропали без вести.
В Пандах отсутствующие данные представлены двумя значениями:
- None: None — это одноэлементный объект Python, который часто используется для пропущенных данных в коде Python.
- NaN: NaN (сокращение от Not a Number) — это специальное значение с плавающей точкой, распознаваемое всеми системами, которые используют стандартное представление IEEE с плавающей точкой.
Панды считают None
и NaN
по существу взаимозаменяемыми для указания отсутствующих или нулевых значений. Чтобы облегчить это соглашение, в Pandas DataFrame есть несколько полезных функций для обнаружения, удаления и замены пустых значений:
В этой статье мы используем CSV-файл, чтобы загрузить используемый CSV-файл, нажмите здесь .
Проверка пропущенных значений с помощью isnull()
и notnull()
Для проверки отсутствующих значений в Pandas DataFrame мы используем функцию isnull()
и notnull()
. Обе функции помогают проверить, является ли значение NaN
или нет. Эти функции также можно использовать в серии Pandas, чтобы найти нулевые значения в серии.
Проверка пропущенных значений с помощью isnull()
Чтобы проверить нулевые значения в Pandas DataFrame, мы используем isnull()
эта функция возвращает фрейм данных с логическими значениями, равными True для значений NaN.
Код № 1:
|
Выход:
Код № 2:
|
Выход:
Как показано на выходном изображении, отображаются только строки, имеющие Gender = NULL
.
Проверка пропущенных значений с использованием notnull()
Чтобы проверить нулевые значения в Pandas Dataframe, мы используем функцию notnull (), эта функция возвращает фрейм данных с логическими значениями, которые являются False для значений NaN.
Код № 3:
|
Выход:
Код № 4:
|
Выход:
Как показано на выходном изображении, отображаются только строки, имеющие Gender = NOT NULL
.
Заполнение пропущенных значений с помощью fillna()
, replace()
и interpolate()
Чтобы заполнить нулевые значения в наборах данных, мы используем fillna()
, replace()
и interpolate()
эти функции заменяют значения NaN некоторым собственным значением. Все эти функции помогают заполнять нулевые значения в наборах данных DataFrame. Функция Interpolate () в основном используется для заполнения значений NA
в кадре данных, но она использует различные методы интерполяции для заполнения отсутствующих значений, а не жесткое кодирование значения.
Код № 1: заполнение нулевых значений одним значением
|
Выход:
Код № 2: заполнение нулевых значений предыдущими
|
Выход:
Код № 3: заполнение нулевого значения следующими
|
Выход:
Код № 4: заполнение нулевых значений в файле CSV
|
Теперь мы собираемся заполнить все нулевые значения в столбце «Пол» «Нет пола»
|
Выход:
Код № 5: Заполнение нулевых значений методом replace ()
|
Выход:
Теперь мы собираемся заменить все значения Nan во фрейме данных значением -99.
|
Выход:
Код № 6: Использование функции interpolate () для заполнения пропущенных значений линейным методом.
|
Давайте интерполируем пропущенные значения, используя линейный метод. Обратите внимание, что линейный метод игнорирует индекс и обрабатывает значения как одинаково расположенные.
|
Выход:
Как мы видим на выходе, значения в первой строке не могут быть заполнены, так как направление заполнения значений является прямым, и нет предыдущего значения, которое могло бы использоваться при интерполяции.
Удаление пропущенных значений с помощью dropna()
Чтобы удалить нулевые значения из фрейма данных, мы использовали dropna()
эта функция по- dropna()
строки / столбцы наборов данных со значениями Null.
Код № 1: удаление строк с как минимум 1 нулевым значением.
|
Теперь мы отбрасываем строки как минимум с одним значением Nan (нулевое значение)
|
Выход:
Код № 2: Удаление строк, если все значения в этой строке отсутствуют.
|
Теперь мы отбрасываем строки, в которых все данные отсутствуют или содержат нулевые значения (NaN).
|
Выход:
Код № 3: удаление столбцов с как минимум 1 нулевым значением.
|
Теперь мы отбрасываем столбцы, которые имеют по крайней мере 1 пропущенных значений
|
Выход :
Код № 4: удаление строк с как минимум 1 нулевым значением в файле CSV
|
Выход:
Теперь мы сравним размеры фреймов данных, чтобы мы могли узнать, сколько строк имеют хотя бы 1 пустое значение
|
Выход :
Old data frame length: 1000 New data frame length: 764 Number of rows with at least 1 NA value: 236
Поскольку разница составляет 236, в любом столбце было 236 строк, которые имели по крайней мере 1 пустое значение.
Рекомендуемые посты:
Работа с недостающими данными в Pandas
0.00 (0%) 0 votes
Удаление нескольких столбцов на основе имен столбцов в Pandas
у меня есть некоторые данные, и когда я импортирую его, я получаю следующие ненужные столбцы, которые я ищу простой способ удалить все эти
'Unnamed: 24', 'Unnamed: 25', 'Unnamed: 26', 'Unnamed: 27',
'Unnamed: 28', 'Unnamed: 29', 'Unnamed: 30', 'Unnamed: 31',
'Unnamed: 32', 'Unnamed: 33', 'Unnamed: 34', 'Unnamed: 35',
'Unnamed: 36', 'Unnamed: 37', 'Unnamed: 38', 'Unnamed: 39',
'Unnamed: 40', 'Unnamed: 41', 'Unnamed: 42', 'Unnamed: 43',
'Unnamed: 44', 'Unnamed: 45', 'Unnamed: 46', 'Unnamed: 47',
'Unnamed: 48', 'Unnamed: 49', 'Unnamed: 50', 'Unnamed: 51',
'Unnamed: 52', 'Unnamed: 53', 'Unnamed: 54', 'Unnamed: 55',
'Unnamed: 56', 'Unnamed: 57', 'Unnamed: 58', 'Unnamed: 59',
'Unnamed: 60'
они индексируются 0-индексированием, поэтому я попробовал что-то вроде
df.drop(df.columns[[22, 23, 24, 25,
26, 27, 28, 29, 30, 31, 32 ,55]], axis=1, inplace=True)
но это не очень эффективно. Я попытался написать некоторые для циклов, но это поразило меня как плохое поведение панд. Поэтому я задаю вопрос здесь.
Я видел некоторые примеры, которые похожи (падение нескольких столбцов панды), но это не ответ на мой вопрос.
Я не знаю, что вы подразумеваете под неэффективным, но если вы имеете в виду с точки зрения ввода, может быть проще просто выбрать интересующие cols и назначить обратно в df:
df = df[cols_of_interest]
здесь cols_of_interest
— Это список столбцов, о которых вы заботитесь.
или вы можете нарезать столбцы и передать это в drop
:
df.drop(df.ix[:,'Unnamed: 24':'Unnamed: 60'].head(0).columns, axis=1)
вызов head
просто выбирает 0 строк, поскольку нас интересуют только имена столбцов, а не данные
обновление
другим методом было бы проще использовать булеву маску из str.contains
и инвертировать его, чтобы замаскировать столбцы:
In [2]:
df = pd.DataFrame(columns=['a','Unnamed: 1', 'Unnamed: 1','foo'])
df
Out[2]:
Empty DataFrame
Columns: [a, Unnamed: 1, Unnamed: 1, foo]
Index: []
In [4]:
~df.columns.str.contains('Unnamed:')
Out[4]:
array([ True, False, False, True], dtype=bool)
In [5]:
df[df.columns[~df.columns.str.contains('Unnamed:')]]
Out[5]:
Empty DataFrame
Columns: [a, foo]
Index: []
5 Полезных функций Python Pandas для Data Science
Содержание страницы
В повседневной обработке данных для проектов машинного обучения и data science библиотека Python Pandas является одной из наиболее часто используемых.
shift() — функция Python Pandas
Предположим, вы столкнулись с ситуацией, когда вам нужно сместить все строки в DataFrame или использовать цену акций предыдущего дня в DataFrame. Может быть, мы хотим построить среднюю температуру за последние три дня в наборе данных.
Shift() будет идеальным способом для достижения всех этих целей.
Функция Pandas Shift(), сдвигает индекс на желаемое количество периодов. Эта функция принимает скалярный параметр, называемый периодом, который представляет количество сдвигов для желаемой оси. Эта функция полезна при работе с данными временных рядов. Мы можем использовать fill_value для заполнения за пределами граничных значений.
import pandas as pd import numpy as np df = pd.DataFrame({'DATE': [1, 2, 3, 4, 5], 'VOLUME': [100, 200, 300,400,500], 'PRICE': [214, 234, 253,272,291]}) print(df) ===РЕЗУЛЬТАТ=== DATE VOLUME PRICE 0 1 100 214 1 2 200 234 2 3 300 253 3 4 400 272 4 5 500 291 print(df.shift(1)) ===РЕЗУЛЬТАТ=== DATE VOLUME PRICE 0 NaN NaN NaN 1 1.0 100.0 214.0 2 2.0 200.0 234.0 3 3.0 300.0 253.0 4 4.0 400.0 272.0 # with fill_Value = 0 print(df.shift(1,fill_value=0)) ===РЕЗУЛЬТАТ=== DATE VOLUME PRICE 0 0 0 0 1 1 100 214 2 2 200 234 3 3 300 253 4 4 400 272
Теперь, если нам нужно получить цену акций предыдущего дня в виде нового столбца, мы можем использовать сдвиг с помощью функции shift():
df['PREV_DAY_PRICE'] = df['PRICE'].shift(1,fill_value=0) print(df) ===Результат=== DATE VOLUME PRICE PREV_DAY_PRICE 0 1 100 214 0 1 2 200 234 214 2 3 300 253 234 3 4 400 272 253 4 5 500 291 272
Мы можем легко рассчитать среднюю цену акций за последние три дня, как показано ниже, и создать новый столбец функций.
df['LAST_3_DAYS_AVE_PRICE'] = (df['PRICE'].shift(1,fill_value=0) + df['PRICE'].shift(2,fill_value=0) + df['PRICE'].shift(3,fill_value=0))/3
Теперь DataFrame станет таким:
DATE VOLUME PRICE LAST_3_DAYS_AVE_PRICE 0 1 100 214 0.000000 1 2 200 234 71.333333 2 3 300 253 149.333333 3 4 400 272 233.666667 4 5 500 291 253.000000
Мы также можем сдвигаться вперед, чтобы получить значение из следующего временного периода или следующего значения в ряду (не обязательно это должен быть период).
df['TOMORROW_PRICE'] = df['PRICE'].shift(-1,fill_value=0)
Теперь фрейм данных будет:
DATE VOLUME PRICE TOMORROW_PRICE 0 1 100 214 234 1 2 200 234 253 2 3 300 253 272 3 4 400 272 291 4 5 500 291 0
Более подробную информацию о параметрах и других настройках см. в документации Pandas.
value_counts() — функция Python Pandas
Функция Pandas value_counts() возвращает объект, содержащий количество уникальных значений. Полученный объект можно отсортировать в порядке убывания или в порядке возрастания, включить NA или исключить NA посредством управления параметрами. Эта функция может использоваться с индексами в DataFrames или Pandas Series.
a = pd.Index([3,3,4,2,1,3, 1, 2, 3, 4, np.nan,4,6,7]) print(a.value_counts()) ===РЕЗУЛЬТАТ=== 3.0 4 4.0 3 1.0 2 2.0 2 7.0 1 6.0 1 dtype: int64
Ниже приведен пример Series.
#In b = pd.Series(['ab','bc','cd',1,'cd','cd','bc','ab','bc',1,2,3,2,3,np.nan,1,np.nan]) b.value_counts() #Out bc 3 cd 3 1 3 3 2 ab 2 2 2 dtype: int64
Опция Bin может использоваться вместо подсчета уникальных значений значений, разделив индекс на указанное количество полуоткрытых Bins.
#In a = pd.Index([3,3,4,2,1,3, 1, 2, 3, 4, np.nan,4,6,7]) a.value_counts(bins=4) #Out (2.5, 4.0] 7 (0.993, 2.5] 4 (5.5, 7.0] 2 (4.0, 5.5] 0 dtype: int64
Более подробную информацию о параметрах и других настройках см. в документации Pandas.
mask() — функция Python Pandas
Метод mask() является применением условия if-then для каждого элемента Series или DataFrame. Если Condition равно True, тогда он использует значение из Other (значение по умолчанию — NaN), в противном случае будет сохранено исходное значение. Этот метод mask() очень похож на where().
Ниже приведен DataFrame, в котором мы хотим изменить знак всех элементов, которые делятся на два без остатка.
Этого легко можно достигнуть с помощью функции mask():
df = pd.DataFrame(np.arange(15).reshape(-1, 3), columns=['A', 'B','C']) print(df) #Out A B C 0 0 1 2 1 3 4 5 2 6 7 8 3 9 10 11 4 12 13 14 #mask operation to check if element is divided by 2 without any remainder. If match change the sign of the element as original df.mask(df % 2 == 0,-df) #Out A B C 0 0 1 -2 1 3 -4 5 2 -6 7 -8 3 9 -10 11 4 -12 13 -14
Более подробную информацию о параметрах и других настройках см. в документации Pandas mask.
nlargest() — функция Python Pandas
Во многих случаях мы сталкиваемся с ситуациями, когда нам нужно найти 3 верхних (top) или 5 нижних (bottom) значений для Series или DataFrame (например, трех лучших учеников с самыми высокими показателями с их совокупным баллом или трех худших кандидатов с общим количеством голосов, полученных на выборах).
Функции Python Pandas nlargest() и nsmallest() — лучший способ для такой обработки данных.
В приведенном ниже примере показаны три самых больших значения из DataFrame из 10 наблюдений.
import pandas as pd import numpy as np df = pd.DataFrame({'HEIGHT': [170,78,99,160,160,130,155,70,70,20], 'WEIGHT': [50,60,70,80,90,90,90,50,60,70]}, index=['A','B','C','D','E','F','G','H','I','J']) print(df) HEIGHT WEIGHT A 170 50 B 78 60 C 99 70 D 160 80 E 160 90 F 130 90 G 155 90 H 70 50 I 70 60 J 20 70 dfl = df.nlargest(3,'HEIGHT') print(dfl) HEIGHT WEIGHT A 170 50 D 160 80 E 160 90
Если есть связь, то есть несколько вариантов, которые можно разрешить с помощью «first», «last», «all» (по умолчанию «first»). Сохраняйте все случаи. Мы попытаемся найти две самые большие высоты в примерах ниже.
dfl = df.nlargest(2,'HEIGHT',keep='all') print(dfl) HEIGHT WEIGHT A 170 50 D 160 80 E 160 90
Сохраните последнее вхождение.
dfl = df.nlargest(2,'HEIGHT',keep='last') print(dfl) HEIGHT WEIGHT A 170 50 E 160 90
Сохраните первое вхождение.
dfl = df.nlargest(2,'HEIGHT',keep='first') print(dfl) HEIGHT WEIGHT A 170 50 D 160 80
Более подробную информацию о параметрах и других настройках см. в документации Pandas nlargest().
nsmallest() — функция Python Pandas
nsmallest() также работает аналогичным образом, но с учетом самого маленького фильтра. Обратитесь к примеру ниже, в котором осуществляется поиск двух наименьших веса.
import pandas as pd import numpy as np df = pd.DataFrame({'HEIGHT': [170,78,99,160,160,130,155,70,70,20], 'WEIGHT': [50,60,70,80,90,90,90,50,60,70]}, index=['A','B','C','D','E','F','G','H','I','J']) print(df) HEIGHT WEIGHT A 170 50 B 78 60 C 99 70 D 160 80 E 160 90 F 130 90 G 155 90 H 70 50 I 70 60 J 20 70 dfs = df.nsmallest(3,'WEIGHT') print(dfs) HEIGHT WEIGHT A 170 50 H 70 50 B 78 60
Более подробную информацию о параметрах и других настройках см. в документации Pandas nsmallest.
5
2
голоса
Рейтинг статьи
Навигация по записям
Использование Pandas для изучения вашего набора данных
Подписывайся на наш канал в Telegram, чтобы ежедневно совершенствоваться в Python. Там выходят задачи, полезные советы и сливы платных курсов — перейти
Оглавление
- Настройка вашей среды
- Использование библиотеки Pandas
- Знакомство с вашими данными
- Отображение типов данных
- Отображение базовой статистики
- Изучение вашего набора данных
- Знакомство со структурами данных Pandas
- Понимание объектов серии
- Понимание объектов DataFrame
- Доступ к элементам серии
- Использование оператора индексации
- Использование .loc и .iloc
- Доступ к элементам DataFrame
- Использование оператора индексации
- Использование .loc и .iloc
- Запрос вашего набора данных
- Группировка и агрегация ваших данных
- Манипуляции с колоннами
- Указание типов данных
- Очистка данных
- Недостающие значения
- Неверные значения
- Несоответствующие значения
- Объединение нескольких наборов данных
- Визуализация вашей Pandas DataFrame
- Вывод
У вас есть большой набор данных, который полон интересных идей, но вы не знаете с чего начать? Ваш начальник попросил вас сгенерировать некоторую статистику из него, но ее не так просто извлечь? Это именно те случаи, когда Pandas и Python могут вам помочь! С помощью этих инструментов вы сможете разрезать большой набор данных на управляемые части и получить представление об этой информации.
В этом уроке вы узнаете, как:
- Рассчитать метрики о ваших данных
- Выполнять основные запросы и агрегации
- Обнаруживать и обрабатывать неверные данные, несоответствия и пропущенные значения
- Визуализировать свои данные с графиками
Вы также узнаете о различиях между основными структурами данных, которые используют Pandas и Python.
Настройка вашей среды
Есть несколько вещей, которые вам понадобятся, чтобы начать работу с этим руководством. Во-первых, знакомство со встроенными структурами данных Python, особенно списками и словарями . Для получения дополнительной информации, проверьте списки и кортежи в Python и словари в Python .
Еще, что вам нужно, это библиотека Pandas, которую вы можете установить с помощью pip :
$ python -m pip install pandas
Вы также можете использовать менеджер пакетов Conda :
$ conda install pandas
Если вы используете дистрибутив Anaconda , тогда вам не нужно никаких дополнительных действий! Anaconda уже поставляется с установленной библиотекой Pandas.
Примеры в этом руководстве были протестированы с Python 3.7 и Pandas 0.25.0, но они также должны работать в более старых версиях.
Давайте начнем!
Использование библиотеки Pandas
Теперь, когда вы установили Pandas, пришло время взглянуть на набор данных. В этом руководстве вы проанализируете результаты NBA, предоставленные FiveThirtyEight, в файле CSV размером 17 МБ . Создайте скрипт download_nba_all_elo.py
для загрузки данных:
import requests
download_url = "https://raw.githubusercontent.com/fivethirtyeight/data/master/nba-elo/nbaallelo.csv"
target_csv_path = "nba_all_elo.csv"
response = requests.get(download_url)
response.raise_for_status() # Check that the request was successful
with open(target_csv_path, "wb") as f:
f.write(response.content)
print("Download ready.")
Когда вы выполните скрипт, он сохранит файл nba_all_elo.csv
в вашем текущем рабочем каталоге.
Примечание. Вы также можете использовать веб-браузер для загрузки файла CSV.
Однако наличие варианта загрузки имеет несколько преимуществ:
- Вы можете сообщить, где вы получили свои данные.
- Вы можете повторить загрузку в любое время! Это особенно удобно, если данные часто обновляются.
- Вам не нужно делиться файлом CSV размером 17 МБ с вашими коллегами. Обычно достаточно поделиться скриптом загрузки.
Теперь вы можете использовать библиотеку Pandas для просмотра ваших данных:
>>> import pandas as pd
>>> nba = pd.read_csv("nba_all_elo.csv")
>>> type(nba)
<class 'pandas.core.frame.DataFrame'>
Здесь вы следуете соглашению об импорте Pandas в Python с pd
псевдонимом. Затем вы используете .read_csv()
для чтения в вашем наборе данных и сохранить его как DataFrame
объект в переменной nba
.
Примечание. Ваши данные не в формате CSV? Не беспокойтесь! Библиотека Pandas предоставляет несколько аналогичных функций , таких как read_json()
, read_html()
и read_sql_table()
. Чтобы узнать, как работать с этими форматами файлов, ознакомьтесь с разделом Чтение и запись файлов с помощью Pandas или обратитесь к документации .
Вы можете увидеть, сколько данных nba
содержит:
>>> len(nba)
126314
>>> nba.shape
(126314, 23)
Вы используете встроенную функцию Python len()
для определения количества строк. Вы также используете .shape
атрибут, DataFrame
чтобы увидеть его размерность . Результатом является кортеж, содержащий количество строк и столбцов.
Теперь вы знаете, что в вашем наборе данных 126 314 строк и 23 столбца. Но как вы можете быть уверены, что набор данных действительно содержит статистику баскетбола? Вы можете взглянуть на первые пять строк .head()
:
>>> nba.head()
Если вы используете Jupyter, вы увидите такой результат:
Если ваш экран не очень большой, ваш вывод, вероятно, не будет отображать все 23 столбца. Где-то посередине вы увидите столбец с эллипсами ( ...
), указывающий на отсутствующие данные. Вы можете настроить Pandas для отображения всех 23 столбцов следующим образом:
>>> pd.set_option("display.max.columns", None)
Несмотря на то, что все столбцы видны, вам, вероятно, не понадобится шесть десятичных знаков! Измените на два:
>>> pd.set_option("display.precision", 2)
Чтобы убедиться, что вы успешно изменили параметры, вы можете выполнить .head()
снова или вы можете отобразить последние пять строк .tail()
:
>>> nba.tail()
Теперь вы должны увидеть все столбцы, и ваши данные должны показать два десятичных знака:
Вы можете открыть некоторые дополнительные возможности .head()
и .tail()
с помощью небольшого упражнения. Можете ли вы напечатать последние три строки вашего DataFrame
? Ниже решение:
Вот как распечатать последние три строки nba
:
>>> nba.tail(3)
Ваш вывод должен выглядеть примерно так:
Вы можете видеть последние три строки вашего набора данных с опциями, которые вы установили выше.
Подобно стандартной библиотеке Python, функции в Pandas также имеют несколько необязательных параметров. Всякий раз, когда вы сталкиваетесь с примером, который выглядит актуально, но немного отличается от вашего варианта использования, ознакомьтесь с официальной документацией . Скорее всего, вы найдете решение, настроив некоторые дополнительные параметры!
Знакомство с вашими данными
Вы импортировали файл CSV с библиотекой Pandas Python и впервые просмотрели содержимое вашего набора данных. До сих пор вы видели только размер вашего набора данных и его первые и последние несколько строк. Далее вы узнаете, как более систематически проверять ваши данные .
Отображение типов данных
Первым шагом в ознакомлении с вашими данными является обнаружение различных типов данных, которые они содержат. Хотя вы можете поместить что-либо в список, столбцы DataFrame
содержат значения определенного типа данных. Когда вы сравните структуры данных Pandas и Python, вы увидите, что такое поведение делает Pandas намного быстрее!
Вы можете отобразить все столбцы и их типы данных с помощью .info()
:
>>> nba.info()
Это даст следующий результат:
Вы увидите список всех столбцов в вашем наборе данных и тип данных, содержащихся в каждом столбце. Здесь вы можете увидеть типы данных int64
, float64
и object
. Pandas использует библиотеку NumPy для работы с этими типами. Позже вы познакомитесь с более сложным categorical
типом данных, которого реализует библиотека Pandas.
Тип данных object
является «универсальным для столбцов, которые Pandas не распознает как какой-либо другой конкретный тип». На практике это часто означает, что все значения в столбце являются строками.
Хотя вы можете хранить произвольные объекты Python в object
типе данных, вы должны знать о недостатках этого. Странные значения в object
столбце могут нанести ущерб производительности Pandas и ее совместимости с другими библиотеками. Для получения дополнительной информации ознакомьтесь с официальным руководством по началу работы .
Отображение базовой статистики
Теперь, когда вы увидели, какие типы данных содержатся в вашем наборе данных, пришло время получить обзор значений, содержащихся в каждом столбце. Вы можете сделать это с .describe()
:
>>> nba.describe()
Эта функция показывает некоторую базовую описательную статистику для всех числовых столбцов:
.describe()
по умолчанию анализируются только числовые столбцы, но вы можете указать другие типы данных, если используете include
параметр:>>>
>>> import numpy as np
>>> nba.describe(include=np.object)
.describe()
не будет пытаться вычислить среднее или стандартное отклонение для object
столбцов, поскольку они в основном содержат текстовые строки. Тем не менее, он все равно будет отображать некоторую статистику:
Взгляните на team_id
и fran_id
столбцы. Ваш набор данных содержит 104 различных идентификатора команды, но только 53 различных идентификатора франшизы. Кроме того, самый частый идентификатор команды это BOS
, но самый частый идентификатор франшизы это Lakers
. Как это возможно? Вам нужно будет изучить свой набор данных немного больше, чтобы ответить на этот вопрос.
Изучение вашего набора данных
Исследовательский анализ данных может помочь вам ответить на вопросы о вашем наборе данных. Например, вы можете проверить, как часто конкретные значения встречаются в столбце:
>>> nba["team_id"].value_counts()
BOS 5997
NYK 5769
LAL 5078
...
SDS 11
>>> nba["fran_id"].value_counts()
Name: team_id, Length: 104, dtype: int64
Lakers 6024
Celtics 5997
Knicks 5769
...
Huskies 60
Name: fran_id, dtype: int64
Кажется, что названная команда "Lakers"
сыграла 6024 игры, но только 5078 из них были сыграны Лос-Анджелес Лейкерс. Узнайте, кто другая "Lakers"
команда:>>>
>>> nba.loc[nba["fran_id"] == "Lakers", "team_id"].value_counts()
LAL 5078
MNL 946
Name: team_id, dtype: int64
Действительно, Миннеаполис Лейкерс ( "MNL"
) сыграли 946 игр. Вы даже можете узнать, когда они играли в эти игры:>>>
>>> nba.loc[nba["team_id"] == "MNL", "date_game"].min()
'1/1/1949'
>>> nba.loc[nba["team_id"] == "MNL", "date_game"].max()
'4/9/1959'
>>> nba.loc[nba["team_id"] == "MNL", "date_game"].agg(("min", "max"))
min 1/1/1949
max 4/9/1959
Name: date_game, dtype: object
Вы узнали, почему команда Boston Celtics "BOS"
сыграла больше всего игр в наборе данных. Давайте немного разберем их историю. Узнайте, сколько очков набрали Boston Celtics за все матчи, содержащиеся в этом наборе данных. Решение:
Аналогично агрегатам функций .min()
и .max()
, вы также можете использовать .sum()
:>>>
>>> nba.loc[nba["team_id"] == "BOS", "pts"].sum()
626484
Бостон Селтикс набрал в общей сложности 626,484 балла.
В следующих разделах вы лучше узнаете методы, которые вы только что использовали, но сначала вы увеличите масштаб и узнаете, как работает эта мощная структура данных.
Знакомство со структурами данных Pandas
В то время как DataFrame
предоставляет функции, которые могут казаться довольно интуитивными, базовые концепции немного сложнее понять. По этой причине вы отложите в сторону огромный NBA DataFrame
и создадите несколько небольших объектов Pandas с нуля.
Понимание объектов серии
Основная структура данных Python – это список , который также является хорошей отправной точкой для знакомства с pandas.Series
объектами. Создайте новый Series
объект на основе списка:
>>> revenues = pd.Series([5555, 7000, 1980])
>>> revenues
0 5555
1 7000
2 1980
dtype: int64
Вы использовали список [5555, 7000, 1980]
для создания Series
объекта с именем revenues
. Series
объект состоит из двух компонентов:
- Последовательность значений
- Последовательность идентификаторов, которые являются индексом
Вы можете получить доступ к этим компонентам с .values
и .index
, соответственно:
>>> revenues.values
array([5555, 7000, 1980])
>>> revenues.index
RangeIndex(start=0, stop=3, step=1)
revenues.values
возвращает значения в Series
, тогда как revenues.index
возвращает позиционный индекс.
Примечание. Если вы знакомы с NumPy , вам может быть интересно отметить, что значения Series
объекта на самом деле являются n-мерными массивами:
>>> type(revenues.values)
<class 'numpy.ndarray'>
Если вы не знакомы с NumPy, вам не о чем беспокоиться! Вы можете исследовать все входы и выходы своего набора данных с помощью библиотеки Pandas.
Хотя Pandas опирается на NumPy, существенная разница заключается в их индексации . Как и массив NumPy, у Pandas Series
также есть целочисленный индекс, который неявно определен. Этот неявный индекс указывает положение элемента в Series
.
Однако, у Series
также может быть произвольный тип индекса. Вы можете думать об этом явном индексе как о метках для конкретной строки:
>>> city_revenues = pd.Series(
... [4200, 8000, 6500],
... index=["Amsterdam", "Toronto", "Tokyo"]
... )
>>> city_revenues
Amsterdam 4200
Toronto 8000
Tokyo 6500
dtype: int64
Здесь индекс представляет собой список названий городов, представленных строками. Возможно, вы заметили, что в словарях Python также используются строковые индексы, и это полезная аналогия, о которой следует помнить! Вы можете использовать блоки кода выше, чтобы различать два типа Series
:
revenues
:Series
ведет себя как список Python , потому что он имеет только позиционное индекс.city_revenues
:Series
действует как словарь Python, потому что он имеет позиционный и меточный индекс.
Вот как создать индекс Series
с меткой из словаря Python:>>>
>>> city_employee_count = pd.Series({"Amsterdam": 5, "Tokyo": 8})
>>> city_employee_count
Amsterdam 5
Tokyo 8
dtype: int64
Ключи словаря становятся индексом, а значения словаря являются Series
значениями.
Так же, как словари, Series
, поддерживает ключевые слова .keys()
и in
:
>>> city_employee_count.keys()
Index(['Amsterdam', 'Tokyo'], dtype='object')
>>> "Tokyo" in city_employee_count
True
>>> "New York" in city_employee_count
False
Вы можете использовать эти методы, чтобы быстро ответить на вопросы о вашем наборе данных.
Понимание объектов DataFrame
Хотя Series
является довольно мощной структурой данных, она имеет свои ограничения. Например, вы можете хранить только один атрибут на ключ. Как вы видели с nba
набором данных, который содержит 23 столбца, библиотека Pandas может предложить больше со своим DataFrame
. Эта структура данных представляет собой последовательность Series
объектов, имеющих общий индекс.
Если вы следовали Series
примерам, то у вас уже должны быть два Series
объекта с городами в качестве ключей:
city_revenues
city_employee_count
Вы можете объединить эти объекты в DataFrame
, предоставив словарь в конструкторе. Ключи словаря станут именами столбцов, а значения должны содержать Series
объекты:
>>> city_data = pd.DataFrame({
... "revenue": city_revenues,
... "employee_count": city_employee_count
... })
>>> city_data
revenue employee_count
Amsterdam 4200 5.0
Tokyo 6500 8.0
Toronto 8000 NaN
Обратите внимание, как Pandas заменила недостающее employee_count
значение для Торонто NaN
.
Новый DataFrame
индекс представляет собой объединение двух Series
индексов:
>>> city_data.index
Index(['Amsterdam', 'Tokyo', 'Toronto'], dtype='object')
Как и Series
, DataFrame
также хранит свои значения в массиве NumPy:
>>> city_data.values
array([[4.2e+03, 5.0e+00],
[6.5e+03, 8.0e+00],
[8.0e+03, nan]])
Вы также можете сослаться как на 2 измерения оси DataFrame
:
>>> city_data.axes
[Index(['Amsterdam', 'Tokyo', 'Toronto'], dtype='object'),
Index(['revenue', 'employee_count'], dtype='object')]
>>> city_data.axes[0]
Index(['Amsterdam', 'Tokyo', 'Toronto'], dtype='object')
>>> city_data.axes[1]
Index(['revenue', 'employee_count'], dtype='object')
Ось, отмеченная 0, является индексом строки , а ось, отмеченная 1, является индексом столбца . Эту терминологию важно знать, потому что вы столкнетесь с несколькими DataFrame
методами, которые принимают axis
параметр.
A DataFrame
также представляет собой словарную структуру данных, поэтому она также поддерживает .keys()
и in
. Однако для DataFrame
они относятся не к индексу, а к столбцам:
>>> city_data.keys()
Index(['revenue', 'employee_count'], dtype='object')
>>> "Amsterdam" in city_data
False
>>> "revenue" in city_data
True
Вы можете увидеть эти концепции в действии с большим набором данных NBA. Содержит ли он столбец с именем "points"
, или он был назван "pts"
? Чтобы ответить на этот вопрос, отобразите индекс и оси nba
набора данных, затем посмотрите ниже для решения:
Т.к вы не указали индекс столбца , когда вы читаете в файле CSV, Pandas было назначено RangeIndex
на DataFrame
:
>>> nba.index
RangeIndex(start=0, stop=126314, step=1)
nba
как и все DataFrame
объекты, имеет две оси:
>>> nba.axes
[RangeIndex(start=0, stop=126314, step=1),
Index(['gameorder', 'game_id', 'lg_id', '_iscopy', 'year_id', 'date_game',
'seasongame', 'is_playoffs', 'team_id', 'fran_id', 'pts', 'elo_i',
'elo_n', 'win_equiv', 'opp_id', 'opp_fran', 'opp_pts', 'opp_elo_i',
'opp_elo_n', 'game_location', 'game_result', 'forecast', 'notes'],
dtype='object')]
Вы можете проверить наличие столбца с помощью .keys()
:
>>> "points" in nba.keys()
False
>>> "pts" in nba.keys()
True
Колонка называется "pts"
, а не "points"
.
Поскольку вы используете эти методы для ответов на вопросы о вашем наборе данных, не забывайте, работаете ли вы с Series
или DataFrame
, чтобы ваша интерпретация была точной.
Доступ к элементам серии
В предыдущем разделе вы создали Pandas Series
на основе списка Python и сравнили две структуры данных. Вы видели, как Series
объект похож на списки и словари несколькими способами. Еще одно сходство в том, что вы также можете использовать оператор индексации ( []
) Series
.
Вы также узнаете, как использовать два специфичных для Pandas метода доступа:
.loc
.iloc
Вы увидите, что эти методы доступа к данным могут быть гораздо более удобочитаемыми, чем оператор индексации.
Использование оператора индексации
Напомним, что a Series
имеет два индекса:
- Позиционный или неявный индекс , который всегда
RangeIndex
- Метка или явный индекс , который может содержать любые хешируемые объекты
Затем снова посетите city_revenues
объект:
>>> city_revenues
Amsterdam 4200
Toronto 8000
Tokyo 6500
dtype: int64
Вы можете легко получить доступ к значениям в Series
как с меткой, так и с позиционными индексами:>>>
>>> city_revenues["Toronto"]
8000
>>> city_revenues[1]
8000
Вы также можете использовать отрицательные индексы и части, как если бы вы использовали список:
>>> city_revenues[-1]
6500
>>> city_revenues[1:]
Toronto 8000
Tokyo 6500
dtype: int64
>>> city_revenues["Toronto":]
Toronto 8000
Tokyo 6500
dtype: int64
Если вы хотите узнать больше о возможностях оператора индексации, посмотрите списки и кортежи в Python .
Использование .loc
и .iloc
Оператор индексирования ([]
) удобен, но есть предостережение. Что делать, если метки тоже цифры? Скажем, вам нужно работать с таким Series
объектом:
>>> colors = pd.Series(
... ["red", "purple", "blue", "green", "yellow"],
... index=[1, 2, 3, 5, 8]
... )
>>> colors
1 red
2 purple
3 blue
5 green
8 yellow
dtype: object
colors[1]
вернется? Для позиционного индекса colors[1]
есть "purple"
. Однако, если вы идете по индексу метки, то colors[1]
имеется в виду "red"
.
Хорошая новость в том, что вам не нужно это понимать! Вместо этого, чтобы избежать путаницы, библиотека Pandas предоставляет два метода доступа к данным:
.loc
относится к метке индекса ..iloc
относится к позиционному индексу .
Эти методы доступа к данным гораздо более читабельны:
>>> colors.loc[1]
'red'
>>> colors.iloc[1]
'purple'
colors.loc[1]
возвращает "red"
элемент с меткой 1
. А colors.iloc[1]
возвращает "purple"
элемент с индексом 1
.
На следующем рисунке показано, к каким элементам .loc
и .iloc
относятся:
Опять же, .loc
указывает на индекс метки в правой части изображения. Между тем, .iloc
указывает на позиционный индекс в левой части изображения.
Проще иметь в виду различие между .loc
и .iloc
чем выяснить, что вернет оператор индексации. Даже если вы знакомы со всеми особенностями оператора индексации, может быть опасно предполагать, что все, кто читает ваш код, также усвоили эти правила!
Примечание. В дополнение к тому, что с путаницей Series
с числовыми метками оператор индексации, Python имеет некоторые недостатки производительности . Совершенно нормально использовать его в интерактивных сессиях для специального анализа, но для производственного, кода предпочтительнее использовать методы доступа к данным .loc
и .iloc
.
.loc
и .iloc
также поддерживает функции, которые вы ожидаете от операторов индексирования, такие как нарезка. Однако эти методы доступа к данным имеют важное различие. Пока .iloc
исключает закрывающий элемент, .loc
включает его. Посмотрите на этот блок кода:
>>> # Return the elements with the implicit index: 1, 2
>>> colors.iloc[1:3]
2 purple
3 blue
dtype: object
Если сравнить этот код на картинке выше, то вы можете увидеть , что colors.iloc[1:3]
возвращает элементы с позиционными индексами от 1
и 2
. Закрывающая позиция "green"
с позиционным индексом 3
исключается.
С другой стороны, .loc
включает закрывающий элемент:
>>> # Return the elements with the explicit index between 3 and 8
>>> colors.loc[3:8]
3 blue
5 green
8 yellow
dtype: object
Этот блок кода говорит, чтобы вернуть все элементы с индексом метки между 3
и 8
. Здесь закрывающий элемент "yellow"
имеет индекс метки 8
и включен в выходные данные.
Вы также можете передать отрицательный позиционный индекс .iloc
:
>>> colors.iloc[-2]
'green'
Вы начинаете с конца Series
и возвращаете второй элемент.
Примечание. Раньше существовал .ix
индексатор, который пытался угадать, следует ли применять индексирование по позициям или по меткам в зависимости от типа данных индекса. Поскольку это вызвало много путаницы, оно устарело с версии 0.20.0 Pandas.
Настоятельно рекомендуется не использовать.ix
для индексации. Вместо этого всегда используйте .loc
для индексации меток и .iloc
позиционной индексации. Для получения более подробной информации обратитесь к Руководству пользователя Pandas .
Вы можете использовать блоки кода выше, чтобы различать два Series
поведения:
- Вы можете использовать
.iloc
поSeries
аналогии с использованием[]
в списке . - Вы можете использовать
.loc
поSeries
аналогии с использованием[]
в словаре .
Обязательно помните об этих различиях при доступе к элементам ваших Series
объектов.
Доступ к элементам DataFrame
Поскольку объект DataFrame
состоит из Series
объектов, вы можете использовать те же инструменты для доступа к его элементам. Важное отличие является дополнительным измерением из DataFrame
. Вы будете использовать оператор индексации для столбцов, методов доступа .loc
и .iloc
строк.
Использование оператора индексации
Если вы считаете DataFrame
словарь со значениями Series
, то имеет смысл получить доступ к его столбцам с помощью оператора индексации:
>>> city_data["revenue"]
Amsterdam 4200
Tokyo 6500
Toronto 8000
Name: revenue, dtype: int64
>>> type(city_data["revenue"])
pandas.core.series.Series
Здесь вы используете оператор индексирования для выбора столбца с меткой "revenue"
.
Если имя столбца является строкой, то вы также можете использовать доступ в стиле атрибутов с точечной нотацией:
>>> city_data.revenue
Amsterdam 4200
Tokyo 6500
Toronto 8000
Name: revenue, dtype: int64
city_data["revenue"]
и city_data.revenue
вернёт тот же вывод.
Есть одна ситуация, когда доступ к DataFrame
элементам с точечной нотацией может не работать или может привести к неожиданностям. Это когда имя столбца совпадает с именем DataFrame
атрибута или метода:
>>> toys = pd.DataFrame([
... {"name": "ball", "shape": "sphere"},
... {"name": "Rubik's cube", "shape": "cube"}
... ])
>>> toys["shape"]
0 sphere
1 cube
Name: shape, dtype: object
>>> toys.shape
(2, 2)
Операция индексирования toys["shape"]
возвращает правильные данные, но операция в стиле атрибутаtoys.shape
по- прежнему возвращает форму DataFrame
. Вы должны использовать доступ к атрибуту только в интерактивных сеансах или для операций чтения. Вы не должны использовать его для производственного кода или для манипулирования данными (например, для определения новых столбцов).
Использование .loc
и .iloc
Аналогично Series
, DataFrame
также предоставляет .loc
и .iloc
методы доступа к данным . Помните, .loc
использует метку а .iloc
позиционный индекс:>>>
>>> city_data.loc["Amsterdam"]
revenue 4200.0
employee_count 5.0
Name: Amsterdam, dtype: float64
>>> city_data.loc["Tokyo": "Toronto"]
revenue employee_count
Tokyo 6500 8.0
Toronto 8000 NaN
>>> city_data.iloc[1]
revenue 6500.0
employee_count 8.0
Name: Tokyo, dtype: float64
Каждая строка кода выбирает другую строку из city_data
:
city_data.loc["Amsterdam"]
выбирает строку с индексом метки"Amsterdam"
.city_data.loc["Tokyo": "Toronto"]
выбирает строки с индексами меток от"Tokyo"
до"Toronto"
. Помните,.loc
это включено.city_data.iloc[1]
выбирает строку с позиционным индексом1
, который является"Tokyo"
.
Хорошо, вы использовали .loc
и .iloc
на небольших структурах данных. Теперь пришло время потренироваться с чем-то большим! Используйте метод доступа к данным, чтобы отобразить предпоследнюю строку nba
набора данных. Затем посмотрите решение:
Строки второго до последнего является строка с позиционным индексом из -2
. Вы можете отобразить его с помощью .iloc
:
>>> nba.iloc[-2]
gameorder 63157
game_id 201506170CLE
lg_id NBA
_iscopy 0
year_id 2015
date_game 6/16/2015
seasongame 102
is_playoffs 1
team_id CLE
fran_id Cavaliers
pts 97
elo_i 1700.74
elo_n 1692.09
win_equiv 59.2902
opp_id GSW
opp_fran Warriors
opp_pts 105
opp_elo_i 1813.63
opp_elo_n 1822.29
game_location H
game_result L
forecast 0.48145
notes NaN
Name: 126312, dtype: object
Вы увидите вывод как Series
объект.
Для DataFrame
, методы доступа к данным, .loc
и .iloc
также принимают второй параметр. В то время как первый параметр выбирает строки на основе индексов, второй параметр выбирает столбцы. Вы можете использовать эти параметры вместе, чтобы выбрать подмножество строк и столбцов из вашего DataFrame
:>>>
>>> city_data.loc["Amsterdam": "Tokyo", "revenue"]
Amsterdam 4200
Tokyo 6500
Name: revenue, dtype: int64
Обратите внимание, что вы разделяете параметры запятой ( ,
). Первый параметр "Amsterdam" : "Tokyo,"
говорит, чтобы выбрать все строки между этими двумя метками. Второй параметр идет после запятой и говорит, чтобы выбрать "revenue"
столбец.
Пришло время увидеть ту же конструкцию в действии с большим nba
набором данных. Выберите все игры между ярлыками 5555
и 5559
. Вас интересуют только названия команд и оценки, так что выбирайте и эти элементы. Затем посмотрите ниже, чтобы увидеть решение:
Сначала определите, какие строки вы хотите видеть, затем перечислите соответствующие столбцы:
>>> nba.loc[5555:5559, ["fran_id", "opp_fran", "pts", "opp_pts"]]
Вы используете .loc
для индекса метки и запятой (,
) для разделения ваших двух параметров.
Вы должны увидеть небольшую часть вашего довольно большого набора данных:
Вывод намного легче читать!
С помощью таких методов доступа к данным, как .loc
и .iloc
, вы можете выбрать только то, что нужно в вашем DataFrame
, чтобы ответить на вопросы о вашем наборе данных.
Запрос вашего набора данных
Вы видели, как получить доступ к подмножествам огромного набора данных на основе его индексов. Теперь вы будете выбирать строки на основе значений в столбцах набора данных для запроса данных. Например, вы можете создать новый DataFrame
, содержащий только игры, сыгранные после 2010 года:
>>> current_decade = nba[nba["year_id"] > 2010]
>>> current_decade.shape
(12658, 23)
У вас все еще есть все 23 столбца, но ваш новый DataFrame
состоит только из строк, где значение в "year_id"
столбце больше, чем 2010
.
Вы также можете выбрать строки, в которых определенное поле не равно нулю:
>>> games_with_notes = nba[nba["notes"].notnull()]
>>> games_with_notes.shape
(5424, 23)
Это может быть полезно, если вы хотите избежать пропущенных значений в столбце. Вы также можете использовать .notna()
для достижения той же цели.
Вы даже можете получить доступ к значениям типа object
данных str
и выполнять строковые методы для них:>>>
>>> ers = nba[nba["fran_id"].str.endswith("ers")]
>>> ers.shape
(27797, 23)
Вы используете .str.endswith()
для фильтрации вашего набора данных и нахождения всех игр, где заканчивается имя домашней команды на "ers"
.
Вы можете объединить несколько критериев и запросить свой набор данных. Чтобы сделать это, обязательно поставьте каждый в круглые скобки и используйте логические операторы |
и &
разделите их.
Примечание: Операторы and
, or
, &&
и ||
не будет работать здесь. Если вам интересно, почему, то ознакомьтесь с разделом о том, как библиотека Python Pandas использует логические операторы в Python Pandas: хитрости и особенности, которые вы, возможно, не знаете .
Выполните поиск игр в Балтиморе, где обе команды набрали более 100 очков. Чтобы увидеть каждую игру только один раз, вам нужно исключить дубликаты:>>>
>>> nba[
... (nba["_iscopy"] == 0) &
... (nba["pts"] > 100) &
... (nba["opp_pts"] > 100) &
... (nba["team_id"] == "BLB")
... ]
Здесь вы используете nba["_iscopy"] == 0
для включения только записи, которые не являются копиями.
Ваш вывод должен содержать пять событийных игр:
Попробуйте создать другой запрос с несколькими критериями. Весной 1992 года обеим командам из Лос-Анджелеса пришлось сыграть домашнюю игру на другом корте. Запросите ваш набор данных, чтобы найти эти две игры. Обе команды имеют идентификатор, начиная с "LA"
. Посмотрите ниже, чтобы увидеть решение:
Вы можете использовать, .str
чтобы найти идентификаторы команд, которые начинаются с "LA"
, и вы можете предположить, что такая необычная игра будет иметь некоторые заметки:
>>> nba[
... (nba["_iscopy"] == 0) &
... (nba["team_id"].str.startswith("LA")) &
... (nba["year_id"]==1992) &
... (nba["notes"].notnull())
... ]
Ваш вывод должен показать две игры в день 5/3/1992:
Хорошая находка!
Когда вы знаете, как запрашивать набор данных по нескольким критериям, вы сможете ответить на более конкретные вопросы о вашем наборе данных.
Группировка и агрегация ваших данных
Вы также можете изучить другие функции вашего набора данных, такие как сумма, среднее или среднее значение группы элементов. К счастью, библиотека Pandas Python предлагает функции группировки и агрегирования, которые помогут вам выполнить эту задачу.
А Series
имеет более двадцати различных методов для расчета описательной статистики. Вот некоторые примеры:
>>> city_revenues.sum()
18700
>>> city_revenues.max()
8000
Первый метод возвращает сумму city_revenues
, а второй возвращает максимальное значение. Есть и другие методы, которые вы можете использовать, например, .min()
и .mean()
.
Помните, столбец в DataFrame
действительно является Series
объектом. По этой причине вы можете использовать эти же функции в столбцах nba
:
>>> points = nba["pts"]
>>> type(points)
<class 'pandas.core.series.Series'>
>>> points.sum()
12976235
A DataFrame
может иметь несколько столбцов, что открывает новые возможности для агрегации, такие как группировка :
>>> nba.groupby("fran_id", sort=False)["pts"].sum()
fran_id
Huskies 3995
Knicks 582497
Stags 20398
Falcons 3797
Capitols 22387
...
По умолчанию Pandas сортирует групповые ключи во время вызова .groupby()
. Если не хотите сортировать, то sort=False
. Этот параметр может привести к повышению производительности.
Вы также можете группировать по нескольким столбцам:
>>> nba[
... (nba["fran_id"] == "Spurs") &
... (nba["year_id"] > 2010)
... ].groupby(["year_id", "game_result"])["game_id"].count()
year_id game_result
2011 L 25
W 63
2012 L 20
W 60
2013 L 30
W 73
2014 L 27
W 78
2015 L 31
W 58
Name: game_id, dtype: int64
Вы можете практиковать эти основы с помощью упражнения. Взгляните на воинов Золотого штата 2014-15 сезона ( year_id: 2015
). Сколько побед и поражений они забили в регулярном сезоне и в плей-офф? Ниже ответ:
Сначала вы можете сгруппировать по "is_playoffs"
полю, а затем по результату:
>>> nba[
... (nba["fran_id"] == "Warriors") &
... (nba["year_id"] == 2015)
... ].groupby(["is_playoffs", "game_result"])["game_id"].count()
is_playoffs game_result
0 L 15
W 67
1 L 5
W 16
is_playoffs=0
показывает результаты для регулярного сезона, и is_playoffs=1
показывает результаты для плей-офф.
В приведенных выше примерах вы только поверхностно рассмотрели функции агрегации, которые доступны вам в библиотеке Python Pandas. Чтобы увидеть больше примеров их использования, ознакомьтесь с Pandas GroupBy: ваше руководство по группированию данных в Python .
Манипуляции с колоннами
Вам необходимо знать, как управлять столбцами набора данных на разных этапах процесса анализа данных. Вы можете добавлять и удалять столбцы как часть начальной фазы очистки данных или позже, основываясь на аналитических данных вашего анализа.
Создайте копию своего оригинала DataFrame
для работы:
>>> df = nba.copy()
>>> df.shape
(126314, 23)
Вы можете определить новые столбцы на основе существующих:
>>> df["difference"] = df.pts - df.opp_pts
>>> df.shape
(126314, 24)
Здесь вы использовали "pts"
выбор строк и столбцов одновременно в .iloc — PYTHON
Здесь про это:
Рассмотрим несколько примеров, чтобы понять, чем отличается .iloc от .loc.
Выберем две строки и два столбца:
import pandas as pd import numpy as np df = pd.read_csv('D:\#python#\example\SampleData_Pandas.csv', sep=';') print(df.iloc[ [2,3], [0,3] ])
Результат:
Дата Менеджер 2 01.01.2016 Сидоров 3 01.01.2016 Сидоров
Осуществим выборку строк и столбцов с помощью среза:
import pandas as pd import numpy as np df = pd.read_csv('D:\#python#\example\SampleData_Pandas.csv', sep=';') print(df.iloc[2:9, 0:3])
Результат:
Дата Подразделение Контрагент 2 01.01.2016 Отдел продвижения Абакус ООО 3 01.01.2016 Отдел продвижения Абакус ООО 4 01.01.2016 Отдел продаж Билли Боб ООО 5 01.01.2016 Отдел продаж Билли Боб ООО 6 01.01.2016 Отдел продаж Билли Боб ООО 7 01.01.2016 Отдел продаж Билли Боб ООО 8 01.01.2016 Отдел продвижения Билли Боб ООО
Выберем 1 значение из столбца и указанной колонки:
import pandas as pd import numpy as np df = pd.read_csv('D:\#python#\example\SampleData_Pandas.csv', sep=';') print(df.loc[3, 4])
Результат:
Палатки
Резюме по .loc и .iloc
Доступ к строкам и колонкам по индексу возможен несколькими способами:
- .loc — используется для доступа по строковой метке — т.е. фактически по значению индекса и по названию столбца
- .iloc — используется для доступа по числовому значению (начиная от 0) — т.е. по номеру строки и номеру столбца
Как выбрать строки из Pandas DataFrame по условию
Собираем тестовый набор данных для иллюстрации работы выборки по условию
Color | Shape | Price |
Green | Rectangle | 10 |
Green | Rectangle | 15 |
Green | Square | 5 |
Blue | Rectangle | 5 |
Blue | Square | 10 |
Red | Square | 15 |
Red | Square | 15 |
Red | Rectangle | 5 |
Пишем скрипт:
import pandas as pd Boxes = {'Color': ['Green','Green','Green','Blue','Blue','Red','Red','Red'], 'Shape': ['Rectangle','Rectangle','Square','Rectangle','Square','Square','Square','Rectangle'], 'Price': [10,15,5,5,10,15,15,5] } df = pd.DataFrame(Boxes, columns= ['Color','Shape','Price']) print (df)
Результат выполнения:
Color Shape Price 0 Green Rectangle 10 1 Green Rectangle 15 2 Green Square 5 3 Blue Rectangle 5 4 Blue Square 10 5 Red Square 15 6 Red Square 15 7 Red Rectangle 5
Синтаксис выборки строк из Pandas DataFrame по условию
Вы можете использовать следующую логику для выбора строк в Pandas DataFrame по условию:
df.loc[df.column name condition]
Например, если вы хотите получить строки с зеленым цветом , вам нужно применить:
df.loc[df.Color == 'Green']
Где:
- Color — это название столбца
- Green — это условие (значение колонки)
А вот полный код Python для нашего примера:
import pandas as pd Boxes = {'Color': ['Green','Green','Green','Blue','Blue','Red','Red','Red'], 'Shape': ['Rectangle','Rectangle','Square','Rectangle','Square','Square','Square','Rectangle'], 'Price': [10,15,5,5,10,15,15,5] } df = pd.DataFrame(Boxes, columns= ['Color','Shape','Price']) print (df.loc[df.Color == 'Green'])
Результат:
Color Shape Price 0 Green Rectangle 10 1 Green Rectangle 15 2 Green Square 5
Выберем строки, где цена равна или больше 10
Чтобы получить все строки, где цена равна или больше 10, Вам нужно применить следующее условие:
df.loc[df.Price >= 10]
Полный код Python:
import pandas as pd Boxes = {'Color': ['Green','Green','Green','Blue','Blue','Red','Red','Red'], 'Shape': ['Rectangle','Rectangle','Square','Rectangle','Square','Square','Square','Rectangle'], 'Price': [10,15,5,5,10,15,15,5] } df = pd.DataFrame(Boxes, columns= ['Color','Shape','Price']) print (df.loc[df.Price >= 10])
Результат:
Color Shape Price 0 Green Rectangle 10 1 Green Rectangle 15 4 Blue Square 10 5 Red Square 15 6 Red Square 15
Выберем строки, в которых цвет зеленый, а форма — прямоугольник
Теперь цель состоит в том, чтобы выбрать строки на основе двух условий:
- Color зеленый; а также
- Shape = прямоугольник
Мы будем использовать символ & для применения нескольких условий. В нашем примере код будет выглядеть так:
df.loc[(df.Color == 'Green') & (df.Shape == 'Rectangle')]
Полный код примера Python для выборки Pandas DataFrame:
import pandas as pd Boxes = {'Color': ['Green','Green','Green','Blue','Blue','Red','Red','Red'], 'Shape': ['Rectangle','Rectangle','Square','Rectangle','Square','Square','Square','Rectangle'], 'Price': [10,15,5,5,10,15,15,5] } df = pd.DataFrame(Boxes, columns= ['Color','Shape','Price']) print (df.loc[(df.Color == 'Green') & (df.Shape == 'Rectangle')])
Результат:
Color Shape Price 0 Green Rectangle 10 1 Green Rectangle 15
Выберем строки, где цвет зеленый ИЛИ форма прямоугольная
Для достижения этой цели будем использовать символ | следующим образом:
df.loc[(df.Color == 'Green') | (df.Shape == 'Rectangle')]
Полный код Python 3:
import pandas as pd Boxes = {'Color': ['Green','Green','Green','Blue','Blue','Red','Red','Red'], 'Shape': ['Rectangle','Rectangle','Square','Rectangle','Square','Square','Square','Rectangle'], 'Price': [10,15,5,5,10,15,15,5] } df = pd.DataFrame(Boxes, columns= ['Color','Shape','Price']) print (df.loc[(df.Color == 'Green') | (df.Shape == 'Rectangle')])
Результат:
Color Shape Price 0 Green Rectangle 10 1 Green Rectangle 15 2 Green Square 5 3 Blue Rectangle 5 7 Red Rectangle 5
Выберем строки, где цена не равна 15
Мы будем использовать комбинацию символов !=, чтобы выбрать строки, цена которых не равна 15:
df.loc[df.Price != 15]
Полный код Pandas DF на питоне:
import pandas as pd Boxes = {'Color': ['Green','Green','Green','Blue','Blue','Red','Red','Red'], 'Shape': ['Rectangle','Rectangle','Square','Rectangle','Square','Square','Square','Rectangle'], 'Price': [10,15,5,5,10,15,15,5] } df = pd.DataFrame(Boxes, columns= ['Color','Shape','Price']) print (df.loc[df.Price != 15])
Результат работы скрипта Python:
Color Shape Price 0 Green Rectangle 10 2 Green Square 5 3 Blue Rectangle 5 4 Blue Square 10 7 Red Rectangle 5
Основа текста
Анализ данных с помощью pandas. Часть 2: Выбор данных и нахождение наиболее частых жалоб
В этой части мы будем использовать новый набор данных, чтобы показать, как быть с большими объёмами данных. Это данные о 311 сервисных запросов (или жалоб) жителей, предоставленные NYC Open Data (скачать данные).
In [1]:
%matplotlib inline import pandas as pd import matplotlib.pyplot as plt plt.style.use('ggplot') plt.rcParams['figure.figsize'] = (10, 5)
In [2]:
complaints = pd.read_csv('data/311-service-requests.csv')
/usr/local/lib/python3.5/dist-packages/IPython/core/interactiveshell.py:2717: DtypeWarning: Columns (8) have mixed types. Specify dtype option on import or set low_memory=False. interactivity=interactivity, compiler=compiler, result=result)
В зависимости от вашей версии pandas, вы можете увидеть предупреждение «DtypeWarning: Columns (8) have mixed types». Это означает, что pandas столкнулся с проблемой чтения в наших данных. В нашем случае это почти наверняка означает, что данные имеют столбцы, где некоторые записи являются строками, а некоторые представляют собой целые числа.
На данный момент мы будем игнорировать это, надеясь на то, что пронесёт, но в долгосрочной перспективе мы должны исследовать это предупреждение.
А что это такое? (сводка)
При печати большого dataframe, будут показаны только первые несколько строк.
Для получения первых 5 строк dataframe, мы можем использовать срез: df[:5]
.
Out[3]:
Unique Key | Created Date | Closed Date | Agency | Agency Name | Complaint Type | Descriptor | Location Type | Incident Zip | Incident Address | … | Bridge Highway Name | Bridge Highway Direction | Road Ramp | Bridge Highway Segment | Garage Lot Name | Ferry Direction | Ferry Terminal Name | Latitude | Longitude | Location | |
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
0 | 26589651 | 10/31/2013 02:08:41 AM | NaN | NYPD | New York City Police Department | Noise — Street/Sidewalk | Loud Talking | Street/Sidewalk | 11432 | 90-03 169 STREET | … | NaN | NaN | NaN | NaN | NaN | NaN | NaN | 40.708275 | -73.791604 | (40.70827532593202, -73.79160395779721) |
1 | 26593698 | 10/31/2013 02:01:04 AM | NaN | NYPD | New York City Police Department | Illegal Parking | Commercial Overnight Parking | Street/Sidewalk | 11378 | 58 AVENUE | … | NaN | NaN | NaN | NaN | NaN | NaN | NaN | 40.721041 | -73.909453 | (40.721040535628305, -73.90945306791765) |
2 | 26594139 | 10/31/2013 02:00:24 AM | 10/31/2013 02:40:32 AM | NYPD | New York City Police Department | Noise — Commercial | Loud Music/Party | Club/Bar/Restaurant | 10032 | 4060 BROADWAY | … | NaN | NaN | NaN | NaN | NaN | NaN | NaN | 40.843330 | -73.939144 | (40.84332975466513, -73.93914371913482) |
3 | 26595721 | 10/31/2013 01:56:23 AM | 10/31/2013 02:21:48 AM | NYPD | New York City Police Department | Noise — Vehicle | Car/Truck Horn | Street/Sidewalk | 10023 | WEST 72 STREET | … | NaN | NaN | NaN | NaN | NaN | NaN | NaN | 40.778009 | -73.980213 | (40.7780087446372, -73.98021349023975) |
4 | 26590930 | 10/31/2013 01:53:44 AM | NaN | DOHMH | Department of Health and Mental Hygiene | Rodent | Condition Attracting Rodents | Vacant Lot | 10027 | WEST 124 STREET | … | NaN | NaN | NaN | NaN | NaN | NaN | NaN | 40.807691 | -73.947387 | (40.80769092704951, -73.94738703491433) |
5 rows × 52 columns
Выбор строк и столбцов
Чтобы выбрать столбец, мы берём имя столбца в качестве индекса (как в словаре), например так:
In [4]:
complaints['Complaint Type'][:5]
Out[4]:
0 Noise - Street/Sidewalk 1 Illegal Parking 2 Noise - Commercial 3 Noise - Vehicle 4 Rodent Name: Complaint Type, dtype: object
неважно, в каком порядке мы это сделаем (взять первые 5 строк у столбца или столбец у первых 5 строк)
In [5]:
complaints[:5]['Complaint Type']
Out[5]:
0 Noise - Street/Sidewalk 1 Illegal Parking 2 Noise - Commercial 3 Noise - Vehicle 4 Rodent Name: Complaint Type, dtype: object
Выбор нескольких столбцов
Что если мы хотим знать только тип жалобы и район, а остальное нам неинтересно? Pandas позволяет легко выбрать подмножество столбцов: просто проиндексируйте списком столбцов.
In [6]:
complaints[['Complaint Type', 'Borough']]
Out[6]:
Complaint Type | Borough | |
---|---|---|
0 | Noise — Street/Sidewalk | QUEENS |
1 | Illegal Parking | QUEENS |
2 | Noise — Commercial | MANHATTAN |
3 | Noise — Vehicle | MANHATTAN |
4 | Rodent | MANHATTAN |
5 | Noise — Commercial | QUEENS |
6 | Blocked Driveway | QUEENS |
7 | Noise — Commercial | QUEENS |
8 | Noise — Commercial | MANHATTAN |
9 | Noise — Commercial | BROOKLYN |
10 | Noise — House of Worship | BROOKLYN |
11 | Noise — Commercial | MANHATTAN |
12 | Illegal Parking | MANHATTAN |
13 | Noise — Vehicle | BRONX |
14 | Rodent | BROOKLYN |
15 | Noise — House of Worship | MANHATTAN |
16 | Noise — Street/Sidewalk | STATEN ISLAND |
17 | Illegal Parking | BROOKLYN |
18 | Street Light Condition | BROOKLYN |
19 | Noise — Commercial | MANHATTAN |
20 | Noise — House of Worship | BROOKLYN |
21 | Noise — Commercial | MANHATTAN |
22 | Noise — Vehicle | QUEENS |
23 | Noise — Commercial | BROOKLYN |
24 | Blocked Driveway | STATEN ISLAND |
25 | Noise — Street/Sidewalk | STATEN ISLAND |
26 | Street Light Condition | BROOKLYN |
27 | Harboring Bees/Wasps | MANHATTAN |
28 | Noise — Street/Sidewalk | MANHATTAN |
29 | Street Light Condition | STATEN ISLAND |
… | … | … |
111039 | Noise — Commercial | MANHATTAN |
111040 | Noise — Commercial | MANHATTAN |
111041 | Noise | BROOKLYN |
111042 | Noise — Street/Sidewalk | MANHATTAN |
111043 | Noise — Commercial | BROOKLYN |
111044 | Noise — Street/Sidewalk | MANHATTAN |
111045 | Water System | MANHATTAN |
111046 | Noise | BROOKLYN |
111047 | Illegal Parking | QUEENS |
111048 | Noise — Street/Sidewalk | MANHATTAN |
111049 | Noise — Commercial | BROOKLYN |
111050 | Noise | MANHATTAN |
111051 | Noise — Commercial | MANHATTAN |
111052 | Water System | MANHATTAN |
111053 | Derelict Vehicles | QUEENS |
111054 | Noise — Street/Sidewalk | BROOKLYN |
111055 | Noise — Commercial | BROOKLYN |
111056 | Street Sign — Missing | QUEENS |
111057 | Noise | MANHATTAN |
111058 | Noise — Commercial | BROOKLYN |
111059 | Noise — Street/Sidewalk | MANHATTAN |
111060 | Noise | MANHATTAN |
111061 | Noise — Commercial | QUEENS |
111062 | Water System | MANHATTAN |
111063 | Water System | MANHATTAN |
111064 | Maintenance or Facility | BROOKLYN |
111065 | Illegal Parking | QUEENS |
111066 | Noise — Street/Sidewalk | MANHATTAN |
111067 | Noise — Commercial | BROOKLYN |
111068 | Blocked Driveway | BROOKLYN |
111069 rows × 2 columns
Посмотрим первые 10 строк:
In [7]:
complaints[['Complaint Type', 'Borough']][:10]
Out[7]:
Complaint Type | Borough | |
---|---|---|
0 | Noise — Street/Sidewalk | QUEENS |
1 | Illegal Parking | QUEENS |
2 | Noise — Commercial | MANHATTAN |
3 | Noise — Vehicle | MANHATTAN |
4 | Rodent | MANHATTAN |
5 | Noise — Commercial | QUEENS |
6 | Blocked Driveway | QUEENS |
7 | Noise — Commercial | QUEENS |
8 | Noise — Commercial | MANHATTAN |
9 | Noise — Commercial | BROOKLYN |
Какой самый частый тип жалобы?
Это очень простой вопрос для pandas! Используем метод .value_counts()
:
In [8]:
complaints['Complaint Type'].value_counts()
Out[8]:
HEATING 14200 GENERAL CONSTRUCTION 7471 Street Light Condition 7117 DOF Literature Request 5797 PLUMBING 5373 PAINT - PLASTER 5149 Blocked Driveway 4590 NONCONST 3998 Street Condition 3473 Illegal Parking 3343 Noise 3321 Traffic Signal Condition 3145 Dirty Conditions 2653 Water System 2636 Noise - Commercial 2578 ELECTRIC 2350 Broken Muni Meter 2070 Noise - Street/Sidewalk 1928 Sanitation Condition 1824 Rodent 1632 Sewer 1627 Taxi Complaint 1227 Consumer Complaint 1227 Damaged Tree 1180 Overgrown Tree/Branches 1083 Missed Collection (All Materials) 973 Graffiti 973 Building/Use 942 Root/Sewer/Sidewalk Condition 836 Derelict Vehicle 803 ... Fire Alarm - Modification 5 Posting Advertisement 5 Internal Code 5 Poison Ivy 5 Miscellaneous Categories 5 Ferry Complaint 4 Transportation Provider Complaint 4 Special Natural Area District (SNAD) 4 Illegal Animal Sold 4 Illegal Fireworks 3 Invitation 3 Fire Alarm - Replacement 3 Adopt-A-Basket 3 Misc. Comments 2 Legal Services Provider Complaint 2 DFTA Literature Request 2 Opinion for the Mayor 2 Public Assembly 2 Window Guard 2 Tunnel Condition 1 Snow 1 X-Ray Machine/Equipment 1 Stalled Sites 1 Municipal Parking Facility 1 Open Flame Permit 1 Trans Fat 1 Ferry Permit 1 DWD 1 Highway Sign - Damaged 1 DHS Income Savings Requirement 1 Name: Complaint Type, dtype: int64
10 наиболее частых типов:
In [9]:
complaint_counts = complaints['Complaint Type'].value_counts() complaint_counts[:10]
Out[9]:
HEATING 14200 GENERAL CONSTRUCTION 7471 Street Light Condition 7117 DOF Literature Request 5797 PLUMBING 5373 PAINT - PLASTER 5149 Blocked Driveway 4590 NONCONST 3998 Street Condition 3473 Illegal Parking 3343 Name: Complaint Type, dtype: int64
Теперь мы можем построить график!
In [10]:
complaint_counts[:10].plot(kind='bar')
Как удалить столбцы из фрейма данных Pandas?
Pandas DataFrame — Удалить столбцы
Вы можете удалить один или несколько столбцов DataFrame.
Чтобы удалить или удалить только один столбец из Pandas DataFrame, вы можете использовать ключевое слово del
, функцию pop ()
или функцию drop ()
в кадре данных.
Чтобы удалить несколько столбцов из фрейма данных Pandas, используйте функцию drop ()
для фрейма данных.
Пример 1: Удаление столбца с помощью ключевого слова del
В этом примере мы создадим DataFrame, а затем удалим указанный столбец с помощью ключевого слова del.Столбец выбирается для удаления с помощью метки столбца.
Программа Python
импортировать панды как pd
mydictionary = {'names': ['Somu', 'Kiku', 'Amol', 'Lini'],
«физика»: [68, 74, 77, 78],
«химия»: [84, 56, 73, 69],
'алгебра': [78, 88, 82, 87]}
#create dataframe
df_marks = pd.DataFrame (mydictionary)
print ('Исходный фрейм данных \ n --------------')
печать (df_marks)
# удалить столбец
дель df_marks ['химия']
print ('\ n \ nDataFrame после удаления столбца \ n --------------')
print (df_marks)
Запустить эту программу ОНЛАЙН
Вывод
Исходный фрейм данных
--------------
имена физика химия алгебра
0 Сому 68 84 78
1 Кику 74 56 88
2 Амол 77 73 82
3 линии 78 69 87
DataFrame после удаления столбца
--------------
имена физика алгебра
0 Сому 68 78
1 Кику 74 88
2 Амол 77 82
3 Lini 78 87
Мы удалили столбец Chemistry из фрейма данных.
Пример 2: Удаление столбца с помощью функции pop ()
В этом примере мы создадим DataFrame, а затем будем использовать функцию pop () в кадре данных для удаления определенного столбца. Столбец выбирается для удаления с помощью метки столбца.
Программа Python
импортировать панды как pd
mydictionary = {'names': ['Somu', 'Kiku', 'Amol', 'Lini'],
«физика»: [68, 74, 77, 78],
«химия»: [84, 56, 73, 69],
'алгебра': [78, 88, 82, 87]}
#create dataframe
df_marks = pd.DataFrame (mydictionary)
print ('Исходный фрейм данных \ n --------------')
печать (df_marks)
# удалить столбец
df_marks.pop ('химия')
print ('\ n \ nDataFrame после удаления столбца \ n --------------')
print (df_marks)
Запустить эту программу ОНЛАЙН
Вывод
Исходный фрейм данных
--------------
имена физика химия алгебра
0 Сому 68 84 78
1 Кику 74 56 88
2 Амол 77 73 82
3 линии 78 69 87
DataFrame после удаления столбца
--------------
имена физика алгебра
0 Сому 68 78
1 Кику 74 88
2 Амол 77 82
3 Lini 78 87
Мы удалили столбец Chemistry из фрейма данных.
Пример 3: Удаление столбца с помощью функции drop ()
В этом примере мы будем использовать функцию drop () в кадре данных для удаления определенного столбца. Мы используем метку столбца, чтобы выбрать столбец для удаления.
Программа Python
импортировать панды как pd
mydictionary = {'names': ['Somu', 'Kiku', 'Amol', 'Lini'],
«физика»: [68, 74, 77, 78],
«химия»: [84, 56, 73, 69],
'алгебра': [78, 88, 82, 87]}
#create dataframe
df_marks = pd.DataFrame (mydictionary)
print ('Исходный фрейм данных \ n --------------')
печать (df_marks)
# удалить столбец
df_marks = df_marks.drop (['химия'], ось = 1)
print ('\ n \ nDataFrame после удаления столбца \ n --------------')
print (df_marks)
Запустить эту программу ОНЛАЙН
Вывод
Пример 4: Удалить несколько столбцов с помощью функции drop ()
В этом примере мы будем использовать функцию drop () в кадре данных для удаления нескольких столбцов. Мы используем массив меток столбцов для выбора столбцов для удаления.
Программа Python
импортировать панды как pd
mydictionary = {'names': ['Somu', 'Kiku', 'Amol', 'Lini'],
«физика»: [68, 74, 77, 78],
«химия»: [84, 56, 73, 69],
'алгебра': [78, 88, 82, 87]}
#create dataframe
df_marks = pd.DataFrame (mydictionary)
print ('Исходный фрейм данных \ n --------------')
печать (df_marks)
#delete columns
df_marks = df_marks.drop (['алгебра', 'химия'], ось = 1)
print ('\ n \ nDataFrame после удаления столбца \ n --------------')
print (df_marks)
Запустить эту программу ОНЛАЙН
Вывод
Сводка
В этом учебнике Pandas мы узнали, как удалить столбец из Pandas DataFrame с помощью ключевого слова del, метода pop () и метода drop () с помощью помощь подробных примеров Python.
панд: удалить строки и столбцы из DataFrame с помощью drop ()
Используйте drop ()
для удаления строк и столбцов из панд. DataFrame
.
До версии 0.21.0
, укажите строку / столбец с параметром , подписав
и ось
. index
или столбцов
можно использовать из 0,21,0
.
Здесь будет описано следующее содержание.
- Удалить строки из DataFrame
- Укажите по имени строки (метке строки)
- Укажите по номеру строки
- Примечания, когда индекс не установлен
- Удалить столбцы из DataFrame
- Укажите по имени столбца (метке столбца)
- Укажите по номеру столбца
- Удалить сразу несколько строк и столбцов
В примере кода используются следующие данные.
импортировать панд как pd df = pd.read_csv ('data / src / sample_pandas_normal.csv', index_col = 0) печать (df) # возрастная точка состояния # название # Алиса 24 NY 64 # Боб 42 CA 92 # Чарли 18 CA 70 # Дэйв 68 TX 70 # Эллен 24 CA 88 # Франк 30 NY 57
CSV-файл находится здесь:
Удалить строки из DataFrame
Укажите по имени строки (метке строки)
Задание с первым параметром меток
и вторым параметром оси
.В случае строк установите axis = 0
.
print (df.drop ('Чарли', ось = 0)) # возрастная точка состояния # название # Алиса 24 NY 64 # Боб 42 CA 92 # Дэйв 68 TX 70 # Эллен 24 CA 88 # Франк 30 NY 57
По умолчанию ось = 0
, поэтому ось
можно не указывать.
печать (df.drop ('Чарли')) # возрастная точка состояния # название # Алиса 24 NY 64 # Боб 42 CA 92 # Дэйв 68 TX 70 # Эллен 24 CA 88 # Франк 30 NY 57
Начиная с версии 0.21.0
, можно также использовать параметр , индекс
.
печать (df.drop (index = 'Charlie')) # возрастная точка состояния # название # Алиса 24 NY 64 # Боб 42 CA 92 # Дэйв 68 TX 70 # Эллен 24 CA 88 # Франк 30 NY 57
Используйте список для одновременного удаления нескольких строк.
print (df.drop (['Боб', 'Дэйв', 'Фрэнк'])) # возрастная точка состояния # название # Алиса 24 NY 64 # Чарли 18 CA 70 # Эллен 24 CA 88 печать (df.drop (index = ['Боб', 'Дэйв', 'Фрэнк'])) # возрастная точка состояния # название # Алиса 24 NY 64 # Чарли 18 CA 70 # Эллен 24 CA 88
По умолчанию исходный DataFrame
не изменяется, и возвращается новый DataFrame
.
Установка параметра inplace
на True
изменяет исходный DataFrame
. В этом случае новый DataFrame
не возвращается, а возвращаемое значение — None
.
df_org = df.copy () df_org.drop (index = ['Боб', 'Дэйв', 'Фрэнк'], inplace = True) печать (df_org) # возрастная точка состояния # название # Алиса 24 NY 64 # Чарли 18 CA 70 # Эллен 24 CA 88
Укажите по номеру строки
Если вы хотите указать номер строки, используйте атрибут index
в DataFrame
.
Укажите номер строки в атрибуте []
из index
, чтобы получить соответствующее имя строки.С помощью списка можно указать несколько номеров строк.
печать (df.index [[1, 3, 5]]) # Индекс (['Боб', 'Дэйв', 'Фрэнк'], dtype = 'object', name = 'name')
Вы можете указать это как первый параметр , обозначающий
или , индекс
из drop ()
.
печать (df.drop (df.index [[1, 3, 5]])) # возрастная точка состояния # название # Алиса 24 NY 64 # Чарли 18 CA 70 # Эллен 24 CA 88 print (df.drop (index = df.index [[1, 3, 5]]))) # возрастная точка состояния # название # Алиса 24 NY 64 # Чарли 18 CA 70 # Эллен 24 CA 88
Примечания, когда индекс не установлен
Если имя строки не задано, по умолчанию индекс
будет последовательностью целых чисел. Будьте осторожны, если index
— это число, а не строка.
df_noindex = pd.read_csv ('данные / src / sample_pandas_normal.csv') печать (df_noindex) # имя возрастная точка состояния # 0 Алиса 24 Нью-Йорк 64 # 1 Боб 42 CA 92 # 2 Чарли 18 CA 70 # 3 Дэйв 68 TX 70 # 4 Эллен 24 CA 88 # 5 Фрэнк 30 Нью-Йорк 57 печать (df_noindex.индекс) # RangeIndex (start = 0, stop = 6, step = 1)
Если это порядковый номер, результат будет одинаковым независимо от того, указываете ли вы номер как есть или используете атрибут index
.
печать (df_noindex.drop ([1, 3, 5])) # имя возрастная точка состояния # 0 Алиса 24 Нью-Йорк 64 # 2 Чарли 18 CA 70 # 4 Эллен 24 CA 88 print (df_noindex.drop (df_noindex.index [[1, 3, 5]])) # имя возрастная точка состояния # 0 Алиса 24 Нью-Йорк 64 # 2 Чарли 18 CA 70 # 4 Эллен 24 CA 88
Результат будет другим, если он не соответствует порядку сортировки и т. Д.При указании числового значения как такового удаляется строка, метка которой является числовым значением, а при использовании атрибута index
удаляется строка, номер которой является числовым значением.
df_noindex_sort = df_noindex.sort_values ('состояние') печать (df_noindex_sort) # имя возрастная точка состояния # 1 Боб 42 CA 92 # 2 Чарли 18 CA 70 # 4 Эллен 24 CA 88 # 0 Алиса 24 Нью-Йорк 64 # 5 Фрэнк 30 Нью-Йорк 57 # 3 Дэйв 68 TX 70 печать (df_noindex_sort.индекс) # Int64Index ([1, 2, 4, 0, 5, 3], dtype = 'int64') print (df_noindex_sort.drop ([1, 3, 5])) # имя возрастная точка состояния # 2 Чарли 18 CA 70 # 4 Эллен 24 CA 88 # 0 Алиса 24 Нью-Йорк 64 print (df_noindex_sort.drop (df_noindex_sort.index [[1, 3, 5]])) # имя возрастная точка состояния # 1 Боб 42 CA 92 # 4 Эллен 24 CA 88 # 5 Фрэнк 30 Нью-Йорк 57
См. Следующий пост для сортировки.
Удалить столбцы из DataFrame
Укажите по имени столбца (метка столбца)
Задание с первым параметром меток
и вторым параметром оси
.В случае строк установите axis = 1
.
print (df.drop ('состояние', ось = 1)) # возрастной балл # название # Алиса 24 64 # Боб 42 92 # Чарли 18 70 # Дэйв 68 70 # Эллен 24 88 # Франк 30 57
Начиная с версии 0.21.0
, вы также можете использовать параметр столбцы
.
печать (df.drop (columns = 'state')) # возрастной балл # название # Алиса 24 64 # Боб 42 92 # Чарли 18 70 # Дэйв 68 70 # Эллен 24 88 # Франк 30 57
Используйте список для одновременного удаления нескольких столбцов.
print (df.drop (['состояние', 'точка'], ось = 1)) # возраст # название # Алиса 24 # Боб 42 # Чарли 18 # Дэйв 68 # Эллен 24 # Фрэнк 30 print (df.drop (columns = ['состояние', 'точка'])) # возраст # название # Алиса 24 # Боб 42 # Чарли 18 # Дэйв 68 # Эллен 24 # Фрэнк 30
Параметр вместо
может использоваться как для строк.
df_org = df.copy () df_org.drop (columns = ['состояние', 'точка'], inplace = True) печать (df_org) # возраст # название # Алиса 24 # Боб 42 # Чарли 18 # Дэйв 68 # Эллен 24 # Фрэнк 30
Укажите по номеру столбца
Если вы хотите указать номер столбца, используйте атрибут columns
из DataFrame
.
печать (df.columns [[1, 2]]) # Индекс (['состояние', 'точка'], dtype = 'объект') print (df.drop (df.columns [[1, 2]], axis = 1)) # возраст # название # Алиса 24 # Боб 42 # Чарли 18 # Дэйв 68 # Эллен 24 # Фрэнк 30 print (df.drop (columns = df.columns [[1, 2]])) # возраст # название # Алиса 24 # Боб 42 # Чарли 18 # Дэйв 68 # Эллен 24 # Фрэнк 30
Если значение столбцов
является целым числом, будьте осторожны, как описано выше для строк.
Удалить сразу несколько строк и столбцов
Начиная с версии 0.21.0
и более поздних, можно одновременно удалить несколько строк и несколько столбцов, указав параметр , индекс
и столбцов
.
Конечно, также можно указать номер строки и номер столбца или указать параметр вместо
.
print (df.drop (index = ['Bob', 'Dave', 'Frank'], columns = ['состояние', 'точка'])) # возраст # название # Алиса 24 # Чарли 18 # Эллен 24 печать (df.drop (index = df.index [[1, 3, 5]], columns = df.columns [[1, 2]]))) # возраст # название # Алиса 24 # Чарли 18 # Эллен 24 df_org = df.copy () df_org.drop (index = ['Боб', 'Дэйв', 'Фрэнк'], columns = ['состояние', 'точка'], inplace = True) печать (df_org) # возраст # название # Алиса 24 # Чарли 18 # Эллен 24
Как удалить столбец фрейма данных Pandas?
Pandas DataFrame — Удалить столбец
Есть разные способы удалить столбец Pandas DataFrame.Ниже приведены некоторые из способов, которые мы обсудим в этом руководстве.
- Удалить столбец с помощью ключевого слова del .
- Удалите столбец с помощью метода drop () .
- Удалите столбец с помощью метода pop () .
Удалить столбец DataFrame с помощью ключевого слова del
Чтобы удалить столбец DataFrame с помощью ключевого слова del
, используйте следующий синтаксис.
del myDataFrame [‘column_name’] |
В следующем примере мы инициализируем DataFrame с тремя столбцами и удалим один из столбцов с помощью ключевого слова del
.
Программа Python
import pandas as pd #initialize a dataframe df = pd.DataFrame ({ ‘a’: [14, 525, ‘b’: [32, 85, 64], ‘c’: [88, 47, 36]}) # удалить столбец ‘b’ del df [‘b’] # распечатать фрейм данных print (df) |
Выход
a c 0 14 88 1 52 47 36 1 52 47 |
Столбец с именем b
был удален из фрейма данных.
Удалить столбец DataFrame с помощью метода drop ()
Метод pandas.DataFrame.drop () возвращает новый DataFrame с указанными столбцами, удаленными из исходного DataFrame. Исходный DataFrame не изменяется.
Программа Python
import pandas as pd #initialize a dataframe df = pd.DataFrame ({ ‘a’: [14, 525, ‘b’: [32, 85, 64], ‘c’: [88, 47, 36]}) # удалить столбец ‘b’ df1 = df.drop ([‘b’], axis = 1) # распечатать фрейм данных print (df1) |
Выход
a 14 88 1 52 47 2 46 36 |
Удалить столбец DataFrame с помощью метода pop ()
pandas.DataFrame.pop () метод удаляет указанный столбец из DataFrame и возвращает удаленный столбец.
Программа Python
import pandas as pd #initialize a dataframe df = pd.DataFrame ({ ‘a’: [14, 525, ‘b’: [32, 85, 64], ‘c’: [88, 47, 36]}) # удалить столбец ‘b’ poppedColumn = df.pop (‘b’) # распечатать фрейм данных print (df) print (‘\ nDeleted Column \ n ————-‘) #print удаленный столбец print (poppedColumn) |
Выход
a c 0 14 88 1 52 47 2 46 36 ———- 0 32 1 85 2 64 Имя: b, d Тип: int64 90 005 |
Заключение
В этом руководстве по Pandas мы узнали, как удалить столбец из DataFrame.
Как удалить один или несколько столбцов в Pandas Dataframe
Давайте обсудим, как удалить один или несколько столбцов в Pandas Dataframe. Удалить один или несколько столбцов из DataFrame можно несколькими способами.
Создайте простой фрейм данных со словарем списков, скажем, имена столбцов: A, B, C, D, E .
|
Выход:
Метод № 1: Удаление столбцов из фрейма данных с использованием метода drop ()
.
Удалить отдельный столбец.
|
Выход:
Удалить несколько определенных столбцов.
|
Выход:
Удалить столбцы на основе индекса столбца.
|
Выход:
Метод № 2: Удаление столбцов из фрейма данных с использованием метода iloc []
и drop ()
.
Удалить все столбцы между одним столбцом и другим столбцом.
|
Выход:
Метод № 3: Удаление столбцов из Dataframe с использованием методов ix ()
и drop ()
.
Удалить все столбцы между одним именем столбца и именем другого столбца.
|
Выход:
Метод № 4: Удаление столбцов из Dataframe с использованием метода loc []
и drop ()
.
Удалить все столбцы между одним именем столбца и именем другого столбца.
Как удалить строки в DataFrame по условиям значений столбцов - thispointer.com
В этой статье мы обсудим, как удалять строки на основе DataFrame, проверяя несколько условий для значений столбцов.
DataFrame предоставляет функцию-член drop (), т.е.
DataFrame.drop (метки = None, axis = 0, index = None, columns = None, level = None, inplace = False, errors = 'поднять')
Он принимает одно имя или список имен меток и удаляет соответствующие строки или столбцы (на основе значения параметра оси i.е. 0 для строк или 1 для столбцов).
Давайте используем это для удаления нескольких строк по условиям.
Давайте создадим объект dataframe из словаря
# List of Tuples студенты = [('jack', 34, 'Sydeny', 'Australia'), («Рити», 30, «Дели», «Индия»), («Викас», 31, «Мумбаи», «Индия»), («Нилу», 32, «Бангалор», «Индия»), ('Джон', 16, 'Нью-Йорк', 'США'), («Майк», 17 лет, «Лас-Вегас», «США»)] # Создать объект DataFrame dfObj = pd.DataFrame (студенты, столбцы = ['Имя', 'Возраст', 'Город', 'Страна'], index = ['a', 'b', 'c', 'd', 'e', 'f' ])
Будет содержимое объекта dataframe dfObj ,
Исходный DataFrame, на который указывает dfObj
. Удалим все строки, для которых столбец «Возраст» имеет значение 30, т.е.
# Получим имена индексов, для которых столбец «Возраст» имеет значение 30 indexNames = dfObj [dfObj ['Возраст'] == 30] .index # Удалить эти индексы строк из dataFrame dfObj.drop (indexNames, inplace = True)
Содержимое обновленного объекта кадра данных dfObj будет следующим:
Строки DataFrame со значением 30 в «Возраст столбца» удалены.
Что здесь произошло? Давайте разберемся,
dfObj ['Age'] == 30
Он предоставит объект Series с True и False.Истина для записей со значением 30 и Ложь для других, т.е.
Ложь б Верно c Ложь d Ложь e Ложь f Ложь Имя: Возраст, dtype: bool
Давайте создадим новый объект DataFrame с этой серией и существующим объектом DataFrame dfObj, то есть
dfObj [dfObj ['Age'] == 30]
Это даст новый объект фрейма данных, который имеет только ту строку, для которой столбец «Возраст» имеет значение 30, т.е.
Имя Возраст Город Страна
b Рити 30 Дели Индия
Теперь этот фрейм данных содержит строки, которые мы хотим удалить из исходного фрейма данных.Итак, давайте возьмем имена индексов из этого объекта фрейма данных, то есть
dfObj [dfObj ['Age'] == 30] .index
Он предоставит объект индекса, содержащий метки индекса, для которых столбец «Возраст» имеет значение 30, т.е.
Index (['b'], dtype = 'object')
Теперь передайте это в dataframe.drop (), чтобы удалить эти строки, т.е.
dfObj.drop (dfObj [dfObj ['Age'] == 30] .index, inplace = True)
Он удалит все строки, для которых столбец «Возраст» имеет значение 30.
Предположим, что содержимое объекта кадра данных dfObj равно,
Исходный фрейм данных, на который указывает dfObj
. Удалим все строки, для которых столбец «Возраст» имеет значение от 30 до 40 i.е.
# удалить все строки со столбцом "Возраст" от 30 до 40 indexNames = dfObj [(dfObj ['Age']> = 30) & (dfObj ['Age'] <= 40)] .index dfObj.drop (indexNames, inplace = True)
Содержимое измененного объекта кадра данных dfObj будет следующим:
Строки со значением 30–40 столбца «Возраст» удалены.
в основном нам нужно использовать & между несколькими условиями.
Предположим, что содержимое объекта кадра данных dfObj равно,
Исходный DataFrame, на который указывает dfObj
Давайте удалим все строки, для которых столбец «Возраст» имеет значение больше 30, а страна - «Индия»
# удалим все строки, для которых столбец «Возраст» имеет значение больше 30, а страна - Индия. indexNames = dfObj [(dfObj ['Возраст']> = 30) & (dfObj ['Country'] == 'India')].индекс dfObj.drop (indexNames, inplace = True)
Содержимое измененного объекта кадра данных dfObj будет следующим:
Удалены строки, возраст которых> 30 и страна - Индия
. Нам нужно использовать & между несколькими условиями.
Полный пример выглядит следующим образом:
импортировать панды как pd def main (): # Список кортежей студенты = [('jack', 34, 'Sydeny', 'Australia'), («Рити», 30, «Дели», «Индия»), («Викас», 31, «Мумбаи», «Индия»), («Нилу», 32, «Бангалор», «Индия»), ('Джон', 16, 'Нью-Йорк', 'США'), («Майк», 17 лет, «Лас-Вегас», «США»)] # Создать объект DataFrame dfObj = pd.DataFrame (студенты, столбцы = ['Имя', 'Возраст', 'Город', 'Страна'], index = ['a', 'b', 'c', 'd', 'e', 'f' ]) print ("Исходный фрейм данных", dfObj, sep = '\ n') '' ' Удалить строки по значению столбца '' ' print ("Удалить все строки, для которых столбец" Возраст "имеет значение 30") # Получить имена индексов, для которых столбец Age имеет значение 30 indexNames = dfObj [dfObj ['Возраст'] == 30] .index # Удалить эти индексы строк из dataFrame dfObj.drop (indexNames, inplace = True) print ("Измененный фрейм данных", dfObj, sep = '\ n') '' ' Удалить строки на основе нескольких условий в столбце '' ' print ("Удалить все строки, для которых столбец" Возраст "имеет значение от 30 до 40") # Создать объект DataFrame dfObj = pd.DataFrame (студенты, columns = ['Имя', 'Возраст', 'Город', 'Страна'], index = ['a', 'b', 'c', 'd', 'e' , 'f']) print ("Исходный фрейм данных", dfObj, sep = '\ n') # удаляем все строки, для которых столбец Age имеет значение от 30 до 40 indexNames = dfObj [(dfObj ['Age']> = 30) & (dfObj ['Age'] <= 40)].индекс dfObj.drop (indexNames, inplace = True) print ("Измененный фрейм данных", dfObj, sep = '\ n') '' ' Удалить строки на основе нескольких условий в разных столбцах '' ' print ("Удалите все строки, в которых столбец" Возраст "имеет значение больше 30, а страна -" Индия "") # Создать объект DataFrame dfObj = pd.DataFrame (студенты, columns = ['Имя', 'Возраст', 'Город', 'Страна'], index = ['a', 'b', 'c', 'd', 'e' , 'f']) print ("Исходный фрейм данных", dfObj, sep = '\ n') # удалить все строки, для которых столбец "Возраст" имеет значение больше 30, а Страна - Индия indexNames = dfObj [(dfObj ['Возраст']> = 30) & (dfObj ['Country'] == 'India')].индекс dfObj.drop (indexNames, inplace = True) print ("Измененный фрейм данных", dfObj, sep = '\ n') если __name__ == '__main__': основной()
Вывод:
Исходный фрейм данных Имя Возраст Город Страна валет 34 Sydeny Австралия b Рити 30 Дели Индия c Викас 31 Мумбаи Индия d Neelu 32 Бангалор Индия e Иоанна 16 Нью-Йорк США f Майк 17 Лас Вегас США Удалите все строки, для которых столбец "Возраст" имеет значение 30. Измененный фрейм данных Имя Возраст Город Страна валет 34 Sydeny Австралия c Викас 31 Мумбаи Индия d Neelu 32 Бангалор Индия e Иоанна 16 Нью-Йорк США f Майк 17 Лас Вегас США Удалите все строки, для которых столбец «Возраст» имеет значение от 30 до 40. Исходный фрейм данных Имя Возраст Город Страна валет 34 Sydeny Австралия b Рити 30 Дели Индия c Викас 31 Мумбаи Индия d Neelu 32 Бангалор Индия e Иоанна 16 Нью-Йорк США f Майк 17 Лас Вегас США Измененный фрейм данных Имя Возраст Город Страна e Иоанна 16 Нью-Йорк США f Майк 17 Лас Вегас США Удалите все строки, в которых столбец "Возраст" имеет значение больше 30, а страна - "Индия". Исходный фрейм данных Имя Возраст Город Страна валет 34 Sydeny Австралия b Рити 30 Дели Индия c Викас 31 Мумбаи Индия d Neelu 32 Бангалор Индия e Иоанна 16 Нью-Йорк США f Майк 17 Лас Вегас США Измененный фрейм данных Имя Возраст Город Страна валет 34 Sydeny Австралия e Иоанна 16 Нью-Йорк США f Майк 17 Лас Вегас США
Как удалить повторяющиеся данные из фрейма данных Python
Не все данные идеальны, и нам действительно нужно удалять повторяющиеся данные из нашего набора данных большую часть времени.Кажется, что удалить повторяющиеся данные легко, но на самом деле это не так. Иногда вы хотите просто удалить дубликаты из одного или нескольких столбцов, а в другой раз вы хотите удалить дубликаты на основе некоторого случайного условия. В этом посте мы увидим, как легко и эффективно удалить повторяющиеся данные с помощью функции drop_duplicates () в pandas
.
Создать фрейм данных с дубликатами данных
импортировать панд как pd
df = pd.DataFrame ({'Имя': ['Джон', 'Гарри', 'Гэри', 'Ричард', 'Анна', 'Ричард', 'Гэри'], 'Возраст': [25,32, 37,43,44,56,37], «Зона»: [«Восток», «Запад», «Север», «Юг», «Восток», «Запад», «Север»]})
Отбросьте повторяющиеся строки
Строки с индексами 2 и 6 в приведенном выше фрейме данных дублируются, и все три столбца Имя, Возраст и Зона совпадают для этих двух строк.Теперь мы удалим все повторяющиеся строки из фрейма данных с помощью функции drop_duplicates ()
.
Удалить дубликаты из определенного столбца и оставить последнюю строку
Мы сгруппируем строки для каждой зоны и оставим последнюю в каждой группе, т.е. для зоны Восток у нас есть две строки в исходном фрейме данных, то есть индекс 0 и 4, и мы хотим сохранить только индекс 4 в этой зоне
df.drop_duplicates ('Зона', keep = 'last')
Удалить дубликаты из определенного столбца и оставить первую строку
Мы сгруппируем строки для каждой зоны и оставим только первые в каждой группе i.е. Для зоны Восток у нас есть две строки в исходном фрейме данных, то есть индекс 0 и 4, и мы хотим сохранить только индекс 0 в этой зоне
df.drop_duplicates ('Зона', keep = 'first')
Удалить все дубликаты из определенного столбца
Мы удалим повторяющиеся строки в исходном фрейме данных, просто измените значение Keep на False
df.drop_duplicates ('Зона', keep = False)
Удалить дубликаты в группе, но оставить строку с максимальным значением
Мы сохраним ряды с максимальным возрастом в каждой зоне.Поэтому мы сначала отсортируем строки по возрасту в порядке возрастания, а затем отбросим дубликаты в столбец Zone и установим для параметра Keep значение Last.
df.sort_values ('Возраст', ascending = True) .drop_duplicates ('Zone', keep = 'last')
Удалить дубликаты в группе, но оставить строку с минимальным значением
Мы сохраним ряд с минимальным возрастом в каждой зоне. Поэтому мы сначала отсортируем строки по возрасту в порядке убывания, а затем отбросим дубликаты в столбец Zone и установим для параметра Keep значение Last.
df.sort_values ('Возраст', ascending = False) .drop_duplicates ('Zone', keep = 'last')
Выпадение дубликатов на основании условия
Мы удалим дубликаты на основе столбца Зона, если возраст больше 30
df [df.Age.gt (30) & ~ (df.duplicated (['Zone']))]
Удаление дубликатов в нескольких столбцах с использованием параметра подмножества
Вы также можете удалить дубликаты из нескольких столбцов.просто добавьте их как список в параметре подмножества. В нашем исходном фрейме данных нет такого значения, поэтому я создам фрейм данных и удалю дубликаты из более чем одного столбца
Вот фрейм данных со строкой с индексом 0 и 7 как дубликаты с тем же
импортировать панд как pd
df = pd.DataFrame ({'Имя': ['Джон', 'Гарри', 'Гэри', 'Ричард', 'Анна', 'Ричард', 'Гэри', 'Джон'], 'Возраст': [ 25,32,37,43,44,56,37,25], «Зона»: [«Восток», «Запад», «Север», «Юг», «Восток», «Запад», «Север», 'Запад']})
Теперь отбросьте одну из двух строк, установив параметр подмножества как список столбца
df.drop_duplicates (subset = ['Имя', 'Возраст'])
Выпадение дубликатов из серии
Мы также можем удалить дубликаты из серии Pandas. вот серия с несколькими повторяющимися строками
a = pd.Series ([1,2,3,3,2,2,1,4,5,6,6,7,8], index = [0,1,2,3,4,5 , 6,7,8,9,10,11,12])
а
Удаление дубликатов и сброс индекса
Мы удалим дубликаты из индекса серии и сбросим индекс с помощью функции reset_index (), иначе он будет иметь исходный индекс из серии после удаления дубликатов
а.