Pandas-2-2-中文文档-十六-

Pandas 2.2 中文文档（十六）

原文：pandas.pydata.org/docs/

API 参考

原文：pandas.pydata.org/docs/reference/index.html

此页面概述了所有公开的 pandas 对象、函数和方法。pandas.* 命名空间中公开的所有类和函数都是公开的。

以下子包是公开的。

• pandas.errors：由 pandas 引发的自定义异常和警告类。

• pandas.plotting：绘图公共 API。

• pandas.testing：用于编写涉及 pandas 对象的测试的函数。

• pandas.api.extensions：用于扩展 pandas 对象的函数和类。

• pandas.api.indexers：滚动窗口索引器的函数和类。

• pandas.api.interchange：DataFrame 互换协议。

• pandas.api.types：数据类型类和函数。

• pandas.api.typing：可能需要用于类型提示的类。这些是用户遇到的中间结果类，但不应由用户直接实例化。不要将这些类与 pandas-stubs 包中的类混淆，后者除了 pandas 中出现的类外还包含用于类型提示的类。

此外，文档中还提到了 pandas.io 和 pandas.tseries 子模块中的公共函数。

警告

pandas.core、pandas.compat 和 pandas.util 顶级模块是私有的。不保证此类模块中的稳定功能。

• 输入/输出

  • 序列化

  • 平面文件

  • 剪贴板

  • Excel

  • JSON

  • HTML

  • XML

  • Latex

  • HDFStore: PyTables (HDF5)

  • 羽毛

  • Parquet

  • ORC

  • SAS

  • SPSS

  • SQL

  • Google BigQuery

  • STATA

• 常用函数

  • 数据操作

  • 顶级缺失数据

  • 顶级处理数值数据

  • 顶级处理日期时间数据

  • 顶级处理区间数据

  • 顶级评估

  • 日期时间格式

  • 散列

  • 从其他 DataFrame 库导入

• 系列

  • 构造函数

  • 属性

  • 转换

  • 索引、迭代

  • 二元运算符函数

  • 函数应用、GroupBy 和窗口

  • 计算/描述性统计

  • 重新索引/选择/标签操作

  • 缺失数据处理

  • 重塑、排序

  • 组合/比较/连接/合并

  • 与时间序列相关

  • 访问器

  • 绘图

  • 序列化/IO/转换

• 数据帧

  • 构造函数

  • 属性和底层数据

  • 转换

  • 索引、迭代

  • 二进制运算函数

  • 函数应用、GroupBy 和窗口

  • 计算/描述性统计

  • 重新索引/选择/标签操作

  • 缺失数据处理

  • 重塑、排序、转置

  • 组合/比较/连接/合并

  • 与时间序列相关

  • 标志

  • 元数据

  • 绘图

  • 稀疏访问器

  • 序列化/IO/转换

• pandas 数组、标量和数据类型

  • 对象

  • 实用工具

• 索引对象

  • 索引

  • 数值索引

  • 分类索引

  • 区间索引

  • MultiIndex

  • DatetimeIndex

  • TimedeltaIndex

  • PeriodIndex

• 日期偏移

  • 日期偏移

  • 工作日

  • BusinessHour

  • CustomBusinessDay

  • CustomBusinessHour

  • MonthEnd

  • MonthBegin

  • BusinessMonthEnd

  • BusinessMonthBegin

  • CustomBusinessMonthEnd

  • CustomBusinessMonthBegin

  • SemiMonthEnd

  • SemiMonthBegin

  • Week

  • WeekOfMonth

  • LastWeekOfMonth

  • BQuarterEnd

  • BQuarterBegin

  • QuarterEnd

  • QuarterBegin

  • BYearEnd

  • BYearBegin

  • YearEnd

  • YearBegin

  • FY5253

  • FY5253Quarter

  • Easter

  • Tick

  • Day

  • Hour

  • Minute

  • Second

  • Milli

  • Micro

  • Nano

• 频率

  • pandas.tseries.frequencies.to_offset

• 窗口

  • 滚动窗口函数

  • 加权窗口函数

  • 扩展窗口函数

  • 指数加权窗口函数

  • 窗口索引器

• GroupBy

  • 索引，迭代

  • 函数应用助手

  • 函数应用

  • DataFrameGroupBy 计算 / 描述统计

  • SeriesGroupBy 计算 / 描述统计

  • 绘图和可视化

• 重新采样

  • 索引，迭代

  • 函数应用

  • 上采样

  • 计算 / 描述统计

• 样式

  • Styler 构造函数

  • Styler 属性

  • 样式应用

  • 内置样式

  • 样式导出和导入

• 绘图

  • pandas.plotting.andrews_curves

  • pandas.plotting.autocorrelation_plot

  • pandas.plotting.bootstrap_plot

  • pandas.plotting.boxplot

  • pandas.plotting.deregister_matplotlib_converters

  • pandas.plotting.lag_plot

  • pandas.plotting.parallel_coordinates

  • pandas.plotting.plot_params

  • pandas.plotting.radviz

  • pandas.plotting.register_matplotlib_converters

  • pandas.plotting.scatter_matrix

  • pandas.plotting.table

• 选项和设置

  • 处理选项

  • 数字格式化

• 扩展

  • pandas.api.extensions.register_extension_dtype

  • pandas.api.extensions.register_dataframe_accessor

  • pandas.api.extensions.register_series_accessor

  • pandas.api.extensions.register_index_accessor

  • pandas.api.extensions.ExtensionDtype

  • pandas.api.extensions.ExtensionArray

  • pandas.arrays.NumpyExtensionArray

  • pandas.api.indexers.check_array_indexer

• 测试

  • 断言函数

  • 异常和警告

  • 错误报告函数

  • 测试套件运行器

• 缺失值

  • pandas.NA

  • pandas.NaT

输入/输出

原文：pandas.pydata.org/docs/reference/io.html

Pickling

read_pickle(filepath_or_buffer[, ...])	从文件中加载经过 pickling 的 pandas 对象（或任何对象）。
DataFrame.to_pickle(path, *[, compression, ...])	将对象 pickling（序列化）到文件。

平面文件

read_table(filepath_or_buffer, *[, sep, ...])	将通用分隔文件读入 DataFrame。
read_csv(filepath_or_buffer, *[, sep, ...])	将逗号分隔值（csv）文件读入 DataFrame。
DataFrame.to_csv([path_or_buf, sep, na_rep, ...])	将对象写入逗号分隔值（csv）文件。
read_fwf(filepath_or_buffer, *[, colspecs, ...])	将固定宽度格式的表格行读入 DataFrame。

剪贴板

read_clipboard([sep, dtype_backend])	从剪贴板读取文本并传递给read_csv()。
DataFrame.to_clipboard(*[, excel, sep])	将对象复制到系统剪贴板。

Excel

read_excel(io[, sheet_name, header, names, ...])	将 Excel 文件读入pandas DataFrame。
DataFrame.to_excel(excel_writer, *[, ...])	将对象写入 Excel 表格。
ExcelFile(path_or_buffer[, engine, ...])	用于将表格化的 Excel 表格解析为 DataFrame 对象的类。
ExcelFile.book
ExcelFile.sheet_names
ExcelFile.parse([sheet_name, header, names, ...])	将指定的工作表解析为 DataFrame。
Styler.to_excel(excel_writer[, sheet_name, ...])	将 Styler 写入 Excel 表格。
ExcelWriter(path[, engine, date_format, ...])	用于将 DataFrame 对象写入 Excel 表格的类。

JSON

read_json(path_or_buf, *[, orient, typ, ...])	将 JSON 字符串转换为 pandas 对象。
json_normalize(data[, record_path, meta, ...])	将半结构化的 JSON 数据规范化为平面表格。
DataFrame.to_json([path_or_buf, orient, ...])	将对象转换为 JSON 字符串。
build_table_schema(data[, index, ...])	从 data 创建表模式。

HTML

read_html(io, *[, match, flavor, header, ...])	将 HTML 表格读取为 DataFrame 对象的 list。
DataFrame.to_html([buf, columns, col_space, ...])	将 DataFrame 渲染为 HTML 表格。
Styler.to_html([buf, table_uuid, ...])	将 Styler 写入文件、缓冲区或以 HTML-CSS 格式的字符串。

XML

read_xml(path_or_buffer, *[, xpath, ...])	将 XML 文档读取为 DataFrame 对象。
DataFrame.to_xml([path_or_buffer, index, ...])	将 DataFrame 渲染为 XML 文档。

Latex

DataFrame.to_latex([buf, columns, header, ...])	将对象渲染为 LaTeX 表格、长表格或嵌套表格。
Styler.to_latex([buf, column_format, ...])	将 Styler 写入文件、缓冲区或以 LaTeX 格式的字符串。

HDFStore: PyTables (HDF5)

read_hdf(path_or_buf[, key, mode, errors, ...])	从存储中读取，如果打开则关闭。
HDFStore.put(key, value[, format, index, ...])	将对象存储在 HDFStore 中。
HDFStore.append(key, value[, format, axes, ...])	在文件中的表格中追加。
HDFStore.get(key)	从文件中检索存储的 pandas 对象。
HDFStore.select(key[, where, start, stop, ...])	检索存储在文件中的 pandas 对象，可选地基于 where 条件。
HDFStore.info()	打印存储的详细信息。
HDFStore.keys([include])	返回与 HDFStore 中存储的对象对应的键列表。
HDFStore.groups()	返回所有顶级节点的列表。
HDFStore.walk([where])	遍历 pandas 对象的 pytables 组层次结构。

警告

可以将 DataFrame 或 Series 的子类存储到 HDF5，但子类的类型在存储时会丢失。

Feather

read_feather(path[, columns, use_threads, ...])	从文件路径加载 feather 格式对象。
DataFrame.to_feather(path, **kwargs)	将 DataFrame 写入二进制 Feather 格式。

Parquet

read_parquet(path[, engine, columns, ...])	从文件路径加载 parquet 对象，返回一个 DataFrame。
DataFrame.to_parquet([path, engine, ...])	将 DataFrame 写入二进制 parquet 格式。

ORC

read_orc(path[, columns, dtype_backend, ...])	从文件路径加载 ORC 对象，返回一个 DataFrame。
DataFrame.to_orc([path, engine, index, ...])	将 DataFrame 写入 ORC 格式。

SAS

read_sas(filepath_or_buffer, *[, format, ...])	读取存储为 XPORT 或 SAS7BDAT 格式文件的 SAS 文件。

SPSS

read_spss(path[, usecols, ...])	从文件路径加载 SPSS 文件，返回一个 DataFrame。

SQL

read_sql_table(table_name, con[, schema, ...])	将 SQL 数据库表读取为 DataFrame。
read_sql_query(sql, con[, index_col, ...])	将 SQL 查询读取为 DataFrame。
read_sql(sql, con[, index_col, ...])	将 SQL 查询或数据库表读取到 DataFrame 中。
DataFrame.to_sql(name, con, *[, schema, ...])	将存储在 DataFrame 中的记录写入 SQL 数据库。

谷歌大查询

read_gbq(query[, project_id, index_col, ...])	（已弃用）从谷歌大查询加载数据。

STATA

read_stata(filepath_or_buffer, *[, ...])	将 Stata 文件读取到 DataFrame 中。
DataFrame.to_stata(path, *[, convert_dates, ...])	将 DataFrame 对象导出为 Stata dta 格式。
StataReader.data_label	返回 Stata 文件的数据标签。
StataReader.value_labels()	返回一个嵌套字典，将每个变量名与其值和标签关联。
StataReader.variable_labels()	返回一个将每个变量名与相应标签关联的字典。
StataWriter.write_file()	将 DataFrame 对象导出为 Stata dta 格式。

Pickling

read_pickle(filepath_or_buffer[, ...])	从文件中加载经过 Pickle 处理的 pandas 对象（或任何对象）。
DataFrame.to_pickle(path, *[, compression, ...])	将对象序列化（Pickle）到文件。

平面文件

read_table(filepath_or_buffer, *[, sep, ...])	将通用分隔文件读取到 DataFrame 中。
read_csv(filepath_or_buffer, *[, sep, ...])	将逗号分隔值（csv）文件读取到 DataFrame 中。
DataFrame.to_csv([path_or_buf, sep, na_rep, ...])	将对象写入逗号分隔值（csv）文件。
read_fwf(filepath_or_buffer, *[, colspecs, ...])	将固定宽度格式行的表读取到 DataFrame 中。

剪贴板

read_clipboard([sep, dtype_backend])	从剪贴板读取文本并传递给 read_csv()。
DataFrame.to_clipboard(*[, excel, sep])	将对象复制到系统剪贴板。

Excel

read_excel(io[, sheet_name, header, names, ...])	将 Excel 文件读取为 pandas DataFrame。
DataFrame.to_excel(excel_writer, *[, ...])	将对象写入 Excel 表格。
ExcelFile(path_or_buffer[, engine, ...])	用于将表格形式的 Excel 表格解析为 DataFrame 对象的类。
ExcelFile.book
ExcelFile.sheet_names
ExcelFile.parse([sheet_name, header, names, ...])	将指定的工作表解析为 DataFrame。
Styler.to_excel(excel_writer[, sheet_name, ...])	将 Styler 写入 Excel 表格。
ExcelWriter(path[, engine, date_format, ...])	用于将 DataFrame 对象写入 Excel 表格的类。

JSON

read_json(path_or_buf, *[, orient, typ, ...])	将 JSON 字符串转换为 pandas 对象。
json_normalize(data[, record_path, meta, ...])	将半结构化的 JSON 数据规范化为平面表。
DataFrame.to_json	将对象转换为 JSON 字符串。
build_table_schema(data[, index, ...])	从 data 创建一个表模式。

HTML

read_html(io, *[, match, flavor, header, ...])	将 HTML 表格读取为 DataFrame 对象的 list。
DataFrame.to_html([buf, columns, col_space, ...])	将 DataFrame 渲染为 HTML 表格。
Styler.to_html([buf, table_uuid, ...])	将 Styler 写入文件、缓冲��或字符串，格式为 HTML-CSS。

XML

read_xml(path_or_buffer, *[, xpath, ...])	将 XML 文档读取为DataFrame对象。
DataFrame.to_xml([path_or_buffer, index, ...])	将 DataFrame 呈现为 XML 文档。

Latex

DataFrame.to_latex([buf, columns, header, ...])	将对象呈现为 LaTeX 表格、长表格或嵌套表格。
Styler.to_latex([buf, column_format, ...])	将 Styler 写入文件、缓冲区或字符串，格式为 LaTeX。

HDFStore: PyTables (HDF5)

read_hdf(path_or_buf[, key, mode, errors, ...])	从存储中读取数据，如果打开了存储，则关闭它。
HDFStore.put(key, value[, format, index, ...])	将对象存储在 HDFStore 中。
HDFStore.append(key, value[, format, axes, ...])	追加到文件中的表格。
HDFStore.get(key)	检索存储在文件中的 pandas 对象。
HDFStore.select(key[, where, start, stop, ...])	检索存储在文件中的 pandas 对象，可选地基于 where 条件。
HDFStore.info()	打印存储的详细信息。
HDFStore.keys([include])	返回存储在 HDFStore 中的对象对应的键列表。
HDFStore.groups()	返回所有顶级节点的列表。
HDFStore.walk([where])	遍历 pytables 组层次结构以查找 pandas 对象。

警告

可以将DataFrame或Series的子类存储到 HDF5 中，但子类的类型在存储时会丢失。

Feather

read_feather(path[, columns, use_threads, ...])	从文件路径加载 feather 格式对象。
DataFrame.to_feather(path, **kwargs)	将 DataFrame 写入二进制 Feather 格式。

Parquet

read_parquet(path[, engine, columns, ...])	从文件路径加载 parquet 对象，返回一个 DataFrame。
DataFrame.to_parquet([path, engine, ...])	将 DataFrame 写入二进制 parquet 格式。

ORC

read_orc(path[, columns, dtype_backend, ...])	从文件路径加载 ORC 对象，返回一个 DataFrame。
DataFrame.to_orc([path, engine, index, ...])	将 DataFrame 写入 ORC 格式。

SAS

read_sas(filepath_or_buffer, *[, format, ...])	读取存储为 XPORT 或 SAS7BDAT 格式文件的 SAS 文件。

SPSS

read_spss(path[, usecols, ...])	从文件路径加载 SPSS 文件，返回一个 DataFrame。

SQL

read_sql_table(table_name, con[, schema, ...])	将 SQL 数据库表读取为 DataFrame。
read_sql_query(sql, con[, index_col, ...])	将 SQL 查询读取为 DataFrame。
read_sql(sql, con[, index_col, ...])	将 SQL 查询或数据库表读取为 DataFrame。
DataFrame.to_sql(name, con, *[, schema, ...])	将存储在 DataFrame 中的记录写入 SQL 数据库。

Google BigQuery

read_gbq(query[, project_id, index_col, ...])	(已弃用) 从 Google BigQuery 加载数据。

STATA

read_stata(filepath_or_buffer, *[, ...])	将 Stata 文件读取为 DataFrame。
DataFrame.to_stata(path, *[, convert_dates, ...])	将 DataFrame 对象导出为 Stata dta 格式。
StataReader.data_label	返回 Stata 文件的数据标签。
StataReader.value_labels()	返回一个嵌套字典，将每个变量名与其值和标签关联起来。
StataReader.variable_labels()	返回一个将每个变量名与相应标签关联起来的字典。
StataWriter.write_file()	将 DataFrame 对象导出为 Stata dta 格式。

pandas.read_pickle

原文：pandas.pydata.org/docs/reference/api/pandas.read_pickle.html

pandas.read_pickle(filepath_or_buffer, compression='infer', storage_options=None)

从文件加载腌制的 pandas 对象（或任何对象）。

警告

从不受信任的来源加载腌制数据可能不安全。请参见这里。

参数：

filepath_or_bufferstr、路径对象或类文件对象

字符串、路径对象（实现 os.PathLike[str]）或实现二进制 readlines() 函数的类文件对象。也接受 URL。URL 不限于 S3 和 GCS。

compressionstr 或 dict，默认为 ‘infer’

用于在磁盘数据上进行即时解压缩。如果 ‘infer’ 并且 ‘filepath_or_buffer’ 是类似路径的对象，则从以下扩展名检测压缩：‘.gz’、‘.bz2’、‘.zip’、‘.xz’、‘.zst’、‘.tar’、‘.tar.gz’、‘.tar.xz’ 或 ‘.tar.bz2’（否则不压缩）。如果使用 'zip' 或 'tar'，ZIP 文件必须只包含一个要读取的数据文件。设置为 None 以不进行解压缩。也可以是一个字典，其中键 'method' 设置为其中之一 {'zip'、'gzip'、'bz2'、'zstd'、'xz'、'tar'}，其他键值对将转发到 zipfile.ZipFile、gzip.GzipFile、bz2.BZ2File、zstandard.ZstdDecompressor、lzma.LZMAFile 或 tarfile.TarFile。例如，以下内容可用于通过自定义压缩字典进行 Zstandard 解压缩：compression={'method': 'zstd', 'dict_data': my_compression_dict}。

1.5.0 版本新增：增加了对 .tar 文件的支持。

1.4.0 版本更改：增加了 Zstandard 支持。

storage_optionsdict，可选

适用于特定存储连接的额外选项，例如主机、端口、用户名、密码等。对于 HTTP(S) URL，键值对将作为标头选项转发到 urllib.request.Request。对于其他 URL（例如以 “s3://” 和 “gcs://” 开头的 URL），键值对将转发到 fsspec.open。请参阅 fsspec 和 urllib 了解更多详细信息，并查看有关存储选项的更多示例，请参考这里。

返回：

与文件中存储的对象相同类型

另请参阅

DataFrame.to_pickle

将 DataFrame 对象腌制（序列化）到文件。

Series.to_pickle

将 Series 对象腌制（序列化）到文件。

read_hdf

读取 HDF5 文件到 DataFrame。

read_sql

读取 SQL 查询或数据库表到 DataFrame。

read_parquet

加载 parquet 对象，返回一个 DataFrame。

注意事项

read_pickle 仅在对象使用 to_pickle 序列化时才保证向后兼容到 pandas 0.20.3。

示例

>>> original_df = pd.DataFrame(
...     {"foo": range(5), "bar": range(5, 10)}
...    )  
>>> original_df  
 foo  bar
0    0    5
1    1    6
2    2    7
3    3    8
4    4    9
>>> pd.to_pickle(original_df, "./dummy.pkl") 

>>> unpickled_df = pd.read_pickle("./dummy.pkl")  
>>> unpickled_df  
 foo  bar
0    0    5
1    1    6
2    2    7
3    3    8
4    4    9 

pandas.DataFrame.to_pickle

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_pickle.html

DataFrame.to_pickle(path, *, compression='infer', protocol=5, storage_options=None)

将对象序列化为文件。

参数：

pathstr, path object, or file-like object

字符串、路径对象（实现了os.PathLike[str]）或实现了二进制write()函数的文件对象。要存储 pickled 对象的文件路径。

compressionstr or dict, default ‘infer’

用于输出数据的即时压缩。如果是'infer'并且'path'是路径形式的，则从以下扩展名检测压缩：'.gz'、'.bz2'、'.zip'、'.xz'、'.zst'、'.tar'、'.tar.gz'、'.tar.xz'或'.tar.bz2'（否则不压缩）。设置为None以不压缩。也可以是一个字典，其中键'method'设置为其中一个{'zip'、'gzip'、'bz2'、'zstd'、'xz'、'tar'}，其他键值对将转发到zipfile.ZipFile、gzip.GzipFile、bz2.BZ2File、zstandard.ZstdCompressor、lzma.LZMAFile或tarfile.TarFile。例如，可以传递以下内容以进行更快的压缩并创建可重现的 gzip 存档：compression={'method': 'gzip', 'compresslevel': 1, 'mtime': 1}。

1.5.0 版本新增支持.tar 文件。

protocolint

指示 pickler 应使用的协议，默认为 HIGHEST_PROTOCOL（参见[1]第 12.1.2 段）。可能的值为 0、1、2、3、4、5。将协议参数设置为负值等效于将其值设置为 HIGHEST_PROTOCOL。

[1]

docs.python.org/3/library/pickle.html.

storage_optionsdict, optional

