iloc, ix และ loc แตกต่างกันอย่างไร?

มีใครบ้างที่สามารถอธิบายวิธีการหั่นทั้งสามวิธีนี้แตกต่างกัน
ฉันเห็นเอกสารและฉันเห็นคำตอบเหล่านี้ แล้ว แต่ฉันก็ยังพบว่าตัวเองไม่สามารถอธิบายได้ว่าทั้งสามนั้นแตกต่างกันอย่างไร สำหรับฉันพวกเขาดูเหมือนจะเปลี่ยนได้ในส่วนใหญ่เพราะพวกเขาอยู่ในระดับที่ต่ำกว่าของการหั่น

DataFrameตัวอย่างเช่นสมมติว่าเราต้องการที่จะได้รับห้าแถวแรกของ งานทั้งสามนี้เป็นอย่างไร

df.loc[:5]
df.ix[:5]
df.iloc[:5]

ใครบางคนสามารถนำเสนอสามกรณีที่ความแตกต่างในการใช้งานมีความชัดเจน?

หมายเหตุ: ในรุ่น 0.20.0 หมีแพนด้าและสูงกว่าixจะเลิกและการใช้locและilocได้รับการสนับสนุนแทน ฉันได้ทิ้งบางส่วนของคำตอบนี้ไว้ซึ่งอธิบายixว่าเป็นเหมือนการอ้างอิงสำหรับผู้ใช้แพนด้ารุ่นก่อนหน้า ixตัวอย่างได้รับการเพิ่มด้านล่างแสดงให้เห็นทางเลือกในการ

ก่อนอื่นต่อไปนี้เป็นสรุปวิธีการสามวิธี:

• locรับแถว (หรือคอลัมน์) ที่มีป้ายกำกับเฉพาะจากดัชนี
• ilocรับแถว (หรือคอลัมน์) ที่ตำแหน่งเฉพาะในดัชนี (ดังนั้นจึงต้องใช้จำนวนเต็มเท่านั้น)
• ixมักจะพยายามทำตัวเหมือนlocแต่กลับไปทำตัวเหมือนilocว่าไม่มีป้ายกำกับอยู่ในดัชนี

เป็นสิ่งสำคัญที่จะต้องทราบรายละเอียดปลีกย่อยบางอย่างที่อาจทำให้ixยุ่งยากเล็กน้อยในการใช้:

• หากดัชนีเป็นประเภทจำนวนเต็มixจะใช้การจัดทำดัชนีตามป้ายกำกับเท่านั้นและจะไม่ถอยกลับไปที่การจัดทำดัชนีตามตำแหน่ง หากฉลากไม่ได้อยู่ในดัชนีจะมีข้อผิดพลาดเกิดขึ้น

• หากดัชนีไม่มีจำนวนเต็มเท่านั้นการกำหนดจำนวนเต็มixจะใช้การจัดทำดัชนีตามตำแหน่งแทนการจัดทำดัชนีตามป้ายกำกับทันที หากอย่างไรก็ตามixมีประเภทอื่น (เช่นสตริง) ก็สามารถใช้การจัดทำดัชนีตามป้ายกำกับ

เมื่อต้องการแสดงให้เห็นถึงความแตกต่างระหว่างสามวิธีให้พิจารณาซีรี่ส์ต่อไปนี้:

>>> s = pd.Series(np.nan, index=[49,48,47,46,45, 1, 2, 3, 4, 5])
>>> s
49   NaN
48   NaN
47   NaN
46   NaN
45   NaN
1    NaN
2    NaN
3    NaN
4    NaN
5    NaN

3เราจะดูที่หั่นด้วยค่าจำนวนเต็ม

ในกรณีนี้s.iloc[:3]ส่งคืน 3 แถวแรก (เนื่องจากเป็น 3 ตำแหน่ง) และs.loc[:3]ส่งคืน 8 แถวแรก (เนื่องจากถือว่า 3 เป็นป้ายกำกับ):

>>> s.iloc[:3] # slice the first three rows
49   NaN
48   NaN
47   NaN

>>> s.loc[:3] # slice up to and including label 3
49   NaN
48   NaN
47   NaN
46   NaN
45   NaN
1    NaN
2    NaN
3    NaN

>>> s.ix[:3] # the integer is in the index so s.ix[:3] works like loc
49   NaN
48   NaN
47   NaN
46   NaN
45   NaN
1    NaN
2    NaN
3    NaN

