Выбор нескольких столбцов в кадре данных Pandas

avatar
user1234440
1 июля 2012 в 21:03
3067687
21
1456

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

index  a   b   c
1      2   3   4
2      3   4   5

Как выбрать 'a', 'b' и сохранить его в df1?

Я пробовал

df1 = df['a':'b']
df1 = df.ix[:, 'a':'b']

Кажется, ничего не работает.

Источник
Asclepius
12 июля 2017 в 17:14
4

Вы никогда не захотите использовать .ix, поскольку это неоднозначно. При необходимости используйте .iloc или .loc.

MichaelR
19 октября 2018 в 00:30
1

Есть ли способ сделать это без обращения к именам заголовков? как и в R, я могу сделать это так: > csvtable_imp_1 <- csvtable_imp[0:6], и он выбирает величину дельты первых столбцов от 0 до 6. Все, что мне нужно было сделать, это прочитать csv-таблицу, разделенную readr lib.

MichaelR
19 октября 2018 в 00:43
0

Я еще немного поработал с этим. Нашел то, что работало как хотел. По умолчанию выбирается количество символов, а не столбцов. infile_1 = largefile_stay.ix[:,0:6]

ZaydH
4 декабря 2018 в 16:20
4

Для тех, кто наткнулся на это поздно, ix теперь устарел. Pandas рекомендует использовать либо: loc (индексирование на основе меток), либо iloc (индексирование на основе позиций).

Connor
24 марта 2019 в 20:18
1

Pandas: Замена для .ix

Ответы (21)

avatar
ely
2 июля 2012 в 02:43
2264

Имена столбцов (которые являются строками) нельзя разрезать так, как вы пытались.

Здесь у вас есть несколько вариантов. Если вы знаете из контекста, какие переменные вы хотите вырезать, вы можете просто вернуть представление только для этих столбцов, передав список в синтаксис __getitem__ ([]).

df1 = df[['a', 'b']]

В качестве альтернативы, если важно индексировать их численно, а не по имени (скажем, ваш код должен делать это автоматически, не зная имен первых двух столбцов), вы можете сделать это вместо этого:

df1 = df.iloc[:, 0:2] # Remember that Python does not slice inclusive of the ending index.

Кроме того, вам следует ознакомиться с идеей представления объекта Pandas по сравнению с копией этого объекта. Первый из вышеперечисленных методов вернет новую копию в памяти желаемого подобъекта (желаемых срезов).

Иногда, однако, существуют соглашения об индексировании в Pandas, которые не делают этого и вместо этого предоставляют вам новую переменную, которая просто ссылается на тот же фрагмент памяти, что и подобъект или фрагмент в исходном объекте. Это произойдет при втором способе индексации, поэтому вы можете изменить его с помощью метода .copy(), чтобы получить обычную копию. Когда это происходит, изменение того, что вы считаете разрезанным объектом, иногда может изменить исходный объект. Всегда хорошо быть начеку.

df1 = df.iloc[0, 0:2].copy() # To avoid the case where changing df1 also changes df

Чтобы использовать iloc, вам необходимо знать позиции столбцов (или индексы). Поскольку позиции столбцов могут меняться, вместо жестко заданных индексов вы можете использовать iloc вместе с get_loc функцией метода columns объекта dataframe для получения индексов столбцов.

{df.columns.get_loc(c): c for idx, c in enumerate(df.columns)}

Теперь вы можете использовать этот словарь для доступа к столбцам через имена и используя iloc.

Wes McKinney
8 июля 2012 в 17:54
247

Примечание: df[['a','b']] создает копию

ely
8 июля 2012 в 18:09
1

Да, это подразумевалось в моем ответе. Бит о копии предназначен только для использования ix[], если вы предпочитаете использовать ix[] по какой-либо причине.

hobs
31 октября 2012 в 18:58
1

ix индексирует строки, а не столбцы. Я думал, ОП нужны колонны.

ely
31 октября 2012 в 19:02
11

