熊猫>= 1.0

下面这张图表总结了熊猫身上一些最重要的基因转换。

到字符串的转换是简单的.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

用这个:

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

我也有同样的问题。

我找不到任何令人满意的解决方案。我的解决方案是简单地将这些float转换为str并删除'。0'这边。

在我的例子中，我只在第一列上应用它:

firstCol = list(df.columns)[0]
df[firstCol] = df[firstCol].fillna('').astype(str).apply(lambda x: x.replace('.0', ''))

在pandas中转换类型有四个主要选项:

To_numeric() -提供将非数字类型(例如字符串)安全转换为合适的数字类型的功能。(请参见to_datetime()和to_timedelta()。) Astype() -将(几乎)任何类型转换为(几乎)任何其他类型(即使这样做并不一定合理)。还允许您转换为类别类型(非常有用)。 infer_objects()——一个实用程序方法，在可能的情况下将包含Python对象的对象列转换为pandas类型。 convert_dtypes() -将DataFrame列转换为支持pd的“最佳”dtype。NA(熊猫的对象，表示一个缺失的值)。

请继续阅读以获得这些方法的更详细的解释和用法。

---

1. to_numeric ()

将DataFrame的一个或多个列转换为数值的最好方法是使用pandas.to_numeric()。

此函数将尝试将非数值对象(例如字符串)更改为适当的整数或浮点数。

基本用法

to_numeric()的输入是一个Series或一个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

如您所见，返回了一个新的Series。请记住将此输出分配给变量或列名以继续使用它:

# convert Series
my_series = pd.to_numeric(my_series)

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

你也可以使用apply()方法来转换一个DataFrame的多个列:

# 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，或者直接忽略包含这些值的列。

下面是一个使用对象为dtype的string序列的例子:

>>> 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

我们可能希望'pandas'被认为是一个缺失/错误的数值，而不是失败。我们可以使用errors关键字参数将无效值强制为NaN，如下所示:

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

错误的第三个选项是，如果遇到无效值，则忽略该操作:

>>> 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()方法使您能够明确您希望DataFrame或Series具有的dtype。它的用途非常广泛，你可以尝试从一种类型转换到任何其他类型。

基本用法

只需要选择一个类型:你可以使用NumPy dtype(例如np.int16)，一些Python类型(例如bool)，或特定于熊猫的类型(如分类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')

注意我说的是"try" -如果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(即28 -7)!

尝试使用pd向下投射。To_numeric (s, downcast='unsigned')可以帮助避免此错误。

---

3.infer_objects ()

pandas的0.21.0版引入了方法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列转换为支持pd的最佳dtype。NA缺失值。

这里的“最佳可能”是指最适合保存值的类型。例如，这是一个pandas整型，如果所有的值都是整数(或缺值):Python整型对象的对象列转换为Int64, NumPy int32值的列转换为pandas dtype int32。

使用我们的对象DataFrame df，我们得到以下结果:

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

由于列'a'保存整数值，因此它被转换为Int64类型(与Int64不同，该类型能够保存缺失的值)。

列'b'包含字符串对象，因此被更改为pandas的字符串dtype。

默认情况下，此方法将从每列中的对象值推断类型。我们可以通过传递infer_objects=False来改变这一点:

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

现在列“a”仍然是一个对象列:pandas知道它可以被描述为一个“整数”列(在内部它运行infer_dtype)，但没有确切地推断它应该有什么整数的dtype，所以没有转换它。列'b'再次被转换为'string' dtype，因为它被识别为持有'string'值。

从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

是否有一种方法可以在转换到DataFrame时指定类型?

是的。其他答案在创建DataFrame之后转换dtypes，但是我们可以在创建时指定类型。根据输入格式使用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 =…)

如果从文件中读取数据，则使用read_csv的dtype参数在加载时设置列类型。

例如，这里我们读取30M行，其评级为8位整数，类型为分类:

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

这是避免大数据内存错误的一种方法。加载后并不总是可以更改dtype，因为我们可能没有足够的内存来加载默认类型的数据。