Python面向对象详解(非常详细)

非常详细的讲解(爆肝1w字)

零基础一样学得会  

干货满满不看后悔

个人主页→数据挖掘博主ZTLJQ的主页

个人推荐python学习系列:

☄️爬虫JS逆向系列专栏 - 爬虫逆向教学

☄️python系列专栏 - 从零开始学python


目录

面向对象的概念和原理

1、什么是面向对象编程?

2、面向对象的特征和优点

3、类与对象的关系和定义

类与对象的关系

类和对象的定义

4、封装、继承和多态的概念和应用

Python中的面向对象编程基础

 1、创建类和对象

 2、初始化方法和实例属性

 3、类方法和静态方法的应用

一、类方法

二、静态方法

三、类方法和静态方法的应用

4、继承和子类化

5、多重继承


面向对象的概念和原理

1、什么是面向对象编程?

面向对象编程(Object-Oriented Programming,OOP)是一种常用的编程思想,它强调万物皆对象,因此在编程时我们可以将现实世界中的事物抽象成程序中的对象,从而更好实现软件的设计与开发。与传统的基于函数的编程不同,面向对象编程注重于将数据与行为封装在一起,即对象既包含数据状态,还包含可调用的行为方法。

 

面向对象编程的特点在于,它具有封装、继承和多态三大特性。封装意味着将对象的状态和行为进行封装,使其对外只暴露必要的接口,从而提高了安全性和可维护性;继承指的是某个对象可以继承另一个对象的特性,从而快速构建具有相似属性的对象;多态是指同一种行为在不同的对象上具有不同的表现形式,即在不同的情境下,同一个方法可以被不同的对象进行调用。

 

总之,面向对象编程是一种强大的编程方式,它具有高度封装性、灵活的继承性和强大的多态性,通过使用对象作为程序的基本处理单元,实现了数据和行为的有机结合,可以使程序更加高效、结构清晰,并方便管理和扩展。

2、面向对象的特征和优点

首先要讲的是封装,封装是OOP中最基本的特征之一,它将数据和方法封装在一个单独的单元中。对于实现封装,可以使用类来描述一个对象,类包括数据成员和成员函数。在类的定义中,可以使用关键字public、protected和private来指定成员访问权限,以保护数据的安全性。

 

代码示例:

class Student:
    def __init__(self, name, age):
        # 公共成员变量
        self.name = name
        # 私有成员变量
        self.__age = age

    def info(self):
        print('姓名:' + self.name)
        print('年龄:' + str(self.__age))

# Student类包括了两个成员变量(name和age)和一个成员函数(info())。
# 其中,name是公共成员变量,可以被外部访问;而age被定义成私有成员变量,只能在类内部访问。
# 通过封装,可以保证数据不被外部随意修改,保证代码的安全性。

其次要讲的就是封装,继承可以让子类继承父类的属性和方法,并且在基础上进行扩展。继承是代码复用的一种重要方式,它可以减少代码冗余,增加程序的可维护性。

 

代码示例:

class Animal:
    def __init__(self, name):
        # 私有成员变量
        self.__name = name

    def eat(self):
        print(self.__name + '开始偷吃零食')


class Cat(Animal):
    def __init__(self, name):
        # 调用父类的构造函数
        super().__init__(name)

    def run(self):
        print(self._name + '开始逃跑')


# Animal类是一个基类,Cat类继承了Animal类的属性和方法,并且增加了一个新的方法scratch()。
# 通过继承,在Cat类中可以调用Animal类的成员函数eat()。

最后要讲的就是,多态指的是同一个行为在不同情况下有不同的表现形式。在OOP中,多态是一种通过继承、重写和接口实现的机制,它可以让不同类的对象对同一消息做出不同的响应。

 

代码示例:

class Animal:
    def __init__(self, name):
        # 私有成员变量
        self.__name = name

    def make_sound(self):
        # 抽象方法
        pass


class Cat(Animal):
    def __init__(self, name):
        # 调用父类的构造函数
        super().__init__(name)

    def make_sound(self):
        print(self.__name + '猫叫')