ix принимает аргументы среза, поэтому вы также можете получать столбцы. Например, df.ix[0:2, 0:2] получает верхний левый подмассив 2x2, как и для матрицы NumPy (конечно, в зависимости от имен столбцов). Вы даже можете использовать синтаксис среза для строковых имен столбцов, например df.ix[0, 'Col1':'Col5']. Это получает все столбцы, которые упорядочены между Col1 и Col5 в массиве df.columns. Неверно сказать, что ix индексирует строки. Это его самое основное использование. Он также поддерживает гораздо больше индексирования, чем это. Итак, ix идеально подходит для этого вопроса.

Antoine
6 апреля 2016 в 14:51
1

что, если я хочу выбрать непоследовательные столбцы, например, index_retain=c(1,3,9)? в R я бы просто сделал my_data_frame[,index_retain]

ely
6 апреля 2016 в 16:23
1

@Antoine Соответствующая документация связана здесь. Короткий ответ - использовать помощник индексации iloc, например my_data_frame.iloc[:, [1, 3, 9]] в вашем примере. Имейте в виду, что индексирование Python начинается с нуля. Однако в более широком смысле, поскольку DataFrame обычно предназначен для представления реляционной структуры данных без неявного упорядочивания столбцов, иногда безопаснее просто написать свои собственные вспомогательные функции, которые ссылаются на столбцы по имени и устраняют любую потребность в доступе к ним. по должности.

ely
6 апреля 2016 в 16:26
0

Например, если вы создаете экземпляр DataFrame из dict, поскольку dict по своей сути неупорядочен, а порядок повторяемых элементов будет зависеть от (произвольного) порядка, в котором элементы были сохранены во время конструктора dict, а затем от одного выполнения вашей программы до затем порядок столбцов может измениться. Подобные вещи могут произойти, если вы сериализуете данные, например, файл .csv, а затем загрузить из файла в другой программе. Во многих случаях порядок будет стабильным, но это редкие несколько угловых случаев, когда вы предполагали, что позиционный порядок был стабильным, но на самом деле это не было причиной проблем.

bincob
11 марта 2017 в 03:16
0

Нарезка в .ix () является инклюзивной, когда вы используете метки, и когда сами метки являются целыми числами, тогда нарезка происходит с учетом конечного индекса. Попробуйте следующий фрагмент ... df = pd.DataFrame (np.ones ([2,3])) print df df.ix [:, 1: 2] = 0 print df

Andrew Cassidy
23 июня 2017 в 01:31
0

df.ix [:, 0: 2] включает ли срез? df.ix [:, 0: 2] .shape # (2, 3)? Я знаю, что ix устарела

Ted Petrou
1 июля 2017 в 13:55
7

@AndrewCassidy Никогда больше не используйте .ix. Если вы хотите нарезать целые числа, используйте .iloc, который не учитывает последнюю позицию, как списки Python.

CuriousLearner
13 января 2018 в 01:43
0

Избегает ли функция "mean" нулевых значений? Я имею в виду, что если бы у меня было всего 3 столбца, и один из столбцов был пуст для определенной строки, тогда функция среднего должна просто возвращать среднее значение двух столбцов. Это так?

Bowen Liu
19 сентября 2018 в 20:33
0

Как бы вы использовали метод .iloc, если нам нужно выбрать столбцы a и c, которые не находятся рядом друг с другом? Спасибо.

Connor
24 марта 2019 в 20:17
0

@ely ix является устаревшим.

Marses
18 июля 2019 в 15:08
1

Старая ветка, но требующая разъяснений, поскольку она, вероятно, не стоит отдельного вопроса. В случае индексации типа df[['a','b']] гарантируется ли сохранение порядка столбцов (то есть a, затем b)? Так, например, df.loc[0, ['a','b']].to_numpy(), будет иметь значение, в каком порядке были столбцы.

324
12 сентября 2019 в 01:40
0

Как бы вы взяли, скажем, только столбцы 2 и 5?

ely
12 сентября 2019 в 12:19
5

