在Pandas中将列转换为字符串

我有以下数据帧从一个SQL查询:

(Pdb) pp total_rows
ColumnID  RespondentCount
0          -1                2
1  3030096843                1
2  3030096845                1

我想这样旋转它:

total_data = total_rows.pivot_table(cols=['ColumnID'])


(Pdb) pp total_data
ColumnID         -1            3030096843   3030096845
RespondentCount            2            1            1


[1 rows x 3 columns]




total_rows.pivot_table(cols=['ColumnID']).to_dict('records')[0]


{3030096843: 1, 3030096845: 1, -1: 2}

但我想确保303列被转换为字符串而不是整数，这样我就得到了这个:

{'3030096843': 1, '3030096845': 1, -1: 2}
1024359 次浏览
小开
最佳答案

转换为字符串的一种方法是使用astype:

total_rows['ColumnID'] = total_rows['ColumnID'].astype(str)

然而，也许你正在寻找to_json函数，它将键转换为有效的json(因此你的键转换为字符串):

In [11]: df = pd.DataFrame([['A', 2], ['A', 4], ['B', 6]])


In [12]: df.to_json()
Out[12]: '{"0":{"0":"A","1":"A","2":"B"},"1":{"0":2,"1":4,"2":6}}'


In [13]: df[0].to_json()
Out[13]: '{"0":"A","1":"A","2":"B"}'

注意:你可以传入一个缓冲区/文件来保存它，以及一些其他选项…

小开

这是另一个，特别对 将多个列转换为字符串，而不是单列:

In [76]: import numpy as np
In [77]: import pandas as pd
In [78]: df = pd.DataFrame({
...:     'A': [20, 30.0, np.nan],
...:     'B': ["a45a", "a3", "b1"],
...:     'C': [10, 5, np.nan]})
...:


In [79]: df.dtypes ## Current datatype
Out[79]:
A    float64
B     object
C    float64
dtype: object


## Multiple columns string conversion
In [80]: df[["A", "C"]] = df[["A", "C"]].astype(str)


In [81]: df.dtypes ## Updated datatype after string conversion
Out[81]:
A    object
B    object
C    object
dtype: object
小开

如果你需要将所有列转换为字符串，你可以简单地使用:

df = df.astype(str)

如果你需要除了少数列以外的所有列都是字符串/对象，那么返回并将其他列转换为你需要的任何东西(在这种情况下是整数)，这是非常有用的:

 df[["D", "E"]] = df[["D", "E"]].astype(int)
小开

使用.apply()和lambda转换函数在这种情况下也有效:

total_rows['ColumnID'] = total_rows['ColumnID'].apply(lambda x: str(x))

对于整个数据帧，你可以使用.applymap()。 (但在任何情况下可能.astype()更快)

小开

熊猫>= 1.0: 是时候停止使用astype(str)了!

在pandas 1.0之前(嗯，实际上是0.25)，这是将Series/column声明为字符串的实际方式:

# pandas <= 0.25
# Note to pedants: specifying the type is unnecessary since pandas will
# automagically infer the type as object
s = pd.Series(['a', 'b', 'c'], dtype=str)
s.dtype
# dtype('O')

从pandas 1.0开始，考虑改用< >强"string"类型< / >强。

# pandas >= 1.0
s = pd.Series(['a', 'b', 'c'], dtype="string")
s.dtype
# StringDtype

以下是文档中引用的原因:

  1. 你可能会意外地将字符串和非字符串混合存储在对象dtype数组中。最好有一个专用的dtype。

  2. object dtype中断特定于dtype的操作，如DataFrame.select_dtypes()。没有一个明确的方法来选择文本 当排除非文本但仍然是对象dtype列时

  3. 读取代码时，object dtype数组的内容没有'string'清晰。

另请参阅__ABC0和object之间的行为差异部分。

扩展名类型(在0.24中引入，在1.0中正式化)更接近于pandas而不是numpy，这很好，因为numpy类型不够强大。例如，NumPy没有任何方法在整数数据中表示缺失的数据(自type(NaN) == float以来)。但是熊猫可以使用Nullable Integer列。

为什么我应该停止使用它?

< p > 不小心混合了dtypes类型
第一个原因，正如文档中概述的那样，你可能会意外地将非文本数据存储在对象列中 
# pandas <= 0.25
pd.Series(['a', 'b', 1.23])   # whoops, this should have been "1.23"


