ฉันมีข้อมูลในคอลัมน์ต่าง ๆ แต่ฉันไม่รู้วิธีแยกเพื่อบันทึกในตัวแปรอื่น

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

ฉันจะเลือกวิธี'a', 'b'และบันทึกไว้ในการ DF1?

ฉันเหนื่อย

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

ดูเหมือนจะไม่มีใครทำงาน

ไม่สามารถแบ่งชื่อคอลัมน์ (ซึ่งเป็นสตริง) ในลักษณะที่คุณพยายามได้

ที่นี่คุณมีสองตัวเลือก หากคุณรู้จากบริบทว่าตัวแปรใดที่คุณต้องการตัดออกคุณสามารถส่งคืนเฉพาะมุมมองของคอลัมน์เหล่านั้นโดยส่งผ่านรายการไปยัง__getitem__ไวยากรณ์ ([])

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

อีกทางหนึ่งหากคุณต้องการสร้างดัชนีให้เป็นตัวเลขและไม่ใช่ชื่อของพวกเขา (พูดว่ารหัสของคุณควรทำสิ่งนี้โดยอัตโนมัติโดยไม่ทราบชื่อของสองคอลัมน์แรก) จากนั้นคุณสามารถทำได้ดังนี้:

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

นอกจากนี้คุณควรทำความคุ้นเคยกับแนวคิดของมุมมองลงในวัตถุ 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ตอนนี้คุณสามารถใช้พจนานุกรมนี้คอลัมน์การเข้าถึงผ่านชื่อและการใช้

ตั้งแต่เวอร์ชัน 0.11.0 สามารถแบ่งคอลัมน์ในลักษณะที่คุณได้ลองใช้.locตัวสร้างดัชนี:

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

เทียบเท่ากับ

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

และผลตอบแทนคอลัมน์ผ่านCE

ตัวอย่างบน 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
...

สมมติว่าชื่อคอลัมน์ของคุณ ( df.columns) คือ['index','a','b','c']จากนั้นข้อมูลที่คุณต้องการอยู่ในคอลัมน์ที่ 3 และ 4 หากคุณไม่ทราบชื่อเมื่อสคริปต์ของคุณทำงานคุณสามารถทำได้

newdf = df[df.columns[2:4]] # Remember, Python is 0-offset! The "3rd" entry is at slot 2.

ในขณะที่ EMS ชี้ให้เห็นในคำตอบของเขาให้แบ่งdf.ixคอลัมน์ให้สั้นลงเล็กน้อย แต่.columnsอินเทอร์เฟซการแบ่งอาจเป็นธรรมชาติมากกว่าเพราะใช้วานิลลา 1-D หลามรายการการทำดัชนี / การแบ่งไวยากรณ์

คำเตือน: 'index'เป็นชื่อที่ไม่ดีสำหรับDataFrameคอลัมน์ ป้ายกำกับเดียวกันนั้นยังใช้สำหรับdf.indexแอตทริบิวต์จริงซึ่งเป็นIndexอาร์เรย์ ดังนั้นคอลัมน์ของคุณจะถูกส่งกลับโดยdf['index']ดัชนี DataFrame df.indexจริงถูกส่งกลับโดย An Indexเป็นประเภทพิเศษที่ได้รับการSeriesปรับให้เหมาะสมสำหรับการค้นหาค่าองค์ประกอบของมัน สำหรับ df.index ใช้เพื่อค้นหาแถวตามป้ายกำกับของพวกเขา ที่df.columnsแอตทริบิวต์ยังเป็นpd.Indexอาร์เรย์สำหรับการหาค่าคอลัมน์โดยป้ายชื่อของพวกเขา

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

ฉันรู้ว่าคำถามนี้ค่อนข้างเก่า แต่ในนุ่นรุ่นล่าสุดมีวิธีที่ง่ายในการทำสิ่งนี้ ชื่อคอลัมน์ (ซึ่งเป็นสตริง) สามารถแบ่งได้ในลักษณะที่คุณต้องการ

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

คุณสามารถระบุรายการของคอลัมน์ที่จะดร็อปและส่งคืน DataFrame ที่มีเฉพาะคอลัมน์ที่จำเป็นต้องใช้ในการdrop()ทำงานกับ Pandas DataFrame

แค่พูด

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

จะกลับมา DataFrame มีเพียงคอลัมน์และbc