特定存储连接的额外选项，例如主机、端口、用户名、密码等。对于 HTTP(S) URL，键值对将作为标头选项转发到urllib.request.Request。对于其他 URL（例如以“s3://”和“gcs://”开头的 URL），键值对将转发到fsspec.open。请参阅fsspec和urllib获取更多详情，并参考这里中有关存储选项的更多示例。

另请参阅

read_pickle

从文件中加载 pickle 的 pandas 对象（或任何对象）。

DataFrame.to_hdf

将 DataFrame 写入 HDF5 文件。

DataFrame.to_sql

将 DataFrame 写入 SQL 数据库。

DataFrame.to_parquet

将 DataFrame 写入二进制 Parquet 格式。

示例

>>> original_df = pd.DataFrame({"foo": range(5), "bar": range(5, 10)})  
>>> original_df  
 foo  bar
0    0    5
1    1    6
2    2    7
3    3    8
4    4    9
>>> original_df.to_pickle("./dummy.pkl") 

>>> unpickled_df = pd.read_pickle("./dummy.pkl")  
>>> unpickled_df  
 foo  bar
0    0    5
1    1    6
2    2    7
3    3    8
4    4    9 

pandas.read_table

原文：pandas.pydata.org/docs/reference/api/pandas.read_table.html

pandas.read_table(filepath_or_buffer, *, sep=_NoDefault.no_default, delimiter=None, header='infer', names=_NoDefault.no_default, index_col=None, usecols=None, dtype=None, engine=None, converters=None, true_values=None, false_values=None, skipinitialspace=False, skiprows=None, skipfooter=0, nrows=None, na_values=None, keep_default_na=True, na_filter=True, verbose=_NoDefault.no_default, skip_blank_lines=True, parse_dates=False, infer_datetime_format=_NoDefault.no_default, keep_date_col=_NoDefault.no_default, date_parser=_NoDefault.no_default, date_format=None, dayfirst=False, cache_dates=True, iterator=False, chunksize=None, compression='infer', thousands=None, decimal='.', lineterminator=None, quotechar='"', quoting=0, doublequote=True, escapechar=None, comment=None, encoding=None, encoding_errors='strict', dialect=None, on_bad_lines='error', delim_whitespace=_NoDefault.no_default, low_memory=True, memory_map=False, float_precision=None, storage_options=None, dtype_backend=_NoDefault.no_default)

将通用分隔文件读入 DataFrame。

还支持可选地迭代或将文件分成块。

额外的帮助可以在IO 工具的在线文档中找到。

参数：

filepath_or_bufferstr，路径对象或类文件对象

任何有效的字符串路径都可以接受。字符串可以是 URL。有效的 URL 方案包括 http、ftp、s3、gs 和 file。对于文件 URL，期望有一个主机。本地文件可以是：file://localhost/path/to/table.csv。

如果要传递路径对象，pandas 接受任何os.PathLike。

通过类文件对象，我们指的是具有read()方法的对象，例如文件句柄（例如通过内置的open函数）或StringIO。

sepstr，默认为‘\t’（制表符）

要视为分隔符的字符或正则表达式模式。如果sep=None，则 C 引擎无法自动检测分隔符，但 Python 解析引擎可以，这意味着将使用后者，并且 Python 的内置嗅探工具csv.Sniffer将仅从文件的第一行自动检测分隔符。此外，长度大于 1 个字符且不同于'\s+'的分隔符将被解释为正则表达式，并且还将强制使用 Python 解析引擎。请注意，正则表达式分隔符容易忽略带引号的数据。正则表达式示例：'\r\t'。

delimiterstr，可选

sep的别名。

headerint，int 序列，‘infer’或 None，默认为‘infer’

包含列标签并标记数据起始位置的行号（从零开始索引）。默认行为是推断列名：如果没有传递names，则行为与header=0相同，并且列名从文件的第一行推断出来；如果列名明确传递给names，则行为与header=None相同。显式传递header=0以替换现有名称。标题可以是指定列的MultiIndex的行位置的整数列表，例如[0, 1, 3]。未指定的中间行将被跳过（例如，在此示例中跳过了 2）。请注意，如果skip_blank_lines=True，此参数将忽略注释行和空行，因此header=0表示数据的第一行而不是文件的第一行。

namesHashable 序列，可选

要应用的列标签序列。如果文件包含标题行，则应明确传递header=0以覆盖列名。此列表中不允许重复项。

index_colHashable，Hashable 序列或 False，可选

作为行标签使用的列，标记为列标签或列索引。如果给出一系列标签或索引，将为行标签形成 MultiIndex。

注意：index_col=False 可以用来强制 pandas 不 将第一列用作索引，例如，当您有一个每行末尾都有分隔符的格式错误文件时。

usecols可哈希序列或可调用对象，可选

要选择的列的子集，标记为列标签或列索引。如果类似列表，所有元素必须是位置的（即整数索引到文档列）或字符串，这些字符串对应于用户在 names 中提供的列名，或者从文档头行（s）中推断出的列名。如果给出了 names，则不考虑文档头行（s）。例如，一个有效的类似列表的 usecols 参数将是 [0, 1, 2] 或 ['foo', 'bar', 'baz']。元素顺序被忽略，所以 usecols=[0, 1] 和 [1, 0] 是相同的。要保留元素顺序的 DataFrame 实例化，请使用 pd.read_csv(data, usecols=['foo', 'bar'])[['foo', 'bar']] 来按照 ['foo', 'bar'] 顺序的列或 pd.read_csv(data, usecols=['foo', 'bar'])[['bar', 'foo']] 为 ['bar', 'foo'] 顺序。

如果可调用，将根据列名评估可调用函数，返回可调用函数评估为 True 的名称。一个有效的可调用参数示例是 lambda x: x.upper() in ['AAA', 'BBB', 'DDD']。使用此参数会导致更快的解析时间和更低的内存使用。

dtypedtype 或 {可哈希 dtype} 字典，可选

要应用于整个数据集或单个列的数据类型。例如，{'a': np.float64, 'b': np.int32, 'c': 'Int64'} 使用 str 或 object 与合适的 na_values 设置一起来保留并不解释 dtype。如果指定了 converters，它们将被应用于 INSTEAD 的 dtype 转换。

自版本 1.5.0 新增：添加了对 defaultdict 的支持。指定一个 defaultdict 作为输入，其中默认值确定了未显式列出的列的 dtype。

engine，可选

要使用的解析引擎。C 和 pyarrow 引擎更快，而 python 引擎目前更完整。多线程目前只由 pyarrow 引擎支持。

自版本 1.4.0 新增：将‘pyarrow’引擎添加为 实验性 引擎，并且某些功能不受支持，或者可能不正确地使用此引擎。

converters 字典，可选

用于转换指定列中值的函数。键可以是列标签或列索引。

true_values列表，可选

除了大小写变体的True之外，还考虑为 True 的值。

false_values列表，可选

除了大小写变体的False之外，还考虑为 False 的值。

skipinitialspacebool，默认为 False

在分隔符后跳过空格。

skiprowsint，int 列表或可调用，可选

要跳过的行号（从 0 开始）或文件开头要跳过的行数（int）。

如果是可调用的，可调用函数将根据行索引进行评估，如果应跳过该行则返回True，否则返回False。一个有效的可调用参数示例是lambda x: x in [0, 2]。

skipfooterint，默认为 0

要跳过的文件底部行数（使用engine='c'时不支持）。

nrowsint，可选

要读取的文件行数。用于读取大文件的片段。

na_values可哈希，可迭代的可哈希或{可哈希迭代}的字典，可选

附加的字符串以识别为NA/NaN。如果传递了dict，则特定于每列的NA值。默认情况下，以下值被解释为NaN：“ “, “#N/A”, “#N/A N/A”, “#NA”, “-1.#IND”, “-1.#QNAN”, “-NaN”, “-nan”, “1.#IND”, “1.#QNAN”, “”, “N/A”, NA, “NULL”, NaN, “None”, “n/a”, “nan”, “null”。

keep_default_nabool，默认为 True

是否在解析数据时包括默认的NaN值。根据是否传入na_values，行为如下：

• 如果keep_default_na为True，并且指定了na_values，则将na_values附加到用于解析的默认NaN值。

• 如果keep_default_na为True，并且未指定na_values，则仅使用默认的NaN值进行解析。

• 如果keep_default_na为False，并且指定了na_values，则仅使用指定的na_values值进行解析。

• 如果keep_default_na为False，并且未指定na_values，则不会将任何字符串解析为NaN。

请注意，如果将na_filter传递为False，则将忽略keep_default_na和na_values参数。

na_filterbool，默认为 True

检测缺失值标记（空字符串和na_values的值）。在没有任何NA值的数据中，传递na_filter=False可以提高读取大文件的性能。

verbosebool，默认为 False

指示放置在非数字列中的NA值的数量。

自版本 2.2.0 起已弃用。

skip_blank_linesbool，默认为 True

如果为True，则跳过空行而不解释为NaN值。

parse_datesbool，可哈希列表，列表的列表或{哈希列表}的字典，默认为 False

行为如下：

• bool。如果为True -> 尝试解析索引。注意：如果传递了date_format或date_parser参数，则会自动设置为True。

• int或名称的list。例如，如果[1, 2, 3] -> 尝试将列 1、2、3 分别解析为单独的日期列。

• list的list。例如，如果[[1, 3]] -> 将列 1 和 3 合并并解析为单个日期列。在解析之前，值用空格连接。

• dict，例如{'foo' : [1, 3]} -> 将列 1、3 解析为日期并称为‘foo’。在解析之前，值用空格连接。

如果某列或索引无法表示为datetime数组，比如因为存在无法解析的值或时区混合，该列或索引将以object数据类型不变返回。对于非标准的datetime解析，请在read_csv()之后使用to_datetime()。

注意：存在用于 iso8601 格式日期的快速路径。

infer_datetime_formatbool，默认为 False

如果True并且启用了parse_dates，pandas 将尝试推断列中datetime字符串的格式，如果可以推断出来，将切换到更快的解析方法。在某些情况下，这可以将解析速度提高 5-10 倍。

自版本 2.0.0 起弃用：严格版本的此参数现在是默认的，传递它没有任何效果。

keep_date_colbool，默认为 False

如果True并且parse_dates指定了合并多个列，则保留原始列。

date_parser可调用对象，可选

用于将一系列字符串列转换为datetime实例数组的函数。默认使用dateutil.parser.parser进行转换。pandas 将尝试以三种不同的方式调用date_parser，如果发生异常，则继续下一个：1) 将一个或多个数组（由parse_dates定义）作为参数传递；2) 将由parse_dates定义的列中的字符串值（按行连接）合并为单个数组并传递；3) 对每一行使用一个或多个字符串（对应于由parse_dates定义的列）调用date_parser。

自版本 2.0.0 起弃用：改用date_format，或者读取为object，然后根据需要应用to_datetime()。

date_formatstr 或列->格式的字典，可选

与parse_dates结合使用时用于解析日期的格式。解析时间的 strftime，例如"%d/%m/%Y"。有关更多选择的信息，请参阅strftime 文档，尽管请注意"%f"将解析直到纳秒。你也可以传递：

• “ISO8601”，解析任何ISO8601

  时间字符串（不一定完全相同的格式）；

• “mixed”，为了单独推断每个元素的格式。这是有风险的，

  你可能应该与 dayfirst 一起使用它。

版本 2.0.0 中的新功能。

dayfirstbool，默认为 False

DD/MM 格式日期，国际和欧洲格式。

cache_datesbool，默认为 True

如果True，使用唯一的转换日期缓存来应用datetime转换。在解析重复日期字符串时可能会产生显著的加速，特别是带有时区偏移的日期字符串。

iteratorbool，默认为 False

返回用于迭代或使用get_chunk()获取块的TextFileReader对象。

chunksizeint，可选

从文件中每块读取的行数。传递一个值会导致函数返回一个 TextFileReader 对象以进行迭代。有关 iterator 和 chunksize 的更多信息，请参阅 IO 工具文档。

compressionstr 或 dict，默认为 ‘infer’

用于在磁盘上的数据的即时解压缩。如果‘infer’并且‘filepath_or_buffer’是类似路径的，则从以下扩展名检测压缩：‘.gz’、‘.bz2’、‘.zip’、‘.xz’、‘.zst’、‘.tar’、‘.tar.gz’、‘.tar.xz’或‘.tar.bz2’（否则不压缩）。如果使用'zip'或'tar'，ZIP 文件必须只包含一个要读取的数据文件。设置为 None 不进行解压缩。也可以是一个字典，其中键 'method' 设置为其中一个 {'zip'、'gzip'、'bz2'、'zstd'、'xz'、'tar'}，其他键值对被转发到 zipfile.ZipFile、gzip.GzipFile、bz2.BZ2File、zstandard.ZstdDecompressor、lzma.LZMAFile 或 tarfile.TarFile。例如，可以通过以下方式传递用于 Zstandard 解压缩的自定义压缩字典：compression={'method': 'zstd', 'dict_data': my_compression_dict}。

1.5.0 版本中的新功能：增加了对.tar 文件的支持。

在 1.4.0 版本中更改：增加了对 Zstandard 的支持。

thousandsstr（长度为 1），可选

数值中的千位分隔符。

decimalstr（长度为 1），默认为 ‘.’

将作为十进制点识别的字符（例如，使用‘，’表示欧洲数据）。

lineterminatorstr（长度为 1），可选

用于表示换行的字符。只有与 C 解析器一起使用时才有效。

quotecharstr（长度为 1），可选

用于表示引用项目的开始和结束的字符。引用项目可以包括 delimiter，并且将被忽略。

quoting，默认为 csv.QUOTE_MINIMAL

控制字段引号行为的 csv.QUOTE_* 常量。默认为 csv.QUOTE_MINIMAL（即，0），表示仅引用包含特殊字符的字段（例如，在 quotechar、delimiter 或 lineterminator 中定义的字符）。

doublequotebool，默认为 True

当指定了 quotechar 且 quoting 不是 QUOTE_NONE 时，指示是否将字段内连续的两个 quotechar 元素解释为单个 quotechar 元素。

escapecharstr（长度为 1），可选

用于转义其他字符的字符。

commentstr（长度为 1），可选

表示应不解析行剩余部分的字符。如果在行的开头找到，将完全忽略该行。此参数必须是单个字符。与空行一样（只要 skip_blank_lines=True），完全被注释的行由参数 header 忽略，但不由 skiprows 忽略。例如，如果 comment='#'，使用 header=0 解析 #empty\na,b,c\n1,2,3 将导致 'a,b,c' 被视为标题。

encodingstr，可选，默认为 ‘utf-8’

读取/写入 UTF 时要使用的编码（例如。'utf-8'）。Python 标准编码列表。

encoding_errorsstr，可选，默认为‘strict’

如何处理编码错误。可能值列表。

从版本 1.3.0 开始的新功能。

dialectstr 或 csv.Dialect，可选

如果提供，此参数将覆盖以下参数的值（默认或非默认）：delimiter，doublequote，escapechar，skipinitialspace，quotechar 和 quoting。如果需要覆盖值，则将发出ParserWarning。有关更多详细信息，请参阅 csv.Dialect 文档。

on_bad_lines 或 Callable，默认为‘error’

指定在遇到错误行（字段过多的行）时要执行的操作。允许的值有：

• 'error'，当遇到错误行时引发异常。

• 'warn'，在遇到错误行时引发警告并跳过该行。

• 'skip'，在遇到错误行时跳过，而不引发或警告。

从版本 1.3.0 开始的新功能。

从版本 1.4.0 开始的新功能：

• 可调用函数，具有签名 (bad_line: list[str]) -> list[str] | None，将处理单个错误行。bad_line是由sep分割的字符串列表。如果函数返回None，则会忽略错误行。如果函数返回具有比预期更多元素的新的字符串list，则会发出ParserWarning，同时删除额外的元素。仅在engine='python'时受支持。

从版本 2.2.0 开始更改：

• 当engine='pyarrow'时，具有如pyarrow 文档中描述的签名的可调用函数。

delim_whitespacebool，默认为 False

指定是否使用空白字符（例如。' '或'\t'）作为sep分隔符。等效于设置sep='\s+'。如果将此选项设置为True，则不应传递任何内容给delimiter参数。

自版本 2.2.0 起弃用：请改用sep="\s+"。

low_memorybool，默认为 True

将文件分块内部处理，以降低解析时的内存使用，但可能导致混合类型推断。为了确保没有混合类型，要么设置为False，要么使用dtype参数指定类型。请注意，无论如何整个文件都会被读入单个DataFrame中，可以使用chunksize或iterator参数以块返回数据。（仅在 C 解析器中有效）。

memory_mapbool，默认为 False

如果为filepath_or_buffer提供了文件路径，则将文件对象直接映射到内存中，并直接从中访问数据。使用此选项可以提高性能，因为不再有任何 I/O 开销。

float_precision，可选

指定 C 引擎应使用哪个转换器处理浮点值。选项为None或'high'表示普通转换器，'legacy'表示原始较低精度的 pandas 转换器，'round_trip'表示往返转换器。

storage_options字典，可选

针对特定存储连接有额外选项，例如主机、端口、用户名、密码等。对于 HTTP(S) URL，键值对将作为头部选项转发给urllib.request.Request。对于其他 URL（例如以“s3://”和“gcs://”开头的 URL），键值对将转发给fsspec.open。更多详情请参阅fsspec和urllib，有关存储选项的更多示例请参考此处。

dtype_backend，默认为‘numpy_nullable’

应用于结果DataFrame的后端数据类型（仍处于实验阶段）。行为如下：

• "numpy_nullable"：返回支持可空 dtype 的DataFrame（默认值）。

• "pyarrow"：返回由 pyarrow 支持的可空ArrowDtype DataFrame。

新功能在 2.0 版本中新增。

返回：

DataFrame 或 TextFileReader

逗号分隔值（csv）文件被返回为带有标记轴的二维数据结构。

另请参见

DataFrame.to_csv

将 DataFrame 写入逗号分隔值（csv）文件。

read_csv

将逗号分隔值（csv）文件读入 DataFrame。

read_fwf

将一张固定宽度格式的表格行读入 DataFrame。

示例

>>> pd.read_table('data.csv') 

pandas.read_csv

原文：pandas.pydata.org/docs/reference/api/pandas.read_csv.html

pandas.read_csv(filepath_or_buffer, *, sep=_NoDefault.no_default, delimiter=None, header='infer', names=_NoDefault.no_default, index_col=None, usecols=None, dtype=None, engine=None, converters=None, true_values=None, false_values=None, skipinitialspace=False, skiprows=None, skipfooter=0, nrows=None, na_values=None, keep_default_na=True, na_filter=True, verbose=_NoDefault.no_default, skip_blank_lines=True, parse_dates=None, infer_datetime_format=_NoDefault.no_default, keep_date_col=_NoDefault.no_default, date_parser=_NoDefault.no_default, date_format=None, dayfirst=False, cache_dates=True, iterator=False, chunksize=None, compression='infer', thousands=None, decimal='.', lineterminator=None, quotechar='"', quoting=0, doublequote=True, escapechar=None, comment=None, encoding=None, encoding_errors='strict', dialect=None, on_bad_lines='error', delim_whitespace=_NoDefault.no_default, low_memory=True, memory_map=False, float_precision=None, storage_options=None, dtype_backend=_NoDefault.no_default)

将逗号分隔值（csv）文件读入 DataFrame。

还支持将文件迭代或分块。

在IO 工具的在线文档中可以找到其他帮助。

参数：

filepath_or_bufferstr，路径对象或类文件对象

任何有效的字符串路径均可接受。字符串可以是 URL。有效的 URL 方案包括 http、ftp、s3、gs 和 file。对于文件 URL，期望有一个主机。本地文件可以是：file://localhost/path/to/table.csv。

如果要传递路径对象，则 pandas 接受任何 os.PathLike。

通过类文件对象，我们指的是具有 read() 方法的对象，例如文件句柄（例如通过内置的 open 函数）或 StringIO。

sepstr，默认为‘,’

字符或正则表达式模式，用于视为分隔符。如果sep=None，C 引擎无法自动检测分隔符，但 Python 解析引擎可以，这意味着后者将被使用，并且 Python 的内置嗅探工具 csv.Sniffer 可以从文件的第一行自动检测到分隔符。此外，长度大于 1 且不同于 '\s+' 的分隔符将被解释为正则表达式，并且还会强制使用 Python 解析引擎。请注意，正则表达式分隔符容易忽略带引号的数据。正则表达式示例：'\r\t'。

delimiterstr，可选

sep 的别名。

headerint、int 序列、‘infer’ 或 None，默认为‘infer’

包含列标签并标记数据开始的行号（从零开始计数）。默认行为是推断列名：如果没有传递names，则行为与 header=0 相同，并且列名从文件的第一行推断出来；如果列名明确传递给 names，则行为与 header=None 相同。显式传递 header=0 以能够替换现有名称。标头可以是指定列的 MultiIndex 的行位置的整数列表，例如 [0, 1, 3]。未指定的中间行将被跳过（例如在此示例中跳过了 2）。请注意，如果 skip_blank_lines=True，则此参数将忽略注释行和空行，因此 header=0 表示数据的第一行而不是文件的第一行。

names可哈希序列，可选

应用的列标签序列。如果文件包含标题行，则应显式传递 header=0 以覆盖列名。此列表中不允许重复项。

index_col可哈希、可哈希序列或 False，可选

列作为行标签使用的列，可以用列标签或列索引表示。如果给定一系列标签或索引，将为行标签形成MultiIndex。

注意：index_col=False可用于强制 pandas不使用第一列作为索引，例如，当您有一个每行末尾带有分隔符的格式不正确的文件时。

usecols可哈希序列或可调用对象，可选

要选择的列的子集，可以用列标签或列索引表示。如果类似列表，所有元素必须是位置的（即整数索引到文档列）或与用户在names中提供的列名对应的字符串，或从文档标题行中推断出来的。如果给定了names，则不考虑文档标题行。例如，一个有效的类似列表的usecols参数可以是[0, 1, 2]或['foo', 'bar', 'baz']。元素顺序被忽略，因此usecols=[0, 1]与[1, 0]相同。要保留元素顺序实例化DataFrame，请使用pd.read_csv(data, usecols=['foo', 'bar'])[['foo', 'bar']]以['foo', 'bar']顺序的列或pd.read_csv(data, usecols=['foo', 'bar'])[['bar', 'foo']]以['bar', 'foo']顺序。

