Python面向对象基础详解指南

18 面向对象基础

18.1 类与对象

18.1.1 类与对象实例的关系

  • 9. 类 — Python 3.12.7 文档

  • 示意图1:

  • 示意图2:

  • 类是抽象的,概念的,代表一类事物,即它是数据类型;

  • 对象是具体的,实际的,代表一个具体事物,即是实例;

  • 类是对象的模板,对象是类的一个个体,对应一个实例。

  • 18.1.2 OOP快速入门

  • 例:

    # 定义 Cat 类
    class Cat:
        age = None
        name = None
        color = None
    
    # 通过 Cat 类,创建实例
    cat1 = Cat()
    
    # 通过对象名.属性名,可以给各个属性赋值
    cat1.name = "芋泥"
    cat1.age = 1
    cat1.color = "白色"
    
    print(f"小猫名字:{cat1.name},小猫年龄:{cat1.age},小猫颜色:{cat1.color}")
    
  • 18.1.3 属性/成员变量

  • 类中定义的属性(变量),也称为成员变量;
  • 属性是类的一个组成部分,可以是任意数据类型;
  • 属性的定义语法同变量,示例:属性名 = 值,如果没有值,可以赋值None
  • 内置常量 — Python 3.12.7 文档;
  • 如果指定的属性有值,那么创建的对象,其对应的属性就有值。
  • 18.1.4 类的定义和使用

  • 定义语法:

    class 类名:
    	属性(成员变量)
    	行为(成员方法)
    
  • 创建对象:

    对象名 = 类名()
    
  • 访问属性:

    对象名.属性名
    
  • 18.2 对象的布尔值

  • 所有对象都有一个布尔值,通过内置函数bool()可以获取对象的布尔值;
  • 下面对象的布尔值为False
  • False
  • 数值0
  • None
  • 空字符串
  • 空列表
  • 空字典
  • 空元组
  • 空集合
  • 18.3 成员方法

  • 成员方法就是类的行为;

  • 语法:

    def 方法名(self, 形参列表):
    	方法体
    
  • 在方法定义的参数列表中,有一个self
  • self是定义成员方法时,需要写上的;
  • self表示当前对象本身;
  • 当我们通过对象调用方法时,self会隐式的传入;
  • 在方法内部,需要使用self,才能访问到成员变量;
  • 例:

    class Person:
        name = None
        age = None
    
        def hi(self):
            print("Hi, Python")
    
        def call01(self):
            i = 1
            sum = 0
            while(i <= 1000):
                sum = sum + i
                i += 1
            print(sum)
    
        def call02(self, n):
            i = 1
            sum = 0
            while(i <= n):
                sum = sum + i
                i += 1
            print(sum)
    
        def get_sum(self, x, y):
            print(x + y)
    
    person = Person()
    person.hi()
    person.call01()
    person.call02(100)
    person.get_sum(1, 2)
    
  • 注意事项和使用细节:

  • Python也允许对象动态地给自己添加方法(该方法只有本对象所有,其它同类的实例对象没有);

    class Person:
        name = None
        age = None
    
    # 定义一个函数
    def hi():
        print("hi")
        
    person = Person()
    
    # 给某个实例对象动态地添加函数
    person.f1 = hi
    person.f1()
    
  • 18.4 self

  • 在方法内部,需要使用self,才能访问到成员变量和成员方法;

    class Cat:
        name = "波斯猫"
        age = 2
    
        def info(self, name):
            print(f"小猫的名字是:{self.name}") # 方法内调用成员变量
    
        def msg(self, name):
            print(f"{name}")
    
        def miao(self):
            self.msg("狸花猫") # 方法内调用成员方法
            print("它在miao~miao~叫")
    
    cat = Cat()
    cat.info("加菲猫")
    cat.miao()
    
    # 小猫的名字是:波斯猫
    # 狸花猫
    # 它在miao~miao~叫
    
  • self是定义成员方法时,需要写上的,如果不写,则需要使用@staticmethod标注,否则会报错;

  • @staticmethod,可以将一个方法转为静态方法;
  • 如果是一个静态方法,可以不适用self
  • 静态方法的调用方式有两种,一种仍是对象.方法,一种是类.方法
  • class Cat:
        name = "波斯猫"
        age = 2
    
        @staticmethod
        def info(name):
            print(f"小猫的名字是:{name}")
    
    cat = Cat()
    # 调用方式1
    cat.info("加菲猫")
    # 调用方式2
    Cat.info("加菲猫")
    
  • self表示当前对象本身。简单的说,哪个对象调用当前函数,self就代表哪个对象;

  • 当通过对象去调用方法时,self会隐式地传入,就是成员方法中的self就是调用这个成员方法的对象本身。

  • 18.5 构造方法

  • 语法:写在类里面

    def __init__(self, 参数列表)
    	代码块
    
  • 在初始化对象的时候,会自动执行该方法;
  • 例:

    class Cat:
        name = None
        age = None
    
        def __init__(self, name, age):
            print(f"构造方法执行了,{name},{age}")
    
    cat1 = Cat("波斯猫", 2)
    cat2 = Cat("加菲猫", 3)
    
  • 注意事项和使用细节:

  • 一个类只有一个__init__方法,即使写了多个,也只有最后一个会生效;

  • Python 可以动态地生成对象属性;

    class Cat:
        def __init__(self, name, age):
            print(f"构造方法执行了,{name},{age}")
            self.name = name
            self.age = age
    
    cat1 = Cat("波斯猫", 2)
    cat2 = Cat("加菲猫", 3)
    
    print(cat1.name, cat1.age)
    print(cat2.name, cat2.age)
    
    # 构造方法执行了,波斯猫,2
    # 构造方法执行了,加菲猫,3
    # 波斯猫 2
    # 加菲猫 3
    
  • 构造方法不能有返回值。

  • 作者:木木慕慕

    物联沃分享整理
    物联沃-IOTWORD物联网 » Python面向对象基础详解指南

    发表回复