我有一个SQL查询的以下DataFrame：
(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}
答案 0 :(得分：220)
转换为字符串的一种方法是使用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"}'
注意：你可以传入一个缓冲区/文件来保存它，以及其他一些选项......
答案 1 :(得分：21)
这是另一个，特别有用 将多列转换为字符串而不仅仅是单列：
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
答案 2 :(得分：21)
astype(str)! 在熊猫1.0之前（实际上是0.25），这是将系列/列声明为字符串的事实上的方法：
# 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')
从熊猫1.0开始，考虑使用"string" type。
# pandas >= 1.0
s = pd.Series(['a', 'b', 'c'], dtype="string")
s.dtype
# StringDtype
这是文档引用的原因：
您可能会意外地将字符串和非字符串的混合存储在对象dtype数组中。最好有一个专用的dtype。
objectdtype中断特定于dtype的操作，例如DataFrame.select_dtypes()。没有一种清晰的方法可以只选择文字 同时排除非文本但仍为object-dtype的列。在读取代码时，
objectdtype数组的内容不如'string'清楚。
另请参阅Behavioral Differences between "string" and object上的部分。
Extension types（在0.24中引入并在1.0中形式化）比numpy更接近熊猫，这很好，因为numpy类型不够强大。例如，NumPy无法以任何方式表示整数数据中的缺失数据（因为type(NaN) == float）。但是大熊猫可以使用Nullable Integer columns。
偶然混合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.
挑战区分字符串和其他python对象
另一个明显的示例示例是，很难区分“字符串”和“对象”。对于任何不支持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
可读性
这是不言自明的；-）
...不。在撰写此答案（1.1版）时，没有性能优势，但是文档预计未来的增强将显着提高性能并减少"string"列（而不是对象）的内存使用。话虽如此，养成良好习惯永远不会太早！
答案 3 :(得分：10)
如果您需要将所有列都转换为字符串，则可以简单地使用：
df = df.astype(str)
如果您需要除几列以外的所有内容作为字符串/对象，然后返回并将其他列转换为所需的内容（在这种情况下为整数），这将非常有用：
df[["D", "E"]] = df[["D", "E"]].astype(int)
答案 4 :(得分：1)
我通常使用这个：
pd['Column'].map(str)
答案 5 :(得分：0)
列转字符串有四种方式
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) 与其余两种技术相比花费的时间更少
答案 6 :(得分：-1)
在这种情况下，也可以将.apply()与lambda转换功能一起使用：
total_rows['ColumnID'] = total_rows['ColumnID'].apply(lambda x: str(x))
对于整个数据框，您可以使用.applymap()。
（但无论如何，.astype()可能会更快）