如果可调用，将对列名评估可调用函数，返回可调用函数评估为True的名称。一个有效的可调用参数示例是lambda x: x.upper() in ['AAA', 'BBB', 'DDD']。使用此参数会导致更快的解析时间和更低的内存使用。

dtypedtype 或{可哈希 dtype}字典，可选

要应用于整个数据集或单独列的数据类型。例如，{'a': np.float64, 'b': np.int32, 'c': 'Int64'}使用str或object与适当的na_values设置一起，以保留并不解释dtype。如果指定了converters，它们将被应用于dtype转换的替代。

新版本 1.5.0 中：添加了对defaultdict的支持。指定一个defaultdict作为输入，其中默认值确定未明确列出的列的dtype。

engine，可选

要使用的解析引擎。C 和 pyarrow 引擎更快，而 python 引擎目前更完整。目前只有 pyarrow 引擎支持多线程。

新版本 1.4.0 中：添加了‘pyarrow’引擎作为实验性引擎，并且某些功能不受支持，或者在此引擎下可能无法正常工作。

converters字典，可选

用于转换指定列中的值的函数。键可以是列标签或列索引。

true_values列表，可选

除了不区分大小写的True的变体外，要考虑为True的值。

false_values列表，可选

除了不区分大小写的False的变体外，要考虑为False的值。

skipinitialspacebool，默认为 False

在分隔符后跳过空格。

skiprowsint、int 列表或可调用对象，可选

要跳过的行号（从 0 开始索引）或文件开头要跳过的行数（int）。

如果是可调用的，可调用函数将根据行索引进行评估，如果应跳过该行则返回True，否则返回False。一个有效的可调用参数示例是lambda x: x in [0, 2]。

skipfooterint，默认为 0

要跳过文件底部的行数（不支持engine='c'）。

nrowsint，可选

要读取的文件行数。用于读取大文件的片段。

na_valuesHashable、Hashable 的 Iterable 或{HashableIterable}字典，可选

要识别为NA/NaN的其他字符串。如果传递了dict，则为每列指定特定的NA值。默认情况下，以下值被解释为NaN：“ “, “#N/A”, “#N/A N/A”, “#NA”, “-1.#IND”, “-1.#QNAN”, “-NaN”, “-nan”, “1.#IND”, “1.#QNAN”, “”, “N/A”, NA, “NULL”, NaN, “None”, “n/a”, “nan”, “null “。

keep_default_nabool，默认为 True

在解析数据时是否包括默认的NaN值。根据是否传入na_values，行为如下：

• 如果keep_default_na为True，并且指定了na_values，则na_values将附加到用于解析的默认NaN值。

• 如果keep_default_na为True，并且未指定na_values，则只使用默认的NaN值进行解析。

• 如果keep_default_na为False，并且指定了na_values，则只有指定的na_values值会被用于解析。

• 如果keep_default_na为False，并且未指定na_values，则不会将任何字符串解析为NaN。

请注意，如果将na_filter传入为False，则keep_default_na和na_values参数将被忽略。

na_filterbool，默认为 True

检测缺失值标记（空字符串和na_values的值）。在没有任何NA值的数据中，传入na_filter=False可以提高读取大文件的性能。

verbosebool，默认为 False

指示非数字列中放置的NA值的数量。

自版本 2.2.0 起已弃用。

skip_blank_linesbool，默认为 True

如果为True，则跳过空行而不是解释为NaN值。

parse_datesbool、Hashable 列表、列表的列表或{Hashablelist}字典，默认为 False

行为如下：

• bool。如果为True -> 尝试解析索引。注意：如果传递了date_format或date_parser参数，则会自动设置为True。

• int或名称的list。例如，如果[1, 2, 3] -> 尝试将列 1、2、3 分别解析为单独的日期列。

• list的list。例如，如果[[1, 3]] -> 将列 1 和 3 组合并解析为单个日期列。在解析之前，值将用空格连接起来。

• dict，例如{'foo' : [1, 3]} -> 将列 1、3 解析为日期并命名为‘foo’。在解析之前，值将用空格连接起来。

如果某列或索引无法表示为datetime数组，例如因为存在无法解析的值或时区混合，该列或索引将按原样返回为object数据类型。对于非标准datetime解析，请在read_csv()之后使用to_datetime()。

注意：存在用于 iso8601 格式的快速路径。

infer_datetime_formatbool，默认值为 False

如果True并且启用了parse_dates，pandas 将尝试推断列中datetime字符串的格式，并且如果可以推断，则切换到更快的解析方法。在某些情况下，这可能会将解析速度提高 5-10 倍。

自 2.0.0 版本起已弃用：该参数的严格版本现在是默认值，传递它将不会产生任何效果。

keep_date_colbool，默认值为 False

如果True并且parse_dates指定合并多个列，则保留原始列。

date_parserCallable，可选

用于将字符串列序列转换为datetime实例数组的函数。默认使用dateutil.parser.parser进行转换。 pandas 将尝试以三种不同的方式调用date_parser，如果发生异常，则继续下一个：1)将一个或多个数组（如parse_dates定义的）作为参数传递；2)将由parse_dates定义的列中的字符串值（按行）串联成单个数组并传递；并且 3)对每一行使用一个或多个字符串（对应于由parse_dates定义的列）调用一次date_parser。

自 2.0.0 版本起已弃用：请改用date_format，或者读取为object然后根据需要应用to_datetime()。

date_formatstr 或列->格式的字典，可选

与parse_dates一起使用时用于解析日期的格式。解析时间的 strftime，例如"%d/%m/%Y"。有关选项的更多信息，请参阅strftime documentation，尽管请注意"%f"将解析直到纳秒。您还可以传递：

• “ISO8601”，以解析任何ISO8601

  时间字符串（不一定完全相同的格式）；

• “mixed”，为每个元素单独推断格式。这很冒险，

  您应该与 dayfirst 一起使用它。

2.0.0 版本中的新功能。

dayfirstbool，默认值为 False

DD/MM 格式日期，国际和欧洲格式。

cache_datesbool，默认值为 True

如果为True，则使用唯一的转换日期缓存应用datetime转换。当解析重复的日期字符串时，特别是带有时区偏移的日期字符串，可能会产生显着的加速。

iteratorbool，默认值为 False

返回用于迭代或使用get_chunk()获取块的TextFileReader对象。

chunksizeint，可选

从文件中每块读取的行数。传递一个值将导致函数返回一个TextFileReader对象进行迭代。有关iterator和chunksize的更多信息，请参阅IO 工具文档。

compressionstr 或 dict，默认‘infer’

用于在磁盘上的数据进行即时解压缩。如果‘infer’和‘filepath_or_buffer’类似路径，则从以下扩展名检测压缩：‘.gz’、‘.bz2’、‘.zip’、‘.xz’、‘.zst’、‘.tar’、‘.tar.gz’、‘.tar.xz’或‘.tar.bz2’（否则不压缩）。如果使用'zip'或'tar'，ZIP 文件必须只包含一个要读取的数据文件。设置为None表示不解压缩。也可以是一个字典，其中键'method'设置为其中之一{'zip'、'gzip'、'bz2'、'zstd'、'xz'、'tar'}，其他键值对转发到zipfile.ZipFile、gzip.GzipFile、bz2.BZ2File、zstandard.ZstdDecompressor、lzma.LZMAFile或tarfile.TarFile。例如，可以通过以下方式传递用于 Zstandard 解压缩的自定义压缩字典：compression={'method': 'zstd', 'dict_data': my_compression_dict}。

1.5.0 版本中的新功能：添加对.tar 文件的支持。

1.4.0 版本中的更改：Zstandard 支持。

thousandsstr (length 1), optional

用作数字值中的千位分隔符的字符。

decimalstr (length 1), default ‘.’

用作小数点的字符（例如，对于欧洲数据使用‘,’）。

lineterminatorstr (length 1), optional

用于表示换行的字符。仅与 C 解析器有效。

quotecharstr (length 1), optional

用于表示引用项的起始和结束的字符。引用项可以包括delimiter，并且将被忽略。

quoting，默认 csv.QUOTE_MINIMAL

控制字段引用行为的csv.QUOTE_*常量。默认值为csv.QUOTE_MINIMAL（即 0），这意味着只有包含特殊字符的字段被引用（例如，在quotechar、delimiter或lineterminator中定义的字符）。

doublequotebool, default True

当指定quotechar且quoting不是QUOTE_NONE时，指示是否将字段内连续的两个quotechar元素解释为单个quotechar元素。

escapecharstr (length 1), optional

用于转义其他字符的字符。

commentstr (length 1), optional

表示该行剩余部分不应解析的字符。如果在行的开头找到该字符，则整行将被忽略。此参数必须是单个字符。与空行一样（只要skip_blank_lines=True），完全注释的行被参数header忽略，但不被skiprows忽略。例如，如果comment='#'，使用header=0解析#empty\na,b,c\n1,2,3将导致将'a,b,c'视为标题。

encodingstr, optional, default ‘utf-8’

读取/写入时要使用的 UTF 编码（例如'utf-8'）。Python 标准编码列表。

编码错误str，可选，默认为'strict'

处理编码错误的方式。可能的值列表。

自版本 1.3.0 起新功能。

方言str 或 csv.Dialect，可选

如果提供了此参数，它将覆盖以下参数的值（默认值或非默认值）：delimiter、doublequote、escapechar、skipinitialspace、quotechar和quoting。如果需要覆盖值，将发出ParserWarning。有关更多详细信息，请参阅csv.Dialect文档。

on_bad_lines或可调用，默认为'error'

指定在遇到坏行（字段过多的行）时要执行的操作。允许的值为：

• 'error'，遇到坏行时引发异常。

• 'warn'，遇到坏行时发出警告并跳过该行。

• 'skip'，遇到坏行时跳过而不发出或警告。

自版本 1.3.0 起新功能。

自版本 1.4.0 起新功能：

• 具有签名(bad_line: list[str]) -> list[str] | None的可调用函数，将处理单个坏行。bad_line是由sep分割的字符串列表。如果函数返回None，则将忽略坏行。如果函数返回具有比预期更多元素的新list字符串，则将发出ParserWarning，同时丢弃额外的元素。仅在engine='python'时支持

自版本 2.2.0 起更改：

• 当engine='pyarrow'时，具有pyarrow 文档中描述的签名的可调用函数。

delim_whitespacebool，默认为 False

指定是否使用空格（例如' '或'\t'）作为sep分隔符。等同于设置sep='\s+'。如果将此选项设置为True，则不应为delimiter参数传递任何内容。

自版本 2.2.0 起弃用：改用sep="\s+"。

low_memorybool，默认为 True

在块中内部处理文件，导致解析时使用更少的内存，但可能混合类型推断。为确保没有混合类型，要么设置为False，要么使用dtype参数指定类型。请注意，整个文件都会被读入单个DataFrame中，使用chunksize或iterator参数以返回以块形式返回数据。 （仅与 C 解析器有效）。

memory_mapbool，默认为 False

如果为filepath_or_buffer提供了文件路径，则将文件对象直接映射到内存并直接从中访问数据。使用此选项可以提高性能，因为不再有任何 I/O 开销。

float_precision，可选

指定 C 引擎应使用哪个转换器处理浮点值。选项为 None 或 'high' 表示普通转换器，'legacy' 表示原始的较低精度 pandas 转换器，'round_trip' 表示往返转换器。

storage_optionsdict，可选

适用于特定存储连接的额外选项，例如主机、端口、用户名、密码等。对于 HTTP(S) URL，键值对将作为标头选项转发给 urllib.request.Request。对于其他 URL（例如以 “s3://” 和 “gcs://” 开头的 URL），键值对将转发给 fsspec.open。请参阅 fsspec 和 urllib 以获取更多详细信息，并有关存储选项的更多示例，请参考这里。

dtype_backend，默认为 ‘numpy_nullable’

应用于生成的 DataFrame 的后端数据类型（仍处于实验阶段）。行为如下：

• "numpy_nullable"：返回由可空数据类型支持的 DataFrame（默认）。

• "pyarrow"：返回由 pyarrow 支持的可空 ArrowDtype DataFrame。

版本 2.0 中的新功能。

返回：

DataFrame 或 TextFileReader

逗号分隔值（csv）文件作为带有标记轴的二维数据结构返回。

另请参阅

DataFrame.to_csv

将 DataFrame 写入逗号分隔值（csv）文件。

read_table

将通用分隔文件读入 DataFrame。

read_fwf

将固定宽度格式行的表读入 DataFrame。

示例

>>> pd.read_csv('data.csv') 

pandas.DataFrame.to_csv

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_csv.html

DataFrame.to_csv(path_or_buf=None, *, sep=',', na_rep='', float_format=None, columns=None, header=True, index=True, index_label=None, mode='w', encoding=None, compression='infer', quoting=None, quotechar='"', lineterminator=None, chunksize=None, date_format=None, doublequote=True, escapechar=None, decimal='.', errors='strict', storage_options=None)

将对象写入逗号分隔值（csv）文件。

参数：

path_or_bufstr，路径对象，类似文件对象，或 None，默认为 None

字符串、路径对象（实现 os.PathLike[str]）或实现 write()函数的类似文件对象。如果为 None，则结果将作为字符串返回。如果传递了一个非二进制文件对象，它应该使用 newline=’’打开，禁用通用换行符。如果传递了一个二进制文件对象，mode 可能需要包含‘b’。

sepstr，默认为‘,’

长度为 1 的字符串。输出文件的字段分隔符。

na_repstr，默认为‘’

缺失数据表示。

float_formatstr，Callable，默认为 None

浮点数的格式化字符串。如果给定了一个可调用对象，它将优先于其他数字格式化参数，如小数。

columns序列，可选

要写入的列。

headerbool 或 str 列表，默认为 True

写出列名。如果给出一个字符串列表，则假定为列名的别名。

indexbool，默认为 True

写入行名称（索引）。

index_labelstr 或序列，或 False，默认为 None

如果需要，用作索引列的列标签。如果给出 None，并且 header 和 index 为 True，则使用索引名称。如果对象使用 MultiIndex，则应给出一个序列。如果为 False，则不打印索引名称的字段。在 R 中更容易导入，请使用 index_label=False。

mode，默认为‘w’

转发到 open(mode=)或 fsspec.open(mode=)以控制文件打开。典型值包括：

• ‘w’，首先截断文件。

• ‘x’，独占创建，如果文件已经存在则失败。

• ‘a’，如果文件存在，则追加到文件末尾。

encodingstr，可选

表示要在输出文件中使用的编码的字符串，默认为‘utf-8’。如果 path_or_buf 是非二进制文件对象，则不支持编码。

compressionstr 或 dict，默认为‘infer’

用于输出数据的即时压缩。如果‘infer’和‘path_or_buf’是类似路径的，则从以下扩展名中检测压缩：‘.gz’、‘.bz2’、‘.zip’、‘.xz’、‘.zst’、‘.tar’、‘.tar.gz’、‘.tar.xz’或‘.tar.bz2’（否则不压缩）。设置为None以不压缩。也可以是一个字典，其中键'method'设置为其中一个{'zip'、'gzip'、'bz2'、'zstd'、'xz'、'tar'}，其他键值对转发到zipfile.ZipFile、gzip.GzipFile、bz2.BZ2File、zstandard.ZstdCompressor、lzma.LZMAFile或tarfile.TarFile。例如，可以传递以下内容以获得更快的压缩并创建可重现的 gzip 存档：compression={'method': 'gzip', 'compresslevel': 1, 'mtime': 1}。

1.5.0 版中的新功能：增加了对.tar 文件的支持。

可以是一个带有‘method’键作为压缩模式和其他条目作为附加压缩选项的字典，如果压缩模式是‘zip’。

支持将压缩选项作为字典中的键传递，压缩模式为‘gzip’、‘bz2’、‘zstd’和‘zip’。

quoting csv 模块中的可选常量

默认为 csv.QUOTE_MINIMAL。如果设置了 float_format，则浮点数将转换为字符串，因此 csv.QUOTE_NONNUMERIC 将将它们视为非数字。

quotechar str，默认为‘"’

长度为 1 的字符串。用于引用字段的字符。

lineterminator str，可选

用于输出文件的换行字符或字符序列。默认为 os.linesep，这取决于调用此方法的操作系统（对于 linux 为’\n’，对于 Windows 为‘\r\n’）。

1.5.0 版更改：以前是 line_terminator，为与 read_csv 和标准库‘csv’模块保持一致而更改。

chunksize int 或 None

每次写入的行数。

date_format str，默认为 None

用于 datetime 对象的格式字符串。

doublequote bool，默认为 True

控制在字段内引用 quotechar 的引用。

escapechar str，默认为 None

长度为 1 的字符串。适当时用于转义 sep 和 quotechar 的字符。

decimal str，默认为‘.’

作为十进制分隔符识别的字符。例如，对于欧洲数据，请使用“，”。

errors str，默认为‘strict’

指定如何处理编码和解码错误。有关选项的完整列表，请参阅 open() 的 errors 参数。

storage_options dict，可选

特定存储连接的额外选项，例如主机、端口、用户名、密码等。对于 HTTP(S) URL，键值对将作为标头选项转发给urllib.request.Request。对于其他 URL（例如以“s3://”和“gcs://”开头的 URL），键值对将转发给fsspec.open。有关更多详细信息，请参阅fsspec和urllib，有关存储选项的更多示例，请参阅此处。

返回：

None 或 str

如果 path_or_buf 为 None，则将生成的 csv 格式作为字符串返回。否则返回 None。

另请参阅

read_csv

将 CSV 文件加载到 DataFrame 中。

to_excel

将 DataFrame 写入 Excel 文件。

示例

创建包含无索引的‘df’的‘out.csv’

>>> df = pd.DataFrame({'name': ['Raphael', 'Donatello'],
...                    'mask': ['red', 'purple'],
...                    'weapon': ['sai', 'bo staff']})
>>> df.to_csv('out.csv', index=False) 

创建包含‘out.csv’的‘out.zip’

>>> df.to_csv(index=False)
'name,mask,weapon\nRaphael,red,sai\nDonatello,purple,bo staff\n'
>>> compression_opts = dict(method='zip',
...                         archive_name='out.csv')  
>>> df.to_csv('out.zip', index=False,
...           compression=compression_opts) 

要将 csv 文件写入新文件夹或嵌套文件夹，您首先需要使用 Pathlib 或 os 创建它：

>>> from pathlib import Path  
>>> filepath = Path('folder/subfolder/out.csv')  
>>> filepath.parent.mkdir(parents=True, exist_ok=True)  
>>> df.to_csv(filepath) 

>>> import os  
>>> os.makedirs('folder/subfolder', exist_ok=True)  
>>> df.to_csv('folder/subfolder/out.csv') 

pandas.read_fwf

原文：pandas.pydata.org/docs/reference/api/pandas.read_fwf.html

pandas.read_fwf(filepath_or_buffer, *, colspecs='infer', widths=None, infer_nrows=100, dtype_backend=_NoDefault.no_default, iterator=False, chunksize=None, **kwds)

将固定宽度格式的行的表读入 DataFrame。

还支持可选地迭代或将文件分成块。

可在IO 工具的在线文档中找到更多帮助。

参数：

filepath_or_bufferstr，路径对象或类似文件的对象

字符串，路径对象（实现os.PathLike[str]），或实现文本read()函数的类似文件的对象。字符串可以是 URL。有效的 URL 方案包括 http，ftp，s3 和文件。对于文件 URL，期望有一个主机。本地文件可以是：file://localhost/path/to/table.csv。

colspecs元组列表（int，int）或‘infer’。可选

