Albert-w

  博客园 :: 首页 :: 博问 :: 闪存 :: 新随笔 :: 联系 :: :: 管理 ::

random模块 取随机值

 

 1 import random
 2  
 3 print(random.random()) #(0,1)----float 随机取大于0且小于1之间的小数
 4  
 5 print(random.randint(1,3))   #[1,3] 随机取大于等于1且小于等于3之间的整数
 6  
 7 print(random.randrange(1,3))  #[1,3) 大于等于1且小于3之间的整数
 8  
 9 print(random.choice([1,'23',[4,5]]))  #1或者23或者[4,5]
10  
11 print(random.sample([1,'23',[4,5]],2))  #列表元素任意2个组合 可能是 1和23  也能使 23 和2 组合
12  
13 print(random.uniform(1,3))  #大于1小于3的小数,如1.927109612082716 
14  
15  
16 item=[1,3,5,7,9]
17 random.shuffle(item) #打乱item的顺序,相当于"洗牌"
18 print(item)

 

 1 import random
 2 print(random.sample([1,'23',[4,5]],2))
 3 print(random.uniform(1,3))
 4 
 5 
 6 item=[1,3,5,7,9]
 7 random.shuffle(item)
 8 print(item)
 9 
10 
11 ##随机生成验证码
12 def make_code(n):   #生成长度为n位的验证码
13     res=''
14     for i in range(n):
15         s1=str(random.randint(0,9))   #产生0 - 9 的随机数字
16         s2=chr(random.randint(65,90)) #产生65 - 90 的随机数字所代表的acsii码的字符 65-90是大写字母
17         res+=random.choice([s1,s2])   #随机选一个
18     return res
19 print(make_code(10))  #生成10位数字+大写字母组合成的随机验证码

##---结果---
[1, [4, 5]]
1.4714607001467908
[9, 3, 1, 5, 7]
IIK7Z9J93Y

 OS模块

os模块是与操作系统交互的一个接口

 1 os.getcwd()   获取当前工作目录,即当前python脚本工作的目录路径
 2 os.chdir("dirname")    改变当前脚本工作目录;相当于shell下cd
 3 os.curdir     返回当前目录: ('.')
 4 os.pardir     获取当前目录的父目录字符串名:('..')
 5 os.makedirs('dirname1/dirname2')    可生成多层递归目录
 6 os.removedirs('dirname1')       若目录为空,则删除,并递归到上一级目录,如若也为空,则删除,依此类推
 7 os.mkdir('dirname')      生成单级目录;相当于shell中mkdir dirname
 8 os.rmdir('dirname')      删除单级空目录,若目录不为空则无法删除,报错;相当于shell中rmdir dirname
 9 os.listdir('dirname')    列出指定目录下的所有文件和子目录,包括隐藏文件,并以列表方式打印
10 os.remove()   删除一个文件
11 os.rename("oldname","newname")  重命名文件/目录
12 os.stat('path/filename')        获取文件/目录信息
13 os.sep        输出操作系统特定的路径分隔符,win下为"\\",Linux下为"/"
14 os.linesep    输出当前平台使用的行终止符,win下为"\t\n",Linux下为"\n"
15 os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:
16 os.name       输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
17 os.system("bash command")  运行shell命令,直接显示
18 os.environ    获取系统环境变量
19 os.path.abspath(path)   返回path规范化的绝对路径
20 os.path.split(path)     将path分割成目录和文件名二元组返回
21 os.path.dirname(path)   返回path的目录。其实就是os.path.split(path)的第一个元素
22 os.path.basename(path)  返回path最后的文件名。如何path以/或\结尾,那么就会返回空值。即os.path.split(path)的第二个元素
23 os.path.exists(path)    如果path存在,返回True;如果path不存在,返回False
24 os.path.isabs(path)     如果path是绝对路径,返回True
25 os.path.isfile(path)    如果path是一个存在的文件,返回True。否则返回False
26 os.path.isdir(path)     如果path是一个存在的目录,则返回True。否则返回False
27 os.path.join(path1[, path2[, ...]])  将多个路径组合后返回,第一个绝对路径之前的参数将被忽略
28 os.path.getatime(path)  返回path所指向的文件或者目录的最后存取时间
29 os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间
30 os.path.getsize(path)   返回path的大小