@ dte324 Если ваш DataFrame называется df, используйте df.iloc[:, [1, 4]]. Обычно, если вам нужен этот тип шаблона доступа, вы уже знаете эти конкретные имена столбцов, и вы можете просто использовать df.loc[:, ['name2', 'name5']], где 'name2' и 'name5' - имена строк ваших столбцов для соответствующих столбцов, которые вы хотите, или посмотрите имена вверх с например name2 = df.columns[1].

Grijesh Chauhan
25 декабря 2019 в 14:27
1

Этот ответ кажется устаревшим?

billiam
23 июля 2020 в 15:12
0

Если df[['a','b']] создает копию, почему необходимо использовать .copy(), т.е. df[['a','b']].copy(), чтобы избежать SettingWithCopyWarning?

questionto42
5 августа 2020 в 13:22
0

@billiam, не могли бы вы задать новый вопрос по этому поводу? Я хотел бы знать, правильно ли, что df[['a','b']] является копией, и рекомендуется ли, помимо прочего, .loc / .iloc.

Bálint Sass
13 февраля 2021 в 10:30
0

@BowenLiu сюда; df.iloc[:, [0, 2]]

WestCoastProjects
13 сентября 2021 в 22:15
0

Кажется, что выбранные столбцы должны быть в индексе ?? Такой подход в этом случае [довольно] неудобен. Кажется, df.filter (cols) делает именно то, что нужно

avatar
Mykola Zotko
4 мая 2021 в 08:19
2

Чтобы исключить некоторые столбцы, вы можете отбросить их в индекс столбца. Например:

   A   B    C     D
0  1  10  100  1000
1  2  20  200  2000

Выбрать все, кроме двух:

df[df.columns.drop(['B', 'D'])]

Вывод:

   A    C
0  1  100
1  2  200

Вы также можете использовать метод truncate для выбора средних столбцов:

df.truncate(before='B', after='C', axis=1)

Вывод:

    B    C
0  10  100
1  20  200
avatar
Suleyman Suleymanzade
2 мая 2021 в 21:20
2
def get_slize(dataframe, start_row, end_row, start_col, end_col):
    assert len(dataframe) > end_row and start_row >= 0
    assert len(dataframe.columns) > end_col and start_col >= 0
    list_of_indexes = list(dataframe.columns)[start_col:end_col]
    ans = dataframe.iloc[start_row:end_row][list_of_indexes]
    return ans

Просто используйте эту функцию

avatar
Ivan Vrzogic
11 октября 2020 в 10:40
3

Чтобы выбрать несколько столбцов, извлеките и просмотрите их после этого: df - это ранее названный фрейм данных, затем создайте новый фрейм данных df1 и выберите столбцы от A до D, которые вы хотите извлечь и просмотреть.

df1 = pd.DataFrame(data_frame, columns=['Column A', 'Column B', 'Column C', 'Column D'])
df1

Появятся все обязательные столбцы!

avatar
Juan Miguel Díaz Pérez
2 августа 2020 в 19:10
7

Попробуйте использовать pandas.DataFrame.get (см. документацию):

import pandas as pd
import numpy as np

dates = pd.date_range('20200102', periods=6)
df = pd.DataFrame(np.random.randn(6, 4), index=dates, columns=list('ABCD'))
df.get(['A', 'C'])
avatar
Biplob Das
19 мая 2020 в 08:18
7
df[['a', 'b']]  # Select all rows of 'a' and 'b'column 
df.loc[0:10, ['a', 'b']]  # Index 0 to 10 select column 'a' and 'b'
df.loc[0:10, 'a':'b']  # Index 0 to 10 select column 'a' to 'b'
df.iloc[0:10, 3:5]  # Index 0 to 10 and column 3 to 5
df.iloc[3, 3:5]  # Index 3 of column 3 to 5
maciejwww
10 октября 2020 в 01:35
0

В третьей строке должно быть df.loc[0:10, 'a':'b']. Я его только что отредактировал.

avatar
Ramin Melikov
21 апреля 2020 в 03:03
21

Вы можете использовать метод pandas.DataFrame.filter для фильтрации или изменения порядка столбцов следующим образом:

df1 = df.filter(['a', 'b'])

Это также очень полезно при связывании методов.

JohnE
26 февраля 2021 в 15:48
2

