නම් කර ඇති තීරු සහ පේළි නොවන අඛණ්ඩ සංඛ්‍යා සහිත පහත දැක්වෙන සුචිගත කළ දත්ත රාමුව මා සතුව ඇත:

          a         b         c         d
2  0.671399  0.101208 -0.181532  0.241273
3  0.446172 -0.243316  0.051767  1.577318
5  0.614758  0.075793 -0.451460 -0.012493

'e'පවතින දත්ත රාමුවට නව තීරුවක් එක් කිරීමට මම කැමතියි , දත්ත රාමුවේ කිසිවක් වෙනස් කිරීමට අවශ්‍ය නැත (එනම්, නව තීරුවේ සෑම විටම දත්ත රාමුවට සමාන දිගක් ඇත).

0   -0.335485
1   -1.166658
2   -0.385571
dtype: float64

eඉහත උදාහරණයට තීරුවක් එක් කරන්නේ කෙසේද ?

ශ්‍රේණිය නිර්මාණය කිරීම සඳහා මුල් df1 දර්ශක භාවිතා කරන්න:

df1['e'] = pd.Series(np.random.randn(sLength), index=df1.index)

2015 සංස්කරණය කරන්න
සමහරු SettingWithCopyWarningමෙම කේතය ලබා ගැනීම වාර්තා කළහ .
කෙසේ වෙතත්, කේතය තවමත් වර්තමාන පැන්ඩා අනුවාදය 0.16.1 සමඟ හොඳින් ක්‍රියාත්මක වේ.

>>> sLength = len(df1['a'])
>>> df1
          a         b         c         d
6 -0.269221 -0.026476  0.997517  1.294385
8  0.917438  0.847941  0.034235 -0.448948

>>> df1['e'] = pd.Series(np.random.randn(sLength), index=df1.index)
>>> df1
          a         b         c         d         e
6 -0.269221 -0.026476  0.997517  1.294385  1.757167
8  0.917438  0.847941  0.034235 -0.448948  2.228131

>>> p.version.short_version
'0.16.1'

SettingWithCopyWarningදත්ත රාමුවේ පිටපතක් මත වලංගු නොවන පැවරුමක් දැනුම් දීම මෙහි අරමුණයි. එය ඔබ වැරැද්දක් කළ බව අනිවාර්යයෙන්ම නොකියයි (එයට ව්‍යාජ ධනාත්මක ප්‍රති අවුලුවන) නමුත් 0.13.0 සිට එකම අරමුණක් සඳහා ප්‍රමාණවත් ක්‍රමවේදයන් ඇති බව එය ඔබට දන්වයි. ඔබට අනතුරු ඇඟවීම ලැබුනේ නම්, එහි උපදෙස් අනුගමනය කරන්න : .loc [row_index, col_indexer] = අගය භාවිතා කිරීමට උත්සාහ කරන්න

>>> df1.loc[:,'f'] = pd.Series(np.random.randn(sLength), index=df1.index)
>>> df1
          a         b         c         d         e         f
6 -0.269221 -0.026476  0.997517  1.294385  1.757167 -0.050927
8  0.917438  0.847941  0.034235 -0.448948  2.228131  0.006109
>>> 

ඇත්ත වශයෙන්ම, මෙය දැනට පැන්ඩස් ලියකියවිලි වල විස්තර කර ඇති පරිදි වඩා කාර්යක්ෂම ක්‍රමයකි

සංස්කරණය 2017

අදහස් දැක්වීම්වල සහ lex ඇලෙක්සැන්ඩර් විසින් පෙන්වා දී ඇති පරිදි, දත්ත රාමුවක නව තීරුවක් ලෙස ශ්‍රේණියේ අගයන් එක් කිරීමට දැනට ඇති හොඳම ක්‍රමය භාවිතා කළ හැකිය assign:

df1 = df1.assign(e=pd.Series(np.random.randn(sLength)).values)

නව තීරුවක් එක් කිරීමේ සරල ක්‍රමය මෙයයි: df['e'] = e

පවතින දත්ත රාමුවට 'ඊ' යන නව තීරුවක් එක් කිරීමට මම කැමතියි, දත්ත රාමුවේ කිසිවක් වෙනස් නොකරන්න. (ශ්‍රේණියට සෑම විටම දත්ත රාමුවකට සමාන දිගක් ලැබේ.)

