เมื่อเร็ว ๆ นี้เริ่มแยกออกจากสถานที่ที่ปลอดภัยของฉัน (R) เป็น python และและ am บิตสับสนโดยเซลล์แปล / Pandasเลือกใน ฉันได้อ่านเอกสารแล้ว แต่ฉันพยายามดิ้นรนที่จะเข้าใจถึงผลกระทบที่เกิดขึ้นจริงของตัวเลือกการโลคัลไลเซชั่น / ตัวเลือกต่างๆ

• มีเหตุผลที่ฉันควรใช้.locหรือ.ilocมากกว่าตัวเลือกทั่วไปมากที่สุด.ixหรือไม่?
• ผมเข้าใจว่า.loc, iloc, atและiatอาจให้บางส่วนถูกต้องรับประกันได้ว่า.ixไม่สามารถให้ แต่ฉันยังอ่านที่.ixมีแนวโน้มที่จะเป็นทางออกที่เร็วที่สุดทั่วกระดาน
• โปรดอธิบายเหตุผลการปฏิบัติที่ดีที่สุดในโลกแห่งความเป็นจริงและการใช้ประโยชน์อย่างอื่นนอกเหนือจากนี้.ixหรือไม่?

loc:ใช้งานได้เฉพาะบนดัชนี
iloc:ทำงานบนตำแหน่ง
ix:คุณสามารถรับข้อมูลจาก dataframe โดยไม่ต้องอยู่ในดัชนี
ที่:รับค่าสเกลาร์ มันเป็น loc ที่รวดเร็วมาก
: รับค่าสเกลาร์ มันเป็นเกมที่เร็วมาก ๆ

http://pyciencia.blogspot.com/2015/05/obtener-y-filtrar-datos-de-un-dataframe.html

หมายเหตุ:ขณะpandas 0.20.0ที่.ixดัชนีจะเลิกในความโปรดปรานของที่เข้มงวดมากขึ้น.ilocและ.locindexers

อัปเดตสำหรับที่pandas 0.20ระบุว่าixเลิกใช้แล้ว นี้แสดงให้เห็นไม่เพียง แต่วิธีการใช้งานloc, iloc, at, iat, set_valueแต่วิธีการที่จะบรรลุการจัดทำดัชนีตำแหน่ง / ฉลากตามผสม

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

หมายเหตุพิเศษ:เมื่อดัชนีสเกลาร์ถูกส่งผ่านlocสามารถกำหนดค่าดัชนีหรือคอลัมน์ใหม่ที่ไม่เคยมีมาก่อน

# label based, but we can use position values
# to get the labels from the index object
df.loc[df.index[2], 'ColName'] = 3

df.loc[df.index[1:3], 'ColName'] = 3

iloc- ตามตำแหน่ง
คล้ายกับlocยกเว้นกับตำแหน่งแทนค่าดัชนีนั้น อย่างไรก็ตามคุณไม่สามารถกำหนดคอลัมน์หรือดัชนีใหม่

# position based, but we can get the position
# from the columns object via the `get_loc` method
df.iloc[2, df.columns.get_loc('ColName')] = 3

df.iloc[2, 4] = 3

df.iloc[:3, 2:4] = 3

at- ตามฉลาก
ทำงานคล้ายกับlocดัชนีสเกลาร์มาก ไม่สามารถทำงานกับตัวสร้างดัชนีอาร์เรย์ สามารถ! กำหนดดัชนีและคอลัมน์ใหม่

ข้อได้เปรียบมากกว่าlocนี้คือเร็วกว่า
ข้อเสียคือคุณไม่สามารถใช้อาร์เรย์สำหรับดัชนี

# label based, but we can use position values
# to get the labels from the index object
df.at[df.index[2], 'ColName'] = 3

df.at['C', 'ColName'] = 3

iat- ตำแหน่งตามธิการในทำนองเดียวกันกับ
ไม่สามารถทำงานกับตัวสร้างดัชนีอาร์เรย์ ไม่ได้! กำหนดดัชนีและคอลัมน์ใหม่iloc