在Linux和Mac平台上,该函数会原样返回path,在windows平台上会将路径中所有字符转换为小写,并将所有斜杠转换为饭斜杠。
>>> os.path.normcase('c:/windows\\system32\\')
'c:\\windows\\system32\\'

规范化路径,如..和/
>>> os.path.normpath('c://windows\\System32\\../Temp/')
'c:\\windows\\Temp'

>>> a='/Users/jieli/test1/\\\a1/\\\\aa.py/../..'
>>> print(os.path.normpath(a))
/Users/jieli/test1

os路径处理


#方式一:推荐使用

import os
#具体应用
import os,sys
possible_topdir = os.path.normpath(os.path.join(
    os.path.abspath(__file__),
    os.pardir, #上一级
    os.pardir,
    os.pardir
))
sys.path.insert(0,possible_topdir)

#方式二:不推荐使用

os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

 

 1 import os
 2 
 3 # print(os.listdir('.')) #当前目录文件
 4 
 5 # print(os.stat('m1.py').st_size)
 6 
 7 # print(os.sep)     #路径分隔符
 8 # print(os.linesep) #换行符
 9 # print(os.pathsep) #文件路径分隔符
10 
11 # print([os.sep,os.linesep,os.pathsep])  #用列表的形式展示
12 
13 # res=os.system('dir .')  #当前目录下有什么子文件
14 # print('====?>',res)
15 
16 # print(os.path.dirname(r'C:\a\b\c\d\a.txt'))
17 # print(os.path.basename(r'C:\a\b\c\d\a.txt'))
18 # print(os.path.split(r'C:\a\b\c\d\a.txt'))
19 
20 # print(os.stat('m1.py').st_atime)
21 # print(os.stat('m1.py').st_size)
22 # print(os.path.getsize('m1.py'))
23 
24 
25 # print(os.path.join('C:\\','a','b','c','d.txt'))  #拼接路径,如果有多个绝对路径,最后一个绝对路径之前的全部忽略
26 # print(os.path.join('C:\\','a','b','D:\\','c','d.txt'))
27 
28 # print(os.path.normcase('c:/wiNdows\\system32\\')  ) #路径格式转换,对于win系统,左斜杠变为右斜杠,大写字母变为小写字母
29 
30 # print(os.path.normpath('c://wIndows\\System32\\../Temp/')  ) #..代表上级目录  
31 #--结果  c:\wIndows\Temp

32 # a='/Users/jieli/test1/\\\a1/\\\\aa.py/../..' 33 # print(os.path.normpath(a)) 34 #--结果 \Users\jieli\test1 35 36 print(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) 37 38 BASE_DIR=os.path.normpath(os.path.join( 39 os.path.abspath(__file__), 40 '..', 41 '..' 42 ) 43 ) 44 print(BASE_DIR)

 sys模块

1 sys.argv           命令行参数List,第一个元素是程序本身路径
2 sys.exit(n)        退出程序,正常退出时exit(0)
3 sys.version        获取Python解释程序的版本信息
4 sys.maxint         最大的Int值
5 sys.path           返回模块的搜索路径,初始化时使用PYTHONPATH环境变量的值
6 sys.platform       返回操作系统平台名称

