Python 初识面向对象

Python 初识面向对象

【一】面向过程和面向对象

【1】面向过程（函数）

• 核心在于：过程
• 过程的就是将程序流程化，将程序看作一系列的过程或者函数的调用
• 程序的执行流程主要由一系列的函数调用和数据处理过程组成
• 数据和函数是分离的，数据由函数操作

【2】面向对象（类）

• 核心在于：对象
• 对象就是将程序整合，整合程序中的数据和功能
• 对象就是**“容器”，用来盛放数据和功能**
• 将程序看作一组对象的集合，每个对象都有自己的状态和行为。
• 对象和对象之间通过消息传递进行通信

【二】对象和类

• 对象：

  • 对象就是现实生活中的实体或者概念，可以是具体的物体（苹果、香蕉），可以是抽象的概念（时间、空间）
  • 对象具有状态（可以描述对象的特征）、行为（可以执行的操作）和标识（区分一个对象和其他对象的唯一标识）

• 类：

  • 类是对一组具有相似特征和行为的对象的抽象
  • 它是对象的模板或者蓝图，定义了类该有哪些属性和行为
  • 类是一种用户自定义的数据类型，它包括了数据和方法

• 举例：

  • 苹果，香蕉：就是对象，他们有自己的状态（颜色、名字）、状态（可以吃）和标识（苹果就是苹果，香蕉就是香蕉）
  • 水果：就是将苹果和香蕉的相似特征和行为进行抽象，定义了该有的属性（名字、颜色）和行为（可食用性）

【三】类的定义

【1】定义类

• 类是对象相似的数据和功能的集合体，所以类中常见的是变量和函数的定义，但类内部也可以包含其他代码。
• 定义类名：采用驼峰体命名，例如（ShoppingCar、Student）
• 功能方法的定义：通常包含一个self（self是实例对象）
• 类里面的成员分为两类：属性和方法（函数）

# 定义类，类名采用驼峰体命名，例如（ShoppingCar、Student）
# 定义植物类
class Plant:
    # 定义变量的共同属性，没有特殊的要求
    # 定义植物的主人是戴夫
    plant_owner = "戴夫"

    # 功能方法的定义，通常要有一个self（self是实例对象）
    # 定义初始化方法
    def set_info(self, name, health):
        self["name"] = name
        self["health"] = health

    # 定义打招呼方法
    def introduce(self):
        print(f"""
        我是{self['name']}
        我的生命值为{self['health']}，
        我的主人是{self['plant_owner']}
        """)

• 注意：在定义阶段类中的代码就会立即执行

class A:
    print("定义时")

# 输出
# 定义时

【2】类成员的访问

• 方式一：类的__dict__内置方法，返回一个字典包含类的所有类成员
• 可以像字典的方式访问键所对应的值

print(Plant.__dict__)
# {'__module__': '__main__', 'plant_owner': '戴夫', 'set_info': <function Plant.set_info at 0x00000277B4103910>, 'introduce': <function Plant.introduce at 0x00000277B43E9CF0>, '__dict__': <attribute '__dict__' of 'Plant' objects>, '__weakref__': <attribute '__weakref__' of 'Plant' objects>, '__doc__': None}
print(Plant.__dict__["plant_owner"])
# 戴夫
print(Plant.__dict__["set_info"])
# <function Plant.set_info at 0x00000277B4103910>
print(Plant.__dict__["introduce"])
# <function Plant.introduce at 0x00000277B43E9CF0>

• 方式二：类名.属性（方法）
• 很方便，常用

# 类名.属性
print(Plant.plant_owner)
# 戴夫

# 类名.方法
print(Plant.set_info)
# <function Plant.set_info at 0x00000277B4103910>
print(Plant.introduce)
# # <function Plant.introduce at 0x00000277B43E9CF0>

【3】类成员的添加

• 添加属性

Plant.enemy = "僵尸"
print(Plant.__dict__)
# 添加了一个键值对（'enemy': '僵尸'）
print(Plant.enemy)
# 僵尸

• 添加方法

def add_func(self):
    print("我是随便添加的方法")

