Изменить тип столбца в пандах

avatar
user1642513
8 апреля 2013 в 23:53
2416203
13
1140

Я хочу преобразовать таблицу, представленную в виде списка списков, в Pandas DataFrame. В качестве крайне упрощенного примера:

a = [['a', '1.2', '4.2'], ['b', '70', '0.03'], ['x', '5', '0']]
df = pd.DataFrame(a)

Как лучше всего преобразовать столбцы в соответствующие типы, в данном случае столбцы 2 и 3 в числа с плавающей запятой? Есть ли способ указать типы при преобразовании в DataFrame? Или лучше сначала создать DataFrame, а затем прокручивать столбцы, чтобы изменить тип для каждого столбца? В идеале я хотел бы сделать это динамически, потому что могут быть сотни столбцов, и я не хочу точно указывать, какие столбцы какого типа. Все, что я могу гарантировать, - это то, что каждый столбец содержит значения одного типа.

Источник

Ответы (13)

avatar
Alex Riley
21 февраля 2015 в 17:37
1858

У вас есть четыре основных варианта преобразования типов в пандах:

  1. to_numeric() - предоставляет функциональные возможности для безопасного преобразования нечисловых типов (например, строк) в подходящий числовой тип. (См. Также to_datetime() и to_timedelta().)

  2. astype() - преобразовать (почти) любой тип в (почти) любой другой тип (даже если это не обязательно разумно). Также позволяет преобразовывать в категориальные типы (очень полезно).

  3. infer_objects() - служебный метод для преобразования столбцов объектов, содержащих объекты Python, в тип pandas, если это возможно.

  4. convert_dtypes() - преобразовать столбцы DataFrame в «наилучший из возможных» dtype, который поддерживает pd.NA (объект pandas для указания отсутствующего значения).

Прочтите более подробные объяснения и использование каждого из этих методов.


1. to_numeric()

Лучший способ преобразовать один или несколько столбцов DataFrame в числовые значения - использовать pandas.to_numeric().

Эта функция попытается преобразовать нечисловые объекты (например, строки) в целые числа или числа с плавающей запятой в зависимости от ситуации.

Базовое использование

Входными данными для to_numeric() является серия или отдельный столбец DataFrame.

>>> s = pd.Series(["8", 6, "7.5", 3, "0.9"]) # mixed string and numeric values
>>> s
0      8
1      6
2    7.5
3      3
4    0.9
dtype: object

>>> pd.to_numeric(s) # convert everything to float values
0    8.0
1    6.0
2    7.5
3    3.0
4    0.9
dtype: float64

Как видите, возвращается новая серия. Не забудьте присвоить этот вывод имени переменной или столбца, чтобы продолжить его использование:

# convert Series
my_series = pd.to_numeric(my_series)

# convert column "a" of a DataFrame
df["a"] = pd.to_numeric(df["a"])

Вы также можете использовать его для преобразования нескольких столбцов DataFrame с помощью метода apply():

# convert all columns of DataFrame
df = df.apply(pd.to_numeric) # convert all columns of DataFrame

# convert just columns "a" and "b"
df[["a", "b"]] = df[["a", "b"]].apply(pd.to_numeric)

Если все ваши значения могут быть преобразованы, это, вероятно, все, что вам нужно.

Обработка ошибок

Но что, если некоторые значения не могут быть преобразованы в числовой тип?

to_numeric() также принимает аргумент ключевого слова errors, который позволяет заставить нечисловые значения быть NaN или просто игнорировать столбцы, содержащие эти значения.

Вот пример использования серии строк s с объектом dtype:

>>> s = pd.Series(['1', '2', '4.7', 'pandas', '10'])
>>> s
0         1
1         2
2       4.7
3    pandas
4        10
dtype: object

Поведение по умолчанию - поднять, если не удается преобразовать значение. В этом случае он не может справиться со строкой pandas:

>>> pd.to_numeric(s) # or pd.to_numeric(s, errors='raise')
ValueError: Unable to parse string