一个元组列表，给出每行固定宽度字段的范围作为半开区间（即，from，to[）。字符串值‘infer’可用于指示解析器尝试从未通过 skiprows 跳过的数据的前 100 行中检测列规范（默认值=‘infer’）。

widths整数列表，可选

一个字段宽度列表，如果间隔是连续的，可以代替‘colspecs’使用。

infer_nrows整数，默认值 100

让解析器确定 colspecs 时要考虑的行数。

dtype_backend，默认值‘numpy_nullable’

应用于结果[DataFrame的后端数据类型（仍处于实验阶段）。行为如下：

• "numpy_nullable"：返回支持可空 dtype 的DataFrame（默认）。

• "pyarrow"：返回支持 pyarrow 的可空ArrowDtype DataFrame。

版本 2.0 中的新功能。

****kwds**可选

可以将可选关键字参数传递给TextFileReader。

返回：

DataFrame 或 TextFileReader

逗号分隔值（csv）文件作为带有标记轴的二维数据结构返回。

另请参见

DataFrame.to_csv

将 DataFrame 写入逗号分隔值（csv）文件。

read_csv

将逗号分隔值（csv）文件读入 DataFrame。

示例

>>> pd.read_fwf('data.csv') 

pandas.read_clipboard

原文：pandas.pydata.org/docs/reference/api/pandas.read_clipboard.html

pandas.read_clipboard(sep='\\s+', dtype_backend=_NoDefault.no_default, **kwargs)

从剪贴板读取文本并传递给read_csv()。

解析剪贴板内容，类似于使用read_csv()解析 CSV 文件。

参数：

sepstr，默认为‘\s+’

字符串或正则表达式分隔符。默认值为'\s+'，表示一个或多个空白字符。

dtype_backend，默认为‘numpy_nullable’

应用于结果DataFrame的后端数据类型（仍处于实验阶段）。行为如下：

• "numpy_nullable"：返回基于 nullable-dtype 的DataFrame（默认）。

• "pyarrow"：返回基于 pyarrow 的 nullable ArrowDtype DataFrame。

版本 2.0 中的新功能。

**kwargs

查看read_csv()获取完整参数列表。

返回：

DataFrame

一个解析后的DataFrame对象。

另请参阅

DataFrame.to_clipboard

将对象复制到系统剪贴板。

read_csv

从逗号分隔值（csv）文件读取到 DataFrame。

read_fwf

将固定宽度格式的行表读入 DataFrame。

示例

>>> df = pd.DataFrame([[1, 2, 3], [4, 5, 6]], columns=['A', 'B', 'C'])
>>> df.to_clipboard()  
>>> pd.read_clipboard()  
 A  B  C
0    1  2  3
1    4  5  6 

pandas.DataFrame.to_clipboard

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_clipboard.html

DataFrame.to_clipboard(*, excel=True, sep=None, **kwargs)

将对象复制到系统剪贴板。

将对象的文本表示写入系统剪贴板。例如，这可以粘贴到 Excel 中。

参数：

excelbool，默认为 True

以 csv 格式生成输出，便于粘贴到 excel 中。

• True，使用提供的分隔符进行 csv 粘贴。

• False，将对象的字符串表示写入剪贴板。

sepstr，默认为'\t'

字段分隔符。

**kwargs

这些参数将传递给 DataFrame.to_csv。

另请参阅

DataFrame.to_csv

将 DataFrame 写入逗号分隔值（csv）文件。

read_clipboard

从剪贴板读取文本并传递给 read_csv。

注意

您平台的要求。

• Linux：xclip，或 xsel（带有 PyQt4 模块）
• Windows：无
• macOS：无

该方法使用了为包 pyperclip 开发的进程。在示例中给出了渲染任何输出字符串格式的解决方案。

示例

复制 DataFrame 的内容到剪贴板。

>>> df = pd.DataFrame([[1, 2, 3], [4, 5, 6]], columns=['A', 'B', 'C']) 

>>> df.to_clipboard(sep=',')  
... # Wrote the following to the system clipboard:
... # ,A,B,C
... # 0,1,2,3
... # 1,4,5,6 

我们可以通过传递关键字 index 并将其设置为 false 来省略索引。

>>> df.to_clipboard(sep=',', index=False)  
... # Wrote the following to the system clipboard:
... # A,B,C
... # 1,2,3
... # 4,5,6 

使用原始的 pyperclip 包进行任何字符串输出格式。

import pyperclip
html = df.style.to_html()
pyperclip.copy(html) 

pandas.read_excel

原文：pandas.pydata.org/docs/reference/api/pandas.read_excel.html

pandas.read_excel(io, sheet_name=0, *, header=0, names=None, index_col=None, usecols=None, dtype=None, engine=None, converters=None, true_values=None, false_values=None, skiprows=None, nrows=None, na_values=None, keep_default_na=True, na_filter=True, verbose=False, parse_dates=False, date_parser=_NoDefault.no_default, date_format=None, thousands=None, decimal='.', comment=None, skipfooter=0, storage_options=None, dtype_backend=_NoDefault.no_default, engine_kwargs=None)

将 Excel 文件读入pandas的DataFrame。

支持从本地文件系统或 URL 读取的 xls、xlsx、xlsm、xlsb、odf、ods 和 odt 文件扩展名。支持读取单个工作表或工作表列表的选项。

参数：

iostr、bytes、ExcelFile、xlrd.Book、路径对象或类似文件对象

任何有效的字符串路径都可以接受。字符串可以是 URL。有效的 URL 方案包括 http、ftp、s3 和 file。对于文件 URL，期望有一个主机。本地文件可以是：file://localhost/path/to/table.xlsx。

如果要传递路径对象，pandas 接受任何os.PathLike。

通过文件类似对象，我们指的是具有read()方法的对象，例如文件句柄（例如通过内置的open函数）或StringIO。

自版本 2.1.0 起弃用：传递字节字符串已被弃用。要从字节字符串读取，请将其包装在BytesIO对象中。

sheet_namestr、int、list 或 None，默认为 0

字符串用于工作表名称。整数用于零索引的工作表位置（图表工作表不计入工作表位置）。字符串/整数列表用于请求多个工作表。指定None以获取所有工作表。

可用情况：

• 默认为0：第一个工作表作为 DataFrame

• 1：第二个工作表作为 DataFrame

• "Sheet1"：加载名为"Sheet1"的工作表

• [0, 1, "Sheet5"]：将第一个、第二个和名为“Sheet5”的工作表加载为 DataFrame 字典

• None：所有工作表。

headerint、int 列表，默认为 0

用于解析的 DataFrame 的列标签的行（从 0 开始索引）。如果传递整数列表，则这些行位置将合并为MultiIndex。如果没有标题，请使用 None。

namesarray-like，默认为 None

使用的列名列表。如果文件不包含标题行，则应显式传递header=None。

index_colint、str、int 列表，默认为 None

用作 DataFrame 行标签的列（从 0 开始索引）。如果没有这样的列，请传递 None。如果传递了列表，则这些列将合并为MultiIndex。如果使用usecols选择了数据子集，则index_col基于该子集。

缺失值将被向前填充，以允许使用to_excel进行merged_cells=True的往返。为了避免向前填充缺失值，请在读取数据后使用set_index而不是index_col。

usecolsstr、类似列表或可调用对象，默认为 None

• 如果为 None，则解析所有列。

• 如果是 str，则表示 Excel 列字母和列范围的逗号分隔列表（例如“A:E”或“A,C,E:F”）。范围包括两侧。

• 如果是 int 列表，则表示要解析的列号列表（从 0 开始索引）。

• 如果是字符串列表，则表示要解析的列名列表。

• 如果是可调用对象，则针对每个列名进行评估，并且如果可调用对象返回True，则解析该列。

根据上述行为返回列的子集。

dtype类型名称或列->类型字典，默认为 None

数据或列的数据类型。例如，{‘a’：np.float64，‘b’：np.int32}使用object来保留数据存储在 Excel 中并且不解释 dtype，这将必然导致object dtype。如果指定了转换器，它们将被应用于 dtype 转换。如果使用None，它将根据数据推断每列的 dtype。

engine，默认为 None

如果 io 不是缓冲区或路径，则必须设置此项以识别 io。引擎兼容性：

• openpyxl支持更新的 Excel 文件格式。

• calamine支持 Excel（.xls，.xlsx，.xlsm，.xlsb）和 OpenDocument（.ods）文件格式。

• odf支持 OpenDocument 文件格式（.odf，.ods，.odt）。

• pyxlsb支持二进制 Excel 文件。

• xlrd支持旧式 Excel 文件（.xls）。

当engine=None时，将使用以下逻辑确定引擎：

• 如果path_or_buffer是 OpenDocument 格式（.odf，.ods，.odt），则将使用odf。

• 否则，如果path_or_buffer是 xls 格式，则将使用xlrd。

• 否则，如果path_or_buffer是 xlsb 格式，则将使用pyxlsb。

• 否则将使用openpyxl。

converters字典，默认为 None

用于转换某些列中的值的函数字典。键可以是整数或列标签，值是一个接受一个输入参数（Excel 单元格内容）并返回转换后内容的函数。

true_values列表，默认为 None

被视为 True 的值。

false_values列表，默认为 None

被视为 False 的值。

skiprows列表，整数或可调用对象，可选

要跳过的行号（从 0 开始）或文件开头要跳过的行数（整数）。如果可调用，则将对行索引评估可调用��数，如果应跳过该行则返回 True，否则返回 False。一个有效的可调用参数示例是lambda x: x in [0, 2]。

nrows整数，默认为 None

要解析的行数。

na_values标量，字符串，类似列表或字典，默认为 None

附加的字符串被识别为 NA/NaN。如果传递了字典，则为每列指定特定的 NA 值。默认情况下，以下值被解释为 NaN：‘’，‘#N/A’，‘#N/A N/A’，‘#NA’，‘-1.#IND’，‘-1.#QNAN’，‘-NaN’，‘-nan’，‘1.#IND’，‘1.#QNAN’，‘’，‘N/A’，‘NA’，‘NULL’，‘NaN’，‘None’，‘n/a’，‘nan’，‘null’。

keep_default_na布尔值，默认为 True

在解析数据时是否包括默认的 NaN 值。根据是否传递了na_values，行为如下：

• 如果keep_default_na为 True，并且指定了na_values，则na_values将被附加到用于解析的默认 NaN 值中。

• 如果keep_default_na为 True，并且未指定na_values，则只使用默认的 NaN 值进行解析。

• 如果keep_default_na为 False，并且指定了na_values，则只使用指定的 NaN 值na_values进行解析。

• 如果keep_default_na为 False，并且未指定na_values，则不会将任何字符串解析为 NaN。

请注意，如果 na_filter 设置为 False，则将忽略keep_default_na和na_values参数。

na_filter布尔值，默认为 True

检测缺失值标记（空字符串和 na_values 的值）。在没有任何 NA 的数据中，传递na_filter=False可以提高读取大文件的性能。

verbose布尔值，默认为 False

指示非数字列中放置的 NA 值的数量。

parse_dates布尔值，类似列表，或字典，默认为 False

行为如下：

• 布尔值。如果为 True -> 尝试解析索引。

• 整数或名称的列表。例如，如果[1, 2, 3] -> 尝试将列 1, 2, 3 分别解析为单独的日期列。

• 列表的列表。例如，如果[[1, 3]] -> 结合列 1 和 3 并解析为单个日期列。

• 字典，例如{‘foo’ : [1, 3]} -> 解析列 1, 3 为日期并将结果命名为‘foo’

如果列或索引包含无法解析的日期，则整个列或索引将以对象数据类型不变返回。如果不想将某些单元格解析为日期，只需在 Excel 中更改它们的类型为“文本”。对���非标准的日期时间解析，请在pd.read_excel之后使用pd.to_datetime。

注意：存在用于 iso8601 格式日期的快速路径。

date_parser函数，可选

用于将一系列字符串列转换为日期时间实例数组的函数。默认使用dateutil.parser.parser进行转换。Pandas 将尝试以三种不同的方式调用 date_parser，如果发生异常，则会继续下一个：1) 将一个或多个数组（由 parse_dates 定义）作为参数传递；2) 将由 parse_dates 定义的列中的字符串值（按行）连接成单个数组并传递；3) 对每一行使用一个或多个字符串（对应于由 parse_dates 定义的列）作为参数调用 date_parser。

自版本 2.0.0 起弃用：改用date_format，或者读取为object，然后根据需要应用to_datetime()。

date_format字符串或列 -> 格式的字典，默认为None

如果与parse_dates一起使用，将根据此格式解析日期。对于更复杂的情况，请读取为object，然后根据需要应用to_datetime()。

自版本 2.0.0 起新增。

thousands字符串，默认为 None

用于将字符串列解析为数字的千位分隔符。请注意，此参数仅对在 Excel 中存储为 TEXT 的列必要，任何数值列将自动解析，无论显示格式如何。

decimal字符串，默认为‘.’

用于将字符串列解析为数字的十进制点的字符。请注意，此参数仅对在 Excel 中存储为 TEXT 的列必要，任何数值列将自动解析，无论显示格式如何。（例如，对于欧洲数据使用‘,’）。

自版本 1.4.0 起新增。

commentstr, 默认为 None

注释掉行的其余部分。将字符或字符传递给此参数以指示输入文件中的注释。注释字符串和当前行末尾之间的任何数据都将被忽略。

skipfooterint, 默认为 0

要跳过的末尾行（从 0 开始索引）。

storage_optionsdict, 可选

适用于特定存储连接的额外选项，例如主机、端口、用户名、密码等。对于 HTTP(S) URL，键值对将作为标头选项转发到 urllib.request.Request。对于其他 URL（例如以“s3://”和“gcs://”开头的 URL），键值对将转发到 fsspec.open。请参阅 fsspec 和 urllib 以获取更多详细信息，并有关存储选项的更多示例，请参考这里。

dtype_backend, 默认为 ‘numpy_nullable’

应用于结果 DataFrame 的后端数据类型（仍处于实验阶段）。行为如下：

• "numpy_nullable": 返回由可空数据类型支持的 DataFrame（默认）。

• "pyarrow": 返回由 pyarrow 支持的可空 ArrowDtype DataFrame。

2.0 版本中的新功能。

engine_kwargsdict, 可选

传递给 excel 引擎的任意关键字参数。

返回：

DataFrame 或 DataFrame 字典

从传入的 Excel 文件中获取的 DataFrame。有关返回 DataFrame 字典的更多信息，请参阅 sheet_name 参数中的注释。

另请参见

DataFrame.to_excel

将 DataFrame 写入 Excel 文件。

DataFrame.to_csv

将 DataFrame 写入逗号分隔值（csv）文件。

read_csv

将逗号分隔值（csv）文件读入 DataFrame。

read_fwf

将固定宽度格式的行表读入 DataFrame。

注释

有关每个 Excel 引擎使用的方法的具体信息，请参阅 pandas 用户指南

示例

文件可以使用文件名字符串或打开的文件对象进行读取：

>>> pd.read_excel('tmp.xlsx', index_col=0)  
 Name  Value
0   string1      1
1   string2      2
2  #Comment      3 

>>> pd.read_excel(open('tmp.xlsx', 'rb'),
...               sheet_name='Sheet3')  
 Unnamed: 0      Name  Value
0           0   string1      1
1           1   string2      2
2           2  #Comment      3 

可以通过 index_col 和 header 参数指定索引和标题

>>> pd.read_excel('tmp.xlsx', index_col=None, header=None)  
 0         1      2
0  NaN      Name  Value
1  0.0   string1      1
2  1.0   string2      2
3  2.0  #Comment      3 

列类型会被推断，但也可以明确指定

>>> pd.read_excel('tmp.xlsx', index_col=0,
...               dtype={'Name': str, 'Value': float})  
 Name  Value
0   string1    1.0
1   string2    2.0
2  #Comment    3.0 

True、False 和 NA 值以及千位分隔符具有默认值，但也可以明确指定。也可以提供您想要的值作为字符串或字符串列表！

>>> pd.read_excel('tmp.xlsx', index_col=0,
...               na_values=['string1', 'string2'])  
 Name  Value
0       NaN      1
1       NaN      2
2  #Comment      3 

可以使用 comment kwarg 跳过 Excel 输入文件中的注释行。

>>> pd.read_excel('tmp.xlsx', index_col=0, comment='#')  
 Name  Value
0  string1    1.0
1  string2    2.0
2     None    NaN 

pandas.DataFrame.to_excel

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_excel.html

DataFrame.to_excel(excel_writer, *, sheet_name='Sheet1', na_rep='', float_format=None, columns=None, header=True, index=True, index_label=None, startrow=0, startcol=0, engine=None, merge_cells=True, inf_rep='inf', freeze_panes=None, storage_options=None, engine_kwargs=None)

将对象写入 Excel 表。

要将单个对象写入 Excel .xlsx 文件，只需指定目标文件名即可。要写入多个工作表，需要创建一个带有��标文件名的 ExcelWriter 对象，并指定要写入的文件中的工作表。

通过指定唯一的 sheet_name 可以写入多个工作表。将所有数据写入文件后，需要保存更改。请注意，使用已经存在的文件名创建 ExcelWriter 对象将导致擦除现有文件的内容。

参数：

excel_writer类似路径、类似文件或 ExcelWriter 对象

文件路径或现有的 ExcelWriter。

sheet_namestr，默认值为‘Sheet1’

包含 DataFrame 的工作表的名称。

na_repstr，默认值为‘’

缺失数据表示。

float_formatstr，可选

浮点数的格式化字符串。例如，float_format="%.2f"将 0.1234 格式化为 0.12。

columns序列或字符串列表，可选

要写入的列。

headerbool 或字符串列表，默认值为 True

写出列名。如果给定一个字符串列表，则假定为列名的别名。

indexbool，默认值为 True

写入行名称（索引）。

index_labelstr 或序列，可选

如果需要，用于索引列的列标签。如果未指定，并且 header 和 index 为 True，则使用索引名称。如果 DataFrame 使用 MultiIndex，则应给出一个序列。

startrowint，默认值为 0

左上角单元格行用于存储数据框。

startcolint，默认值为 0

左上角单元格列用于存储数据框。

enginestr，可选

写入要使用的引擎，‘openpyxl’或‘xlsxwriter’。您还可以通过选项io.excel.xlsx.writer或io.excel.xlsm.writer设置此选项。

merge_cellsbool，默认值为 True

将 MultiIndex 和 Hierarchical Rows 写为合并单元格。

inf_repstr，默认值为‘inf’

无穷大的表示（Excel 中没有本机表示无穷大）。

freeze_panesint 元组（长度为 2），可选

指定要冻结的基于一的最底部行和最右侧列。

storage_optionsdict，可选

适用于特定存储连接的额外选项，例如主机、端口、用户名、密码等。对于 HTTP(S) URL，键值对将作为标头选项转发给urllib.request.Request。对于其他 URL（例如以“s3://”和“gcs://”开头的 URL），键值对将转发给fsspec.open。有关更多详细信息，请参阅fsspec和urllib，有关存储选项的更多示例，请参考这里。

版本 1.2.0 中的新功能。

engine_kwargsdict，可选

传递给 excel 引擎的任意关键字参数。

另请参见

to_csv

将 DataFrame 写入逗号分隔值（csv）文件。

ExcelWriter

用于将 DataFrame 对象写入 excel 工作表的类。

read_excel

将 Excel 文件读取到 pandas DataFrame 中。

read_csv

将逗号分隔值（csv）文件读取到 DataFrame 中。

io.formats.style.Styler.to_excel

向 Excel 工作表添加样式。

注意事项

为了与to_csv()兼容，to_excel 在写入之前将列表和字典序列化为字符串。

一旦工作簿被保存，就无法在不重新写入整个工作簿的情况下再写入数据。

示例

创建、写入并保存工作簿：

>>> df1 = pd.DataFrame([['a', 'b'], ['c', 'd']],
...                    index=['row 1', 'row 2'],
...                    columns=['col 1', 'col 2'])
>>> df1.to_excel("output.xlsx") 

指定工作表名称：

>>> df1.to_excel("output.xlsx",
...              sheet_name='Sheet_name_1') 

如果希望在工作簿中写入多个工作表，必须指定一个 ExcelWriter 对象：

>>> df2 = df1.copy()
>>> with pd.ExcelWriter('output.xlsx') as writer:  
...     df1.to_excel(writer, sheet_name='Sheet_name_1')
...     df2.to_excel(writer, sheet_name='Sheet_name_2') 

ExcelWriter 也可以用于追加到现有的 Excel 文件中：

>>> with pd.ExcelWriter('output.xlsx',
...                     mode='a') as writer:  
...     df1.to_excel(writer, sheet_name='Sheet_name_3') 

要设置用于编写 Excel 文件的库，可以传递 engine 关键字（默认引擎会根据文件扩展名自动选择）：

>>> df1.to_excel('output1.xlsx', engine='xlsxwriter') 

pandas.ExcelFile

原文：pandas.pydata.org/docs/reference/api/pandas.ExcelFile.html

class pandas.ExcelFile(path_or_buffer, engine=None, storage_options=None, engine_kwargs=None)

用于将表格化 Excel 表格解析为 DataFrame 对象的类。

有关更多文档，请参阅 read_excel。

参数：

path_or_bufferstr、bytes、路径对象（pathlib.Path 或 py._path.local.LocalPath），

文件类对象，xlrd 工作簿或 openpyxl 工作簿。如果是字符串或路径对象，则应为.xls、.xlsx、.xlsb、.xlsm、.odf、.ods 或.odt 文件的路径。

enginestr，默认为 None

如果 io 不是缓冲区或路径，则必须设置此项以识别 io。支持的引擎：xlrd、openpyxl、odf、pyxlsb、calamine 引擎兼容性：

• xlrd支持旧式 Excel 文件（.xls）。

• openpyxl支持更新的 Excel 文件格式。

• odf支持 OpenDocument 文件格式（.odf、.ods、.odt）。

• pyxlsb支持二进制 Excel 文件。

• calamine支持 Excel（.xls、.xlsx、.xlsm、.xlsb）和 OpenDocument（.ods）文件格式。

从版本 1.2.0 开始更改：引擎xlrd现在仅支持旧式.xls文件。当engine=None时，将使用以下逻辑来确定引擎：

• 如果path_or_buffer是 OpenDocument 格式（.odf、.ods、.odt），则将使用odf。

• 否则，如果path_or_buffer是 xls 格式，将使用xlrd。

• 否则，如果path_or_buffer是 xlsb 格式，则将使用pyxlsb。

1.3.0 版本中的新功能。

• 否则，如果安装了openpyxl，则将使用openpyxl。

• 否则，如果安装了xlrd >= 2.0，将引发ValueError。

警告

请勿使用xlrd读取.xlsx文件时报告问题。这不受支持，请改用openpyxl。

engine_kwargsdict，可选

传递给 excel 引擎的任意关键字参数。

示例

>>> file = pd.ExcelFile('myfile.xlsx')  
>>> with pd.ExcelFile("myfile.xls") as xls:  
...     df1 = pd.read_excel(xls, "Sheet1") 

属性

book
sheet_names

方法

close()	必要时关闭 io
parse	将指定的工作表解析为 DataFrame。

pandas.ExcelFile.book

原文：pandas.pydata.org/docs/reference/api/pandas.ExcelFile.book.html

property ExcelFile.book

pandas.ExcelFile.sheet_names

原文：pandas.pydata.org/docs/reference/api/pandas.ExcelFile.sheet_names.html

property ExcelFile.sheet_names

pandas.ExcelFile.parse

原文：pandas.pydata.org/docs/reference/api/pandas.ExcelFile.parse.html

ExcelFile.parse(sheet_name=0, header=0, names=None, index_col=None, usecols=None, converters=None, true_values=None, false_values=None, skiprows=None, nrows=None, na_values=None, parse_dates=False, date_parser=_NoDefault.no_default, date_format=None, thousands=None, comment=None, skipfooter=0, dtype_backend=_NoDefault.no_default, **kwds)

将指定的工作表解析为 DataFrame。

等同于 read_excel(ExcelFile, …)。有关可接受参数的更多信息，请参阅 read_excel 文档字符串。

返回：

DataFrame 或 DataFrame 字典

从传入的 Excel 文件中获取的 DataFrame。

示例

>>> df = pd.DataFrame([[1, 2, 3], [4, 5, 6]], columns=['A', 'B', 'C'])
>>> df.to_excel('myfile.xlsx')  
>>> file = pd.ExcelFile('myfile.xlsx')  
>>> file.parse() 

pandas.io.formats.style.Styler.to_excel

原文：pandas.pydata.org/docs/reference/api/pandas.io.formats.style.Styler.to_excel.html

Styler.to_excel(excel_writer, sheet_name='Sheet1', na_rep='', float_format=None, columns=None, header=True, index=True, index_label=None, startrow=0, startcol=0, engine=None, merge_cells=True, encoding=None, inf_rep='inf', verbose=True, freeze_panes=None, storage_options=None)

将 Styler 写入 Excel 工作表。

