මට DataFrameපණ්ඩස්ගෙන් එකක් තිබේ:

import pandas as pd
inp = [{'c1':10, 'c2':100}, {'c1':11,'c2':110}, {'c1':12,'c2':120}]
df = pd.DataFrame(inp)
print df

ප්‍රතිදානය:

   c1   c2
0  10  100
1  11  110
2  12  120

දැන් මට මෙම රාමුවේ පේළි හරහා නැවත කියවීමට අවශ්‍යයි. සෑම පේළියක් සඳහාම එහි මූලද්‍රව්‍යයන්ට (සෛලවල අගයන්) තීරු නාමයෙන් ප්‍රවේශ වීමට මට අවශ්‍යය. උදාහරණයක් වශයෙන්:

for row in df.rows:
   print row['c1'], row['c2']

පාණ්ඩස්හි එය කළ හැකිද?

මට මේ හා සමාන ප්‍රශ්නයක් හමු විය . නමුත් එය මට අවශ්‍ය පිළිතුර ලබා දෙන්නේ නැත. උදාහරණයක් ලෙස, එහි භාවිතා කිරීමට යෝජනා කර ඇත:

for date, row in df.T.iteritems():

හෝ

for row in df.iterrows():

නමුත් rowවස්තුව යනු කුමක්ද සහ එය සමඟ වැඩ කරන්නේ කෙසේද යන්න මට තේරෙන්නේ නැත.

DataFrame.iterrows යනු දර්ශකය සහ පේළිය යන දෙකම ලබා දෙන උත්පාදක ය

import pandas as pd
import numpy as np

df = pd.DataFrame([{'c1':10, 'c2':100}, {'c1':11,'c2':110}, {'c1':12,'c2':120}])

for index, row in df.iterrows():
    print(row['c1'], row['c2'])

Output: 
   10 100
   11 110
   12 120

පැන්ඩාස් හි දත්ත රාමුවක පේළි හරහා නැවත ක්‍රියා කරන්නේ කෙසේද?

පිළිතුර: එපා ^* !

පැන්ඩාස් හි අනුකරණය කිරීම ප්‍රති-රටාවක් වන අතර ඔබ කළ යුත්තේ ඔබ අනෙක් සෑම විකල්පයක්ම අවසන් කළ විට පමණි. iterපේළි දහස් ගණනකට වඩා එහි නමෙහි " " සමඟ කිසිදු කාර්යයක් භාවිතා නොකළ යුතුය, නැතහොත් ඔබට බොහෝ කාලයක් බලා සිටීමට පුරුදු වනු ඇත .

ඔබට දත්ත රාමුවක් මුද්‍රණය කිරීමට අවශ්‍යද? භාවිතා කරන්න DataFrame.to_string().

ඔබට යමක් ගණනය කිරීමට අවශ්‍යද? එවැනි අවස්ථාවක, මෙම අනුපිළිවෙලෙහි ක්‍රම සොයන්න (ලැයිස්තුව මෙතැන් සිට වෙනස් කරන ලදි ):

1. දෛශිකකරණය
2. සයිතන් චර්යාවන්
3. ලැයිස්තු අවබෝධය (වැනිලා forලූප්)
4. DataFrame.apply(): i) සයිතන් හි සිදු කළ හැකි අඩු කිරීම්, ii) පයිතන් අවකාශයේ අනුකරණය කිරීම
5. DataFrame.itertuples() සහ iteritems()
6. DataFrame.iterrows()

iterrowsසහ itertuples(මෙම ප්‍රශ්නයට පිළිතුරු වශයෙන් බොහෝ ඡන්ද ලබා ගැනීම) අනුක්‍රමික සැකසුම් සඳහා පේළි වස්තු / නාම පුවරු උත්පාදනය කිරීම වැනි ඉතා දුර්ලභ අවස්ථාවන්හිදී භාවිතා කළ යුතුය, ඇත්ත වශයෙන්ම මෙම කාර්යයන් සඳහා ප්‍රයෝජනවත් වන එකම දෙය මෙයයි.

අධිකාරියට අභියාචනයක් ඉදිරිපත් කරන්න

පුනරාවර්තනයේ ප්‍රලේඛන පිටුවේ විශාල රතු අනතුරු ඇඟවීමේ පෙට්ටියක් ඇත:

පැන්ඩා වස්තූන් හරහා ගමන් කිරීම සාමාන්‍යයෙන් මන්දගාමී වේ. බොහෝ අවස්ථාවන්හීදී, පේළි හරහා අතින් නැවත යෙදීම අවශ්‍ය නොවේ [...].

