python中的类和对象-猿码集

1. python中的类和对象

面向对象编程是现代程序设计的一种重要编程模型。面向对象编程（Object Oriented Programming，OOP）是一种通过对象的方式，来实现对真实世界建模的程序设计方法。而在python中，类和对象就是面向对象的重要组成部分。

1.1 什么是类和对象

类就是一种在程序中定义对象属性和方法的结构。它是面向对象编程的基础，所有的对象都是基于类创建的。而对象则是类的一个实例，它包含了类的属性和方法。

在python中，创建一个类需要使用关键字“class”，语法如下所示：


class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

在类的内部，我们可以定义属性和方法，这些属性和方法可以在外部通过对象进行访问。以下是定义一个简单类的示例代码：


class Person:
    name = "张三"
    age = 18
    def say_hello(self):
        print("我叫{}，今年{}岁。".format(self.name, self.age))
p = Person()
p.say_hello()

在这个例子中，我们定义了一个名为Person的类，它有两个属性（name和age）和一个方法（say_hello）。在方法内部，我们使用了“self”关键字来表示该方法属于一个对象。最后，我们创建了一个名为p的Person对象，并调用了它的say_hello()方法。

1.2 类的继承

类的继承是一种重要的面向对象编程思想，它允许我们在现有类的基础上创建新类。被继承的类被称为父类（或基类），新创建的类称为子类（或派生类）。子类继承了父类的属性和方法，并可以在此基础上添加新的属性和方法。

在python中，我们可以使用“class 子类名(父类名)”的方式来创建一个继承自父类的子类。以下是一个简单的继承示例：


class Animal:
    def __init__(self, name):
        self.name = name
    def eat(self):
        print("{}正在吃东西...".format(self.name))
class Dog(Animal):
    def __init__(self, name):
        super().__init__(name)
    def bark(self):
        print("{}正在汪汪叫...".format(self.name))
d = Dog("旺财")
d.eat()
d.bark()

在这个例子中，我们定义了一个名为Animal的父类和一个名为Dog的子类。在子类中，我们通过super()函数调用了父类的构造函数，从而继承了父类的属性。然后，我们又添加了一个名为bark()的新方法。

2. 类的属性和方法

2.1 实例属性和类属性

在python中，类包含两种类型的属性：实例属性和类属性。实例属性是指属于对象的属性，而类属性则是指属于类的属性。

实例属性一般在__init__方法中定义，在创建对象时进行初始化。而类属性则是在类定义中直接定义的，所有的对象都共享这些属性。

以下是一个实例属性和类属性的例子：


class Student:
    name = "张三"  # 类属性
    def __init__(self, age):
        self.age = age  # 实例属性
s1 = Student(18)
s2 = Student(20)
print(s1.name, s1.age)  # 张三 18
print(s2.name, s2.age)  # 张三 20
Student.name = "李四"
s1.age = 19
print(s1.name, s1.age)  # 李四 19
print(s2.name, s2.age)  # 李四 20

在这个例子中，我们定义了一个名为Student的类，它拥有一个类属性（name）和一个实例属性（age）。我们创建了两个Student对象，并分别输出了它们的属性值。然后，我们修改了类属性和一个对象的实例属性，并再次输出它们的属性值。

2.2 实例方法和类方法

在类的定义中，我们可以定义两种类型的方法：实例方法和类方法。实例方法是指属于对象的方法，可以访问对象的属性。而类方法则是指属于类的方法，可以访问类的属性。

在python中，实例方法的第一个参数必须是self，表示该方法属于对象。而类方法则使用“@classmethod”装饰器来标识。以下是一个实例方法和类方法的例子：


class Person:
    name = "张三"
    def __init__(self, age):
        self.age = age
    def say_hello(self):
        print("我叫{}，今年{}岁。".format(self.name, self.age))
    @classmethod
    def set_name(cls, name):
        cls.name = name
