标签：等于 私有属性 访问 class val c++ rop icm 实例
@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)) #外部不能调用私有方法
标签：等于 私有属性 访问 class val c++ rop icm 实例
原文地址：http://blog.51cto.com/13496943/2347453
