python学习31(面向对象_2)

@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)) #外部不能调用私有方法