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:

import pandas as pd

  

import numpy as np

  

dict = {'First Score':[100, 90, np.nan, 95],

        'Second Score': [30, 45, 56, np.nan],

        'Third Score':[np.nan, 40, 80, 98]}

  

df = pd.DataFrame(dict)

  
df.isnull()

Выход:

Код № 2:

import pandas as pd 

    

data = pd.read_csv("employees.csv"

    

bool_series = pd.isnull(data["Gender"]) 

    
data[bool_series] 

Выход:
Как показано на выходном изображении, отображаются только строки, имеющие Gender = NULL .

Проверка пропущенных значений с использованием notnull()

Чтобы проверить нулевые значения в Pandas Dataframe, мы используем функцию notnull (), эта функция возвращает фрейм данных с логическими значениями, которые являются False для значений NaN.

Код № 3:

import pandas as pd

  

import numpy as np

  

dict = {'First Score':[100, 90, np.nan, 95],

        'Second Score': [30, 45, 56, np.nan],

        'Third Score':[np.nan, 40, 80, 98

]}

  

df = pd.DataFrame(dict)

  
df.notnull()

Выход:

Код № 4:

import pandas as pd 

    

data = pd.read_csv("employees.csv"

    

bool_series = pd.notnull(data["Gender"]) 

    
data[bool_series] 

Выход:
Как показано на выходном изображении, отображаются только строки, имеющие Gender = NOT NULL .

Заполнение пропущенных значений с помощью
fillna()
, replace() и interpolate()

Чтобы заполнить нулевые значения в наборах данных, мы используем fillna() , replace() и interpolate() эти функции заменяют значения NaN некоторым собственным значением. Все эти функции помогают заполнять нулевые значения в наборах данных DataFrame. Функция Interpolate () в основном используется для заполнения значений NA в кадре данных, но она использует различные методы интерполяции для заполнения отсутствующих значений, а не жесткое кодирование значения.

Код № 1: заполнение нулевых значений одним значением

import pandas as pd

  

import numpy as np

  

dict = {'First Score':[100, 90, np.nan, 95],

        'Second Score': [30, 45, 56, np.nan],

        'Third Score':[np.nan, 40, 80, 98]}

  

df = pd.DataFrame(dict)

  

df.fillna(0)

Выход:

Код № 2: заполнение нулевых значений предыдущими

import pandas as pd

  

import numpy as np

  

dict = {'First Score':[100, 90, np.nan, 95],

        'Second Score': [30, 45, 56, np.nan],

        'Third Score':[np.nan, 40, 80, 98]}

  

df = pd.DataFrame(dict)

  

df.fillna(method =

'pad')

Выход:

Код № 3: заполнение нулевого значения следующими

import pandas as pd

  

import numpy as np

  

dict = {'First Score':[100, 90, np.nan, 95],

        'Second Score': [30, 45, 56, np.nan],

        'Third Score':[np.nan, 40, 80,

98]}

  

df = pd.DataFrame(dict)

  

df.fillna(method ='bfill')

Выход:

Код № 4: заполнение нулевых значений в файле CSV

import pandas as pd 

    

data = pd.read_csv("employees.csv")

  

data[10:25]


Теперь мы собираемся заполнить все нулевые значения в столбце «Пол» «Нет пола»

import pandas as pd 

    

data = pd.read_csv("employees.csv"

  

data["Gender"].fillna("No Gender", inplace = True

  
data

Выход:

Код № 5: Заполнение нулевых значений методом replace ()

import pandas as pd 

    

data = pd.read_csv("employees.csv")

  

data[10:25

]

Выход:

Теперь мы собираемся заменить все значения Nan во фрейме данных значением -99.

import pandas as pd 

    

data = pd.read_csv("employees.csv"

    

data.replace(to_replace = np.nan, value = -99

Выход:

Код № 6: Использование функции interpolate () для заполнения пропущенных значений линейным методом.

import pandas as pd 

    

df = pd.DataFrame({"A":[12, 4, 5, None, 1], 

                   "B":[None, 2, 54, 3, None], 

                   "C":[20, 16, None, 3, 8], 

                   "D":[14, 3, None, None, 6]}) 

    
df 


Давайте интерполируем пропущенные значения, используя линейный метод. Обратите внимание, что линейный метод игнорирует индекс и обрабатывает значения как одинаково расположенные.

df.interpolate(method ='linear', limit_direction ='forward')

Выход:

Как мы видим на выходе, значения в первой строке не могут быть заполнены, так как направление заполнения значений является прямым, и нет предыдущего значения, которое могло бы использоваться при интерполяции.

Удаление пропущенных значений с помощью dropna()

Чтобы удалить нулевые значения из фрейма данных, мы использовали dropna() эта функция по- dropna() строки / столбцы наборов данных со значениями Null.

Код № 1: удаление строк с как минимум 1 нулевым значением.

import pandas as pd

  

import numpy as np

  

dict = {'First Score':[100, 90, np.nan, 95],

        'Second Score': [30, np.nan, 45, 56],

        'Third Score':[52, 40, 80, 98],

        'Fourth Score':[np.nan, np.nan, np.nan, 65]}

  

df = pd.DataFrame(dict)

    
df


Теперь мы отбрасываем строки как минимум с одним значением Nan (нулевое значение)

import pandas as pd

  

import numpy as np

  

dict = {'First Score':[100, 90, np.nan, 95],

        'Second Score': [30, np.nan, 45, 56],

        'Third Score':[52, 40, 80, 98],

        'Fourth Score':[np.nan, np.nan, np.nan, 65]}

  

df = pd.DataFrame(dict)

  
df.dropna()

Выход:

Код № 2: Удаление строк, если все значения в этой строке отсутствуют.

import pandas as pd

  

import numpy as np

  

dict = {'First Score':[100, np.nan, np.nan, 95],

        'Second Score': [30, np.nan, 45, 56],

        'Third Score':[52, np.nan, 80, 98],

        'Fourth Score':[np.nan, np.nan, np.nan, 65]}

  

df = pd.DataFrame(dict)

    
df


Теперь мы отбрасываем строки, в которых все данные отсутствуют или содержат нулевые значения (NaN).

import pandas as pd

  

import numpy as np

  

dict = {'First Score':[100, np.nan, np.nan, 95],

        'Second Score': [30, np.nan, 45, 56],

        'Third Score':[52, np.nan, 80, 98],

        'Fourth Score':[np.nan, np.nan, np.nan, 65]}

  

df = pd.DataFrame(dict)

  

df.dropna(how = 'all')

Выход:

Код № 3: удаление столбцов с как минимум 1 нулевым значением.

import pandas as pd

   

import numpy as np

   

dict = {'First Score':[100, np.nan, np.nan, 95],

        'Second Score': [30, np.nan, 45, 56],

        'Third Score':[52, np.nan, 80, 98],

        'Fourth Score':[60, 67, 68, 65]}

  

df = pd.DataFrame(dict)

     
df


Теперь мы отбрасываем столбцы, которые имеют по крайней мере 1 пропущенных значений

import pandas as pd

   

import numpy as np

   

dict = {'First Score':[100, np.nan, np.nan, 95],

        'Second Score': [30, np.nan, 45, 56],

        'Third Score':[52, np.nan, 80, 98],

        'Fourth Score':[60, 67, 68, 65]}

  

df = pd.DataFrame(dict)

  

df.dropna(axis = 1)

Выход :

Код № 4: удаление строк с как минимум 1 нулевым значением в файле CSV

import pandas as pd 

    

data = pd.read_csv("employees.csv"

    

new_data = data.dropna(axis = 0, how ='any'

    
new_data

Выход:

Теперь мы сравним размеры фреймов данных, чтобы мы могли узнать, сколько строк имеют хотя бы 1 пустое значение

print("Old data frame length:", len(data))

print("New data frame length:", len(new_data)) 

print("Number of rows with at least 1 NA value: ", (len(data)-len(new_data)))

Выход :

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()

Это даст следующий результат:

Вы увидите список всех столбцов в вашем наборе данных и тип данных, содержащихся в каждом столбце. Здесь вы можете увидеть типы данных int64float64 и 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 объекта с именем revenuesSeries объект состоит из двух компонентов:

  1. Последовательность значений
  2. Последовательность идентификаторов, которые являются индексом

Вы можете получить доступ к этим компонентам с .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:

  1. revenues: Series ведет себя как список Python , потому что он имеет только позиционное индекс.
  2. 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 объекта с городами в качестве ключей:

  1. city_revenues
  2. 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')

Как и SeriesDataFrame также хранит свои значения в массиве 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 параметр.

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 метода доступа:

  1. .loc
  2. .iloc

Вы увидите, что эти методы доступа к данным могут быть гораздо более удобочитаемыми, чем оператор индексации.

Использование оператора индексации

Напомним, что a Series имеет два индекса:

  1. Позиционный или неявный индекс , который всегдаRangeIndex
  2. Метка или явный индекс , который может содержать любые хешируемые объекты

Затем снова посетите 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 предоставляет два метода доступа к данным:

  1. .loc относится к метке индекса .
  2. .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 поведения:

  1. Вы можете использовать .iloc по Series аналогии с использованием [] в списке .
  2. Вы можете использовать .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:

  1. city_data.loc["Amsterdam"] выбирает строку с индексом метки "Amsterdam".
  2. city_data.loc["Tokyo": "Toronto"] выбирает строки с индексами меток от "Tokyo" до "Toronto". Помните, .loc это включено.
  3. 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".

Вы можете объединить несколько критериев и запросить свой набор данных. Чтобы сделать это, обязательно поставьте каждый в круглые скобки и используйте логические операторы | и & разделите их.

Примечание: Операторы andor&& и || не будет работать здесь. Если вам интересно, почему, то ознакомьтесь с разделом о том, как библиотека 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

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 KeyCreated DateClosed DateAgencyAgency NameComplaint TypeDescriptorLocation TypeIncident ZipIncident AddressBridge Highway NameBridge Highway DirectionRoad RampBridge Highway SegmentGarage Lot NameFerry DirectionFerry Terminal NameLatitudeLongitudeLocation
02658965110/31/2013 02:08:41 AMNaNNYPDNew York City Police DepartmentNoise — Street/SidewalkLoud TalkingStreet/Sidewalk1143290-03 169 STREETNaNNaNNaNNaNNaNNaNNaN40.708275-73.791604(40.70827532593202, -73.79160395779721)
12659369810/31/2013 02:01:04 AMNaNNYPDNew York City Police DepartmentIllegal ParkingCommercial Overnight ParkingStreet/Sidewalk1137858 AVENUENaNNaNNaNNaNNaNNaNNaN40.721041-73.909453(40.721040535628305, -73.90945306791765)
22659413910/31/2013 02:00:24 AM10/31/2013 02:40:32 AMNYPDNew York City Police DepartmentNoise — CommercialLoud Music/PartyClub/Bar/Restaurant100324060 BROADWAYNaNNaNNaNNaNNaNNaNNaN40.843330-73.939144(40.84332975466513, -73.93914371913482)
32659572110/31/2013 01:56:23 AM10/31/2013 02:21:48 AMNYPDNew York City Police DepartmentNoise — VehicleCar/Truck HornStreet/Sidewalk10023WEST 72 STREETNaNNaNNaNNaNNaNNaNNaN40.778009-73.980213(40.7780087446372, -73.98021349023975)
42659093010/31/2013 01:53:44 AMNaNDOHMHDepartment of Health and Mental HygieneRodentCondition Attracting RodentsVacant Lot10027WEST 124 STREETNaNNaNNaNNaNNaNNaNNaN40.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 TypeBorough
0Noise — Street/SidewalkQUEENS
1Illegal ParkingQUEENS
2Noise — CommercialMANHATTAN
3Noise — VehicleMANHATTAN
4RodentMANHATTAN
5Noise — CommercialQUEENS
6Blocked DrivewayQUEENS
7Noise — CommercialQUEENS
8Noise — CommercialMANHATTAN
9Noise — CommercialBROOKLYN
10Noise — House of WorshipBROOKLYN
11Noise — CommercialMANHATTAN
12Illegal ParkingMANHATTAN
13Noise — VehicleBRONX
14RodentBROOKLYN
15Noise — House of WorshipMANHATTAN
16Noise — Street/SidewalkSTATEN ISLAND
17Illegal ParkingBROOKLYN
18Street Light ConditionBROOKLYN
19Noise — CommercialMANHATTAN
20Noise — House of WorshipBROOKLYN
21Noise — CommercialMANHATTAN
22Noise — VehicleQUEENS
23Noise — CommercialBROOKLYN
24Blocked DrivewaySTATEN ISLAND
25Noise — Street/SidewalkSTATEN ISLAND
26Street Light ConditionBROOKLYN
27Harboring Bees/WaspsMANHATTAN
28Noise — Street/SidewalkMANHATTAN
29Street Light ConditionSTATEN ISLAND
111039Noise — CommercialMANHATTAN
111040Noise — CommercialMANHATTAN
111041NoiseBROOKLYN
111042Noise — Street/SidewalkMANHATTAN
111043Noise — CommercialBROOKLYN
111044Noise — Street/SidewalkMANHATTAN
111045Water SystemMANHATTAN
111046NoiseBROOKLYN
111047Illegal ParkingQUEENS
111048Noise — Street/SidewalkMANHATTAN
111049Noise — CommercialBROOKLYN
111050NoiseMANHATTAN
111051Noise — CommercialMANHATTAN
111052Water SystemMANHATTAN
111053Derelict VehiclesQUEENS
111054Noise — Street/SidewalkBROOKLYN
111055Noise — CommercialBROOKLYN
111056Street Sign — MissingQUEENS
111057NoiseMANHATTAN
111058Noise — CommercialBROOKLYN
111059Noise — Street/SidewalkMANHATTAN
111060NoiseMANHATTAN
111061Noise — CommercialQUEENS
111062Water SystemMANHATTAN
111063Water SystemMANHATTAN
111064Maintenance or FacilityBROOKLYN
111065Illegal ParkingQUEENS
111066Noise — Street/SidewalkMANHATTAN
111067Noise — CommercialBROOKLYN
111068Blocked DrivewayBROOKLYN

111069 rows × 2 columns

Посмотрим первые 10 строк:

In [7]:

complaints[['Complaint Type', 'Borough']][:10]

Out[7]:

Complaint TypeBorough
0Noise — Street/SidewalkQUEENS
1Illegal ParkingQUEENS
2Noise — CommercialMANHATTAN
3Noise — VehicleMANHATTAN
4RodentMANHATTAN
5Noise — CommercialQUEENS
6Blocked DrivewayQUEENS
7Noise — CommercialQUEENS
8Noise — CommercialMANHATTAN
9Noise — CommercialBROOKLYN

Какой самый частый тип жалобы?

Это очень простой вопрос для 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 .

импорт панд как pd

данные = {

'A' : [ 'A1' , 'A2' , 'A3' , 'A4' , 'A5 ],

'B' : [ 'B1' , 'B2' , 'B3' , 'B4' ' ],

'C' : [ 'C1' , 'C2' , 'C3' , 'C4' ' ],

'D' : [ 'D1' , 'D2' , 'D3' , 'D4' , ],

'E' : [ 'E1' , 'E2' , 'E3' , 'E4' , ]}

df = pd.DataFrame (данные)

df

Выход:

Метод № 1: Удаление столбцов из фрейма данных с использованием метода drop () .

Удалить отдельный столбец.



импорт панд как pd

данные = {

'A' : [ 'A1' , 'A2' , 'A3' , 'A4' , 'A5 ],

'B' : [ 'B1' , 'B2' , 'B3' , 'B4' ' ],

'C' : [ 'C1' , 'C2' , 'C3' , 'C4' ' ],

'D' : [ 'D1' , 'D2' , 'D3' , 'D4' , ],

'E' : [ 'E1' , 'E2' , 'E3' , 'E4' , ]}

df = pd.DataFrame (данные)

df.drop ([ 'A' ], ось = 1 )

Выход:


Удалить несколько определенных столбцов.

импорт панд как pd

данные = {

'A' : [ 'A1' , 'A2' , 'A3' , 'A4' , 'A5 ],

'B' : [ 'B1' , 'B2' , 'B3' , 'B4' ' ],

'C' : [ 'C1' , 'C2' , 'C3' , 'C4' ' ],

'D' : [ 'D1' , 'D2' , 'D3' , 'D4' , ],

'E' : [ 'E1' , 'E2' , 'E3' , 'E4' , ]}

df = pd.DataFrame (данные)

df.drop ([ 'C' , 'D' ], ось = 1 )

Выход:

Удалить столбцы на основе индекса столбца.

импорт панд как pd

данные = {

'A' : [ 'A1' , 'A2' , 'A3' , 'A4' , 'A5 ],

'B' : [ 'B1' , 'B2' , 'B3' , 'B4' ' ],

'C' : [ 'C1' , 'C2' , 'C3' , 'C4' ' ],

'D' : [ 'D1' , 'D2' , 'D3' , 'D4' , ],

'E' : [ 'E1' , 'E2' , 'E3' , 'E4' , ]}

df = pd.DataFrame (данные)

df.drop (df.columns [[ 0 , 4 , 2 ]], ось = 1 , inplace = )

df

Выход:

Метод № 2: Удаление столбцов из фрейма данных с использованием метода iloc [] и drop () .

Удалить все столбцы между одним столбцом и другим столбцом.



импорт панд как pd

данные = {

'A' : [ 'A1' , 'A2' , 'A3' , 'A4' , 'A5 ],

'B' : [ 'B1' , 'B2' , 'B3' , 'B4' ' ],

'C' : [ 'C1' , 'C2' , 'C3' , 'C4' ' ],

'D' : [ 'D1' , 'D2' , 'D3' , 'D4' , ],

'E' : [ 'E1' , 'E2' , 'E3' , 'E4' , ]}

df = pd.DataFrame (данные)

df.drop (df.iloc [:, 1 : 3 ], inplace = True , ось = 1 )

df

Выход:

Метод № 3: Удаление столбцов из Dataframe с использованием методов ix () и drop () .

Удалить все столбцы между одним именем столбца и именем другого столбца.

импорт панд как pd

данные = {

'A' : [ 'A1' , 'A2' , 'A3' , 'A4' , 'A5 ],

'B' : [ 'B1' , 'B2' , 'B3' , 'B4' ' ],

'C' : [ 'C1' , 'C2' , 'C3' , 'C4' ' ],

'D' : [ 'D1' , 'D2' , 'D3' , 'D4' , ],

'E' : [ 'E1' , 'E2' , 'E3' , 'E4' , ]}

df = pd.DataFrame (данные)

df.drop (df.ix [:, 'B' : 'D' ] .columns, ось = 1 )

Выход:


Метод № 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 (), иначе он будет иметь исходный индекс из серии после удаления дубликатов

  а.
        
	

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *

Theme: Overlay by Kaira Extra Text
Cape Town, South Africa