filter великолепен и не так хорошо известен, как должен быть. В частности, вы также можете использовать такие регулярные выражения: df.filter(regex='a|b'). У меня есть более длинный пример ответа на этот вопрос: coderhelper.com/questions/29241836/…

flipSTAR
29 марта 2021 в 14:50
2

filter также может игнорировать несуществующие столбцы в "items = .. list", что иногда бывает очень полезно!

WestCoastProjects
13 сентября 2021 в 22:16
1

Это лучший ответ

avatar
Kareem Jeiroudi
26 мая 2019 в 19:21
3

Я видел несколько ответов на этот вопрос, но один остался для меня непонятным. Как бы вы выбрали интересующие вас столбцы?

Ответ на этот вопрос заключается в том, что если они собраны в списке, вы можете просто ссылаться на столбцы, используя список.

Пример

print(extracted_features.shape)
print(extracted_features)

(63,)
['f000004' 'f000005' 'f000006' 'f000014' 'f000039' 'f000040' 'f000043'
 'f000047' 'f000048' 'f000049' 'f000050' 'f000051' 'f000052' 'f000053'
 'f000054' 'f000055' 'f000056' 'f000057' 'f000058' 'f000059' 'f000060'
 'f000061' 'f000062' 'f000063' 'f000064' 'f000065' 'f000066' 'f000067'
 'f000068' 'f000069' 'f000070' 'f000071' 'f000072' 'f000073' 'f000074'
 'f000075' 'f000076' 'f000077' 'f000078' 'f000079' 'f000080' 'f000081'
 'f000082' 'f000083' 'f000084' 'f000085' 'f000086' 'f000087' 'f000088'
 'f000089' 'f000090' 'f000091' 'f000092' 'f000093' 'f000094' 'f000095'
 'f000096' 'f000097' 'f000098' 'f000099' 'f000100' 'f000101' 'f000103']

У меня есть следующий массив list / NumPy extracted_features, в котором указано 63 столбца. Исходный набор данных имеет 103 столбца, и я хотел бы извлечь именно их, тогда я бы использовал

dataset[extracted_features]

И вы получите это

Enter image description here

Это то, что вы довольно часто будете использовать в машинном обучении (точнее, при выборе функций). Я хотел бы обсудить и другие способы, но я думаю, что они уже были рассмотрены другими пользователями Stack Overflower.

avatar
pink.slash
20 февраля 2019 в 01:01
14

Вы можете использовать Pandas.

Я создаю DataFrame:

import pandas as pd
df = pd.DataFrame([[1, 2,5], [5,4, 5], [7,7, 8], [7,6,9]],
                  index=['Jane', 'Peter','Alex','Ann'],
                  columns=['Test_1', 'Test_2', 'Test_3'])

DataFrame:

       Test_1  Test_2  Test_3
Jane        1       2       5
Peter       5       4       5
Alex        7       7       8
Ann         7       6       9

Чтобы выбрать один или несколько столбцов по имени:

df[['Test_1', 'Test_3']]

       Test_1  Test_3
Jane        1       5
Peter       5       5
Alex        7       8
Ann         7       9

Вы также можете использовать:

df.Test_2

И вы получите столбец Test_2:

Jane     2
Peter    4
Alex     7
Ann      6

Вы также можете выбрать столбцы и строки из этих строк, используя .loc() . Это называется «нарезкой» . Обратите внимание, что я беру из столбца Test_1 в Test_3:

df.loc[:, 'Test_1':'Test_3']

"Срез":

       Test_1  Test_2  Test_3
Jane        1       2       5
Peter       5       4       5
Alex        7       7       8
Ann         7       6       9

И если вам просто нужны Peter и Ann из столбцов Test_1 и Test_3:

df.loc[['Peter', 'Ann'], ['Test_1', 'Test_3']]

Вы получите:

       Test_1  Test_3
Peter       5       5
Ann         7       9
avatar
Puneet Sinha
29 января 2019 в 05:37
5

Вы также можете использовать df.pop ():