要将单个 Styler 写入 Excel .xlsx 文件，只需指定目标文件名即可。要写入多个工作表，需要创建一个带有目标文件名的 ExcelWriter 对象，并指定要写入的文件中的工作表。

可通过指定唯一的 sheet_name 来写入多个工作表。将所有数据写入文件后，需要保存更改。请注意，使用已经存在的文件名创建 ExcelWriter 对象将导致擦除现有文件的内容。

参数：

excel_writer类似路径、类似文件或 ExcelWriter 对象

文件路径或现有的 ExcelWriter。

sheet_namestr，默认为‘Sheet1’

将包含 DataFrame 的工作表的名称。

na_repstr，默认为‘’

缺失数据表示。

float_formatstr，可选

浮点数的格式字符串。例如，float_format="%.2f"将 0.1234 格式化为 0.12。

columns序列或字符串列表，可选

要写入的列。

headerbool 或字符串列表，默认为 True

写出列名。如果给出字符串列表，则假定为列名的别名。

indexbool，默认为 True

写入行名称（索引）。

index_labelstr 或序列，可选

如果需要，可指定索引列的列标签。如果未指定，并且标题和索引为 True，则使用索引名称。如果 DataFrame 使用 MultiIndex，则应给出一个序列。

startrowint，默认为 0

要转储数据框的左上角单元格行。

startcolint，默认为 0

要转储数据框的左上角单元格列。

enginestr，可选

要使用的写引擎，‘openpyxl’或‘xlsxwriter’。您还可以通过选项io.excel.xlsx.writer或io.excel.xlsm.writer设置此选项。

merge_cellsbool，默认为 True

将 MultiIndex 和分层行写为合并单元格。

inf_repstr，默认为‘inf’

无穷大的表示（Excel 中没有本机表示）。

freeze_panesint 元组（长度为 2），可选

指定要冻结的最底部行和最右侧列（从 1 开始计数）。

storage_optionsdict，可选

适用于特定存储连接的额外选项，例如主机、端口、用户名、密码等。对于 HTTP(S) URL，键值对将作为标头选项转发到urllib.request.Request。对于其他 URL（例如以“s3://”和“gcs://”开头的 URL），键值对将转发到fsspec.open。有关更多详细信息，请参阅fsspec和urllib，有关存储选项的更多示例，请参考这里。

版本 1.5.0 中的新功能。

engine_kwargsdict，可选

传递给 excel 引擎的任意关键字参数。

另请参见

to_csv

将 DataFrame 写入逗号分隔值 (csv) 文件。

ExcelWriter

用于将 DataFrame 对象写入 Excel 工作表中的类。

read_excel

将 Excel 文件读取到 pandas DataFrame 中。

read_csv

从逗号分隔值 (csv) 文件读取到 DataFrame 中。

io.formats.style.Styler.to_excel

为 Excel 工作表添加样式。

注意事项

为了与 to_csv() 兼容，to_excel 在写入之前将列表和字典序列化为字符串。

一旦工作簿已保存，就无法在不重写整个工作簿的情况下再写入数据。

示例

创建、写入并保存工作簿：

>>> df1 = pd.DataFrame([['a', 'b'], ['c', 'd']],
...                    index=['row 1', 'row 2'],
...                    columns=['col 1', 'col 2'])
>>> df1.to_excel("output.xlsx") 

指定工作表名称：

>>> df1.to_excel("output.xlsx",
...              sheet_name='Sheet_name_1') 

如果您希望在工作簿中写入多个工作表，则需要指定一个 ExcelWriter 对象：

>>> df2 = df1.copy()
>>> with pd.ExcelWriter('output.xlsx') as writer:  
...     df1.to_excel(writer, sheet_name='Sheet_name_1')
...     df2.to_excel(writer, sheet_name='Sheet_name_2') 

ExcelWriter 也可用于追加到现有的 Excel 文件中：

>>> with pd.ExcelWriter('output.xlsx',
...                     mode='a') as writer:  
...     df1.to_excel(writer, sheet_name='Sheet_name_3') 

若要设置用于写入 Excel 文件的库，可以传递 engine 关键字（默认引擎会根据文件扩展名自动选择）：

>>> df1.to_excel('output1.xlsx', engine='xlsxwriter') 

pandas.ExcelWriter

原文：pandas.pydata.org/docs/reference/api/pandas.ExcelWriter.html

class pandas.ExcelWriter(path, engine=None, date_format=None, datetime_format=None, mode='w', storage_options=None, if_sheet_exists=None, engine_kwargs=None)

用于将 DataFrame 对象写入 Excel 工作表的类。

默认使用：

• xlsxwriter 用于 xlsx 文件，如果安装了 xlsxwriter，否则使用 openpyxl

• odswriter 用于 ods 文件

请参阅 DataFrame.to_excel 以获取典型用法。

写入器应作为上下文管理器使用。否则，请调用 close() 保存并关闭任何已打开的文件句柄。

参数：

pathstr 或 typing.BinaryIO

xls 或 xlsx 或 ods 文件的路径。

enginestr（可选）

要用于写入的引擎。如果为 None，则默认为 io.excel.<extension>.writer。注意：只能作为关键字参数传递。

date_formatstr，默认为 None

写入 Excel 文件的日期格式字符串（例如‘YYYY-MM-DD’）。

datetime_formatstr，默认为 None

写入 Excel 文件的日期时间对象的格式字符串（例如‘YYYY-MM-DD HH:MM:SS’）。

mode，默认为‘w’

要使用的文件模式（写入或追加）。追加不适用于 fsspec URL。

storage_optionsdict，可选

适用于特定存储连接的额外选项，例如主机、端口、用户名、密码等。对于 HTTP(S) URL���键值对将作为标头选项转发给 urllib.request.Request。对于其他 URL（例如以“s3://”和“gcs://”开头的 URL），键值对将转发给 fsspec.open。请参阅 fsspec 和 urllib 了解更多详细信息，并且有关存储选项的更多示例，请参考这里。

if_sheet_exists，默认为‘error’

尝试写入已存在的工作表时的行为方式（仅追加模式）。

• error: 引发 ValueError。

• new: 创建一个由引擎确定名称的新工作表。

• replace: 在写入之前删除工作表的内容。

• overlay: 将内容写入现有工作表，而无需先删除，但可能会覆盖现有内容。

版本 1.3.0 中的新功能。

在版本 1.4.0 中更改：添加了 overlay 选项

engine_kwargsdict，可选

要传递给引擎的关键字参数。这些将传递给各自引擎的以下函数：

• xlsxwriter: xlsxwriter.Workbook(file, **engine_kwargs)

• openpyxl（写入模式）：openpyxl.Workbook(**engine_kwargs)

• openpyxl（追加模式）：openpyxl.load_workbook(file, **engine_kwargs)

• odswriter: odf.opendocument.OpenDocumentSpreadsheet(**engine_kwargs)

版本 1.3.0 中的新功能。

注意

为了与 CSV 写入器兼容，ExcelWriter 在写入之前将列表和字典序列化为字符串。

示例

默认用法：

>>> df = pd.DataFrame([["ABC", "XYZ"]], columns=["Foo", "Bar"])  
>>> with pd.ExcelWriter("path_to_file.xlsx") as writer:
...     df.to_excel(writer) 

要在单个文件中写入到不同工作表：

>>> df1 = pd.DataFrame([["AAA", "BBB"]], columns=["Spam", "Egg"])  
>>> df2 = pd.DataFrame([["ABC", "XYZ"]], columns=["Foo", "Bar"])  
>>> with pd.ExcelWriter("path_to_file.xlsx") as writer:
...     df1.to_excel(writer, sheet_name="Sheet1")  
...     df2.to_excel(writer, sheet_name="Sheet2") 

您可以设置日期格式或日期时间格式：

>>> from datetime import date, datetime  
>>> df = pd.DataFrame(
...     [
...         [date(2014, 1, 31), date(1999, 9, 24)],
...         [datetime(1998, 5, 26, 23, 33, 4), datetime(2014, 2, 28, 13, 5, 13)],
...     ],
...     index=["Date", "Datetime"],
...     columns=["X", "Y"],
... )  
>>> with pd.ExcelWriter(
...     "path_to_file.xlsx",
...     date_format="YYYY-MM-DD",
...     datetime_format="YYYY-MM-DD HH:MM:SS"
... ) as writer:
...     df.to_excel(writer) 

您还可以追加到现有的 Excel 文件中：

>>> with pd.ExcelWriter("path_to_file.xlsx", mode="a", engine="openpyxl") as writer:
...     df.to_excel(writer, sheet_name="Sheet3") 

这里，如果 _sheet_exists 参数设置为替换已经存在的表格：

>>> with ExcelWriter(
...     "path_to_file.xlsx",
...     mode="a",
...     engine="openpyxl",
...     if_sheet_exists="replace",
... ) as writer:
...     df.to_excel(writer, sheet_name="Sheet1") 

你也可以将多个 DataFrame 写入到单个表格中。请注意，if_sheet_exists参数需要设置为overlay：

>>> with ExcelWriter("path_to_file.xlsx",
...     mode="a",
...     engine="openpyxl",
...     if_sheet_exists="overlay",
... ) as writer:
...     df1.to_excel(writer, sheet_name="Sheet1")
...     df2.to_excel(writer, sheet_name="Sheet1", startcol=3) 

你可以将 Excel 文件存储在 RAM 中：

>>> import io
>>> df = pd.DataFrame([["ABC", "XYZ"]], columns=["Foo", "Bar"])
>>> buffer = io.BytesIO()
>>> with pd.ExcelWriter(buffer) as writer:
...     df.to_excel(writer) 

你可以将 Excel 文件打包成 zip 归档：

>>> import zipfile  
>>> df = pd.DataFrame([["ABC", "XYZ"]], columns=["Foo", "Bar"])  
>>> with zipfile.ZipFile("path_to_file.zip", "w") as zf:
...     with zf.open("filename.xlsx", "w") as buffer:
...         with pd.ExcelWriter(buffer) as writer:
...             df.to_excel(writer) 

你可以指定到底层引擎的额外参数：

>>> with pd.ExcelWriter(
...     "path_to_file.xlsx",
...     engine="xlsxwriter",
...     engine_kwargs={"options": {"nan_inf_to_errors": True}}
... ) as writer:
...     df.to_excel(writer) 

在追加模式下，engine_kwargs将传递给 openpyxl 的load_workbook：

>>> with pd.ExcelWriter(
...     "path_to_file.xlsx",
...     engine="openpyxl",
...     mode="a",
...     engine_kwargs={"keep_vba": True}
... ) as writer:
...     df.to_excel(writer, sheet_name="Sheet2") 

属性

book	书籍实例。
date_format	写入 Excel 文件中日期的格式字符串（例如'YYYY-MM-DD'）。
datetime_format	写入 Excel 文件中日期的格式字符串（例如'YYYY-MM-DD'）。
engine	引擎的名称。
if_sheet_exists	写入已经存在的表格时的行为。
sheets	将表格名称映射到表格对象。
supported_extensions	写入器引擎支持的扩展名。

方法

check_extension(ext)	检查路径的扩展名是否与写入器支持的扩展名匹配。
close()	保存的同义词，使其更类似于文件操作。

pandas.read_json

原文：pandas.pydata.org/docs/reference/api/pandas.read_json.html

pandas.read_json(path_or_buf, *, orient=None, typ='frame', dtype=None, convert_axes=None, convert_dates=True, keep_default_dates=True, precise_float=False, date_unit=None, encoding=None, encoding_errors='strict', lines=False, chunksize=None, compression='infer', nrows=None, storage_options=None, dtype_backend=_NoDefault.no_default, engine='ujson')

将 JSON 字符串转换为 pandas 对象。

参数：

path_or_buf有效的 JSON 字符串、路径对象或类文件对象

任何有效的字符串路径都可以接受。字符串可以是 URL。有效的 URL 方案包括 http、ftp、s3 和 file。对于文件 URL，期望有一个主机。本地文件可以是：file://localhost/path/to/table.json。

如果要传递路径对象，pandas 接受任何os.PathLike。

通过类文件对象，我们指的是具有read()方法的对象，例如文件句柄（例如通过内置的open函数）或StringIO。

自 2.1.0 版本起已弃用：传递 json 文字字符串已弃用。

orient字符串，可选

预期的 JSON 字符串格式指示。兼容的 JSON 字符串可以通过具有相应 orient 值的to_json()生成。可能的 orient 集合是：

• 'split'：类似于{index -> [index], columns -> [columns], data -> [values]}

• 'records'：类似于[{column -> value}, ... , {column -> value}]

• 'index'：类似于{index -> {column -> value}}

• 'columns'：类似于{column -> {index -> value}}

• 'values'：仅值数组

• 'table'：类似于{'schema': {schema}, 'data': {data}}

允许的默认值取决于 typ 参数的值。

• 当typ == 'series'时，

  • 允许的方向是{'split','records','index'}

  • 默认为'index'

  • 对于'index'，Series 索引必须是唯一的。

• 当typ == 'frame'时，

  • 允许的方向是{'split','records','index', 'columns','values', 'table'}

  • 默认为'columns'

  • 对于'index'和'columns'，DataFrame 索引必须是唯一的。

  • 对于'index'、'columns'和'records'，DataFrame 列必须是唯一的。

typ，默认为‘frame’

要恢复的对象类型。

dtype布尔值或字典，默认为 None

如果为 True，则推断数据类型；如果为列到数据类型的字典，则使用这些数据类型；如果为 False，则根本不推断数据类型，仅适用于数据。

对于除了'table'之外的所有orient值，默认为 True。

convert_axes布尔值，默认为 None

尝试将轴转换为适当的数据类型。

对于除了'table'之外的所有orient值，默认为 True。

convert_dates布尔值或字符串列表，默认为 True

如果为 True，则默认的日期列可能会被转换（取决于 keep_default_dates）。如果为 False，则不会转换任何日期。如果是列名称列表，则这些列将被转换，同时默认的日期列也可能会被转换（取决于 keep_default_dates）。

keep_default_dates布尔值，默认为 True

如果解析日期（convert_dates 不为 False），则尝试解析默认的日期列。如果列标签是日期样式的，则为日期样式。

• 以'_at'结尾，

• 以'_time'结尾，

• 以'timestamp'开头，

• 它是'modified'，或

• 它是'date'。

precise_float布尔值，默认为 False

设置为启用更高精度（strtod）函数在将字符串解码为双精度值时。默认（False）是使用快速但不太精确的内置功能。

date_unitstr，默认为 None

时间戳单位，用于检测日期转换。默认行为是尝试检测正确的精度，但如果不需要，则传递‘s’、‘ms’、‘us’或‘ns’中的一个，以强制仅解析秒、毫秒、微秒或纳秒。

encodingstr，默认为‘utf-8’

用于解码 py3 字节的编码。

encoding_errorsstr，可选，默认为“strict”

如何处理编码错误。可能值的列表。

在 1.3.0 版本中新增。

linesbool，默认为 False

按行读取文件作为 json 对象。

chunksizeint，可选

返回 JsonReader 对象以进行迭代。有关chunksize的更多信息，请参阅行分隔的 json 文档。只有在 lines=True 时才能传递此参数。如果为 None，则文件将一次性全部读入内存。

compressionstr 或 dict，默认为‘infer’

用于在磁盘上的数据进行即时解压缩。如果‘infer’和‘path_or_buf’是类似路径的，则从以下扩展名中检测压缩：‘.gz’、‘.bz2’、‘.zip’、‘.xz’、‘.zst’、‘.tar’、‘.tar.gz’、‘.tar.xz’或‘.tar.bz2’（否则不压缩）。如果使用'zip'或'tar'，ZIP 文件必须只包含一个要读取的数据文件。设置为None表示不解压缩。也可以是一个字典，其中键'method'设置为其中之一{'zip'、'gzip'、'bz2'、'zstd'、'xz'、'tar'}，其他键值对转发到zipfile.ZipFile、gzip.GzipFile、bz2.BZ2File、zstandard.ZstdDecompressor、lzma.LZMAFile或tarfile.TarFile。例如，可以通过传递以下内容来进行 Zstandard 解压缩，使用自定义压缩字典：compression={'method': 'zstd', 'dict_data': my_compression_dict}。

在 1.5.0 版本中新增：对.tar 文件的支持。

在 1.4.0 版本中更改：Zstandard 支持。

nrowsint，可选

必须读取的行数，来自行分隔的 json 文件。只有在 lines=True 时才能传递此参数。如果为 None，则将返回所有行。

storage_optionsdict，可选

适用于特定存储连接的额外选项，例如主机、端口、用户名、密码等。对于 HTTP(S) URL，键值对将作为标头选项转发到urllib.request.Request。对于其他 URL（例如以“s3://”和“gcs://”开头的 URL），键值对将转发到fsspec.open。请参阅fsspec和urllib以获取更多详细信息，并有关存储选项的更多示例，请参考这里。

dtype_backend，默认为‘numpy_nullable’

应用于结果 DataFrame 的后端数据类型（仍处于试验阶段）。行为如下：

• "numpy_nullable"：返回支持可空 dtype 的 DataFrame（默认值）。

• "pyarrow"：返回支持 pyarrow 的可空 ArrowDtype DataFrame。

从 2.0 版本开始新增。

engine，默认为 “ujson”

要使用的解析引擎。当 lines=True 时才可用 "pyarrow" 引擎。

从 2.0 版本开始新增。

返回：

Series、DataFrame 或 pandas.api.typing.JsonReader

当 chunksize 不为 0 或 None 时返回一个 JsonReader。否则，返回的类型取决于 typ 的值。

另请参阅

DataFrame.to_json

将 DataFrame 转换为 JSON 字符串。

Series.to_json

将 Series 转换为 JSON 字符串。

json_normalize

将半结构化的 JSON 数据规范化为平面表格。

注意事项

关于 orient='table'，如果一个带有文字 Index 名称为 index 的 DataFrame 被写入 to_json()，后续的读操作会错误地将 Index 名称设置为 None。这是因为 index 也被 DataFrame.to_json() 用来表示缺少的 Index 名称，后续的 read_json() 操作无法区分两者。对于 MultiIndex 和任何以 'level_' 开头的名称，也会遇到相同的限制。

示例

>>> from io import StringIO
>>> df = pd.DataFrame([['a', 'b'], ['c', 'd']],
...                   index=['row 1', 'row 2'],
...                   columns=['col 1', 'col 2']) 

使用 'split' 格式化的 JSON 对 Dataframe 进行编码/解码：

>>> df.to_json(orient='split')
 '{"columns":["col 1","col 2"],"index":["row 1","row 2"],"data":[["a","b"],["c","d"]]}'
>>> pd.read_json(StringIO(_), orient='split')
 col 1 col 2
row 1     a     b
row 2     c     d 

使用 'index' 格式化的 JSON 对 Dataframe 进行编码/解码：

>>> df.to_json(orient='index')
'{"row 1":{"col 1":"a","col 2":"b"},"row 2":{"col 1":"c","col 2":"d"}}' 

>>> pd.read_json(StringIO(_), orient='index')
 col 1 col 2
row 1     a     b
row 2     c     d 

使用 'records' 格式化的 JSON 对 Dataframe 进行编码/解码。请注意，此编码不会保留索引标签。

>>> df.to_json(orient='records')
'[{"col 1":"a","col 2":"b"},{"col 1":"c","col 2":"d"}]'
>>> pd.read_json(StringIO(_), orient='records')
 col 1 col 2
0     a     b
1     c     d 

使用 Table Schema 进行编码

>>> df.to_json(orient='table')
 '{"schema":{"fields":[{"name":"index","type":"string"},{"name":"col 1","type":"string"},{"name":"col 2","type":"string"}],"primaryKey":["index"],"pandas_version":"1.4.0"},"data":[{"index":"row 1","col 1":"a","col 2":"b"},{"index":"row 2","col 1":"c","col 2":"d"}]}' 

以下示例使用 dtype_backend="numpy_nullable"

>>> data = '''{"index": {"0": 0, "1": 1},
...        "a": {"0": 1, "1": null},
...        "b": {"0": 2.5, "1": 4.5},
...        "c": {"0": true, "1": false},
...        "d": {"0": "a", "1": "b"},
...        "e": {"0": 1577.2, "1": 1577.1}}'''
>>> pd.read_json(StringIO(data), dtype_backend="numpy_nullable")
 index     a    b      c  d       e
0      0     1  2.5   True  a  1577.2
1      1  <NA>  4.5  False  b  1577.1 

pandas.json_normalize

原文：pandas.pydata.org/docs/reference/api/pandas.json_normalize.html

pandas.json_normalize(data, record_path=None, meta=None, meta_prefix=None, record_prefix=None, errors='raise', sep='.', max_level=None)

将半结构化的 JSON 数据规范化为平面表。

参数：

data字典或字典列表

未序列化的 JSON 对象。

record_pathstr 或 str 列表，默认为 None

每个对象中到记录列表的路径。如果未传递，则假定数据为记录数组。

meta路径列表（str 或 str 列表），默认为 None

用作结果表中每个记录的元数据字段。

meta_prefixstr，默认为 None

如果为 True，则以点（?）路径为记录添加前缀，例如如果元数据为['foo'，'bar']，则为 foo.bar.field。

record_prefixstr，默认为 None

如果为 True，则以点（?）路径为记录添加前缀，例如如果记录路径为['foo'，'bar']，则为 foo.bar.field。

errors，默认为‘raise’

配置错误处理。

• ‘ignore’：如果元数据中列出的键不一定总是存在，则将忽略 KeyError。

• ‘raise’：如果元数据中列出的键不一定总是存在，则将引发 KeyError。

sepstr，默认为‘.’

嵌套记录将生成以 sep 分隔的名称。例如，对于 sep=‘.’，{‘foo’：{‘bar’：0}} -> foo.bar。

max_levelint，默认为 None

规范化的最大级别（字典深度）。如果为 None，则规范化所有级别。

返回：

frameDataFrame

将半结构化的 JSON 数据规范化为平面表。

示例

>>> data = [
...     {"id": 1, "name": {"first": "Coleen", "last": "Volk"}},
...     {"name": {"given": "Mark", "family": "Regner"}},
...     {"id": 2, "name": "Faye Raker"},
... ]
>>> pd.json_normalize(data)
 id name.first name.last name.given name.family        name
0  1.0     Coleen      Volk        NaN         NaN         NaN
1  NaN        NaN       NaN       Mark      Regner         NaN
2  2.0        NaN       NaN        NaN         NaN  Faye Raker 

