文本挖掘的常用工具:Python

拓展知识:

文本挖掘(TextMinin)是一个从非结构化文本信息中获取用户感兴趣或者有用的模式的过程。文本挖掘的主要目的是从非结构化文本文档中提取有趣的、重要的模式和知识。可以看成是基于数据库的数据挖掘或知识发现的扩展。

文本挖掘是从数据挖掘发展而来，因此其定义与我们熟知如的数据挖掘定义相类似。但与传统的数据挖掘相比，文本挖掘有其地特之处，主要表现在:文档本身是半结构化或非结构化的，无确定形式并且缺乏机器可理解的语义;

而数据挖掘的对象以数据库中的结构化数据为主，并利用关系表等存储结构来发现知识，文本挖掘是指以大量文本教据中抽取事先末知的、可理解的、最终可用的知识的过程，同时运用这些知识更好地组织信息以便将来参考。

文本挖掘的主要用途是以原本未经处理的文本中提取出未知的知识，但是文本挖掘也是一项非常困难的工作,因为它必须处理那些本来就样糊而目非结构化的文本数据,所以它是一个多学科杂的领域涵盖了信息技术、文本分析、模式识别、统计学、数据可视化、数据库技术，机器学以及数据挖掘等技术。

文本挖插是以数据挖掘发展而来，因此其定义与我们熟知的数据挖掘定义相类似。但与传统的数据挖掘相比，文本挖掘有其中特之处，主要表现在:文档本身是半结构化或非结构化的，无确定形式并目缺乏机器口理解的语义;

而数据控掘的对象以数据库中的结构化数据为主，并利用关系表等存储结构来发现知识，因此，有些数据挖掘技术并不适用于文本挖掘，即使可用，也需要建立在对文本集预处理的基础之上。

文本挖掘是应里驱动的。它在商业智能、信息检索、生物信息外理等方面都有广泛的应用:例如，客户关系管理，自动邮件回复，拉圾邮件过滤，自动简历评审，搜索引擎等等

文本挖掘的主要支撑技术:自然语言处理和机器学习由于处理的对象是半结构化或非结构化的文档自然语言处理技术成为实现生物医学文本挖掘的主要技术手段。

下面小编就为大家带来一篇高效测试用例组织算法pairwise之Python实现方法。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧

开篇：

测试过程中，对于多参数参数多值的情况进行测试用例组织，之前一直使用正交分析法进行用例组织，说白了就是把每个参数的所有值分别和其他参数的值做一个全量组合，用Python脚本实现，就是itertools模块中product方法（又称笛卡尔积法）。

正交分析法的优点是测试用例覆盖率100%，缺点测试用例数量庞大，执行用例消耗的人工巨大。

Pairwise （结对）算法源于对传统的正交分析方法优化后得到的产物，它的理论来自于数学统计。毫不避讳的说，本人看不懂数学统计中的学术论文，只能从网上找一些通俗简单的说法来理解其基本含义。

网上很多人都实例都是用 操作系统，浏览器，语言环境来举例的，本人也做同样示例：

操作系统： W（Windows）,L（Linux）,Mac （Mac） ；浏览器：M（Firefox）,O(Opera)，IE；语言环境：C（中文），E（英文）

按照正交分析法：会产生3x3x2=18种组合方式 ，测试用例覆盖率100%。

Pairwise结对测试用例组织法，可压缩到9种组合方式。因此有点是 测试用例数量少，缺点是一定会有漏测。

引论：

Pairwise算法的核心理念

1、一组测试用例（每个用例有3个参数的值组成，如[W,M,C]）中每一个2个元素组合起来，两两组合，就有3种组合方式（有位置的[W,M][W,C][M,C]）；

2、如果这第一组测试用两两组合出的3种组合方式，对比原则：[W,M]只会和其他组的第一个元素对比，[W,C]只会和其他组中第二个元素对比。。；

[W,M][W,C][M,C]这三个元素分别出现在其余有效组位置相同的元素中，就可以认为这一组Case为多余Case，并进行删除。

名词解释：有效组表示未被删除的组和未被对比过的组。举例：第1,3组被删除，则第4组要对比的有效组为第2,5,6,718组。有效组这里踩过坑%>_<%

3、最终得到测试用例，就是结对算法计算出来的最优测试用例集合。

