පැන්ඩාස් ඩේටා ෆ්‍රේම් වෙතින් තීරු ශීර්ෂ ලැයිස්තුවක් ලබා ගැනීමට මට අවශ්‍යය. දත්ත රාමුව පැමිණෙන්නේ පරිශීලක ආදානයෙනි, එබැවින් තීරු කීයක් තිබේද යන්න හෝ ඒවා හඳුන්වන්නේ කුමක් දැයි මම නොදනිමි.

උදාහරණයක් ලෙස, මට මේ ආකාරයට දත්ත රාමුවක් ලබා දෙන්නේ නම්:

>>> my_dataframe
    y  gdp  cap
0   1    2    5
1   2    3    9
2   8    7    2
3   3    4    7
4   6    7    7
5   4    8    3
6   8    2    8
7   9    9   10
8   6    6    4
9  10   10    7

මට මේ වගේ ලැයිස්තුවක් ලබා ගැනීමට අවශ්‍යයි:

>>> header_list
['y', 'gdp', 'cap']

කිරීමෙන් ඔබට ලැයිස්තුවක් ලෙස අගයන් ලබා ගත හැකිය:

list(my_dataframe.columns.values)

ඔබට සරලව භාවිතා කළ හැකිය: ( එඩ් චුම්ගේ පිළිතුරෙහි පෙන්වා ඇති පරිදි ):

list(my_dataframe)

වඩාත්ම ක්‍රියාකාරී වන බිල්ට් ඉන් ක්‍රමයක් ඇත:

my_dataframe.columns.values.tolist()

.columnsදර්ශකයක් .columns.valuesනැවත ලබා දෙයි, අරාවක් .tolistලබා දෙන අතර ලැයිස්තුවක් ආපසු ලබා දීමට මෙය උපකාරක ශ්‍රිතයක් ඇත.

කාර්ය සාධනය ඔබට එතරම් වැදගත් නොවේ නම්, Indexවස්තූන් .tolist()ඔබට කෙලින්ම ඇමතිය හැකි ක්‍රමයක් නිර්වචනය කරයි :

my_dataframe.columns.tolist()

කාර්ය සාධනයේ වෙනස පැහැදිලිය:

%timeit df.columns.tolist()
16.7 µs ± 317 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

%timeit df.columns.values.tolist()
1.24 µs ± 12.3 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

ටයිප් වෛර කරන අය සඳහා, ඔබ ඇමතිය හැකි listමත df, වන පරිදි:

list(df)

සමහර ඉක්මන් පරීක්ෂණ සිදු කර ඇති අතර සමහර විට පුදුමයට කරුණක් නම් බිල්ට් අනුවාදය භාවිතා dataframe.columns.values.tolist()කිරීම වේගවත්ම වේ:

In [1]: %timeit [column for column in df]
1000 loops, best of 3: 81.6 µs per loop

In [2]: %timeit df.columns.values.tolist()
10000 loops, best of 3: 16.1 µs per loop

In [3]: %timeit list(df)
10000 loops, best of 3: 44.9 µs per loop

In [4]: % timeit list(df.columns.values)
10000 loops, best of 3: 38.4 µs per loop

(මම තවමත් ඇත්තෙන්ම කැමතියි list(dataframe), එබැවින් ස්තූතියි එඩ්චම්!)

එය ඊටත් වඩා සරල වේ (පැන්ඩා 0.16.0 අනුව):

df.columns.tolist()

ඔබට හොඳ ලැයිස්තුවක තීරු නම් ලබා දෙනු ඇත.

>>> list(my_dataframe)
['y', 'gdp', 'cap']

නිදොස් කිරීමේ මාදිලියේ සිටියදී දත්ත රාමුවක තීරු ලැයිස්තුගත කිරීම සඳහා, ලැයිස්තු අවබෝධයක් භාවිතා කරන්න:

>>> [c for c in my_dataframe]
['y', 'gdp', 'cap']

මාර්ගය වන විට, ඔබට සරලව භාවිතා කිරීමෙන් වර්ග කළ ලැයිස්තුවක් ලබා ගත හැකිය sorted:

>>> sorted(my_dataframe)
['cap', 'gdp', 'y']

පුදුමයට කරුණක් නම් මෙය මෙතෙක් පළ කර ඇති ආකාරය මා දැක නැත, එබැවින් මම මෙය මෙහි තබමි.

විස්තාරණය කළ නොහැකි ඉවත් කිරීම (python3.5 +): [*df]සහ මිතුරන්

පයිතන් 3.5 සමඟ මුදා හැරීමේ සාමාන්‍යකරණයන් (PEP 448) හඳුන්වා දී ඇත. එබැවින්, පහත සඳහන් මෙහෙයුම් සියල්ලම කළ හැකිය.

df = pd.DataFrame('x', columns=['A', 'B', 'C'], index=range(5))
df

   A  B  C
0  x  x  x
1  x  x  x
2  x  x  x
3  x  x  x
4  x  x  x 

ඔබට අවශ්‍ය නම් list....