>>> data = [
...     {
...         "id": 1,
...         "name": "Cole Volk",
...         "fitness": {"height": 130, "weight": 60},
...     },
...     {"name": "Mark Reg", "fitness": {"height": 130, "weight": 60}},
...     {
...         "id": 2,
...         "name": "Faye Raker",
...         "fitness": {"height": 130, "weight": 60},
...     },
... ]
>>> pd.json_normalize(data, max_level=0)
 id        name                        fitness
0  1.0   Cole Volk  {'height': 130, 'weight': 60}
1  NaN    Mark Reg  {'height': 130, 'weight': 60}
2  2.0  Faye Raker  {'height': 130, 'weight': 60} 

将嵌套数据规范化至 1 级。

>>> data = [
...     {
...         "id": 1,
...         "name": "Cole Volk",
...         "fitness": {"height": 130, "weight": 60},
...     },
...     {"name": "Mark Reg", "fitness": {"height": 130, "weight": 60}},
...     {
...         "id": 2,
...         "name": "Faye Raker",
...         "fitness": {"height": 130, "weight": 60},
...     },
... ]
>>> pd.json_normalize(data, max_level=1)
 id        name  fitness.height  fitness.weight
0  1.0   Cole Volk             130              60
1  NaN    Mark Reg             130              60
2  2.0  Faye Raker             130              60 

>>> data = [
...     {
...         "state": "Florida",
...         "shortname": "FL",
...         "info": {"governor": "Rick Scott"},
...         "counties": [
...             {"name": "Dade", "population": 12345},
...             {"name": "Broward", "population": 40000},
...             {"name": "Palm Beach", "population": 60000},
...         ],
...     },
...     {
...         "state": "Ohio",
...         "shortname": "OH",
...         "info": {"governor": "John Kasich"},
...         "counties": [
...             {"name": "Summit", "population": 1234},
...             {"name": "Cuyahoga", "population": 1337},
...         ],
...     },
... ]
>>> result = pd.json_normalize(
...     data, "counties", ["state", "shortname", ["info", "governor"]]
... )
>>> result
 name  population    state shortname info.governor
0        Dade       12345   Florida    FL    Rick Scott
1     Broward       40000   Florida    FL    Rick Scott
2  Palm Beach       60000   Florida    FL    Rick Scott
3      Summit        1234   Ohio       OH    John Kasich
4    Cuyahoga        1337   Ohio       OH    John Kasich 

>>> data = {"A": [1, 2]}
>>> pd.json_normalize(data, "A", record_prefix="Prefix.")
 Prefix.0
0          1
1          2 

返回带有给定字符串前缀的规范化数据列。

pandas.DataFrame.to_json

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_json.html

DataFrame.to_json(path_or_buf=None, *, orient=None, date_format=None, double_precision=10, force_ascii=True, date_unit='ms', default_handler=None, lines=False, compression='infer', index=None, indent=None, storage_options=None, mode='w')

将对象转换为 JSON 字符串。

注意 NaN 和 None 将被转换为 null，日期时间对象将被转换为 UNIX 时间戳。

参数：

path_or_buf字符串、路径对象、类文件对象或 None，默认为 None

字符串、路径对象（实现 os.PathLike[str]）、或实现 write()函数的类文件对象。如果为 None，则结果将作为字符串返回。

orient字符串

预期的 JSON 字符串格式指示。

• Series：

  • 默认为‘index’
  • 允许的值为：{‘split’, ‘records’, ‘index’, ‘table’}。

• DataFrame：

  • 默认为‘columns’
  • 允许的值为：{‘split’, ‘records’, ‘index’, ‘columns’, ‘values’, ‘table’}。

• JSON 字符串的格式：

  • ‘split’：类似于{‘index’ -> [index], ‘columns’ -> [columns], ‘data’ -> [values]}的字典
  • ‘records’：类似于[{column -> value}, … , {column -> value}]的列表
  • ‘index’：类似于{index -> {column -> value}}的字典
  • ‘columns’：类似于{column -> {index -> value}}的字典
  • ‘values’：仅值数组
  • ‘table’：类似于{‘schema’: {schema}, ‘data’: {data}}的字典

  描述数据，其中数据组件类似于orient='records'。

date_format

日期转换类型。‘epoch’= epoch 毫秒，‘iso’= ISO8601。默认取决于 orient。对于orient='table'，默认为‘iso’。对于所有其他 orient， 默认为‘epoch’。

double_precision整数，默认为 10

编码浮点值时要使用的小数位数。可能的最大值为 15。传递大于 15 的 double_precision 将引发 ValueError。

force_ascii布尔值，默认为 True

强制编码的字符串为 ASCII。

date_unit字符串，默认为‘ms’（毫秒）

编码的时间单位，控制时间戳和 ISO8601 的精度。其中‘s’、‘ms’、‘us’、‘ns’分别代表秒、毫秒、微秒和纳秒。

default_handler可调用对象���默认为 None

如果对象无法转换为 JSON 的适当格式，则调用处理程序。应接收一个参数，即要转换的对象，并返回一个可序列化对象。

lines布尔值，默认为 False

如果‘orient’为‘records’，则以行分隔的 json 格式进行写出。如果‘orient’不正确，将引发 ValueError，因为其他不是类似列表。

compression字符串或字典，默认为‘infer’

用于即时压缩输出数据。如果‘infer’和‘path_or_buf’类似于路径，则从以下扩展名中检测压缩：‘.gz’、‘.bz2’、‘.zip’、‘.xz’、‘.zst’、‘.tar’、‘.tar.gz’、‘.tar.xz’或‘.tar.bz2’（否则不压缩）。设置为None表示不压缩。也可以是一个字典，其中键'method'设置为其中之一{'zip'、'gzip'、'bz2'、'zstd'、'xz'、'tar'}，其他键值对转发给zipfile.ZipFile、gzip.GzipFile、bz2.BZ2File、zstandard.ZstdCompressor、lzma.LZMAFile或tarfile.TarFile。例如，可以传递以下内容以进行更快的压缩并创建可重现的 gzip 存档：compression={'method': 'gzip', 'compresslevel': 1, 'mtime': 1}。

版本 1.5.0 中的新功能：增加了对.tar 文件的支持。

版本 1.4.0 中的更改：增加了对 Zstandard 的支持。

indexbool 或 None，默认为 None

仅当‘orient’为‘split���、‘index’、‘column’或‘table’时才使用索引。其中，‘index’和‘column’不支持 index=False。

indentint，可选

用于缩进每个记录的空格长度。

storage_optionsdict，可选

针对特定存储连接的额外选项，例如主机、端口、用户名、密码等。对于 HTTP(S) URL，键值对将作为标头选项转发给urllib.request.Request。对于其他 URL（例如以“s3://”和“gcs://”开头的 URL），键值对将转发给fsspec.open。请参阅fsspec和urllib以获取更多详细信息，并参考这里获取有关存储选项的更多示例。

modestr，默认为‘w’（写入）

在提供 path_or_buf 时，指定输出的 IO 模式。接受的参数只有‘w’（写入）和‘a’（追加）。仅当 lines 为 True 且 orient 为‘records’时支持 mode=’a’。

返回：

None 或 str

如果 path_or_buf 为 None，则将生成的 json 格式作为字符串返回。否则返回 None。

另请参阅

read_json

将 JSON 字符串转换为 pandas 对象。

注意

indent=0的行为与 stdlib 中的行为不同，stdlib 不会缩进输出但会插入换行符。目前，在 pandas 中，indent=0和默认的indent=None是等效的，尽管这可能会在将来的版本中发生变化。

orient='table'在‘schema’下包含一个‘pandas_version’字段。这存储了在模式的最新修订版中使用的 pandas 版本。

示例

>>> from json import loads, dumps
>>> df = pd.DataFrame(
...     [["a", "b"], ["c", "d"]],
...     index=["row 1", "row 2"],
...     columns=["col 1", "col 2"],
... ) 

>>> result = df.to_json(orient="split")
>>> parsed = loads(result)
>>> dumps(parsed, indent=4)  
{
 "columns": [
 "col 1",
 "col 2"
 ],
 "index": [
 "row 1",
 "row 2"
 ],
 "data": [
 [
 "a",
 "b"
 ],
 [
 "c",
 "d"
 ]
 ]
} 

使用'records'格式化的 JSON 对 DataFrame 进行编码/解码。请注意，此编码不保留索引标签。

>>> result = df.to_json(orient="records")
>>> parsed = loads(result)
>>> dumps(parsed, indent=4)  
[
 {
 "col 1": "a",
 "col 2": "b"
 },
 {
 "col 1": "c",
 "col 2": "d"
 }
] 

使用'index'格式化的 JSON 对 DataFrame 进行编码/解码：

>>> result = df.to_json(orient="index")
>>> parsed = loads(result)
>>> dumps(parsed, indent=4)  
{
 "row 1": {
 "col 1": "a",
 "col 2": "b"
 },
 "row 2": {
 "col 1": "c",
 "col 2": "d"
 }
} 

使用'columns'格式化的 JSON 对 DataFrame 进行编码/解码：

>>> result = df.to_json(orient="columns")
>>> parsed = loads(result)
>>> dumps(parsed, indent=4)  
{
 "col 1": {
 "row 1": "a",
 "row 2": "c"
 },
 "col 2": {
 "row 1": "b",
 "row 2": "d"
 }
} 

使用'values'格式化的 JSON 对 DataFrame 进行编码/解码：

>>> result = df.to_json(orient="values")
>>> parsed = loads(result)
>>> dumps(parsed, indent=4)  
[
 [
 "a",
 "b"
 ],
 [
 "c",
 "d"
 ]
] 

使用 Table Schema 进行编码：

>>> result = df.to_json(orient="table")
>>> parsed = loads(result)
>>> dumps(parsed, indent=4)  
{
 "schema": {
 "fields": [
 {
 "name": "index",
 "type": "string"
 },
 {
 "name": "col 1",
 "type": "string"
 },
 {
 "name": "col 2",
 "type": "string"
 }
 ],
 "primaryKey": [
 "index"
 ],
 "pandas_version": "1.4.0"
 },
 "data": [
 {
 "index": "row 1",
 "col 1": "a",
 "col 2": "b"
 },
 {
 "index": "row 2",
 "col 1": "c",
 "col 2": "d"
 }
 ]
} 

pandas.io.json.build_table_schema

原文：pandas.pydata.org/docs/reference/api/pandas.io.json.build_table_schema.html

pandas.io.json.build_table_schema(data, index=True, primary_key=None, version=True)

从data创建表模式。

参数：

dataSeries，DataFrame

indexbool，默认为 True

是否在模式中包括data.index。

primary_keybool 或 None，默认为 True

要指定为主键的列名。默认值 None 将在索引唯一时将‘primaryKey’设置为索引级别或级别。

versionbool，默认为 True

是否包括一个字段pandas_version，用于记录上次修订表模式的 pandas 版本。此版本可能与已安装的 pandas 版本不同。

返回：

字典

注意

请参阅表模式以获取转换类型。时间增量转换为 ISO8601 格式，秒字段后面有 9 位小数，以实现纳秒精度。

分类数据转换为任何 dtype，并使用枚举字段约束列出允许的值。有序属性包含在有序字段中。

示例

>>> from pandas.io.json._table_schema import build_table_schema
>>> df = pd.DataFrame(
...     {'A': [1, 2, 3],
...      'B': ['a', 'b', 'c'],
...      'C': pd.date_range('2016-01-01', freq='d', periods=3),
...     }, index=pd.Index(range(3), name='idx'))
>>> build_table_schema(df)
{'fields': [{'name': 'idx', 'type': 'integer'}, {'name': 'A', 'type': 'integer'}, {'name': 'B', 'type': 'string'}, {'name': 'C', 'type': 'datetime'}], 'primaryKey': ['idx'], 'pandas_version': '1.4.0'} 

pandas.read_html

译文：pandas.pydata.org/docs/reference/api/pandas.read_html.html

pandas.read_html(io, *, match='.+', flavor=None, header=None, index_col=None, skiprows=None, attrs=None, parse_dates=False, thousands=',', encoding=None, decimal='.', converters=None, na_values=None, keep_default_na=True, displayed_only=True, extract_links=None, dtype_backend=_NoDefault.no_default, storage_options=None)

将 HTML 表格读取为DataFrame对象的list。

参数：

iostr、路径对象或类文件对象

字符串、实现os.PathLike[str]的路径对象，或实现字符串read()函数的类文件对象。该字符串可以表示 URL 或 HTML 本身。请注意，lxml 仅接受 http、ftp 和 file URL 协议。如果您有一个以 'https' 开头的 URL，您可以尝试删除 's'。

自版本 2.1.0 起已弃用：传递 html 文本字符串已弃用。请改用io.StringIO/io.BytesIO包装文本字符串/字节输入。

matchstr 或编译的正则表达式，可选

包含与此正则表达式或字符串匹配的文本的表将被返回。除非 HTML 非常简单，否则您可能需要传递一个非空字符串。默认为‘.+’（匹配任何非空字符串）。默认值将返回页面上包含的所有表。该值被转换为正则表达式，以便在 Beautiful Soup 和 lxml 之间有一致的行为。

flavor 或类似列表，可选

要使用的解析引擎（或解析引擎列表）。bs4 和 html5lib 是互为同义词，它们都是为了向后兼容而存在的。默认值为None，尝试使用lxml进行解析，如果失败则退回到bs4 + html5lib。

headerint 或类似列表，可选

用于将行（或用于使列标题的MultiIndex的行列表）的行。

index_colint 或类似列表，可选

用于创建索引的列（或列列表）。

skiprowsint、类似列表或切片，可选

在解析列整数后要跳过的行数。基于 0。如果给定整数序列或切片，将跳过由该序列索引的行。请注意，单个元素序列意味着‘跳过第 n 行’，而整数意味着‘跳过 n 行’。

attrsdict，可选

这是一个属性字典，您可以传递以用于在 HTML 中识别表。在传递给 lxml 或 Beautiful Soup 之前，这些属性不会被检查是否有效。但是，这些属性必须是有效的 HTML 表属性才能正常工作。例如，

attrs = {'id': 'table'} 

是一个有效的属性字典，因为‘id’ HTML 标签属性是根据此文档对于任何 HTML 标签都是有效的 HTML 属性。

attrs = {'asdf': 'table'} 

不是有效的属性字典，因为‘asdf’不是有效的 HTML 属性，即使它是有效的 XML 属性。可以在这里找到有效的 HTML 4.01 表属性。HTML 5 规范的工作草案可以在这里找到。它包含了现代 Web 的表属性的最新信息。

parse_dates布尔值，可选

有关更多详细信息，请参阅read_csv()。

thousands字符串，可选

用于解析千位分隔符的分隔符。默认为','。

encoding字符串，可选

用于解码网页的编码。默认为None。None保留了先前的编码行为，这取决于底层解析器库（例如，解析器库将尝试使用文档提供的编码）。

decimal字符串，默认为‘.’

用作小数点识别的字符（例如，对于欧洲数据使用‘,’）。

converters字典，默认为 None

用于转换特定列中的值的函数字典。键可以是整数或列标签，值是一个接受一个输入��数（单元格内容而不是列）的函数，并返回转换后的内容。

na_values可迭代对象，默认为 None

自定义 NA 值。

keep_default_na布尔值，默认为 True

如果指定了 na_values 并且 keep_default_na 为 False，则默认的 NaN 值将被覆盖，否则它们将被追加。

displayed_only布尔值，默认为 True

是否应解析具有“display: none”的元素。

extract_links

在指定部分中带有标签的表元素将提取其 href。

版本 1.5.0 中新增。

dtype_backend，默认为‘numpy_nullable’

应用于生成的DataFrame的后端数据类型（仍处于实验阶段）。行为如下：

• "numpy_nullable"：返回支持可空数据类型的DataFrame（默认）。

• "pyarrow"：返回支持 pyarrow 的可空ArrowDtype DataFrame。

版本 2.0 中新增。

storage_options字典，可选

针对特定存储连接有意义的额外选项，例如主机、端口、用户名、密码等。对于 HTTP(S) URL，键值对将作为标头选项转发给urllib.request.Request。对于其他 URL（例如以“s3://”和“gcs://”开头的 URL），键值对将转发给fsspec.open。请参阅fsspec和urllib以获取更多详细信息，并参考这里获取有关存储选项的更多示例。

版本 2.1.0 中新增。

返回：

dfs

一个 DataFrames 列表。

另请参阅

read_csv

将逗号分隔值（csv）文件读入 DataFrame。

注意

在使用此功能之前，您应该阅读关于 HTML 解析库的注意事项。

在调用此函数后，需要进行一些清理工作。例如，如果在传递 header=0 参数时，列名被转换为 NaN，则可能需要手动分配列名。我们尽量不对表格的结构做过多假设，并将表格中包含的 HTML 的特殊性推给用户。

此函数搜索<table>元素，仅搜索每个<tr>和<th>行以及表格中每个<tr>或<th>元素中的<td>元素。<td>代表“表格数据”。此函数尝试正确处理colspan和rowspan属性。如果函数有一个<thead>参数，则用于构建标题，否则函数尝试在主体中找到标题（将只包含<th>元素的行放入标题中）。

与read_csv()类似，header 参数在应用 skiprows 之后再应用。

此函数将始终返回一个DataFrame列表，否则将失败，例如，它不会返回空列表。

示例

查看文档中 IO 部分的 read_html 文档以查看一些读取 HTML 表格的示例。

pandas.DataFrame.to_html

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_html.html

DataFrame.to_html(buf=None, *, columns=None, col_space=None, header=True, index=True, na_rep='NaN', formatters=None, float_format=None, sparsify=None, index_names=True, justify=None, max_rows=None, max_cols=None, show_dimensions=False, decimal='.', bold_rows=True, classes=None, escape=True, notebook=False, border=None, table_id=None, render_links=False, encoding=None)

将 DataFrame 渲染为 HTML 表。

参数：

bufstr、路径或类似于 StringIO 的对象，可选，默认为 None

要写入的缓冲区。如果为 None，则返回输出为字符串。

columnsarray-like，可选，默认为 None

要写入的列的子集。默认情况下写入所有列。

col_spacestr 或 int，int 或 str 的列表或字典，可选

每列的最小宽度，以 CSS 长度单位表示。假定 int 是 px 单位。

headerbool，可选

是否打印列标签，默认为 True。

indexbool，可选，默认为 True

是否打印索引（行）标签。

na_repstr，可选，默认为‘NaN’

用于 NaN 的字符串表示。

formatterslist、tuple 或带一个参数的函数的字典，可选

按位置或名称应用于列元素的格式化函数。每个函数的结果必须是一个 unicode 字符串。列表/元组的长度必须等于列数。

float_format带一个参数的函数，可选，默认为 None

如果它们是浮点数，应用于列元素的格式化函数。该函数必须返回一个 unicode 字符串，并且仅适用于非NaN元素，NaN由na_rep处理。

sparsifybool，可选，默认为 True

设置为 False 以打印具有分层索引的 DataFrame 中的每个多索引键。

index_namesbool，可选，默认为 True

打印索引的名称。

justifystr，默认为 None

如何对齐列标签。如果为 None，则使用打印配置的选项（由 set_option 控制），‘right’立即生效。有效值为

• 左

• 右

• 居中

• 对齐

• justify-all

• 开始

• 结束

• 继承

• 匹配父元素

• 初始

• 取消设置。

max_rowsint，可选

在控制台中显示的最大行数。

max_colsint，可选

在控制台中显示的最大列数。

show_dimensionsbool，默认为 False

显示 DataFrame 的维度（行数乘以列数）。

decimalstr，默认为‘.’

十进制分隔符，例如在欧洲为 ‘,’。

bold_rowsbool，默认为 True

使输出中的行标签加粗。

classesstr 或列表或元组，默认为 None

应用于生成的 HTML 表的 CSS 类。

escapebool，默认为 True

将字符<、>和&转换为 HTML 安全序列。

notebook，默认为 False

生成的 HTML 是否为 IPython Notebook 专用。

borderint

在开放的

标签中包含了一个 border=border 属性。默认为 pd.options.display.html.border。

table_idstr，可选

如果指定，则在开放的

标签中包含一个 css id。

render_linksbool，默认为 False

将 URL 转换为 HTML 链接。

encodingstr，默认为“utf-8”

设置字符编码。

返回：

str 或 None

如果 buf 为 None，则返回结果为字符串。否则返回 None。

另请参阅

to_string

将 DataFrame 转换为字符串。

示例

>>> df = pd.DataFrame(data={'col1': [1, 2], 'col2': [4, 3]})
>>> html_string = '''<table border="1" class="dataframe">
...   <thead>
...     <tr style="text-align: right;">
...       <th></th>
...       <th>col1</th>
...       <th>col2</th>
...     </tr>
...   </thead>
...   <tbody>
...     <tr>
...       <th>0</th>
...       <td>1</td>
...       <td>4</td>
...     </tr>
...     <tr>
...       <th>1</th>
...       <td>2</td>
...       <td>3</td>
...     </tr>
...   </tbody>
... </table>'''
>>> assert html_string == df.to_html() 

pandas.io.formats.style.Styler.to_html

原文：pandas.pydata.org/docs/reference/api/pandas.io.formats.style.Styler.to_html.html

Styler.to_html(buf=None, *, table_uuid=None, table_attributes=None, sparse_index=None, sparse_columns=None, bold_headers=False, caption=None, max_rows=None, max_columns=None, encoding=None, doctype_html=False, exclude_styles=False, **kwargs)

将 Styler 写入 HTML-CSS 格式的文件、缓冲区或字符串。

新版本 1.3.0。

参数：

bufstr，路径对象，类似文件对象，可选

字符串，路径对象（实现 os.PathLike[str]），或实现字符串 write() 函数的类似文件对象。如果为 None，则结果将作为字符串返回。

table_uuidstr，可选

将 id 属性分配给

HTML 元素的格式：

<table id="T_<table_uuid>" ..>

如果未给出，则使用 Styler 最初分配的值。

table_attributesstr，可选

分配给

HTML 元素的属性的格式：

<table .. <table_attributes> >

如果未给出，则默认为 Styler 的现有值。

sparse_indexbool，可选

是否稀疏显示分层索引。设置为 False 将为每行显示分层键的每个显式级别元素。默认为 pandas.options.styler.sparse.index 值。