_{* එය ඇත්ත වශයෙන්ම "එපා" යන්නට වඩා ටිකක් සංකීර්ණයි. df.iterrows()මෙම ප්‍රශ්නයට නිවැරදි පිළිතුර වේ, නමුත් "ඔබේ දෘෂ්ටි කෝණය දෛශික කරන්න" වඩා හොඳ එකකි. පුනරාවර්තනය වළක්වා ගත නොහැකි තත්වයන් ඇති බව මම පිළිගනිමි (නිදසුනක් ලෙස, සමහර මෙහෙයුම්වල ප්‍රති result ලය පෙර පේළිය සඳහා ගණනය කළ අගය මත රඳා පවතී). කෙසේ වෙතත්, කවදාදැයි දැන ගැනීමට පුස්තකාලය සමඟ යම් දැනුමක් අවශ්‍ය වේ. ඔබට ක්‍රියාකාරී විසඳුමක් අවශ්‍ය දැයි ඔබට විශ්වාස නැත්නම්, ඔබට බොහෝ විට අවශ්‍ය නොවේ. PS: මෙම පිළිතුර ලිවීම සඳහා මගේ තාර්කිකත්වය ගැන වැඩි විස්තර දැනගැනීම සඳහා, පහළට යන්න.}

ලූපයට වඩා වේගවත්: දෛශිකකරණය , සයිතන්

මූලික මෙහෙයුම් සහ ගණනය කිරීම් වලින් හොඳ සංඛ්‍යාවක් පැන්ඩස් විසින් "දෛශිකකරණය" කරනු ලැබේ (NumPy හරහා හෝ සයිතොනීකරණය කරන ලද කාර්යයන් හරහා). මෙයට අංක ගණිතය, සැසඳීම්, (බොහෝ) අඩු කිරීම්, නැවත සකස් කිරීම (හැරීම වැනි), සම්බන්ධ වීම සහ කණ්ඩායම් ක්‍රියාකාරකම් ඇතුළත් වේ. ඔබේ ගැටළුව සඳහා සුදුසු දෛශික ක්‍රමයක් සොයා ගැනීම සඳහා අත්‍යවශ්‍ය මූලික ක්‍රියාකාරිත්වය පිළිබඳ ප්‍රලේඛනය බලන්න .

කිසිවක් නොමැති නම්, අභිරුචි සයිතන් දිගු භාවිතා කර ඔබේම දෑ ලිවීමට නිදහස් වන්න .

ඊළඟ හොඳම දේ: ලැයිස්තු අවබෝධය ^*

1) දෛශික විසඳුමක් නොමැති නම්, 2) කාර්ය සාධනය වැදගත්, නමුත් ඔබේ කේතය සයිතොනීකරණය කිරීමේ කරදරයෙන් මිදීමට තරම් වැදගත් නොවේ නම්, ලැයිස්තු අවබෝධය ඔබේ ඊළඟ ඇමතුම් වරාය විය යුතුය. ඔබේ කේතය මත. ඒ නිසා එය සාක්ෂි හොඳ මුදලක් බව ලැයිස්තුව comprehensions පොදු Pandas කාර්යයන් බොහෝ ප්රමාණවත් තරම් වේගවත් (සහ ඇතැම් විට වේගවත්) යෝජනා කිරීමට.

සූත්රය සරලයි,

# Iterating over one column - `f` is some function that processes your data
result = [f(x) for x in df['col']]
# Iterating over two columns, use `zip`
result = [f(x, y) for x, y in zip(df['col1'], df['col2'])]
# Iterating over multiple columns - same data type
result = [f(row[0], ..., row[n]) for row in df[['col1', ...,'coln']].to_numpy()]
# Iterating over multiple columns - differing data type
result = [f(row[0], ..., row[n]) for row in zip(df['col1'], ..., df['coln'])]

ඔබේ ව්‍යාපාර තර්කනය ශ්‍රිතයකට සම්බන්ධ කර ගත හැකි නම්, ඔබට එය ලැයිස්තුගත අවබෝධයක් භාවිතා කළ හැකිය. අමු පයිතන් කේතයේ සරල බව සහ වේගය හරහා ඔබට අත්තනෝමතික ලෙස සංකීර්ණ දේවල් ක්‍රියාත්මක කළ හැකිය.

ගුහා

ලැයිස්තු අවබෝධය ඔබගේ දත්ත සමඟ වැඩ කිරීම පහසු යැයි උපකල්පනය කරයි - එයින් අදහස් කරන්නේ ඔබේ දත්ත වර්ග ස්ථාවර වන අතර ඔබට NaNs නොමැති නමුත් මෙය සැමවිටම සහතික කළ නොහැක.

1. පළමුවැන්න වඩාත් පැහැදිලිය, නමුත් NaNs සමඟ ගනුදෙනු කිරීමේදී, ඒවා තිබේ නම් සාදන ලද පැන්ඩා ක්‍රම වලට වැඩි කැමැත්තක් දක්වන්න (ඒවාට වඩා හොඳ කොන-නඩත්තු කිරීමේ තර්කනයක් ඇති නිසා), හෝ ඔබේ ව්‍යාපාර තර්කනයට සුදුසු NaN හැසිරවීමේ තර්කනය ඇතුළත් බව සහතික කරන්න.
2. මිශ්‍ර දත්ත වර්ග සමඟ ගනුදෙනු කිරීමේදී ඔබ වඩාත් සුලභ වර්ගයට දත්ත ව්‍යංගයෙන් උඩුගත zip(df['A'], df['B'], ...)කරනවා වෙනුවට නැවත නැවත යෙදිය යුතුය df[['A', 'B']].to_numpy(). උදාහරණයක් ලෙස A සංඛ්‍යාත්මක නම් සහ B නූල් to_numpy()නම්, මුළු අරාවම නූල් වලට දමනු ඇත, එය ඔබට අවශ්‍ය දේ නොවිය හැකිය. වාසනාවකට මෙන් zipඔබේ තීරු එකට ඇලවීම මේ සඳහා වඩාත්ම සරල විසඳුමයි.