>>> df = pd.DataFrame([('falcon', 'bird',    389.0),
...                    ('parrot', 'bird',     24.0),
...                    ('lion',   'mammal',   80.5),
...                    ('monkey', 'mammal', np.nan)],
...                   columns=('name', 'class', 'max_speed'))
>>> df
     name   class  max_speed
0  falcon    bird      389.0
1  parrot    bird       24.0
2    lion  mammal       80.5
3  monkey  mammal

>>> df.pop('class')
0      bird
1      bird
2    mammal
3    mammal
Name: class, dtype: object

>>> df
     name  max_speed
0  falcon      389.0
1  parrot       24.0
2    lion       80.5
3  monkey        NaN

Используйте df.pop(c).

avatar
Wickkiey
21 ноября 2018 в 15:32
48

С пандами,

остроумие имен столбцов

dataframe[['column1','column2']]

для выбора по iloc и определенным столбцам с номером индекса:

dataframe.iloc[:,[1,2]]

с именами столбцов loc может использоваться как

dataframe.loc[:,['column1','column2']]
avatar
Ankita
15 октября 2018 в 11:43
8

Другой простой подход: итерация строк

Использование iterows

 df1 = pd.DataFrame() # Creating an empty dataframe
 for index,i in df.iterrows():
    df1.loc[index, 'A'] = df.loc[index, 'A']
    df1.loc[index, 'B'] = df.loc[index, 'B']
    df1.head()
cs95
9 июня 2019 в 03:49
8

Не рекомендуется использовать iterrows (). Это явный стимул к худшему антипаттерну в истории панд.

Ankita
9 июня 2019 в 19:41
0

Не могли бы вы объяснить, что вы подразумеваете под «худшим антипаттерном»?

Elf
16 августа 2019 в 14:07
2

IMHO, iterrows () должен быть последним вариантом при использовании pandas.

avatar
tozCSS
15 августа 2018 в 18:13
25

Начиная с версии 0.21.0, использование .loc или [] со списком с одной или несколькими недостающими метками не рекомендуется в пользу .reindex. Итак, ответ на ваш вопрос:

df1 = df.reindex(columns=['b','c'])

В предыдущих версиях использование .loc[list-of-labels] работало бы до тех пор, пока был найден хотя бы один из ключей (в противном случае это привело бы к возникновению KeyError). Это поведение устарело, и теперь отображается предупреждающее сообщение. Рекомендуемая альтернатива - использовать .reindex().

Подробнее на Индексирование и выбор данных.

avatar
Harshit
21 июля 2018 в 21:28
6

Различные подходы, обсуждаемые в предыдущих ответах, основаны на предположении, что либо пользователь знает индексы столбцов, которые нужно отбросить или подмножество, либо пользователь желает подмножество фрейма данных, используя диапазон столбцов (например, между 'C': 'E').

pandas.DataFrame.drop () , безусловно, является вариантом подмножества данных на основе списка столбцов, определенного пользователем (хотя вы должны быть осторожны, всегда используйте копию фрейма данных и inplace параметры не должны быть установлены на True !!)

Другой вариант - использовать pandas.columns.difference () , который устанавливает различие в именах столбцов и возвращает тип индекса массива, содержащего желаемые столбцы. Ниже приводится решение:

df = pd.DataFrame([[2,3,4], [3,4,5]], columns=['a','b','c'], index=[1,2])
columns_for_differencing = ['a']
df1 = df.copy()[df.columns.difference(columns_for_differencing)]
print(df1)

Результатом будет:

    b   c
1   3   4
2   4   5
Bazyli Debowski
8 августа 2018 в 17:20
1

Копия () не нужна. то есть: df1 = df[df.columns.difference(columns_for_differencing)] вернет новый / скопированный фрейм данных. Вы сможете изменить df1 без изменения df. Спасибо, кстати. Это было именно то, что мне было нужно.

avatar
W.Perrin
3 января 2018 в 07:56
10

Если вы хотите получить один элемент по индексу строки и имени столбца, вы можете сделать это так же, как df['b'][0]. Это так просто, как вы можете себе представить.

Или вы можете использовать df.ix[0,'b'] - смешанное использование индекса и метки.