class Dog(Animal):
    def __init__(self, name):
        # 调用父类的构造函数
        super().__init__(name)

    def make_sound(self):
        print(self.__name + '狗叫')


# Animal类包含一个抽象方法make_sound(),它在子类中被重写,实现了多态。
# Cat类和Dog类都是Animal类的子类,它们重写了make_sound()方法
# 使得同一个行为(make_sound())在不同情况下有不同的表现形式。

3、类与对象的关系和定义

类与对象的关系我们可以用一个案例类比,假设你要买一张飞机票,并且你需要填写一份订票表格。这份订票表格就相当于一个类,它有一些属性(如你的姓名、航班编号、起点和终点等信息),而你填写的表格就是对象。在填写表格时,你需要根据表格的属性来输入相关信息,就像在使用类时需要调用类的属性和方法一样。

类与对象的关系

类是一个模板,对象是根据这个模板创建的具体实例。如果将类比喻为蛋糕模具,那么对象就是蛋糕。一个类可以创建多个对象,它们之间是独立的,互相不影响。

类和对象的定义

类是一种用户自定义的数据类型,它由数据和方法组成。数据表示属性,方法表示行为。一个类可以包含多个属性和方法。属性是类的成员变量,可以存储数据。方法是一组操作数据的代码,它们可以实现某些功能或者改变属性的值。

给大家展示一个通用的格式:

class 类名:
    类属性 = 值
    def __init__(self, 参数):
        self.属性1 = 参数1
        self.属性2 = 参数2
    def 方法1(self, 参数):
        # 方法代码
    def 方法2(self, 参数):
        # 方法代码
  • class是声明类的关键字。
  • __init__是类的构造方法,当创建类的对象时,会自动调用这个方法。self表示对象本身,其他参数就是对象的属性。
  • 属性是类的成员变量,可以在类内部和外部使用。可以在类外使用类名访问类属性,如:类名.类属性
  • 方法是类的成员函数,接受的第一个参数是self,表示对象本身。在类内使用方法时,不需要传递这个参数。外部访问方法时,需要在对象后面加上方法名,如:对象.方法名()

举一个简单的例子 :

class Dog:
    # 类属性
    species = '犬科'
    
    # 构造方法
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    # 方法
    def bark(self):
        print("汪汪汪")
        
# 创建对象
dog1 = Dog('大黄', 2)
dog2 = Dog('二黄', 1)

# 访问属性
print(dog1.name)
print(dog2.age)

# 调用方法
dog1.bark()

4、封装、继承和多态的概念和应用

首先介绍封装的概念,封装是指将数据和行为打包到一个类中,并可以控制外部访问的级别。封装可以保护数据和方法的访问,并且提高代码的可维护性。我们可以利用访问控制修饰符来实现封装,包括公有、私有、受保护和包访问等四种级别。

简单的来说其实就是, 封装就是不让人靠近自己的东西,保护自己的隐私

 

代码示例:

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

  def get_name(self):
    return self.name

  def get_age(self):
    return self.age

  def set_name(self, name):
    self.name = name

  def set_age(self, age):
    self.age = age

person = Person("ZT", 20)
person.set_name("Tim")
print(person.get_name()) # 输出 Tim

接下来就是继承,继承是指一个类可以从父类中继承方法和属性。如果父类的某个属性或方法也在子类中定义了,那么子类会重写父类的属性或方法,这样子类可以更好地针对自己的特定要求来实现相应的功能。有人说继承可以使代码更加简洁,但是过度的继承反而会使代码变得非常复杂。---- 继承其实就像是血缘关系,你可以从你的祖先那里继承一些好的特点,但也不能完全成为他们。

 

代码示例:

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

    def eat(self):
        print(self.name + '在吃东西')

class Dog(Animal):
    def __init__(self, name):
        super().__init__(name)

    def bark(self):
        print(self.name + '在汪汪叫')

dog = Dog('小狗')
dog.eat()
dog.bark()

多态是指对象可以用多种形态来引用。这样做可以使代码更加灵活,因为同样的操作可以应用于不同的类型。多态有两种实现方式,一种是基于继承的实现,在这种实现中,父类定义一些通用的方法,子类则可以重写这些方法并实现不同的功能。另一种实现方式是接口,这种实现方式可以让不同的类实现同一个接口,从而实现多态。

 