Вместо того, чтобы потерпеть неудачу, мы могли бы захотеть, чтобы «панды» считались отсутствующим / неверным числовым значением. Мы можем привести недопустимые значения к NaN следующим образом, используя аргумент ключевого слова errors:

>>> pd.to_numeric(s, errors='coerce')
0     1.0
1     2.0
2     4.7
3     NaN
4    10.0
dtype: float64

Третий вариант для errors - просто игнорировать операцию, если обнаружено недопустимое значение:

>>> pd.to_numeric(s, errors='ignore')
# the original Series is returned untouched

Этот последний вариант особенно полезен для преобразования всего вашего DataFrame, но мы не знаем, какие из наших столбцов можно надежно преобразовать в числовой тип. В этом случае просто напишите:

df.apply(pd.to_numeric, errors='ignore')

Функция будет применена к каждому столбцу DataFrame. Столбцы, которые можно преобразовать в числовой тип, будут преобразованы, а столбцы, которые не могут быть преобразованы (например, они содержат нецифровые строки или даты), останутся без изменений.

Понижающее преобразование

По умолчанию преобразование с to_numeric() даст вам либо int64, либо float64 dtype (или любое другое целое число, присущее вашей платформе).

Обычно это то, что вам нужно, но что, если вы хотите сэкономить немного памяти и использовать более компактный тип dtype, например float32 или int8?

to_numeric() дает вам возможность понижать значение до 'integer', 'signed', 'unsigned', 'float'. Вот пример простой серии s целочисленного типа:

>>> s = pd.Series([1, 2, -7])
>>> s
0    1
1    2
2   -7
dtype: int64

При понижении до 'integer' используется наименьшее возможное целое число, которое может содержать значения:

>>> pd.to_numeric(s, downcast='integer')
0    1
1    2
2   -7
dtype: int8

При понижении до 'float' аналогично выбирается плавающий тип меньшего размера, чем обычно:

>>> pd.to_numeric(s, downcast='float')
0    1.0
1    2.0
2   -7.0
dtype: float32

2. astype()

Метод astype() позволяет явно указать тип dtype, который должен иметь ваш DataFrame или Series. Он очень универсален, так как вы можете попробовать перейти от одного типа к другому.

Базовое использование

Просто выберите тип: вы можете использовать dtype NumPy (например, np.int16), некоторые типы Python (например, bool) или типы, специфичные для pandas (например, категориальный dtype).

Вызовите метод объекта, который вы хотите преобразовать, и astype() попытается преобразовать его за вас:

# convert all DataFrame columns to the int64 dtype
df = df.astype(int)

# convert column "a" to int64 dtype and "b" to complex type
df = df.astype({"a": int, "b": complex})

# convert Series to float16 type
s = s.astype(np.float16)

# convert Series to Python strings
s = s.astype(str)

# convert Series to categorical type - see docs for more details
s = s.astype('category')

Обратите внимание, я сказал «попробуйте» - если astype() не знает, как преобразовать значение в Series или DataFrame, это вызовет ошибку. Например, если у вас есть значение NaN или inf, вы получите сообщение об ошибке при попытке преобразовать его в целое число.

Начиная с pandas 0.20.0, эту ошибку можно подавить, передав errors='ignore'. Ваш исходный объект будет возвращен нетронутым.

Будьте осторожны

astype() - мощный инструмент, но иногда он может преобразовывать значения «неправильно». Например:

>>> s = pd.Series([1, 2, -7])
>>> s
0    1
1    2
2   -7
dtype: int64

Это небольшие целые числа, как насчет преобразования в 8-битный тип без знака для экономии памяти?

>>> s.astype(np.uint8)
0      1
1      2
2    249
dtype: uint8

Преобразование сработало, но -7 было преобразовано в 249 (т.е. 2 8 - 7)!

Попытка выполнить понижающее преобразование с помощью pd.to_numeric(s, downcast='unsigned') вместо этого может помочь предотвратить эту ошибку.


3. infer_objects()

Версия 0.21.0 pandas представила метод infer_objects() для преобразования столбцов DataFrame с типом данных объекта в более конкретный тип (мягкие преобразования).

