Python面相对象的编程

文章目录

1.基本概念
2.常用方法及代码实现

1.基本概念

Python的面向对象编程（Object-Oriented Programming，简称OOP）是一种编程范式，它使用“对象”来设计应用程序和计算机程序。这些对象由数据和能够操作这些数据的方法组成。面向对象编程的主要目标是提高软件的可重用性、可维护性和灵活性。在Python中，面向对象编程具有以下几个核心概念：

类（Class）：

类是创建对象的模板或蓝图。它定义了一组属性（称为字段或变量），以及操作这些数据的方法。一个类可以包括基本的数据属性（静态的信息片段），以及能够对数据执行特定功能的方法。

对象（Object）：

对象是类的实例。如果类是蓝图，对象就是根据这个蓝图构建的房子。每个对象都拥有类定义的字段和方法的具体实例。即便两个对象来自同一个类，它们也可以拥有不同的数据属性。

封装（Encapsulation）：

封装是面向对象编程的一个主要特点，指的是将对象的数据（属性）和代码（方法）捆绑在一起，形成一个独立的单元。在封装的概念中，类通常会防止外部代码直接访问内部数据结构，而是通过方法（称为getter和setter）来操作数据，这提供了更好的数据控制和更容易的维护。

继承（Inheritance）：

继承允许一个类（称为子类或派生类）继承另一个类（称为父类或基类）的属性和方法。子类重用父类的代码可以减少冗余，而且子类可以扩展或修改从父类继承的行为，这提高了代码的可用性和可扩展性。

多态（Polymorphism）：

多态是指同一个接口支持不同的底层形态（数据类型）。在Python中，多态表现为可以通过相同的接口调用不同类的方法，具体调用哪个方法取决于调用方法的对象。比如，不同的类可能都定义了一个相同的方法名，但是每个类的该方法的具体实现可能不同。

抽象（Abstraction）：

抽象是简化复杂的现实问题的方法，它通常用于隐藏复杂度，只显示最相关的细节。在Python中，可以使用抽象类来定义不能直接实例化的类，这些抽象类意在专门为其他类提供基本的、通用的功能模板，具体实现则留给继承了抽象类的子类。

通过使用这些OOP原则，Python程序员能够创建可读性强、易于扩展和维护的应用程序。

2.常用方法及代码实现

类和对象

#面相对象

#定义一个Foo类，包含两个方法

class Foo:

        def bar(self):# bar是Foo类的一个方法，不接受除 self（指向类实例本身的引用）之外的任何参数。当Bar方法调用时它会打印字符串"Cheney"

            print("shichengfu")

        def Hello(self,name):# Hello是Foo类的另一个方法，接受一个参数name以及隐式的self参数。该方法打印一句格式化字符串，其中包含传入的name参数

            print("我的名字是：{}".format(name))  

obj = Foo()

obj.bar()

obj.Hello('Shichengfu')

封装
下面的代码定义了一个名为 Foo 的类，并且在这个类中封装了两个属性：name 和 age。封装是面向对象编程的一大特性，它主要用于将数据（属性）和与数据相关的方法绑定在一起，形成一个独立的实体（对象），这样的封装可以提高代码的复用性和安全性。

#封装

#定义一个Foo类

class Foo:

    def __init__(self,name,age):

        self.name = name

        self.age = age

Figer1 = Foo("Shichengfu",18)

Figer2 = Foo("Chujiahui",19)

print("Figer1的name为%s"%Figer1.name)

print("Figer2的age为%d"%Figer2.age)

调用封装的内容

# 封装

class Fool:

    def __init__(self,name,age):    #初 始化对象属性

        self.name = name

        self.age = age

    def detial(self):   #定义一个detial方法

        print(self.name)

        print(self.age)

obj = Fool("Shichengfu",18)     # 实例化一个对象

obj.detial()    # 调用detial方法

继承
继承是面向对象三大特性之一（另外两个是封装和多态）。继承允许一个类（称为子类）继承另一个类（称为父类或基类）的属性和方法。这样做的主要好处是代码重用，可以将通用的代码放在一个父类中，通过继承机制在多个子类中复用这些代码。

# 继承

class Animal:  #定义一个父类

    def eat(self):

        print("%s 吃"%self.name)

    def drink(self):

        print("%s 喝"%self.name)

    def sleep(self):

        print("%s 睡"%self.name)  

#定义一个子类

class Dog(Animal):

    def __init__(self,name):

        self.name = name

        self.breed = "王怿铭"

    def cry(self):

        print("汪汪汪")

dog = Dog("王怿铭")

dog.eat()

dog.drink()

dog.cry()

类的继承机制
在Python中，类的继承机制允许多重继承，这意味着一个类可以同时继承多个父类。这与Java和C#等其他面向对象的编程语言不同，后者仅支持单一继承，但可以通过接口来实现多继承的某些效果。在Python中，多继承引入了寻找方法和属性的顺序问题，即当一个类继承自多个父类时，Python2.X需要一个明确的规则来决定从哪个父类中寻找方法或属性，这就涉及到深度优先和广度优先的搜索策略。

在Python 2中，有经典类和新式类之分。Python 3中，所有类默认都是新式类（即使不显式继承自 object）。‘即使不显式’通常用于描述某些操作或行为在没有明确指定的情况下依然会发生的情况，这种说法帮助简化代码和提高编程效率，但同时它也要求开发者理解默认行为，以避免意外的错误。

在Python 3中，类的继承和方法解析遵循C3线性化算法。C3线性化是一种特定的算法，用于解决在具有多重继承的类体系中确定方法解析顺序的问题。这个算法确保任何类都会在其父类之前被检查，同时也保持了父类的顺序。这意味着，Python 3中不再单纯使用传统的深度优先或广度优先策略来解析方法调用。

多态
多态是面向对象编程（OOP）中的一个核心概念，它允许在不同类的对象上以共同的方式调用相同的方法，而具体执行什么方法则取决于调用方法的对象的实际数据类型。这使得编程更加灵活，并增强了代码的可扩展性和可维护性。多态字面意思是“多种形态”，在编程中，它允许使用者以统一的接口处理不同类型的对象。

在下面的例子中，Animal 类定义了一个 speak 方法，Dog 和 Cat 类继承自 Animal 并重写了 speak 方法。函数 animal_sound 接受一个 Animal 类型的对象，并调用它的 speak 方法。当传递 Dog 和 Cat 对象时，尽管 animal_sound 函数的参数类型是 Animal，它依然调用了实际类型对应的方法。

class Animal:

    def speak(self):

        print("Some sound")  

class Dog(Animal):

    def speak(self):

        print("Woof woof")  

class Cat(Animal):

    def speak(self):

        print("Meow meow")  

def animal_sound(animal):

    animal.speak()  # 调用传入对象的speak方法  

# 创建Dog和Cat的实例对象

dog = Dog()

cat = Cat()  

# 传递不同的对象

animal_sound(dog)  # 输出: Woof woof

animal_sound(cat)  # 输出: Meow meow

多态是实现开闭原则的关键部分，即软件实体（类、模块、函数等）应该对扩展开放，对修改封闭。这使得在不更改现有代码的情况下，用户可以添加新功能，使系统易于扩展和维护。