දර්ශක අගයන් ඇති ඒවාට eගැලපේ යැයි මම සිතමිdf1 .

නම් කරන ලද නව තීරුවක් ආරම්භ කිරීමට ඇති පහසුම ක්‍රමය eසහ ඔබේ ශ්‍රේණියේ අගයන් එයට පවරන්න e:

df['e'] = e.values

පැවරීම (පණ්ඩස් 0.16.0+)

පැන්ඩාස් 0.16.0 වන විට, ඔබට ද භාවිතා කළ හැකිය assign, එය දත්ත රාමුවකට නව තීරු ලබා දෙන අතර නව ඒවාට අමතරව සියලු මුල් තීරු සමඟ නව වස්තුවක් (පිටපතක්) ලබා දෙයි.

df1 = df1.assign(e=e.values)

අනුව මෙම උදාහරණය (ද එහි ප්රභව කේත ඇතුළත් වන assignකාර්යය), ඔබ ද එකකට වඩා වැඩි තීරුව ඇතුලත් කර ගත හැක:

df = pd.DataFrame({'a': [1, 2], 'b': [3, 4]})
>>> df.assign(mean_a=df.a.mean(), mean_b=df.b.mean())
   a  b  mean_a  mean_b
0  1  3     1.5     3.5
1  2  4     1.5     3.5

ඔබේ උදාහරණය සමඟ සන්දර්භය තුළ:

np.random.seed(0)
df1 = pd.DataFrame(np.random.randn(10, 4), columns=['a', 'b', 'c', 'd'])
mask = df1.applymap(lambda x: x <-0.7)
df1 = df1[-mask.any(axis=1)]
sLength = len(df1['a'])
e = pd.Series(np.random.randn(sLength))

>>> df1
          a         b         c         d
0  1.764052  0.400157  0.978738  2.240893
2 -0.103219  0.410599  0.144044  1.454274
3  0.761038  0.121675  0.443863  0.333674
7  1.532779  1.469359  0.154947  0.378163
9  1.230291  1.202380 -0.387327 -0.302303

>>> e
0   -1.048553
1   -1.420018
2   -1.706270
3    1.950775
4   -0.509652
dtype: float64

df1 = df1.assign(e=e.values)

>>> df1
          a         b         c         d         e
0  1.764052  0.400157  0.978738  2.240893 -1.048553
2 -0.103219  0.410599  0.144044  1.454274 -1.420018
3  0.761038  0.121675  0.443863  0.333674 -1.706270
7  1.532779  1.469359  0.154947  0.378163  1.950775
9  1.230291  1.202380 -0.387327 -0.302303 -0.509652

මෙම නව අංගය ප්‍රථම වරට හඳුන්වා දුන් අවස්ථාවේ විස්තරය මෙහි සොයාගත හැකිය .

සුපිරි සරල තීරු පැවරුම

පැන්ඩාස් දත්ත රාමුවක් ඇණවුම් කරන ලද තීරු නියෝගයක් ලෙස ක්‍රියාත්මක වේ.

මෙයින් අදහස් කරන්නේ __getitem__ []එක්තරා තීරුවක් ලබා ගැනීම සඳහා පමණක් භාවිතා කළ නොහැකි බවයි__setitem__ [] = නව තීරුවක් පැවරීමට භාවිතා කළ හැකි බවයි.

උදාහරණයක් ලෙස, මෙම dataframe හුදෙක් භාවිතා එය එකතු තීරුවක් පුළුවන් []accessor

    size      name color
0    big      rose   red
1  small    violet  blue
2  small     tulip   red
3  small  harebell  blue

df['protected'] = ['no', 'no', 'no', 'yes']

    size      name color protected
0    big      rose   red        no
1  small    violet  blue        no
2  small     tulip   red        no
3  small  harebell  blue       yes

දත්ත රාමුවේ දර්ශකය අක්‍රිය වුවද මෙය ක්‍රියාත්මක වන බව සලකන්න.

df.index = [3,2,1,0]
df['protected'] = ['no', 'no', 'no', 'yes']
    size      name color protected
3    big      rose   red        no
2  small    violet  blue        no
1  small     tulip   red        no
0  small  harebell  blue       yes

[] = යන්නට මාර්ගයයි, නමුත් පරෙස්සම් වන්න!