[*df]
# ['A', 'B', 'C']

නැතහොත්, ඔබට අවශ්‍ය නම් set,

{*df}
# {'A', 'B', 'C'}

නැතහොත්, ඔබට අවශ්‍ය නම් tuple,

*df,  # Please note the trailing comma
# ('A', 'B', 'C')

නැතහොත්, ඔබට ප්‍රති result ලය කොහේ හෝ ගබඩා කිරීමට අවශ්‍ය නම්,

*cols, = df  # A wild comma appears, again
cols
# ['A', 'B', 'C']

... ඔබ කෝපි යතුරු ලියන ශබ්ද බවට පරිවර්තනය කරන ආකාරයේ පුද්ගලයෙක් නම්, මෙය ඔබේ කෝපි වඩාත් කාර්යක්ෂමව පරිභෝජනය කරයි;)

PS: කාර්ය සාධනය වැදගත් නම්, ඔබට ඉහත විසඳුම් වාසිදායක ලෙස බැහැර කිරීමට අවශ්‍ය වනු ඇත

df.columns.to_numpy().tolist()
# ['A', 'B', 'C']

මෙය එඩ් චුම්ගේ පිළිතුරට සමානය, නමුත් v0.24 සඳහා යාවත්කාලීන කර ඇති අතර එහිදී .to_numpy()භාවිතයට වඩාත් සුදුසු වේ .values. වැඩි විස්තර සඳහා මෙම පිළිතුර (මා විසින්) බලන්න .

දෘශ්‍ය පරීක්‍ෂණය
මෙය වෙනත් පිළිතුරු වල සාකච්ඡා කර ඇති බව මා දැක ඇති බැවින්, ඔබට නැවත භාවිතයට ගත නොහැකි ඇසුරුම් භාවිතා කළ හැකිය (පැහැදිලි ලූප අවශ්‍ය නොවේ).

print(*df)
A B C

print(*df, sep='\n')
A
B
C

වෙනත් ක්‍රම විවේචනය කිරීම

forතනි පේළියකින් කළ හැකි මෙහෙයුමක් සඳහා පැහැදිලි පුඩුවක් භාවිතා නොකරන්න (ලැයිස්තු අවබෝධය හරි).

ඊළඟට, භාවිතා sorted(df) කිරීම තීරුවල මුල් අනුපිළිවෙල ආරක්ෂා නොකරයි . ඒ සඳහා ඔබ list(df)ඒ වෙනුවට භාවිතා කළ යුතුය .

ඊළඟට, list(df.columns)සහ list(df.columns.values)දුර්වල යෝජනා වේ (වර්තමාන අනුවාදය අනුව, v0.24). Index(ආපසු පැමිණියේ df.columns) සහ NumPy අරා දෙකම (ආපසු එවනු ලැබුවේ df.columns.values) .tolist()ක්‍රමය අර්ථ දක්වන්නේ වේගවත් හා වඩා මුග්ධ ලෙසිනි.

අවසාන වශයෙන්, ලැයිස්තුගත කිරීම එනම්, list(df)පයිතන් <= 3.4 සඳහා ඉහත සඳහන් කළ ක්‍රමවේදයන්ට සංක්ෂිප්ත විකල්පයක් ලෙස පමණක් භාවිතා කළ යුතුය.

එය ලබා ගත හැකිය my_dataframe.columns.

ඩේටා ෆ්‍රේම් එකක් අනුගමනය කරන්නේ වස්තූන්ගේ “යතුරු” හරහා පුනරාවර්තනය කිරීමේ ආ ict ාවයි .

my_dataframe.keys()

යතුරු / තීරු ලැයිස්තුවක් සාදන්න - වස්තු ක්‍රමය to_list()සහ පයිතොනික් ක්‍රමය

my_dataframe.keys().to_list()
list(my_dataframe.keys())

ඩේටා ෆ්‍රේම් හි මූලික ක්‍රියාකාරීත්වය තීරු ලේබල ලබා දෙයි

[column for column in my_dataframe]

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

xlarge = pd.DataFrame(np.arange(100000000).reshape(10000,10000))
list(xlarge) #compute time and memory consumption depend on dataframe size - O(N)
list(xlarge.keys()) #constant time operation - O(1)

එය සිත්ගන්නාසුළු නමුත් df.columns.values.tolist()3 ගුණයකින් වේගවත් df.columns.tolist()නමුත් මම සිතුවේ ඒවා එක හා සමාන බවයි:

In [97]: %timeit df.columns.values.tolist()
100000 loops, best of 3: 2.97 µs per loop

In [98]: %timeit df.columns.tolist()
10000 loops, best of 3: 9.67 µs per loop

සටහන් පොතේ

IPython නෝට්බුක්හි දත්ත ගවේෂණය සඳහා, මගේ ප්‍රියතම ක්‍රමය මෙයයි:

sorted(df)

එමඟින් අකාරාදී පිළිවෙලට ඇණවුම් කළ ලැයිස්තුවක් පහසුවෙන් කියවිය හැකිය.