Plant.add_func = add_func
print(Plant.add_func)
# <function add_func at 0x0000022592C73E20>
Plant.add_func(Plant)
# 我是随便添加的方法

【四】实例化对象和实例（对象）属性

【0】补充

• 类属性（类里面的属性）和实例属性（实例方法里面的属性），统称属性

【1】文字说明

• 实例化对象
  • 类名加括号就可以调用类，调用类的目的是创建对象。
  • 对象的创建又称为实例化对象，即实例出一个对象
  • 和函数一样，需要先定义才能调用
• 实例属性
  • 使用内置方法__dict__只能访问实例属性，类属性无法访问
  • 使用**实例.属性可以访问所有属性和方法**

【2】代码讲解

# 实例化一个向日葵植物
sunflower = Plant()

# 查看实例化对象的实例属性，应该为空
print(sunflower.__dict__)
# {}                           # 确实为空

# 可以添加实例属性
sunflower.__dict__["func"] = "生产阳光"
# 再次查看实例属性
print(sunflower.__dict__)
# {'func': '生产阳光'}           # 添加成功

# 使用.方法，查看类属性
print(sunflower.plant_owner)
# 戴夫

【3】构造方法（初始化方法）__init__（魔法方法）

• 类实例化的时候自动帮我们添加对象的属性

（1）代码

# 定义植物类
class Plant:
    # 定义植物的主人是戴夫
    plant_owner = "戴夫"

    # 定义初始化方法
    def __init__(self, name, health, attack_value):
        self.name = name
        self.health = health
        self.attack_value = attack_value


# 实例化对象， self不用传参
sunflower = Plant(name="向日葵", health=100, attack_value=0)
pee_shooter = Plant(name="豌豆射手", health=80, attack_value=10)
# # 实例化对象等效方法
# Plant.__init__(self=sunflower, name="向日葵", health=100, attack_value=0)
# Plant.__init__(self=pee_shooter, name="豌豆射手", health=80, attack_value=10)


# 查看实例对象实例属性
print(sunflower.__dict__)
# {'name': '向日葵', 'health': 100, 'attack_value': 0}
print(pee_shooter.__dict__)
# {'name': '豌豆射手', 'health': 80, 'attack_value': 10}

（2）实例化（调用类的过程）说明

• 首先会产生一个空对象，并分配内存空间
• 然后自动调用实例化方法__init__，将空对象以及调用类时括号内的参数一同传递给__init__方法
• 最后返回初始完成后的对象，即实例化后的对象
• 注意：__init__方法必须返回None，默认不写return

【4】实例（对象）属性的查找顺序

• 通过内置方法__dict__可以查找到对象的实例属性
• 同过.方法可以查找到所有属性
• 那么类属性和实例属性都有相同的内容时，会先找那个呢？

class Plant:
    plant_owner = "戴夫"

    def __init__(self, name, health, attack_value):
        self.name = name
        self.health = health
        self.attack_value = attack_value

sunflower = Plant(name="向日葵", health=100, attack_value=0)
pee_shooter = Plant(name="豌豆射手", health=80, attack_value=10)

# 查看类属性plant_owner
print(id(Plant.plant_owner))
print(id(sunflower.plant_owner))
print(id(pee_shooter.plant_owner))
# 2317596043440             # 输出地址都相同，那么就是同一个东西
# 2317596043440
# 2317596043440

# 给对象sunflower添加同名的实例属性
sunflower.plant_owner = "僵尸王"
print(id(Plant.plant_owner))
print(id(sunflower.plant_owner))
print(id(pee_shooter.plant_owner))
# 2317596043440
# 2852031322448             # 添加的同名属性地址和其他的不同
# 2317596043440

• 总结：如果对象有这个属性，那么就访问对象自己的属性，如果对象没有这个属性，那就会去类中寻找类属性，如果类中都没有的话，他会继续从父类中查找，父类都找不到，那就会报错了
• 补充：还可以发现，通过实例修改类属性是完成不了的，实际上是创建了一个同名的实例属性，而不是修改类属性，通常使用类名来修改类属性