_{* ඉහත සඳහන් කේවට්ස් කොටසේ දක්වා ඇති හේතු නිසා ඔබේ සැතපුම් ගණන වෙනස් විය හැකිය .}

පැහැදිලි උදාහරණයක්

පැන්ඩා තීරු දෙකක් එකතු කිරීමේ සරල උදාහරණයකින් වෙනස නිරූපණය කරමු A + B. මෙය දෛශිකකරණය කළ හැකි ඔපෙරෝනයකි, එබැවින් ඉහත සාකච්ඡා කළ ක්‍රමවේදයන්ගේ ක්‍රියාකාරිත්වය වෙනස් කිරීම පහසු වනු ඇත.

ඔබේ යොමු කිරීම සඳහා මිණුම් සලකුණු කේතය . පතුලේ ඇති රේඛාව මම්පන්ඩාස් හි ලියා ඇති ශ්‍රිතයක් මනිනු ලබයි. ඔබ කරන්නේ කුමක්දැයි ඔබ නොදන්නේ නම් අංකපන්ඩා කේතය ලිවීමෙන් වැළකී සිටිය යුතුය. දණ්ඩක් ඔබ (එනම්, වැඩි කැමැත්තක් කළ හැකි API වෙත vecභාර vec_numpy).

කෙසේ වෙතත්, සෑම විටම මෙම කප්පාදුව හා වියලි නොවන බව මා සඳහන් කළ යුතුය. සමහර විට "මෙහෙයුමක් සඳහා හොඳම ක්‍රමය කුමක්ද" යන්නට පිළිතුර "එය ඔබගේ දත්ත මත රඳා පවතී" යන්නයි. මගේ අවවාදය නම් එකක් මත පදිංචි වීමට පෙර ඔබේ දත්ත පිළිබඳ විවිධ ප්‍රවේශයන් පරීක්ෂා කිරීමයි.

තවදුරටත් කියවීම

• පැන්ඩා වලට මිනිත්තු 10 ක් සහ අත්‍යවශ්‍ය මූලික ක්‍රියාකාරිත්වය - පැන්ඩාස් සහ එහි දෛශිකකරණය කරන ලද * / සයිතොනීකරණය කරන ලද කාර්යයන් පිළිබඳ පුස්තකාලයට ඔබව හඳුන්වා දෙන ප්‍රයෝජනවත් සබැඳි.

• කාර්ය සාධනය වැඩි දියුණු කිරීම - සම්මත පැන්ඩා මෙහෙයුම් වැඩි දියුණු කිරීම පිළිබඳ ලියකියවිලි වලින් ලබාගත් ප්‍රාථමිකයකි

• පැන්ඩා වල ලූප ඇත්තෙන්ම නරකද? මා සැලකිලිමත් විය යුත්තේ කවදාද? - ලැයිස්තු අවබෝධය සහ විවිධ මෙහෙයුම් සඳහා ඒවායේ යෝග්‍යතාවය පිළිබඳ සවිස්තරාත්මක ලිවීම (ප්‍රධාන වශයෙන් සංඛ්‍යාත්මක නොවන දත්ත සම්බන්ධ)

• මගේ කේතයේ පැන්ඩා () භාවිතා කිරීමට මට කවදා හෝ අවශ්‍ය වන්නේ කවදාද? -applyමන්දගාමී වේ (නමුත්iter*පවුලතරම් මන්දගාමී නොවේ. කෙසේ වෙතත්, යමෙකුටapplyබරපතල විකල්පයක් ලෙසසැලකිය හැකි (හෝ කළ යුතු) අවස්ථාතිබේ, විශේෂයෙන් සමහරGroupByමෙහෙයුම් වලදී).

_{* පැන්ඩා සංගීත ක්‍රම “දෛශිකකරණය” කර ඇත්තේ ඒවා ශ්‍රේණියේ නිශ්චිතව දක්වා ඇති නමුත් එක් එක් මූලද්‍රව්‍ය මත ක්‍රියාත්මක වන බැවිනි. නූල් මෙහෙයුම් දෛශිකකරණයට සහජයෙන්ම අසීරු බැවින් යටින් පවතින යාන්ත්‍රණයන් තවමත් ක්‍රියාකාරී වේ.}

ඇයි මම මේ පිළිතුර ලිව්වේ

