对比xlwt,openpyxl,xlrd图示引用别人的一张图：xlwt不支持写xlsx文件。openpyxl不支持读xls文件。xlrd支持读xls,xlsx文件。推荐读文件用xlrd,写文件用openpyxl。实测准备了3.64 MB的excel文件。from functools import wraps
from time import time
import openpyxl
import xlrd
def timer(func):
@wraps(func)
def inner(*args, **kwargs):
tmp = time()
res = func(*args, **kwargs)
print(time() - tmp)
return res
return inner
@timer
def openpyxl_test():
fp = openpyxl.open('题库.xlsx')
sheet = fp['xxx']
print(sheet.dimensions)
for rows in sheet.iter_rows(min_row=1, max_row=8122, min_col=1, max_col=13):
for cell in rows:
pass
pass
@timer
def xlrd_test():
fp = xlrd.open_workbook('题库.xlsx')
sheet = fp.sheet_by_name('xxx')
print(sheet.nrows, sheet.ncols)
for index in range(sheet.nrows):
row = sheet.row_values(index)
pass
if __name__ == '__main__':
openpyxl_test()
>>>
A1:M8122
7.71000599861145
xlrd_test()
>>>
8122 13
4.619961738586426
读取8000行数据，openpyxl用时7.71秒，xlrd用时4.62秒。xlrd&xlwt读写操作区别：openyxl：可以对xlsx、xlsm文件进行读、写操作，主要对Excel2007年之后的版本(.xlsx)xlrd：可以对xlsx、xls、xlsm文件进行读操作且效率高xlwt：主要对xls文件进行写操作且效率高，但是不能执行xlsx文件安装读：pip3 install xlrd==1.2.0 （高版本不支持xlsx)写：pip install xlwt读操作import xlrd
# 读取文件
df = xlrd.open_workbook('test.xlsx')
# 显示所有sheet
print(df.sheet_names())
>>> ['Sheet1', 'Sheet2', 'Sheet3']
# 获取所有sheet对象
print(df.sheets())
[<xlrd.sheet.Sheet object at 0x000001995152D7C8>, <xlrd.sheet.Sheet object at 0x0000019951567648>, <xlrd.sheet.Sheet object at 0x0000019951567988>]
# 获取sheet对象
table=df.sheets()[0]
table=df.sheet_by_index(0)
table=df.sheet_by_name('name')
# 获取行列
row=table.nrows
col=table.ncols
# 获取整行，整列的值，行列值从0开始
table.row_values(num1)
table.column_values(num2)
# 获取单元格的值
cell=table.cell(0,0).value
写操作import xlwt
# 创建excel文件
df2 = xlwt.Workbook()
# 新建表
table2=df2.add_sheet('name')
table2=df2.add_sheet('name',cell_overwrite_ok=True) 允许重复写一个单元格
# 写入数据
table2.write(0,0,'Python')
# 保存
df2.save('data2.xls')
excel时间处理xldate_as_tuple在使用xlrd读取Excel表格中的日期格式时，读取出来的是一个浮点数，导致不能正确使用，而xldate_as_tuple方法可以很好地解决这个问题。xlrd.xldate_as_tuple(xldate,datemode)参数 xldate: 要处理的单元格值参数 datemode:时间基准（0代表1900-01-01为基准，1代表1904-01-01为基准）；常使用1900为基准返回值：返回一个元组，类似于（year,month,day,hour,minute,nearest_second）但是，仅适用于date类型的excel单元格，不适用于time类型的单元格xlrd.xldate.xldate_as_datetime(xldate,datemode)参数 xldate: 要处理的单元格值参数 datemode:时间基准（0代表1900-01-01为基准，1代表1904-01-01为基准）；常使用1900为基准返回值：datetime对象，格式 year-month-day hour:minute:secondopenpyxl读写操作前提知识：测试数据：openpyxl安装 ：pip install openpyxl读取from openpyxl import load_workbook
# 导入excel文件
workbook = load_workbook(filename='test.xlsx’)
或
workbook = open("test.xlsx")
# 打印该文件所有表名
print(workbook.sheetnames)
# 切换表
sheet = workbook['sheet1']
# 打印该表单元格规模
print(sheet.dimensions)
# 取该表的某个单元格
cell = sheet['A1']
# 打印该单元格的坐标
print(cell.row, cell.column, cell.coordinate)
# 获取多个单元格
for cell in sheet['A1:A10']
for cell in sheet['A1:G10']
for rows in sheet.iter_rows(min_row=1,max_row=5,min_col=2,max_col=7):
for cell in rows:
print(cell.value,end='')
print()
# 获取单元格对象的值,[必须是单元格对象]，如果取到元组是点不出value的
print(cell.value)
写入# 保存
workbook.save('test.xlsx')
# 修改
cell = sheet['A1']
cell.value = 'A1'
# 追加到最后最后一行
sheet.append([15, None, None, 14, 'qq.com'])
# 添加公式
sheet['K11'] = '=AVERAGE(K1:K10)'
# 在第二行处增加4行
sheet.insert_rows(2,4)
# 在第二列处增加4列
sheet.insert_cols(2,4)
# 删除行
sheet.delete_rows(2,4)
# 删除列
sheet.delete_cols(2,4)
# 最后一定要保存一遍
workbook.save('test.xlsx')
# 创建excel
from openpyxl import Workbook
workbook = Workbook()
openpyxl优化模式有时，你可能需要打开或写入极端大的 XLSX 文件，但通用的 openpyxl 程序无法处理这么大的负载。 幸运的是，有两种模式可以使你在（几乎）恒定的内存消耗下读写无限量的数据。 只读模式：有时，你可能需要打开或写入极端大的 XLSX 文件，但通用的 openpyxl 程序无法处理这么大的负载。 幸运的是，有两种模式可以使你在（几乎）恒定的内存消耗下读写无限量的数据。 from openpyxl import load_workbook
wb = load_workbook(filename='large_file.xlsx', read_only=True)
ws = wb['big_data']
for row in ws.rows:
for cell in row:
print(cell.value)
只写模式：常规的 openpyxl.worksheet.worksheet.Worksheet 被替代成更快的 openpyxl.worksheet._write_only.WriteOnlyWorksheet 。 当你想导出大量数据的时候请确保安装了 lxml 库. >>> from openpyxl import Workbook
>>> wb = Workbook(write_only=True)
>>> ws = wb.create_sheet()
>>>
>>> # now we'll fill it with 100 rows x 200 columns
>>>
>>> for irow in range(100):
...
ws.append(['%d' % i for i in range(200)])
>>> # save the file
>>> wb.save('new_big_file.xlsx') # doctest: +SKIP
和普通工作簿不同的是，新创建的只写工作簿没有任何工作表；工作表只能由 create_sheet() 方法进行创建。 在只读工作簿中，只能由 append() 来添加行。无法使用 cell() 或 iter_rows() 对任意位置的单元进行读取或写入。 可以导出不限量的数据（即使超过 Excel 的处理上限），同时内存使用量小于10Mb。 一个只写工作簿只能保存一次。之后如果任何尝试保存和添加数据（append()）的操作都会会引发 openpyxl.utils.exceptions.WorkbookAlreadySaved 错误。 导出大数据，但内存又不够用的时候，可以给openpyxl加上只读或只写属性，并且安装lxml库（因为excel解压后也是xml格式的文件），按照官方文档的说法可以增加一些读写速度，但对于内存使用量小于10Mb，我感觉不可信，导出150MB的excel文件，kubectl top内存占用5G+。另外可以手动调用gc去回收一些引用计数为0的变量，import gc
# 调用del引用计数-1
del wb, ws
# 触发垃圾回收
gc.collect()
pandasopenpyxl，xlrd 都只可以读取filename，而不能从io种读取excel和csv，例如，无法将request.content作为输入源，所以引入了pandas。用途 Pandas 可以从各种文件格式比如 CSV、JSON、SQL、Microsoft Excel 导入数据。
Pandas 可以对各种数据进行运算操作，比如归并、再成形、选择，还有数据清洗和数据加工特征。
Pandas 广泛应用在学术、金融、统计学等各个数据分析领域。 数据结构Pandas 的主要数据结构是 Series （一维数据）与 DataFrame（二维数据），这两种数据结构足以处理金融、统计、社会科学、工程等领域里的大多数典型用例。Series 是一种类似于一维数组的对象，它由一组数据（各种Numpy数据类型）以及一组与之相关的数据标签（即索引）组成。DataFrame 是一个表格型的数据结构，它含有一组有序的列，每列可以是不同的值类型（数值、字符串、布尔型值）。DataFrame 既有行索引也有列索引，它可以被看做由 Series 组成的字典（共同用一个索引）。Pandas 数据结构 - DataFrameDataFrame 是一个表格型的数据结构，它含有一组有序的列，每列可以是不同的值类型（数值、字符串、布尔型值）。DataFrame 既有行索引也有列索引，它可以被看做由 Series 组成的字典（共同用一个索引）。DataFrame 构造方法如下：pandas.DataFrame( data, index, columns, dtype, copy)
参数说明：data：一组数据(ndarray、series, map, lists, dict 等类型)。index：索引值，或者可以称为行标签。columns：列标签，默认为 RangeIndex (0, 1, 2, …, n) 。dtype：数据类型。copy：拷贝数据，默认为 False。Pandas DataFrame 是一个二维的数组结构，类似二维数组。使用列表创建import pandas as pd
data = [['Google',10],['Codebaoku',12],['Wiki',13]]
df = pd.DataFrame(data,columns=['Site','Age'])
print(df)
输出结果如下：
Site
Age
0
Google
10
1
Codebaoku
12
2
Wiki
13
使用 ndarrays 创建import pandas as pd
data = {'Site':['Google', 'Codebaoku', 'Wiki'], 'Age':[10, 12, 13]}
df = pd.DataFrame(data)
print (df)
结果与上一致。使用字典创建import pandas as pd
data = [{'a': 1, 'b': 2}, {'a': 5, 'b': 10, 'c': 20}]
df = pd.DataFrame(data)
print(df)
输出结果如下：
a
b
c
0
1
2
NaN
1
5
10
20.0
没有对应的部分数据为 NaN。Pandas 可以使用 loc 属性返回指定行的数据，如果没有设置索引，第一行索引为 0，第二行索引为 1，以此类推：import pandas as pd
data = {
"calories": [420, 380, 390],
"duration": [50, 40, 45]
}
# 数据载入到 DataFrame 对象
df = pd.DataFrame(data)
# 返回第一行
print(df.loc[0])
# 返回第二行
print(df.loc[1])
输出结果如下：calories
420
duration
50
Name: 0, dtype: int64
calories
380
duration
40
Name: 1, dtype: int64
注意：返回结果其实就是一个 Pandas Series 数据。也可以返回多行数据，使用 [[ … ]] 格式，… 为各行的索引，以逗号隔开：import pandas as pd
data = {
"calories": [420, 380, 390],
"duration": [50, 40, 45]
}
# 数据载入到 DataFrame 对象
df = pd.DataFrame(data)
# 返回第一行和第二行
print(df.loc[[0, 1]])
输出结果为：
calories
duration
0
420
50
1
380
40
注意：返回结果其实就是一个 Pandas DataFrame 数据。
可以指定索引值，如下范例：import pandas as pd
data = {
"calories": [420, 380, 390],
"duration": [50, 40, 45]
}
df = pd.DataFrame(data, index = ["day1", "day2", "day3"])
print(df)
输出结果为：
calories
duration
day1
420
50
day2
380
40
day3
390
45
Pandas 可以使用 loc 属性返回指定索引对应到某一行：import pandas as pd
data = {
"calories": [420, 380, 390],
"duration": [50, 40, 45]
}
df = pd.DataFrame(data, index = ["day1", "day2", "day3"])
# 指定索引
print(df.loc["day2"])
输出结果为：calories
380
duration
40
Name: day2, dtype: int64
Pandas CSV 文件import pandas
from io import BytesIO
# 模拟request
buf = BytesIO()
with open("./test.csv", "rb") as f:
for line in f:
buf.write(line)
# 指针回溯
buf.seek(0)
res = pandas.read_csv(buf)
print(res)
输出结果如下：
col1
col2
col3
0
1
2
3
1
4
5
6
也可以使用 to_csv() 方法将 DataFrame 存储为 csv 文件：import pandas as pd
# 三个字段 name, site, age
nme = ["Google", "Codebaoku", "Taobao", "Wiki"]
st = ["www.google.com", "www.codebaoku.com", "www.taobao.com", "www.wikipedia.org"]
ag = [90, 40, 80, 98]
# 字典
dict = {'name': nme, 'site': st, 'age': ag}
df = pd.DataFrame(dict)
# 保存 dataframe
df.to_csv('site.csv')
使用数据表信息查看维度查看：df.shape
数据表基本信息（维度、列名称、数据格式、所占空间等）：df.info()
每一列数据的格式：df.dtypes
某一列格式：df['B'].dtype
空值：df.isnull()
查看某一列空值：df['B'].isnull()
查看某一列的唯一值：df['B'].unique()
查看数据表的值：df.values
查看列名称：df.columns
查看前5行数据、后5行数据：df.head() #默认前5行数据
df.tail()
#默认后5行数据
数据表清洗1、用数字0填充空值：df.fillna(value=0)
2、使用列prince的均值对NA进行填充：df['prince'].fillna(df['prince'].mean())
3、清除city字段的字符空格：df['city']=df['city'].map(str.strip)
4、大小写转换：df['city']=df['city'].str.lower()
5、更改数据格式：df['price'].astype('int')
6、更改列名称：df.rename(columns={'category': 'category-size'})
7、删除后出现的重复值：df['city'].drop_duplicates()
8 、删除先出现的重复值：df['city'].drop_duplicates(keep='last')
9、数据替换：df['city'].replace('sh', 'shanghai')
数据预处理df1=pd.DataFrame({"id":[1001,1002,1003,1004,1005,1006,1007,1008],
"gender":['male','female','male','female','male','female','male','female'],
"pay":['Y','N','Y','Y','N','Y','N','Y',],
"m-point":[10,12,20,40,40,40,30,20]})
数据表合并1.1 merge df_inner=pd.merge(df,df1,how='inner')
# 匹配合并，交集
df_left=pd.merge(df,df1,how='left')
#
df_right=pd.merge(df,df1,how='right')
df_outer=pd.merge(df,df1,how='outer')
#并集
1.2 append result = df1.append(df2)
1.3 join result = left.join(right, on='key')
1.4 concat pd.concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False,
keys=None, levels=None, names=None, verify_integrity=False,
copy=True)
objs︰ 一个序列或系列、 综合或面板对象的映射。如果字典中传递，将作为键参数，使用排序的键，除非它传递，在这种情况下的值将会选择（见下文）。任何没有任何反对将默默地被丢弃，除非他们都没有在这种情况下将引发 ValueError。axis: {0，1，…}，默认值为 0。要连接沿轴。join: {‘内部’、 ‘外’}，默认 ‘外’。如何处理其他 axis(es) 上的索引。联盟内、 外的交叉口。ignore_index︰ 布尔值、 默认 False。如果为 True，则不要串联轴上使用的索引值。由此产生的轴将标记0，…，n-1。这是有用的如果你串联串联轴没有有意义的索引信息的对象。请注意在联接中仍然受到尊重的其他轴上的索引值。join_axes︰ 索引对象的列表。具体的指标，用于其他 n-1 轴而不是执行内部/外部设置逻辑。 keys︰序列，默认为无。构建分层索引使用通过的键作为最外面的级别。如果多个级别获得通过，应包含元组。levels︰ 列表的序列，默认为无。具体水平 （唯一值） 用于构建多重。否则，他们将推断钥匙。names︰ 列表中，默认为无。由此产生的分层索引中的级的名称。verify_integrity︰ 布尔值、 默认 False。检查是否新的串联的轴包含重复项。这可以是相对于实际数据串联非常昂贵。副本︰ 布尔值、 默认 True。如果为 False，请不要，不必要地复制数据。例子：1.frames = [df1, df2, df3]
2.result = pd.concat(frames)
2、设置索引列df_inner.set_index('id')
3、按照特定列的值排序：df_inner.sort_values(by=['age'])
4、按照索引列排序：df_inner.sort_index()
5、如果prince列的值>3000，group列显示high，否则显示low：df_inner['group'] = np.where(df_inner['price'] > 3000,'high','low')
6、对复合多个条件的数据进行分组标记df_inner.loc[(df_inner['city'] == 'beijing') & (df_inner['price'] >= 4000), 'sign']=1
7、对category字段的值依次进行分列，并创建数据表，索引值为df_inner的索引列，列名称为category和sizepd.DataFrame((x.split('-') for x in df_inner['category']),index=df_inner.index,columns=['category','size'])
8、将完成分裂后的数据表和原df_inner数据表进行匹配df_inner=pd.merge(df_inner,split,right_index=True, left_index=True)
数据提取主要用到的三个函数：loc,iloc和ix，loc函数按标签值进行提取，iloc按位置进行提取，ix可以同时按标签和位置进行提取。1、按索引提取单行的数值df_inner.loc[3]
2、按索引提取区域行数值df_inner.iloc[0:5]
3、重设索引df_inner.reset_index()
4、设置日期为索引df_inner=df_inner.set_index('date')
5、提取4日之前的所有数据df_inner[:'2013-01-04']
6、使用iloc按位置区域提取数据df_inner.iloc[:3,:2] #冒号前后的数字不再是索引的标签名称，而是数据所在的位置，从0开始，前三行，前两列。
7、适应iloc按位置单独提起数据df_inner.iloc[[0,2,5],[4,5]] #提取第0、2、5行，4、5列
8、使用ix按索引标签和位置混合提取数据df_inner.ix[:'2013-01-03',:4] #2013-01-03号之前，前四列数据
9、判断city列的值是否为北京df_inner['city'].isin(['beijing'])
10、判断city列里是否包含beijing和shanghai，然后将符合条件的数据提取出来df_inner.loc[df_inner['city'].isin(['beijing','shanghai'])]
11、提取前三个字符，并生成数据表pd.DataFrame(df_inner['category'].str[:3])
数据筛选使用与、或、非三个条件配合大于、小于、等于对数据进行筛选，并进行计数和求和。1、使用“与”进行筛选df_inner.loc[(df_inner['age'] > 25) & (df_inner['city'] == 'beijing'), ['id','city','age','category','gender']]
2、使用“或”进行筛选df_inner.loc[(df_inner['age'] > 25)
(df_inner['city'] == 'beijing'), ['id','city','age','category','gender']].sort(['age'])
3、使用“非”条件进行筛选df_inner.loc[(df_inner['city'] != 'beijing'), ['id','city','age','category','gender']].sort(['id'])
4、对筛选后的数据按city列进行计数df_inner.loc[(df_inner['city'] != 'beijing'), ['id','city','age','category','gender']].sort(['id']).city.count()
5、使用query函数进行筛选df_inner.query('city == ["beijing", "shanghai"]')
6、对筛选后的结果按prince进行求和df_inner.query('city == ["beijing", "shanghai"]').price.sum()
数据汇总主要函数是groupby和pivote_table1、对所有的列进行计数汇总df_inner.groupby(‘city’).count()2、按城市对id字段进行计数df_inner.groupby(‘city’)[‘id’].count()3、对两个字段进行汇总计数df_inner.groupby([‘city’,‘size’])[‘id’].count()4、对city字段进行汇总，并分别计算prince的合计和均值df_inner.groupby(‘city’)[‘price’].agg([len,np.sum, np.mean])数据统计数据采样，计算标准差，协方差和相关系数1、简单的数据采样df_inner.sample(n=3)2、手动设置采样权重weights = [0, 0, 0, 0, 0.5, 0.5]df_inner.sample(n=2, weights=weights)3、采样后不放回df_inner.sample(n=6, replace=False)4、采样后放回df_inner.sample(n=6, replace=True)5、 数据表描述性统计df_inner.describe().round(2).T #round函数设置显示小数位，T表示转置6、计算列的标准差df_inner[‘price’].std()7、计算两个字段间的协方差df_inner[‘price’].cov(df_inner[‘m-point’])8、数据表中所有字段间的协方差df_inner.cov()9、两个字段的相关性分析df_inner[‘price’].corr(df_inner[‘m-point’]) #相关系数在-1到1之间，接近1为正相关，接近-1为负相关，0为不相关10、数据表的相关性分析df_inner.corr()数据输出分析后的数据可以输出为xlsx格式和csv格式1、写入Exceldf_inner.to_excel(‘excel_to_python.xlsx’, sheet_name=‘bluewhale_cc’)2、写入到CSVdf_inner.to_csv(‘excel_to_python.csv’)

