美文网首页Python 之道
Python 3 学习笔记之——面向对象

Python 3 学习笔记之——面向对象

作者: seniusen | 来源:发表于2018-10-27 22:40 被阅读0次

    1. 类的介绍

    类(Class) 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例,类是对象的抽象。

    • 方法:类中定义的函数。
    • 类变量:类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
    • 方法变量:定义在方法中的变量。
    • 继承:即一个派生类(derived class)继承基类(base class)的属性和方法。
    • 方法重写:如果从父类继承的方法不能满足子类的需求,可以对其进行改写,这个过程叫方法的覆盖(override),也成为方法的重写。

    2. 类的定义

    语法格式如下:

    class ClassName:
        <statement-1>
        .
        .
        .
        <statement-N>
    
    • 类有一个名为 _init_() 的特殊方法,也即是构造函数,该方法会在定义对象的时候自动调用,可以通过参数传递来对类的实例进行设定。

    • 在类内部,使用 def 关键字来定义一个方法,与一般函数不同,类方法必须包含参数 self,并且作为第一个参数,self 代表类的实例,类似于 C++ 中的 this 指针。

    • 类的私有属性 __private_attrs 以两个下划线开头,在类内部的方法中使用时用 self.__private_attrs 调用,不能在类外部访问类的私有属性。

    • 类的私有方法 __private_method 以两个下划线开头,只能在类的内部调用,不能在类外部调用。

    class person:
        
        instances = 0                # 类变量,所有类公用
        
        def __init__(self, name, age, weight):
            self.name = name         # 公有属性
            self.age = age
            self.__weight = weight   # 私有属性,在类外无法直接访问
            
            person.instances += 1;   # 通过类来访问类变量
        
        def tell_a_secret(self):     # 私有方法
            print("Tell you a secret, my weight is {} kg.".format(self.__weight))
        
        def speak(self):             # 公有方法
            print('My name is {}, I\'m {} years old.'.format(self.name, self.age))
            self.tell_a_secret()
    
    
    people = person('seniusen', 21, 60)
    people.speak()
    print(people.instances)
    print(people.instances) # 通过实例也可以访问类变量
    
    # My name is seniusen, I'm 21 years old.
    # Tell you a secret, my weight is 60 kg.
    # 1
    # 1
    

    3. 类的单继承

    语法格式如下:

    class DerivedClassName(BaseClassName1):
        <statement-1>
        .
        .
        .
        <statement-N>
    
    • 注意圆括号中基类的顺序,若是基类中有相同的方法名,而在子类使用时未指定,则 Python 从左至右进行搜索。即方法在子类中未找到时,从左到右查找基类中是否包含该方法

    • 基类名 BaseClassName 必须与派生类定义在一个作用域,如果基类定义在另一个模块,这时候我们还可以用一个表达式来定义派生类,class DerivedClassName(modname.BaseClassName):

    class student(person):
            
        def __init__(self, name, age, weight, major):
            
            person.__init__(self, name, age, weight) # 调用父类的构造函数,此时必须给定 self 参数
            # super(student, self).__init__(name, age, weight) 或者利用 super() 函数
            self.major = major
    
        # 重写父类的方法
        def speak(self): # 公有方法
            person.speak(self)
            print('My major in college is {}.'.format(self.major))
    
    stu = student('seniusen', 21, 60, 'Automation')
    stu.speak()
    print(student.instances)
    print(stu.instances) # 通过实例也可以访问类变量
    
    # My name is seniusen, I'm 21 years old.
    # Tell you a secret, my weight is 60 kg.
    # My major in college is Automation.
    # 2
    # 2
    

    3. 类的多继承

    语法格式如下:

    class DerivedClassName(Base1, Base2, Base3):
        <statement-1>
        .
        .
        .
        <statement-N>
    
    class teacher:
          
        def __init__(self, title, topic):
            self.title = title 
            self.topic = topic
        
        def speak(self): # 公有方法
            print('I\'m a {} , my research topic is {}.'.format(self.title, self.topic))
    
    # 继承自 teacher 和 student 的子类
    class sample(teacher, student):
        
        def __init__(self, name, age, weight, major, title, topic):
            student.__init__(self, name, age, weight, major)
            teacher.__init__(self, title, topic)
    
    test = sample('seniusen', 21, 60, 'Automation', 'prefessor', 'CV')
    test.speak() # 没有指定方法,从左到右查找,这里调用了 teacher 类的 speak() 方法
    
    # I'm a prefessor , my research topic is CV.
    
    
    • 利用 super() 函数可以调用被子类重写的父类中的方法。
    class Parent:           # 定义父类
        
        def myMethod(self):
            print ('Method form Parent class!')
    
            
    class Child(Parent):    # 定义子类
        
        def myMethod(self):
            print ('Method form Child class!')
    
    a = Child()                # 子类实例
    a.myMethod()               # 子类调用重写方法
    super(Child, a).myMethod() #用子类对象调用父类已被覆盖的方法
    
    # Method form Child class!
    # Method form Parent class!
    
    

    参考资料 菜鸟教程

    获取更多精彩,请关注「seniusen」!


    相关文章

      网友评论

        本文标题:Python 3 学习笔记之——面向对象

        本文链接:https://www.haomeiwen.com/subject/bvqjtqtx.html