ข้อได้เปรียบมากกว่าilocนี้คือเร็วกว่า
ข้อเสียคือคุณไม่สามารถใช้อาร์เรย์สำหรับดัชนี

# position based, but we can get the position
# from the columns object via the `get_loc` method
IBM.iat[2, IBM.columns.get_loc('PNL')] = 3

set_value- ตามฉลาก
ทำงานคล้ายกับlocดัชนีสเกลาร์มาก ไม่สามารถทำงานกับตัวสร้างดัชนีอาร์เรย์ สามารถ! กำหนดดัชนีและคอลัมน์ใหม่

ได้เปรียบเร็วมากเพราะมีค่าใช้จ่ายน้อยมาก!
ข้อเสียมีค่าใช้จ่ายน้อยมากเพราะpandasไม่ได้ทำการตรวจสอบความปลอดภัยเป็นจำนวนมาก การใช้งานที่มีความเสี่ยงของคุณเอง นอกจากนี้ไม่ได้มีไว้สำหรับการใช้งานสาธารณะ

# label based, but we can use position values
# to get the labels from the index object
df.set_value(df.index[2], 'ColName', 3)

set_valueกับtakable=True -ตำแหน่งตามธิการในทำนองเดียวกันกับ
ไม่สามารถทำงานกับตัวสร้างดัชนีอาร์เรย์ ไม่ได้! กำหนดดัชนีและคอลัมน์ใหม่iloc

ได้เปรียบเร็วมากเพราะมีค่าใช้จ่ายน้อยมาก!
ข้อเสียมีค่าใช้จ่ายน้อยมากเพราะpandasไม่ได้ทำการตรวจสอบความปลอดภัยเป็นจำนวนมาก การใช้งานที่มีความเสี่ยงของคุณเอง นอกจากนี้ไม่ได้มีไว้สำหรับการใช้งานสาธารณะ

# position based, but we can get the position
# from the columns object via the `get_loc` method
df.set_value(2, df.columns.get_loc('ColName'), 3, takable=True)

มีสองวิธีหลักที่แพนด้าทำการเลือกจาก DataFrame

• ตามป้ายกำกับ
• ตามสถานที่ตั้งจำนวนเต็ม

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

ก่อนที่จะแสดงข้อมูลสรุปให้ทุกคนตรวจสอบให้แน่ใจว่า ...

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

มีดรรชนีหลักสามตัวสำหรับนุ่น ขณะนี้มีผู้ประกอบการจัดทำดัชนีของตัวเอง (วงเล็บ[]) และ.loc .ilocมาสรุปกัน:

• []- หลักเลือกชุดย่อยของคอลัมน์ แต่สามารถเลือกแถวได้เช่นกัน ไม่สามารถเลือกแถวและคอลัมน์พร้อมกัน
• .loc - เลือกชุดย่อยของแถวและคอลัมน์ตามป้ายกำกับเท่านั้น
• .iloc - เลือกชุดย่อยของแถวและคอลัมน์ตามตำแหน่งจำนวนเต็มเท่านั้น

ฉันแทบไม่เคยใช้.atหรือ.iatไม่เพิ่มฟังก์ชั่นเพิ่มเติมและเพิ่มประสิทธิภาพเพียงเล็กน้อย ฉันจะกีดกันการใช้งานของพวกเขาหากคุณไม่มีแอปพลิเคชันที่มีความอ่อนไหวต่อเวลา ไม่ว่าเราจะมีบทสรุป:

• .at เลือกค่าสเกลาร์เดียวใน DataFrame ตามป้ายกำกับเท่านั้น
• .iat เลือกค่าสเกลาร์เดียวใน DataFrame ตามตำแหน่งจำนวนเต็มเท่านั้น

นอกเหนือจากการเลือกตามเลเบลและตำแหน่งจำนวนเต็มการเลือกแบบบูลหรือที่เรียกว่าการจัดทำดัชนีบูลีนนั้นมีอยู่