කෙසේ වෙතත්, ඔබට එය තිබේ නම් pd.Seriesසහ එය සුචිගත කර ඇති දත්ත රාමුවකට පැවරීමට උත්සාහ කරන්නේ නම්, ඔබ කරදරයට පත්වනු ඇත. උදාහරණය බලන්න:

df['protected'] = pd.Series(['no', 'no', 'no', 'yes'])
    size      name color protected
3    big      rose   red       yes
2  small    violet  blue        no
1  small     tulip   red        no
0  small  harebell  blue        no

මෙයට හේතුව pd.Seriesපෙරනිමියෙන් 0 සිට n දක්වා ගණනය කළ දර්ශකයක් තිබීමයි. පැන්ඩා [] =ක්‍රමය "බුද්ධිමත්" වීමට උත්සාහ කරයි

ඇත්ත වශයෙන්ම සිදුවන්නේ කුමක්ද.

ඔබ භාවිතා කරන විට [] = ක්‍රමය පැන්ඩා නිහ ly ව වම් අත දත්ත රාමුවේ දර්ශකය සහ දකුණු අත ශ්‍රේණියේ දර්ශකය භාවිතා කරමින් බාහිර සම්බන්ධතාවයක් හෝ පිටත ඒකාබද්ධ කිරීමක් සිදු කරයි.df['column'] = series

පැති සටහන

මෙය ඉක්මණින් සංජානන විසංවාදයට හේතු වේ, මන්දයත් []=ක්‍රමය මඟින් ආදානය මත පදනම්ව විවිධ දේ කිරීමට උත්සාහ කරන අතර පැන්ඩා ක්‍රියා කරන ආකාරය ඔබ දන්නේ නැත්නම් ප්‍රති come ලය අනාවැකි කිව නොහැක . එබැවින් []=කේත පදනම් වලට එරෙහිව මම උපදෙස් දෙමි , නමුත් සටහන් පොතක දත්ත ගවේෂණය කිරීමේදී එය හොඳයි.

ගැටලුව වටා ගමන් කිරීම

ඔබට pd.Seriesඉහළ සිට පහළට පැවරීමට අවශ්‍ය නම්, හෝ ඔබ code ලදායී කේතයක් කේතනය කරන්නේ නම් සහ දර්ශක අනුපිළිවෙල ගැන ඔබට විශ්වාස නැත්නම්, මේ ආකාරයේ ගැටළුවක් සඳහා එය ආරක්ෂා කිරීම වටී.

ඔබට pd.Seriesa np.ndarrayහෝ a දක්වා පහත හෙලීමට හැකිය list, මෙය උපක්‍රමය කරයි.

df['protected'] = pd.Series(['no', 'no', 'no', 'yes']).values

හෝ

df['protected'] = list(pd.Series(['no', 'no', 'no', 'yes']))

නමුත් මෙය එතරම් පැහැදිලි නැත.

සමහර කෝඩරය පැමිණ "හේයි, මෙය අතිරික්තයක් ලෙස පෙනේ, මම මෙය දුරස් කරමි".

පැහැදිලි මාර්ගය

පිළිබඳ දර්ශකය සකස් කිරීම pd.Seriesපිළිබඳ දර්ශකය විය dfපැහැදිලි වේ.

df['protected'] = pd.Series(['no', 'no', 'no', 'yes'], index=df.index)

හෝ වඩාත් යථාර්ථවාදීව, ඔබට pd.Seriesදැනටමත් ලබා ගත හැකිය.

protected_series = pd.Series(['no', 'no', 'no', 'yes'])
protected_series.index = df.index

3     no
2     no
1     no
0    yes

දැන් පැවරිය හැකිය

df['protected'] = protected_series

    size      name color protected
3    big      rose   red        no
2  small    violet  blue        no
1  small     tulip   red        no
0  small  harebell  blue       yes

සමඟ විකල්ප මාර්ගය df.reset_index()

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

df.reset_index(drop=True)
protected_series.reset_index(drop=True)
df['protected'] = protected_series

    size      name color protected
0    big      rose   red        no
1  small    violet  blue        no
2  small     tulip   red        no
3  small  harebell  blue       yes

සටහන df.assign

df.assignඔබ කරන්නේ කුමක්ද යන්න වඩාත් පැහැදිලිව ප්‍රකාශ කරන අතරම , ඇත්ත වශයෙන්ම එයට ඉහත සඳහන් කළ ගැටලු සියල්ලම ඇත[]=