Примечание: Начиная с версии 0.20, ix устарел в пользу loc / iloc.

avatar
Alvis
2 мая 2017 в 09:41
24

Я нашел этот метод очень полезным:

# iloc[row slicing, column slicing]
surveys_df.iloc [0:3, 1:4]

Более подробную информацию можно найти здесь.

324
12 сентября 2019 в 01:40
0

Как бы вы взяли, скажем, только столбцы 2 и 5?

Julian Gorfer
3 октября 2019 в 08:43
2

Тогда это будет surveys_df.iloc [:, [2,5]].

avatar
ayhan
30 апреля 2016 в 12:39
200

Начиная с версии 0.11.0, столбцы могут быть нарезаны так, как вы пытались использовать .loc индексатор:

df.loc[:, 'C':'E']

эквивалентно

df[['C', 'D', 'E']]  # or df.loc[:, ['C', 'D', 'E']]

и возвращает столбцы от C до E.


Демонстрация случайно сгенерированного DataFrame:

import pandas as pd
import numpy as np
np.random.seed(5)
df = pd.DataFrame(np.random.randint(100, size=(100, 6)),
                  columns=list('ABCDEF'),
                  index=['R{}'.format(i) for i in range(100)])
df.head()

Out:
     A   B   C   D   E   F
R0  99  78  61  16  73   8
R1  62  27  30  80   7  76
R2  15  53  80  27  44  77
R3  75  65  47  30  84  86
R4  18   9  41  62   1  82

Чтобы получить столбцы от C до E (обратите внимание, что в отличие от целочисленного среза, в столбцы включается 'E'):

df.loc[:, 'C':'E']

Out:
      C   D   E
R0   61  16  73
R1   30  80   7
R2   80  27  44
R3   47  30  84
R4   41  62   1
R5    5  58   0
...

То же самое работает для выбора строк на основе меток. Получите строки от R6 до R10 из этих столбцов:

df.loc['R6':'R10', 'C':'E']

Out:
      C   D   E
R6   51  27  31
R7   83  19  18
R8   11  67  65
R9   78  27  29
R10   7  16  94

.loc также принимает логический массив, поэтому вы можете выбрать столбцы, чья соответствующая запись в массиве - True. Например, df.columns.isin(list('BCD')) возвращает array([False, True, True, True, False, False], dtype=bool) - Истина, если имя столбца находится в списке ['B', 'C', 'D']; В противном случае неверно.

df.loc[:, df.columns.isin(list('BCD'))]

Out:
      B   C   D
R0   78  61  16
R1   27  30  80
R2   53  80  27
R3   65  47  30
R4    9  41  62
R5   78   5  58
...
JQTs
24 июня 2021 в 20:18
0

df.loc [:, 'C': 'E'] это точный ответ, который я искал. Я поместил C и E в другую скобку, это была моя ошибка. Спасибо

avatar
zerovector
4 февраля 2016 в 14:05
81

В последней версии Pandas есть простой способ сделать именно это. Имена столбцов (которые являются строками) можно нарезать любым способом.

columns = ['b', 'c']
df1 = pd.DataFrame(df, columns=columns)
Banjocat
28 ноября 2017 в 07:05
9

Это можно сделать только при создании. Вопрос в том, есть ли у вас это уже во фрейме данных.

Bálint Sass
13 февраля 2021 в 10:26
1

df1 = df.iloc[:, columns] работает, когда у вас уже есть фрейм данных.

hobs
23 августа 2021 в 22:41
0

И этот интерфейс создания для создания имен столбцов всегда был там.

hobs
23 августа 2021 в 22:42
0

@ BálintSass, и если вы уже знаете имена столбцов, а не только их целочисленную позицию (индекс).

avatar
Muthu Chithambara Jothi
3 сентября 2014 в 11:30
27

Вы можете предоставить список столбцов, которые нужно удалить, и вернуть DataFrame только с необходимыми столбцами, используя функцию drop() в Pandas DataFrame.

Просто говорю

colsToDrop = ['a']
df.drop(colsToDrop, axis=1)

вернет DataFrame только со столбцами b и c.

