【学习笔记】《深入浅出Pandas》第3章：Pandas数据读取与输出

Pandas可以将指定格式的数据读取到DataFrame中，并将DataFrame输出为指定格式的文件。

3.1 数据读取

3.1.1 CSV文件

CSV是用逗号分隔值的数据形式，有时也称字符分隔值，因为分隔字符也可以不是逗号。
CSV文件的一般扩展名为.csv，用制表符号分隔也常用.tsv作为扩展名。CSV文件的读取方式如下：

# 文件目录
pd.read_csv('data.csv') # 如果文件与代码文件在同一目录下
pd.read_csv('data/my/data.csv') # 指定目录
pd.read_csv('data/my/my.data') # CSV文件的扩展名不一定是.csv

CSV文件可以存储在网络上，通过URL来访问和读取：

pd.read_csv('http://www.gairuo.com/file/data/dataset/GDP-China')

CSV不带数据格式，标准化较强。

3.1.2 Excel

# 返回DataFrame
pd.read_excel('team.xlsx') # 默认读取第一个标签页Sheet
pd.read_excel('Path_to_file.xlsx', sheet_name='Sheet1') # 指定Sheet
# 从URL读取
pd.read_excel('https://www.gairuo.com/data/dataset/team.xlsx')

3.1.3 JSON

JSON是互联网上通用的轻量级数据交换格式，是HTTP请求中数据的标准格式之一。

# data.json为同目录下的一个文件
pd.read_json('data.json')
# 读取半结构化的JSON数据
pd.json_normalize(data)

3.1.4 HTML

pd.read_html()函数可以接受HTML字符串、HTML文件、URL，并将HTML中的< table >标签表格数据解析为DataFrame。
如果返回多个df的列表，则可以通过索引取第几个。如果页面只有一个表格，那么这个列表就只有一个DataFrame。

dfs = pd.read_html('https://www.gairuo.com/p/pandas-io')
dfs[0] # 查看第一个df
# 读取网页文件，第一行为表头
dfs = pd.read_html('data.html', header=0)
# 第一列为索引
dfs = pd.read_html(url, index_col=0)

如果一个网页表格很多，可以指定元素获取：

# id='table'的表格，注意这里仍然可能返回多个
dfs1 = pd.read_html(url, attrs={'id': 'table'})
# dfs1[0]
# class='sortable'
dfs2 = pd.read_html(url, attrs={'class': 'sortable'})

3.1.5 剪贴板

剪贴板是操作系统级的一个暂存数据的地方，保存在内存中。

cdf = pd.read_clipboard() # 复制数据，并直接赋值

3.1.6 SQL

Pandas需要引入SQLAlchemy库来支持SQL。Pandas连接数据库进行查询和更新的方法如下：

# 把数据表的数据转换成DataFrame
read_sql_table(table_name, con[, schema, ...]) 

# 用sql查询数据到DataFrame里
read_sql_query(sql, con[, index_col, ...])

# 同时支持以上两种功能
real_sql(sql, con[, index_col, ...])

# 把记录数据写到数据库
DataFrame.to_sql(self, name, con[, schema, ...])

import sqlalchemy import create_engine
# 创建数据库对象， SQLite内存模式
engine = create_engine('sqlite:///:memory:')
# 取出表名为data的表数据
with engine.connect() as conn, conn.begin():
	data = pd.read_sql_table('data', conn)
# data
# 将数据写入
data.to_sql('data', engine)
# 大量写入
data.to_sql('data_chunked', engine, chunksize=1000)
# 使用sql查询
pd.read_sql_query('SELECT * FROM data', engine)

3.2 读取CSV

3.2.1 语法

pd.read_csv()用法及参数

pd.read_csv(filepath_or_buffer, sep=',', delimiter=None, header='infer',
			names=None, index_col=None, usecols=None, squeeze=False, prefix=None, 
			mangle_dupe_cols=True, dtype=None, engine=None, converters=None, 
			true_values=None, false_values=None, skipinitialspace=False, 
			skiprows=None, nrows=None, na_values=None, keep_default_na=True,
			na_filter=True, verbose=False, skip_blank_lines=True, parse_dates=False,
			infer_datetime_format=False, keep_date_col=False, date_parser=None, 
			dayfirst=False, iterator=False, chunksize=None, compression='infer', 
			thousands=None, decimal=b'.', lineterminator=None, quotechar='"', 
			quoting=0, escapechar=None, comment=None, encoding=None, dialect=None, 
			tupleize_cols=False, error_bad_lines=True, warn_bad_lines=True, 
			skipfooter=0, skip_footer=0, doublequote=True, delim_whitespace=False,
			as_recarray=False, compact_ints=False, use_unsigned=False, 
			low_memory=True, buffer_lines=None, memory_map=False, float_precision=None)