dropวิธีการจัดทำเอกสารที่นี่

กับแพนด้า

ปัญญาชื่อคอลัมน์

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

เพื่อเลือกโดย iloc และคอลัมน์เฉพาะที่มีหมายเลขดัชนี:

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

ด้วยชื่อคอลัมน์ loc สามารถใช้เช่น

dataframe.loc[:,['column1','column2']]

ฉันพบว่าวิธีนี้มีประโยชน์มาก:

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

รายละเอียดเพิ่มเติมสามารถดูได้ที่นี่

เริ่มต้นด้วย 0.21.0 ใช้.locหรือมีรายการที่มีหนึ่งหรือมากกว่าป้ายหายไปจะเลิกในความโปรดปรานของ[] .reindexดังนั้นคำตอบสำหรับคำถามของคุณคือ:

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

ในรุ่นก่อนหน้าการใช้.loc[list-of-labels]จะใช้ได้ตราบเท่าที่พบอย่างน้อย 1 คีย์ (ไม่เช่นนั้นจะเป็นการเพิ่มKeyError) พฤติกรรมนี้เลิกใช้แล้วและตอนนี้แสดงข้อความเตือน .reindex()ทางเลือกที่แนะนำคือการใช้งาน

อ่านเพิ่มเติมที่การจัดทำดัชนีและการเลือกข้อมูล

คุณสามารถใช้นุ่น ฉันสร้าง 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

วิธีเลือก 1 คอลัมน์ขึ้นไปโดยใช้ชื่อ:

    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']

"Slice" คือ:

            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

หากคุณต้องการรับองค์ประกอบหนึ่งรายการตามดัชนีแถวและชื่อคอลัมน์คุณสามารถทำได้เช่นdf['b'][0]กัน มันง่ายอย่างที่คุณสามารถสร้างภาพ

หรือคุณสามารถใช้df.ix[0,'b']การใช้ดัชนีและฉลากแบบผสม

หมายเหตุ:เนื่องจาก v0.20 ixได้เลิกในความโปรดปรานของ/lociloc

วิธีการหนึ่งที่ง่ายและแตกต่าง: วนซ้ำแถว

ใช้ 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()

วิธีการที่แตกต่างกันที่กล่าวถึงในการตอบกลับข้างต้นจะขึ้นอยู่กับสมมติฐานที่ว่าผู้ใช้รู้ดัชนีคอลัมน์ที่จะวางหรือเซ็ตย่อยหรือผู้ใช้ต้องการเซ็ตย่อย dataframe โดยใช้ช่วงของคอลัมน์ (เช่นระหว่าง 'C': 'E') . pandas.DataFrame.drop ()เป็นตัวเลือกในการเซ็ตย่อยข้อมูลตามรายการของคอลัมน์ที่กำหนดโดยผู้ใช้ (แม้ว่าคุณจะต้องระมัดระวังว่าคุณใช้สำเนาของ dataframe และพารามิเตอร์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

คุณยังสามารถใช้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)

ฉันเห็นคำตอบหลายข้อ แต่ยังไม่ชัดเจนสำหรับฉัน คุณจะเลือกคอลัมน์ที่น่าสนใจเหล่านั้นได้อย่างไร คำตอบก็คือถ้าคุณรวบรวมมันไว้ในรายการคุณสามารถอ้างอิงคอลัมน์โดยใช้รายการ

ตัวอย่าง

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']

ฉันมีรายการ / อาร์เรย์ numpy ต่อไปนี้extracted_featuresระบุ 63 คอลัมน์ ชุดข้อมูลดั้งเดิมมี 103 คอลัมน์และฉันต้องการแยกสิ่งเหล่านั้นอย่างแน่นอนแล้วฉันจะใช้

dataset[extracted_features]

และคุณจะจบลงด้วยสิ่งนี้

สิ่งนี้คุณจะใช้ค่อนข้างบ่อยในการเรียนรู้ของเครื่อง (โดยเฉพาะอย่างยิ่งในการเลือกคุณสมบัติ) ฉันอยากจะพูดถึงวิธีอื่นเช่นกัน แต่ฉันคิดว่ามันได้รับการครอบคลุมโดย stackoverflowers อื่น หวังว่านี่จะเป็นประโยชน์!

คุณสามารถใช้pandas.DataFrame.filterวิธีการกรองหรือเรียงลำดับคอลัมน์ใหม่ดังนี้

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

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