ตัวอย่างการอธิบาย.loc, การ.ilocเลือกบูลีนและ.atและ.iatแสดงอยู่ด้านล่าง

ครั้งแรกที่เราจะมุ่งเน้นไปที่ความแตกต่างระหว่างและ.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'

คัดเลือกโดย.atและ.iat

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

df.at['Christina', 'color']
'black'

การเลือกด้วย.iatเกือบจะเหมือนกัน.ilocแต่จะเลือกค่าสเกลาร์เดียวเท่านั้น คุณต้องส่งจำนวนเต็มสำหรับทั้งที่ตั้งของแถวและคอลัมน์

df.iat[2, 5]
'FL'

df = pd.DataFrame({'A':['a', 'b', 'c'], 'B':[54, 67, 89]}, index=[100, 200, 300])

df

                        A   B
                100     a   54
                200     b   67
                300     c   89
In [19]:    
df.loc[100]

Out[19]:
A     a
B    54
Name: 100, dtype: object

In [20]:    
df.iloc[0]

Out[20]:
A     a
B    54
Name: 100, dtype: object

In [24]:    
df2 = df.set_index([df.index,'A'])
df2

Out[24]:
        B
    A   
100 a   54
200 b   67
300 c   89

In [25]:    
df2.ix[100, 'a']

Out[25]:    
B    54
Name: (100, a), dtype: int64

เริ่มต้นด้วย df เล็ก ๆ นี้:

import pandas as pd
import time as tm
import numpy as np
n=10
a=np.arange(0,n**2)
df=pd.DataFrame(a.reshape(n,n))

เราจะได้

df
Out[25]: 
        0   1   2   3   4   5   6   7   8   9
    0   0   1   2   3   4   5   6   7   8   9
    1  10  11  12  13  14  15  16  17  18  19
    2  20  21  22  23  24  25  26  27  28  29
    3  30  31  32  33  34  35  36  37  38  39
    4  40  41  42  43  44  45  46  47  48  49
    5  50  51  52  53  54  55  56  57  58  59
    6  60  61  62  63  64  65  66  67  68  69
    7  70  71  72  73  74  75  76  77  78  79
    8  80  81  82  83  84  85  86  87  88  89
    9  90  91  92  93  94  95  96  97  98  99

ด้วยสิ่งนี้เรามี:

df.iloc[3,3]
Out[33]: 33

df.iat[3,3]
Out[34]: 33

df.iloc[:3,:3]
Out[35]: 
    0   1   2   3
0   0   1   2   3
1  10  11  12  13
2  20  21  22  23
3  30  31  32  33



df.iat[:3,:3]
Traceback (most recent call last):
   ... omissis ...
ValueError: At based indexing on an integer index can only have integer indexers

ดังนั้นเราไม่สามารถใช้. ii สำหรับชุดย่อยซึ่งเราต้องใช้. iloc เท่านั้น

แต่ลองเลือกทั้งคู่จาก df ที่ใหญ่กว่าและลองตรวจสอบความเร็ว ...

# -*- coding: utf-8 -*-
"""
Created on Wed Feb  7 09:58:39 2018

@author: Fabio Pomi
"""

import pandas as pd
import time as tm
import numpy as np
n=1000
a=np.arange(0,n**2)
df=pd.DataFrame(a.reshape(n,n))
t1=tm.time()
for j in df.index:
    for i in df.columns:
        a=df.iloc[j,i]
t2=tm.time()
for j in df.index:
    for i in df.columns:
        a=df.iat[j,i]
t3=tm.time()
loc=t2-t1
at=t3-t2
prc = loc/at *100
print('\nloc:%f at:%f prc:%f' %(loc,at,prc))

loc:10.485600 at:7.395423 prc:141.784987

ด้วย. loc เราสามารถจัดการชุดย่อยและด้วย. at เพียง scalar เดียว แต่. at เร็วกว่า. loc

:-)