Как проверить dtype столбца в python pandas

Мне нужно использовать разные функции для обработки числовых столбцов и столбцов строк. То, что я делаю сейчас, действительно глупо:

allc = list((agg.loc[:, (agg.dtypes==np.float64)|(agg.dtypes==np.int)]).columns)
for y in allc:
    treat_numeric(agg[y])    

allc = list((agg.loc[:, (agg.dtypes!=np.float64)&(agg.dtypes!=np.int)]).columns)
for y in allc:
    treat_str(agg[y])

Есть ли более элегантный способ сделать это? Например.

for y in agg.columns:
    if(dtype(agg[y]) == 'string'):
          treat_str(agg[y])
    elif(dtype(agg[y]) != 'string'):
          treat_numeric(agg[y])

Ответы

Ответ 1

Доступ к типу данных столбца можно получить с помощью dtype:

for y in agg.columns:
    if(agg[y].dtype == np.float64 or agg[y].dtype == np.int64):
          treat_numeric(agg[y])
    else:
          treat_str(agg[y])

Ответ 2

В pandas 0.20.2 вы можете сделать:

from pandas.api.types import is_string_dtype
from pandas.api.types import is_numeric_dtype

is_string_dtype(df['A'])
>>>> True

is_numeric_dtype(df['B'])
>>>> True

Итак, ваш код будет выглядеть следующим образом:

for y in agg.columns:
    if (is_string_dtype(agg[y])):
        treat_str(agg[y])
    elif (is_numeric_dtype(agg[y])):
        treat_numeric(agg[y])

Ответ 4

Заголовок задаваемого вопроса носит общий характер, но авторы используют прецедент, указанный в основной части вопроса. Так что любые другие ответы могут быть использованы.

Но чтобы полностью ответить на заглавный вопрос, необходимо уточнить, что в некоторых случаях все подходы могут потерпеть неудачу и требуют некоторой доработки. Я рассмотрел все из них (и некоторые дополнительные) в порядке уменьшения надежности (на мой взгляд):

1. Сравнение типов напрямую через == (принятый ответ).

Несмотря на то, что это принятый ответ и имеет наибольшее количество голосов, я думаю, что этот метод не следует использовать вообще. Потому что на самом деле этот подход не рекомендуется в питоне, как упоминалось несколько раз здесь.
Но если кто-то все еще хочет его использовать - должен знать о некоторых типах панд, таких как pd.CategoricalDType, pd.PeriodDtype или pd.IntervalDtype. Здесь нужно использовать дополнительный type( ), чтобы правильно распознать dtype:

s = pd.Series([pd.Period('2002-03','D'), pd.Period('2012-02-01', 'D')])
s
s.dtype == pd.PeriodDtype   # Not working
type(s.dtype) == pd.PeriodDtype # working 

>>> 0    2002-03-01
>>> 1    2012-02-01
>>> dtype: period[D]
>>> False
>>> True

Еще одна оговорка: этот тип должен быть точно указан:

s = pd.Series([1,2])
s
s.dtype == np.int64 # Working
s.dtype == np.int32 # Not working

>>> 0    1
>>> 1    2
>>> dtype: int64
>>> True
>>> False

2. isinstance() подход.

Этот метод не был упомянут в ответах до сих пор.

Так что если прямое сравнение типов не является хорошей идеей - давайте попробуем встроенную функцию python для этой цели, а именно - isinstance().
Вначале происходит сбой, поскольку предполагается, что у нас есть некоторые объекты, но pd.Series или pd.DataFrame можно использовать как просто пустые контейнеры с предопределенным dtype, но без объектов в нем:

s = pd.Series([], dtype=bool)
s

>>> Series([], dtype: bool)

Но если кто-то как-то преодолеет эту проблему и захочет получить доступ к каждому объекту, например, в первой строке, и проверит его dtype следующим образом:

df = pd.DataFrame({'int': [12, 2], 'dt': [pd.Timestamp('2013-01-02'), pd.Timestamp('2016-10-20')]},
                  index = ['A', 'B'])
for col in df.columns:
    df[col].dtype, 'is_int64 = %s' % isinstance(df.loc['A', col], np.int64)

>>> (dtype('int64'), 'is_int64 = True')
>>> (dtype('<M8[ns]'), 'is_int64 = False')

Это будет вводить в заблуждение в случае смешанного типа данных в одном столбце:

df2 = pd.DataFrame({'data': [12, pd.Timestamp('2013-01-02')]},
                  index = ['A', 'B'])
for col in df2.columns:
    df2[col].dtype, 'is_int64 = %s' % isinstance(df2.loc['A', col], np.int64)

>>> (dtype('O'), 'is_int64 = False')

И последнее, но не менее важное: этот метод не может напрямую распознать Category dtype. Как указано в документах:

Возвращение одного элемента из категориальных данных также возвращает значение, а не категориальное с длиной "1".

df['int'] = df['int'].astype('category')
for col in df.columns:
    df[col].dtype, 'is_int64 = %s' % isinstance(df.loc['A', col], np.int64)

>>> (CategoricalDtype(categories=[2, 12], ordered=False), 'is_int64 = True')
>>> (dtype('<M8[ns]'), 'is_int64 = False')

Так что этот метод также практически неприменим.

3. df.dtype.kind подход.

Этот метод еще может работать с пустыми pd.Series или pd.DataFrames, но имеет другие проблемы.

Во-первых, он не может отличаться некоторыми dtypes:

