python學習31(面向對象_2)
阿新 • • 發佈:2019-01-29
ava 裝飾器 一定的 setattr self. 對象 eth 並且 等於
@method_name.setter @method_name.deleter
定義時在普通方法的基礎上添加@method_name.setter裝飾器,賦值操作時候自動執行被修飾的方法;添加@method_name.deleter裝飾器,del 刪除
#coding=utf-8
class Goods(object):
@property
def price(self):
print("@property")
return "hhq"
@price.setter
def price(self,value):
print("@price.setter")
print(value)
@price.deleter
def price(self):
print("@price.deleter")
obj = Goods()
print(obj.price)#自動執行@property修飾的方法,並獲得返回值
obj.price = 123#自動執行@prirce_setter修飾的方法,並將123賦值方法的參數
del obj.price#自動執行@price_deleter修飾的方法
新式類中的屬性有三種訪問方式,並分別對應了三個被@property、@方法名.setter、@方法名.deleter修飾的方法
動態添加、刪除、修改類的實例變量
#conding=utf-8
class Employee(object):
empCount = 0
def __init__(self,name,salary):
self.name = name
self.salary = salary
age = 10
Employee.empCount += 1
def displayCount(self):
print "total employee ", Employee.empCount
def displayEmployee(self):
print "name: ",self.name,"salary: ",self.salary
emp1 = Employee("SR",10000)
emp1.displayCount()
emp1.displayEmployee()
emp1.salary = 20000#可以直接修改類的屬性值
print emp1.salary
emp1.age = 25#類本來沒有age這個實例變量,可以動態添加
print emp1.age
del emp1.age #可以刪除添加的實例變量,原實例變量也可以刪除
Employee.var = 9#可以增加類變量
print Employee.var
使用函數添加、刪除、修改、訪問類屬性
1、getattr(obj, name[, default]) : 訪問對象的屬性,如果存在返回對象屬性的值,否則拋出AttributeError異常。
2、hasattr(obj,name) : 檢查是否存在某個屬性,存在返回True,否則返回False。
3、setattr(obj,name,value) : 設置一個屬性。如果屬性不存在,會創建一個新屬性,該函數無返回值。若存在則更新這個值
4、delattr(obj, name) : 刪除屬性,如果屬性不存在則拋出AttributeError異常,該函數也無返回值
#conding=utf-8
class Employee(object):
empCount = 0
def __init__(self,name,salary):
self.name = name
self.salary = salary
Employee.empCount += 1
def displayCount(self):
print ("total employee:", Employee.empCount)
def displayEmployee(self):
print ("name: ",self.name,"salary: ",self.salary)
emp1 = Employee("SR",10000)
if hasattr(emp1,"name"):判斷實例變量name是否存在,存在的話返回True
print("屬性name存在")
else:
print("屬性name不存在")
print(getattr(emp1,"name"))#獲取實例變量name的值
setattr(emp1,"name","HR")#設置實例變量name的值
print(emp1.name)
setattr(emp1,"age",10)#age不存在,創建age並賦值10
print(emp1.age)
delattr(emp1,"age")#刪除實例變量age
print(emp1.age)
Python內置類屬性
Python有如下內置的類屬性:
__dict__ : 類的屬性(包含一個字典,由類的數據屬性組成)
__doc__ :類的文檔字符串,也就是類的幫助信息。
__name__: 類名
__module__: 類定義所在的模塊(類的全名是’__main__.className’,如
果類位於一個導入模塊mymod中,那麽className.__module__ 等於
mymod)
__bases__ : 類的所有父類(包含了所有父類組成的元組)
示例:
#conding=utf-8
class Person(object):
"這是一個Person類"
static_var = 0
def __init__(self,name,age):
self.age = age
self.name = name
def get_info(self):
return "name:%s age:%s" %(self.name,self.age)
def get_static_var(self):
return p.static_var
#return P.static_var
if __name__ == "__main__":
p = Person("huhongqiang",20)
print(p.__dict__)
print(Person.__dict__)
print(p.__doc__)
print(Person.__doc__)
print(Person.__name__)
print(Person.__module__)
print(p.__module__)
print(Person.__bases__)
類變量
Python中類變量也叫類的靜態成員變量或類屬性,類變量在整個實例化的對象中是公用的。類變量定義在類中且在函數體外。類變量通常不作為實例變量使用,它的值在這個類的所有實例之間共享。類變量緊接在類名後面定義,相當於java和c++的static變量。實例變量在__init__()函數裏定義,相當於java和c++的普通變量。
類變量可被類直接訪問,也可以被實例對象直接訪問
#conding=utf-8
class Person(object):
"這是一個Person類"
static_var = 0 #類變量
def __init__(self,name,age):
self.age = age
self.name = name
def get_info(self):
return "name:%s age:%s" %(self.name,self.age)
def set_static_var(self):
Person.static_var += 1
def get_static_var(self):
return p.static_var
#return P.static_var
if __name__ == "__main__":
p = Person("huhongqiang",20)
p.set_static_var()
p2 = Person("dg",30)
p2.set_static_var()
print(p.static_var)
print(p2.static_var)
實例變量
實例變量是在__init__函數裏定義的,相當於java和c++的普通變量,只作用於當前類的實例。實例變量前面需要加上self關鍵字,表示執行實例本身。
全局變量、局部變量、靜態變量(類變量)、實例變量
a、全局變量:在模塊內、在所有函數外面、在class外面,這就是全局變量。
b、局部變量:在函數內、在class的方法內(未加self修飾的),這就是局部變量
c、 靜態變量:在class內的,但不在class的方法內的,這就是靜態變量
d、 實例變量:在class的方法內的,用self修飾的變量,這就是實例變量
修改類變量
通過類方法修改
通過實例方法修改
通過類修改
通過靜態方法修改
#conding=utf-8
class Person(object):
class_var = 10
def ins_method(self):
Person.class_var = 20#通過實例方法修改
@classmethod
def class_method(cls):
Person.class_var = 30#通過類方法修改
@staticmethod
def static_method():
Person.class_var = 40#通過靜態方法修改
p = Person()
p.ins_method()
print(Person.class_var)
Person.class_method()
print(Person.class_var)
Person.static_method()
print(Person.class_var)
Person.class_var = "xxxx"#通過類直接修改類變量
print(Person.class_var)
修改類變量(二)
>>> class Foo(object):
... x = {1:"a"}
...
>>> foo = Foo()
>>> foo.x
{1: ‘a‘}
>>> Foo.x
{1: ‘a‘}
>>> foo.x[2] = "b"#此處修改的是類變量,添加了一個鍵值對
>>> foo.x
{1: ‘a‘, 2: ‘b‘}
>>> Foo.x
{1: ‘a‘, 2: ‘b‘}
>>> foo.x = {3:"c"}#此處添加了一個實例變量,只不過和類變量同名
>>> foo.x#實例對象優先訪問自己的實例變量
{3: ‘c‘}
>>> Foo.x#訪問類變量
{1: ‘a‘, 2: ‘b‘}
>>> del foo.x#刪除實例變量x
>>> foo.x
{1: ‘a‘, 2: ‘b‘}
class P(object):
list1 = [1,2,3]
p = P()
p.list1[0] = 10#修改了類變量的值
print(p.list1)
print(P.list1)
p.list1 = ["a","b","c"]#增加一個同名的實例變量
print(p.list1)
print(P.list1)
類方法
類方法是類對象所擁有的方法,在類的內部使用關鍵字def定義的方法,但與一般方法不同的是,需要用修飾器”@classmethod”來標識其為類方法,並且在定義類方法時需要把類本身的實例(cls,指向該類本身)作為參數傳進入。類方法既可以直接使用類名去調用,還可以使用類的實例去調
靜態方法
靜態方法是在類的內部使用關鍵字def定義的方法,但與其他方法不同的是,需要用修飾器”@staticmethod”來標識其為靜態方法,並且在定義靜態方法時不需要傳入任何隱式參數。
靜態方法既可以直接使用類名去調用,還可以使用類的實例去調
實例方法
實例方法則是類中定義的普通方法,定義時需要傳入隱式參數self,且為第一個參數,調用時則不需要,並且只能通過實例調用
類方法可以被類對象或實例調用,實例方法只能被實例調用,它只屬於類的單個實例擁有,靜態方法兩者都能調用,它在類和實例間共享。Python實現了一定的靈活性使得類方法和靜態方法,都能夠被實例和類二者調用。所以三者主要區別在於參數傳遞上的區別,實例方法隱含傳的參數是類實例self,而類方法隱含傳遞的參數是類本身cls,而靜態方法無隱含參數,主要為了類實例也可以直接調用靜態方法。
類的私有屬性
私有變量
類可以把類變量、實例變量定義成私有變量,私有變量以兩個下劃線”__”開頭,不能在類的外部被直接訪問,只能在類的內部被訪問, 訪問時候需要加self,self.__private_attr
class Person(object):
__privateCount = 0
def __init__(self,name):
self.__name = name
def visit_private_attr(self):
#self.__privatCount += 1
Person.__privateCount = 10
print(self.__name)
print(Person.__privateCount)
p = Person("huhongqiang")
p.visit_private_attr()
print(Person.__privateCount)#類外不能訪問私有變量
print(p.__name)
私有方法
私有方法以兩個下劃線__開頭,只能在類的內部使用,在類內部使用私有方法需要加self,self.private_metod,不能在類的外部調用
示例:
class Person(object):
id = 12
def __init__(self,name):
self.name = name
self.__inName = "ads"
def __setId(self,id):
Person.id = id*2
def getId(self):
self.__setId(18)#類內部普通方法調用私有方法
return Person.id
p = Person("perl")
print(p.getId())
print("類的外部調用私有方法")
print(p.__setId(12)) #外部不能調用私有方法
python學習31(面向對象_2)