නව පරිශීලකයින්ගෙන් මා දකින පොදු ප්‍රවණතාවක් නම් "X කිරීමට මගේ ඩීඑෆ් හරහා නැවත ක්‍රියා කරන්නේ කෙසේද?". ලූපයක් iterrows()තුළ යමක් කරන අතරතුර ඇමතුම් ලබා දෙන කේතය පෙන්වයි for. මෙන්න හේතුව. දෛශිකකරණය පිළිබඳ සංකල්පයට හඳුන්වා දී නොමැති පුස්තකාලයට නව පරිශීලකයෙකු යමක් කිරීමට ඔවුන්ගේ දත්ත නැවත කියවීමේදී ඔවුන්ගේ ගැටළුව විසඳන කේතය දැකගත හැකිය. ඩේටා ෆ්‍රේම් හරහා නැවත ක්‍රියා කරන්නේ කෙසේදැයි නොදැන, ඔවුන් කරන පළමු දෙය ගූගල් එය වන අතර මෙම ප්‍රශ්නයේදී මෙහි අවසන් වේ. ඔවුන් පිළිගත් පිළිතුර ඔවුන්ට කෙසේ කළ යුතු දැයි පවසන අතර, ඔවුන් ඇස් වසාගෙන මෙම කේතය ධාවනය කරන්නේ නිවැරදිව නොවේ නම් නැවත ප්‍රශ්න කිරීමකින් තොරව ය.

මෙම පිළිතුරේ පරමාර්ථය වන්නේ නව පරිශීලකයින්ට සෑම ගැටළුවකටම විසඳුම අත්‍යවශ්‍ය නොවන බවත්, වඩා හොඳ, වේගවත් හා වඩා මුග්ධ විසඳුම් පැවතිය හැකි බවත් ඒවා ගවේෂණය කිරීම සඳහා කාලය ආයෝජනය කිරීම වටී බවත් තේරුම් ගැනීමට උපකාර කිරීමයි. මම දෛශිකකරණයට එදිරිව පුනරාවර්තන යුද්ධයක් ආරම්භ කිරීමට උත්සාහ නොකරමි, නමුත් මෙම පුස්තකාලය සමඟ ඔවුන්ගේ ගැටළු වලට විසඳුම් ලබා දීමේදී නව පරිශීලකයින් දැනුවත් කිරීමට මට අවශ්‍යය.

ඔබට ඇත්තටම කිරීමට අවශ්ය නම් පළමු සලකා වඩාත් කැපීපෙනේ වූ DataFrame දී පේළි කට. විකල්ප සඳහා මෙම පිළිතුර බලන්න .

ඔබට තවමත් පේළි හරහා නැවත යෙදීමට අවශ්‍ය නම්, ඔබට පහත ක්‍රම භාවිතා කළ හැකිය. වෙනත් කිසිදු පිළිතුරක සඳහන් නොවන වැදගත් අවවාද කිහිපයක් සටහන් කරන්න .

• DataFrame.iterrows ()

  for index, row in df.iterrows():
      print(row["c1"], row["c2"])

• DataFrame.itertuples ()

  for row in df.itertuples(index=True, name='Pandas'):
      print(row.c1, row.c2)

itertuples() වඩා වේගවත් විය යුතුය iterrows()

ලේඛනයට අනුව දැනුවත්ව සිටින්න (මේ මොහොතේ පැන්ඩා 0.24.2):

• iterrows: dtypeපේළියේ සිට පේළියට නොගැලපේ

  Iterrows සෑම පේළියක් සඳහාම ශ්‍රේණියක් ලබා දෙන නිසා, එය පේළි හරහා dtypes ආරක්ෂා නොකරයි (දත්ත රාමු සඳහා තීරු හරහා dtypes සංරක්ෂණය කර ඇත). පේළි හරහා නැවත ගමන් කරන විට dtypes ආරක්ෂා කර ගැනීම සඳහා, itertuples () භාවිතා කිරීම වඩා හොඳය, එය නම් කළ අගයන් නැවත ලබා දෙයි.

• iterrows: පේළි වෙනස් නොකරන්න

  ඔබ නැවත කියවන දෙයක් කිසි විටෙකත් වෙනස් නොකළ යුතුය . මෙය සෑම අවස්ථාවකම වැඩ කිරීමට සහතික නොවේ. දත්ත වර්ග මත පදනම්ව, අනුකාරකය පිටපතක් ලබා දෙන අතර එය දර්ශනයක් නොවන අතර එයට ලිවීමෙන් කිසිදු බලපෑමක් සිදු නොවේ.

  භාවිතය DataFrame.apply () ඒ වෙනුවට:

  new_df = df.apply(lambda x: x * 2)

• itertuples:

  තීරු නම් වලංගු නොවන පයිතන් හඳුනාගැනීම්, නැවත නැවත කිරීම හෝ යටි ඉරි වලින් ආරම්භ කිරීම නම් ස්ථානීය නම් ලෙස නම් කරනු ලැබේ. තීරු විශාල සංඛ්‍යාවක් සමඟ (> 255), සාමාන්‍ය ටුපල් ආපසු ලබා දෙනු ලැබේ.