代码示例:

class Animal:
    def move(self):
        pass

class Dog(Animal):
    def move(self):
        print("狗在跑")

class Cat(Animal):
    def move(self):
        print("猫在爬")

class Zoo:
    def __init__(self):
        self.animals = []

    def addAnimal(self, animal):
        self.animals.append(animal)

    def moveAll(self):
        for animal in self.animals:
            animal.move()

zoo = Zoo()
zoo.addAnimal(Dog())
zoo.addAnimal(Cat())
zoo.moveAll()

# 我们创建了一个动物园Zoo,并在其中添加了一只狗和一只猫。
# 当我们调用moveAll()方法时,它们会分别按照自己的方式移动,即狗会跑,猫会爬。

给大家写一个综合了封装,多态,继承的案例代码:

class Animal:
    def __init__(self, name, age, gender):
        self.__name = name
        self.__age = age
        self.__gender = gender

    def __get_name(self):
        return self.__name

    def __get_age(self):
        return self.__age

    def __get_gender(self):
        return self.__gender

    def eat(self):
        print('吃饭中...')

    def sleep(self):
        print('睡觉中...')

class Dog(Animal):
    def __init__(self, name, age, gender, breed):
        super().__init__(name, age, gender)
        self.__breed = breed

    def bark(self):
        print('汪汪!')

    def play(self):
        print('玩球中...')

class Cat(Animal):
    def __init__(self, name, age, gender, color):
        super().__init__(name, age, gender)
        self.__color = color

    def meow(self):
        print('喵喵!')

    def sleep(self):
        print('打盹中...')

def animal_action(animal):
    animal.eat()
    animal.sleep()


if __name__ == '__main__':
    dog = Dog('小黄', 3, '雄性', '金毛')
    cat = Cat('小花', 2, '雌性', '橘黄色')

    animal_action(dog)
    animal_action(cat)

Python中的面向对象编程基础

 1、创建类和对象

首先,类是我们在面向对象编程中的基础,它是一种用来描述具有相同属性和方法的对象集合的蓝图。举个例子,我们可以创建一个名为 "人" 的类,这个类里面包含了姓名、年龄、性别等属性,以及 eat、sleep、work 等方法。然后我们可以实例化这个 "人" 类,创建很多具有不同属性的人的对象。

 

代码示例:

# 首先,我们来创建一个“人”类
class Person:
    # 把属性放在 __init__ 方法里面,注意第一个参数永远是 self,代表该类的实例
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender
    
    # 这里是一个日常生活中的行为,写成方法
    def eat(self):
        print("{} 在吃饭".format(self.name))
    
    # 再来一个睡觉
    def sleep(self):
        print("{} 正在睡觉".format(self.name))
    
    # 最后一个工作
    def work(self):
        print("{} 在工作".format(self.name))


# 现在我们创建两个人的对象
p1 = Person("小明", 18, "男")
p2 = Person("小红", 22, "女")

# 通过对象调用方法
p1.eat()  # 小明 在吃饭
p2.sleep()  # 小红 正在睡觉

我们创建了一个名为 "Person" 的类,并定义了 "name"、 "age"、 "gender" 等属性,然后定义了 "eat"、 "sleep"、 "work" 等方法。通过实例化这个类,我们可以创建不同名字、不同年龄、不同性别的人,来调用这些方法。

 2、初始化方法和实例属性

初始化方法是在创建一个新的对象实例时,执行其中的代码,以初始化对象的属性和状态。Python 中的初始化方法通常为 init(),它是所有类中的可选方法。当您创建一个类的新实例时,Python 将自动调用 init() 方法,并将该实例作为第一个参数传递给它,并使用该实例来设置各种属性和状态。

 

代码示例:

首先,我们定义了一个名为 Person 的类,并在其中编写了初始化方法 init():

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

在上面的代码中,我们定义了一个新的类 Person,并在其中定义了初始化方法 init()。此方法将 name 和 age 作为参数传递,并使用 self.name 和 self.age 对象属性分别赋值。