打印进度条
 1 #=========知识储备==========
 2 #进度条的效果
 3 [#             ]
 4 [##            ]
 5 [###           ]
 6 [####          ]
 7 
 8 #指定宽度
 9 print('[%-15s]' %'#')
10 print('[%-15s]' %'##')
11 print('[%-15s]' %'###')
12 print('[%-15s]' %'####')
13 
14 #打印%
15 print('%s%%' %(100)) #第二个%号代表取消第一个%的特殊意义
16 
17 #可传参来控制宽度
18 print('[%%-%ds]' %50) #[%-50s]
19 print(('[%%-%ds]' %50) %'#')
20 print(('[%%-%ds]' %50) %'##')
21 print(('[%%-%ds]' %50) %'###')
22 
23 
24 #=========实现打印进度条函数==========
25 import sys
26 import time
27 
28 def progress(percent,width=50):
29     if percent >= 1:
30         percent=1
31     show_str=('[%%-%ds]' %width) %(int(width*percent)*'#')
32     print('\r%s %d%%' %(show_str,int(100*percent)),file=sys.stdout,flush=True,end='')
33 
34 
35 #=========应用==========
36 data_size=1025
37 recv_size=0
38 while recv_size < data_size:
39     time.sleep(0.1) #模拟数据的传输延迟
40     recv_size+=1024 #每次收1024
41 
42     percent=recv_size/data_size #接收的比例
43     progress(percent,width=70) #进度条的宽度70
44 
45 #打印进度条
 1 ###模拟下载进度条
 2 def progress(percent,width=50): #固定宽度
 3     if percent >= 100:
 4         # print('\r[%s] 100%%' %(width*'#'))
 5         percent=100
 6     show_str=('[%%-%ds]' %width) %(int(width*percent/100)*'#')  #固定长度,百分比的形式
 7     print('\r%s %d%%' %(show_str,percent),file=sys.stdout,flush=True,end='')
 8 #
 9 total_size=1025121
10 recv_size=0
11 
12 while recv_size < total_size:
13     time.sleep(0.01) #模拟下载的网络延迟
14     recv_size+=1024  #传输速率
15     recv_per=int(100*recv_size/total_size)
16     progress(recv_per,width=10)

  json&pickle模块

之前我们学习过用eval内置方法可以将一个字符串转成python对象,不过,eval方法是有局限性的,对于普通的数据类型,json.loads和eval都能用,但遇到特殊类型的时候,eval就不管用了,所以eval的重点还是通常用来执行一个字符串表达式,并返回表达式的值。

1 import json
2 x="[null,true,false,1]"
3 print(eval(x)) #报错,无法解析null类型,而json就可以
4 print(json.loads(x))


什么是序列化?

我们把对象(变量)从内存中变成可存储或传输的过程称之为序列化,在Python中叫pickling,在其他语言中也被称之为serialization,marshalling,flattening等等,都是一个意思。

为什么要序列化?

1:持久保存状态

需知一个软件/程序的执行就在处理一系列状态的变化,在编程语言中,'状态'会以各种各样有结构的数据类型(也可简单的理解为变量)的形式被保存在内存中。

内存是无法永久保存数据的,当程序运行了一段时间,我们断电或者重启程序,内存中关于这个程序的之前一段时间的数据(有结构)都被清空了。

在断电或重启程序之前将程序当前内存中所有的数据都保存下来(保存到文件中),以便于下次程序执行能够从文件中载入之前的数据,然后继续执行,这就是序列化。

具体的来说,你玩使命召唤闯到了第13关,你保存游戏状态,关机走人,下次再玩,还能从上次的位置开始继续闯关。或如,虚拟机状态的挂起等。

2:跨平台数据交互

序列化之后,不仅可以把序列化后的内容写入磁盘,还可以通过网络传输到别的机器上,如果收发的双方约定好实用一种序列化的格式,那么便打破了平台/语言差异化带来的限制,实现了跨平台数据交互。

反过来,把变量内容从序列化的对象重新读到内存里称之为反序列化,即unpickling。

如何序列化之json和pickle:

json

如果我们要在不同的编程语言之间传递对象,就必须把对象序列化为标准格式,比如XML,但更好的方法是序列化为JSON,因为JSON表示出来就是一个字符串,可以被所有语言读取,也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式,并且比XML更快,而且可以直接在Web页面中读取,非常方便。

   内存中结构化数据 <-----> 格式JSON <----->字符串 <-----> 保存到文件中会基于网络传输

举例

 1 import json
 2 # dic={'name':'egon','age':18}  #一个自定类型
 3 
 4 # print(type(json.dumps(dic)))  #导入模块 叫 json , 序列化,字典转成了字符串形式,使用 dumps转换
 5 
 6 # with open('a.json','w') as f: #可以吧转换后的字符串写入到文件中
 7 #     f.write(json.dumps(dic))  
 8 
 9 # with open('a.json','r') as f: #使用json读取文件   evel只是把字符串里的命令提取出来执行下,没有序列化的作用
10 #     data=f.read()
11 #     dic=json.loads(data)      #取文件,相当于反序列化
12 #     print(dic['name'])
13 
14 # dic={'name':'egon','age':18}  #原生字典
15 # json.dump(dic,open('b.json','w')) #序列化 dump  生成字符串
16 # print(json.load(open('b.json','r'))['name']) #反解序列化  字符串解析成字典
17 
18 
19 
20 # with open('c.json','r') as f:
21 #     data=f.read()
22 #     #[null,true,false,1]
23 #     eval(data)  #evel只是把字符串里的命令提取出来执行下,没有序列化的作用

注意点

1 import json
2 #dct="{'1':111}"#json 不认单引号
3 #dct=str({"1":111})#报错,因为生成的数据还是单引号:{'one': 1}
4 
5 dct='{"1":"111"}'
6 print(json.loads(dct))
7 
8 #conclusion:
9 #        无论数据是怎样创建的,只要满足json格式,就可以json.loads出来,不一定非要dumps的数据才能loads

pickle序列化

内存中结构化数据 <-----> 格式pickle <----->bytes类型 <-----> 保存到文件中会基于网络传输

Pickle的问题和所有其他编程语言特有的序列化问题一样,就是它只能用于Python,并且可能不同版本的Python彼此都不兼容,因此,只能用Pickle保存那些不重要的数据,不能成功地反序列化也没关系。

 1 import pickle
 2  
 3 dic={'name':'alvin','age':23,'sex':'male'}
 4  
 5 print(type(dic))#<class 'dict'>
 6  
 7 j=pickle.dumps(dic)
 8 print(type(j))#<class 'bytes'>
 9  
10  
11 f=open('序列化对象_pickle','wb')#注意是w是写入str,wb是写入bytes,j是'bytes'
12 f.write(j)  #-------------------等价于pickle.dump(dic,f)
13  
14 f.close()
15 #-------------------------反序列化
16 import pickle
17 f=open('序列化对象_pickle','rb')
18  
19 data=pickle.loads(f.read())#  等价于data=pickle.load(f)
20  
21  
22 print(data['age'])
 1 #pickle序列化
 2 import pickle
 3 
 4 # dic={'name':'egon','age':18}
 5 #
 6 # print(pickle.dumps(dic))
 7 # with open('d.pkl','wb') as f:
 8 #     f.write(pickle.dumps(dic))  #序列化,将字典的形式转换成byte类型
 9 
10 # with open('d.pkl','rb') as f:
11 #     dic=pickle.loads(f.read())   #反序列化
12 #     print(dic['name'])
13 
14 # dic={'name':'egon','age':18}
15 # pickle.dump(dic,open('e.pkl','wb'))
16 
17 
18 # print(pickle.load(open('e.pkl','rb'))['name'])
21 
22 #
23 
24 def func():
25     print('from func')
26 
28 # import json
29 # print(json.dumps(func)) #函数不是json对象
30 
31 import pickle
32 # print(pickle.dumps(func))  #只要是放到内存里的东西都可以序列化
33 pickle.dump(func,open('func.pkl','wb'))
34 
35 ####################
36 #pickle反序列化(基于内存中有这个地址才能反序列化)
37 import pickle
38 
39 # def func():
40 #     print('反序列化的文件')
41 
42 # pickle.dump(func,open('func.pkl','wb'))
43 # f=pickle.load(open('func.pkl','rb'))
44 # print(f)
45 
46 
47 # class Foo:
48 #     pass
49 
50 
51 # obj1=Foo()
52 # obj2=Foo()
53 # print(obj1 is obj2)
54 
55 # pickle.dump(obj1,open('class.pkl','wb'))
56 
57 
58 # import pickle
59 # pickle.load(open('class.pkl','rb'))  #反序列化
60 
61 
62 
63 # l1=list()
64 # l2=list()
65 # print(type(l1))
66 # print(type(l2))

 shelve模块

shelve模块比pickle模块简单,只有一个open函数,返回类似字典的对象,可读可写;
key必须为字符串,而值可以是python所支持的数据类型

1 import shelve
2 
3 f=shelve.open(r'sheve.txt')
4 # f['stu1_info']={'name':'egon','age':18,'hobby':['piao','smoking','drinking']}
5 # f['stu2_info']={'name':'gangdan','age':53}
6 # f['school_info']={'website':'http://www.pypy.org','city':'beijing'}
7 
8 print(f['stu1_info']['hobby'])
9 f.close()

小练习 计算器

开发一个简单的python计算器

1、实现加减乘除及拓号优先级解析
2、用户输入 1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )等类似公式后,必须自己解析里面的(),+,-,*,/符号和公式(不能调用eval等类似功能偷懒实现),运算后得出结果,结果必须与真实的计算器所得出的结果一致

 

  1 #!/usr/bin/env python
  2 # -*- coding:utf-8 -*-
  3 """
  4 该计算器思路:
  5     1、递归寻找表达式中只含有 数字和运算符的表达式,并计算结果
  6     2、由于整数计算会忽略小数,所有的数字都认为是浮点型操作,以此来保留小数
  7 使用技术:
  8     1、正则表达式
  9     2、递归
 10  
 11 执行流程如下:
 12 ******************** 请计算表达式: 1 - 2 * ( (60-30 +(-40.0/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) ) ********************
 13 before: ['1-2*((60-30+(-40.0/5)*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2))']
 14 -40.0/5=-8.0
 15 after: ['1-2*((60-30+-8.0*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2))']
 16 ========== 上一次计算结束 ==========
 17 before: ['1-2*((60-30+-8.0*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2))']
 18 9-2*5/3+7/3*99/4*2998+10*568/14=173545.880953
 19 after: ['1-2*((60-30+-8.0*173545.880953)-(-4*3)/(16-3*2))']
 20 ========== 上一次计算结束 ==========
 21 before: ['1-2*((60-30+-8.0*173545.880953)-(-4*3)/(16-3*2))']
 22 60-30+-8.0*173545.880953=-1388337.04762
 23 after: ['1-2*(-1388337.04762-(-4*3)/(16-3*2))']
 24 ========== 上一次计算结束 ==========
 25 before: ['1-2*(-1388337.04762-(-4*3)/(16-3*2))']
 26 -4*3=-12.0
 27 after: ['1-2*(-1388337.04762--12.0/(16-3*2))']
 28 ========== 上一次计算结束 ==========
 29 before: ['1-2*(-1388337.04762--12.0/(16-3*2))']
 30 16-3*2=10.0
 31 after: ['1-2*(-1388337.04762--12.0/10.0)']
 32 ========== 上一次计算结束 ==========
 33 before: ['1-2*(-1388337.04762--12.0/10.0)']
 34 -1388337.04762--12.0/10.0=-1388335.84762
 35 after: ['1-2*-1388335.84762']
 36 ========== 上一次计算结束 ==========
 37 我的计算结果: 2776672.69524
 38 """
 39  
 40  
 41 import re
 42  
 43  
 44 def compute_mul_div(arg):
 45     """ 操作乘除
 46     :param expression:表达式
 47     :return:计算结果
 48     """
 49  
 50     val = arg[0]
 51     mch = re.search('\d+\.*\d*[\*\/]+[\+\-]?\d+\.*\d*', val)
 52     if not mch:
 53         return
 54     content = re.search('\d+\.*\d*[\*\/]+[\+\-]?\d+\.*\d*', val).group()
 55  
 56     if len(content.split('*'))>1:
 57         n1, n2 = content.split('*')
 58         value = float(n1) * float(n2)
 59     else:
 60         n1, n2 = content.split('/')
 61         value = float(n1) / float(n2)
 62  
 63     before, after = re.split('\d+\.*\d*[\*\/]+[\+\-]?\d+\.*\d*', val, 1)
 64     new_str = "%s%s%s" % (before,value,after)
 65     arg[0] = new_str
 66     compute_mul_div(arg)
 67  
 68  
 69 def compute_add_sub(arg):
 70     """ 操作加减
 71     :param expression:表达式
 72     :return:计算结果
 73     """
 74     while True:
 75         if arg[0].__contains__('+-') or arg[0].__contains__("++") or arg[0].__contains__('-+') or arg[0].__contains__("--"):
 76             arg[0] = arg[0].replace('+-','-')
 77             arg[0] = arg[0].replace('++','+')
 78             arg[0] = arg[0].replace('-+','-')
 79             arg[0] = arg[0].replace('--','+')
 80         else:
 81             break
 82  
 83     if arg[0].startswith('-'):
 84         arg[1] += 1
 85         arg[0] = arg[0].replace('-','&')
 86         arg[0] = arg[0].replace('+','-')
 87         arg[0] = arg[0].replace('&','+')
 88         arg[0] = arg[0][1:]
 89     val = arg[0]
 90     mch = re.search('\d+\.*\d*[\+\-]{1}\d+\.*\d*', val)
 91     if not mch:
 92         return
 93     content = re.search('\d+\.*\d*[\+\-]{1}\d+\.*\d*', val).group()
 94     if len(content.split('+'))>1:
 95         n1, n2 = content.split('+')
 96         value = float(n1) + float(n2)
 97     else:
 98         n1, n2 = content.split('-')
 99         value = float(n1) - float(n2)
100  
101     before, after = re.split('\d+\.*\d*[\+\-]{1}\d+\.*\d*', val, 1)
102     new_str = "%s%s%s" % (before,value,after)
103     arg[0] = new_str
104     compute_add_sub(arg)
105  
106  
107 def compute(expression):
108     """ 操作加减乘除
109     :param expression:表达式
110     :return:计算结果
111     """
112     inp = [expression,0]
113  
114     # 处理表达式中的乘除
115     compute_mul_div(inp)
116  
117     # 处理
118     compute_add_sub(inp)
119     if divmod(inp[1],2)[1] == 1:
120         result = float(inp[0])
121         result = result * -1
122     else:
123         result = float(inp[0])
124     return result
125  
126  
127 def exec_bracket(expression):
128     """ 递归处理括号,并计算
129     :param expression: 表达式
130     :return:最终计算结果
131     """
132     # 如果表达式中已经没有括号,则直接调用负责计算的函数,将表达式结果返回,如:2*1-82+444
133     if not re.search('\(([\+\-\*\/]*\d+\.*\d*){2,}\)', expression):
134         final = compute(expression)
135         return final
136     # 获取 第一个 只含有 数字/小数 和 操作符 的括号
137     # 如:
138     #    ['1-2*((60-30+(-40.0/5)*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2))']
139     #    找出:(-40.0/5)
140     content = re.search('\(([\+\-\*\/]*\d+\.*\d*){2,}\)', expression).group()
141  
142     # 分割表达式,即:
143     # 将['1-2*((60-30+(-40.0/5)*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2))']
144     # 分割更三部分:['1-2*((60-30+(    (-40.0/5)      *(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2))']
145     before, nothing, after = re.split('\(([\+\-\*\/]*\d+\.*\d*){2,}\)', expression, 1)
146  
147     print 'before:',expression
148     content = content[1:len(content)-1]
149  
150     # 计算,提取的表示 (-40.0/5),并活的结果,即:-40.0/5=-8.0
151     ret = compute(content)
152  
153     print '%s=%s' %( content, ret)
154  
155     # 将执行结果拼接,['1-2*((60-30+(      -8.0     *(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2))']
156     expression = "%s%s%s" %(before, ret, after)
157     print 'after:',expression
158     print "="*10,'上一次计算结束',"="*10
159  
160     # 循环继续下次括号处理操作,本次携带者的是已被处理后的表达式,即:
161     # ['1-2*((60-30+   -8.0  *(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2))']
162  
163     # 如此周而复始的操作,直到表达式中不再含有括号
164     return exec_bracket(expression)
165  
166  
167  
168 # 使用 __name__ 的目的:
169 #   只有执行 python index.py 时,以下代码才执行
170 #   如果其他人导入该模块,以下代码不执行
171 if __name__ == "__main__":
172     #print '*'*20,"请计算表达式:", "1 - 2 * ( (60-30 +(-40.0/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )" ,'*'*20
173     #inpp = '1 - 2 * ( (60-30 +(-40.0/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) ) '
174     inpp = "1-2*-30/-12*(-20+200*-3/-200*-300-100)"
175     #inpp = "1-5*980.0"
176     inpp = re.sub('\s*','',inpp)
177     # 表达式保存在列表中
178     result = exec_bracket(inpp)
179     print result
Python计算器

 

posted on 2019-10-16 15:55  Albert-w  阅读(170)  评论(0编辑  收藏  举报