0       a
1       b
2    1.23
dtype: object


pd.Series(['a', 'b', 1.23]).tolist()
# ['a', 'b', 1.23]   # oops, pandas was storing this as float all the time.

# pandas >= 1.0
pd.Series(['a', 'b', 1.23], dtype="string")


0       a
1       b
2    1.23
dtype: string


pd.Series(['a', 'b', 1.23], dtype="string").tolist()
# ['a', 'b', '1.23']   # it's a string and we just averted some potentially nasty bugs.
< p > 很难区分字符串和其他python对象
另一个明显的例子是很难区分“字符串”;和“;objects"。对象本质上是任何不支持vectorizable操作的类型的毛毯类型

考虑,

# Setup
df = pd.DataFrame({'A': ['a', 'b', 'c'], 'B': [{}, [1, 2, 3], 123]})
df
 

A          B
0  a         {}
1  b  [1, 2, 3]
2  c        123

直到熊猫0.25，几乎没有办法区分“a”;和“;B"没有相同类型的数据。

# pandas <= 0.25
df.dtypes


A    object
B    object
dtype: object


df.select_dtypes(object)


A          B
0  a         {}
1  b  [1, 2, 3]
2  c        123

从pandas 1.0开始，这变得简单多了:

# pandas >= 1.0
# Convenience function I call to help illustrate my point.
df = df.convert_dtypes()
df.dtypes


A    string
B    object
dtype: object


df.select_dtypes("string")


A
0  a
1  b
2  c
< p > 可读性
这是不言自明的;-)

好吧，那我现在应该停止使用它吗?

……没有。在写这个答案时(版本1.1)，还存在没有性能好处，但文档希望未来的增强能够显著提高性能，并减少"string"列的内存使用，而不是对象。话虽如此，养成好习惯越早越好!

小开

我通常用这个:

pd['Column'].map(str)
小开

有四种方法将列转换为字符串

1. astype(str)
df['column_name'] = df['column_name'].astype(str)


2. values.astype(str)
df['column_name'] = df['column_name'].values.astype(str)


3. map(str)
df['column_name'] = df['column_name'].map(str)


4. apply(str)
df['column_name'] = df['column_name'].apply(str)

让我们看看每种类型的性能

#importing libraries
import numpy as np
import pandas as pd
import time


#creating four sample dataframes using dummy data
df1 = pd.DataFrame(np.random.randint(1, 1000, size =(10000000, 1)), columns =['A'])
df2 = pd.DataFrame(np.random.randint(1, 1000, size =(10000000, 1)), columns =['A'])
df3 = pd.DataFrame(np.random.randint(1, 1000, size =(10000000, 1)), columns =['A'])
df4 = pd.DataFrame(np.random.randint(1, 1000, size =(10000000, 1)), columns =['A'])


#applying astype(str)
time1 = time.time()
df1['A'] = df1['A'].astype(str)
print('time taken for astype(str) : ' + str(time.time()-time1) + ' seconds')


#applying values.astype(str)
time2 = time.time()
df2['A'] = df2['A'].values.astype(str)
print('time taken for values.astype(str) : ' + str(time.time()-time2) + ' seconds')


#applying map(str)
time3 = time.time()
df3['A'] = df3['A'].map(str)
print('time taken for map(str) : ' + str(time.time()-time3) + ' seconds')


#applying apply(str)
time4 = time.time()
df4['A'] = df4['A'].apply(str)
print('time taken for apply(str) : ' + str(time.time()-time4) + ' seconds')

输出

time taken for astype(str): 5.472359895706177 seconds
time taken for values.astype(str): 6.5844292640686035 seconds
time taken for map(str): 2.3686647415161133 seconds
time taken for apply(str): 2.39758563041687 seconds

map(str)和apply(str)与其余两种技术相比需要更少的时间

小开

熊猫版本:1.3.5

更新后的答案

df['colname'] = df['colname'].astype(str) =比;这在默认情况下是有效的。但如果你在使用astype(str)之前创建了str变量，比如str = "myString"，这就行不通了。在本例中，您可能想使用下面的行。

df['colname'] = df['colname'].astype('str')

===========

(注:不正确的旧解释)

df['colname'] = df['colname'].astype('str') =比;将数据帧列转换为字符串类型

df['colname'] = df['colname'].astype(str) =比;给出一个错误


提交答案