การแจ้งเตือนs.ix[:3]จะส่งคืนซีรี่ส์เดียวกันs.loc[:3]เนื่องจากมองหาป้ายกำกับก่อนแทนที่จะทำงานกับตำแหน่ง (และดัชนีsเป็นประเภทจำนวนเต็ม)

ถ้าเราลองด้วยป้ายกำกับจำนวนเต็มที่ไม่ได้อยู่ในดัชนี (พูด6) ล่ะ?

ที่นี่s.iloc[:6]จะส่งคืน 6 แถวแรกของซีรี่ส์ตามที่คาดไว้ อย่างไรก็ตามs.loc[:6]ยก KeyError เนื่องจาก6ไม่ได้อยู่ในดัชนี

>>> s.iloc[:6]
49   NaN
48   NaN
47   NaN
46   NaN
45   NaN
1    NaN

>>> s.loc[:6]
KeyError: 6

>>> s.ix[:6]
KeyError: 6

ตามรายละเอียดปลีกย่อยข้างต้นs.ix[:6]ตอนนี้ยก KeyError เพราะมันพยายามที่จะทำงานเหมือนlocแต่ไม่สามารถหา a 6ในดัชนีได้ เพราะดัชนีของเราเป็นจำนวนเต็มชนิดไม่ถอยกลับไปทำตัวเหมือนixiloc

อย่างไรก็ตามหากดัชนีของเราเป็นประเภทผสมเนื่องจากจำนวนเต็มixจะทำงานในilocทันทีแทนที่จะเพิ่ม KeyError:

>>> s2 = pd.Series(np.nan, index=['a','b','c','d','e', 1, 2, 3, 4, 5])
>>> s2.index.is_mixed() # index is mix of different types
True
>>> s2.ix[:6] # now behaves like iloc given integer
a   NaN
b   NaN
c   NaN
d   NaN
e   NaN
1   NaN

โปรดทราบว่าixยังสามารถยอมรับจำนวนเต็มและทำตัวเหมือนloc:

>>> s2.ix[:'c'] # behaves like loc given non-integer
a   NaN
b   NaN
c   NaN

เป็นคำแนะนำทั่วไปถ้าคุณเท่านั้นจัดทำดัชนีการใช้ป้ายกำกับหรือเฉพาะการจัดทำดัชนีการใช้ตำแหน่งจำนวนเต็มติดด้วยlocหรือilocเพื่อหลีกเลี่ยงผลที่ไม่คาดคิด - ixพยายามที่จะไม่ใช้

การรวมการจัดทำดัชนีตามตำแหน่งและฉลาก

บางครั้งได้รับ DataFrame คุณจะต้องผสมผสานวิธีการจัดทำฉลากและตำแหน่งสำหรับแถวและคอลัมน์

ตัวอย่างเช่นพิจารณา DataFrame ต่อไปนี้ วิธีที่ดีที่สุดในการแบ่งแถวถึงและรวม 'c' และใช้สี่คอลัมน์แรก

>>> df = pd.DataFrame(np.nan, 
                      index=list('abcde'),
                      columns=['x','y','z', 8, 9])
>>> df
    x   y   z   8   9
a NaN NaN NaN NaN NaN
b NaN NaN NaN NaN NaN
c NaN NaN NaN NaN NaN
d NaN NaN NaN NaN NaN
e NaN NaN NaN NaN NaN

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

>>> df.ix[:'c', :4]
    x   y   z   8
a NaN NaN NaN NaN
b NaN NaN NaN NaN
c NaN NaN NaN NaN

ในรุ่นที่ใหม่กว่าของแพนด้าเราสามารถบรรลุผลนี้โดยใช้ilocและความช่วยเหลือของวิธีการอื่น:

>>> df.iloc[:df.index.get_loc('c') + 1, :4]
    x   y   z   8
a NaN NaN NaN NaN
b NaN NaN NaN NaN
c NaN NaN NaN NaN

get_loc()เป็นวิธีดัชนีหมายถึง "รับตำแหน่งของฉลากในดัชนีนี้" โปรดทราบว่าเนื่องจากการแบ่งส่วนด้วยilocเป็นพิเศษของจุดสิ้นสุดของมันเราจะต้องเพิ่ม 1 ในค่านี้ถ้าเราต้องการแถว 'c' เช่นกัน

มีตัวอย่างต่อไปในเอกสารแพนด้าอยู่ที่นี่

ilocทำงานตามตำแหน่งจำนวนเต็ม ดังนั้นไม่ว่าคุณจะติดป้ายกำกับแถวอะไรคุณสามารถทำได้เช่นรับแถวแรกโดยทำ

df.iloc[0]

