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)