Python-面向对象

面向对象

面向对象是一种编程思想, 即按照真实世界的思维方式构建软件系统.

定义类

class 类名[(父类)]:
    类体

创建对象

用类创建对象的过程称为实例化, 是将类这个抽象的概念具体到该类实物的过程.

class Car:  # class Car(object):
    pass    # 类体


car = Car()

类的成员

  • 实例变量 -- 对象个体特有的"数据".

  • 构造方法 -- __init__ 用来创建和初始化实例变量.

  • 实例方法 -- 某个实例或对象个体特有的方法.

  • 类变量 -- 变量属于类, 不属于单个对象.

  • 类方法 -- @classmethod 方法属于类, 不属于实例.

    class Dog:
        family = "犬科"  # 创建和初始化类变量family
    
        def __init__(self, name, age, sex='M'):  # 定义构造方法
            self.name = name  # 创建和初始化实例变量name
            self.age = age    # 创建和初始化实例变量age
            self.sex = sex    # 创建和初始化实例变量sex
    
        @classmethod  # 装饰器
        def show_family(cls):  # 定义类方法
            print(cls.family)
    
        def show_info(self):  # 定义实例方法
            print(self.name, self.age, self.sex)
    
        def bark(self, sound):
            print(self.name, "在叫:", sound, sep='')
    
    
    d = Dog("球球", 2)
    Dog.show_family()  # 犬科
    d.show_info()      # 球球 2 M
    d.bark("汪!")      # 球球在叫:汪!
    
特殊类属性 说明
__name__ 类的名字
__doc__ 类的文档字符串
__bases__ 类的所有父类构成的元组
__dict__ 类的属性
__module__ 类定义所在的模块
__class__ 实例对应的类
类专有方法 说明
__init__ 在生成对象时调用
__del__ 析构函数, 释放对象时使用
__repr__ 打印, 转换
__setitem__ 按照索引赋值
__getitem__ 按照索引获取值
__len__ 获得长度
__call__ 函数调用
__add__ 加运算
__sub__ 减运算
__mul__ 乘运算
__div__ 除运算
__mod__ 求余运算
__pow__ 乘方运算

面向对象的特性

封装性

  • 私有变量:

    防止外部调用者随意存取类的内部数据(成员变量), 内部数据会被封装为"私有变量".

  • 私有方法:

    不可以在类的外部访问私有方法.

  • 属性:

    为了实现对象的封装, 在一个类中成员变量应该被设计为私有的, 然后通过公有方法访问.

    class Account:
        __interest_rate = 0.0568  # 私有类变量
    
        def __init__(self, owner, amount):
            self.owner = owner      # 公有实例变量
            self.__amount = amount  # 私有实例变量
    
        @property
        def amount(self):  # 定义amount属性的get()方法. 方法名就是属性名, 即amount.
            return self.__amount
    
        @amount.setter
        def amount(self, amount):  # 定义set()方法, 使用@属性.setter修饰器进行修饰.
            self.__amount = amount
    
        def __get_info(self):  # 私有实例方法
            print("{0} 金额: {1} 利率: {2}. ".format(self.owner,
                                                 self.__amount,
                                                 Account.__interest_rate))
    
        def desc(self):  # 公有实例方法
            self.__get_info()
    
    
    account = Account("Tony", 800.0)
    print(account.amount)  # 800.0
    account.desc()         # Tony 金额: 800.0 利率: 0.0568.
    account.amount = 500.0
    account.desc()         # Tony 金额: 500.0 利率: 0.0568. 
    

继承性

  1. 子类继承父类: 特殊类拥有一般类的全部数据和操作.

    class Animal:
        def __init__(self, name):
            self.name = name  # 实例变量
            print("Animal_1")
    
        def show_info(self):
            print(self.name)
    
    
    class Cat(Animal):
        def __init__(self, name, age):
            super(Cat, self).__init__(name)  # 首先找到父类, 然后把父类的对象转换为子类的对象.
            self.age = age
            print("Cat_1")
    
        def show_info(self):
            super(Cat, self).show_info()
            print(self.age)
            # print(self.name, self.age) 方法重写
    
    cat = Cat("Tom", 2)
    cat.show_info()
    animal = Animal("John")
    animal.show_info()
    
    # Animal_1
    # Cat_1
    # Tom
    # 2
    # Animal_1
    # John
    
  2. 多继承

    class Horse:
        def __init__(self, name):
            self.name = name
            
        def show_info(self):
            print(self.name)
            
        def run(self):
            print("马跑...")
    
    
    class Donkey:
        def __init__(self, name):
            self.name = name
    
        def show_info(self):
            print(self.name)
    
        def run(self):
            print("驴跑...")
            
        def roll(self):
            print("驴打滚...")
    
    
    class Mule(Horse, Donkey):
        def __init__(self, name):
            super(Mule, self).__init__(name)
    
    
    m = Mule("骡宝莉")
    m.show_info()  # 继承Horse的方法
    m.run()        # 继承Horse的方法
    m.roll()       # 继承Donkey的方法
    

多态性

多态性指对象可以表现出多种形态.

  1. 在多个子类继承父类, 并重写父类方法后, 这些子类所创建的对象之间就是多态的.

  2. Python 支持鸭子类型测试[1], Python解释器不检查发生多态的对象是否继承了同一个父类, 只要它们有相同的方法, 它们之间就是多态的.

    class Animal:
        def speak(self):
            print("某种叫声")
    
    
    class Cat(Animal):
        def speak(self):
            print("猫叫")
    
    
    class Dog(Animal):
        def speak(self):
            print("狗叫")
    
    
    class Car:
        def speak(self):
            print("鸣笛")
    
    
    def start(obj):
        obj.speak()  # obj对象指向访问的属性名或方法
    
    
    an1 = Cat()
    an2 = Dog()
    car = Car()
    start(an1)
    start(an2)
    start(car)
    

  1. 一个东西如果它看起来像鸭子, 走起来像鸭子, 叫起来也像鸭子, 那么它就是鸭子. ↩︎

posted @ 2022-08-18 22:24  Khru  阅读(52)  评论(0)    收藏  举报