obtenir la liste des colonnes de dataframe pandas en fonction du type de données

Si j'ai un dataframe avec les colonnes suivantes:

1. NAME                                     object
2. On_Time                                      object
3. On_Budget                                    object
4. %actual_hr                                  float64
5. Baseline Start Date                  datetime64[ns]
6. Forecast Start Date                  datetime64[ns] 

Je voudrais pouvoir dire: voici un dataframe, donnez-moi une liste des colonnes qui sont de type Object ou de type DateTime?

J'ai une fonction qui convertit les nombres (Float64) en deux décimales, et j'aimerais utiliser cette liste de colonnes de dataframe, d'un type particulier, et l'exécuter via cette fonction pour les convertir toutes en 2dp.

Peut être:

For c in col_list: if c.dtype = "Something"
list[]
List.append(c)?

Si vous voulez une liste de colonnes d'un certain type, vous pouvez utiliser groupby:

>>> df = pd.DataFrame([[1, 2.3456, 'c', 'd', 78]], columns=list("ABCDE"))
>>> df
   A       B  C  D   E
0  1  2.3456  c  d  78

[1 rows x 5 columns]
>>> df.dtypes
A      int64
B    float64
C     object
D     object
E      int64
dtype: object
>>> g = df.columns.to_series().groupby(df.dtypes).groups
>>> g
{dtype('int64'): ['A', 'E'], dtype('float64'): ['B'], dtype('O'): ['C', 'D']}
>>> {k.name: v for k, v in g.items()}
{'object': ['C', 'D'], 'int64': ['A', 'E'], 'float64': ['B']}

À partir de pandas v0.14.1, vous pouvez utiliser select_dtypes()pour sélectionner des colonnes par dtype

In [2]: df = pd.DataFrame({'NAME': list('abcdef'),
    'On_Time': [True, False] * 3,
    'On_Budget': [False, True] * 3})

In [3]: df.select_dtypes(include=['bool'])
Out[3]:
  On_Budget On_Time
0     False    True
1      True   False
2     False    True
3      True   False
4     False    True
5      True   False

In [4]: mylist = list(df.select_dtypes(include=['bool']).columns)

In [5]: mylist
Out[5]: ['On_Budget', 'On_Time']

L'utilisation dtypevous donnera le type de données de la colonne souhaitée:

dataframe['column1'].dtype

si vous voulez connaître les types de données de toutes les colonnes à la fois , vous pouvez utiliser le pluriel de dtypecomme dtypes :

dataframe.dtypes

Vous pouvez utiliser un masque booléen sur l'attribut dtypes:

In [11]: df = pd.DataFrame([[1, 2.3456, 'c']])

In [12]: df.dtypes
Out[12]: 
0      int64
1    float64
2     object
dtype: object

In [13]: msk = df.dtypes == np.float64  # or object, etc.

In [14]: msk
Out[14]: 
0    False
1     True
2    False
dtype: bool

Vous pouvez regarder uniquement ces colonnes avec le dtype souhaité:

In [15]: df.loc[:, msk]
Out[15]: 
        1
0  2.3456

Vous pouvez maintenant utiliser round (ou autre) et le réattribuer:

In [16]: np.round(df.loc[:, msk], 2)
Out[16]: 
      1
0  2.35

In [17]: df.loc[:, msk] = np.round(df.loc[:, msk], 2)

In [18]: df
Out[18]: 
   0     1  2
0  1  2.35  c

list(df.select_dtypes(['object']).columns)

Cela devrait faire l'affaire

utiliser df.info(verbose=True)where dfis a pandas datafarme, par défautverbose=False

Le moyen le plus direct pour obtenir une liste de colonnes de certains types de dtype, par exemple 'object':

df.select_dtypes(include='object').columns

Par exemple:

>>df = pd.DataFrame([[1, 2.3456, 'c', 'd', 78]], columns=list("ABCDE"))
>>df.dtypes

A      int64
B    float64
C     object
D     object
E      int64
dtype: object

Pour obtenir toutes les colonnes dtype 'objet':

>>df.select_dtypes(include='object').columns

Index(['C', 'D'], dtype='object')

Pour juste la liste:

>>list(df.select_dtypes(include='object').columns)

['C', 'D']   

Si vous voulez une liste des seules colonnes d'objets, vous pouvez faire:

non_numerics = [x for x in df.columns \
                if not (df[x].dtype == np.float64 \
                        or df[x].dtype == np.int64)]

puis si vous souhaitez obtenir une autre liste contenant uniquement les chiffres:

numerics = [x for x in df.columns if x not in non_numerics]

Je suis venu avec ces trois lignes .

Essentiellement, voici ce qu'il fait:

1. Récupérez les noms des colonnes et leurs types de données respectifs.
2. Je le suis éventuellement en sortie dans un csv.

inp = pd.read_csv('filename.csv') # read input. Add read_csv arguments as needed
columns = pd.DataFrame({'column_names': inp.columns, 'datatypes': inp.dtypes})
columns.to_csv(inp+'columns_list.csv', encoding='utf-8') # encoding is optional

Cela m'a rendu la vie beaucoup plus facile en essayant de générer des schémas à la volée. J'espère que cela t'aides

pour yoshiserry;

def col_types(x,pd):
    dtypes=x.dtypes
    dtypes_col=dtypes.index
    dtypes_type=dtypes.value
    column_types=dict(zip(dtypes_col,dtypes_type))
    return column_types

J'utilise infer_objects ()

Docstring: essayez de déduire de meilleurs dtypes pour les colonnes d'objets.

Tente une conversion douce des colonnes de type objet, en laissant les colonnes non-objet et non convertibles inchangées. Les règles d'inférence sont les mêmes que lors de la construction normale de Series / DataFrame.

df.infer_objects().dtypes