python类(2)

#从python开始学习编程 学习笔记

以后看书时注意一下书上表述：好像是类属性attribute，对象特性property，对象方法

1、对于一个类下的全部个体来说，某些属性可能存在个体差异。不是所有的人类都是男，或者都是女。这个性质的值随着对象的不同而不同。

因此，为了完整描述个体，除了共性的类属性外，我们还需要用于说明个性的对象属性。在类中，我们可以通过self来操作对象的属性。

2、python提供了初始化对象属性的办法，python定义了一系列特殊方法，又称为魔法方法，前后有两个下划线，比如__init__()、__add__()、__dict__()等

3、对于类的__init__()方法，python会在每次创建对象时自动调用。因此，我们可以在__init__()方法内部来初始化对象属性。

4、除了操作对象属性外，self参数还有另外一个功能，就是能让我们在一个方法内部调用同一类的其他方法。

5、覆盖，一般情况下，子类和父类都有的方法，子类会覆盖父类的方法，可以调用super函数保留父类方法（有点奇怪，搞两个方法干啥了？？）

class Bird:
    def chirp(self):
        print('make sound')

class Chicken(Bird):
    def chirp(self):
        super().chirp()
        print('ji')
summer=Chicken()
print(summer.chirp())
# make sound
# ji
# None
#从结果来看，先调用父类方法，再调用子类方法

6、一切皆对象：我们知道，list是列表的类。如果用dir(list)查看list的属性，能看到一个属性是__add__(),从样式来看，__add__()是特殊方法（魔法方法）。

他特殊在哪呢？这个方法定义了‘+’运算符对于list对象的意义，两个list对象相加时，会进行合并列表的操作。

(1.8).__mul__(2.8)      #5.04
True.__or__(False)      #True
[1,2,3]+[4,5,6]         #[1, 2, 3, 4, 5, 6]
['abc']+['def']         #['abc', 'def']
'abc'.__add__('def')    #'abcdef'

7、属性覆盖的背后

class Bird:
    feather=True
    def chirp(self):
        print('some sound')
class Chicken(Bird):
    fly=False
    def __init__(self,age):
        self.age=age
    def chirp(self):
        print('ji')
summer=Chicken(2)
print('==============> summer')
print(summer.__dict__)
print('==============> Chicken')
print(Chicken.__dict__)
print('==============> Bird')
print(Bird.__dict__)
print('==============> object')
print(object.__dict__)

==============> summer
{'age': 2}
==============> Chicken
{'__module__': '__main__', 'fly': False, '__init__': <function Chicken.__init__ at 0x00000188456A0488>, 'chirp': <function Chicken.chirp at 0x00000188456A0510>, '__doc__': None}
==============> Bird
{'__module__': '__main__', 'feather': True, 'chirp': <function Bird.chirp at 0x00000188456A0598>, '__dict__': <attribute '__dict__' of 'Bird' objects>, '__weakref__': <attribute '__weakref__' of 'Bird' objects>, '__doc__': None}
==============> object
{'__repr__': <slot wrapper '__repr__' of 'object' objects>, '__hash__': <slot wrapper '__hash__' of 'object' objects>, '__str__': <slot wrapper '__str__' of 'object' objects>, '__getattribute__': <slot wrapper '__getattribute__' of 'object' objects>, '__setattr__': <slot wrapper '__setattr__' of 'object' objects>, '__delattr__': <slot wrapper '__delattr__' of 'object' objects>, '__lt__': <slot wrapper '__lt__' of 'object' objects>, '__le__': <slot wrapper '__le__' of 'object' objects>, '__eq__': <slot wrapper '__eq__' of 'object' objects>, '__ne__': <slot wrapper '__ne__' of 'object' objects>, '__gt__': <slot wrapper '__gt__' of 'object' objects>, '__ge__': <slot wrapper '__ge__' of 'object' objects>, '__init__': <slot wrapper '__init__' of 'object' objects>, '__new__': <built-in method __new__ of type object at 0x0000000059A8B580>, '__reduce_ex__': <method '__reduce_ex__' of 'object' objects>, '__reduce__': <method '__reduce__' of 'object' objects>, '__subclasshook__': <method '__subclasshook__' of 'object' objects>, '__init_subclass__': <method '__init_subclass__' of 'object' objects>, '__format__': <method '__format__' of 'object' objects>, '__sizeof__': <method '__sizeof__' of 'object' objects>, '__dir__': <method '__dir__' of 'object' objects>, '__class__': <attribute '__class__' of 'object' objects>, '__doc__': 'The most base type'}

第一行为bird类的属性，比如feather。第二行为chicken类的属性，比如fly和__init__方法。第三行为summer对象的属性，也就是age。有一些属性，比如__doc__，并不是由我们定义的，而是由Python自动生成。此外，bird类也有父类，是object类(正如我们的bird定义，class bird(object))。这个object类是Python中所有类的父类。

print(dir(summer))
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'age', 'chirp', 'feather', 'fly']

如果我们用内置函数dir来查看summer的属性的话，可以看到summer对象包含了全部四个部分，也就是说，Python中的属性是分层定义的，比如这里分为object/bird/chicken/summer这四层。当我们需要调用某个属性的时候，Python会一层层向上遍历，直到找到那个属性。(某个属性可能出现在不同的层被重复定义，Python向上的过程中，会选取先遇到的那一个，也就是比较低层的属性定义)。这正是属性覆盖的原理所在。由于对象不需要重复存储其祖先类的属性，所以分层管理的机制可以节省存储空间。