หรือห้าแถวสุดท้ายโดยทำ

df.iloc[-5:]

คุณสามารถใช้มันในคอลัมน์ วิธีนี้จะดึงข้อมูลคอลัมน์ที่ 3:

df.iloc[:, 2]    # the : in the first position indicates all rows

คุณสามารถรวมเข้าด้วยกันเพื่อรับจุดตัดของแถวและคอลัมน์:

df.iloc[:3, :3] # The upper-left 3 X 3 entries (assuming df has 3+ rows and columns)

ในทางกลับกันให้.locใช้ดัชนีที่มีชื่อ มาตั้งกรอบข้อมูลด้วยสตริงเป็นป้ายชื่อแถวและคอลัมน์:

df = pd.DataFrame(index=['a', 'b', 'c'], columns=['time', 'date', 'name'])

จากนั้นเราจะได้แถวแรกโดย

df.loc['a']     # equivalent to df.iloc[0]

และสองแถวที่สองของ'date'คอลัมน์โดย

df.loc['b':, 'date']   # equivalent to df.iloc[1:, 1]

และอื่น ๆ ทีนี้ก็น่าจะชี้ให้เห็นว่าดัชนีแถวและคอลัมน์เริ่มต้นสำหรับ a DataFrameเป็นจำนวนเต็มตั้งแต่ 0 และในกรณีนี้ilocและlocจะทำงานในลักษณะเดียวกัน นี่คือเหตุผลที่ตัวอย่างทั้งสามของคุณมีความเท่าเทียมกัน หากคุณมีดัชนีที่ไม่ใช่ตัวเลขเช่นสตริงหรือชุดข้อมูล df.loc[:5] จะทำให้เกิดข้อผิดพลาด

นอกจากนี้คุณสามารถทำการดึงคอลัมน์ได้โดยใช้กรอบข้อมูล__getitem__:

df['time']    # equivalent to df.loc[:, 'time']

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

df.ix[:2, 'time']    # the first two rows of the 'time' column

ฉันคิดว่ามันก็คุ้มค่าที่จะกล่าวถึงว่าคุณสามารถส่งเวกเตอร์บูลีนไปยังlocวิธีการได้เช่นกัน ตัวอย่างเช่น:

 b = [True, False, True]
 df.loc[b] 

จะกลับมาวันที่ 1 และ 3 dfแถว สิ่งนี้เทียบเท่ากับสิ่งที่df[b]เลือก แต่ยังสามารถใช้สำหรับกำหนดผ่านเวกเตอร์บูลีน:

df.loc[b, 'name'] = 'Mary', 'John'

ในความคิดของฉันคำตอบที่ยอมรับนั้นสร้างความสับสนเนื่องจากใช้ DataFrame ที่มีค่าที่หายไป ฉันยังไม่ชอบคำที่ขึ้นอยู่กับตำแหน่งของคำศัพท์.ilocแทนและชอบสถานที่จำนวนเต็มเพราะมันเป็นคำอธิบายที่มากขึ้นและสิ่งที่.ilocหมายถึง คำสำคัญคือ INTEGER - .ilocต้องการ INTEGERS

ดูชุดบล็อกที่มีรายละเอียดสูงของฉันในการเลือกชุดย่อยสำหรับข้อมูลเพิ่มเติม

.ix เลิกใช้แล้วและคลุมเครือและไม่ควรใช้

เพราะ.ixจะเลิกเราจะมุ่งเน้นไปที่ความแตกต่างระหว่างและ.loc.iloc

ก่อนที่เราจะพูดถึงความแตกต่างสิ่งสำคัญคือต้องเข้าใจว่า DataFrames มีป้ายกำกับที่ช่วยระบุแต่ละคอลัมน์และแต่ละดัชนี ลองมาดูตัวอย่าง DataFrame:

df = pd.DataFrame({'age':[30, 2, 12, 4, 32, 33, 69],
                   'color':['blue', 'green', 'red', 'white', 'gray', 'black', 'red'],
                   'food':['Steak', 'Lamb', 'Mango', 'Apple', 'Cheese', 'Melon', 'Beans'],
                   'height':[165, 70, 120, 80, 180, 172, 150],
                   'score':[4.6, 8.3, 9.0, 3.3, 1.8, 9.5, 2.2],
                   'state':['NY', 'TX', 'FL', 'AL', 'AK', 'TX', 'TX']
                   },
                  index=['Jane', 'Nick', 'Aaron', 'Penelope', 'Dean', 'Christina', 'Cornelia'])