牛逼闪闪的学术证明

Pairwise是L L Thurstone(29 May1887 _ 30 September 1955)在1927年首先提出来的。他是美国的一位心理统计学家。Pairwise也正是基于数学统计和对传统的正交分析法进行优化后得到的产物。

Pairwise基于如下2个假设：

（1）每一个维度都是正交的，即每一个维度互相都没有交集。

（2）根据数学统计分析，73%的缺陷（单因子是35%，双因子是38%）是由单因子或2个因子相互作用产生的。19%的缺陷是由3个因子相互作用产生的。

因此，pairwise基于覆盖所有2因子的交互作用产生的用例集合性价比最高而产生的。

正文

一、思路

对一个测试场景如何从何从输入被测条件，到产出Pairwise测试用例，使用Python编程思路如下：

1、将allparams=[['M','O','P'],['W','L','I'],['C','E']]进行笛卡尔积全组合处理，生成正则分析法产生的全量测试用例集合的一维数组（len=N）；

2、将全量测试用例中的每个测试用例，都进行两两组合的分解处理，生成与全量测试用例集合 长度相同的二维数组(一维 len=N）；

3、使用Python版Pairwise算法剔除无效测试用例，最终得到有效的结对测试用例集合；

代码第1,2函数利用Python自带数学计算库itertools编写，代码第3函数为本人死磕出来的代码。

二、直接上代码

# -- coding: utf-8 --

from datetime import

import random,os,copy,time

import logging

import itertools

'''

#Author:Kuzaman

#Time:2017-07-18

'''

class utils2 :

#1、笛卡尔积 对参数分组全排列

def product(self,tuple1):

newlist=[]

for x in eval('itertoolsproduct'+str(tuple(tuple1))):

newlistappend(x)

return newlist

#2、对笛卡尔积处理后的二维原始数据进行N配对处理，得到Pairwise计算之前的数据

def get_pairslist(self,lista):

pwlist = []

for i in lista:

subtemplist = []

for sublista in itertoolscombinations(i, 2):

subtemplistappend(sublista)

pwlistappend(subtemplist)

return pwlist

#3、进行Pirwise算法计算

def pairwise(self,listb):

sublistlen = len(listb[1])

flag = [0]sublistlen

templistb = copydeepcopy(listb)

delmenu = []

holdmenu=[]

selfpprint (listb)

print ('--'25)

for lb in listb:

for sublb in lb:

for k in templistb:

Xa = lbindex(sublb)

Ya = listbindex(lb)

if k != lb and sublb == k[Xa]:

# print (sublb,'===>' ,k[Xa],'相等了。。')

flag[Xa] = 1

break

else:

# print (sublb,'===>' ,k[Xa],'不不不等了。。')

flag[Xa] = 0

# print ('下标%d,子元素 %s 双匹配对比结果flag:%s'%(listbindex(lb),lb,flag))

if 0 not in flag:

num = listbindex(lb)

delmenuappend(num)

templistbremove(lb)

# print ('下标为%d行应删除,内容=%s,'%(num,lb))

# print ('delmenu:',delmenu)

else:

num2 = listbindex(lb)

holdmenuappend(num2)

# print ('下标为%d行应保留,内容=%s,'%(num2,lb))

# print('holdmenu=',holdmenu)

# print (''20)

print ('保留元素列表：%s

匹配重复元素列表：%s'%(holdmenu,delmenu))

return templistb

def pwresult(self,slist,delmenu):

for x in delmenu:

slistremove(slist[x])

return slist

def pprint(self,list):

for i in list:

print ('line %d:'%(listindex(i)+1),i)

if __name__ == '__main__':

u2 = utils2()

allparams=[['M','O','P'],['W','L','I'],['C','E']]#,'K'],[1,2,3],['Yes','No']]

str = u2product(allparams)

strpc = u2get_pairslist(str)

finallist = u2pairwise(strpc)

print('最终保留测试用例个数：%d 个'%(len(finallist)))

u2pprint(finallist)代码解读：

第三for循环代码39~48行，主要是垂直判断 待检测元素 与 相同位置的元素是否有相同的

第二for循环代码38~48行，把一组测试用例中的两两配对，从左至右分别和同位置的元素作对比

第一for循环代码37~48行，遍历每一组测试用例。

第50~58行代码，判断一组用例的两两配对在其他组同位置上从上到下都能找到相同元素，则将改无效Case从templistb中删除，保持templistb的有效性。

执行结果：

line 1: [('M', 'W'), ('M', 'C'), ('W', 'C')] <---第二个函数get_pairslist(self,lista)处理后的两两配对组合

line 2: [('M', 'W'), ('M', 'E'), ('W', 'E')] <---同第一行解释

line 3: [('M', 'L'), ('M', 'C'), ('L', 'C')]

line 4: [('M', 'L'), ('M', 'E'), ('L', 'E')]

line 5: [('M', 'I'), ('M', 'C'), ('I', 'C')]

line 6: [('M', 'I'), ('M', 'E'), ('I', 'E')]

line 7: [('O', 'W'), ('O', 'C'), ('W', 'C')]

line 8: [('O', 'W'), ('O', 'E'), ('W', 'E')]

line 9: [('O', 'L'), ('O', 'C'), ('L', 'C')]

line 10: [('O', 'L'), ('O', 'E'), ('L', 'E')]

line 11: [('O', 'I'), ('O', 'C'), ('I', 'C')]

line 12: [('O', 'I'), ('O', 'E'), ('I', 'E')]

line 13: [('P', 'W'), ('P', 'C'), ('W', 'C')]

line 14: [('P', 'W'), ('P', 'E'), ('W', 'E')]

line 15: [('P', 'L'), ('P', 'C'), ('L', 'C')]

line 16: [('P', 'L'), ('P', 'E'), ('L', 'E')]

line 17: [('P', 'I'), ('P', 'C'), ('I', 'C')]

line 18: [('P', 'I'), ('P', 'E'), ('I', 'E')] <----同第一行解释

--------------------------------------------------

保留元素列表：[1, 3, 4, 7, 9, 10, 12, 14, 17] <----有效用例在数组中下标

匹配重复元素列表：[0, 2, 5, 6, 8, 11, 13, 15, 16] <----被剔除的无效测试用例在数组中下标

最终保留测试用例个数：9 个

line 1: [('M', 'W'), ('M', 'E'), ('W', 'E')]

line 2: [('M', 'L'), ('M', 'E'), ('L', 'E')]

line 3: [('M', 'I'), ('M', 'C'), ('I', 'C')]

line 4: [('O', 'W'), ('O', 'E'), ('W', 'E')]

line 5: [('O', 'L'), ('O', 'E'), ('L', 'E')]

line 6: [('O', 'I'), ('O', 'C'), ('I', 'C')]

line 7: [('P', 'W'), ('P', 'C'), ('W', 'C')]

line 8: [('P', 'L'), ('P', 'C'), ('L', 'C')]

line 9: [('P', 'I'), ('P', 'E'), ('I', 'E')]

[Finished in 02s]三、代码核心内容白话解释

pairwise(self,listb)函数包含3层for循环，先画一个二维数组：

i[0] i[1] i[2]

listbindex(i)=0 : [('M', 'W'), ('M', 'C'), ('W', 'C')]

listbindex(i)=1 : [('M', 'W'), ('M', 'E'), ('W', 'E')]

listbindex(i) : [('M', 'L'), ('M', 'C'), ('L', 'C')]

listbindex(i) : [('M', 'L'), ('M', 'E'), ('L', 'E')]

listbindex(i) : [('M', 'I'), ('M', 'C'), ('I', 'C')]

listbindex(i) : [('M', 'I'), ('M', 'E'), ('I', 'E')]

listbindex(i) : [('O', 'W'), ('O', 'E'), ('W', 'E')]

listbindex(i) : [('O', 'L'), ('O', 'C'), ('L', 'C')]

listbindex(i) : [('O', 'L'), ('O', 'E'), ('L', 'E')]

listbindex(i) : [('O', 'I'), ('O', 'C'), ('I', 'C')]

listbindex(i)=n : [('O', 'I'), ('O', 'E'), ('I', 'E')]二维列表 listb ，其中的行（发音：hang，二声。横着的那排）从上到下就是第一层for循环 ；每一行中的i[0],i[1],i[2]就是第二层for循环从左至右；第三次for循环元素i[x]从上之下与有效组 templistb通位置元素的对比。

1、第n行的i[0]要和有效templistb的其他行的i[0]元素对比（第三for），如果有相等的，记录一个标识 如 flag1=True，如果没有相等的记录falg1=False；

2、直到第二for中的i[0],i[1],i[2]都进行对比后，会得到 [flag1，flag2,flag3 ]，所有flag=True则该行为无效用例

3、第一for遍历全部组合，最终得到保留下来的有效templistb

见图：

完结篇

以上是自己编写的pairwise的全部内容，此算法共耗时3天：

第一天在确定这究竟是什么算法，看了很多学术文献，看不懂；

第二天开始写程序，for的嵌套循环设计耽误很久；

第三天程序成型，有执行结果，发现与参考文章结论不同，随后再仔细研读参考文章，发现掉坑里了。重新推翻代码按照正确思路，用1个小时完成最终结果。

本人做测试的，还不是专业的测试开发，写代码比较费劲，真正应了设计占70%，编码占30%的理。如果像基础在差点，逻辑在乱点，就只能用时间堆了。

70个Python 项目列表:

1、[Python转字符画)

2、[200行 Python 代码实现 2048)

3、[Python3 实现火车票查询工具]

4、[高德 API+Python 解决租房问题]

5、[Python3 色情识别]

6、[Python 破解验证码]

7、[Python 实现简单的 Web 服务器

8、[pygame 开发打飞机游戏]

9、[Django 搭建简易博客]

10、[Python 基于共现提取《釜山行》人物关系]

11、[基于 scrapy 爬虫的天气数据采集(python)]

12、[Flask 开发轻博客]

13、[Python3 隐写术]

14、[Python 实现简易 Shell]

15、[使用 Python 解数学方程)

16、[PyQt实现简易浏览器]

17、[神经网络实现手写字符识别系统)

18、[Python 实现简单画板]

19、[Python 实现3D 建模工具]

20、[NBA常规赛结果预测一利用 Python 进行比赛数据分析

[Python文本解析器]

[Python3 & OpenCV 视频转字符动画]

[Python3 实现淘女郎照片爬虫 ]

[Python3实现简单的FTP认证服务器

[基于 Flask 与 MySQL 实现番剧推荐系统

[Python 实现端口扫描器]

[使用Python3编写系列实用脚本]

[Python 实现康威生命游戏]

[Python 3 实现 Markdown 解析器]

[Python 气象数据分析-- 《Python 数据分析实战》

[Python实现键值数据库]

[k-近邻算法实现手写数字识别系统]

[ebay在线拍卖数据分析]

[Python 实现英文新闻摘要自动提取][Python实现简易局域网视频聊天工具]

39、[Python实现Python解释器]

40、[Python3基于Scapy实现DDos]

[Python 实现密码强度检测器]41、

42[使用 Python 实现深度神经网络

不[Python实现从excel读取数据并绘制成精美图像][人机对战初体验:Python基于Pygame实现四子棋游双[Python3 实现可控制肉鸡的反向Shell]

似低城机城根弧引江汉M红纸红致致

[Python打造漏洞扫描器]

[Python应用马尔可夫链算法实现随机文本生成)

[数独游戏的Python实现与破解]

[使用Python定制词云]

[Python开发简单计算器

[Python 实现 FTP 弱口令扫描器

[Python实现Huffman编码解压缩文件]

[Python实现Zip文件的暴力破解]

[Python3 智能裁切]

[Python实现网站模拟登陆

[给Python3爬虫做一个界面妹子图网实战]、[Python 3 实现转彩色字符]

[自联想器的 Python 实现]

[Python 实现简单滤镜]

60(Flask 实现简单聊天室

61、

R

[Python实现模板引擎]

63[Python实现遗传算法求解n-queens问题]

64、[Python3 实现命令行动态进度条]

65、[Python 获取挂号信息并邮件通知

66

、[Python实现java web项目远端自动化更新部署67、[使用 Python3编写 Github 自动周报生成器)

68、[使用 Python 生成分形]

69、[Python 实现 Redis 异步客户端

70、[Python 实现中文错别字高亮系统

这篇文章主要介绍了Python实现的矩阵类,结合完整实例形式分析了Python矩阵的定义、计算、转换等相关操作技巧,需要的朋友可以参考下

本文实例讲述了Python实现的矩阵类。分享给大家供大家参考，具体如下：

科学计算离不开矩阵的运算。当然，python已经有非常好的现成的库：numpy(numpy的简单安装与使用

我写这个矩阵类，并不是打算重新造一个轮子，只是作为一个练习，记录在此。

注：这个类的函数还没全部实现，慢慢在完善吧。

全部代码：

import copy

class Matrix:

'''矩阵类'''

def __init__(self, row, column, fill=00):

selfshape = (row, column)

selfrow = row

selfcolumn = column

self_matrix = [[fill]column for i in range(row)]

# 返回元素m(i, j)的值: m[i, j]

def __getitem__(self, index):

if isinstance(index, int):

return self_matrix[index-1]

elif isinstance(index, tuple):

return self_matrix[index[0]-1][index[1]-1]

# 设置元素m(i,j)的值为s: m[i, j] = s

def __setitem__(self, index, value):

if isinstance(index, int):

self_matrix[index-1] = copydeepcopy(value)

elif isinstance(index, tuple):

self_matrix[index[0]-1][index[1]-1] = value

def __eq__(self, N):

'''相等'''

# A == B

assert isinstance(N, Matrix), "类型不匹配，不能比较"

return Nshape == selfshape # 比较维度，可以修改为别的

def __add__(self, N):

'''加法'''

# A + B

assert Nshape == selfshape, "维度不匹配，不能相加"

M = Matrix(selfrow, selfcolumn)

for r in range(selfrow):

for c in range(selfcolumn):

M[r, c] = self[r, c] + N[r, c]

return M

def __sub__(self, N):

'''减法'''

# A - B

assert Nshape == selfshape, "维度不匹配，不能相减"

M = Matrix(selfrow, selfcolumn)

for r in range(selfrow):

for c in range(selfcolumn):

M[r, c] = self[r, c] - N[r, c]

return M

def __mul__(self, N):

'''乘法'''

# A B (或：A 20)

if isinstance(N, int) or isinstance(N,float):

M = Matrix(selfrow, selfcolumn)

for r in range(selfrow):

for c in range(selfcolumn):

M[r, c] = self[r, c]N

else:

assert Nrow == selfcolumn, "维度不匹配，不能相乘"

M = Matrix(selfrow, Ncolumn)

for r in range(selfrow):

for c in range(Ncolumn):

sum = 0

for k in range(selfcolumn):

sum += self[r, k] N[k, r]

M[r, c] = sum

return M

def __p__(self, N):

'''除法'''

# A / B

pass

def __pow__(self, k):

'''乘方'''

# Ak

assert selfrow == selfcolumn, "不是方阵，不能乘方"

M = copydeepcopy(self)

for i in range(k):

M = M self

return M

def rank(self):

'''矩阵的秩'''

pass

def trace(self):

'''矩阵的迹'''

pass

def adjoint(self):

'''伴随矩阵'''

pass

def invert(self):

'''逆矩阵'''

assert selfrow == selfcolumn, "不是方阵"

M = Matrix(selfrow, selfcolumn2)

I = selfidentity() # 单位矩阵

Ishow()#############################

# 拼接

for r in range(1,Mrow+1):

temp = self[r]

tempextend(I[r])

M[r] = copydeepcopy(temp)

Mshow()#############################

# 初等行变换

for r in range(1, Mrow+1):

# 本行首元素(M[r, r])若为 0，则向下交换最近的当前列元素非零的行

if M[r, r] == 0:

for rr in range(r+1, Mrow+1):

if M[rr, r] != 0:

M[r],M[rr] = M[rr],M[r] # 交换两行

break

assert M[r, r] != 0, '矩阵不可逆'

# 本行首元素(M[r, r])化为 1

temp = M[r,r] # 缓存

for c in range(r, Mcolumn+1):

M[r, c] /= temp

print("M[{0}, {1}] /= {2}"format(r,c,temp))

Mshow()

# 本列上、下方的所有元素化为 0

for rr in range(1, Mrow+1):

temp = M[rr, r] # 缓存

for c in range(r, Mcolumn+1):

if rr == r:

continue

M[rr, c] -= temp M[r, c]

print("M[{0}, {1}] -= {2} M[{3}, {1}]"format(rr, c, temp,r))

Mshow()

# 截取逆矩阵

N = Matrix(selfrow,selfcolumn)

for r in range(1,selfrow+1):

N[r] = M[r][selfrow:]

return N

def jieti(self):

'''行简化阶梯矩阵'''

pass

def transpose(self):

'''转置'''

M = Matrix(selfcolumn, selfrow)

for r in range(selfcolumn):

for c in range(selfrow):

M[r, c] = self[c, r]

return M

def cofactor(self, row, column):

'''代数余子式（用于行列式展开）'''

assert selfrow == selfcolumn, "不是方阵，无法计算代数余子式"

assert selfrow >= 3, "至少是33阶方阵"

assert row <= selfrow and column <= selfcolumn, "下标超出范围"

M = Matrix(selfcolumn-1, selfrow-1)

for r in range(selfrow):

if r == row:

continue

for c in range(selfcolumn):

if c == column:

continue

rr = r-1 if r > row else r

cc = c-1 if c > column else c

M[rr, cc] = self[r, c]

return M

def det(self):

'''计算行列式(determinant)'''

assert selfrow == selfcolumn,"非行列式，不能计算"

if selfshape == (2,2):

return self[1,1]self[2,2]-self[1,2]self[2,1]

else:

sum = 00

for c in range(selfcolumn+1):

sum += (-1)(c+1)self[1,c]selfcofactor(1,c)det()

return sum

def zeros(self):

'''全零矩阵'''

M = Matrix(selfcolumn, selfrow, fill=00)

return M

def ones(self):

'''全1矩阵'''

M = Matrix(selfcolumn, selfrow, fill=10)

return M

def identity(self):

'''单位矩阵'''

assert selfrow == selfcolumn, "非nn矩阵，无单位矩阵"

M = Matrix(selfcolumn, selfrow)

for r in range(selfrow):

for c in range(selfcolumn):

M[r, c] = 10 if r == c else 00

return M

def show(self):

'''打印矩阵'''

for r in range(selfrow):

for c in range(selfcolumn):

print(self[r+1, c+1],end=' ')

print()

if __name__ == '__main__':

m = Matrix(3,3,fill=20)

n = Matrix(3,3,fill=35)

m[1] = [1,1,2]

m[2] = [1,2,1]

m[3] = [2,1,1]

p = m n

q = m21

r = m3

#rshow()

#qshow()

#print(p[1,1])

#r = minvert()

#s = rm

print()

mshow()

print()

#rshow()

print()

#sshow()

print()

print(mdet())

本篇文章给大家带来的内容是关于Python如何实现简单的用户交互程序（示例），有一定的参考价值，有需要的朋友可以参考一下，希望对你有所帮助。

我们经常使用的程序都会有与用户交互的程序，比如网页的登录，需要输入自己的账号，密码这类的用户交互功能。

我们来写个简单的用户输入和输出的程序代码：

user1 = input("账号：") #申明变量user1 储存获取用户输入的账号

password1 = input("密码：") #申明变量 password1 储存获取用户输入的账号

print(user1 , password1) #输出用户输入的账号密码这样就可以要求用户输入账号密码，然后输出获取的账号密码。

我们再举个例子：

题目：我们有100块钱，我们买了name1花了consumption 元，还剩多少钱？

money1 = 100 #定义变量money1

name1 = input("名称：" ) #定义变量买了什么东西name1

consumption1 = input("价格：") #定义变量consumption1价格是多少

print(name1) #输出买的东西名称

print("找回客户", money1-int(consumption1), "块") #计算剩余多少钱，逗号是将各个部分的拼接起来，是独立的部分，所以互相不影响。或者可以

print("找回客户" + str(money1-int(consumption1)) + "块") #计算剩余多少钱，加号连接， 他们是一个整体，所以每个部分都要转换为字符创串的形式才可以相加，输出。

这样就可以输出买了什么东西，找回了多少钱。如下图：

这里我们要注意一些地方：

int 是 integer 的缩写意思 整数

str 是 string 的缩写意思是 字符串

input 所获取的所有数据是字符串的类型，但是money1里的量是整数，所以我们在计算余数时，也就是 money1-int(consumption1) 这里时，需要把变量consumption1接收的字符串转换为整数，用int，我们用第一个输出方式，用逗号隔开相当于字符串之间的拼接。而第二种输出方式用 + 方式连接，所以需要再把整数 money1-int(consumption1) 转换为字符串，用str，这样就可以输出了。