接下来创建一个 Person 实例,并访问其中的属性:

person1 = Person("小明", 20)
print("这个人的名字是:", person1.name)
print("这个人的年龄是:", person1.age)

# 输出结果是:
# 这个人的名字是:小明
# 这个人的年龄是:20

在 Python 中,实例属性是方法内部定义的属性,它们与类的实例相关联,并且每个实例都有自己的一套实例属性。

代码示例:

我定义了一个名为 Car 的类,并为每个实例定义了一组属性:

class Car:
    def __init__(self):
        self.color = "黑色"
        self.brand = "奥迪"
        self.year = 2023

    def describe(self):
        print("这辆车是一辆 %d 年的 %s %s ,颜色为 %s" % (self.year, self.brand, self.model, self.color))

car1 = Car()
car1.model = "Q7"  # 为对象手动添加一个属性
car1.describe()

# 输出结果是:
# 这辆车是一辆 2023 年的 奥迪 Q7 ,颜色为 黑色

在上面的代码中,我们定义了一个新的类 Car,并在其中编写了初始化方法 init()。该方法设置了一个名为 color、brand 和 year 的实例属性。同时,该类还定义了一个名为 describe() 的方法,该方法将输出具体的汽车属性。

当我们创建一个 Car 实例 car1 时,Python 将自动调用 init() 方法,并设置其 color、brand 和 year 实例属性。接着我们又手动添加了一个 model 实例属性,并调用了 describe() 方法,从而输出了 car1 实例的详细属性。

 3、类方法和静态方法的应用

在Python中,类方法和静态方法都是用来处理类的一些数据和行为的。两种方法都是通过类名进行调用,而不是通过实例对象进行调用。

一、类方法

在Python中,定义类方法需要使用‘@classmethod’装饰器。类方法的第一个参数必须是‘cls’,表示类本身,可以通过‘cls’来调用类属性和类方法。

 

代码示例:

class Person:
    total_persons = 0

    def __init__(self, name):
        self.name = name
        Person.total_persons += 1

    @classmethod
    def show_total_persons(cls):
        print("Total persons: ", cls.total_persons)

p1 = Person("Tom")
p2 = Person("Jerry")
Person.show_total_persons()

在上面的代码中,我们创建了一个‘Person’类来记录创建的总人数。我们定义一个类方法‘show_total_persons()’来显示总人数。在实例化两个‘Person’对象后,我们使用‘Person.show_total_persons()’来显示人数。

二、静态方法

在Python中,定义静态方法需要使用‘@staticmethod’装饰器。静态方法没有参数限制,它只是一个普通函数,涉及到类和对象的问题,都需要在函数内部进行处理。

 

代码示例:

class Calculator:

    @staticmethod
    def add(x, y):
        return x + y

Calculator.add(3, 5)

在上面的代码中,我们定义了一个静态方法‘add()’,然后在类名后面直接调用它。

三、类方法和静态方法的应用

在Python中,类方法和静态方法的应用非常广泛,可以用来处理一些通用的类方法和静态方法。

 

代码示例:

在我们进行日期计算的时候,经常会用到类似的代码:

from datetime import datetime

now = datetime.now()
current_year = now.year

但是这种代码重复了很多次,我们可以定义一个类方法来处理它。

class DateCalculator:

    @classmethod
    def current_year(cls):
        now = datetime.now()
        return now.year

print("Current year: ", DateCalculator.current_year())

在上面的代码中,我们使用类方法‘current_year()’来计算当前的年份。使用类方法比多次编写相同的代码更加易于维护和编写。

4、继承和子类化

首先,什么是继承?简单来说,它是一种让一个类从另一个类上继承它的属性和方法的方式。这个被继承的类称作“父类”,而这个继承的类则称作“子类”。例如,一个动物类可以是一个父类,而狗类和猫类可以是子类。

 

代码示例:

class Animal:
    def __init__(self, name):
        self.name = name
    
    def speak(self):
        print("我是一只动物,我的名字是", self.name)

class Dog(Animal):
    def __init__(self, name):
        super().__init__(name)
    
    def bark(self):
        print("汪汪!")

