මට විවිධ තීරුවල දත්ත ඇත, නමුත් එය වෙනත් විචල්‍යයක සුරැකීමට එය උපුටා ගන්නේ කෙසේදැයි මම නොදනිමි.

index  a   b   c
1      2   3   4
2      3   4   5

මම කොහොමද තෝරා නැහැ 'a', 'b'සහ df1 කිරීමට එය බේරා?

මම උත්සාහ කළා

df1 = df['a':'b']
df1 = df.ix[:, 'a':'b']

කිසිවක් වැඩ කරන බවක් නොපෙනේ.

ඔබ උත්සාහ කළ ආකාරයට තීරු නම් (නූල්) කපා ගත නොහැක.

මෙන්න ඔබට විකල්ප කිහිපයක් තිබේ. ඔබට කුමන විචල්‍යයන් කපා දැමිය යුතුදැයි සන්දර්භයෙන් ඔබ දන්නේ නම්, ඔබට __getitem__සින්ටැක්ස් ([]) වෙත ලැයිස්තුවක් යැවීමෙන් ඔබට එම තීරු පිළිබඳ දර්ශනයක් ලබා දිය හැකිය .

df1 = df[['a', 'b']]

විකල්පයක් ලෙස, ඒවා සංඛ්‍යාත්මකව සුචිගත කිරීම වැදගත් නම් සහ ඒවායේ නමෙන් නොවේ නම් (ඔබේ කේතය පළමු තීරු දෙකේ නම් නොදැන ස්වයංක්‍රීයව මෙය කළ යුතු යැයි පවසන්න) එවිට ඔබට මෙය කළ හැකිය:

df1 = df.iloc[:, 0:2] # Remember that Python does not slice inclusive of the ending index.

ඊට අමතරව, පණ්ඩස් වස්තුවකට එදිරිව එදිරිව එම වස්තුවේ පිටපතක් නැරඹීමේ අදහස ඔබ හුරු කර ගත යුතුය. ඉහත ක්‍රම වලින් පළමුවැන්න අපේක්ෂිත උප වස්තුව (අපේක්ෂිත පෙති) මතකයේ නව පිටපතක් ලබා දෙනු ඇත.

කෙසේ වෙතත්, සමහර විට, මෙය සිදු නොකරන පැන්ඩස්හි සුචිගත කිරීමේ සම්මුතීන් ඇති අතර ඒ වෙනුවට ඔබට නව විචල්‍යයක් ලබා දෙන අතර එය මුල් වස්තුවේ උප වස්තුව හෝ පෙත්ත ලෙස එකම මතක කොටසකට යොමු කරයි. සුචිගත කිරීමේ දෙවන ක්‍රමය සමඟ මෙය සිදුවනු ඇත, එබැවින් ඔබට copy()සාමාන්‍ය පිටපතක් ලබා ගැනීම සඳහා එය ශ්‍රිතය සමඟ වෙනස් කළ හැකිය . මෙය සිදු වූ විට, පෙති කපන ලද වස්තුව යැයි ඔබ සිතන දේ වෙනස් කිරීම සමහර විට මුල් වස්තුව වෙනස් කළ හැකිය. මේ පිළිබඳව විමසිල්ලෙන් සිටීම සැමවිටම හොඳයි.

df1 = df.iloc[0, 0:2].copy() # To avoid the case where changing df1 also changes df

භාවිතා කිරීමට iloc, ඔබ තීරු ස්ථාන (හෝ දර්ශක) දැන සිටිය යුතුය. තීරු ස්ථාන වෙනස් විය හැකි බැවින්, දෘඩ කේතීකරණ දර්ශක වෙනුවට, තීරු දර්ශක ලබා ගැනීම සඳහා දත්ත රාමු වස්තුවක ක්‍රමයේ ක්‍රියාකාරිත්වය ilocසමඟ ඔබට භාවිතා කළ හැකිය .get_loccolumns

{df.columns.get_loc(c): c for idx, c in enumerate(df.columns)}

දැන් ඔබට මෙම ශබ්ද කෝෂය භාවිතා කර නම් සහ තීරු හරහා තීරු වෙත පිවිසිය හැකිය iloc.

