2018-08-01 python学习—面向对象(内置类）

class Color:
    """颜色类"""
    red = (255, 0 , 0)
#用于验证__module__

from color import Color
"""
内置类属性：python中每个类都拥有内置的类属性
__name__
__doc__
__dict__   #如果用__slots__方法去约束对象属性后，对象__dict__不能使用（）子类也是
__module__
__bases__
"""
class Animal:
    """动物类"""
    pass


class Cat(Animal):

    """说明文档:猫类"""
    number = 0


    def __init__(self, name='', color=''):
        self.name = name
        self.color = color

    def run(self):
        print('%s在跑' % self.name)

    @staticmethod
    def shout():
        print('喵~')

    @classmethod
    def get_number(cls):
        print('猫的数量:%d' % cls.number)


if __name__ == '__main__':
    cat1 = Cat('小花', 'white')

    """
    1.类.__name__
    获取类的名字(字符串)
    """
    print(Cat.__name__)  #Cat

    """
    2.类.__doc__
    获取类的说明文档
    """
    print(Cat.__doc__)     #说明文档:猫类
    print(list.__doc__)    
 #list() -> new empty list
 #list(iterable) -> new list initialized from iterable's items

    """
    3.类.__dict__  获取类中所有的类属性和对应的值，以键值对的形式存到字典中
      对象.__dict__ 将对象的属性和对应的值，转换成字典的元素（常用,记住）
    """
    print(Cat.__dict__)
"""
结果：
{'__module__': '__main__', '__doc__': '说明文档:猫类', 'number': 0,
 '__init__': , 
'run': ,
 'shout': , 
'get_number': }
"""
    print(cat1.__dict__)  #{'name': '小花', 'color': 'white'}

    """
    4.类.__module__: 获取当前类所在的模块的名字
    
    """
    print(Cat.__module__)  #__main__
    print(Color.__module__)   #color

    """
    5.类.__bases__: 获取当前类的父类
    """
    print(Cat.__bases__)    #(,)

继承后，子类可以拥有除父类继承的内容以外的其他的内容

1.关于方法
1）.在子类中可以直接添加其他的方法
2）.重写：
a.完全重写
重新实现从父类继承下来的方法，重写后，子类再调用这个方法的时候，就调用子类的
b.保留父类实现的功能，再添加新的功能

对象和类调用方法的过程：先看当前类是否存在这个方法，没有才看父类有没有这个方法；
如果父类没有就看父类的父类有没有，直到找到基类(object)为止

class Animal(object):
    """动物类"""
    def __init__(self):
        self.age = 0
        self.color = ''

    def eat(self):
        print('吃东西')

    def shout(self):
        print('叫唤')

    @classmethod
    def get_number(cls):
        return 100


class Dog(Animal):
    """狗类"""
    def look_after(self):
        print('看家')

    #  重写父类的shout
    def shout(self):
        print('汪汪汪~')

    # 重写父类eat方法
    def eat(self):
        # 保留父类eat的功能
        super().eat()
        print('吃骨头')

    @classmethod
    def get_number(cls):
        # 保留父类的类方法的功能的时候，还是super().类方法
        print(super().get_number())


if __name__ == '__main__':
    dog = Dog()
    dog.age = 3
    print(dog.color)
    dog.shout()
    dog.look_after()
    dog.eat()

    an = Animal()
    # 继承后，父类不能使用在子类中添加的属性和方法
    # an.look_after()
    an.eat()

    Dog.get_number()

对象属性的继承：是通过继承init方法来继承的对象属性

给当前类添加对象属性: 重写init方法。
注意：如果要保留父类的对象属性，需要使用super()去调用父类的init方法

多态：同一个事物有多种形态。
方法的多态：子类继承父类的方法，可以对方法进行重写，一个方法就有多种形态（多态的表现）
类的多态：继承产生多态

class Person(object):
    """人类"""
    def __init__(self, name, age=0, sex=''):
        self.name = name
        self.age = age
        self.sex = sex

    def eat(self):
        print('人在吃饭')


class Staff(Person):
    # init方法的参数：保证在创建对象的时候就可以给某些属性赋值
    def __init__(self, name='', age=0, salary=0):
        super().__init__(name, age)
        self.salary = salary

    def eat(self):
        print('员工在吃饭')

class Scientist(Person):
    def eat(self):
        print('科学家在吃饭')

if __name__ == '__main__':
    p1 = Person('李四',sex='女')
    p1.eat()

    s1 = Staff(age=18)
    s1.sex = '男'
    print(s1.name)
    s1.salary = 10000
    print(s1.salary)
    s1.eat()

1.重载：一个类中可以有多个名字相同的方法，但是参数不一样，就叫重载。python中不支持

class Student:

    # python不支持方法的重载
    # def run(self):
    #     print('人在跑')
    def run(self, name):
        print('%s在跑' % name)

"""
2.运算符重载（重新定义运算符运算的过程）
>、<
大于和小于符号只需要重载其中的一个，另外一个的结果，直接是重的结果取反
>
+、-
"""
class Student2:
    def __init__(self, name='', age=0, height=0):
        self.name = name
        self.age = age
        self.height = height

    #   重载: >
    """
    self > other
    """
    def __gt__(self, other):
        # 比较对象1>对象2的时候是比较的他们的height属性
        return self.height > other.height
        # return self.age > other.age
        # return id(self) > id(other)

    # 重载：<
    def __lt__(self, other):
        return self.age < other.age

    # 重载: +
    def __add__(self, other):
        return self.age + other.age

    # 重载: -
    def __sub__(self, other):
        return self.height - other.height