Например, вот DataFrame с двумя столбцами типа объекта. Один содержит фактические целые числа, а другой - строки, представляющие целые числа:

>>> df = pd.DataFrame({'a': [7, 1, 5], 'b': ['3','2','1']}, dtype='object')
>>> df.dtypes
a    object
b    object
dtype: object

Используя infer_objects(), вы можете изменить тип столбца 'a' на int64:

>>> df = df.infer_objects()
>>> df.dtypes
a     int64
b    object
dtype: object

Столбец «b» остался один, поскольку его значения были строками, а не целыми числами. Если вы хотите принудительно преобразовать оба столбца в целочисленный тип, вы можете использовать вместо него df.astype(int).


4. convert_dtypes()

Версия 1.0 и выше включает метод convert_dtypes() для преобразования столбцов Series и DataFrame в наилучший из возможных dtype, который поддерживает отсутствующее значение pd.NA.

Здесь «наилучший из возможных» означает тип, наиболее подходящий для хранения значений. Например, это целочисленный тип pandas, если все значения являются целыми числами (или отсутствующими значениями): столбец объекта целочисленных объектов Python преобразуется в Int64, столбец значений NumPy int32 станет pandas dtype Int32.

С нашим object DataFrame df мы получаем следующий результат:

>>> df.convert_dtypes().dtypes                                             
a     Int64
b    string
dtype: object

Поскольку столбец 'a' содержал целочисленные значения, он был преобразован в тип Int64 (который может содержать отсутствующие значения, в отличие от int64).

Столбец 'b' содержал строковые объекты, поэтому был изменен на pandas 'string dtype.

По умолчанию этот метод определяет тип на основе значений объекта в каждом столбце. Мы можем изменить это, передав infer_objects=False:

>>> df.convert_dtypes(infer_objects=False).dtypes                          
a    object
b    string
dtype: object

Теперь столбец 'a' остался столбцом объекта: pandas знает, что его можно описать как 'целочисленный' столбец (внутри он выполнялся infer_dtype), но не понял, какой именно тип целого числа он должен был так не преобразовал. Столбец 'b' снова был преобразован в 'строковый' dtype, поскольку он был распознан как содержащий 'строковые' значения.

Rob
4 августа 2015 в 08:24
10

Кроме того, в отличие от .astype (float), это преобразует строки в NaN вместо того, чтобы вызывать ошибку.

Matti Lyra
31 октября 2015 в 14:28
15

.convert_objects устарел, так как 0.17 - используйте вместо него df.to_numeric

fogx
7 мая 2021 в 09:58
0

есть ли способ error=coerce в astype()?

avatar
tdy
16 марта 2022 в 22:03
1

Есть ли способ указать типы при преобразовании в DataFrame?

Да. Другие ответы преобразуют dtypes после создания DataFrame, но мы можем указать типы при создании. Используйте либо DataFrame.from_records, либо read_csv(dtype=...) в зависимости от формата ввода.

Последнее иногда необходимо, чтобы избежать ошибок памяти при работе с большими данными.


1. DataFrame.from_records

Создайте DataFrame из структурированного массива желаемых типов столбцов:

x = [['foo', '1.2', '70'], ['bar', '4.2', '5']]

df = pd.DataFrame.from_records(np.array(
    [tuple(row) for row in x], # pass a list-of-tuples (x can be a list-of-lists or 2D array)
    'object, float, int'       # define the column types
))

Вывод:

>>> df.dtypes
# f0     object
# f1    float64
# f2      int64
# dtype: object

2. read_csv(dtype=...)

Если вы читаете данные из файла, используйте параметр dtype в read_csv, чтобы задать типы столбцов во время загрузки.

Например, здесь мы читаем 30M строк с rating как 8-битные целые числа и genre как категориальные:

lines = '''
foo,biography,5
bar,crime,4
baz,fantasy,3
qux,history,2
quux,horror,1
'''
columns = ['name', 'genre', 'rating']
csv = io.StringIO(lines * 6_000_000) # 30M lines