කේත ගබඩාවක

කේතයෙන් මට එය වඩාත් පැහැදිලිව පෙනේ

df.columns

මන්ද එය ඔබගේ කේතය කියවන අනෙක් අයට ඔබ කරන දේ පවසන බැවිනි.

%%timeit
final_df.columns.values.tolist()
948 ns ± 19.2 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

%%timeit
list(final_df.columns)
14.2 µs ± 79.1 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

%%timeit
list(final_df.columns.values)
1.88 µs ± 11.7 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

%%timeit
final_df.columns.tolist()
12.3 µs ± 27.4 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

%%timeit
list(final_df.head(1).columns)
163 µs ± 20.6 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

සිමියොන් වීසර් පිළිතුරු දුන් පරිදි ... ඔබට කළ හැකිය

list(my_dataframe.columns.values) 

හෝ

list(my_dataframe) # for less typing.

නමුත් මම හිතන්නේ බොහෝ මිහිරි ස්ථානය මෙයයි:

list(my_dataframe.columns)

එය පැහැදිලිය, ඒ සමඟම අනවශ්‍ය ලෙස දිගු නොවේ.

ඉක්මන්, පිළිවෙලට, දෘශ්‍ය පරීක්‍ෂණයක් සඳහා මෙය උත්සාහ කරන්න:

for col in df.columns:
    print col

මෙය අපට ලැයිස්තුවක ඇති තීරු නම් ලබා දෙයි:

list(my_dataframe.columns)

Tolist () නමින් තවත් ශ්‍රිතයක් භාවිතා කළ හැකිය:

my_dataframe.columns.tolist()

ප්‍රශ්නය අතිරේක පැහැදිලි කිරීමක් අවශ්‍ය යැයි මට හැඟේ.

Ixfixxxer සඳහන් කළ පරිදි, පිළිතුර ඔබේ ව්‍යාපෘතියේ ඔබ භාවිතා කරන පැන්ඩා අනුවාදය මත රඳා පවතී. ඔබට pd.__version__විධාන සමඟ ලබා ගත හැකි .

ඔබ මා වැනි කිසියම් හේතුවක් නිසා (ඩෙබියන් ජෙසී මත මම 0.14.1 භාවිතා කරමි) 0.16.0 ට වඩා පැරණි පැන්ඩා අනුවාදය භාවිතා කරන්නේ නම්, ඔබ භාවිතා කළ යුත්තේ:

df.keys().tolist() නැති නිසා df.columns තවමත් ක්‍රමයක් ක්‍රියාත්මක කර නොමැති බැවිනි.

මෙම යතුරු ක්‍රමයේ ඇති වාසිය නම්, එය පැන්ඩා වල නවතම අනුවාදයේ පවා ක්‍රියාත්මක වන නිසා එය වඩාත් විශ්වීය ය.

n = []
for i in my_dataframe.columns:
    n.append(i)
print n

ඉහත දක්වා ඇති විසඳුම හොඳයි. Frame.column_names () වැනි දෙයක් පැන්ඩා වල ශ්‍රිතයක් වනු ඇතැයි මම අපේක්ෂා කරමි, නමුත් එය එසේ නොවන බැවින් සමහර විට පහත සඳහන් වාක්‍ය ඛණ්ඩය භාවිතා කිරීම සතුටක් වනු ඇත. එය කෙසේ හෝ "ටොලිස්ට්" ශ්‍රිතය ඇමතීමෙන් ඔබ නිසි ආකාරයෙන් පැන්ඩා භාවිතා කරයි යන හැඟීම ආරක්ෂා කරයි: frame.columns.tolist ()

frame.columns.tolist() 

දත්ත රාමුවට දර්ශකයක් හෝ බහු ඉන්ඩෙක්ස් එකක් තිබේ නම් සහ ඒවා තීරු නම් ලෙස ඇතුළත් කිරීමට අවශ්‍ය නම්:

names = list(filter(None, df.index.names + df.columns.values.tolist()))

එවැනි සරල මෙහෙයුමක් සඳහා අනවශ්‍ය කාර්ය සාධනයක් ඇති reset_index () ඇමතීමෙන් එය වළක්වයි.

දත්ත රාමු දර්ශකය ප්‍රාථමික / අද්විතීය යතුරකට සිතියම් ගත කරන දත්ත සමුදායන්ගෙන් දත්ත වසා දැමීම නිසා මට මෙය බොහෝ විට අවශ්‍ය වේ, නමුත් ඇත්ත වශයෙන්ම එය මට තවත් "තීරුවක්" පමණි. පැන්ඩාට මේ වගේ දෙයක් සඳහා ගොඩනංවන ක්‍රමයක් තිබීම අර්ථවත් වනු ඇත (මුළුමනින්ම මට එය මග හැරී ඇත).

මෙම විසඳුම මඟින් ඔබේ වස්තුවේ සියලුම තීරු my_dataframe ලැයිස්තුගත කරයි:

print(list(my_dataframe))