新版本 1.4.0。

sparse_columnsbool，可选

是否稀疏显示分层索引。设置为 False 将为每列显示分层键的每个显式级别元素。默认为 pandas.options.styler.sparse.columns 值。

新版本 1.4.0。

bold_headersbool，可选

将 “font-weight: bold;” 添加为 CSS 属性以应用于表格样式标题单元格。

新版本 1.4.0。

captionstr，可选

在呈现之前设置或覆盖 Styler 上的标题。

新版本 1.4.0。

max_rowsint，可选

将呈现的最大行数。默认为 pandas.options.styler.render.max_rows/max_columns。

新版本 1.4.0。

max_columnsint，可选

将呈现的最大列数。默认为 pandas.options.styler.render.max_columns，即 None。

如果总元素数量较大，则可能会减少行和列。此值设置为 pandas.options.styler.render.max_elements，即 262144（18 位浏览器渲染）。

新版本 1.4.0。

encodingstr，可选

文件输出的字符编码设置（如果可用，则为 meta 标签）。默认为 “utf-8”的 pandas.options.styler.render.encoding 值。

doctype_htmlbool，默认为 False

是否输出包含所有 HTML 元素的完全结构化 HTML 文件，或仅包含核心 <style> 和 <table> 元素。

exclude_stylesbool，默认为 False

是否包括 <style> 元素和所有相关元素的 class 和 id 标识符，或仅包含 <table> 元素而不包含样式标识符。

**kwargs

任何额外的关键字参数都会传递给 jinja2 self.template.render 过程。当您需要为自定义模板提供额外变量时，这很有用。

返回：

str 或 None

如果 buf 为 None，则将结果作为字符串返回。否则返回 None。

另请参阅

DataFrame.to_html

将 DataFrame 以 HTML 格式写入文件、缓冲区或字符串。

示例

>>> df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
>>> print(df.style.to_html())  
<style type="text/css">
</style>
<table id="T_1e78e">
 <thead>
 <tr>
 <th class="blank level0" >&nbsp;</th>
 <th id="T_1e78e_level0_col0" class="col_heading level0 col0" >A</th>
 <th id="T_1e78e_level0_col1" class="col_heading level0 col1" >B</th>
 </tr>
... 

pandas.read_xml

原文：pandas.pydata.org/docs/reference/api/pandas.read_xml.html

pandas.read_xml(path_or_buffer, *, xpath='./*', namespaces=None, elems_only=False, attrs_only=False, names=None, dtype=None, converters=None, parse_dates=None, encoding='utf-8', parser='lxml', stylesheet=None, iterparse=None, compression='infer', storage_options=None, dtype_backend=_NoDefault.no_default)

将 XML 文档读取为 DataFrame 对象。

自版本 1.3.0 起。

参数：

path_or_bufferstr、路径对象或类似文件的对象

字符串、路径对象（实现 os.PathLike[str]）或实现 read() 函数的类似文件的对象。字符串可以是任何有效的 XML 字符串或路径。字符串还可以是 URL。有效的 URL 方案包括 http、ftp、s3 和 file。

自版本 2.1.0 起已弃用：传递 xml 文本字符串已弃用。请改用 io.StringIO 或 io.BytesIO 包装字面 xml 输入。

xpathstr，可选，默认为 ‘./*’

用于迁移到 DataFrame 所需节点集的 XPath。XPath 应返回一个元素集合，而不是单个元素。注意：etree 解析器支持有限的 XPath 表达式。对于更复杂的 XPath，请使用需要安装的 lxml。

namespaces字典，可选

XML 文档中定义的命名空间，以字典形式表示，键为命名空间前缀，值为 URI。在 XML 中不需要包含所有命名空间，只需要在 xpath 表达式中使用的命名空间。注意：如果 XML 文档使用默认命名空间表示为 xmlns=’’ 而没有前缀，则必须为 URI 分配任何临时命名空间前缀，例如 ‘doc’，以解析底层节点和/或属性。例如，

namespaces = {"doc": "https://example.com"} 

elems_onlybool，可选，默认为 False

仅解析指定 xpath 处的子元素。默认情况下，返回所有子元素和非空文本节点。

attrs_onlybool，可选，默认为 False

仅解析指定 xpath 处的属性。默认情况下，返回所有属性。

names类似列表，可选

DataFrame 中解析的 XML 数据的列名。使用此参数重命名原始元素名称，并区分相同名称的元素和属性。

dtype类型名称或列 -> 类型的字典，可选

数据或列的数据类型。例如 {‘a’: np.float64, ‘b’: np.int32, ‘c’: ‘Int64’} 使用 str 或 object 以及适当的 na_values 设置来保留并不解释 dtype。如果指定了转换器，则将应用转换器而不是 dtype 转换。

自版本 1.5.0 起。

converters字典，可选

用于转换特定列中值的函数字典。键可以是整数或列标签。

自版本 1.5.0 起。

parse_datesbool 或 int 或名称列表或列表的列表或字典，默认为 False

解析索引或列为日期时间的标识符。行为如下：

• 布尔值。如果为 True -> 尝试解析索引。

• int 或名称列表。例如，如果 [1, 2, 3] -> 尝试将列 1、2、3 分别解析为单独的日期列。

• 列表的列表。例如，如果 [[1, 3]] -> 结合列 1 和 3 并解析为单个日期列。

• 字典，例如 {‘foo’ : [1, 3]} -> 将列 1、3 解析为日期并称结果为 ‘foo’。

新功能版本 1.5.0。

encoding 字符串，可选，默认为 ‘utf-8’

XML 文档的编码。

parser {‘lxml’、’etree’}，默认为 ‘lxml’

用于检索数据的解析器模块。仅支持 ‘lxml’ 和 ‘etree’。使用 ‘lxml’ 可以支持更复杂的 XPath 搜索和使用 XSLT 样式表的能力。

stylesheet 字符串、路径对象或类似文件的对象

URL、类似文件的对象或包含 XSLT 脚本的原始字符串。此样式表应将复杂的、深度嵌套的 XML 文档展平，以便更容易解析。要使用此功能，您必须安装 lxml 模块，并将 lxml 指定为 parser。xpath 必须引用经过 XSLT 转换生成的转换后的 XML 文档中的节点，而不是原始 XML 文档。目前仅支持 XSLT 1.0 脚本，不支持更新版本。

iterparse 字典，可选

XML 文档的迭代解析中要检索的节点或属性，格式为字典，键为重复元素的名称，值为重复元素的后代元素或属性名称的列表。注意：如果使用了此选项，它将替换 xpath 解析，而不像 xpath 那样，后代元素不需要相互关联，而可以存在于文档中重复元素的任何位置。这种内存高效的方法应用于非常大的 XML 文件（500MB、1GB 或 5GB+）。例如，

iterparse = {"row_element": ["child_elem", "attr", "grandchild_elem"]} 

新功能版本 1.5.0。

compression 字符串或字典，默认为 ‘infer’

用于在磁盘上的数据上进行即时解压缩。如果 ‘infer’ 并且 ‘path_or_buffer’ 是类似路径的，则从以下扩展名检测压缩：‘.gz’、‘.bz2’、‘.zip’、‘.xz’、‘.zst’、‘.tar’、‘.tar.gz’、‘.tar.xz’ 或 ‘.tar.bz2’（否则不压缩）。如果使用 'zip' 或 'tar'，ZIP 文件必须只包含一个要读取的数据文件。设置为 None 不进行解压缩。也可以是一个字典，键为 'method'，设置为其中之一 {'zip'、'gzip'、'bz2'、'zstd'、'xz'、'tar'}，其他键值对转发到 zipfile.ZipFile、gzip.GzipFile、bz2.BZ2File、zstandard.ZstdDecompressor、lzma.LZMAFile 或 tarfile.TarFile。例如，可以通过自定义压缩字典传递以下内容以进行 Zstandard 解压缩：compression={'method': 'zstd', 'dict_data': my_compression_dict}。

新功能版本 1.5.0：增加了对 .tar 文件的支持。

版本 1.4.0 中的更改：Zstandard 支持。

storage_options 字典，可选

适用于特定存储连接的额外选项，例如主机、端口、用户名、密码等。对于 HTTP(S) URL，键值对将作为标头选项转发给urllib.request.Request。对于其他 URL（例如以“s3://”和“gcs://”开头的 URL），键值对将转发给fsspec.open。请参阅fsspec和urllib以获取更多详细信息，并参考此处中的存储选项示例。

dtype_backend，默认为‘numpy_nullable’

应用于生成的DataFrame的后端数据类型（仍处于实验阶段）。行为如下：

• "numpy_nullable"：返回支持可空 dtype 的DataFrame（默认）。

• "pyarrow"：返回由 pyarrow 支持的可空ArrowDtype DataFrame。

版本 2.0 中的新功能。

返回：

df

一个 DataFrame。

另请参见

read_json

将 JSON 字符串转换为 pandas 对象。

read_html

将 HTML 表格读入 DataFrame 对象列表。

注意

此方法最适合导入以下格式的浅层 XML 文档，这是DataFrame（按行列）的理想适配。

<root>
    <row>
      <column1>data</column1>
      <column2>data</column2>
      <column3>data</column3>
      ...
   </row>
   <row>
      ...
   </row>
   ...
</root> 

作为文件格式，XML 文档可以以任何方式设计，包括元素和属性的布局，只要符合 W3C 规范即可。因此，此方法是特定扁平设计的便利处理程序，而不是所有可能的 XML 结构。

但是，对于更复杂的 XML 文档，stylesheet允许您使用 XSLT（一种特殊用途语言）临时重新设计原始文档，以便迁移到 DataFrame 的扁平版本。

此函数将始终返回单个DataFrame或由于 XML 文档、xpath或其他参数问题而引发异常。

有关使用此方法将 XML 文件解析为 DataFrame 的更多信息，请参阅文档中 IO 部分的 read_xml 文档。

示例

>>> from io import StringIO
>>> xml = '''<?xml version='1.0' encoding='utf-8'?>
... <data >
...  <row>
...    <shape>square</shape>
...    <degrees>360</degrees>
...    <sides>4.0</sides>
...  </row>
...  <row>
...    <shape>circle</shape>
...    <degrees>360</degrees>
...    <sides/>
...  </row>
...  <row>
...    <shape>triangle</shape>
...    <degrees>180</degrees>
...    <sides>3.0</sides>
...  </row>
... </data>''' 

>>> df = pd.read_xml(StringIO(xml))
>>> df
 shape  degrees  sides
0    square      360    4.0
1    circle      360    NaN
2  triangle      180    3.0 

>>> xml = '''<?xml version='1.0' encoding='utf-8'?>
... <data>
...   <row shape="square" degrees="360" sides="4.0"/>
...   <row shape="circle" degrees="360"/>
...   <row shape="triangle" degrees="180" sides="3.0"/>
... </data>''' 

>>> df = pd.read_xml(StringIO(xml), xpath=".//row")
>>> df
 shape  degrees  sides
0    square      360    4.0
1    circle      360    NaN
2  triangle      180    3.0 

>>> xml = '''<?xml version='1.0' encoding='utf-8'?>
... <doc:data >
...   <doc:row>
...     <doc:shape>square</doc:shape>
...     <doc:degrees>360</doc:degrees>
...     <doc:sides>4.0</doc:sides>
...   </doc:row>
...   <doc:row>
...     <doc:shape>circle</doc:shape>
...     <doc:degrees>360</doc:degrees>
...     <doc:sides/>
...   </doc:row>
...   <doc:row>
...     <doc:shape>triangle</doc:shape>
...     <doc:degrees>180</doc:degrees>
...     <doc:sides>3.0</doc:sides>
...   </doc:row>
... </doc:data>''' 

>>> df = pd.read_xml(StringIO(xml),
...                  xpath="//doc:row",
...                  namespaces={"doc": "https://example.com"})
>>> df
 shape  degrees  sides
0    square      360    4.0
1    circle      360    NaN
2  triangle      180    3.0 

>>> xml_data = '''
...         <data>
...            <row>
...               <index>0</index>
...               <a>1</a>
...               <b>2.5</b>
...               <c>True</c>
...               <d>a</d>
...               <e>2019-12-31 00:00:00</e>
...            </row>
...            <row>
...               <index>1</index>
...               <b>4.5</b>
...               <c>False</c>
...               <d>b</d>
...               <e>2019-12-31 00:00:00</e>
...            </row>
...         </data>
...         ''' 

>>> df = pd.read_xml(StringIO(xml_data),
...                  dtype_backend="numpy_nullable",
...                  parse_dates=["e"])
>>> df
 index     a    b      c  d          e
0      0     1  2.5   True  a 2019-12-31
1      1  <NA>  4.5  False  b 2019-12-31 

pandas.DataFrame.to_xml

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_xml.html

DataFrame.to_xml(path_or_buffer=None, *, index=True, root_name='data', row_name='row', na_rep=None, attr_cols=None, elem_cols=None, namespaces=None, prefix=None, encoding='utf-8', xml_declaration=True, pretty_print=True, parser='lxml', stylesheet=None, compression='infer', storage_options=None)

将 DataFrame 渲染为 XML 文档。

版本 1.3.0 中的新功能。

参数：

path_or_buffer字符串、路径对象、类文件对象或 None，默认为 None

字符串、路径对象（实现os.PathLike[str]）、或实现write()函数的类文件对象。如果为 None，则结果将作为字符串返回。

index布尔值，默认为 True

是否在 XML 文档中包含索引。

root_name字符串，默认为‘data’

XML 文档中根元素的名称。

row_name字符串，默认为‘row’

XML 文档中行元素的名称。

na_rep字符串，可选

缺失数据的表示。

attr_cols类似列表，可选

要写入为行元素属性的列的列表。层次列将使用下划线分隔不同级别。

elem_cols类似列表，可选

要写入为行元素子元素的列的列表。默认情况下，所有列都作为行元素的子元素输出。层次列将使用下划线分隔不同级别。

namespaces字典，可选

在根元素中定义的所有命名空间。字典的键应该是前缀名称，字典的值应该是对应的 URI。默认命名空间应该给出空字符串键。例如，

namespaces = {"": "https://example.com"} 

prefix字符串，可选

文档中每个元素和/或属性使用的命名空间前缀。这应该是namespaces字典中的键之一。

encoding字符串，默认为‘utf-8’

结果文档的编码。

xml_declaration布尔值，默认为 True

是否在文档开头包含 XML 声明。

pretty_print布尔值，默认为 True

输出是否应该进行漂亮的打印，包括缩进和换行。

parser，默认为‘lxml’

用于构建树的解析器模块。仅支持‘lxml’和‘etree’。使用‘lxml’，支持使用 XSLT 样式表的能力。

stylesheet字符串、路径对象或类文件对象，可选

用于转换原始 XML 输出的 XSLT 脚本的 URL、类文件对象或包含 XSLT 脚本的原始字符串。脚本应该使用来自原始输出的元素和属性的布局。此参数需要安装lxml。目前仅支持 XSLT 1.0 脚本，不支持更新版本。

compression字符串或字典，默认为‘infer’

用于对输出数据进行即时压缩。如果‘infer’和‘path_or_buffer’类似于路径，则从以下扩展名检测压缩：‘.gz’、‘.bz2’、‘.zip’、‘.xz’、‘.zst’、‘.tar’、‘.tar.gz’、‘.tar.xz’或‘.tar.bz2’（否则不压缩）。设置为None表示不压缩。也可以是一个字典，其中键 'method' 设置为其中之一 {'zip', 'gzip', 'bz2', 'zstd', 'xz', 'tar'}，其他键值对转发给 zipfile.ZipFile、gzip.GzipFile、bz2.BZ2File、zstandard.ZstdCompressor、lzma.LZMAFile 或 tarfile.TarFile。例如，可以传递以下内容以进行更快的压缩并创建可重现的 gzip 存档：compression={'method': 'gzip', 'compresslevel': 1, 'mtime': 1}。

版本 1.5.0 中的新功能：增加了对 .tar 文件的支持。

版本 1.4.0 中的更改：Zstandard 支持。

storage_optionsdict，可选

针对特定存储连接有意义的额外选项，例如主机、端口、用户名、密码等。对于 HTTP(S) URL，键值对将作为标头选项转发给 urllib.request.Request。对于其他 URL（例如以“s3://”和“gcs://”开头的 URL），键值对将转发给 fsspec.open。请参阅 fsspec 和 urllib 以获取更多详细信息，并参考此处有关存储选项的更多示例。

返回：

None 或 str

如果 io 为 None，则返回结果的 XML 格式作为字符串。否则返回 None。

另请参见

to_json

将 pandas 对象转换为 JSON 字符串。

to_html

将 DataFrame 转换为 HTML。

示例

>>> df = pd.DataFrame({'shape': ['square', 'circle', 'triangle'],
...                    'degrees': [360, 360, 180],
...                    'sides': [4, np.nan, 3]}) 

>>> df.to_xml()  
<?xml version='1.0' encoding='utf-8'?>
<data>
 <row>
 <index>0</index>
 <shape>square</shape>
 <degrees>360</degrees>
 <sides>4.0</sides>
 </row>
 <row>
 <index>1</index>
 <shape>circle</shape>
 <degrees>360</degrees>
 <sides/>
 </row>
 <row>
 <index>2</index>
 <shape>triangle</shape>
 <degrees>180</degrees>
 <sides>3.0</sides>
 </row>
</data> 

>>> df.to_xml(attr_cols=[
...           'index', 'shape', 'degrees', 'sides'
...           ])  
<?xml version='1.0' encoding='utf-8'?>
<data>
 <row index="0" shape="square" degrees="360" sides="4.0"/>
 <row index="1" shape="circle" degrees="360"/>
 <row index="2" shape="triangle" degrees="180" sides="3.0"/>
</data> 

>>> df.to_xml(namespaces={"doc": "https://example.com"},
...           prefix="doc")  
<?xml version='1.0' encoding='utf-8'?>
<doc:data >
 <doc:row>
 <doc:index>0</doc:index>
 <doc:shape>square</doc:shape>
 <doc:degrees>360</doc:degrees>
 <doc:sides>4.0</doc:sides>
 </doc:row>
 <doc:row>
 <doc:index>1</doc:index>
 <doc:shape>circle</doc:shape>
 <doc:degrees>360</doc:degrees>
 <doc:sides/>
 </doc:row>
 <doc:row>
 <doc:index>2</doc:index>
 <doc:shape>triangle</doc:shape>
 <doc:degrees>180</doc:degrees>
 <doc:sides>3.0</doc:sides>
 </doc:row>
</doc:data> 

pandas.DataFrame.to_latex

译文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_latex.html

DataFrame.to_latex(buf=None, *, columns=None, header=True, index=True, na_rep='NaN', formatters=None, float_format=None, sparsify=None, index_names=True, bold_rows=False, column_format=None, longtable=None, escape=None, encoding=None, decimal='.', multicolumn=None, multicolumn_format=None, multirow=None, caption=None, label=None, position=None)

将对象呈现为 LaTeX 表格、长表或嵌套表。

需要\usepackage{{booktabs}}。输出可以复制/粘贴到主 LaTeX 文档中，或从外部文件中读取\input{{table.tex}}。

在 2.0.0 版本中更改：重构为使用 Styler 实现通过 jinja2 模板化。

参数：

bufstr，路径或类似 StringIO 的对象，可选，默认为 None

要写入的缓冲区。如果为 None，则输出作为字符串返回。

columns标签列表，可选

要写入的列的子集。默认情况下写入所有列。

headerbool 或字符串列表，默认为 True

写出列名。如果给出字符串列表，则假定为列名的别名。

indexbool，默认为 True

写入行名称（索引）。

na_repstr，默认为‘NaN’

缺失数据表示。

formatters函数列表或{{str: function}}字典，可选

按位置或名称应用于列元素的格式化函数。每个函数的结果必须是 Unicode 字符串。列表的长度必须等于列数。

float_format一参数函数或 str，可选，默认为 None

浮点数的格式化程序。例如float_format="%.2f"和float_format="{{:0.2f}}".format都会使 0.1234 格式化为 0.12。

sparsifybool，可选

对于具有分层索引的 DataFrame，设置为 False 以在每行打印每个多重索引键。默认情况下，该值将从配置模块中读取。

index_namesbool，默认为 True

打印索引的名称。

bold_rowsbool，默认为 False

使输出中的行标签加粗。

column_formatstr，可选

表格列的格式如LaTeX 表格格式中指定的格式，例如对于 3 列使用‘rcl’。默认情况下，除了数字列，默认使用‘l’。

longtablebool，可选

使用 longtable 环境而不是 tabular。需要在 LaTeX 导言中添加 usepackage{{longtable}}。默认情况下，该值将从 pandas 配置模块中读取，并且如果选项styler.latex.environment为“longtable”，则设置为 True。

在 2.0.0 版本中更改：影响此参数的 pandas 选项已更改。

escapebool，可选

默认情况下，该值将从 pandas 配置模块中读取，并且如果选项styler.format.escape为“latex”，则设置为 True。当设置为 False 时，防止在列名中转义 latex 特殊字符。

在 2.0.0 版本中更改：影响此参数的 pandas 选项已更改，以及默认值为 False。

encodingstr，可选

表示要在输出文件中使用的编码的字符��，默认为‘utf-8’。

decimalstr，默认为‘.’

在欧洲，逗号‘,’被识别为小数分隔符。

multicolumnbool，默认为 True

使用多列增强 MultiIndex 列。默认值将从配置模块中读取，并设置为选项styler.sparse.columns。

从版本 2.0.0 开始更改：影响此参数的 pandas 选项已更改。

multicolumn_formatstr，默认为‘r’

用于多列对齐的对齐方式，类似于 column_format。默认值将从配置模块中读取，并设置为选项styler.latex.multicol_align。

从版本 2.0.0 开始更改：影响此参数的 pandas 选项已更改， 默认值也更改为“r”。

multirowbool，默认为 True

使用多行增强 MultiIndex 行。需要在 LaTeX 导言中添加 usepackage{{multirow}}。将在包含的行中打印居中标签（而不是顶部对齐），通过 clines 分隔组。默认值将从 pandas 配置模块中读取，并设置为选项styler.sparse.index。

从版本 2.0.0 开始更改：影响此参数的 pandas 选项已更改， 默认值也更改为 True。

captionstr 或 元组，可选

元组（full_caption，short_caption），这将导致\caption[short_caption]{{full_caption}}；如果传递单个字符串，则不会设置短标题。

labelstr，可选

要放置在输出中\label{{}}内的 LaTeX 标签。这与主.tex文件中的\ref{{}}一起使用。

positionstr，可选

表格的 LaTeX 位置参数，在输出中放置在\begin{{}}之后。

返回：

str 或 None

如果 buf 为 None，则将结果作为字符串返回。否则返回 None。

另请参阅

io.formats.style.Styler.to_latex

使用条件格式化将 DataFrame 渲染为 LaTeX。

DataFrame.to_string

将 DataFrame 渲染为适合控制台的表格输出。

DataFrame.to_html

将 DataFrame 渲染为 HTML 表格。

注意

从 v2.0.0 开始，此方法已更改为使用 Styler 实现作为Styler.to_latex()的一部分，通过jinja2模板化。这意味着jinja2是一个要求，并且需要安装，以使此方法正常运行。建议用户切换到使用 Styler，因为该实现更经常更新，并且在输出方面具有更大的灵活性。

示例

将通用 DataFrame 转换为带格式的 LaTeX：

>>> df = pd.DataFrame(dict(name=['Raphael', 'Donatello'],
...                        age=[26, 45],
...                        height=[181.23, 177.65]))
>>> print(df.to_latex(index=False,
...                   formatters={"name": str.upper},
...                   float_format="{:.1f}".format,
... ))  
\begin{tabular}{lrr}
\toprule
name & age & height \\
\midrule
RAPHAEL & 26 & 181.2 \\
DONATELLO & 45 & 177.7 \\
\bottomrule
\end{tabular} 

pandas.io.formats.style.Styler.to_latex

原文：pandas.pydata.org/docs/reference/api/pandas.io.formats.style.Styler.to_latex.html

Styler.to_latex(buf=None, *, column_format=None, position=None, position_float=None, hrules=None, clines=None, label=None, caption=None, sparse_index=None, sparse_columns=None, multirow_align=None, multicol_align=None, siunitx=False, environment=None, encoding=None, convert_css=False)

将 Styler 写入 LaTeX 格式的文件、缓冲区或字符串。

从版本 1.3.0 开始新增。

参数：

bufstr、路径对象、类文件对象或 None，默认为 None

字符串、实现 os.PathLike[str] 的路径对象或实现字符串 write() 函数的类文件对象。如果为 None，则将结果作为字符串返回。

column_formatstr，可选

放置在位置的 LaTeX 列规范：

\begin{tabular}{<column_format>}

对于索引和非数字数据列，默认为 ‘l’，对于数值数据列，默认为 ‘r’，如果 siunitx 为 True，则为 ‘S’。

positionstr，可选

表的 LaTeX 定位参数（例如 ‘h!’），放置在位置：

\\begin{table}[<position>]。

position_float，可选

放置在位置的 LaTeX 浮动命令：

\begin{table}[]

<position_float>

如果 environment 是 “longtable”，则不能使用。

hrulesbool

设置为 True 以从 {booktabs} LaTeX 包添加 \toprule、\midrule 和 \bottomrule。默认为 pandas.options.styler.latex.hrules，为 False。

在版本 1.4.0 中更改。

clinesstr，可选

用于控制添加 \cline 命令以分隔索引标签。可能的值为：

• None：不添加 cline 命令（默认值）。
• “all;data”：为每个索引值添加一个 cline，延伸表的宽度，包括数据条目。
• “all;index”：与上述相同，只是线条仅延伸到索引条目的宽度。
• “skip-last;data”：除了最后一级（永远不会稀疏化）之外，为每个索引值添加一个 cline，延伸表的宽度。
• “skip-last;index”：与上述相同，只是线条仅延伸到索引条目的宽度。

从版本 1.4.0 开始新增。

labelstr，可选

包含为 LaTeX 添加的标签：\label{}。这与主 .tex 文件中的 \ref{} 一起使用。

captionstr、元组，可选

如果是字符串，则包含为 LaTeX 表添加的标题：\caption{

}。如果是元组，即 (“完整标题”, “简短标题”)，则将标题包含为：\caption[<caption[1]>]{<caption[0]>}。

sparse_indexbool，可选

是否稀疏化显示分层索引。设置为 False 将为每一行的分层键中的每个明确级别元素显示一个。默认为 pandas.options.styler.sparse.index，为 True。

sparse_columnsbool，可选

是否稀疏化显示分层索引。设置为 False 将为每个列的分层键中的每个明确级别元素显示一个。默认为 pandas.options.styler.sparse.columns，为 True。

multirow_align，可选

如果稀疏化分层 MultiIndexes，文本是居中对齐、顶部对齐还是底部对齐，使用 multirow 包。如果未给出，默认为pandas.options.styler.latex.multirow_align，即“c”。如果给出“naive”，则会渲染为无 multirow。

在 1.4.0 版本中更改。

multicol_align，可选

如果稀疏化分层 MultiIndex 列，文本是否对齐在左侧、中间或右侧。如果未给出，默认为pandas.options.styler.latex.multicol_align，即“r”。如果给出了一个简单的选项，则会渲染为无多列。管道修饰符也可以添加到非简单值上，以绘制垂直线，例如，“|r”将在右对齐的合并单元格的左侧绘制一条线。

在 1.4.0 版本中更改。

siunitxbool，默认为 False

设置为True以使 LaTeX 与{siunitx}包兼容。

环境str，可选

如果给出，将替换\\begin{table}中的‘table’的环境。如果指定了‘longtable’，则会呈现更合适的模板。如果未给出，默认为pandas.options.styler.latex.environment，即 None。

1.4.0 版本中的新功能。

encodingstr，可选

字符编码设置。默认为pandas.options.styler.render.encoding，即“utf-8”。

convert_cssbool，默认为 False

将简单的单元格样式从 CSS 转换为 LaTeX 格式。任何未在转换表中找到的 CSS 都将被丢弃。可以通过添加选项--latex 来强制应用样式。请参阅注释。

返回：

str 或 None

如果 buf 为 None，则将结果作为字符串返回。否则返回 None。

另请参见

Styler.format

格式化单元格的文本显示值。

注释

Latex 包

对于以下功能，我们建议使用以下 LaTeX 插入：

功���	包含
稀疏列	无：包含在默认的{tabular}环境中
稀疏行	\usepackage
hrules	\usepackage
颜色	\usepackage[table]
siunitx	\usepackage
粗体（带有 siunitx）	\usepackage{etoolbox}\robustify\bfseries\sisetup{detect-all = true} (在{document}内)
斜体（带有 siunitx）	\usepackage{etoolbox}\robustify\itshape\sisetup{detect-all = true} (在{document}内)
环境	如果 arg 为“longtable”则使用\usepackage{longtable} | 或任何其他相关的环境包
超链接	\usepackage

单元格样式

只有在伴随的样式函数已经用适当的 LaTeX 命令构建时，LaTeX 样式才能被渲染。所有样式功能都围绕着 CSS (<attribute>, <value>)对的概念构建（参见表格可视化），这应该被一个 LaTeX (<command>, <options>)方法所取代。每个单元格将使用嵌套的 LaTeX 命令及其伴随的选项进行单独样式化。

例如，以下代码将在 HTML-CSS 中突出显示并加粗一个单元格：

>>> df = pd.DataFrame([[1,2], [3,4]])
>>> s = df.style.highlight_max(axis=None,
...                            props='background-color:red; font-weight:bold;')
>>> s.to_html() 

使用仅限于 LaTeX 的命令的等效格式如下：

>>> s = df.style.highlight_max(axis=None,
...                            props='cellcolor:{red}; bfseries: ;')
>>> s.to_latex() 

在内部，这些结构化的 LaTeX (<command>, <options>) 对被转换为 display_value，默认结构为：\<command><options> <display_value>。在存在多个命令的情况下，后者会递归嵌套，因此上面的示例突出显示的单元格呈现为 \cellcolor{red} \bfseries 4。

偶尔，这种格式不适合应用的命令或正在使用的 LaTeX 包的组合，因此可以在元组的 <options> 中添加附加标志，以产生所需括号的不同位置（默认与 --nowrap 相同）：

元组格式	输出结构
（,）	<command> <display_value>
（, --nowrap）	<command> <display_value>
（, --rwrap）	<command>
（, --wrap）	{<command> <display_value>}
（, --lwrap）	{<command>} <display_value>
（, --dwrap）	{<command>}

例如，应始终使用带有 -rwrap 的 textbf 命令来设置字体粗细，因此 ('textbf', '--rwrap') 将渲染一个可用的单元格，用大括号包裹，如 \textbf{<display_value>}。

更全面的示例如下：

>>> df = pd.DataFrame([[1, 2.2, "dogs"], [3, 4.4, "cats"], [2, 6.6, "cows"]],
...                   index=["ix1", "ix2", "ix3"],
...                   columns=["Integers", "Floats", "Strings"])
>>> s = df.style.highlight_max(
...     props='cellcolor:[HTML]{FFFF00}; color:{red};'
...           'textit:--rwrap; textbf:--rwrap;'
... )
>>> s.to_latex() 

表格样式

在内部，Styler 使用其 table_styles 对象来解析 column_format、position、position_float 和 label 输入参数。这些参数以以下格式添加到表样式中：

set_table_styles([
    {"selector": "column_format", "props": f":{column_format};"},
    {"selector": "position", "props": f":{position};"},
    {"selector": "position_float", "props": f":{position_float};"},
    {"selector": "label", "props": f":{{{label.replace(':','§')}}};"}
], overwrite=False) 

对于 hrules 参数的例外情况，实际上它同时控制所有三个命令：toprule、bottomrule 和 midrule。可以将 hrules 设置为 True，也可以手动设置每个单独的规则定义，通过手动设置 table_styles，例如下面我们设置一个常规的 toprule，为 bottomrule 设置一个 hline，并排除 midrule：

set_table_styles([
    {'selector': 'toprule', 'props': ':toprule;'},
    {'selector': 'bottomrule', 'props': ':hline;'},
], overwrite=False) 

如果其他 commands 被添加到表样式中，它们将被检测到，并立即放置在‘\begin{tabular}’命令的上方。例如，要添加奇偶行着色，来自 {colortbl} 包，格式为 \rowcolors{1}{pink}{red}，使用：

set_table_styles([
    {'selector': 'rowcolors', 'props': ':{1}{pink}{red};'}
], overwrite=False) 

使用这些参数的更全面的示例如下：

>>> df.columns = pd.MultiIndex.from_tuples([
...     ("Numeric", "Integers"),
...     ("Numeric", "Floats"),
...     ("Non-Numeric", "Strings")
... ])
>>> df.index = pd.MultiIndex.from_tuples([
...     ("L0", "ix1"), ("L0", "ix2"), ("L1", "ix3")
... ])
>>> s = df.style.highlight_max(
...     props='cellcolor:[HTML]{FFFF00}; color:{red}; itshape:; bfseries:;'
... )
>>> s.to_latex(
...     column_format="rrrrr", position="h", position_float="centering",
...     hrules=True, label="table:5", caption="Styled LaTeX Table",
...     multirow_align="t", multicol_align="r"
... ) 

格式化

要格式化值，应先使用 Styler.format()，然后再调用 Styler.to_latex，以及其他方法，例如 Styler.hide()：

>>> s.clear()
>>> s.table_styles = []
>>> s.caption = None
>>> s.format({
...    ("Numeric", "Integers"): '\${}',
...    ("Numeric", "Floats"): '{:.3f}',
...    ("Non-Numeric", "Strings"): str.upper
... })  
 Numeric      Non-Numeric
 Integers   Floats    Strings
L0    ix1       $1   2.200      DOGS
 ix2       $3   4.400      CATS
L1    ix3       $2   6.600      COWS 

>>> s.to_latex()  
\begin{tabular}{llrrl}
{} & {} & \multicolumn{2}{r}{Numeric} & {Non-Numeric} \\
{} & {} & {Integers} & {Floats} & {Strings} \\
\multirow[c]{2}{*}{L0} & ix1 & \\$1 & 2.200 & DOGS \\
 & ix2 & \$3 & 4.400 & CATS \\
L1 & ix3 & \$2 & 6.600 & COWS \\
\end{tabular} 

CSS 转换

这种方法可以将使用 HTML-CSS 构建的 Styler 转换为 LaTeX，使用以下有限的转换。

CSS 属性	CSS 值	LaTeX 命令	LaTeX 选项
字体粗细	粗体更粗	bfseriesbfseries
字体样式	斜体倾斜	itshapeslshape
背景颜色	红色#fe01ea#f0ergb(128,255,0)rgba(128,0,0,0.5)rgb(25%,255,50%)	单元格颜色	{红色}–lwrap[HTML]{FE01EA}–lwrap[HTML]{FF00EE}–lwrap[rgb]{0.5,1,0}–lwrap[rgb]{0.5,0,0}–lwrap[rgb]{0.25,1,0.5}–lwrap
颜色	红色#fe01ea#f0ergb(128,255,0)rgba(128,0,0,0.5)rgb(25%,255,50%)	颜色	{红色}[HTML]{FE01EA}[HTML]{FF00EE}[rgb]{0.5,1,0}[rgb]{0.5,0,0}[rgb]

也可以使用--latex标志向 HTML-CSS Styler 添加用户定义的仅 LaTeX 样式，并添加 LaTeX 解析选项，转换器将在 CSS 注释中检测到。

>>> df = pd.DataFrame([[1]])
>>> df.style.set_properties(
...     **{"font-weight": "bold /* --dwrap */", "Huge": "--latex--rwrap"}
... ).to_latex(convert_css=True)  
\begin{tabular}{lr}
{} & {0} \\
0 & {\bfseries}{\Huge{1}} \\
\end{tabular} 