df = pd.read_csv(csv, names=columns, dtype={'rating': 'int8', 'genre': 'category'})

В этом случае мы вдвое уменьшаем использование памяти при загрузке:

>>> df.info(memory_usage='deep')
# memory usage: 1.8 GB
>>> pd.read_csv(io.StringIO(lines * 6_000_000)).info(memory_usage='deep')
# memory usage: 3.7 GB

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

avatar
rubengavidia0x
28 января 2022 в 00:52
0

Если у вас есть различные столбцы объектов, такие как этот Dataframe из 74 столбцов объектов и 2 столбцов Int, где каждое значение имеет буквы, представляющие единицы:

import pandas as pd 
import numpy as np
dataurl = 'https://raw.githubusercontent.com/RubenGavidia/Pandas_Portfolio.py/main/Wes_Mckinney.py/nutrition.csv'
nutrition = pd.read_csv(dataurl,index_col=[0])
nutrition.head(3)

    name    serving_size    calories    total_fat   saturated_fat   cholesterol sodium  choline folate  folic_acid  ... fat saturated_fatty_acids   monounsaturated_fatty_acids polyunsaturated_fatty_acids fatty_acids_total_trans alcohol ash caffeine    theobromine water
0   Cornstarch  100 g   381 0.1g    NaN 0   9.00 mg 0.4 mg  0.00 mcg    0.00 mcg    ... 0.05 g  0.009 g 0.016 g 0.025 g 0.00 mg 0.0 g   0.09 g  0.00 mg 0.00 mg 8.32 g
1   Nuts, pecans    100 g   691 72g 6.2g    0   0.00 mg 40.5 mg 22.00 mcg   0.00 mcg    ... 71.97 g 6.180 g 40.801 g    21.614 g    0.00 mg 0.0 g   1.49 g  0.00 mg 0.00 mg 3.52 g
2   Eggplant, raw   100 g   25  0.2g    NaN 0   2.00 mg 6.9 mg  22.00 mcg   0.00 mcg    ... 0.18 g  0.034 g 0.016 g 0.076 g 0.00 mg 0.0 g   0.66 g  0.00 mg 0.00 mg 92.30 g
3 rows × 76 columns

nutrition.dtypes
name             object
serving_size     object
calories          int64
total_fat        object
saturated_fat    object
                  ...  
alcohol          object
ash              object
caffeine         object
theobromine      object
water            object
Length: 76, dtype: object

nutrition.dtypes.value_counts()
object    74
int64      2
dtype: int64

Хорошим способом преобразовать все столбцы в числовые является использование регулярных выражений для замены единиц измерения и astype(float) для изменения типа данных столбцов на float:

nutrition.index = pd.RangeIndex(start = 0, stop = 8789, step= 1)
nutrition.set_index('name',inplace = True)
nutrition.replace('[a-zA-Z]','', regex= True, inplace=True)
nutrition=nutrition.astype(float)
nutrition.head(3)

serving_size    calories    total_fat   saturated_fat   cholesterol sodium  choline folate  folic_acid  niacin  ... fat saturated_fatty_acids   monounsaturated_fatty_acids polyunsaturated_fatty_acids fatty_acids_total_trans alcohol ash caffeine    theobromine water
name                                                                                    
Cornstarch  100.0   381.0   0.1 NaN 0.0 9.0 0.4 0.0 0.0 0.000   ... 0.05    0.009   0.016   0.025   0.0 0.0 0.09    0.0 0.0 8.32
Nuts, pecans    100.0   691.0   72.0    6.2 0.0 0.0 40.5    22.0    0.0 1.167   ... 71.97   6.180   40.801  21.614  0.0 0.0 1.49    0.0 0.0 3.52
Eggplant, raw   100.0   25.0    0.2 NaN 0.0 2.0 6.9 22.0    0.0 0.649   ... 0.18    0.034   0.016   0.076   0.0 0.0 0.66    0.0 0.0 92.30
3 rows × 75 columns