คำทั้งหมดที่เป็นตัวหนาคือป้ายกำกับ ป้าย, age, color, food, height, scoreและstateใช้สำหรับคอลัมน์ ป้ายอื่น ๆJane, Nick, Aaron, Penelope, Dean, Christina, Corneliaใช้สำหรับดัชนี

วิธีหลักในการเลือกแถวใดแถวหนึ่งใน DataFrame คือด้วย.locและตัว.ilocสร้างดัชนี ตัวทำดัชนีแต่ละตัวเหล่านี้ยังสามารถใช้เพื่อเลือกคอลัมน์พร้อมกันได้ แต่ตอนนี้มันง่ายกว่าที่จะมุ่งเน้นไปที่แถวในตอนนี้ นอกจากนี้ตัวจัดทำดัชนีแต่ละตัวใช้ชุดของวงเล็บที่ตามชื่อทันทีเพื่อทำการเลือก

.loc เลือกข้อมูลตามป้ายกำกับเท่านั้น

ก่อนอื่นเราจะพูดถึง.locตัวสร้างดัชนีซึ่งเลือกข้อมูลตามป้ายกำกับดัชนีหรือคอลัมน์เท่านั้น ใน DataFrame ตัวอย่างของเราเราได้ให้ชื่อที่มีความหมายเป็นค่าสำหรับดัชนี DataFrames จำนวนมากจะไม่มีชื่อที่มีความหมายและจะเป็นค่าเริ่มต้นเป็นจำนวนเต็มตั้งแต่ 0 ถึง n-1 โดยที่ n คือความยาวของ DataFrame

มีอินพุตที่แตกต่างกันสามแบบที่คุณสามารถใช้ได้ .loc

• สตริง
• รายการของสตริง
• สัญกรณ์ Slice โดยใช้สตริงเป็นค่าเริ่มต้นและหยุด

การเลือกแถวเดียวกับ. loc ด้วยสตริง

ในการเลือกข้อมูลแถวเดียวให้วางเลเบลดัชนีไว้ในวงเล็บ.locข้างล่างนี้

df.loc['Penelope']

ส่งคืนแถวของข้อมูลในรูปแบบ

age           4
color     white
food      Apple
height       80
score       3.3
state        AL
Name: Penelope, dtype: object

การเลือกหลายแถวด้วย. loc ด้วยรายการสตริง

df.loc[['Cornelia', 'Jane', 'Dean']]

ส่งคืน DataFrame พร้อมแถวตามลำดับที่ระบุในรายการ:

การเลือกหลายแถวด้วย. loc ด้วยสัญกรณ์ชิ้น

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

df.loc['Aaron':'Dean']

สามารถแบ่งส่วนที่ซับซ้อนได้ในลักษณะเดียวกับรายการ Python

.iloc เลือกข้อมูลตามตำแหน่งจำนวนเต็มเท่านั้น

.ilocตอนนี้ขอให้หันไป ทุกแถวและคอลัมน์ของข้อมูลใน DataFrame มีตำแหน่งจำนวนเต็มที่กำหนด นี่คือนอกเหนือไปจากฉลากที่แสดงสายตาในการส่งออก ตำแหน่งจำนวนเต็มเป็นเพียงจำนวนแถว / คอลัมน์จากด้านบน / ซ้ายเริ่มต้นที่ 0

มีอินพุตที่แตกต่างกันสามแบบที่คุณสามารถใช้ได้ .iloc

• จำนวนเต็ม
• รายการจำนวนเต็ม
• สัญกรณ์ Slice โดยใช้จำนวนเต็มเป็นค่าเริ่มต้นและหยุด

การเลือกแถวเดียวด้วย .iloc ด้วยจำนวนเต็ม

df.iloc[4]

ส่งคืนแถวที่ 5 (ตำแหน่งจำนวนเต็ม 4) เป็นซีรีย์

age           32
color       gray
food      Cheese
height       180
score        1.8
state         AK
Name: Dean, dtype: object

การเลือกหลายแถวด้วย. iloc พร้อมรายการจำนวนเต็ม

df.iloc[[2, -2]]

ส่งคืน DataFrame ของแถวที่สามและแถวที่สองเป็นแถวสุดท้าย:

การเลือกหลายแถวด้วย .iloc พร้อมเครื่องหมายชิ้น

df.iloc[:5:3]

การเลือกแถวและคอลัมน์พร้อมกันด้วย. loc และ .iloc

