python刷新函数,python动态刷新

Python Qt5中textBrowser控件实现实时刷新,并不是函数执行完成后一次全部打印出来

QTimer timer;

成都创新互联公司是专业的富蕴网站建设公司,富蕴接单;提供网站制作、成都网站设计,网页设计,网站设计,建网站,PHP网站建设等专业做网站服务;采用PHP框架,可快速的进行富蕴网站开发网页制作和功能扩展;专业做搜索引擎喜爱的网站,专业的做网站团队,希望更多企业前来合作!

timer.setInterval(1000);

timer.start();

connect(timer,SIGNAL(timeOut()),this,SLOT(myTimerout()));

void thisObject::myTimerOut()

{

ui-textBrowser-append(QString("hello === %1").arg(i));

}

Python刷新excel

用openpyxl读取excel的load_workbook有个data_only参数。

例如:

yb_wb = load_workbook(u"D:\Desktop\xxx.xlsx", data_only=True)顾名思义,True时,只读data,忽略公式。

但是有个情景是——得先保留公式,根据旧公式写入新公式。然后再读取值进行操作。也就是说先data_only = False,然后再data_only = True。

这样会导致读取值操作的时候,公式全部没有了。对,全部为空。就是这么奇怪。

wb = openpyxl.load_workbook(‘abc.xlsx’, data_only=True)