p1 = Person(18)
p2 = Person(20)
p1.say_hello()  # 我叫张三，今年18岁。
p2.say_hello()  # 我叫张三，今年20岁。
Person.set_name("李四")
p1.say_hello()  # 我叫李四，今年18岁。
p2.say_hello()  # 我叫李四，今年20岁。

在这个例子中，我们定义了一个名为Person的类，它拥有一个类属性（name）和一个实例属性（age）。我们创建了两个Person对象，并分别调用了它们的say_hello()方法。然后，我们定义了一个类方法set_name()，用来修改类属性name。最后，我们调用了这个类方法，并再次调用两个对象的say_hello()方法。

2.3 静态方法

静态方法是指属于类的方法，与类和对象都没有关系，不需要访问类或对象的属性和方法。在python中，静态方法使用“@staticmethod”装饰器来标识。以下是一个静态方法的例子：


class Math:
    @staticmethod
    def add(x, y):
        return x + y
print(Math.add(1, 2))  # 3

在这个例子中，我们定义了一个名为Math的类，并创建了一个静态方法add()，用来计算两个数的和。我们使用类名来调用这个静态方法，并传入两个参数，最后输出结果为3。

3. 封装、继承和多态

3.1 封装

封装是指将对象的属性和方法隐蔽起来，不被外部直接访问。这样可以保护属性和方法不被意外修改，增加程序的健壮性。在python中，使用“__”双下划线来表示私有属性和方法。

以下是一个封装的例子：


class Car:
    def __init__(self, brand, model):
        self.__brand = brand
        self.__model = model
    def get_brand(self):
        return self.__brand
    def set_brand(self, brand):
        self.__brand = brand
    def get_model(self):
        return self.__model
    def set_model(self, model):
        self.__model = model
car = Car("奔驰", "S350")
print(car.get_brand(), car.get_model())  # 奔驰 S350
car.set_brand("宝马")
car.set_model("X5")
print(car.get_brand(), car.get_model())  # 宝马 X5

在这个例子中，我们定义了一个名为Car的类，并将属性brand和model私有化。通过定义get和set方法，可以在外部获取或修改这些属性。我们通过对象访问这些方法，并查看属性值的变化。

3.2 继承

继承是一种重要的面向对象编程思想，它允许我们在现有类的基础上创建新类。被继承的类被称为父类（或基类），新创建的类称为子类（或派生类）。子类继承了父类的属性和方法，并可以在此基础上添加新的属性和方法。

在python中，我们可以使用“class 子类名(父类名)”的方式来创建一个继承自父类的子类。

3.3 多态

多态是一种重要的面向对象编程思想，指的是同样的方法在不同的对象上产生不同的行为。在python中，多态通过方法重写（override）实现。

在方法重写中，子类定义了一个与父类同名的方法，并覆盖了父类的方法。当我们调用子类的该方法时，程序会优先调用子类的方法，从而产生不同的行为。

以下是一个多态的例子：


class Animal:
    def say_hello(self):
        print("动物在叫...")
class Dog(Animal):
    def say_hello(self):
        print("汪汪叫...")
class Cat(Animal):
    def say_hello(self):
        print("喵喵叫...")
a = Animal()
d = Dog()
c = Cat()
a.say_hello()  # 动物在叫...
d.say_hello()  # 汪汪叫...
c.say_hello()  # 喵喵叫...

在这个例子中，我们定义了一个名为Animal的父类和两个名为Dog和Cat的子类。在子类中，我们分别重写了父类的say_hello()方法。然后，我们创建了三个对象，并分别调用了它们的say_hello()方法，从而展示了多态的特性。

4. 总结

python是一种支持面向对象编程的高级编程语言。在python中，类和对象是面向对象编程的重要组成部分，类提供了属性和方法的定义，而对象则包含了实际的属性和方法。通过类的继承，我们可以在现有类的基础上创建新类，并继承了父类的属性和方法。另外，多态是一种重要的面向对象编程思想，采用方法重写的方式实现。以上内容是python中类和对象的基础知识，对于深入学习python及其他面向对象编程语言都有着很好的指导意义。

python中的类和对象