Theory
સાઠ હજાર હરોળ, પાંચ ઉપયોગી નજર
ResultDesk હવે આખી university ની CSV લોડ કરે છે: સાઠ હજાર હરોળ. print(df) ફિલ્મના અંતના શ્રેયની જેમ સરકી જાય છે.
વિશ્લેષકો ક્યારેય આખાં કોષ્ટકો વાંચતા નથી. એ નજર નાખે છે: પહેલી હરોળ (બરાબર લોડ થયું?), છેલ્લી હરોળ (બરાબર પૂરું થયું?), એક આંકડાકીય સારાંશ (એ કેવું દેખાય છે?), અને પછી એ ચોક્કસ ખાનાં તરફ હાથ લંબાવે છે.
પાંચ functions એ બધું આવરે છે, અને એમાંનાં બે, loc અને iloc, એવો ભેદ વહન કરે છે જેને પરીક્ષાઓ દર વર્ષે નિચોવે છે.
Theory
Flat નો નંબર સામે ડાબેથી ત્રીજો દરવાજો
ઇમારતમાં ઘર શોધવાની બે રીત:
- લેબલથી: "Flat 203": દરવાજા પરનો નંબર. એ loc છે: એ index નાં લેબલ અને ખાનાંનાં નામ વાંચે છે.
- સ્થાનથી: "બીજો માળ, ત્રીજો દરવાજો": પ્રવેશદ્વારથી ગણતાં. એ iloc (integer-location) છે: દરવાજા પર જે લખ્યું હોય એ ગમે તે, એ 0, 1, 2 ગણે છે.
એ જ ઇમારત, સરનામાની બે વ્યવસ્થા, અને એ ત્યાં સુધી જ સંમત રહે છે જ્યાં સુધી દરવાજા ક્રમમાં નંબરવાળા હોય.
Theory
નજર નાખવાની ઓજારપેટી
- df.head(): પહેલી 5 હરોળ (દસ માટે head(10)): બરાબર-લોડ-થયું-કે-નહીં ની તપાસ.
- df.tail(): છેલ્લી 5: તૂટેલી અંતિમ લીટીઓ અને આયાતનો કચરો પકડે છે.
- df.describe(): દરેક numeric ખાના માટે count, mean, std, min, ચતુર્થક (25%, 50%, 75%), max: ગયા પાઠના આંકડા, એક call માં.
- df.to_numpy(): નીચેનું કાચું numpy નું array, લેબલ કઢાયેલાં (જૂની જોડણી
.valuesપુસ્તકોમાં હજી દેખાય છે: એ જ વિચાર).
ચારેય ફક્ત વાંચવાની નજર છે: એમાંનું કોઈ DataFrame બદલતું નથી.
Practical
નજર, પછી ચોક્કસ સરનામાં
import pandas as pd
df = pd.read_csv('marks.csv') # index: 0, 1, 2, ...
print(df.head()) # first 5 rows
print(df.tail(3)) # last 3
print(df.describe()) # the statistical X-ray
print(df.to_numpy()) # raw array, labels gone (aka .values)
# loc: BY LABEL (index label, column NAME)
print(df.loc[0, 'score']) # row labelled 0, column 'score'
print(df.loc[0:3, ['roll', 'score']]) # labels 0..3 INCLUSIVE: 4 rows!
# iloc: BY POSITION (counting from 0)
print(df.iloc[0, 2]) # first row, third column
print(df.iloc[0:3]) # positions 0,1,2: 3 rows (end EXCLUDED)
# loc happily takes last lesson's masks too:
print(df.loc[df['score'] > 60, ['roll', 'score']])
This example runs in Gri-Learn on the web, where you can edit it and see the output.
At a glance
loc સામે iloc, પરીક્ષાનું કોષ્ટક
| પાસું | loc | iloc |
|---|---|---|
| શેનાથી પસંદ કરે | લેબલ (index નું મૂલ્ય, ખાનાનું નામ) | પૂર્ણાંક સ્થાન (0, 1, 2...) |
| 0:3 નો ટુકડો શું આપે | 4 હરોળ (બંને છેડા સહિત) | 3 હરોળ (અંતનો છેડો બાદ) |
| ખાનાનું સ્વરૂપ | df.loc[0, 'score'] | df.iloc[0, 2] |
| Boolean masks | હા | ના (ફક્ત સ્થાન) |
Think first
ચાર-સામે-ત્રણ નો ફાંદો
df પાસે default index 0,1,2,...,9 છે. Tap કરતાં પહેલાં બંનેના જવાબ આપો: df.loc[0:3] કેટલી હરોળ આપે છે, df.iloc[0:3] કેટલી આપે છે, અને એ કેમ જુદી પડે છે?
Show the answer
loc[0:3] → 4 હરોળ (લેબલ 0, 1, 2, 3): લેબલના ટુકડા બંને છેડા સામેલ કરે છે, કારણ કે મરજી મુજબનાં લેબલ સાથે ('Riya':'Aman'?) pandas "અંતથી એક આગળ" ગણી શકતું નથી.
iloc[0:3] → 3 હરોળ (સ્થાન 0, 1, 2): પૂર્ણાંકના ટુકડા Python ની list ના નિયમો પાળે છે, અંતનો છેડો બાદ.
સરખી દેખાતી અભિવ્યક્તિ, જુદી હરોળની સંખ્યા: આ જ loc/iloc નો પરીક્ષાનો પ્રશ્ન છે, અને હવે તમે ફક્ત આંકડા નહીં, કારણ સાથે જવાબ આપી શકો છો.
Quiz
ગાળ્યા પછી, top = df[df['score'] > 80], બચેલાં index નાં લેબલ 7, 23, 41 છે. કયું call ભરોસાપાત્ર રીતે **પહેલી** બચેલી હરોળ આપે છે?
- top.iloc[0]: સ્થાન શૂન્ય હંમેશા હોય છે; top.loc[0] એ KeyError આપે છે કારણ કે કોઈ હરોળનું લેબલ 0 નથી
- top.loc[0]: loc હંમેશા પહેલી હરોળ આપે છે
- top.head(): ગાળ્યા પછી head વાપરી શકાતું નથી
- બંને ચાલે છે: ગાળેલા frames પર loc અને iloc અદલાબદલ થઈ શકે છે
Show the answer
top.iloc[0]: સ્થાન શૂન્ય હંમેશા હોય છે; top.loc[0] એ KeyError આપે છે કારણ કે કોઈ હરોળનું લેબલ 0 નથી
ગાળવાથી મૂળ લેબલ (7, 23, 41) જળવાય છે, એટલે હવે 0 નું કોઈ લેબલ છે જ નહીં: loc[0] એ 0 નંબરવાળો દરવાજો શોધે છે અને નિષ્ફળ જાય છે. iloc[0] ભૌતિક રીતે ગણે છે: પહેલી હરોળ, એનું લેબલ ગમે તે હોય. ગાળ્યા પછીનું આ છૂટા પડવું જ એ જગ્યા છે જ્યાં બે વ્યવસ્થા સંમત થવાનું બંધ કરે છે, અને વિકલ્પ A નો તર્ક એ વ્યાવસાયિક ટેવ છે: 'પહેલી/છેલ્લી' માટે સ્થાન, 'X તરીકે ઓળખાતી હરોળ' માટે લેબલ. (head(1) પણ ચાલત: વિકલ્પ C નો દાવો ખોટો છે.)
Watch out
રોજિંદી ત્રણ લપસણ
સ્થાન સાથે loc: index 0,1,2... હોય ત્યાં સુધી નસીબે ચાલે છે, કોઈ પણ ગાળણ કે ક્રમ પછી તૂટે છે: ટાઈપ કરતાં પહેલાં લેબલ-કે-સ્થાન નક્કી કરો.
describe() ધાર્યા કરતાં ઓછાં ખાનાં દેખાડે છે: એ default માં ફક્ત numeric ખાનાંનો સારાંશ આપે છે; લખાણનાં ખાનાં માટે describe(include='object') જોઈએ.
જૂનાં પુસ્તકોમાં .values: to_numpy() જેવું જ array; બંને નામ ઓળખો, આધુનિક લખો.
Theory
એકમ 4 પૂરો; ચિત્રો શરૂ થાય છે
તમારી pandas ની પેટી ગણો: લોડ કરવું અને સાચવવું (read_csv/to_csv), કાપવું (કૌંસ અને masks), સારાંશ કરવો (mean થી describe), અને ચોક્કસ સરનામું આપવું (loc/iloc). એ કામ કરતા વિશ્લેષકનું હાર્દ છે. એકમ 5 આ સંખ્યાઓને ચિત્રો માં ફેરવે છે: matplotlib તમે કાઢેલી એ જ Series લઈને વર્ગની કથા દોરે છે: lines, bars, scatters, histograms.
Summary
Key takeaways
- head(n)/tail(n): છેડા પર નજર; describe(): numeric ખાનાંનો count થી max સુધીનો આંકડાકીય સારાંશ.
- to_numpy() (અગાઉ .values) DataFrame ને એના કાચા numpy ના array માં ઉતારે છે.
- loc લેબલ થી પસંદ કરે છે: ટુકડા બંને છેડા સામેલ કરે છે; boolean masks સ્વીકારે છે.
- iloc સ્થાન થી પસંદ કરે છે: ટુકડા અંતનો છેડો બાદ કરે છે, Python ની lists ની જેમ.
- Default index પર loc[0:3] = 4 હરોળ, iloc[0:3] = 3 હરોળ: જાણીતી પરીક્ષાની જોડી.
- ગાળ્યા પછી લેબલમાં ખાલી જગ્યા રહે છે: 'પહેલી હરોળ' માટે iloc[0], 'X લેબલવાળી હરોળ' માટે loc.
- Memory hook: Flat નો નંબર સામે ડાબેથી ત્રીજો દરવાજો.