Метод drop задокументирован здесь.

avatar
hobs
31 октября 2012 в 18:57
128

Предполагая, что имена ваших столбцов (df.columns) равны ['index','a','b','c'], тогда нужные данные находятся в третья и четвертая колонки. Если вы не знаете их имен при запуске сценария, вы можете сделать это

newdf = df[df.columns[2:4]] # Remember, Python is zero-offset! The "third" entry is at slot two.

Как указывает EMS в его ответ, df.ix нарезает столбцы немного более лаконично, но интерфейс нарезки .columns может быть более естественным, потому что он использует ванильную одномерную индексацию списков Python / синтаксис нарезки.

Предупреждение : 'index' - неправильное название для столбца DataFrame. Эта же метка также используется для реального атрибута df.index, массива Index. Таким образом, ваш столбец возвращается df['index'], а реальный индекс DataFrame возвращается df.index. Index - это особый вид Series, оптимизированный для поиска значений его элементов. Для df.index это поиск строк по их меткам. Атрибут df.columns также является массивом pd.Index для поиска столбцов по их меткам.

ely
31 октября 2012 в 19:11
3

Как я отмечал в своем комментарии выше, .ix - это , а не только для строк. Он предназначен для нарезки общего назначения и может использоваться для многомерной нарезки. По сути, это просто интерфейс к обычному синтаксису NumPy __getitem__. Тем не менее, вы можете легко преобразовать проблему разделения столбцов в проблему разделения строк, просто применив операцию транспонирования, df.T. В вашем примере используется columns[1:3], что немного вводит в заблуждение. Результатом columns будет Series; будьте осторожны, не относитесь к нему как к массиву. Кроме того, вам, вероятно, следует изменить его на columns[2:3], чтобы он совпадал с вашим «3-м и 4-м» комментарием.

hobs
4 февраля 2016 в 17:26
0

@ Mr.F: Мой [2:4] правильный. Ваш [2:3] неверен. И использование стандартной нотации нарезки python для создания последовательности / серии не вводит в заблуждение IMO. Но мне нравится ваш обход интерфейса DataFrame для доступа к базовому массиву numpy с ix.

ely
4 февраля 2016 в 18:05
0

В этом случае вы правы, но я пытался сказать, что в целом нарезка с метками в Pandas включает конечную точку среза (или, по крайней мере, так было в большинстве предыдущих версий Pandas. ). Поэтому, если вы извлекаете df.columns и хотите разрезать его по метке , тогда у вас будет другая семантика среза, чем если бы вы разрезали его по позиции целочисленного индекса . Я определенно не объяснил это хорошо в своем предыдущем комментарии.

hobs
5 февраля 2016 в 00:17
0

Ах, теперь я понимаю вашу точку зрения. Я забыл, что columns - это неизменяемая серия, а метод получения был переопределен для использования меток в качестве индексов. Спасибо, что нашли время уточнить.

Martien Lubberink
1 июля 2017 в 23:57
2

Обратите внимание на предупреждение об устаревании: .ix устарел. Поэтому это имеет смысл: newdf = df [df.columns [2: 4]]

avatar
Wes McKinney
8 июля 2012 в 17:55
71
In [39]: df
Out[39]: 
   index  a  b  c
0      1  2  3  4
1      2  3  4  5

In [40]: df1 = df[['b', 'c']]

In [41]: df1
Out[41]: 
   b  c
0  3  4
1  4  5
kuanb
14 февраля 2017 в 20:30
1

Что, если бы я хотел переименовать столбец, например, примерно так: df[['b as foo', 'c as bar'], чтобы в выходных данных столбец b переименовался в foo, а столбец c на bar?

Greg
25 августа 2017 в 22:48
6

df[['b', 'c']].rename(columns = {'b' : 'foo', 'c' : 'bar'})

Peter Mortensen
8 февраля 2021 в 14:55
0

Объяснение было бы в порядке. Например. в чем суть? Вы можете отредактировать свой ответ - без «Изменить:», «Обновить:» и т.п. - ответ должен выглядеть так, как если бы он был написан сегодня.