nutrition.dtypes
serving_size     float64
calories         float64
total_fat        float64
saturated_fat    float64
cholesterol      float64
                  ...   
alcohol          float64
ash              float64
caffeine         float64
theobromine      float64
water            float64
Length: 75, dtype: object

nutrition.dtypes.value_counts()
float64    75
dtype: int64

Теперь набор данных чист, и вы можете выполнять числовые операции с этим Dataframe только с помощью regex и astype().

Если вы хотите собрать единицы и вставить их в заголовки, например cholesterol_mg, вы можете использовать этот код:

nutrition.index = pd.RangeIndex(start = 0, stop = 8789, step= 1)
nutrition.set_index('name',inplace = True)
nutrition.astype(str).replace('[^a-zA-Z]','', regex= True)
units = nutrition.astype(str).replace('[^a-zA-Z]','', regex= True)
units = units.mode()
units = units.replace('', np.nan).dropna(axis=1)
mapper = { k: k + "_" + units[k].at[0] for k in units}
nutrition.rename(columns=mapper, inplace=True)
nutrition.replace('[a-zA-Z]','', regex= True, inplace=True)
nutrition=nutrition.astype(float)
avatar
Rajesh
27 сентября 2021 в 10:34
2

df = df.astype ({"columnname": str})

# например - для изменения типа столбца на строку

Trenton McKinney
6 октября 2021 в 00:36
0

Этот дубликат был передан модератору в соответствии с Пометить повторяющиеся ответы на тот же вопрос. Хотя это ответ, он дублирует код в принятом ответе и других ответах. Для SO нет никакой дополнительной ценности, чтобы сохранить много ответов с одним и тем же решением, и нет необходимости в примере для каждого type. Вместо этого проголосуйте за существующие ответы.

avatar
Mustapha Babatunde
24 марта 2021 в 10:15
4

df.info () дает нам исходный тип данных temp, который является float64

 #   Column  Non-Null Count  Dtype  
---  ------  --------------  -----  
 0   date    132 non-null    object 
 1   temp    132 non-null    float64

Теперь используйте этот код, чтобы изменить тип данных на int64:

df['temp'] = df['temp'].astype('int64')

если вы снова выполните df.info (), вы увидите:

  #   Column  Non-Null Count  Dtype 
 ---  ------  --------------  ----- 
  0   date    132 non-null    object
  1   temp    132 non-null    int64 

Это показывает, что вы успешно изменили тип данных временного столбца. Удачного кодирования!

BSalita
8 мая 2021 в 08:26
1

Мне нравится, как df.info () указывает использование памяти в последней строке.

avatar
Sohail
6 апреля 2020 в 14:26
3

Начиная с pandas 1.0.0, у нас есть pandas.DataFrame.convert_dtypes. Вы даже можете контролировать, какие типы преобразовывать!

In [40]: df = pd.DataFrame(
    ...:     {
    ...:         "a": pd.Series([1, 2, 3], dtype=np.dtype("int32")),
    ...:         "b": pd.Series(["x", "y", "z"], dtype=np.dtype("O")),
    ...:         "c": pd.Series([True, False, np.nan], dtype=np.dtype("O")),
    ...:         "d": pd.Series(["h", "i", np.nan], dtype=np.dtype("O")),
    ...:         "e": pd.Series([10, np.nan, 20], dtype=np.dtype("float")),
    ...:         "f": pd.Series([np.nan, 100.5, 200], dtype=np.dtype("float")),
    ...:     }
    ...: )

In [41]: dff = df.copy()

In [42]: df 
Out[42]: 
   a  b      c    d     e      f
0  1  x   True    h  10.0    NaN
1  2  y  False    i   NaN  100.5
2  3  z    NaN  NaN  20.0  200.0

In [43]: df.dtypes
Out[43]: 
a      int32
b     object
c     object
d     object
e    float64
f    float64
dtype: object

In [44]: df = df.convert_dtypes()

In [45]: df.dtypes
Out[45]: 
a      Int32
b     string
c    boolean
d     string
e      Int64
f    float64
dtype: object