值得注意的是，上面都是调用属性的操作，如果进行赋值，那么python就不会分层深入查找了。

autumn=Chicken(3)
autumn.feather=False
print(summer.feather)  #True
print(autumn.__dict__) #{'age': 3, 'feather': False}

因此，python在为属性赋值时，只会搜索对象本身的__dict__，如果找不到对应属性，则将在__dict__中增加。在类 定义的方法中，如果用self引用对象，

也会遵守相同规则。

此外，我们可以不依赖继承关系，直接去操作某个祖先类的属性。

Bird.feather=3

8、特性

同一个对象的不同属性之间可能存在依赖关系。当某个属性被修改时，我们希望依赖于该属性的其他属性也同时变化。这时，我们不能通过__dict__的静态词典

方式来存储属性。Python提供了多种即时生成属性的方法。其中一种称为特性(property)。特性是特殊的属性。

class Bird:
    feather=True
class Chicken(Bird):
    fly=False
    def __init__(self,age):
        self.age=age
    def get_adult(self):
        if self.age>1.0:
            return True
        else:
            return False
    adult=property(get_adult) #property is bulit-in
summer=Chicken(2)
print(summer.adult)  #True
print(summer.get_adult())#True
summer.age=0.5
print(summer.adult)  #False
print(summer.get_adult()) #False

class Bird:
    feather=True
class Chicken(Bird):
    fly=False
    def __init__(self,age):
        self.age=age
    @property
    def get_adult(self):
        if self.age>1.0:
            return True
        else:
            return False
summer=Chicken(2)
print(summer.get_adult)#True
summer.age=0.5
print(summer.get_adult) #False

9、比较如下代码区别：

class Bird:
    feather=True
    age=2
    def __init__(self,name):
        self.name=name
class Chicken(Bird):
    fly=False
    def __init__(self,age):
        self.age=age
    @property
    def get_adult(self):
        if self.age>1.0:
            return True
        else:
            return False
summer=Chicken(2)
print(summer.get_adult)#True
summer.age=0.5
print(summer.get_adult) #False

class Bird:
    feather=True
    age=2
    def __init__(self,name):
        self.name=name
class Chicken(Bird):
    fly=False
#     def __init__(self,age):
#         self.age=age
    @property
    def get_adult(self):
        if self.age>1.0:
            return True
        else:
            return False
summer=Chicken()
print(summer.get_adult)
summer.age=0.5
print(summer.get_adult)
#如果用self引用对象，本层没有，好像会找到父类那一层去。

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-48-496496d87f7c> in <module>()
     14         else:
     15             return False
---> 16 summer=Chicken()
     17 print(summer.get_adult)#True
     18 summer.age=0.5

TypeError: __init__() missing 1 required positional argument: 'name'

class Bird:
    feather=True
    age=2
    def __init__(self,name):
        self.name=name
class Chicken(Bird):
    fly=False
#     def __init__(self,age):
#         self.age=age
    @property
    def get_adult(self):
        if self.age>1.0:
            return True
        else:
            return False
summer=Chicken(2)
print(summer.get_adult)#True
summer.age=0.5
print(summer.get_adult) #False

class Bird:
    feather=True
    age=2
    def __init__(self,name):
        self.name=name
class Chicken(Bird):
    fly=False
    age=2              #增加age=2
#     def __init__(self,age):
#         self.age=age
    @property
    def get_adult(self):
        if self.age>1.0:
            return True
        else:
            return False
summer=Chicken()
print(summer.get_adult)
summer.age=0.5
print(summer.get_adult)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-50-9ac0fb881573> in <module>()
     15         else:
     16             return False
---> 17 summer=Chicken()
     18 print(summer.get_adult)#True
     19 summer.age=0.5

TypeError: __init__() missing 1 required positional argument: 'name'

class Bird:
    feather=True
    age=2
class Chicken(Bird):
    fly=False
    @property
    def get_adult(self):
        if Bird.age>1.0:
            return True
        else:
            return False
summer=Chicken()
print(summer.get_adult)#True
summer.age=0.5
print(summer.get_adult) #True

与上面类似，修改了实例特性，但是类属性没有修改，通过类方法调用的时候修改不起 作用，类属性没有修改。

class A:
    x='jim'
    @classmethod
    def run(cls):
        y=cls.x
        print('{} is running'.format(y))
        return y
class B(A):
    pass
b=B()
print(b.run())
b.x='yang'
print(b.x)
print(A.x)
print(b.run())
#jim is running
#jim
#yang
#jim
#jim is running
#jim

10、特性使用内置函数property()来创建。property()最多可以加载四个参数。前三个参数为函数，分别用于设置获取、修改和删除特性是，Python应该执行的操作。最后一个参数为特性的文档，可以为一个字符串，起说明作用。

class Num:
    def __init__(self,value):
        self.value=value
    def get_neg(self):
        return -self.value
    def set_neg(self,value):
        self.value=-value
    def del_neg(self):
        print('value also deleted')
        del self.value
    neg=property(get_neg,set_neg,del_neg,'i am negative')
x=Num(1.2)
print(x.neg)  # -1.2
x.neg=-22
print(x.value)  #
print(Num.neg.__doc__) #i am negative
del x.neg       #value also deleted