python面向对象

类class关键字

class 类名:
    def 方法名(self,参数1，参数2，...):
        pass

class Cat:
    def eat(self):
        print("猫吃饭")
    def drink(self):
        print("猫喝水")

对象

实例：通过类创建出来的对象叫做类的实例

实例化：创建对象的动作叫做实例化

class Cat:
    def eat(self):
        print("猫吃饭")

    def drink(self):
        print("猫喝水")


c = Cat()  # 根据类创建对象c
c.eat()
c.drink()

self参数和属性

class Cat:
    def set_name(self):
        self.name = "tom"

    def eat(self):
        print("%s吃饭" % self.name)

    def drink(self):
        print("%s喝水" % self.name)


c = Cat()  # 根据类创建对象c
c.set_name()
c.eat()
c.drink()
c.name = "张三"
c.eat()
c.drink()

init方法

class Cat:
    def __init__(self):
        print("cat被创建了")


c = Cat()  # 实例化对象的时候，init方法会被自动调用

class Cat:
    def __init__(self,name="tom"):
        self.name = name

    def eat(self):
        print("%s吃饭" % self.name)

    def drink(self):
        print("%s喝水" % self.name)


c = Cat("jessica")  # 根据类创建对象c
c.eat()
c.drink()

为了避免实例化的时候必须提供实参，init的形参总是有缺省值

del方法

当对象在内存中销毁的时候，自动调用del方法

del方法只有一个参数self

不要理解成调用del是把对象从内存中删除了

对象即使没有del，同样会被销毁

当对象从内存中销毁的时候，有机会能执行一些代码

class Cat:
    def __init__(self, name="tom"):
        self.name = name

    def show_name(self):
        print(self.name)

    def __del__(self):
        print("%s销毁了" % self.name)


c = Cat()
c.show_name()

如果对象是局部的，那么函数执行完毕，自动调用del方法

如果对象是全局的，那么程序执行完毕，自动调用del方法

设计

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

    def get_name(self):
        return self.name

    def set_name(self, name):
        self.name = name

    def get_age(self):
        return self.age

    def set_age(self, age):
        self.age = age

    def show_name(self):
        print(self.name)

    def show_age(self):
        print(self.age)


d = Dog("汤姆", 18)    # 实例化的时候设置属性的值
d.show_name()    # 汤姆
d.set_name("加菲猫")    # 实例化以后设置属性的值
d.show_name()    # 加菲猫 

str方法

class demo:
    def __init__(self,name="demo"):
        self.name=name

    def __str__(self):
        return self.name
d=demo()
print(d)

继承

封装：将属性和方法封装到类内部，只能在内部使用，不能在类的外部使用

继承：实现代码的重用，相同的代码不需要重复编写

多态：不同对象调用父类相同的方法，产生不同的执行结果，增加灵活度

class Animal:
    def sleep(self):
        print("睡")

    def eat(self):
        print("吃")


class Dog(Animal):
    def run(self):
        print("跑")


d = Dog()
d.sleep()
d.eat()
d.run()

扩展父类方法（super()）

class Animal:
    def sleep(self):
        print("睡")

    def eat(self):
        print("吃")


class Dog(Animal):
    def run(self):
        print("跑")

    def eat(self):
        super().eat()
        print("吃肉")


d = Dog()
d.sleep()
d.eat()
d.run()

封装

把属性和方法前面加上两个下划线__，这个属性和方法就成为了类的内部属性和方法

多态

 

类属性（定义在类里面，方法外面）

class dog:
    name = "二哈"

    def __init__(self):
        pass


print(dog.name)
dog.name = "狼狗"
print(dog.name)

类方法

class dog:
    name = "二哈"

    @classmethod
    def set_name(cls, name):
        cls.name = name  # 通过类方法的形参修改类属性name值

    def __init__(self):
        self.age=20    #类方法无法访问普通属性age

    def demo(self):
        print("普通方法")# 类方法无法访问普通方法demo


print(dog.name)
dog.name="比熊"
print(dog.name)
dog.set_name("涛涛")
print(dog.name)

普通方法使用类属性和类方法

class dog:
    name = "小白"

    @classmethod
    def get_name(cls):
        return cls.name

    def demo(self):
        dog.name = "小小白"
        print(dog.get_name())


d = dog()
d.demo()

统计实例化的次数

class dog:
    index = 0;

    @classmethod
    def count(cls):
        return cls.index

    def __init__(self):
        dog.index += 1;


d1 = dog()
d2 = dog()
d3 = dog()
d4 = dog()
print(dog.count())    # 4

静态方法（跟类没有关系）

静态方法不能访问类中其他成员

class dog:
    @staticmethod
    def help():
        print("帮助")

dog.help()