class Cat(Animal):
    def __init__(self, name):
        super().__init__(name)

    def meow(self):
        print("喵喵!")

在这个例子中,我们定义了一个 Animal 类作为一个父类,其包含一个 speak 方法,用于输出“我是一只动物,我的名字是XXX”。

接下来,我们定义了一个 Dog 类和一个 Cat 类作为 Animal 的子类。在这两个子类中,我们通过调用 super().__init__(name) 方法让 Dog 和 Cat 的 name 属性继承自 Animal 的 name 属性。同时,我们也为它们分别添加了 bark 和 meow 方法,用于输出不同的声音。

dog = Dog("旺财")
dog.speak()
dog.bark()

# Output:
# 我是一只动物,我的名字是 旺财
# 汪汪!

cat = Cat("咪咪")
cat.speak()
cat.meow()

# Output:
# 我是一只动物,我的名字是 咪咪
# 喵喵!

可以看到,我们成功地通过继承让 Dog 和 Cat 类获得了 Animal 类的 speak 方法,并且通过子类化添加了不同的方法来实现功能的扩展。这样的方式既方便又灵活,可以大大简化我们的代码。

当然,这样的继承也可以产生一些问题,比如说实例化的对象可能会因为多层继承而产生命名冲突的问题。但是,在合理使用的情况下,它是一种非常有用的编程方式。

5、多重继承

多重继承是面向对象中非常重要且使用广泛的一种继承方式。它允许我们从多个父类中继承属性和方法,从而实现更加灵活的代码设计。但是,多重继承也可能会导致一些问题,例如方法名冲突、类的复杂性增加等等。因此,在使用多重继承时需要谨慎设计,尽量避免出现问题。

 

假设我们有3个类,分别是Animal(动物)、Bird(鸟)和Fish(鱼)。Animal类是基类,它包含了所有动物都具有的属性和方法,例如eat、sleep等等。Bird和Fish类都是继承自Animal类的子类,并且它们分别添加了自己独有的属性和方法,例如Bird类具有fly方法,而Fish类具有swim方法。

那么,如果我们需要创建一个Penguin(企鹅)类,它既需要继承Bird类的fly方法,又需要继承Fish类的swim方法,该怎么办呢?这时候,就需要使用多重继承了。

代码示例:

class Animal:
    def __init__(self, name):
        self.name = name
        
    def eat(self):
        print(self.name + "正在吃东西...")
        
    def sleep(self):
        print(self.name + "正在睡觉...")
        
class Bird(Animal):
    def fly(self):
        print(self.name + "正在飞翔...")
        
class Fish(Animal):
    def swim(self):
        print(self.name + "正在游泳...")
        
class Penguin(Bird, Fish):
    def __init__(self, name):
        super().__init__(name)
        
    def run(self):
        print(self.name + "正在奔跑...")

在上面的代码中,我们定义了Animal、Bird和Fish三个类,它们分别继承自Animal类,并且添加了独有的属性和方法。接着,我们定义了Penguin类,它同时继承自Bird类和Fish类,并且添加了自己的run方法。这样,Penguin类就可以同时拥有Bird类的fly方法和Fish类的swim方法了。

接下来,我们可以创建一个Penguin对象,来测试它的方法是否正常:

penguin = Penguin("小企鹅")
penguin.fly()   # 输出:小企鹅正在飞翔...
penguin.swim()  # 输出:小企鹅正在游泳...
penguin.eat()   # 输出:小企鹅正在吃东西...
penguin.sleep() # 输出:小企鹅正在睡觉...
penguin.run()   # 输出:小企鹅正在奔跑...

在上面的代码中,我们创建了一个名为小企鹅的Penguin对象,并且测试了它的飞翔、游泳、吃东西、睡觉和奔跑等方法。可以看到,这些方法都能够正常运行,并且Penguin类通过多重继承成功地继承了Bird类和Fish类的属性和方法。

希望此篇文章能够帮助你更好的理解面向对象!!!

 

你可能感兴趣的:(python基础,python,算法,开发语言,pycharm,编辑器)