0.11.0 අනුවාදය අනුව, ඔබ දර්ශකය භාවිතා කිරීමට උත්සාහ කළ ආකාරයට තීරු කපා ගත හැකිය.loc :

df.loc[:, 'C':'E']

සමාන වේ

df[['C', 'D', 'E']]  # or df.loc[:, ['C', 'D', 'E']]

සහ තීරු Cහරහා ආපසු එයි E.

අහඹු ලෙස ජනනය කරන ලද දත්ත රාමුවක නිරූපණයක්:

import pandas as pd
import numpy as np
np.random.seed(5)
df = pd.DataFrame(np.random.randint(100, size=(100, 6)), 
                  columns=list('ABCDEF'), 
                  index=['R{}'.format(i) for i in range(100)])
df.head()

Out: 
     A   B   C   D   E   F
R0  99  78  61  16  73   8
R1  62  27  30  80   7  76
R2  15  53  80  27  44  77
R3  75  65  47  30  84  86
R4  18   9  41  62   1  82

C සිට E දක්වා තීරු ලබා ගැනීම සඳහා (පූර්ණ සංඛ්‍යා පෙති මෙන් නොව, 'E' තීරුවල ඇතුළත් කර ඇති බව සලකන්න):

df.loc[:, 'C':'E']

Out: 
      C   D   E
R0   61  16  73
R1   30  80   7
R2   80  27  44
R3   47  30  84
R4   41  62   1
R5    5  58   0
...

ලේබල මත පදනම්ව පේළි තේරීම සඳහා එකම ක්‍රියා කරයි. එම තීරුවලින් 'R6' සිට 'R10' දක්වා පේළි ලබා ගන්න:

df.loc['R6':'R10', 'C':'E']

Out: 
      C   D   E
R6   51  27  31
R7   83  19  18
R8   11  67  65
R9   78  27  29
R10   7  16  94

.locබූලියන් අරාව ද පිළිගන්නා අතර එමඟින් අරාවෙහි අනුරූප ප්‍රවේශය ඇති තීරු තෝරා ගත හැකිය True. උදාහරණයක් ලෙස, df.columns.isin(list('BCD'))ප්‍රතිලාභ array([False, True, True, True, False, False], dtype=bool)- තීරුවේ නම ලැයිස්තුවේ තිබේ නම් ඇත්ත ['B', 'C', 'D']; අසත්ය, වෙනත් ආකාරයකින්.

df.loc[:, df.columns.isin(list('BCD'))]

Out: 
      B   C   D
R0   78  61  16
R1   27  30  80
R2   53  80  27
R3   65  47  30
R4    9  41  62
R5   78   5  58
...

ඔබගේ තීරු නම් ( df.columns) යැයි උපකල්පනය කිරීම ['index','a','b','c'], එවිට ඔබට අවශ්‍ය දත්ත 3 වන සහ 4 වන තීරුවල ඇත. ඔබගේ ස්ක්‍රිප්ට් ක්‍රියාත්මක වන විට ඔබ ඔවුන්ගේ නම් නොදන්නේ නම්, ඔබට මෙය කළ හැකිය

newdf = df[df.columns[2:4]] # Remember, Python is 0-offset! The "3rd" entry is at slot 2.

ඊඑම්එස් ඔහුගේ පිළිතුරෙන් පෙන්වා දෙන පරිදි , df.ixපෙති තීරු ටිකක් සංක්ෂිප්තව දක්වයි, නමුත් පෙති .columnsකපන අතුරු මුහුණත වඩාත් ස්වාභාවික විය හැක්කේ එය වැනිලා 1-ඩී පයිතන් ලැයිස්තු සුචිගත කිරීම / පෙති කපන සින්ටැක්ස් භාවිතා කරන බැවිනි.