In [46]: dff = dff.convert_dtypes(convert_boolean = False)

In [47]: dff.dtypes
Out[47]: 
a      Int32
b     string
c     object
d     string
e      Int64
f    float64
dtype: object
avatar
cs95
18 февраля 2020 в 10:12
14

панды> = 1.0

Вот диаграмма, в которой обобщены некоторые из наиболее важных преобразований в пандах.

enter image description here

Преобразование в строку тривиально .astype(str) и не показано на рисунке.

«Жесткое» преобразование в «Мягкое»

Обратите внимание, что «преобразования» в этом контексте могут относиться либо к преобразованию текстовых данных в их фактический тип данных (жесткое преобразование), либо к выводу более подходящих типов данных для данных в столбцах объекта (мягкое преобразование). Чтобы проиллюстрировать разницу, взгляните на

df = pd.DataFrame({'a': ['1', '2', '3'], 'b': [4, 5, 6]}, dtype=object)
df.dtypes                                                                  

a    object
b    object
dtype: object

# Actually converts string to numeric - hard conversion
df.apply(pd.to_numeric).dtypes                                             

a    int64
b    int64
dtype: object

# Infers better data types for object data - soft conversion
df.infer_objects().dtypes                                                  

a    object  # no change
b     int64
dtype: object

# Same as infer_objects, but converts to equivalent ExtensionType
df.convert_dtypes().dtypes                                                     
avatar
SarahD
1 февраля 2019 в 09:49
1

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

a = [['a', 1.2, 4.2], ['b', 70, 0.03], ['x', 5, 0]]

, но из-за чрезмерной обработки списка перед созданием фрейма данных я теряю типы, и все становится строкой.

Создание фрейма данных с помощью массива numpy

df = pd.DataFrame(np.array(a))

df
Out[5]: 
   0    1     2
0  a  1.2   4.2
1  b   70  0.03
2  x    5     0

df[1].dtype
Out[7]: dtype('O')

дает тот же фрейм данных, что и в вопросе, где записи в столбцах 1 и 2 рассматриваются как строки. Однако делая

df = pd.DataFrame(a)

df
Out[10]: 
   0     1     2
0  a   1.2  4.20
1  b  70.0  0.03
2  x   5.0  0.00

df[1].dtype
Out[11]: dtype('float64')

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

avatar
Thom Ives
12 октября 2018 в 21:02
28

Когда мне нужно было указать только определенные столбцы, и я хочу быть явным, я использовал (для DOCS LOCATION):

dataframe = dataframe.astype({'col_name_1':'int','col_name_2':'float64', etc. ...})

Итак, используя исходный вопрос, но предоставляя ему имена столбцов ...

a = [['a', '1.2', '4.2'], ['b', '70', '0.03'], ['x', '5', '0']]
df = pd.DataFrame(a, columns=['col_name_1', 'col_name_2', 'col_name_3'])
df = df.astype({'col_name_2':'float64', 'col_name_3':'float64'})
avatar
Akash Nayak
15 ноября 2017 в 09:38
48

этот ниже код изменит тип данных столбца.

df[['col.name1', 'col.name2'...]] = df[['col.name1', 'col.name2'..]].astype('data_type')

вместо типа данных вы можете указать свой тип данных. Что вы хотите, например str, float, int и т. Д.

H. Vabri
6 января 2018 в 16:28
0

Имейте в виду, что при применении этого к столбцу, содержащему строки `` 'True' '' 'и ``' 'False' '`` с использованием data_type bool, все изменяется на True.

neves
22 сентября 2018 в 18:21
0

Эту опцию также можно преобразовать в тип «категория».

avatar
MikeyE
11 июля 2017 в 05:56
10

Как насчет создания двух фреймов данных, каждый с разными типами данных для своих столбцов, а затем их объединения?

d1 = pd.DataFrame(columns=[ 'float_column' ], dtype=float)
d1 = d1.append(pd.DataFrame(columns=[ 'string_column' ], dtype=str))

Результаты

In[8}:  d1.dtypes
Out[8]: 
float_column     float64
string_column     object
dtype: object