වැඩි විස්තර සඳහා පුනරාවර්තනය පිළිබඳ පැන්ඩා ලියකියවිලි බලන්න .

ඔබ භාවිතා කළ යුතුය df.iterrows(). පේළි-පේළිය නැවත සැකසීම විශේෂයෙන් කාර්යක්ෂම නොවන්නේ Seriesවස්තූන් නිර්මාණය කළ යුතු බැවිනි.

අතර iterrows()හොඳ විකල්පයක් වන, සමහර විට itertuples()වඩාත් වේගවත් විය හැක:

df = pd.DataFrame({'a': randn(1000), 'b': randn(1000),'N': randint(100, 1000, (1000)), 'x': 'x'})

%timeit [row.a * 2 for idx, row in df.iterrows()]
# => 10 loops, best of 3: 50.3 ms per loop

%timeit [row[1] * 2 for row in df.itertuples()]
# => 1000 loops, best of 3: 541 µs per loop

ඔබට df.apply()පේළි හරහා නැවත සැකසීමට සහ ශ්‍රිතයක් සඳහා තීරු කිහිපයකට ප්‍රවේශ විය හැකිය.

docs: DataFrame.apply ()

def valuation_formula(x, y):
    return x * y * 0.5

df['price'] = df.apply(lambda row: valuation_formula(row['x'], row['y']), axis=1)

ඔබට පහත පරිදි df.iloc ශ්‍රිතය භාවිතා කළ හැකිය:

for i in range(0, len(df)):
    print df.iloc[i]['c1'], df.iloc[i]['c2']

පේළි සහ තීරු මත නැවත ක්‍රියා කරන්නේ කෙසේදැයි මම සොයමින් සිටියෙමි .

for i, row in df.iterrows():
    for j, column in row.iteritems():
        print(column)

කාර්යක්ෂමව නැවත ක්‍රියා කරන්නේ කෙසේද?

ඔබට සැබවින්ම පැන්ඩාස් දත්ත රාමුවක් නැවත සැකසීමට සිදුවුවහොත්, ඔබට බොහෝ විට iterrows () භාවිතා කිරීමෙන් වැළකී සිටීමට අවශ්‍ය වනු ඇත . විවිධ ක්‍රම ඇති අතර සුපුරුදු iterrows()දේ හොඳම ඒවා නොවේ. itertuples () 100 ගුණයක් වේගවත් විය හැකිය.

කෙටියෙන්:

• සාමාන්ය රීතියක් ලෙස, භාවිතා කරන්න df.itertuples(name=None). විශේෂයෙන්, ඔබට ස්ථාවර සංඛ්‍යා තීරු සහ තීරු 255 ට අඩු විට. කරුණ බලන්න (3)
• එසේ නොමැතිනම්, df.itertuples()ඔබේ තීරුවල අවකාශ හෝ '-' වැනි විශේෂ අක්ෂර තිබේ නම් හැර භාවිතා කරන්න. කරුණ බලන්න (2)
• එය භාවිතා කිරීමට හැකි වන itertuples()ඔබේ dataframe පසුගිය උදාහරණයක් භාවිතා අමුතු තීරු ඇත පවා නම්. කරුණ බලන්න (4)
• iterrows()ඔබට පෙර විසඳුම් ලබා ගත නොහැකි නම් පමණක් භාවිතා කරන්න. කරුණ බලන්න (1)

පැන්ඩාස් දත්ත රාමුවක පේළි හරහා නැවත සැකසීමට විවිධ ක්‍රම:

පේළි මිලියනයක් සහ තීරු 4 ක් සහිත අහඹු දත්ත රාමුවක් ජනනය කරන්න:

    df = pd.DataFrame(np.random.randint(0, 100, size=(1000000, 4)), columns=list('ABCD'))
    print(df)

1) සුපුරුදු iterrows()පහසුය, නමුත් ඉතා මන්දගාමී ය:

start_time = time.clock()
result = 0
for _, row in df.iterrows():
    result += max(row['B'], row['C'])

total_elapsed_time = round(time.clock() - start_time, 2)
print("1. Iterrows done in {} seconds, result = {}".format(total_elapsed_time, result))

2) පෙරනිමිය itertuples()දැනටමත් වඩා වේගවත් ය, නමුත් එය වැනි තීරු නම් සමඟ ක්‍රියා නොකරයි My Col-Name is very Strange(ඔබේ තීරු පුනරාවර්තනය වී ඇත්නම් හෝ තීරු නාමයක් සරලවම පයිතන් විචල්‍ය නාමයක් බවට පරිවර්තනය කළ නොහැකි නම්).

start_time = time.clock()
result = 0
for row in df.itertuples(index=False):
    result += max(row.B, row.C)

total_elapsed_time = round(time.clock() - start_time, 2)
print("2. Named Itertuples done in {} seconds, result = {}".format(total_elapsed_time, result))