openpyxl 的用法实例1.1 Openpyxl 库的安装使用openpyxl 模块是一个读写 Excel 2010 文档的 Python 库，如果要处理更早格式的 Excel 文 档，需要用到额外的库，openpyxl 是一个比较综合的工具，能够同时读取和修改 Excel 文档。 其他很多的与 Excel 相关的项目基本只支持读或者写 Excel 一种功能。新建、读取、保存工 作簿。1.2 Excel 的新建、读取、保存1.2.1 新建保存工作簿(覆盖创建)新建：openpyxl.Workbook()，注意这个的 W 是大写的(本人吃过亏)，可以设置 write_only=True/False 的读写方式，默认是可写。 保存：workbook.save('工作簿名.xlsx')from openpyxl import Workbook
wb=Workbook() # 新建工作簿
wb.save('我的工作簿.xlsx') # 相对路径保存工作簿
每个 workbook 创建后，默认会存在一个 sheet。也可以自行创建新的 sheet。
1.2.2 读取保存工作簿
读取工作簿：openpyxl.load_workbook('工作簿名.xlsx')，注意以下相关参数的设置。read_only=False/True False 表示可以读、写，True 表示只能读、不能写。guess_types=False/True False 表示转换数据，True 表示不能转换数据。data_only=False/True False 表示序单元格的真实信息，True 表示只读取值。
from openpyxl import load_workbook
wb=load_workbook('成绩表-1.xlsx') # 读取 工作簿
wb.save('成绩表-2.xlsx') # 保 存工作簿
1.2.3 实例(批量建新工作簿)
from openpyxl import Workbook
for m in range(1,13):
wb = Workbook()
# 新建工作簿
wb.save('%d 月.xlsx'%m)# 保存工作簿1.3 工作表对象的获取方法1.3.1 工作表获取方式:获取当前活动工作表的：sheet = wb.active以索引值方式获取工作表：sheet= wb.worksheets[2]以工作表名获取： wb['工作表名']，注意，此表达方式为切片显示，所以没有成员提示。很少用sheet = wb["Sheet-甲乙-甲乙"]循环工作表：很好用，一般用sheetnameswb = wb.worksheets获取所有工作表名：wb.sheetnameswb4 = wb.sheetnames获取指定工作表名wb7 = wb.sheetnames[2].title()修改工作表名称import openpyxl
wb = openpyxl.load_workbook('我的工作簿.xlsx')
# wb[wb.sheetnames[1]].title = '南京'
sh_name = wb.sheetnames
# 获取所有sheet
sh = wb[sh_name[1]]
sh.title = "南京"
sheet = wb.sheetnames[1].title()
wb.save('我的工作簿.xlsx')
print(sheet)1.3.2 实例(批量修改工作表名)import openpyxl
wb = openpyxl.load_workbook('各年业绩表.xlsx')
for sh in wb.worksheets:
sh.title = sh.title + '-芝华公司'
wb.save('各年业绩表(修改后).xlsx')1.4 工作表的新建、复制、删除1.4.1 新建工作表可以在新建的工作簿中新建工作表(在新建工作簿时，会默认新建一个工作表)。也能在已经存在的工作簿中新建工作表。新建工作表时的默认工作表名：wb.create_sheet()
#默认工作表名为 Sheet1、 Sheet2、 Sheet3……wb8 = wb.create_sheet('工作表名',指定位置)1.4.2 复制工作表wb.copy_worksheet(wb.worksheets[3])1.4.3 删除工作表workbook.remove(工作表)wb.remove(wb.worksheets[2])1.5 关于工作表的实例应用1.5.1 实例应用(批量新建12个月工作表)import openpyxl
wb = openpyxl.Workbook()
# 新建工作簿
for m in range(1, 13):
wb.create_sheet('%d 月' % m)
# 新建月份工作表
wb.remove(wb['Sheet'])
# 删除 指定工作表
wb.save('2022 年计划表.xlsx')
# 保存工作簿。1.5.2 实例应用(删除不符合条件的工作表)import openpyxl
wb=openpyxl.load_workbook('2021 年.xlsx')
# 读取 工作簿
for sh in wb: # 循环 工作簿中的工作表
if sh.title.split('-')[0]!='北京': # 判断 工作表是否不等于北京
wb.remove(sh) # 删除 工作表
wb.save('北京.xlsx') # 保 存工作簿1.5.3 实例应用(批量复制工作表)import openpyxl
wb = openpyxl.load_workbook('模板.xlsx')
for m in range(1, 13):
wb.copy_worksheet(wb['测试']).title = '%d 月' % m
wb.remove(wb['测试'])
wb.save('2018 年各月表格.xlsx')以上是处理工作表的方式
以下是处理单元格的方法1.6 单元格信息获取1.6.1 单元格数据获取A1 表示法：工作表['A1']，R1C1 表示法：工作表.cell(行号,列号)import openpyxl
wb = openpyxl.load_workbook("各年业绩表.xlsx")
ws = wb.worksheets[0]
#不能使sheetnames
sh2 = ws["a1"].value
#必须是小写
print(sh2)
sh = ws.cell(1,1).value
print(sh)1.6.2 实例应用(汇总各表各单元格数据)import openpyxl
wb = openpyxl.load_workbook('各年业绩表.xlsx')
print(sum([s['b14'].value for s in wb]))
print(sum([s.cell(14,2).value for s in wb]))1.7 单元格区域信息获取1.7.1 单元格区域数据获取
1.工作表['起始单元格': '终止单元格']或工作表['起始单元格: 终止单元格']，此方法是按行读取的数据。
import openpyxl
wb = openpyxl.load_workbook('demo.xlsx')
sh = wb["天峰集团"]
s = sh["a1":"a2"]
print(s)
wb.save("demo.xlsx")2.工作表['起始行号': '结束行号']或者工作表['起始行号: 结束行号']，此方法是按行读取的数据。import openpyxl
wb = openpyxl.load_workbook('demo.xlsx')
sh = wb["天峰集团"]
s = sh["1:3"]
print(s)
wb.save("demo.xlsx")3.工作表['起始列号': '结束列号']或者工作表['起始列号: 结束列号']，此方法是按列读取的数据。import openpyxl
wb = openpyxl.load_workbook('demo.xlsx')
sh = wb["天峰集团"]
s = sh["a:w"]
print(s)
wb.save("demo.xlsx")4.获取(按行)指定工作表所有已用数据：list(workbook.worksheets[索引值].values)print([[c.value for c in row] for row in ws['a1:d3']])1.7.2 实例应用按行求和(方法 1)import openpyxl
wb=openpyxl.load_workbook('test.xlsx')
ws=wb.active
rngs=ws['a2:e71']
print(['%s-%d'%(row[0].value,sum([c.value for c in row][1:])) for row in rngs])按行求和(方法 )import openpyxl
wb=openpyxl.load_workbook('test.xlsx')
ws=wb.active
print(['%s-%d'%(row[0],sum(row[1:])) for row in list(ws.values)[1:]])按列统计平均值import openpyxl
wb=openpyxl.load_workbook('test.xlsx')
ws=wb.active
f=[sum(l)/len(l) for l in list(zip(*list(ws.values)[1:]))[1:]]
n=[c.value for c in ws['1']][1:]
print(['%s-%.2f'%c for c in list(zip(n,f))])
print(['%s-%.2f'%(l[0],sum(l[1:])/len(l[1:])) for l in list(zip(*list(ws.values)))[1:]])1.8 行列信息获取1.8.1 行列信息获取按行获取工作表使用区域数据：worksheet.rows按列获取工作表使用区域数据：worksheet.columns获取工作表中最小行号：worksheet.min_row获取工作表中最小列号：worksheet.min_column获取工作表中最大行号：worksheet.max_row获取工作表中最大列号：worksheet.max_column获取单元格的行号：cell.row获取单元格的列号：cell.column iter方法获取指定区域：1.按行获取指定工作表单元格区域：worksheet.iter_rows(……)2.按列获取指定工作表单元格区域：worksheet.iter_cols(……)可以通过 min_row、min_col、max_col、max_row 这几个参数进行单元格区域的控制import openpyxl
wb=openpyxl.load_workbook('demo.xlsx')
ws=wb.active
minr=ws.min_row
minc=ws.min_column
maxr=ws.max_row
maxc=ws.max_column
rngs=ws.iter_rows(min_row=minr+1,min_col=minc+2,max_row=maxr-1,max_col=maxc-1)
col=ws.iter_cols(min_row=minr+1,min_col=minc+1,max_row=maxr-1,max_col=minc+1)
total=([sum([v.value for v in row]) for row in rngs])
cp=([[v.value for v in row] for row in col][0])
print(list(zip(cp,total)))1.8.2 实例应用import openpyxl
wb=openpyxl.load_workbook('test.xlsx')
ws=wb.worksheets[0]
for row in ws.iter_rows(min_row=36,min_col=2,max_col=4,max_row=40):
print([c.value for c in row])import openpyxl
wb=openpyxl.load_workbook('test.xlsx')
ws=wb.worksheets[0]
for row in list(ws.rows)[1:]:
l=[v.value for v in row]
print(l[0],sum(l[1:]))import openpyxl
wb=openpyxl.load_workbook('test.xlsx')
ws=wb.worksheets[0]
for col in list(ws.columns)[1:]:
l=[v.value for v in col]
print(l[0],max(l[1:]))import openpyxl
wb=openpyxl.load_workbook('test.xlsx')
ws=wb.worksheets[0]
total=[sum([c.value for c in row]) for row in ws.iter_rows(min_col=2,min_row=2)]
name=[c.value for c in ws['a']][1:]
print(list(zip(name,total)))import openpyxl
wb=openpyxl.load_workbook('test.xlsx')
ws=wb.worksheets[0]
total=[sum([c.value for c in col]) for col in ws.iter_cols(min_col=2,min_row=2)]
name=[c.value for c in ws[1][1:]]
print(list(zip(name,total)))单元格的写入1.9.1 单元格与区域数据写入A1 表示法：工作表['A1']=值，R1C1 表示法：工作表.cell(行号,列号,值)import openpyxl
wb=openpyxl.load_workbook('test.xlsx')
ws=wb.worksheets[1]
s = ws['a1']=123
ws.cell(2,3,'我是中国人')
ws.cell(3,3).value='我是四川人'
print(s)
wb.save('test.xlsx')1.9.2 实例应用(九九乘法表)import openpyxl
wb=openpyxl.Workbook()
ws=wb.active
ws.title='九九表'
for x in range(1,10):
for y in range(1,x+1):
ws.cell(x,y,f'{y}×{x}={x*y}')
wb.save('九九表.xlsx')1.10 批量写入数据1.10.1 按行写入数据 (追加)在最后一行写入数据：工作表.append(列表)import openpyxl
wb=openpyxl.load_workbook('test.xlsx')
ws=wb.worksheets[0]
ws.append({'a':'张三','b':56,'c':'fdgsfg'})
wb.save('test.xlsx')1.10.2 实例应用(九九乘法表)wb=openpyxl.load_workbook('demo.xlsx')
ws=wb.active
# for r in [['%d*%d=%d'%(y,x,x*y) for y in range(1,x+1)] for x in range(1,10)]:
#
ws.append(r)
# ws.delete_rows(1)
# wb.save('demo.xlsx')
for row in ws['a1:c6']:
for c in row:
c.value=1
wb.save('demo.xlsx')1.11 循环方式批量写入数据1.11.1 循环获取单元格对象，再写入
之前我们可以通过组合单元格来获取或者写入数据，但还有一种方法，就是直接循环单 元格区域来写入数据。与循环读取的表示方式基本相同，只是多了一个赋值。
import openpyxl
wb=openpyxl.load_workbook('test.xlsx')
ws=wb.worksheets[0]
for row in ws['a1:g9']:
print(row)
for c in row:
print(c.value)
wb.save('test.xlsx')1.11.2 实例应用(大于等于 90 分为优秀)import openpyxl
wb=openpyxl.load_workbook('demo.xlsx')
ws=wb.active
rngs=ws.row("2:2")
for row in rngs:
for c in row:
if c.value>=90:
c.value=str(c.value)+'(优秀)'
wb.save('demo1.xlsx')1.11.3 实例应用(每个人的总分大于等于300为优秀)最后加一列写优秀import openpyxl
wb=openpyxl.load_workbook('demo.xlsx')
ws=wb.active
rngs=ws.iter_rows(min_row=2,min_col=2)
for row in rngs:
sm=sum([c.value for c in row][0:4])
if sm>=300:
row[-1].value='优秀' #切片用的多
wb.save('demo2.xlsx')

