5.python面向对象

1.对象

对象 = 属性 + 行为

 

2.python与面向对象

（1）定义语法：类名与变量名区分大小写

class [类名]:
    [语法块]

（2）类使用

（3）类的构造方法：构造函数就是类的__init__方法

class Dog:
    def __init__(self):
        print("狗子")

dog = Dog()

（4）类的属性：属性必须要使用"self"加上点的方式赋值，不能直接定义变量，直接定义的变量的生命周期只会在函数内。

class Dog:
    def __init__(self,name):
        self.name = name
        self.age = 3
     

dog = Dog("狗子")

print(dog.name)
print(dog.age)

（5）类中的方法

class Dog:
    def __init__(self,name):
        self.name = name
       
    def play(self):
        print("我是",self.name)
     

dog = Dog("狗子")
dog.play()

（6）私有属性：外部不能修改这个属性

在定义属性名字的时候使用两条下划线作为开头

class Dog:
    def __init__(self,name):
        self.__name = name
        self.__age = None
        print(self.__name,"生成成功")

    def set_age(self,age):
        if not isinstance(age,int):
            print("必须输入数字")
            return False

        if age<=0:
            print("年龄必须大于0")
            return False

        self.__age = age

    def display(self):
        print("汪汪汪，我今年",self.__age)


dog = Dog("旺财")
dog.set_age("hello")
dog.set_age(-8)
dog.set_age(3)
dog.display()    

（7）私有方法：只能在类内部被调用，实例不能直接调用

class Dog:
    def __say(self,name):
        print(name)

    def play(self):
        self.__say("汪汪汪")

dog = Dog()
dog.play()

 

3.继承与多态

封装，继承，多态是面向对象的三大特征

注：python支持多继承

定义子类的语法：

class subClass(BaseClass1,BaseClass2):
    语法块

（1）继承

**如果子类定义了构造方法，那么父类的构造方法__init__就不会自动调用，需要子类在构造方法中专门调用

class Animal:
    def __init__(self,name):
        self.name = name

    def play(self):
        print("我是",self.name)

class Dog(Animal):
    def __init__(self):
        super(Dog,self).__init__("旺财")

dog=Dog()
dog.play()

**子类不能继承父类中的私有方法，也不能调用父类中的私有方法

class Animal:
    def __init__(self,name):
        self.name = name

    def __play(self):
        print("Animal，__play")

    def play(self):
        print("Animal，play")

class Dog(Animal):
    def __init__(self):
        super(Dog,self).__init__("旺财")

    def say(self):
        self.play()

dog=Dog()
dog.play()

 

（2）多态：多种形态。多态会根据类的不同表现出不同的行为。

判断一个实例是不是某个对象可以用isinstance函数

class Animal:
    def say(self):
        print("Animal")

class Dog(Animal):
    def say(self):
        print("Dog")

class Cat(Animal):
    def say(self):
        print("Cat")

dog = Dog()
cat = Cat()


print(isinstance(dog,Animal))
print(isinstance(cat,Animal))

 

（3）鸭子类型

不需要明确继承关系，根据文档变成，只要接口有，各个方法接口名参数一样，就可以直接实现继承的效果

class Dog():
    def say(self):
        print("Dog")

class Cat():
    def say(self):
        print("Cat")

def animal_say(animal):
    animal.say()

dog = Dog()
cat = Cat()

animal_say(dog)
animal_say(cat)

 

4.类变量和实例变量

类变量：在定义类的时候定义的变量。注意，实例不能修改类变量，如果修改，会新建一个同名的成员变量来代理实例中的类变量

class Animal:
    name = "动物"

dog = Animal()
cat = Animal()

print(dog.name)
print(cat.name)

Animal.name = "哺乳类动物"

print(dog.name)
print(cat.name)

 

5.静态方法与类方法

静态方法在定义类时就已经被分配定义好了，并不绑定类也不绑定实例，相当于给方法添加了一个前缀。

静态方法引入了装饰器的概念。

（1）定义静态方法

class Animal:
    name = "动物"

    @staticmethod
    def play():
        print("playing")

Animal.play()

 

（2）类方法

该方法绑定在定义的类上面，而不是绑定在实例上面

class Animal:
    name = "动物"

    @classmethod
    def play(cls):
        print(cls.name,"playing")

Animal.play()

 

类方法和静态方法不同的是，类方法和成员方法一样有一个初始参数，但是这个参数不同于成员方法。成员方法的第一个参数指向的是实例，而类方法指向的则是定义的类本身。所以类方法可以读取和修改类变量