【python】什么是对象

@[toc] python对象

Object

在 Python 中，对象（Object） 是面向对象编程（OOP）的核心概念。对象是类的实例，类定义了对象的属性和行为。Python 中的一切都是对象，包括数字、字符串、列表、函数等。

对象的基本概念

• 类（Class）：

  • 类是对象的蓝图或模板，定义了对象的属性和方法。
  • 通过类可以创建多个对象。

• 对象（Object）：

  • 对象是类的实例，具有类定义的属性和方法。
  • 每个对象都有自己的状态（属性值）和行为（方法）。

• 属性（Attribute）：

  • 对象的变量，用于存储数据。

• 方法（Method）：

  • 对象的函数，用于定义对象的行为。

创建类和对象

# 定义一个类
class Dog:
    # 类的属性（类变量）
    species = "Canis familiaris"

    # 初始化方法（构造函数）
    def __init__(self, name, age):
        # 实例属性
        self.name = name
        self.age = age

    # 实例方法
    def bark(self):
        return f"{self.name} says woof!"

    def get_age(self):
        return f"{self.name} is {self.age} years old."


# 创建对象（类的实例）
dog1 = Dog("Buddy", 3)
dog2 = Dog("Milo", 5)

# 访问对象的属性和方法
print(dog1.name)  # 输出: Buddy
print(dog2.species)  # 输出: Canis familiaris
print(dog1.bark())  # 输出: Buddy says woof!
print(dog2.get_age())  # 输出: Milo is 5 years old.

对象的属性和方法
实例属性：

• 每个对象独有的属性，通过 self 在 init 方法中定义。
• 例如：self.name 和 self.age。

类属性：

• 所有对象共享的属性，直接在类中定义。
• 例如：species。

实例方法：

• 定义在类中的函数，第一个参数通常是 self，表示对象本身。
• 例如：bark() 和 get_age()。

对象的动态特性

Python 中的对象是动态的，可以在运行时添加或修改属性和方法。

# 添加新属性
dog1.color = "brown"
print(dog1.color)  # 输出: brown

# 修改属性
dog1.age = 4
print(dog1.get_age())  # 输出: Buddy is 4 years old.

# 添加新方法
def roll_over(self):
    return f"{self.name} is rolling over!"

# 动态绑定方法
dog1.roll_over = roll_over.__get__(dog1)
print(dog1.roll_over())  # 输出: Buddy is rolling over!

对象的特殊方法

Python 提供了许多特殊方法（以双下划线 __ 开头和结尾），用于定义对象的行为。例如：

__init__：构造函数，初始化对象。

__str__：定义对象的字符串表示。

__len__：定义对象的长度。

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

    def __str__(self):
        return f"Dog(name={self.name}, age={self.age})"

    def __len__(self):
        return self.age


dog = Dog("Buddy", 3)
print(dog)  # 输出: Dog(name=Buddy, age=3)
print(len(dog))  # 输出: 3

对象的继承

继承是面向对象编程的重要特性，允许一个类继承另一个类的属性和方法。

# 父类
class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        return f"{self.name} makes a sound."


# 子类
class Cat(Animal):
    def speak(self):
        return f"{self.name} says meow!"


# 创建子类对象
cat = Cat("Whiskers")
print(cat.speak())  # 输出: Whiskers says meow!

对象的封装

封装是将对象的属性和方法隐藏起来，只暴露必要的接口。Python 通过命名约定实现封装：

公有属性和方法：直接访问。

私有属性和方法：以双下划线 __ 开头，只能在类内部访问。

class BankAccount:
    def __init__(self, owner, balance):
        self.owner = owner
        self.__balance = balance  # 私有属性

    def deposit(self, amount):
        self.__balance += amount

    def get_balance(self):
        return self.__balance


account = BankAccount("Alice", 1000)
account.deposit(500)
print(account.get_balance())  # 输出: 1500
# print(account.__balance)  # 报错: AttributeError

对象的多态

多态是指不同类的对象可以对相同的方法做出不同的响应。

class Dog:
    def speak(self):
        return "Woof!"


class Cat:
    def speak(self):
        return "Meow!"


def animal_sound(animal):
    print(animal.speak())


dog = Dog()
cat = Cat()

animal_sound(dog)  # 输出: Woof!
animal_sound(cat)  # 输出: Meow!

总结

Python 中的对象是类的实例，具有属性和方法。

类是对象的模板，定义了对象的属性和行为。

对象是动态的，可以在运行时修改属性和方法。

继承、封装和多态是面向对象编程的三大特性。