python openpyxl模块学习笔记前言小白一枚，多多指教!欢迎指错！！!一、openpyxl库openpyxl库是一个能够读写Excel的python库(好像至少是2010版Excel)二、使用基本操作1.创建一个新的Excel表格/打开一个已经存在的Excel表格1>创建一个新的Excel表格代码如下（示例）：from
openpyxl import
Workbook
wb = Workbook() # 实例化
ws = wb.active #激活 worksheet
'''这里加上读写操作代码块'''
wb.save('workbook1.xlsx')#保存
2>打开一个已存在的Excel表from openpyxl import load_workbook
wb = load_workbook('workbook1.xlsx')#实例化
ws = wb.active#激活当前活跃的工作表,获取当前活跃的sheet对象
#或者是ws = wb['Sheet']
'''这里加上读写操作代码'''
wb.save('workbook1.xlsx')#保存文件
ws = wb.active可以写成ws = wb[‘Sheet’]这两个的作用相同都是获取一个sheet对象前者是获取当前活跃的工作表作为对象，后者是按名称获取Excel中的工作表作为对象（二者可根据需要来选择使用）2.写入数据1>指定单元格进行填写from openpyxl import Workbook
wb = Workbook()
ws = wb['Sheet']# 获取Sheet工作表对象
# 设置内容
ws['A1'] = 'Hello World!'#在A列第1行填入 Hello World!
import datetime#一般的import都放在前面，这里为了方便阅读
ws['A2'] = datetime.datetime.today()#在A2单元格填入现在的时间
wb.save('new_sample.xlsx')#保存
2>一行一行进行填写from openpyxl import Workbook
wb1 = Workbook()
ws1 = wb1.active
ws1.append(['A1','B1','C1','D1'])
ws1.append([1,2,3,4,])
wb1.save('workbook1.xlsx')
效果就是这样子的3.读出数据首先不得不说一下三个生成器:rows:按行获取单元格(cell对象)columns:按列获取单元格(cell对象)values:按行获取单元格内容(单元格数据)注：对于以上三者的具体定义，笔者不是很理解，values获取的好像是元组类型可以多试试打印输出来探索每一个的作用，可意会不可言传（能力有限，不会描述- .-）1>打印出某一个单元格的内容from openpyxl import load_workbook
wb1 = load_workbook('workbook1.xlsx')
ws1 = wb1.active
a1 = ws1['A1']
print(a1)#打印结果为<Cell 'Sheet'.A1> a1应该是为类里的一个cell对象
print(type(a1))#打印结果为<class 'openpyxl.cell.cell.Cell'>,
print(a1.value)#打印结果为 A1 (.value ->单元格的值。加上.value之后应该是打印 对象a1的属性值。)
wb1.save('workbook1.xlsx')
注：这里对a1 及其type是笔者的猜测，静候评论区大佬来解答~~2>打印出某一列的值from openpyxl import load_workbook
wb1 = load_workbook('workbook1.xlsx')
ws1 = wb1.active
a = ws1['A']
for i in a:
print(i.value)
wb1.save('workbook1.xlsx')
3>打印出每一个单元格的值（一行一行打印）from openpyxl import load_workbook
wb1 = load_workbook('workbook1.xlsx')
ws1 = wb1.active
for cell in ws1.values:
print(*cell)
wb1.save('workbook1.xlsx')
打印结果如下注:cell在这里是元组类型，打印时前面加*打印，笔者也不知道为什么能达到如此效果，烦请大佬评论区解答~~总结问题与错误请在评论区指出