python3-基礎13

時間 2019-11-09

原文原文鏈接

random模塊取隨機值python

 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模塊web

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\\'
shell

規範化路徑，如..和/
>>> os.path.normpath('c://windows\\System32\\../Temp/')
'c:\\windows\\Temp' express

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

os路徑處理json

#方式一：推薦使用windows

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)

#方式二：不推薦使用bash

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 * ( (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     一、遞歸尋找表達式中只含有 數字和運算符的表達式，並計算結果
  6     二、因爲整數計算會忽略小數，全部的數字都認爲是浮點型操做，以此來保留小數
  7 使用技術：
  8     一、正則表達式
  9     二、遞歸
 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計算器

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。