අවවාදයයි: තීරුවකට 'index'නරක නමකි DataFrame. එම ලේබලය සැබෑ df.indexගුණාංගය වන Indexඅරාව සඳහා ද භාවිතා වේ. එබැවින් ඔබේ තීරුව නැවත ලබා දෙන df['index']අතර සැබෑ දත්ත රාමු දර්ශකය මඟින් ආපසු ලබා දෙනු ලැබේ df.index. An Indexයනු එහි Seriesමූලද්‍රව්‍යවල අගයන් සොයා බැලීම සඳහා විශේෂිත වූ ප්‍රශස්තිකරණයකි. Df.index සඳහා එය ඔවුන්ගේ ලේබලය අනුව පේළි බැලීම සඳහා ය. ඒවායේ ලේබල අනුව තීරු බැලීම සඳහා එම df.columnsගුණාංගය ද pd.Indexඅරාවකි.

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

columns = ['b', 'c']
df1 = pd.DataFrame(df, columns=columns)

In [39]: df
Out[39]: 
   index  a  b  c
0      1  2  3  4
1      2  3  4  5

In [40]: df1 = df[['b', 'c']]

In [41]: df1
Out[41]: 
   b  c
0  3  4
1  4  5

පැන්ඩා සමඟ,

wit තීරු නම්

dataframe[['column1','column2']]

දර්ශක අංකය සහිත iloc සහ විශේෂිත තීරු අනුව තෝරා ගැනීමට:

dataframe.iloc[:,[1,2]]

ලොක් තීරු නම් සමඟ භාවිතා කළ හැකිය

dataframe.loc[:,['column1','column2']]

අතහැර දැමිය යුතු තීරු ලැයිස්තුවක් ඔබට ලබා දිය හැකි drop()අතර පැන්ඩාස් දත්ත රාමුවක ශ්‍රිතය භාවිතා කර අවශ්‍ය තීරු පමණක් සහිතව දත්ත රාමුව ආපසු ලබා දිය හැකිය .

නිකම්ම කියනවා

colsToDrop = ['a']
df.drop(colsToDrop, axis=1)

හුදෙක් තීරු සමග DataFrame බවත් නැවත bහා c.

මෙම dropක්රමය ලේඛනගතව ඇත මෙතන .

මෙම ක්‍රමය ඉතා ප්‍රයෝජනවත් බව මට පෙනී ගියේය:

# iloc[row slicing, column slicing]
surveys_df.iloc [0:3, 1:4]

වැඩි විස්තර මෙහි සොයාගත හැකිය

0.21.0 සිට ඇරඹී, නැතිවූ ලේබල් එකක් හෝ වැඩි ගණනක් සහිත ලැයිස්තුවක් භාවිතා කිරීම .locහෝ ඊට []පක්ෂව ප්‍රතික්ෂේප කරනු .reindexලැබේ. එබැවින්, ඔබේ ප්‍රශ්නයට පිළිතුර:

df1 = df.reindex(columns=['b','c'])

පෙර සංස්කරණ වලදී, .loc[list-of-labels]අවම වශයෙන් යතුරු 1 ක් සොයාගත් තාක් කල් භාවිතා කිරීම ක්‍රියා කරයි (එසේ නොවුවහොත් එය a මතු කරයි KeyError). මෙම හැසිරීම අවලංගු කර ඇති අතර දැන් අනතුරු ඇඟවීමේ පණිවිඩයක් පෙන්වයි. නිර්දේශිත විකල්පය භාවිතා කිරීමයි .reindex().

දත්ත සුචිගත කිරීමේදී සහ තේරීමේදී වැඩිදුර කියවන්න

ඔබට පැන්ඩා භාවිතා කළ හැකිය. මම දත්ත රාමුව නිර්මාණය කරමි:

    import pandas as pd
    df = pd.DataFrame([[1, 2,5], [5,4, 5], [7,7, 8], [7,6,9]], 
                      index=['Jane', 'Peter','Alex','Ann'],
                      columns=['Test_1', 'Test_2', 'Test_3'])

දත්ත රාමුව:

           Test_1  Test_2  Test_3
    Jane        1       2       5
    Peter       5       4       5
    Alex        7       7       8
    Ann         7       6       9

නම අනුව තීරු 1 ක් හෝ වැඩි ගණනක් තෝරා ගැනීමට:

    df[['Test_1','Test_3']]

           Test_1  Test_3
    Jane        1       5
    Peter       5       5
    Alex        7       8
    Ann         7       9

ඔබට මෙයද භාවිතා කළ හැකිය:

    df.Test_2