当’abc.xlsx’被生成并在Excel程序中打开并保存之后(这个过程Excel会把公式结果计算出来),该文件附带有两套值,一套是公式全都没有计算的(data_only=False(默认)),一套是公式计算了结果的(data_only=True)。(如果没有被Excel打开并保存,则只有一套值(data_only=False的那套,公式没有计算结果的)。

此时,以data_only=True或默认data_only=False打开会得到两种不同的结果,各自独立,即data_only=True状态下打开的,会发现公式结果为None(空值)或者一个计算好的常数,而不会看到它原本的公式是如何。而data_only=False则只会显示公式而已。因此,data_only=True状态下打开,如果最后用save()函数保存了,则原xlsx文件中,公式会被替换为常数结果或空值。而data_only=False状态下打开,最后用save()函数保存了的话,原xlsx文件也会只剩下data_only=False的那套值(即公式),另一套(data_only=True)的值会丢失,如想重新获得两套值,则仍旧需要用Excel程序打开该文件并保存。

解决方法:

可以定义一个刷新函数重新打开一次并保存。

from win32com.client import Dispatch

def just_open(filename):

xlApp = Dispatch("Excel.Application")

xlApp.Visible = False

xlBook = xlApp.Workbooks.Open(filename)

xlBook.Save()

xlBook.Close()

print('自动更新结束')

filename = r"D:\Desktop\xxx.xlsx"

just_open(filename)

先调用win32com打开一次,就OK,原公式就会变成值,后面就可以愉快的操作了。

python 8个常用内置函数解说

8个超好用内置函数set(),eval(),sorted(),reversed(),map(),reduce(),filter(),enumerate()

python中有许多内置函数,不像print那么广为人知,但它们却异常的强大,用好了可以大大提高代码效率。

这次来梳理下8个好用的python内置函数

1、set()

当需要对一个列表进行去重操作的时候,set()函数就派上用场了。

用于创建一个集合,集合里的元素是无序且不重复的。集合对象创建后,还能使用并集、交集、差集功能。

2、eval()之前有人问如何用python写一个四则运算器,输入字符串公式,直接产生结果。用eval()来做就很简单:eval(str_expression)作用是将字符串转换成表达式,并且执行。

3、sorted()在处理数据过程中,我们经常会用到排序操作,比如将列表、字典、元组里面的元素正/倒排序。这时候就需要用到sorted() ,它可以对任何可迭代对象进行排序,并返回列表。对列表升序操作:

对元组倒序操作:

使用参数:key,根据自定义规则,按字符串长度来排序:

根据自定义规则,对元组构成的列表进行排序:

4、reversed()如果需要对序列的元素进行反转操作,reversed()函数能帮到你。reversed()接受一个序列,将序列里的元素反转,并最终返回迭代器。

5、map()做文本处理的时候,假如要对序列里的每个单词进行大写转化操作。这个时候就可以使用map()函数。

map()会根据提供的函数,对指定的序列做映射,最终返回迭代器。也就是说map()函数会把序列里的每一个元素用指定的方法加工一遍,最终返回给你加工好的序列。举个例子,对列表里的每个数字作平方处理:

6、reduce()前面说到对列表里的每个数字作平方处理,用map()函数。那我想将列表里的每个元素相乘,该怎么做呢?这时候用到reduce()函数。

reduce()会对参数序列中元素进行累积。第一、第二个元素先进行函数操作,生成的结果再和第三个元素进行函数操作,以此类推,最终生成所有元素累积运算的结果。再举个例子,将字母连接成字符串。

你可能已经注意到,reduce()函数在python3里已经不再是内置函数,而是迁移到了functools模块中。这里把reduce()函数拎出来讲,是因为它太重要了。

7、filter()一些数字组成的列表,要把其中偶数去掉,该怎么做呢?

filter()函数轻松完成了任务,它用于过滤序列,过滤掉不符合条件的元素,返回一个迭代器对象。filter()函数和map()、reduce()函数类似,都是将序列里的每个元素映射到函数,最终返回结果。我们再试试,如何从许多单词里挑出包含字母w的单词。

8、enumerate()这样一个场景,同时打印出序列里每一个元素和它对应的顺序号,我们用enumerate()函数做做看。

enumerate翻译过来是枚举、列举的意思,所以说enumerate()函数用于对序列里的元素进行顺序标注,返回(元素、索引)组成的迭代器。再举个例子说明,对字符串进行标注,返回每个字母和其索引。

python字典操作函数

字典是一种通过名字或者关键字引用的得数据结构,其键可以是数字、字符串、元组,这种结构类型也称之为映射。字典类型是Python中唯一内建的映射类型,基本的操作包括如下:

(1)len():返回字典中键—值对的数量;

(2)d[k]:返回关键字对于的值;

(3)d[k]=v:将值关联到键值k上;

(4)del d[k]:删除键值为k的项;

(5)key in d:键值key是否在d中,是返回True,否则返回False。

(6)clear函数:清除字典中的所有项

(7)copy函数:返回一个具有相同键值的新字典;deepcopy()函数使用深复制,复制其包含所有的值,这个方法可以解决由于副本修改而使原始字典也变化的问题

(8)fromkeys函数:使用给定的键建立新的字典,键默认对应的值为None

(9)get函数:访问字典成员

(10)has_key函数:检查字典中是否含有给出的键

(11)items和iteritems函数:items将所有的字典项以列表方式返回,列表中项来自(键,值),iteritems与items作用相似,但是返回的是一个迭代器对象而不是列表

(12)keys和iterkeys:keys将字典中的键以列表形式返回,iterkeys返回键的迭代器

(13)pop函数:删除字典中对应的键

(14)popitem函数:移出字典中的项

(15)setdefault函数:类似于get方法,获取与给定键相关联的值,也可以在字典中不包含给定键的情况下设定相应的键值

(16)update函数:用一个字典更新另外一个字典

(17) values和itervalues函数:values以列表的形式返回字典中的值,itervalues返回值得迭代器,由于在字典中值不是唯一的,所以列表中可以包含重复的元素

一、字典的创建

1.1 直接创建字典

d={'one':1,'two':2,'three':3}

printd

printd['two']

printd['three']

运算结果:

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

1.2 通过dict创建字典

# _*_ coding:utf-8 _*_

items=[('one',1),('two',2),('three',3),('four',4)]

printu'items中的内容:'

printitems

printu'利用dict创建字典,输出字典内容:'

d=dict(items)

printd

printu'查询字典中的内容:'

printd['one']

printd['three']

运算结果:

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

items中的内容:

[('one',1), ('two',2), ('three',3), ('four',4)]

利用dict创建字典,输出字典内容:

{'four':4,'three':3,'two':2,'one':1}

查询字典中的内容:

或者通过关键字创建字典

# _*_ coding:utf-8 _*_

d=dict(one=1,two=2,three=3)

printu'输出字典内容:'

printd

printu'查询字典中的内容:'

printd['one']

printd['three']

运算结果:

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

输出字典内容:

{'three':3,'two':2,'one':1}

查询字典中的内容:

二、字典的格式化字符串

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3,'four':4}

printd

print"three is %(three)s."%d

运算结果:

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'four':4,'three':3,'two':2,'one':1}

threeis3.

三、字典方法

3.1 clear函数:清除字典中的所有项

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3,'four':4}

printd

d.clear()

printd

运算结果:

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'four':4,'three':3,'two':2,'one':1}

{}

请看下面两个例子

3.1.1

# _*_ coding:utf-8 _*_

d={}

dd=d

d['one']=1

d['two']=2

printdd

d={}

printd

printdd

运算结果:

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'two':2,'one':1}

{}

{'two':2,'one':1}

3.1.2

# _*_ coding:utf-8 _*_

d={}

dd=d

d['one']=1

d['two']=2

printdd

d.clear()

printd

printdd

运算结果:

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'two':2,'one':1}

{}

{}

3.1.2与3.1.1唯一不同的是在对字典d的清空处理上,3.1.1将d关联到一个新的空字典上,这种方式对字典dd是没有影响的,所以在字典d被置空后,字典dd里面的值仍旧没有变化。但是在3.1.2中clear方法清空字典d中的内容,clear是一个原地操作的方法,使得d中的内容全部被置空,这样dd所指向的空间也被置空。