После создания фрейма данных вы можете заполнить его переменными с плавающей запятой в 1-м столбце и строками (или любым другим типом данных) во 2-м столбце.

avatar
Harry Stevens
14 июня 2017 в 05:42
17

Вот функция, которая принимает в качестве аргументов DataFrame и список столбцов и приводит все данные в столбцах к числам.

# df is the DataFrame, and column_list is a list of columns as strings (e.g ["col1","col2","col3"])
# dependencies: pandas

def coerce_df_columns_to_numeric(df, column_list):
    df[column_list] = df[column_list].apply(pd.to_numeric, errors='coerce')

Итак, для вашего примера:

import pandas as pd

def coerce_df_columns_to_numeric(df, column_list):
    df[column_list] = df[column_list].apply(pd.to_numeric, errors='coerce')

a = [['a', '1.2', '4.2'], ['b', '70', '0.03'], ['x', '5', '0']]
df = pd.DataFrame(a, columns=['col1','col2','col3'])

coerce_df_columns_to_numeric(df, ['col2','col3'])
jvalenti
5 июля 2019 в 20:52
0

что, если вы хотите использовать индексы столбцов вместо имен столбцов?

avatar
hernamesbarbara
21 апреля 2013 в 18:15
488

Как насчет этого?

a = [['a', '1.2', '4.2'], ['b', '70', '0.03'], ['x', '5', '0']]
df = pd.DataFrame(a, columns=['one', 'two', 'three'])
df
Out[16]: 
  one  two three
0   a  1.2   4.2
1   b   70  0.03
2   x    5     0

df.dtypes
Out[17]: 
one      object
two      object
three    object

df[['two', 'three']] = df[['two', 'three']].astype(float)

df.dtypes
Out[19]: 
one       object
two      float64
three    float64
hernamesbarbara
9 декабря 2013 в 14:12
11

Да! pd.DataFrame имеет аргумент dtype, который может позволить вам делать то, что вы ищете. df = pd.DataFrame (a, columns = ['one', 'two', 'three'], dtype = float) In [2]: df.dtypes Out [2]: один объект два float64 три float64 dtype: object

orange
6 июня 2014 в 07:34
22

Когда я пытаюсь выполнить предложенную операцию, я получаю предупреждение SettingWithCopyWarning: A value is trying to be set on a copy of a slice from a DataFrame. Try using .loc[row_index,col_indexer] = value instead. Возможно, это было введено в более новую версию pandas, и в результате я не вижу ничего плохого, но мне просто интересно, о чем это предупреждение. Любая идея?

A.Wan
27 июня 2014 в 01:14
2

@orange предупреждение должно предупредить пользователей о потенциально запутанном поведении с цепными операциями и с пандами, возвращающими копии, а не редактирующие фреймы данных. см. coderhelper.com/questions/20625582/… и т.п.

Vitaly Isaev
21 января 2015 в 11:25
23

Это хороший метод, но он не работает, когда в столбце есть NaN. Понятия не имею, почему NaN просто не может оставаться NaN при приведении float к int: ValueError: Cannot convert NA to integer

Pietro Battiston
22 октября 2015 в 12:06
1

@VitalyIsaev: потому что у numpy ints нет представления для NaN: pandas.pydata.org/pandas-docs/stable/…

Gill Bates
7 июня 2016 в 14:03
0

@hernamesbarbara, можно ли передать разные dtype для разных столбцов?

FichteFoll
7 июля 2016 в 02:43
9

@GillBates да, в словаре. df = pd.DataFrame(a, columns=['one', 'two', 'three'], dtype={'one': str, 'two': int, 'three': float}). Однако мне трудно найти спецификацию для принятых значений "dtype". Список был бы неплохим (в настоящее время я использую dict(enumerate(my_list))).

wyx
11 апреля 2017 в 06:50
0

@FichteFoll Не может работать. Возврат ValueError: entry not a 2- or 3- tuple

Soren
15 февраля 2018 в 14:53
0

Это также преобразует дату и время.