3) itertuples()නම භාවිතා කරන පෙරනිමිය = කිසිවක් ඊටත් වඩා වේගවත් නමුත් ඔබට තීරුවකට විචල්‍යයක් අර්ථ දැක්විය යුතු බැවින් එය පහසු නොවේ.

start_time = time.clock()
result = 0
for(_, col1, col2, col3, col4) in df.itertuples(name=None):
    result += max(col2, col3)

total_elapsed_time = round(time.clock() - start_time, 2)
print("3. Itertuples done in {} seconds, result = {}".format(total_elapsed_time, result))

4) අවසාන වශයෙන්, නම් itertuples()කිරීම පෙර ලක්ෂ්‍යයට වඩා මන්දගාමී වේ, නමුත් ඔබට එක් තීරුවකට විචල්‍යයක් නිර්වචනය කිරීමට අවශ්‍ය නොවන අතර එය තීරු නම් සමඟ ක්‍රියා කරයි My Col-Name is very Strange.

start_time = time.clock()
result = 0
for row in df.itertuples(index=False):
    result += max(row[df.columns.get_loc('B')], row[df.columns.get_loc('C')])

total_elapsed_time = round(time.clock() - start_time, 2)
print("4. Polyvalent Itertuples working even with special characters in the column name done in {} seconds, result = {}".format(total_elapsed_time, result))

ප්‍රතිදානය:

         A   B   C   D
0       41  63  42  23
1       54   9  24  65
2       15  34  10   9
3       39  94  82  97
4        4  88  79  54
...     ..  ..  ..  ..
999995  48  27   4  25
999996  16  51  34  28
999997   1  39  61  14
999998  66  51  27  70
999999  51  53  47  99

[1000000 rows x 4 columns]

1. Iterrows done in 104.96 seconds, result = 66151519
2. Named Itertuples done in 1.26 seconds, result = 66151519
3. Itertuples done in 0.94 seconds, result = 66151519
4. Polyvalent Itertuples working even with special characters in the column name done in 2.94 seconds, result = 66151519

මෙම ලිපිය iterrows සහ itertuples අතර ඉතා රසවත් සංසන්දනයකි

ක්‍රියාත්මක කරන ඔබේම අනුකාරකය ඔබට ලිවිය හැකිය namedtuple

from collections import namedtuple

def myiter(d, cols=None):
    if cols is None:
        v = d.values.tolist()
        cols = d.columns.values.tolist()
    else:
        j = [d.columns.get_loc(c) for c in cols]
        v = d.values[:, j].tolist()

    n = namedtuple('MyTuple', cols)

    for line in iter(v):
        yield n(*line)

මෙය කෙලින්ම සැසඳිය හැකිය pd.DataFrame.itertuples. එකම කාර්යය වඩාත් කාර්යක්ෂමව ඉටු කිරීම මගේ ඉලක්කයයි.

මගේ ශ්‍රිතය සමඟ ලබා දී ඇති දත්ත රාමුව සඳහා:

list(myiter(df))

[MyTuple(c1=10, c2=100), MyTuple(c1=11, c2=110), MyTuple(c1=12, c2=120)]

හෝ සමඟ pd.DataFrame.itertuples:

list(df.itertuples(index=False))

[Pandas(c1=10, c2=100), Pandas(c1=11, c2=110), Pandas(c1=12, c2=120)]

සවිස්තරාත්මක පරීක්ෂණයක්
අපි සියලු තීරු ලබා ගත හැකි සහ තීරු උප කුලක පරීක්ෂා කරමු.

def iterfullA(d):
    return list(myiter(d))

def iterfullB(d):
    return list(d.itertuples(index=False))

def itersubA(d):
    return list(myiter(d, ['col3', 'col4', 'col5', 'col6', 'col7']))

def itersubB(d):
    return list(d[['col3', 'col4', 'col5', 'col6', 'col7']].itertuples(index=False))

res = pd.DataFrame(
    index=[10, 30, 100, 300, 1000, 3000, 10000, 30000],
    columns='iterfullA iterfullB itersubA itersubB'.split(),
    dtype=float
)

for i in res.index:
    d = pd.DataFrame(np.random.randint(10, size=(i, 10))).add_prefix('col')
    for j in res.columns:
        stmt = '{}(d)'.format(j)
        setp = 'from __main__ import d, {}'.format(j)
        res.at[i, j] = timeit(stmt, setp, number=100)

res.groupby(res.columns.str[4:-1], axis=1).plot(loglog=True);

dataframeඔබට භාවිතා කළ හැකි සියලුම පේළි ලූප කිරීමට:

for x in range(len(date_example.index)):
    print date_example['Date'].iloc[x]

 for ind in df.index:
     print df['c1'][ind], df['c2'][ind]

සමහර විට ප්රයෝජනවත් රටාවක් වන්නේ:

# Borrowing @KutalmisB df example
df = pd.DataFrame({'col1': [1, 2], 'col2': [0.1, 0.2]}, index=['a', 'b'])
# The to_dict call results in a list of dicts
# where each row_dict is a dictionary with k:v pairs of columns:value for that row
for row_dict in df.to_dict(orient='records'):
    print(row_dict)

එහි ප්‍රති results ලය:

{'col1':1.0, 'col2':0.1}
{'col1':2.0, 'col2':0.2}

පුඩුවක් කිරීමට සියලු පේළි dataframeහා භාවිතය එක් එක් පේලියේ අගයන් පහසුවෙන් , namedtuplesපරිවර්තනය කළ හැක ndarrays. උදාහරණයක් වශයෙන්:

df = pd.DataFrame({'col1': [1, 2], 'col2': [0.1, 0.2]}, index=['a', 'b'])

පේළි හරහා අනුකරණය කිරීම:

for row in df.itertuples(index=False, name='Pandas'):
    print np.asarray(row)

ප්‍රති results ල:

[ 1.   0.1]
[ 2.   0.2]

නම් කරන බව කරුණාවෙන් සලකන්න index=True, මෙම දර්ශකය tuple පළමු අංගය ලෙස එකතු සමහර යෙදුම් සඳහා අනවශ්ය විය හැකි.

දත්ත රාමුවක් ලබා ගැනීමේදී විසිකිරීමේ පේළි නැවත සැකසීමට ක්‍රමයක් ඇත, ශ්‍රේණියක් නොවේ. පේළිය දත්ත රාමුවක් ලෙස ආපසු ලබා දීම සඳහා ඔබට දර්ශකයක් ලැයිස්තුවක් ලෙස සම්මත කළ හැකි බව කිසිවෙකු සඳහන් කර ඇති බවක් මා දකින්නේ නැත:

for i in range(len(df)):
    row = df.iloc[[i]]

ද්විත්ව වරහන් භාවිතය සැලකිල්ලට ගන්න. මෙය තනි පේළියක් සහිත දත්ත රාමුවක් ලබා දෙයි.

අගයන් බැලීම සහ වෙනස් කිරීම යන දෙකම සඳහා, මම භාවිතා කරමි iterrows(). A for loop එකකදී සහ tuple unpacking භාවිතා කිරීමෙන් (උදාහරණය බලන්න :) i, row, මම rowඅගය බැලීම සඳහා පමණක් භාවිතා iකරන අතර locමට අගයන් වෙනස් කිරීමට අවශ්‍ය වූ විට ක්‍රමය සමඟ භාවිතා කරමි. පෙර පිළිතුරු වල සඳහන් පරිදි, මෙහිදී ඔබ නැවත කියවන දෙයක් වෙනස් නොකළ යුතුය.

for i, row in df.iterrows():
    df_column_A = df.loc[i, 'A']
    if df_column_A == 'Old_Value':
        df_column_A = 'New_value'  

මෙන්න rowලූපයේ ඇත්තේ එම පේළියේ පිටපතක් මිස එය නැරඹීම නොවේ. එමනිසා, ඔබ වැනි දෙයක් ලිවිය යුතු නැත row['A'] = 'New_Value', එය දත්ත රාමුව වෙනස් නොකරනු ඇත. කෙසේ වෙතත්, ඔබට වැඩ කිරීමට දත්ත රාමුව භාවිතා කිරීමට iසහ locනියම කිරීමට හැකිය.

cs95 පෙන්වන්නේ පැන්ඩාස් දෛශිකකරණය දත්ත රාමු සමඟ දේවල් ගණනය කිරීම සඳහා වෙනත් පැන්ඩා ක්‍රමවලට වඩා බොහෝ සෙයින් අභිබවා යන බවයි.

මට අවශ්‍ය වූයේ ඔබ මුලින්ම දත්ත රාමුව NumPy අරාවකට පරිවර්තනය කර දෛශිකකරණය භාවිතා කරන්නේ නම් එය පැන්ඩාස් දත්ත රාමු දෛශිකකරණයට වඩා වේගවත් වන අතර (එය නැවත දත්ත රාමු ශ්‍රේණියක් බවට හැරවීමට කාලයද ඇතුළත් වේ).

ඔබ පහත සඳහන් කාර්යයන් cs95 හි මිණුම් සලකුණු කේතයට එකතු කළහොත් මෙය පැහැදිලිව පෙනේ:

def np_vectorization(df):
    np_arr = df.to_numpy()
    return pd.Series(np_arr[:,0] + np_arr[:,1], index=df.index)

def just_np_vectorization(df):
    np_arr = df.to_numpy()
    return np_arr[:,0] + np_arr[:,1]

පැන්ඩාස් දත්ත රාමුවේ පේළි හරහා නැවත සැකසීමට බොහෝ ක්‍රම තිබේ. ඉතා සරල හා අවබෝධාත්මක ක්‍රමයක් නම්:

df = pd.DataFrame({'A':[1, 2, 3], 'B':[4, 5, 6], 'C':[7, 8, 9]})
print(df)
for i in range(df.shape[0]):
    # For printing the second column
    print(df.iloc[i, 1])

    # For printing more than one columns
    print(df.iloc[i, [0, 2]])

ඊටත් වඩා වේගවත් කිරීම් සඳහා ඔබට NumPy සුචිගත කිරීම කළ හැකිය. එය සැබවින්ම පුනරාවර්තනය නොවන නමුත් සමහර යෙදුම් සඳහා නැවත යෙදීමට වඩා හොඳින් ක්‍රියා කරයි.

subset = row['c1'][0:5]
all = row['c1'][:]

ඔබට එය අරාවකට දැමීමට අවශ්‍ය විය හැකිය. මෙම දර්ශක / තේරීම් දැනටමත් NumPy අරා මෙන් ක්‍රියා කළ යුතු යැයි මම සිතමි, නමුත් මම ගැටළු වලට මුහුණ දී වාත්තු කිරීමට අවශ්‍ය විය

np.asarray(all)
imgs[:] = cv2.resize(imgs[:], (224,224) ) # Resize every image in an hdf5 file

දත්ත රාමුවේ එක් එක් ඉලක්කම් හුදකලා කිරීමට මෙම උදාහරණය iloc භාවිතා කරයි.

import pandas as pd

 a = [1, 2, 3, 4]
 b = [5, 6, 7, 8]

 mjr = pd.DataFrame({'a':a, 'b':b})

 size = mjr.shape

 for i in range(size[0]):
     for j in range(size[1]):
         print(mjr.iloc[i, j])

සමහර පුස්තකාල (උදා: මම භාවිතා කරන ජාවා අන්තර් පුස්තකාල පුස්තකාලයක්) වරකට අගයන් පේළියකින් සම්මත කිරීම අවශ්‍ය වේ, නිදසුනක් ලෙස, දත්ත ප්‍රවාහය කරන්නේ නම්. ප්‍රවාහ ස්වභාවය ප්‍රතිවර්තනය කිරීම සඳහා, මම මගේ දත්ත රාමු අගයන් එකින් එක 'ප්‍රවාහය' කරමි, මම පහත ලියා ඇති අතර එය වරින් වර ප්‍රයෝජනවත් වේ.

class DataFrameReader:
  def __init__(self, df):
    self._df = df
    self._row = None
    self._columns = df.columns.tolist()
    self.reset()
    self.row_index = 0

  def __getattr__(self, key):
    return self.__getitem__(key)

  def read(self) -> bool:
    self._row = next(self._iterator, None)
    self.row_index += 1
    return self._row is not None

  def columns(self):
    return self._columns

  def reset(self) -> None:
    self._iterator = self._df.itertuples()

  def get_index(self):
    return self._row[0]

  def index(self):
    return self._row[0]

  def to_dict(self, columns: List[str] = None):
    return self.row(columns=columns)

  def tolist(self, cols) -> List[object]:
    return [self.__getitem__(c) for c in cols]

  def row(self, columns: List[str] = None) -> Dict[str, object]:
    cols = set(self._columns if columns is None else columns)
    return {c : self.__getitem__(c) for c in self._columns if c in cols}

  def __getitem__(self, key) -> object:
    # the df index of the row is at index 0
    try:
        if type(key) is list:
            ix = [self._columns.index(key) + 1 for k in key]
        else:
            ix = self._columns.index(key) + 1
        return self._row[ix]
    except BaseException as e:
        return None

  def __next__(self) -> 'DataFrameReader':
    if self.read():
        return self
    else:
        raise StopIteration

  def __iter__(self) -> 'DataFrameReader':
    return self

භාවිතා කළ හැකි:

for row in DataFrameReader(df):
  print(row.my_column_name)
  print(row.to_dict())
  print(row['my_column_name'])
  print(row.tolist())

නැවත සැකසෙන පේළි සඳහා අගයන් / නාම සිතියම් ආරක්ෂා කරයි. නිසැකවම, ඉහත දක්වා ඇති පරිදි අයදුම් කිරීම සහ සයිතන් භාවිතා කිරීමට වඩා මන්දගාමී වේ, නමුත් සමහර අවස්ථාවන්හිදී එය අවශ්‍ය වේ.

කෙටියෙන්

• හැකි නම් දෛශිකකරණය භාවිතා කරන්න
• ක්‍රියාකාරිත්වය දෛශිකකරණය කළ නොහැකි නම් - ලැයිස්තු අවබෝධය භාවිතා කරන්න
• සම්පූර්ණ පේළිය නියෝජනය කරන තනි වස්තුවක් ඔබට අවශ්‍ය නම් - itertuples භාවිතා කරන්න
• ඉහත සඳහන් දේ ඉතා මන්දගාමී නම් - swifter.apply උත්සාහ කරන්න
• එය තවමත් මන්දගාමී නම් - සයිතන් පුරුද්ද උත්සාහ කරන්න

මෙම වීඩියෝවේ විස්තර

මිණුම් ලකුණ