3.2.2 数据内容

filepath_or_buffer是第一个参数，没有默认值，也不能为空，第一个参数传参的时候可以不写参数名。

# 支持文件路径或者文件缓冲对象
pd.read_csv('data\data.csv') # 本地相对路径, 注意目录层级
pd.read_csv('data.csv') # 如果文件与代码文件在同一目录下
pd.read_csv('data\my\my.data') #CSV文件的扩展名不一定是.csv
pd.read_csv('E:\data\data.csv') # 本地绝对路径
pd.read_csv('https://www.gairuo.com/file/data/dataset/GDP-China.csv') # URL

CSV中的数据字符以字符串形式直接传入：

from io import StringIO
data = ('col1, col2, col3\n'
		'a, b, 1\n'
		'a, b, 2\n'
		'c, d, 3')
pd.read_csv(StringIO(data))
pd.read_csv(StringIO(data), dtype=object)

也可以传入字节数据：

from io import BytesIO
data = (b'word, length\n'
		b'Tr\xc3\xa4umen, 7\n'
		b'Gr\xc3\xbc\xc3\x9fe, 5')
pd.read_csv(BytesIO(data))

3.2.3 分隔符

sep参数是字符型，代表每行数据内容的分隔符号，默认是逗号，另外常见的还有制表符(\t)、空格。