df = pd.DataFrame({'prd'  :[pd.Period('2002-03','D'), pd.Period('2012-02-01', 'D')],
                   'str'  :['s1', 's2'],
                   'cat'  :[1, -1]})
df['cat'] = df['cat'].astype('category')
for col in df:
    # kind will define all columns as 'Object'
    print (df[col].dtype, df[col].dtype.kind)

>>> period[D] O
>>> object O
>>> category O

Во-вторых, что мне на самом деле до сих пор неясно, это даже возвращает некоторые типы dapes Нет.

4. df.select_dtypes подход.

Это почти то, что мы хотим. Этот метод разработан внутри панд так, что он обрабатывает большинство angular случаев, упомянутых ранее - пустые DataFrames, хорошо отличается от numpy или специфичных для панд dtypes. Он хорошо работает с одним dtype, например, .select_dtypes('bool'). Может использоваться даже для выбора групп столбцов на основе dtype:

test = pd.DataFrame({'bool' :[False, True], 'int64':[-1,2], 'int32':[-1,2],'float': [-2.5, 3.4],
                     'compl':np.array([1-1j, 5]),
                     'dt'   :[pd.Timestamp('2013-01-02'), pd.Timestamp('2016-10-20')],
                     'td'   :[pd.Timestamp('2012-03-02')- pd.Timestamp('2016-10-20'),
                              pd.Timestamp('2010-07-12')- pd.Timestamp('2000-11-10')],
                     'prd'  :[pd.Period('2002-03','D'), pd.Period('2012-02-01', 'D')],
                     'intrv':pd.arrays.IntervalArray([pd.Interval(0, 0.1), pd.Interval(1, 5)]),
                     'str'  :['s1', 's2'],
                     'cat'  :[1, -1],
                     'obj'  :[[1,2,3], [5435,35,-52,14]]
                    })
test['int32'] = test['int32'].astype(np.int32)
test['cat'] = test['cat'].astype('category')

Примерно так, как указано в документах:

test.select_dtypes('number')

>>>     int64   int32   float   compl   td
>>> 0      -1      -1   -2.5    (1-1j)  -1693 days
>>> 1       2       2    3.4    (5+0j)   3531 days

Он может подумать, что здесь мы видим первые неожиданные (если раньше были для меня: вопрос) результаты - TimeDelta включен в выходной файл DataFrame. Но, как ответил наоборот, так и должно быть, но об этом нужно знать. Обратите внимание, что bool dtype пропущен, что также может быть нежелательным для кого-то, но это из-за bool и number находятся в разных "поддеревьях" numpy dtypes. В случае с bool мы можем использовать test.select_dtypes(['bool']) здесь.

Следующее ограничение этого метода заключается в том, что для текущей версии панд (0.24.2) этот код: test.select_dtypes('period') будет вызывать NotImplementedError.

И еще одно: он не может отличать строки от других объектов:

test.select_dtypes('object')

>>>     str     obj
>>> 0    s1     [1, 2, 3]
>>> 1    s2     [5435, 35, -52, 14]

Но это, во-первых, уже упомянуто в документации. И второе - это не проблема этого метода, а способ хранения строк в DataFrame. Но в любом случае в этом случае требуется некоторая постобработка.

5. df.api.types.is_XXX_dtype подход.

Предполагается, что этот способ является наиболее надежным и естественным способом достижения распознавания dtype (путь модуля, в котором находятся функции, говорит сам за себя), как я полагаю. И он работает почти идеально, но все равно имеет хотя бы одно предупреждение и все же должен как-то различать строковые столбцы.

Кроме того, это может быть субъективно, но этот подход также имеет более "понятную человеку" обработку групп dtypes number по сравнению с .select_dtypes('number'):

for col in test.columns:
    if pd.api.types.is_numeric_dtype(test[col]):
        print (test[col].dtype)

>>> bool
>>> int64
>>> int32
>>> float64
>>> complex128

Нет timedelta и bool включены. Совершенный.

В данный момент мой конвейер использует именно эту функциональность, а также немного последующей обработки.

Выход.

Надеюсь, я смог аргументировать главное - что все обсуждаемые подходы могут быть использованы, но только pd.DataFrame.select_dtypes() и pd.api.types.is_XXX_dtype действительно должны рассматриваться как применимые.

Ответ 5

Если вы хотите пометить тип столбца dataframe как строку, вы можете сделать: 

df['A'].dtype.kind

Пример: 

In [8]: df = pd.DataFrame([[1,'a',1.2],[2,'b',2.3]])
In [9]: df[0].dtype.kind, df[1].dtype.kind, df[2].dtype.kind
Out[9]: ('i', 'O', 'f')

Ответ на ваш код: 

for y in agg.columns:
    if(agg[y].dtype.kind == 'f' or agg[y].dtype.kind == 'i'):
          treat_numeric(agg[y])
    else:
          treat_str(agg[y])

Ответ 6

Чтобы красиво напечатать столбец типов данных

Чтобы проверить типы данных после, например, импорта из файла

def printColumnInfo(df):
    template="%-8s %-30s %s"
    print(template % ("Type", "Column Name", "Example Value"))
    print("-"*53)
    for c in df.columns:
        print("%-8s %-30s %s" % (df[c].dtype, c, df[c].iloc[1]) )

Иллюстративный вывод:

Type     Column Name                    Example Value
-----------------------------------------------------
int64    Age                            49
object   Attrition                      No
object   BusinessTravel                 Travel_Frequently
float64  DailyRate                      279.0