ඔබට තීරුව ලබා ගන්න Test_2

    Jane     2
    Peter    4
    Alex     7
    Ann      6

ඔබට මෙම පේළි වලින් තීරු සහ පේළි තෝරා ගත හැකිය .loc(). මෙය "පෙති කැපීම" ලෙස හැඳින්වේ . මම තීරුවේ Test_1සිට ගෙන යන බව සැලකිල්ලට ගන්නTest_3

    df.loc[:,'Test_1':'Test_3']

"පෙත්ත" යනු:

            Test_1  Test_2  Test_3
     Jane        1       2       5
     Peter       5       4       5
     Alex        7       7       8
     Ann         7       6       9

ඔබට අවශ්‍ය නම් Peterසහ Annතීරු වලින් Test_1සහ Test_3:

    df.loc[['Peter', 'Ann'],['Test_1','Test_3']]

ඔබට ලැබෙන්නේ:

           Test_1  Test_3
    Peter       5       5
    Ann         7       9

පේළි දර්ශකය සහ තීරු නාමයෙන් ඔබට එක් අංගයක් ලබා ගැනීමට අවශ්‍ය නම්, ඔබට එය හරියට කළ හැකිය df['b'][0]. එය ඔබට රූපගත කළ හැකි තරම් සරල ය.

නැතහොත් ඔබට df.ix[0,'b']දර්ශකයේ සහ ලේබලයේ මිශ්‍ර භාවිතය භාවිතා කළ හැකිය .

සටහන: v0.20 / ixට පක්ෂව ඉවත් කර ඇති බැවින් .lociloc

pandas.DataFrame.filterමෙවැනි තීරු පෙරීමට හෝ නැවත සකස් කිරීමට ඔබට ක්‍රමයක් භාවිතා කළ හැකිය :

df1 = df.filter(['a', 'b'])

ඔබ දම්වැල් දැමීමේ ක්‍රම වලදී මෙයද ඉතා ප්‍රයෝජනවත් වේ.

එක් වෙනස් හා පහසු ප්‍රවේශයක්: පේළි නැවත සැකසීම

iterows භාවිතා කිරීම

 df1= pd.DataFrame() #creating an empty dataframe
 for index,i in df.iterrows():
    df1.loc[index,'A']=df.loc[index,'A']
    df1.loc[index,'B']=df.loc[index,'B']
    df1.head()

ඉහත ප්‍රතිචාර වල සාකච්ඡා කර ඇති වෙනස් ප්‍රවේශයන් පදනම් වී ඇත්තේ එක්කෝ පරිශීලකයා තීරු දර්ශක අතහැර දැමීමට හෝ උප කුලකයට දන්නා බව උපකල්පනය කිරීම හෝ තීරු පරාසයක් භාවිතා කරමින් දත්ත රාමුවක් උපසිරැසි කිරීමට පරිශීලකයා කැමති වේ (උදාහරණයක් ලෙස 'සී': 'ඊ' අතර) . pandas.DataFrame.drop () නිසැකවම පරිශීලකයා විසින් අර්ථ දක්වා ඇති තීරු ලැයිස්තුවක් මත පදනම්ව දත්ත උපසිරැසි ගැන්වීමේ විකල්පයකි ( ඔබ සැමවිටම දත්ත රාමුවේ පිටපතක් භාවිතා කරන බවට සැලකිලිමත් විය යුතු අතර ස්ථාන පරාමිතීන් සත්‍ය ලෙස සැකසිය යුතු නැත !!)

තවත් විකල්පයක් වන්නේ pandas.columns.difference () භාවිතා කිරීමයි , එය තීරු නම් වල නිශ්චිත වෙනසක් සිදු කරයි, සහ අපේක්ෂිත තීරු අඩංගු දර්ශක වර්ගයක් ලබා දෙයි. විසඳුම පහත දැක්වේ:

df = pd.DataFrame([[2,3,4],[3,4,5]],columns=['a','b','c'],index=[1,2])
columns_for_differencing = ['a']
df1 = df.copy()[df.columns.difference(columns_for_differencing)]
print(df1)

ප්‍රතිදානය වනුයේ: b c 1 3 4 2 4 5

ඔබට df.pop () ද භාවිතා කළ හැකිය