# 数据分隔符默认是逗号，可以指定为其他符号
pd.read_csv(data, sep='\t') # 制表符分隔tab
pd.read_table(data) # read_table默认是制表符分隔tab
pd.read_csv(data, sep='|') # 制表符分隔tab
pd.read_csv(data, sep='(?, engine='python') # 使用正则表达式

pd.read_csv还提供了一个参数名为delimiter的定界符，这是一个备选分隔符，是sep的别名，效果和sep一样。如果指定该参数，则sep失效。

3.2.4 表头

header参数支持整型和由整型组成的列表， 指定第几行是表头，默认第一行为表头。

pd.read_csv(data, header=0) # 第一行
pd.read_csv(data, header=None) # 没有表头
pd.read_csv(data, header=[0, 1, 3]) # 多层索引MultiIndex

如果skil_blank_lines=True，header参数会忽略空行和注释行，因此header=0表示第一行数据而非文件的第一行。

3.2.5 列名

names指定列的名称，它是一个类似列表的序列，与数据一一对应。如果文件不包含列名，那么应该设置header=None，列名中不允许有重复值。

pd.read_csv(data, names=['列1'， '列2']) # 指定列名列表

3.2.6 索引

index_col用来指定索引列，可以是行索引的列编号或者列名，如果给定一个序列，则有多个行索引。Pandas不会自动将第一列作为索引，不指定时会自动使用以0开始的自然索引。

# 支持int、str、int序列、str序列、False，默认是None
pd.read_csv(data, index_col=False) # 不再使用首列作为索引
pd.read_csv(data, index_col=0) # 第几列是索引
pd.read_csv(data, index_col='年份') # 指定列名
pd.read_csv(data, index_col=['a', 'b']) # 多个索引
pd.read_csv(data, index_col=[0, 3]) # 按照列索引指定多个索引

3.2.7 使用部分列

如果只是用数据的部分列，可以用usecols指定。

# 支持类似列表的序列和可调用对象
# 读取部分列
pd.read_csv(data, usecols=[0, 4, 3]) # 按索引只读取指定列，与顺序无关
pd.read_csv(data, usecols=['列1', '列5']) # 按列名，列名必须存在
pd.read_csv(data, usecols=['列1', '列5'])[['列5', '列1']] # 指定列顺序，其实是df的筛选功能
pd.read_csv(data, usecols=lambda x:x.upper() in ['COL3', 'COL1']) 
# 用callable方式可以巧妙指定顺序，in后面是我们要的顺序

3.2.8 返回序列

将squeeze设置为True，如果文件只包含一列，则返回一个Series，如果有多列，则还是返回DataFrame。

# 布尔型，默认False
pd.read_csv(data, usecols=[0], squeeze=True) # 只取一列，返回一个Series
pd.read_csv(data, usecols=[0, 2], squeeze=True) # 取两列则是df

3.2.9 表头前缀

如果原始数据没有列名，可以指定一个前缀加序数的名称，如n0、n1，通过prefix参数指定前缀。

# 格式为字符型str
# 表头为c_0、c_2
pd.read_csv(data, prefix='c_', header=None)

3.2.10 处理重复列名

如果参数mangle_dupe_cols=True，当列名有重复的时候，解析列名会变成X，X.1，…，X.N，而不是X，X，…。
如果参数为False，当列名有重复的时候，前列会被后列覆盖。

# bool型，默认为True
data = 'a, b, a\n0, 1, 2,\n3, 4, 5'
pd.read_csv(StringIO(data), mangle_dupe_cols=True)
# 表头为a b a.1
# False会报ValueError错误

但是在jupyter notebook上运行，并没有得到想要的结果，未解决。

3.2.11 数据类型

dtype可以指定各数据列的数据类型，后续会单独介绍。

# 传入类型名称，或者以列名为键、以指定类型为值的字典
pd.read_csv(data, dtype=np.float64) # 所有数据均为此数据类型
pd.read_csv(data, dtype={'c1': np.float64, 'c2': str}) # 指定字段的数据类型
pd.read_csv(data, dtype=[datetime, datetime, str, float]) # 依次指定

3.2.12 引擎

分析引擎可以选择c或Python，C语言的速度最快，Python语言的功能最为完善，一般情况下，不需要另行指定。a,

# 格式为engine=None， 其中可选值有{'c', 'python'}
pd.read_csv(data, engine='c')

3.2.13 列数据处理

使用converters参数对列的数据进行转换，参数中指定列名与针对此列的处理函数，最终以字典的形式传入，字典的键可以是列名或者列的序号。

# 字典格式，默认为None
data = 'x, y\na, 1\nb, 2'
def foo(p):
	return p + 's'
# x应用函数，y使用lambda
pd.read_csv(StringIO(data), converters={'x': foo,
										'y': lambda x: x*3})
# 使用列索引
pd.read_csv(StringIO(data), converters={0: foo,
										1: lambda x: x*3}) 

3.2.14 真假值转换

参数true_values和false_values将指定的文本内容转换为True或False，可以使用列表指定多个值。

# 列表，默认为None
data = ('a, b, c\n1, Yes, 2\n3, No, 4')
pd.read_csv(StringIO(data), true_values=['Yes'], false_values=['No'])

3.2.15 跳过指定行

如下跳过需要忽略的行数（从文件开始处算起）或需要忽略的行号列表（从0开始）：

pd.read_csv(data, skiprows=2) # 跳过前三行
pd.read_csv(data, skiprows=range(2)) # 跳过前三行

pd.read_csv(data, skiprows=[24, 234, 141]) # 跳过指定行
pd.read_csv(data, skiprows=np.array([2, 6, 11])) # 跳过指定行

pd.read_csv(data, skiprows=lambda x: x%2 != 0) # 隔行跳过

尾部跳过，从文件尾部开始忽略，C引擎不支持：

# int类型，默认为0
pd.read_csv(filename, skipfooter=1) # 最后一行不加载

skip_blank_lines指定是否跳过空行，如果为True，则跳过空行，否则数据记为NaN。

# bool型，默认为True
# 不跳过空行
pd.read_csv(data, skip_blank_lines=False)

如果skip_blank_lines=True，header参数将会忽略空行和注释行，因此header=0表示第一行数据而不是文件的第一行。

3.2.16 读取指定行

参数nrows用于指定需要读取的行数，从文件第一行算起，经常用于较大的数据。

# int类型，默认为None
pd.read_csv(data, nrows=1000)

3.2.17 空值替换

参数na_values的值是一组用于替换NA/NaN的值。如果传参，需要指定特定列的值。
使用na_values时需要关注下面keep_default_na（保留默认空值）的配合使用和影响：

# 可传入标量、字符串、类似列表序列和字典，默认为None
pd.read_csv(data, na_values=[5]) # 5和5.0会被认为是NaN
pd.read_csv(data, na_values='?') # ?会被认为是NaN

pd.read_csv(data, keep_fault_na=False, na_values=[""]) # 空值为NaN
pd.read_csv(data, keep_fault_na=False, na_values=["NA", "0"]) # 字符NA和字符0会被认为是NaN

pd.read_csv(data, na_values='abc') # 等同于na_values=['a', 'b', 'c']
pd.read_csv(data, na_values={'c': 3, 1: [2, 5]}) # 指定列的指定值会被认为是NaN

3.2.18 保留默认空值

参数：keep_default_na
分析数据时是否包含默认的NaN值，是否自动识别。
如果指定na_values参数，并且keep_default_na=False， 那么默认的NaN将被覆盖，否则添加。

# keep_default_na bool型，默认为True 
# 不自动识别空值
pd.read_csv(data, keep_default_na=False)

如果na_filter=False（默认为True），那么keep_default_na和na_values的参数均无效。
na_filter为是否检查丢失值（空字符串或空值）。对于大文件来说，数据集没有空值，设定na_filter=False可以提升读取速度。

# bool型，默认为True
pd.read_csv(data, na_filter=False) # 不检查

3.2.19 日期时间解析

日期时间解析器参数date_parser用于解析日期的函数，默认使用deteutil.parser.parser来做转换。
如果某些列或某些行启用了parse_dates，并且datetime字符串的格式相同，则通过设置infer_datetime_format=True，可以大大提高解析速度。

# 解析时间的函数名，默认为None
# 指定时间解析库，默认是dateutil.parser.parser
date_parser = pd.io.date_converters.parser_date_time
date_parser = lambda x: pd.to_datetime(x, utc=True, format='%d%b%Y')
date_parser = lambda d: pd.datetime.strptime(d, '%d%b%Y')

# 使用
pd.read_csv(data, parse_dates=['年份'], date_parser=date_parser)

parse_dates参数用于对时间日期解析：

# bool型、整型组成的列表、列表组成的列表或者字典，默认为False
pd.read_csv(data, parse_dates=True) # 自动解析日期时间格式
pd.read_csv(data, parse_dates=['年份']) # 指定日期时间字段进行解析
pd.read_csv(data, parse_dates={'时间': [1, 4]})
# 将第1、4列合并解析成名为“时间”的时间类型列

如果infer_datetime_format被设定为True并且parse_dates可用，那么pandas将尝试转换为日期类型：

# bool型，默认为False
pd.read_csv(data, parse_dates=True, infer_datetime_format=True)

如果用上文中的parse_dates参数将多列合并并解析为一个时间列，设置为keep_date_col的值为True时，会保留这些原有的时间组成列；如果设置为False，则不保留这些列。

# bool型，默认为False
pd.read_csv(data, parse_dates=[[1, 2], [1, 3]], keep_date_col=True)

对于DD/MM格式的日期类型，如时间2020-01-06，如果dayfirst=True，则会转换成2020-06-01：

# bool型，默认为False
pd.read_csv(data, dayfirst=True, parse_dates=[0])

cache_dates如果为True，则使用唯一的转换日期缓存来应用datetime转换：

# bool型，默认为True
pd.read_csv(data, cache_dates=False)

3.2.20 文件处理

以下是一些对读取文件对象的处理方法：
iterator参数如果设置为True，则返回一个TextFileReader对象，并可以对它进行迭代，以便逐块处理文件。

# bool型，默认为False
pd.read_csv(data, iterator=True)

chunksize指定文件块的大小，分块处理大型CSV文件：

# 整型，默认为None
pd.read_csv(data, chunksize=100000)

# 分块处理大文件
df_iterator = pd.read_csv(file, chunksize=50000)
def process_dataframe(df):
	pass
	return processed_df

for index, df_tmp in enumerate(df_iterator):
	df_processed = processed_dataframe(df_tmp)
	if index > 0:
		df_processed.to_csv(path)
	else:
		df_processed.to_csv(path, mode='a', header=False)

compression（压缩格式）用于对磁盘数据进行即时解压缩。
如果为“infer”，且filepath_or_buffer是以.gz、.bz2、.zip或.xz结尾的字符串，则使用gzip、bz2、zip或xz，否则不进行解压缩。
如果使用zip，则ZIP文件必须仅包含一个要读取的数据文件。
设置为None将不进行解压缩。

# 可选值有'infer'、'gzip'、'bz2'、'zip'和None，默认为'infer'
pd.read_csv('sample.tar.gz', compression='gzip')

encoding（编码）指定字符集类型，通常指定’utf-8’：

# 字符型，默认为None
pd.read_csv('gairuo.csv', encoding='utf-8')
pd.read_csv("gairuo.csv", encoding="gb2312") # 常见中文

3.2.21 符号

以下是对文件中的一些数据符号进行的特殊识别处理：

# thousands（千分位分隔符） bool型，默认为None
pd.read_csv('test.csv', thousands=',') # 逗号分隔

# decimal（小数点） 识别为小数点的字符
# 字符串型，默认为','
pd.read_csv(data, decimal=",")

# lineterminator（行结束符）,将文件分成几行的字符，仅对C解析器有效
# 长度为1的字符串，默认为None
data = 'a, b, c~1, 2, 3~4, 5, 6'
pd.read_csv(StringIO(data), lineterminator='~')

# quotechar（引号），用于表示引用数据的开始和结束的字符
# 引用的项目可以包含定界符，它将被忽略
# 长度为1的字符串
pd.read_csv(file, quotechar='"')

在csv模块中，数据可能会用引号等字符包裹起来，quoting参数用来控制识别字段的引号模式，它可以是Python csv模块中的csv.QUOTE_*常量，也可以传入对应数字。各个传入值的意义如下：

• 0或csv.QUOTE_MINIMAL：仅特殊字段有引号
• 1或csv.QUOTE_ALL：所有字段都有引号
• 2或csv.QUOTE_NONNUMERIC：所有非数字字段都有引号
• 3或csv.QUOTE_NONE：所有字段都没有引号

如果使用csv模块，需要事先引入csv模块：

# 整型或csv.QUOTE_*实例，默认为0
import csv
pd.read_csv('input_file.csv', quoting=csv.QUOTE_NONE)

双引号doublequote，当单引号已经被定义，并且quoting参数不是QUOTE_NONE的时候，使用双引号表示将引号内的元素作为一个元素使用：

# bool型，默认为True
import csv
pd.read_csv('data.csv', quotechar='"', doublequote=True, quoting=csv.QUOTE_NONNUMERIC)

escapechar可以传入一个转义符，用于过滤数据中的该转入符。
比如，如果一行用双引号包裹着的数据中有换行符，用以下代码可以过滤其中的换行符：

# 长度为1的转义字符串，默认为None
pd.read_csv(StringIO(data), escapechar='\n', encoding='utf-8')

注释标识comment，指示不应该分析行的部分。如果在一行的开头找到该标识，则完全忽略该行。此参数必须是单个字符。
eg：如果comment=‘#’，则解析header=0的’#empty \na, b, c \n1, 2, 3’会将a，b，c视为header。

# 字符串，默认为None
s = '# notes\na, b, c\n# more notes\n1, 2, 3'
pd.read_csv(StringIO(s), sep=',', comment='#', skiprows=1) # skiprows 跳过前两行

空格分隔符delim_whitespace， 指定是否将空格用作分隔符，等效于设置sep=‘\s+’。
如果该选项设置为True，则不应该为delimiter参数传递任何内容。delimiter用于指定分隔符。

# bool型，默认为False
pd.read_csv(StringIO(data), delim_whitespace=False)

3.3 读取Excel

3.3.1 语法

pandas.read_excel接口的语法如下：

pd.read_excel(io, sheet_name=0, header=0, names=None, index_col=None,
			  usecols=None, squeeze=False, dtype=None, engine=None,
			  converters=None, true_values=None, false_values=None,
			  skiprows=None, nrows=None, na_values=None, keep_default_na=True,
			  verbose=False, parse_dates=False, date_parser=None,
			  thousands=None, comment=None, skipfooter=0,
			  convert_float=True, mangle_dupe_cols=True, **kwds)

3.3.2 文件内容

io是第一个参数，没有默认值，也不能为空，根据Python的语法，第一个参数传参的时候可以不写。可以传入本地文件名，或者远程文件的URL：

# 字符串、字节、Excel文件、xlrd.Book实例、路径对象或者类似文件的对象
# 本地相对路径
pd.read_excel('data\data.xlsx') # 注意目录层级
pd.read_excel('data.xlsx') # 如果文件与代码文件在同一目录下

# 本地绝对路径
pd.read_excel('E:\data\data.xlsx') 

# 使用URL
pd.read_excel('https://www.gairuo.com/file/data/dataset/team.xlsx')

3.3.3 表格

sheet_name可以指定Excel文件读取哪个sheet，如果不指定，默认读取第一个。

# 字符串、整型、列表、None，默认为0
pd.read_excel('tmp.xlsx', sheet_name=1) # 第二个sheet
pd.read_excel('tmp.xlsx', sheet_name='总结表') # 按sheet的名字

# 读取第一个、第二个、名为Sheet5的sheet，返回一个df组成的字典
dfs = pd.read_excel('tmp.xlsx', sheet_name=[0, 1, "Sheet5"])
dfs = pd.read_excel('tmp.xlsx', sheet_name=None) # 所有sheet
dfs['Sheet5'] # 读取时按sheet名

3.3.4 表头

数据表头参数为header，如不指定，默认为第一行。

# 整型、整型组成的列表，默认为0
pd.read_excel('tmp.xlsx', header=None) # 不设表头
pd.read_excel('tmp.xlsx', header=2) # 第三行是表头
pd.read_excel('tmp.xlsx', header=[0, 1]) # 两层表头，多层索引

3.3.5 列名

用names指定列名，也就是表头的名称，如果不指定，默认为表头的名称。

# 序列，默认为None
pd.read_excel('tmp.xlsx', names=['姓名', '年龄', '成绩'])
pd.read_excel('tmp.xlsx', names=c_list) # 传入列表变量
pd.read_excel('tmp.xlsx', header=None, names=None) # 没有表头，需要设置列名为None

3.3.6 其他参数

其他参数与pandas.read_csv的同名参数功能一致，如果想使用仅pandas.read_csv有的参数，可以考虑将数据保存为csv文件。

3.4 数据输出

任何原始格式的数据载入DataFrame后，都可以使用类似DataFrame.to_csv()的方法输出到相应格式的文件或者目标系统里。

3.4.1 CSV

DataFrame.to_csv方法可以将DataFrame导出为CSV格式的文件，需要传入一个CSV文件名。

df.to_csv('done.csv')
df.to_csv('data\done.csv') # 可以指定文件目录路径
df.to_csv('done.csv', index=False) # 不要索引

另外还可以使用sep参数指定分隔符，columns传入一个序列指定列名，编码用encoding传入。
如果不需要表头，可以将header设为False。
如果文件较大，可以使用compression进行压缩：

# 创建一个包含out.csv的压缩文件out.zip
compression_opts = dict(method='zip', archive_name='out.csv')
df.to_csv('out.zip', index=False, compression=compression_opts)

3.4.2 Excel

使用DataFrame.to_excel方法即可导出为Excel格式。要导出DataFrame对象，需要指定以.xlsx或.xls为扩展名的文件名，生成的文件标签也可以用sheet_name指定。
如果要导出多个DataFrame到一个Excel，可以借助ExcelWriter对象来实现。

df.to_excel('path_to_file.xlsx') # 导出，可以指定文件路径
df.to_excel('path_to_file.xlsx', sheet_name='Sheet1', index=False) # 指定Sheet名，不要索引
df.to_excel('path_to_file.xlsx', index_label='label', merge_cell=False) # 指定索引名，不合并单元格 

多个数据的导出如下：

# 将多个df分不同sheet导入到一个Excel文件中
with pd.ExcelWriter('path_to_file.xlsx') as writer:
	df1.to_excel(writer, sheet_name='Sheet1')
	df2.to_excel(writer, sheet_name='Sheet2')

使用指定的Excel导出引擎如下：

# 指定操作引擎
df.to_excel('path_to_file.xlsx', sheet_name='Sheet1', engine='xlsxwriter')
# 在'engine'参数中设置ExcelWriter使用的引擎
writer = pd.ExcelWriter('path_to_file.xlsx', engine='xlsxwriter')
df.to_excel(writer)
writer.save()

# 设置系统引擎
from pandas import options
options.io.excel.xlsx.writer = 'xlsxwriter'
df.to_excel('path_to_file.xlsx', sheet_name='Sheet1')

3.4.3 HTML

DataFrame.to_html会将DataFrame中的数据组装在HTML代码的table标签中，输入一个字符串，这部分HTML代码可以放在网页中展示，也可以作为邮件正文。

print(df.to_html())
print(df.to_html(columns=[0])) # 输出指定列
print(df.to_html(bold_rows=False)) # 表头不加粗
print(df.to_html(classes=['class1', 'class2'])) # 表格指定样式，支持多个 

3.4.4 数据库（SQL）

# 需要安装SQLAlchemy库
from sqlalchemy import create_engine
# 创建数据库对象，SQLite内存模式
engine = create_engine('sqlite:///:memory')
# 取出表名为data的表数据
with engine.connect() as conn, conn.begin():
	data = pd.read_sql_table('data', conn)

# data
data.to_sql('data', engine) # 将数据写入
data.to_sql('data_chunked', engine, chunksize=1000) # 大量写入
data.read_sql_query('SELECT * FROM data', engine)

3.4.5 Markdown

print(cdf.to_markdown())