例子

下面我们给出一个完整的逐步示例，添加一些高级功能并注意一些常见的陷阱。

首先，我们像往常一样创建 DataFrame 和 Styler，包括 MultiIndex 行和列，这允许更高级的格式选项：

>>> cidx = pd.MultiIndex.from_arrays([
...     ["Equity", "Equity", "Equity", "Equity",
...      "Stats", "Stats", "Stats", "Stats", "Rating"],
...     ["Energy", "Energy", "Consumer", "Consumer", "", "", "", "", ""],
...     ["BP", "Shell", "H&M", "Unilever",
...      "Std Dev", "Variance", "52w High", "52w Low", ""]
... ])
>>> iidx = pd.MultiIndex.from_arrays([
...     ["Equity", "Equity", "Equity", "Equity"],
...     ["Energy", "Energy", "Consumer", "Consumer"],
...     ["BP", "Shell", "H&M", "Unilever"]
... ])
>>> styler = pd.DataFrame([
...     [1, 0.8, 0.66, 0.72, 32.1678, 32.1678**2, 335.12, 240.89, "Buy"],
...     [0.8, 1.0, 0.69, 0.79, 1.876, 1.876**2, 14.12, 19.78, "Hold"],
...     [0.66, 0.69, 1.0, 0.86, 7, 7**2, 210.9, 140.6, "Buy"],
...     [0.72, 0.79, 0.86, 1.0, 213.76, 213.76**2, 2807, 3678, "Sell"],
... ], columns=cidx, index=iidx).style 

其次，我们将格式化显示，并且，由于我们的表格相当宽，将隐藏索引的重复级别-0：

>>> (styler.format(subset="Equity", precision=2)
...       .format(subset="Stats", precision=1, thousands=",")
...       .format(subset="Rating", formatter=str.upper)
...       .format_index(escape="latex", axis=1)
...       .format_index(escape="latex", axis=0)
...       .hide(level=0, axis=0)) 

请注意，索引和列标题中的一个字符串条目是“H&M”。如果不将escape="latex"选项应用于format_index方法，则生成的 LaTeX 将无法渲染，并且返回的错误很难调试。使用适当的转义，将“&”转换为“&”。

第三，我们将对我们的对象应用一些（CSS-HTML）样式。我们将使用内置方法，并定义自己的方法来突出显示股票推荐：

>>> def rating_color(v):
...     if v == "Buy": color = "#33ff85"
...     elif v == "Sell": color = "#ff5933"
...     else: color = "#ffdd33"
...     return f"color: {color}; font-weight: bold;"
>>> (styler.background_gradient(cmap="inferno", subset="Equity", vmin=0, vmax=1)
...       .map(rating_color, subset="Rating")) 

所有上述样式在转换为 HTML（见下文）和 LaTeX 后都可以使用：

然而，最后我们想要添加一个仅 LaTeX 样式（来自{graphicx}包），这不容易从 CSS 转换，pandas 不支持它。请注意这里使用的--latex标志，以及--rwrap以确保格式正确，转换时不被忽略。

>>> styler.map_index(
...     lambda v: "rotatebox:{45}--rwrap--latex;", level=2, axis=1
... ) 

最后，我们渲染我们的 LaTeX，根据需要添加其他选项：

>>> styler.to_latex(
...     caption="Selected stock correlation and simple statistics.",
...     clines="skip-last;data",
...     convert_css=True,
...     position_float="centering",
...     multicol_align="|c|",
...     hrules=True,
... )  
\begin{table}
\centering
\caption{Selected stock correlation and simple statistics.}
\begin{tabular}{llrrrrrrrrl}
\toprule
 &  & \multicolumn{4}{|c|}{Equity} & \multicolumn{4}{|c|}{Stats} & Rating \\
 &  & \multicolumn{2}{|c|}{Energy} & \multicolumn{2}{|c|}{Consumer} &
\multicolumn{4}{|c|}{} &  \\
 &  & \rotatebox{45}{BP} & \rotatebox{45}{Shell} & \rotatebox{45}{H\&M} &
\rotatebox{45}{Unilever} & \rotatebox{45}{Std Dev} & \rotatebox{45}{Variance} &
\rotatebox{45}{52w High} & \rotatebox{45}{52w Low} & \rotatebox{45}{} \\
\midrule
\multirow[c]{2}{*}{Energy} & BP & {\cellcolor[HTML]{FCFFA4}}
\color[HTML]{000000} 1.00 & {\cellcolor[HTML]{FCA50A}} \color[HTML]{000000}
0.80 & {\cellcolor[HTML]{EB6628}} \color[HTML]{F1F1F1} 0.66 &
{\cellcolor[HTML]{F68013}} \color[HTML]{F1F1F1} 0.72 & 32.2 & 1,034.8 & 335.1
& 240.9 & \color[HTML]{33FF85} \bfseries BUY \\
 & Shell & {\cellcolor[HTML]{FCA50A}} \color[HTML]{000000} 0.80 &
{\cellcolor[HTML]{FCFFA4}} \color[HTML]{000000} 1.00 &
{\cellcolor[HTML]{F1731D}} \color[HTML]{F1F1F1} 0.69 &
{\cellcolor[HTML]{FCA108}} \color[HTML]{000000} 0.79 & 1.9 & 3.5 & 14.1 &
19.8 & \color[HTML]{FFDD33} \bfseries HOLD \\
\cline{1-11}
\multirow[c]{2}{*}{Consumer} & H\&M & {\cellcolor[HTML]{EB6628}}
\color[HTML]{F1F1F1} 0.66 & {\cellcolor[HTML]{F1731D}} \color[HTML]{F1F1F1}
0.69 & {\cellcolor[HTML]{FCFFA4}} \color[HTML]{000000} 1.00 &
{\cellcolor[HTML]{FAC42A}} \color[HTML]{000000} 0.86 & 7.0 & 49.0 & 210.9 &
140.6 & \color[HTML]{33FF85} \bfseries BUY \\
 & Unilever & {\cellcolor[HTML]{F68013}} \color[HTML]{F1F1F1} 0.72 &
{\cellcolor[HTML]{FCA108}} \color[HTML]{000000} 0.79 &
{\cellcolor[HTML]{FAC42A}} \color[HTML]{000000} 0.86 &
{\cellcolor[HTML]{FCFFA4}} \color[HTML]{000000} 1.00 & 213.8 & 45,693.3 &
2,807.0 & 3,678.0 & \color[HTML]{FF5933} \bfseries SELL \\
\cline{1-11}
\bottomrule
\end{tabular}
\end{table} 

pandas.read_hdf

原文：pandas.pydata.org/docs/reference/api/pandas.read_hdf.html

pandas.read_hdf(path_or_buf, key=None, mode='r', errors='strict', where=None, start=None, stop=None, columns=None, iterator=False, chunksize=None, **kwargs)

从存储中读取，如果我们打开了它，则关闭它。

从文件中检索存储的 pandas 对象，可选地基于 where 条件。

警告

Pandas 使用 PyTables 来读写 HDF5 文件，当使用 “fixed” 格式时，可以使用 pickle 序列化对象-dtype 数据。从不受信任的源接收到的 pickled 数据可能是不安全的。

参见：docs.python.org/3/library/pickle.html，了解更多。

参数：

path_or_bufstr，路径对象，pandas.HDFStore

任何有效的字符串路径都可以接受。仅支持本地文件系统，不支持远程 URL 和类文件对象。

如果您想传递一个路径对象，pandas 接受任何 os.PathLike。

或者，pandas 接受一个打开的 pandas.HDFStore 对象。

keyobject，可选

存储中的组标识符。如果 HDF 文件包含单个 pandas 对象，则可以省略。

mode，默认为 ‘r’

打开文件时要使用的模式。如果 path_or_buf 是 pandas.HDFStore，则忽略。默认为 ‘r’。

errorsstr，默认为 ‘strict’

指定如何处理编码和解码错误。有关选项的完整列表，请参阅 open() 的 errors 参数。

wherelist，可选

一系列术语（或可转换）对象。

startint，可选

要开始选择的行号。

stopint，可选

要停止选择的行号。

columnslist，可选

要返回的列名称列表。

iteratorbool，可选

返回一个迭代器对象。

chunksizeint，可选

使用迭代器时要包含的迭代中的行数。

**kwargs

传递给 HDFStore 的其他关键字参数。

返回：

对象

选定的对象。返回类型取决于存储的对象。

另请参见

DataFrame.to_hdf

从 DataFrame 中写入 HDF 文件。

HDFStore

对 HDF 文件的低级访问。

示例

>>> df = pd.DataFrame([[1, 1.0, 'a']], columns=['x', 'y', 'z'])  
>>> df.to_hdf('./store.h5', 'data')  
>>> reread = pd.read_hdf('./store.h5')