>>> df = pd.DataFrame([('falcon', 'bird',    389.0),
...                    ('parrot', 'bird',     24.0),
...                    ('lion',   'mammal',   80.5),
...                    ('monkey', 'mammal', np.nan)],
...                   columns=('name', 'class', 'max_speed'))
>>> df
     name   class  max_speed
0  falcon    bird      389.0
1  parrot    bird       24.0
2    lion  mammal       80.5
3  monkey  mammal 

>>> df.pop('class')
0      bird
1      bird
2    mammal
3    mammal
Name: class, dtype: object

>>> df
     name  max_speed
0  falcon      389.0
1  parrot       24.0
2    lion       80.5
3  monkey        NaN

මෙය ඔබට ප්‍රයෝජනවත් දැයි මට දන්වන්න, කරුණාකර df.pop (c) භාවිතා කරන්න

මම එයට පිළිතුරු කිහිපයක් දැක ඇත්තෙමි, නමුත් එය මට පැහැදිලි නැත. ඔබ එම උනන්දුව දක්වන තීරු තෝරා ගන්නේ කෙසේද? එයට පිළිතුර නම්, ඔබ ඒවා ලැයිස්තුවකට එකතු කර ඇත්නම්, ඔබට ලැයිස්තුව භාවිතා කරමින් තීරු සඳහන් කළ හැකිය.

උදාහරණයක්

print(extracted_features.shape)
print(extracted_features)

(63,)
['f000004' 'f000005' 'f000006' 'f000014' 'f000039' 'f000040' 'f000043'
 'f000047' 'f000048' 'f000049' 'f000050' 'f000051' 'f000052' 'f000053'
 'f000054' 'f000055' 'f000056' 'f000057' 'f000058' 'f000059' 'f000060'
 'f000061' 'f000062' 'f000063' 'f000064' 'f000065' 'f000066' 'f000067'
 'f000068' 'f000069' 'f000070' 'f000071' 'f000072' 'f000073' 'f000074'
 'f000075' 'f000076' 'f000077' 'f000078' 'f000079' 'f000080' 'f000081'
 'f000082' 'f000083' 'f000084' 'f000085' 'f000086' 'f000087' 'f000088'
 'f000089' 'f000090' 'f000091' 'f000092' 'f000093' 'f000094' 'f000095'
 'f000096' 'f000097' 'f000098' 'f000099' 'f000100' 'f000101' 'f000103']

extracted_featuresතීරු 63 ක් සඳහන් කරමින් මට පහත ලැයිස්තුව / අංක අරා ඇත. මුල් දත්ත කට්ටලයේ තීරු 103 ක් ඇති අතර, මම ඒවා හරියටම උපුටා ගැනීමට කැමතියි, එවිට මම භාවිතා කරමි

dataset[extracted_features]

ඔබ මේ සමඟ අවසන් වනු ඇත

යන්ත්‍ර ඉගෙනීමේදී ඔබ මෙය බොහෝ විට භාවිතා කරනු ඇත (වඩාත් නිශ්චිතවම, විශේෂාංග තේරීමේදී). මම වෙනත් ක්‍රම ගැනද සාකච්ඡා කිරීමට කැමැත්තෙමි, නමුත් මම හිතන්නේ එය දැනටමත් වෙනත් ස්ටක් ඕවර් මල් වලින් ආවරණය වී ඇත. මෙය ප්‍රයෝජනවත් වී ඇතැයි සිතමි!

භාවිතා කිරීමට උත්සාහ කරන්න pandas.DataFrame.get( ලියකියවිලි බලන්න ):

import pandas as pd
import numpy as np
dates = pd.date_range('20200102', periods=6)
df = pd.DataFrame(np.random.randn(6, 4), index=dates, columns=list('ABCD'))
df.get(['A','C'])

df[['a','b']] # select all rows of 'a' and 'b'column 
df.loc[0:10, ['a','b']] # index 0 to 10 select column 'a' and 'b'
df.loc[0:10, ['a':'b']] # index 0 to 10 select column 'a' to 'b'
df.iloc[0:10, 3:5] # index 0 to 10 and column 3 to 5
df.iloc[3, 3:5] # index 3 of column 3 to 5