3.2 copy函数:返回一个具有相同键值的新字典

# _*_ coding:utf-8 _*_

x={'one':1,'two':2,'three':3,'test':['a','b','c']}

printu'初始X字典:'

printx

printu'X复制到Y:'

y=x.copy()

printu'Y字典:'

printy

y['three']=33

printu'修改Y中的值,观察输出:'

printy

printx

printu'删除Y中的值,观察输出'

y['test'].remove('c')

printy

printx

运算结果:

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

初始X字典:

{'test': ['a','b','c'],'three':3,'two':2,'one':1}

X复制到Y:

Y字典:

{'test': ['a','b','c'],'one':1,'three':3,'two':2}

修改Y中的值,观察输出:

{'test': ['a','b','c'],'one':1,'three':33,'two':2}

{'test': ['a','b','c'],'three':3,'two':2,'one':1}

删除Y中的值,观察输出

{'test': ['a','b'],'one':1,'three':33,'two':2}

{'test': ['a','b'],'three':3,'two':2,'one':1}

注:在复制的副本中对值进行替换后,对原来的字典不产生影响,但是如果修改了副本,原始的字典也会被修改。deepcopy函数使用深复制,复制其包含所有的值,这个方法可以解决由于副本修改而使原始字典也变化的问题。

# _*_ coding:utf-8 _*_

fromcopyimportdeepcopy

x={}

x['test']=['a','b','c','d']

y=x.copy()

z=deepcopy(x)

printu'输出:'

printy

printz

printu'修改后输出:'

x['test'].append('e')

printy

printz

运算输出:

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

输出:

{'test': ['a','b','c','d']}

{'test': ['a','b','c','d']}

修改后输出:

{'test': ['a','b','c','d','e']}

{'test': ['a','b','c','d']}

3.3 fromkeys函数:使用给定的键建立新的字典,键默认对应的值为None

# _*_ coding:utf-8 _*_

d=dict.fromkeys(['one','two','three'])

printd

运算输出:

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':None,'two':None,'one':None}

或者指定默认的对应值

# _*_ coding:utf-8 _*_

d=dict.fromkeys(['one','two','three'],'unknow')

printd

运算结果:

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':'unknow','two':'unknow','one':'unknow'}

3.4 get函数:访问字典成员

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

printd.get('one')

printd.get('four')

运算结果:

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

1

None

注:get函数可以访问字典中不存在的键,当该键不存在是返回None

3.5 has_key函数:检查字典中是否含有给出的键

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

printd.has_key('one')

printd.has_key('four')

运算结果:

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

True

False

3.6 items和iteritems函数:items将所有的字典项以列表方式返回,列表中项来自(键,值),iteritems与items作用相似,但是返回的是一个迭代器对象而不是列表

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

list=d.items()

forkey,valueinlist:

printkey,':',value

运算结果:

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

three :3

two :2

one :1

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

it=d.iteritems()

fork,vinit:

print"d[%s]="%k,v

运算结果:

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

d[three]=3

d[two]=2

d[one]=1

3.7 keys和iterkeys:keys将字典中的键以列表形式返回,iterkeys返回键的迭代器

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

printu'keys方法:'

list=d.keys()

printlist

printu'\niterkeys方法:'

it=d.iterkeys()

forxinit:

printx

运算结果:

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

keys方法:

['three','two','one']

iterkeys方法:

three

two

one

3.8 pop函数:删除字典中对应的键

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

d.pop('one')

printd

运算结果:

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

{'three':3,'two':2}

3.9 popitem函数:移出字典中的项

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

d.popitem()

printd

运算结果:

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

{'two':2,'one':1}

3.10 setdefault函数:类似于get方法,获取与给定键相关联的值,也可以在字典中不包含给定键的情况下设定相应的键值

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

printd.setdefault('one',1)

printd.setdefault('four',4)

printd

运算结果:

{'three':3,'two':2,'one':1}

{'four':4,'three':3,'two':2,'one':1}

3.11 update函数:用一个字典更新另外一个字典

# _*_ coding:utf-8 _*_

d={

'one':123,

'two':2,

'three':3

}

printd

x={'one':1}

d.update(x)

printd

运算结果:

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':123}

{'three':3,'two':2,'one':1}

3.12 values和itervalues函数:values以列表的形式返回字典中的值,itervalues返回值得迭代器,由于在字典中值不是唯一的,所以列表中可以包含重复的元素

# _*_ coding:utf-8 _*_

d={

'one':123,

'two':2,

'three':3,

'test':2

}

printd.values()

运算结果:

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

[2,3,2,123]


网页题目:python刷新函数,python动态刷新
分享链接:http://myzitong.com/article/hdoigg.html