df.assign(protected=pd.Series(['no', 'no', 'no', 'yes']))
    size      name color protected
3    big      rose   red       yes
2  small    violet  blue        no
1  small     tulip   red        no
0  small  harebell  blue        no

df.assignඔබේ තීරුව නොකියන ලෙස බලා සිටින්න self. එය දෝෂ ඇති කරයි. ශ්‍රිතයේ මේ ආකාරයේ කෞතුක වස්තු ඇති බැවින් මෙය df.assign සුවඳින් යුක්ත වේ.

df.assign(self=pd.Series(['no', 'no', 'no', 'yes'])
TypeError: assign() got multiple values for keyword argument 'self'

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

මෑත පැන්ඩා සංස්කරණ වලදී යා යුතු මාර්ගය df.assign භාවිතා කරන බව පෙනේ :

df1 = df1.assign(e=np.random.randn(sLength))

එය නිපදවන්නේ නැත SettingWithCopyWarning.

NumPy හරහා කෙලින්ම මෙය කිරීම වඩාත් කාර්යක්ෂම වනු ඇත:

df1['e'] = np.random.randn(sLength)

මගේ මුල් (ඉතා පැරණි) යෝජනාව භාවිතා කිරීම map(එය වඩා මන්දගාමී) බව සලකන්න :

df1['e'] = df1['a'].map(lambda x: np.random.random())

පහසුම ක්‍රම: -

data['new_col'] = list_of_values

data.loc[ : , 'new_col'] = list_of_values

පැන්ඩා වස්තුවක නව අගයන් සැකසීමේදී දම්වැල් සුචිගත කිරීම යනුවෙන් හැඳින්වෙන දේ ඔබ මග හැරේ. වැඩිදුර කියවීමට මෙතන ක්ලික් කරන්න .

ඔබට නව තීරුව ආරම්භක මූලික අගයකට (උදා None) සැකසීමට අවශ්‍ය නම් , ඔබට මෙය කළ හැකිය:df1['e'] = None

මෙය ඇත්ත වශයෙන්ම සෛලයට "වස්තු" වර්ගය පවරයි. එබැවින් පසුව ඔබට ලැයිස්තුව වැනි සංකීර්ණ දත්ත වර්ග තනි සෛල තුළට දැමීමට නිදහස තිබේ.

මට SettingWithCopyWarningභීතියක් ඇති වූ අතර එය iloc syntax භාවිතා කිරීමෙන් සවි කර නොමැත. මගේ දත්ත රාමුව ODBC ප්‍රභවයකින් read_sql විසින් නිර්මාණය කරන ලදි. ඉහත ලෝටෙක් විසින් යෝජනාවක් භාවිතා කරමින්, පහත සඳහන් දෑ මා වෙනුවෙන් වැඩ කළේය:

df.insert(len(df.columns), 'e', pd.Series(np.random.randn(sLength),  index=df.index))

තීරුව අවසානයේ ඇතුළත් කිරීමට මෙය හොඳින් ක්‍රියා කළේය. එය වඩාත්ම කාර්යක්ෂම දැයි මම නොදනිමි, නමුත් අනතුරු ඇඟවීමේ පණිවිඩවලට මම කැමති නැත. වඩා හොඳ විසඳුමක් ඇතැයි මම සිතමි, නමුත් මට එය සොයාගත නොහැකි අතර එය දර්ශකයේ යම් අංශයක් මත රඳා පවතී.
සටහන . මෙය එක් වරක් පමණක් ක්‍රියාත්මක වන අතර නැවත ලිවීමට හා පවතින තීරුව උත්සාහ කරන්නේ නම් දෝෂ පණිවිඩයක් ලබා දෙනු ඇත.
සටහන ඉහත සහ 0.16.0 සිට පැවරීම හොඳම විසඳුමයි. ප්‍රලේඛනය බලන්න http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.assign.html#pandas.DataFrame.assign ඔබේ අතරමැදි අගයන් නැවත ලියන්නේ නැති දත්ත ප්‍රවාහ වර්ගය සඳහා හොඳින් ක්‍රියා කරයි.

1. පළමුව list_of_eඅදාළ දත්ත ඇති පයිතන් සාදන්න .
2. මෙය භාවිතා කරන්න: df['e'] = list_of_e

ඔබ එක් කිරීමට උත්සාහ කරන තීරුව ශ්‍රේණි විචල්‍යයක් නම්:

df["new_columns_name"]=series_variable_name #this will do it for you

ඔබ දැනට පවතින තීරුවක් ප්‍රතිස්ථාපනය කළත් මෙය හොඳින් ක්‍රියාත්මක වේ.ඔබට ප්‍රතිස්ථාපනය කිරීමට අවශ්‍ය තීරුවට සමානව new_columns_name ටයිප් කරන්න.එය දැනට පවතින තීරු දත්ත නව ශ්‍රේණි දත්ත සමඟ නැවත ලියයි.

දත්ත රාමුව සහ ශ්‍රේණි වස්තුව එකම දර්ශකයක් තිබේ නම් , pandas.concatමෙහි ද ක්‍රියා කරයි:

import pandas as pd
df
#          a            b           c           d
#0  0.671399     0.101208   -0.181532    0.241273
#1  0.446172    -0.243316    0.051767    1.577318
#2  0.614758     0.075793   -0.451460   -0.012493

e = pd.Series([-0.335485, -1.166658, -0.385571])    
e
#0   -0.335485
#1   -1.166658
#2   -0.385571
#dtype: float64

# here we need to give the series object a name which converts to the new  column name 
# in the result
df = pd.concat([df, e.rename("e")], axis=1)
df

#          a            b           c           d           e
#0  0.671399     0.101208   -0.181532    0.241273   -0.335485
#1  0.446172    -0.243316    0.051767    1.577318   -1.166658
#2  0.614758     0.075793   -0.451460   -0.012493   -0.385571

ඔවුන්ට එකම දර්ශකයක් නොමැති නම්:

e.index = df.index
df = pd.concat([df, e.rename("e")], axis=1)

මෝඩකම:

df.loc[:, 'NewCol'] = 'New_Val'

උදාහරණයක්:

df = pd.DataFrame(data=np.random.randn(20, 4), columns=['A', 'B', 'C', 'D'])

df

           A         B         C         D
0  -0.761269  0.477348  1.170614  0.752714
1   1.217250 -0.930860 -0.769324 -0.408642
2  -0.619679 -1.227659 -0.259135  1.700294
3  -0.147354  0.778707  0.479145  2.284143
4  -0.529529  0.000571  0.913779  1.395894
5   2.592400  0.637253  1.441096 -0.631468
6   0.757178  0.240012 -0.553820  1.177202
7  -0.986128 -1.313843  0.788589 -0.707836
8   0.606985 -2.232903 -1.358107 -2.855494
9  -0.692013  0.671866  1.179466 -1.180351
10 -1.093707 -0.530600  0.182926 -1.296494
11 -0.143273 -0.503199 -1.328728  0.610552
12 -0.923110 -1.365890 -1.366202 -1.185999
13 -2.026832  0.273593 -0.440426 -0.627423
14 -0.054503 -0.788866 -0.228088 -0.404783
15  0.955298 -1.430019  1.434071 -0.088215
16 -0.227946  0.047462  0.373573 -0.111675
17  1.627912  0.043611  1.743403 -0.012714
18  0.693458  0.144327  0.329500 -0.655045
19  0.104425  0.037412  0.450598 -0.923387


df.drop([3, 5, 8, 10, 18], inplace=True)

df

           A         B         C         D
0  -0.761269  0.477348  1.170614  0.752714
1   1.217250 -0.930860 -0.769324 -0.408642
2  -0.619679 -1.227659 -0.259135  1.700294
4  -0.529529  0.000571  0.913779  1.395894
6   0.757178  0.240012 -0.553820  1.177202
7  -0.986128 -1.313843  0.788589 -0.707836
9  -0.692013  0.671866  1.179466 -1.180351
11 -0.143273 -0.503199 -1.328728  0.610552
12 -0.923110 -1.365890 -1.366202 -1.185999
13 -2.026832  0.273593 -0.440426 -0.627423
14 -0.054503 -0.788866 -0.228088 -0.404783
15  0.955298 -1.430019  1.434071 -0.088215
16 -0.227946  0.047462  0.373573 -0.111675
17  1.627912  0.043611  1.743403 -0.012714
19  0.104425  0.037412  0.450598 -0.923387

df.loc[:, 'NewCol'] = 0

df
           A         B         C         D  NewCol
0  -0.761269  0.477348  1.170614  0.752714       0
1   1.217250 -0.930860 -0.769324 -0.408642       0
2  -0.619679 -1.227659 -0.259135  1.700294       0
4  -0.529529  0.000571  0.913779  1.395894       0
6   0.757178  0.240012 -0.553820  1.177202       0
7  -0.986128 -1.313843  0.788589 -0.707836       0
9  -0.692013  0.671866  1.179466 -1.180351       0
11 -0.143273 -0.503199 -1.328728  0.610552       0
12 -0.923110 -1.365890 -1.366202 -1.185999       0
13 -2.026832  0.273593 -0.440426 -0.627423       0
14 -0.054503 -0.788866 -0.228088 -0.404783       0
15  0.955298 -1.430019  1.434071 -0.088215       0
16 -0.227946  0.047462  0.373573 -0.111675       0
17  1.627912  0.043611  1.743403 -0.012714       0
19  0.104425  0.037412  0.450598 -0.923387       0

හිස් තීරුවක් සෑදීමට

df['i'] = None

හම් 3 සඳහා මෙන් , .locඑය විසඳීමට SettingWithCopyWarningමට නොහැකි වූ අතර මට එය යොමු කිරීමට සිදුවිය df.insert(). මගේ නඩුවේ ව්‍යාජ ධනාත්මකව ජනනය කර ඇත්තේ "ව්‍යාජ" දාම සුචිගත කිරීමෙනි , නව තීරුව dict['a']['e']කොහේද 'e', සහdict['a'] ශබ්ද කෝෂයෙන් එන දත්ත රාමුවකි.

ඔබ කරන්නේ කුමක්දැයි ඔබ දන්නේ නම්, ඔබට pd.options.mode.chained_assignment = None මෙහි දී ඇති වෙනත් විසඳුම්වලින් එකක් භාවිතා කිරීමට වඩා අනතුරු ඇඟවීම මාරු කළ හැකිය .

දත්ත රාමුවක දී යම් ස්ථානයක (0 <= loc <= තීරු ප්‍රමාණය) නව තීරුවක් ඇතුළත් කිරීමට, Dataframe.insert භාවිතා කරන්න:

DataFrame.insert(loc, column, value)

එබැවින්, df නම් දත්ත රාමුවක අවසානයේ e තීරුව එක් කිරීමට ඔබට අවශ්‍ය නම් , ඔබට මෙය භාවිතා කළ හැකිය:

e = [-0.335485, -1.166658, -0.385571]    
DataFrame.insert(loc=len(df.columns), column='e', value=e)

අගය ශ්‍රේණියක්, පූර්ණ සංඛ්‍යාවක් (සියලු සෛල මෙම එක් අගයකින් පුරවනු ලැබේ) හෝ අරාව වැනි ව්‍යුහයක් විය හැකිය

https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.insert.html

නව තීරුවක් පැවරීමට පෙර, ඔබ සුචිගත කළ දත්ත තිබේ නම්, ඔබට දර්ශකය වර්ග කළ යුතුය. අවම වශයෙන් මගේ නඩුවේදී මට සිදු වූයේ:

data.set_index(['index_column'], inplace=True)
"if index is unsorted, assignment of a new column will fail"        
data.sort_index(inplace = True)
data.loc['index_value1', 'column_y'] = np.random.randn(data.loc['index_value1', 'column_x'].shape[0])

සැලකිල්ලට ගත යුතු එක් දෙයක් නම්, ඔබ එසේ කරන්නේ නම්

df1['e'] = Series(np.random.randn(sLength), index=df1.index)

මෙය df1.index හි වම් සම්බන්ධතාවයක් වනු ඇත. එබැවින් ඔබට බාහිර සම්බන්ධ වීමේ බලපෑමක් ඇති කිරීමට අවශ්‍ය නම් , මගේ අසම්පූර්ණ විසඳුම වන්නේ ඔබේ දත්තවල විශ්වය ආවරණය වන පරිදි දර්ශක අගයන් සහිත දත්ත රාමුවක් නිර්මාණය කර ඉහත කේතය භාවිතා කිරීමයි. උදාහරණයක් වශයෙන්,

data = pd.DataFrame(index=all_possible_values)
df1['e'] = Series(np.random.randn(sLength), index=df1.index)

මම numpy.nanගොළු නොවී දත්ත රාමුවකට s තීරුවක් එකතු කිරීමේ සාමාන්‍ය ක්‍රමයක් සොයමින් සිටියෙමි SettingWithCopyWarning.

පහත සඳහන් දෑ වලින්:

• මෙහි පිළිතුරු
• යතුරුපදයක් ලෙස විචල්‍යයක් සම්මත කිරීම පිළිබඳ මෙම ප්‍රශ්නය
• numpyNaNs පේළියක් ජනනය කිරීම සඳහා මෙම ක්‍රමය

මම මෙය ඉදිරිපත් කළෙමි:

col = 'column_name'
df = df.assign(**{col:numpy.full(len(df), numpy.nan)})

පවතින දත්ත රාමුවට 'ඊ' නව තීරුවක් එක් කිරීමට

 df1.loc[:,'e'] = Series(np.random.randn(sLength))

සම්පූර්ණත්වය සඳහා - DataFrame.eval () ක්‍රමය භාවිතා කරන තවත් විසඳුමක් :

දත්ත:

In [44]: e
Out[44]:
0    1.225506
1   -1.033944
2   -0.498953
3   -0.373332
4    0.615030
5   -0.622436
dtype: float64

In [45]: df1
Out[45]:
          a         b         c         d
0 -0.634222 -0.103264  0.745069  0.801288
4  0.782387 -0.090279  0.757662 -0.602408
5 -0.117456  2.124496  1.057301  0.765466
7  0.767532  0.104304 -0.586850  1.051297
8 -0.103272  0.958334  1.163092  1.182315
9 -0.616254  0.296678 -0.112027  0.679112

විසඳුමක්:

In [46]: df1.eval("e = @e.values", inplace=True)

In [47]: df1
Out[47]:
          a         b         c         d         e
0 -0.634222 -0.103264  0.745069  0.801288  1.225506
4  0.782387 -0.090279  0.757662 -0.602408 -1.033944
5 -0.117456  2.124496  1.057301  0.765466 -0.498953
7  0.767532  0.104304 -0.586850  1.051297 -0.373332
8 -0.103272  0.958334  1.163092  1.182315  0.615030
9 -0.616254  0.296678 -0.112027  0.679112 -0.622436

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

df = pd.DataFrame([[1, 2], [3, 4], [5,6]], columns=list('AB'))

newCol = [3,5,7]
newName = 'C'

values = np.insert(df.values,df.shape[1],newCol,axis=1)
header = df.columns.values.tolist()
header.append(newName)

df = pd.DataFrame(values,columns=header)

ඔබට එය ලැබුනේ නම් SettingWithCopyWarning, පහසු විසඳුමක් නම් ඔබ තීරුවක් එක් කිරීමට උත්සාහ කරන දත්ත රාමුව පිටපත් කිරීමයි.

df = df.copy()
df['col_name'] = values

මෙය පැන්ඩාස් දත්ත රාමුවකට නව තීරුවක් එක් කිරීමේ විශේෂ අවස්ථාවකි. මෙන්න, මම දත්ත රාමුවේ පවතින තීරු දත්ත මත පදනම්ව නව අංගයක් / තීරුවක් එක් කරමි.

එබැවින්, අපගේ දත්ත රාමුවට 'විශේෂාංග_1', 'විශේෂාංග_2', 'සම්භාවිතා_කෝර්' යන තීරු තිබිය යුතු අතර 'සම්භාවිතාව_කෝර්' තීරුවේ දත්ත මත පදනම්ව අපට නව_ තීරුවක් 'පුරෝකථනය කළ_ පන්තියක්' එක් කළ යුතුය.

මම පයිතන් වෙතින් සිතියම් () ශ්‍රිතය භාවිතා කරන අතර මගේ දත්ත ශ්‍රිතයේ සෑම පේළියකටම විශේෂිත පංති ලේබලයක් ලබා දෙන්නේ කෙසේද යන්න පිළිබඳ තර්කනය ක්‍රියාත්මක කරන මගේම ශ්‍රිතයක් අර්ථ දක්වනු ඇත.

data = pd.read_csv('data.csv')

def myFunction(x):
   //implement your logic here

   if so and so:
        return a
   return b

variable_1 = data['probability_score']
predicted_class = variable_1.map(myFunction)

data['predicted_class'] = predicted_class

// check dataFrame, new column is included based on an existing column data for each row
data.head()