面向对象

类的三大属性

封装

封装是一个信号，用来告诉开发者这个类中的属性是否可以改变。一般来说，我们用getter()方法来表示该属性不能被修改，用setter()方法来说明这个类如果要被修改应该使用的手段和方法。

• 可以用在属性前加一个_来表示该属性是不允许被修改的。
• 同时也可以加 __来表示该属性是被隐藏的，这种时候可以不用getter()和setter()方法。

注意：封装后的类的属性依旧是可以被修改的，getter()方法只是做到提示。

class Dog():
    def __init__(self,name):
        self._name=name
    #getter()
    def get_name(self):
        print('get')
        return self._name
    #setter()
    def set_name(self,name):
        self._name=name
dog=Dog('藏獒')
print(dog._name)
print(dog.get_name())

property装饰器

• @property   property装饰器可以让程序不可被修改
• @name.setter()   即修改属性的setter()方法

class Person():
    def __init__(self,name):
        self._name=name
    #getter()
    @property
    def name(self):
        print('get')
        return self.name
    #setter()
    @name.setter
    def name(self,name):
        self._name=name

继承

继承是python中一个非常重要的属性，可以通过继承获取父类的方法，进而使代码变得简洁，可操作性强。所有类都有一个共同的父类——object

值得一提的是，我们可以用issubclass来判断两个类之间是否有继承关系。

class animal():
    def __init__(self,name):
        self.name=name
    def run(self):
        print('%s会跑'%self.name)
    def sleep(self):
        print('%s会睡觉'%self.name)
class dog(animal):
    pass
dog1=dog('藏獒')
dog1.run()
print(issubclass(animal,object))
print(issubclass(dog,animal))
print(issubclass(animal,dog))

多重继承

一个类可以同时作为几个类的子类，同时具有它们的方法。

class A:
    def method1(self):
        print('a')
class B:
    def method2(self):
        print('b')
class C(A,B):
    pass

print(C.__bases__)
print(issubclass(C,A))
print(issubclass(C,B))
c=C()
c.method1()
c.method2()

多态

让代码变得更加灵活，操作更加方便。

class Person():
    def __init__(self,name):
        self._name=name
    def run(self):
        print('人能跑')
    #getter()
    @property
    def name(self):
        print('get')
        return self._name
    #setter()
    @name.setter
    def name(self,name):
        self._name=name

class person(Person):
    pass

a=Person('a')
b=person('b')

def speak(name):
    print('好好学习 %s'%name)
speak(a._name)
speak(b._name)
speak(a.name)
speak(b.name)
def run(x):
    x.run()
run(a)

speak()函数就是类的多态的表现，我们还可以直接使用类中的方法如:run()

属性和方法

• 类属性：定义在类中的，只能在类中被修改。类属性可以通过类和该类的实例进行访问

class A:
    #类属性，定义在类内的
    #类属性可以用类和该类的实例访问
    num = 0

a=A()
a.num = 10
print(a.num)
print(A.num)

• 实例属性：只能通过实例对象访问，无法通过类对象访问
• 类方法：可以通过类对象调用，也可以通过实例对象调用（通过@classmethod调用）
• 实例方法：通过实例对象进行调用，但不能用类对象调用（通过创建实例调用）
• 静态方法：静态方法 和这个类没有关系，不用指定参数，实例和类方法都可以调用（通过@staticmethod调用）

class A:
    #类属性，定义在类内的
    #类属性可以用类和该类的实例访问
    num = 0

a=A()
a.num = 10
print(a.num)
print(A.num)


class number():
    def __init__(self,num):
        self.num = num
    def text(self):
        print('text')
    @classmethod
    def text2(cls):
        print('text2')
    @staticmethod
    def text1():
        print('text1')

#实例属性只能通过实例对象访问，无法通过类对象访问
b=number(10)
print(b.num)
# print(number.num)   wrong!!

#实例方法
b.text()
#类方法
#可以通过类对象调用，也可以通过实例对象调用
b.text2()
number.text2()
#静态方法  和这个类没有关系，不用指定参数，实例和类方法都可以调用
b.text1()
number.text1()

方法的重写

super()方法可以使用父类的方法

一般我们可以用_base_方法查看继承了什么类

#super()获取父类的方法
class animal():
    def __init__(self,name):
        self.name=name
    def run(self):
        print('%s会跑'%self.name)
    def sleep(self):
        print('%s啊会睡觉'%self.name)
class dog(animal):
    def __init__(self, name):
        self.name = name

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

    def sleep(self):
        print('%s会睡觉' % self.name)
        super().sleep()
dog1=dog('狗')
dog1.sleep()

#查看继承了什么类
print(dog.__base__)