我想将表示为列表列表的表格转换为Pandas DataFrame. 作为一个极其简化的示例：
a = [['a', '1.2', '4.2'], ['b', '70', '0.03'], ['x', '5', '0']]
df = pd.DataFrame(a)
将列转换为适当类型的最佳方法是什么，在这种情况下，第 2 列和第 3 列转换为浮点数？有没有办法在转换为 DataFrame 时指定类型？还是先创建 DataFrame 然后遍历列以更改每列的类型更好？理想情况下，我想以动态方式执行此操作，因为可能有数百列，我不想准确指定哪些列属于哪种类型。我只能保证每一列都包含相同类型的值。
在 pandas 中转换类型有四个主要选项：
to_numeric()- 提供安全地将非数字类型（例如字符串）转换为合适的数字类型的功能。（另见to_datetime()和to_timedelta()。）
astype()- 将（几乎）任何类型转换为（几乎）任何其他类型（即使这样做不一定明智）。还允许您转换为分类类型（非常有用）。
infer_objects()- 如果可能的话，一种实用方法，用于将保存 Python 对象的对象列转换为 pandas 类型。
convert_dtypes()- 将 DataFrame 列转换为支持的“最佳”dtype pd.NA（pandas 对象以指示缺失值）。
请继续阅读以了解每种方法的更详细说明和用法。
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"])
您还可以使用它通过以下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，或简单地忽略包含这些值的列。
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()将为您提供 anint64或float64dtype （或您的平台本机的任何整数宽度）。
这通常是您想要的，但是如果您想节省一些内存并使用更紧凑的 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
astype()该astype()方法使您能够明确说明您希望 DataFrame 或 Series 具有的 dtype。它非常通用，您可以尝试从一种类型转换为任何其他类型。
只需选择一种类型：您可以使用 NumPy dtype（例如np.int16）、一些 Python 类型（例如 bool）或 pandas 特定的类型（例如 categorical 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 中的值，则会引发错误。例如，如果您有一个NaNorinf值，您将在尝试将其转换为整数时遇到错误。
从 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')而不是向下转换可以帮助防止此错误。
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)改用。
convert_dtypes()1.0 及更高版本包括将 Series 和 DataFrame 列转换为支持缺失值convert_dtypes()的最佳 dtype的方法。pd.NA
这里“最好的”是指最适合保存这些值的类型。例如，这是一个 pandas 整数类型，如果所有值都是整数（或缺失值）：Python 整数对象的对象列转换为Int64NumPyint32值的列，将成为 pandas dtype Int32。
使用我们的objectDataFrame df，我们得到以下结果：
>>> df.convert_dtypes().dtypes
a Int64
b string
dtype: object
由于列 'a' 保存整数值，它被转换为Int64类型（它能够保存缺失值，不像int64）。
列“b”包含字符串对象，因此已更改为 pandas 的stringdtype。
默认情况下，此方法将根据每列中的对象值推断类型。我们可以通过传递来改变它infer_objects=False：
>>> df.convert_dtypes(infer_objects=False).dtypes
a object
b string
dtype: object
现在列 'a' 仍然是一个对象列：pandas 知道它可以被描述为一个 'integer' 列（在内部它运行infer_dtype）但没有准确推断它应该具有什么 dtype 的整数，因此没有转换它。列 'b' 再次转换为 'string' dtype，因为它被识别为保存 'string' 值。
这个怎么样？
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
下面的代码将更改列的数据类型。
df[['col.name1', 'col.name2'...]] = df[['col.name1', 'col.name2'..]].astype('data_type')
代替数据类型，您可以提供数据类型。您想要什么，例如 str、float、int 等。
当我只需要指定特定列并且想要明确时，我使用过（每个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'})
这是一个函数，它接受一个 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'])
这是一张图表，总结了 pandas 中一些最重要的转换。
到字符串的转换是微不足道.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
如何创建两个数据框，每个数据框的列具有不同的数据类型，然后将它们附加在一起？
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
创建数据框后，您可以在第一列中使用浮点变量填充它，在第二列中使用字符串（或您想要的任何数据类型）填充它。
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
这表明您已成功更改列 temp 的数据类型。快乐编码！
df = df.astype({"columnname": str})
#eg - 用于将列类型更改为字符串
从 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
我以为我有同样的问题，但实际上我有一点不同，这使得问题更容易解决。对于其他查看此问题的人，值得检查输入列表的格式。在我的情况下，数字最初是浮动的，而不是问题中的字符串：
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')
实际上确实给出了一个数据框，其中的列格式正确
如果您有各种对象列，例如 74 个对象列和 2 个 Int 列的 Dataframe，其中每个值都有代表单位的字母：
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) 将列数据类型更改为浮点：
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
现在数据集是干净的，您只能使用 regex 和 astype() 对此 Dataframe 进行数字运算。
如果您想收集单位并粘贴在标题上，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)