หนึ่งความสามารถที่ยอดเยี่ยมของทั้งสอง.loc/.ilocคือความสามารถในการเลือกทั้งแถวและคอลัมน์พร้อมกัน ในตัวอย่างข้างต้นคอลัมน์ทั้งหมดถูกส่งคืนจากการเลือกแต่ละรายการ เราสามารถเลือกคอลัมน์ที่มีอินพุตเหมือนกันกับแถว เราก็ต้องแยกการเลือกแถวและคอลัมน์ที่มีเครื่องหมายจุลภาค

ตัวอย่างเช่นเราสามารถเลือกแถว Jane และ Dean ด้วยความสูงคอลัมน์คะแนนและสถานะดังนี้:

df.loc[['Jane', 'Dean'], 'height':]

สิ่งนี้ใช้รายการของป้ายกำกับสำหรับแถวและสัญกรณ์ชิ้นสำหรับคอลัมน์

เราสามารถดำเนินการที่คล้ายกัน.ilocโดยใช้จำนวนเต็มเท่านั้น

df.iloc[[1,4], 2]
Nick      Lamb
Dean    Cheese
Name: food, dtype: object

การเลือกพร้อมกันพร้อมป้ายกำกับและตำแหน่งจำนวนเต็ม

.ixใช้ในการเลือกพร้อมกันกับป้ายกำกับและตำแหน่งจำนวนเต็มซึ่งมีประโยชน์ แต่สับสนและคลุมเครือในบางครั้งและขอบคุณที่เลิกใช้แล้ว ในกรณีที่คุณต้องทำการเลือกด้วยการผสมผสานของป้ายชื่อและตำแหน่งจำนวนเต็มคุณจะต้องสร้างทั้งป้ายชื่อตัวเลือกหรือตำแหน่งจำนวนเต็ม

ตัวอย่างเช่นหากเราต้องการเลือกแถวNickและCorneliaตามด้วยคอลัมน์ 2 และ 4 เราสามารถใช้.locโดยการแปลงจำนวนเต็มเป็นป้ายกำกับโดยทำดังนี้:

col_names = df.columns[[2, 4]]
df.loc[['Nick', 'Cornelia'], col_names] 

หรือมิฉะนั้นให้แปลงเลเบลดัชนีเป็นจำนวนเต็มด้วยget_locเมธอดดัชนี

labels = ['Nick', 'Cornelia']
index_ints = [df.index.get_loc(label) for label in labels]
df.iloc[index_ints, [2, 4]]

การเลือกบูลีน

ตัวทำดัชนี. loc ยังสามารถทำการเลือกแบบบูลได้ ตัวอย่างเช่นหากเราสนใจที่จะค้นหาแถวทั้งหมดที่อายุมากกว่า 30 และส่งคืนเฉพาะคอลัมน์foodและscoreเราสามารถทำสิ่งต่อไปนี้:

df.loc[df['age'] > 30, ['food', 'score']] 

คุณสามารถทำซ้ำสิ่งนี้ด้วย .ilocแต่คุณไม่สามารถผ่านชุดบูลีนได้ คุณต้องแปลง boolean Series เป็น array numpy ดังนี้:

df.iloc[(df['age'] > 30).values, [2, 4]] 

การเลือกแถวทั้งหมด

มันเป็นไปได้ที่จะใช้.loc/.ilocสำหรับการเลือกคอลัมน์เพียง คุณสามารถเลือกแถวทั้งหมดได้โดยใช้โคลอนดังนี้:

df.loc[:, 'color':'score':2]

ผู้ประกอบการจัดทำดัชนี []สามารถเลือกแถวและคอลัมน์ได้ แต่ไม่พร้อมกัน

คนส่วนใหญ่คุ้นเคยกับวัตถุประสงค์หลักของตัวดำเนินการการจัดทำดัชนี DataFrame ซึ่งเป็นการเลือกคอลัมน์ สตริงเลือกคอลัมน์เดียวเป็นชุดและรายการสตริงเลือกหลายคอลัมน์เป็น DataFrame

df['food']

Jane          Steak
Nick           Lamb
Aaron         Mango
Penelope      Apple
Dean         Cheese
Christina     Melon
Cornelia      Beans
Name: food, dtype: object

การใช้รายการเลือกหลายคอลัมน์

df[['food', 'score']]

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

df['Penelope':'Christina'] # slice rows by label

df[2:6:2] # slice rows by integer location

ต้องการความชัดเจนใน.loc/.ilocการเลือกแถว ตัวดำเนินการการทำดัชนีเพียงอย่างเดียวไม่สามารถเลือกแถวและคอลัมน์พร้อมกันได้

df[3:5, 'color']
TypeError: unhashable type: 'slice'