编写python程序、创建名为class的数据库_python面向对象编程class1
python面向對象編程class1
#!/usr/bin/python
class clz:
###name="nam330"
def __init__(self):
self.id=111
self.name="nam222"
print("Hello,1 World!",id,self.id)
def setName(self,name):
self.name=name
print("Hello,2 World!",name,self.name)
@property
def getName(self):
print("Hello,5 World!",self.name)
return self.name
def getNam(self):
print("Hello,5 World!",self.name)
return self.name
c=clz()
print("Hello,3 World!")
###c.setName("name333")
print("Hello,4 World!",c.name)
print("Hello,6 World!",c.getNam() )
print("Hello,6 World!",c.getName )
print("Hello,3 World!")
c.setName("name333")
print("Hello,7 World!",c.name)
print("Hello,8 World!",c.getNam() )
print("Hello,9 World!",c.getName )
python面向對象編程
本篇內容:
1、反射
2、面向對象編程
3、面向對象三大特性
4、類成員
5、類成員修飾符
6、類的特殊成員
7、單例模式
反射
python中的反射功能是由以下四個內置函數提供：hasattr、getattr、setattr、delattr，改四個函數分別用于對對象內部執行：檢查是否含有某成員、獲取成員、設置成員、刪除成員。
復制代碼
import commas同等于下面字符串導入模塊
inp = input("請輸入模塊名：")
dd = __import__(inp)
ret =dd.f1()
print(ret)
復制代碼
復制代碼
#應用根據用戶輸入導入模塊
inp = input("請輸入模塊：")
inp_func = input("請輸入執行的函數：")
# __import__以字符串的形式導入模塊
moudle = __import__(inp)
#getattr 用以去某個模塊中尋找某個函數
target_func = getattr(moudle,inp_func)
relust = target_func()
print(relust)
復制代碼
1、getattr
通過字符串的形式去某個模塊中尋找東西
import commas
#去commas，尋找name變量，找不到返回none
target_func = getattr(commas ,"name",None)
print(target_func)
2、hasattr
通過字符串的形式去某個模塊中判斷東西是否存在
import commas
#去commas模塊中尋找f1，有返回true，沒有返回none
target_func = hasattr(commas,"f1")
print(target_func)
3、setattr
通過字符串的形式去某個模塊中設置東西
復制代碼
import commas
#去commas模塊中尋找name，有返回true，沒有返回none
target_func1 = hasattr(commas,"name")
print(target_func1)
#在內存里往commas模塊中添加name = "zhangyanlin"
setattr(commas,"name","zhangyanlin")
#在內存里往commas模塊中創建函數
setattr(commas,"f3",lambda x: "zhen" if x >10 else "jia")
#去commas模塊中尋找name，有返回true，沒有返回none
target_func = hasattr(commas,"name")
print(target_func)
復制代碼
4、delattr
復制代碼
import commas
target_func = hasattr(commas,"f1")
print(target_func)
del_func = delattr(commas,"f1")
target_func = hasattr(commas,"f1")
print(target_func)
復制代碼
案例：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
'''
基于web框架實現路由功能
'''
url = str(input("請輸入URL：")) #輸入URL，先輸入模塊，后面加函數
target_moudle,target_func = url.split("/") # 用/把分割開，前面是模塊 后面是函數
moudle = __import__(target_moudle,fromlist=True) #導入模塊
if hasattr(moudle,target_func): #判斷模塊里有這個函數
target_func = getattr(moudle,target_func) #找到那個函數
ret = target_func() #執行函數
print(ret)
else: #否則報錯
print("404")
復制代碼
class Foo:
def __init__(self,name):
self.name = name
def login(self):
print("登錄請按1：")
obj = Foo("zhangyanlin")
ret = getattr(obj,"name")
print(ret)
#反射
#以字符串的形式去對續航中操作成員
#反射：類，只能找類的成員
ret = hasattr(Foo,"login")
print(ret)
#反射：對象，既可以找對象也能找類的成員
ret = hasattr(obj,"name")
print(ret)
ret = hasattr(obj,"login")
print(ret)
復制代碼
面向對象編程
面向過程：根據業務邏輯從上到下寫壘代碼
函數式：將某功能代碼封裝到函數中，日后便無需重復編寫，僅調用函數即可
面向對象：對函數進行分類和封裝，讓開發“更快更好更強...”
面向過程編程最易被初學者接受，其往往用一長段代碼來實現指定功能，開發過程中最常見的操作就是粘貼復制，即：將之前實現的代碼塊復制到現需功能處。
1、創建類和對象
面向對象編程是一種編程方式，此編程方式的落地需要使用 “類” 和 “對象” 來實現，所以，面向對象編程其實就是對 “類” 和 “對象” 的使用。
類就是一個模板，模板里可以包含多個函數，函數里實現一些功能
對象則是根據模板創建的實例，通過實例對象可以執行類中的函數
class是關鍵字，表示類
創建對象，類名稱后加括號即可
1
2
3
4
5
6
7
8
9
10
11
12
13
# 創建類
class Foo:
def Bar(self):
print 'Bar'
def Hello(self, name):
print 'i am %s' %name
# 根據類Foo創建對象obj
obj = Foo()
obj.Bar() #執行Bar方法
obj.Hello('wupeiqi') #執行Hello方法
一、封裝
封裝，顧名思義就是將內容封裝到某個地方，以后再去調用被封裝在某處的內容。所以，在使用面向對象的封裝特性時，需要：
將內容封裝到某處
從某處調用被封裝的內容
第一步：將內容封裝到某處
demo
第二步：從某處調用被封裝的內容調用被封裝的內容時，有兩種情況：
通過對象直接調用
通過self間接調用
1、通過對象直接調用被封裝的內容上圖展示了對象 obj1 和 obj2 在內存中保存的方式，根據保存格式可以如此調用被封裝的內容：對象.屬性名
demo 2、通過self間接調用被封裝的內容執行類中的方法時，需要通過self間接調用被封裝的內容
demo 二、繼承繼承，面向對象中的繼承和現實生活中的繼承相同，即：子可以繼承父的內容。例如： 貓可以：喵喵叫、吃、喝、拉、撒 狗可以：汪汪叫、吃、喝、拉、撒吃、喝、拉、撒是貓和狗都具有的功能，而我們卻分別的貓和狗的類中編寫了兩次。如果使用 繼承 的思想，如下實現： 動物：吃、喝、拉、撒 貓：喵喵叫(貓繼承動物的功能) 狗：汪汪叫(狗繼承動物的功能)
demo所以，對于面向對象的繼承來說，其實就是將多個類共有的方法提取到父類中，子類僅需繼承父類而不必一一實現每個方法。注：除了子類和父類的稱謂，你可能看到過 派生類 和 基類 ，他們與子類和父類只是叫法不同而已。 那么問題又來了，多繼承呢？
是否可以繼承多個類
如果繼承的多個類每個類中都定了相同的函數，那么那一個會被使用呢？
1、Python的類可以繼承多個類，Java和C#中則只能繼承一個類
demo 三、多態 Pyhon不支持多態并且也用不到多態，多態的概念是應用于Java和C#這一類強類型語言中，而Python崇尚“鴨子類型”。
python偽代碼實現java，c#多態
python“鴨子類型” 類成員 1、字段:
靜態字段：提供給類里每個對象(方法)使用
普通字段：讓每個方法都有不同的數據
2、方法：
靜態方法： 無需使用對象封裝，用類方法執行
類方法： 類方法執行，調用時會顯示出當前是哪個類
普通方法： 對象方式執行，使用對象中的數據
3、特性：
可以獲取特性 也可以設置特性
一、字段字段包括：普通字段和靜態字段，他們在定義和使用中有所區別，而最本質的區別是內存中保存的位置不同，
普通字段屬于對象
靜態字段屬于類
View Code由上述代碼可以看出【普通字段需要通過對象來訪問】【靜態字段通過類訪問】，在使用上可以看出普通字段和靜態字段的歸屬是不同的。其在內容的存儲方式類似如下圖：注：靜態字段只在內存中保存一份，普通字段在每個對象中都要保存一份 二、方法方法包括：普通方法、靜態方法和類方法，三種方法在內存中都歸屬于類，區別在于調用方式不同。 1、普通方法：由對象調用；至少一個self參數；執行普通方法時，自動將調用該方法的對象賦值給self； 2、類方法：由類調用； 至少一個cls參數；執行類方法時，自動將調用該方法的類復制給cls； 3、靜態方法：由類調用；無默認參數；
定義方法并使用相同點：對于所有的方法而言，均屬于類(非對象)中，所以，在內存中也只保存一份。不同點：方法調用者不同、調用方法時自動傳入的參數不同。 三、特性 如果你已經了解Python類中的方法，那么特性就非常簡單了，因為Python中的屬性其實是普通方法的變種。對于特性，有以下兩個知識點： 1、特性的基本使用 2、特性的兩種定義方式 1、特性的基本使用
特性由屬性的定義和調用要注意一下幾點： 1、定義時，在普通方法的基礎上添加 @property 裝飾器； 2、定義時，屬性僅有一個self參數 3、調用時，無需括號
方法：foo_obj.func()
屬性：foo_obj.prop注意：屬性存在意義是：訪問屬性時可以制造出和訪問字段完全相同的假象 屬性由方法變種而來，如果Python中沒有屬性，方法完全可以代替其功能。實例：對于主機列表頁面，每次請求不可能把數據庫中的所有內容都顯示到頁面上，而是通過分頁的功能局部顯示，所以在向數據庫中請求數據時就要顯示的指定獲取從第m條到第n條的所有數據(即：limit m,n)，這個分頁的功能包括： 1、根據用戶請求的當前頁和總數據條數計算出 m 和 n 2、根據m 和 n 去數據庫中請求數據
View Code 2、屬性的兩種定義方式屬性的定義有兩種方式： 1、裝飾器 即：在方法上應用裝飾器 2、靜態字段 即：在類中定義值為property對象的靜態字段 1.1 裝飾器方式經典類，具有一種@property裝飾器
View Code新式類，具有三種@property裝飾器
View Code注：1、經典類中的屬性只有一種訪問方式，其對應被 @property 修飾的方法
2、新式類中的屬性有三種訪問方式，并分別對應了三個被@property、@方法名.setter、@方法名.deleter修飾的方法由于新式類中具有三種訪問方式，我們可以根據他們幾個屬性的訪問特點，分別將三個方法定義為對同一個屬性：獲取、修改、刪除
View Code 1.2 靜態字段方式，創建值為property對象的靜態字段當使用靜態字段的方式創建屬性時，經典類和新式類無區別
View Codeproperty的構造方法中有個四個參數 1、第一個參數是方法名，調用 對象.屬性 時自動觸發執行方法 2、第二個參數是方法名，調用 對象.屬性 ＝ XXX 時自動觸發執行方法 3、第三個參數是方法名，調用 del 對象.屬性 時自動觸發執行方法 4、第四個參數是字符串，調用 對象.屬性.__doc__ ，此參數是該屬性的描述信息
View Code由于靜態字段方式創建屬性具有三種訪問方式，我們可以根據他們幾個屬性的訪問特點，分別將三個方法定義為對同一個屬性：獲取、修改、刪除
View Code所以，定義屬性共有兩種方式，分別是【裝飾器】和【靜態字段】，而【裝飾器】方式針對經典類和新式類又有所不同。 類成員修飾符 類的所有成員在上一步驟中已經做了詳細的介紹，對于每一個類的成員而言都有兩種形式： 1、公有成員，在任何地方都能訪問 2、私有成員，只有在類的內部才能方法 私有成員和公有成員的定義不同：私有成員命名時，前兩個字符是下劃線。(特殊成員除外，例如：__init__、__call__、__dict__等)
1
2
3
4
5
class C:
def __init__(self):
self.name = '公有字段'
self.__foo = "私有字段"
私有成員和公有成員的訪問限制不同： 1、靜態字段 1、公有靜態字段：類可以訪問；類內部可以訪問；派生類中可以訪問 2、私有靜態字段：僅類內部可以訪問；
公有字段
私有字段2、普通字段 1、公有普通字段：對象可以訪問；類內部可以訪問；派生類中可以訪問 2、私有普通字段：僅類內部可以訪問；注：如果想要強制訪問私有字段，可以通過 【對象._類名__私有字段明 】訪問(如：obj._C__foo)，不建議強制訪問私有成員。
公有字段
私有字段 類的特殊成員 1、 __doc__ 表示類的描述信息
View Code2、 __module__ 和 __class__ __module__ 表示當前操作的對象在那個模塊 __class__ 表示當前操作的對象的類是什么
lib/test.py
index3、 __init__ 構造方法，通過類創建對象時，自動觸發執行。
View Code
繼承父類__init__ 4、 __del__ 析構方法，當對象在內存中被釋放時，自動觸發執行。注：此方法一般無須定義，因為Python是一門高級語言，程序員在使用時無需關心內存的分配和釋放，因為此工作都是交給Python解釋器來執行，所以，析構函數的調用是由解釋器在進行垃圾回收時自動觸發執行的。
code 5、 __call__ 對象后面加括號，觸發執行。注：構造方法的執行是由創建對象觸發的，即：對象 = 類名() ；而對于 __call__ 方法的執行是由對象后加括號觸發的，即：對象() 或者 類()()
View Code6、 __dict__ 類或對象中的所有成員上文中我們知道：類的普通字段屬于對象；類中的靜態字段和方法等屬于類，即：
View Code7、 __str__如果一個類中定義了__str__方法，那么在打印 對象 時，默認輸出該方法的返回值。
View Code8、__getitem__、__setitem__、__delitem__用于索引操作，如字典。以上分別表示獲取、設置、刪除數據
View Code9、 __iter__ 用于迭代器，之所以列表、字典、元組可以進行for循環，是因為類型內部定義了 __iter__
View Code
for循環內部語法 單例模式 所謂單例，是指一個類的實例從始至終只能被創建一次。 方法1如果想使得某個類從始至終最多只有一個實例，使用__new__方法會很簡單。Python中類是通過__new__來創建實例的：
1
2
3
4
5
6
7
8
9
10
11
12
13
class Singleton(object):
def __new__(cls,*args,**kwargs):
if not hasattr(cls,'_inst'):
cls._inst=super(Singleton,cls).__new__(cls,*args,**kwargs)
return cls._inst
if __name__=='__main__':
class A(Singleton):
def __init__(self,s):
self.s=s
a=A('apple')
b=A('banana')
print(id(a),a.s)
print(id(b),b.s)
結果：
1
2
29922256 banana
29922256 banana
通過__new__方法，將類的實例在創建的時候綁定到類屬性_inst上。如果cls._inst為None，說明類還未實例化，實例化并將實例綁定到cls._inst，以后每次實例化的時候都返回第一次實例化創建的實例。注意從Singleton派生子類的時候，不要重載__new__。 方法2當你編寫一個類的時候，某種機制會使用類名字，基類元組，類字典來創建一個類對象。新型類中這種機制默認為type，而且這種機制是可編程的，稱為元類__metaclass__ 。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Singleton(type):
def __init__(self,name,bases,class_dict):
super(Singleton,self).__init__(name,bases,class_dict)
self._instance=None
def __call__(self,*args,**kwargs):
if self._instance is None:
self._instance=super(Singleton,self).__call__(*args,**kwargs)
return self._instance
if __name__=='__main__':
class A(object):
__metaclass__=Singleton
a=A()
b=A()
print(id(a),id(b))
結果：
1
34248016 34248016
id是相同的。例子中我們構造了一個Singleton元類，并使用__call__方法使其能夠模擬函數的行為。構造類A時，將其元類設為Singleton，那么創建類對象A時，行為發生如下：A=Singleton(name,bases,class_dict),A其實為Singleton類的一個實例。創建A的實例時，A()=Singleton(name,bases,class_dict)()=Singleton(name,bases,class_dict).__call__()，這樣就將A的所有實例都指向了A的屬性_instance上，這種方法與方法1其實是相同的。 方法4最簡單的方法：
1
2
3
class singleton(object):
pass
singleton=singleton()
將名字singleton綁定到實例上，singleton就是它自己類的唯一對象了。 方法5
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class ConnectionPool:
__instance = None
def __init__(self):
self.ip = "192.168.1.1"
self.port = 3306
self.username = "zhangyanlin"
self.pwd = 123456
@staticmethod
def get_instance():
if ConnectionPool.__instance:
return ConnectionPool.__instance
else:
ConnectionPool.__instance = ConnectionPool()
return ConnectionPool.__instance
obj1 = ConnectionPool()
print(obj1.get_instance())
obj2 = ConnectionPool()
print(obj2.get_instance())
obj3 = ConnectionPool()
print(obj3.get_instance())
定義靜態方法，判斷讓所有只用第一個對象在內存中創建的ID
一、功能分析
日常生活中我們用的計算器都包括加減乘除冪平方立方1 - 2 * ( (60-30 +(-9**5-2-5-2*-3-5/3-40*4/2-3/5+6*3) * (-9-2-5-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )這么這么長的一個式子，大家算的時候都知道先算冪，立方，平方，再算乘除，加減
二、知識點
所用到的python的知識點有：
正則表達式re模塊
字符串的處理
三、程序實現流程分析
用正則表達式處理字符串，只提取其中的數字和運算符，并轉換成列表
編寫一個函數，處理沒有括號的基本運算的基本表達式
再寫一個函數遞歸處理帶有括號的函數，先計算最內部括號中的表達式, 然后將最內部的括號替換為計算后的結果, 在遞歸外部一層的, 最后返回的就是所需的結果
四、代碼部分
上面也說了處理的時候先處理冪，平方，立方
1、處理冪函數
import re,sys
def Power(arg):
'''
計算冪函數
:param arg: 傳進來的等式
:return: 返回計算完的等式
'''
while True:
relust = re.split(r"(\d+\.?\d*[\*/]{2}-?\d+\.?\d*)", arg, 1)
if len(relust) == 3: # 判斷切割出來的是不是3個元素
before = relust[0] # 第一個元素賦值給before
content = relust[1] # 第二個元素賦值給content
after = relust[2]
if "**" in content: #如果等式里面有“**”
start,end = content.split("**") #用**吧分割開
finlly = float(start) ** float(end) #計算冪等式
arg = before + str(finlly) + after #把結果替換回原等式
else:
return arg
2、處理乘除
從左往右的時候不能先算乘，必須遇到乘就算乘遇到除就算除，樓主在這踩過坑，所以大家也注意下：
def Multply_didvid(arg): #定義乘除運算的函數
'''
計算加減
:param arg: 傳進來的算法
:return: 返回運算結果
'''
while True: #while循環每一次傳進來的運算
arg = re.sub(r"\+\+","+",arg)
arg = re.sub(r"\+\-", "-", arg)
arg = re.sub(r"\-\+", "-", arg)
arg = re.sub(r"\-\-", "+", arg)
relust = re.split(r"(\d+\.?\d*[\*/]-?\d+\.?\d*)",arg,1) #把從左往右第一次匹配到得乘法
# print(relust)
if len(relust) ==3: #判斷切割出來的是不是3個元素
before = relust[0] #第一個元素賦值給before
content = relust[1] #第二個元素賦值給content
after = relust[2] #第三個元素賦值給after
if "*" in content: #判斷第二個元素里面有沒有"*"
start,end = content.split("*") #用“*”把分割開賦值給start，end
finlly = float(start) * float(end) #運算出乘法
arg = before+str(finlly)+after #替換原來的運算式
else: #否則就是除法
start, end = content.split("/") #用/分割開賦值給start，end
finlly = float(start) / float(end) #把除法算出來
arg = before + str(finlly) + after #替換原來的元算是
# print(arg)
else:
return arg #將運算結果返回去
3、處理加減
加減是最簡單的，把每個數字帶前面的符號給切割出來，然后給定義一個計數器，依次相加就可得出結果
def Add_sub(arg): #加減法運算-9-2-5-2+5-3
'''
計算加減運算
:param arg: 傳進來的算術
:return: 返回運算結果
'''
result = re.findall(r"[\+\-]?\d+\.?\d*",arg) #列出所有的元素
start = 0 #定義空值讓他挨個去加
for i in result:
start += float(i) #讓素有元素相加
return start #返回運算結果
4、式子處理函數
拿到式子，我們肯定是先處理式子，把有括號得拿出來處理
def Calculate(source):
'''
計算函數
:param source: 傳進來的等式
:return: 返回計算結果
'''
while True:
source = re.sub(r"\s*", "", source) #去掉空格
source = source.replace("++","+").replace("+-","-").replace("--","+").replace("-+","-") #替換符號
res = re.split(r"\(([^()]+)\)",source,1) #先取出括號里面的值
if len(res) ==3: #判斷分割出來的是不是3個元素
before = res[0] #分別將元素賦值給三個值
content = res[1]
after = res[2]
powe = Power(content)
mu_di = Multply_didvid(powe) #執行乘除
ad_su = Add_sub(mu_di) #執行加減
res = before + str(ad_su) + after #運算結果替換原來等式
source = res #賦值給其他傳進來元素
#print("去括號得到得值為：",source)
else:
powe = Power(source)
mu_di = Multply_didvid(powe) #沒括號得等式
ad_su = Add_sub(mu_di) #計算加法
source = ad_su
# print('最后結果為:',ad_su) #打印最后結果
return source
到這里為止，代碼就可以算是完成了，下面把代碼總和起來，可以運行試試看:
import re,sys
def Power(arg):
'''
計算冪函數
:param arg: 傳進來的等式
:return: 返回計算完的等式
'''
while True:
relust = re.split(r"(\d+\.?\d*[\*/]{2}-?\d+\.?\d*)", arg, 1)
if len(relust) == 3: # 判斷切割出來的是不是3個元素
before = relust[0] # 第一個元素賦值給before
content = relust[1] # 第二個元素賦值給content
after = relust[2]
if "**" in content: #如果等式里面有“**”
start,end = content.split("**") #用**吧分割開
finlly = float(start) ** float(end) #計算冪等式
arg = before + str(finlly) + after #把結果替換回原等式
else:
return arg
def Multply_didvid(arg): #定義乘除運算的函數
'''
計算加減
:param arg: 傳進來的算法
:return: 返回運算結果
'''
while True: #while循環每一次傳進來的運算
arg = re.sub(r"\+\+","+",arg)
arg = re.sub(r"\+\-", "-", arg)
arg = re.sub(r"\-\+", "-", arg)
arg = re.sub(r"\-\-", "+", arg)
relust = re.split(r"(\d+\.?\d*[\*/]-?\d+\.?\d*)",arg,1) #把從左往右第一次匹配到得乘法
# print(relust)
if len(relust) ==3: #判斷切割出來的是不是3個元素
before = relust[0] #第一個元素賦值給before
content = relust[1] #第二個元素賦值給content
after = relust[2] #第三個元素賦值給after
if "*" in content: #判斷第二個元素里面有沒有"*"
start,end = content.split("*") #用“*”把分割開賦值給start，end
finlly = float(start) * float(end) #運算出乘法
arg = before+str(finlly)+after #替換原來的運算式
else: #否則就是除法
start, end = content.split("/") #用/分割開賦值給start，end
finlly = float(start) / float(end) #把除法算出來
arg = before + str(finlly) + after #替換原來的元算是
# print(arg)
else:
return arg #將運算結果返回去
def Add_sub(arg): #加減法運算-9-2-5-2+5-3
'''
計算加減運算
:param arg: 傳進來的算術
:return: 返回運算結果
'''
result = re.findall(r"[\+\-]?\d+\.?\d*",arg) #列出所有的元素
start = 0 #定義空值讓他挨個去加
for i in result:
start += float(i) #讓素有元素相加
return start #返回運算結果
def Calculate(source):
'''
計算函數
:param source: 傳進來的等式
:return: 返回計算結果
'''
while True:
source = re.sub(r"\s*", "", source) #去掉空格
source = source.replace("++","+").replace("+-","-").replace("--","+").replace("-+","-") #替換符號
res = re.split(r"\(([^()]+)\)",source,1) #先取出括號里面的值
if len(res) ==3: #判斷分割出來的是不是3個元素
before = res[0] #分別將元素賦值給三個值
content = res[1]
after = res[2]
powe = Power(content)
mu_di = Multply_didvid(powe) #執行乘除
ad_su = Add_sub(mu_di) #執行加減
res = before + str(ad_su) + after #運算結果替換原來等式
source = res #賦值給其他傳進來元素
#print("去括號得到得值為：",source)
else:
powe = Power(source)
mu_di = Multply_didvid(powe) #沒括號得等式
ad_su = Add_sub(mu_di) #計算加法
source = ad_su
# print('最后結果為:',ad_su) #打印最后結果
return source
print('\n****************************************************************')
print(' \033[33m 歡迎使用計算器(^-_-^) \033[0m')
print('\n****************************************************************')
print("計算等式直接復制即可！:","1 - 2 * ( (60-30 +(-9**5-2-5-2*-3-5/3-40*4/2-3/5+6*3) * (-9-2-5-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )")
while True:
inp = input("請輸入計算等式(q\退出):")
if inp =="q":
sys.exit("歡迎下次光臨！")
elif not inp.strip():
inp = inp.strip()
continue
else:
fin = Calculate(inp)
print("計算結果為:%s" % fin)
print("eval結果為:%s" % eval(inp))
五：總結
死是不是發現還有點復雜，我相信大家還能寫出更簡單的，當然python為了追求簡單，一行代碼也可以搞定，eval()函數直接搞定，但是自己寫下好提高自己的能力嘛
總結
以上是生活随笔為你收集整理的编写python程序、创建名为class的数据库_python面向对象编程class1的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 华融湘江银行是什么性质的银行 华融湘江银
- 下一篇： 九九乘法表编程上三角python_jav