小白也能看懂的Python基础教程（8）

Python面向对象

一、面向对象的概念

1、常见的编程思想

2、面向过程是什么？

3、什么是面向对象？

4、封装

5、继承

6、多态

二、面向对象的概念

1、两个重要概念

2、类

3、对象

4、self关键字

三、对象属性

1、什么是对象属性

2、类外面访问属性

3、类内部获取属性

四、魔法方法

1、什么是魔法方法？

2、无参_init_()方法

3、有参_init_()方法

4、_str_()方法

5、_del_()方法

五、继承基础

1、定义类的几种语法

2、什么是继承？

3、单继承

4、多继承

5、子类调用方法的顺序

六、面向对象综合案例

一、面向对象的概念

1、常见的编程思想

先来看看什么是思想？比如，乌鸦喝水、猴子吃椰子等。

说明：我们会发现，有了思想，就能解决很多问题。

类似的，编程思想就是：利用计算机来解决实际编程问题的一种思维方式。

而编程思想是通用的，与计算机语言本身没有太大关系。

常见的编程思想有：

（1）面向过程

（2）面向对象

Python是同时支持面向过程和面向对象的编程语言！

2、面向过程是什么？

【官方解释】面向过程是一种以过程为中心的编程思想。

通俗地说，在解决编程问题时，我们会把需要的操作步骤都列出来，然后按照操作步骤写代码，这种思维就是面向过程思想。

说明：比如，要产生一个随机数，步骤：（1）导入random模块；（2）产生随机数；（3）输出结果。

在实际生活中，为了更好理解面向过程。使用面向过程思维来了解：使用ATM机取钱的过程。

（1）带上银行卡，去ATM机所在的地方；

（2）排队等待；

（3）轮到自己了，把银行卡插入ATM机；

（4）输入密码，取钱；

（5）取钱成功

3、什么是面向对象？

【官方解释】面向对象是软件开发方法，一种编程范式。

面向对象是相对于面向过程来讲的，面向对象方法，把相关的数据和方法组织为一个整体来看待，从更高的层次来进行系统建模，更贴近事物的自然运行模式。

通俗地说，面向对象思想就是：当解决问题的视角不再是详细的操作步骤，而是另一个视角：操作对象。

比如，操作手机打电话、操作电脑来看电影、操作冰箱来存储新鲜水果等。

【对象】可以理解为冰箱、手机、电脑等一切事物。

说明：面向对象听起来很抽象、模糊、不理解，暂时没关系，记住五个字：一切皆对象。

面向对象思想优势：

（1）在现实生活中，所有事物都被看作是对象；

（2）面向对象的宗旨：模拟现实世界中的一切事物；

（3）贴近实际生活，给所有对象都赋予属性和方法，更加人性化。

面向对象思想虽然比较复杂，但有一些特性有迹可循。

面向对象的三大特性：

（1）封装

（2）继承

（3）多态

4、封装

在现实生活中，也有很多与封装的案例。比如，小明是一个IT公司的程序员。

类似的，在Python面向对象中也有封装。

简单地说，封装就是把对象的属性和方法放在一个整体中，并限制对属性和方法的访问操作。而这里说的整体，就是【类】。

class 类名:
    def 方法名():
	属性1 = 值1
	属性2 = 值2
	...
	
    def 方法名2():
	执行代码1
	执行代码2
	...

5、继承

在现实生活中，继承一般指的是子女继承父辈的财产，比如：子承父业等。

类似的，面向对象继承也有继承父类的意思。

通俗地说，当子类继承了父类后，子类就具有父类的属性和方法。比如，下图的关系。

注意：继承可以让程序更加简洁。

6、多态

多态指的是：不同类的对象对同一消息做出不同的响应。这里的发送消息，通常是指调用方法。

通过生活案例来说明什么是多态，比如：电脑键盘上的F12功能键是固定不变的，但完成功能不同。

固定不变的F12功能键	完成功能
F12	在WPS办公软件使用时，提示用户保存文件。
F12	在Notepad++编辑软件使用时，会把工作区间进行全屏显示。
F12	在Chrome浏览器使用时，能进入到开发者模式。

二、面向对象的概念

1、两个重要概念

要掌握Python面向对象的特性，首先需要了解两个重要概念：类、对象。

我们通过公司职员-张三为例子来解释说明。

类是抽象的概念，指的是：对某些事物的描述。[模板]

对象是具体的概念，指的是：实实在在存在的个体。[填写]

例如，请判断以下哪些是类，哪些是对象？

（1）员工；

（2）《陈翔六点半》里的演员妹爷；

（3）手机；

（4）被8分钟残忍嘎腰子的那只羊；

（5）银行卡；

（6）昆虫；

（7）动物；

（8）老王买的最新款iPhone 14 Pro；

（9）在对面马路上快速奔跑的Tank 300。

2、类

类是抽象的概念，指的是：对某些事物的描述。简单地说，类就是一个模板。

定义Python类语法：

class 类名:
    def 方法名(self):
    	代码1
    	代码2
    	...
    # 其他方法...

比如，我们都知道，小轿车是根据汽车图纸制造出来的，汽车图纸就是一个模板（类）。在汽车图纸模板中，指定：制造出来的汽车必须能跑起来。

例如，一起来完成：

（1）定义一个汽车类；

（2）让汽车类能跑起来；

（3）执行程序，观察效果。

class Car:
    def run(self):
        print("汽车能跑起来..."  )
# 当仅定义了后,执行程序没有效果

可以使用class关键字来定义Python类；

注意：类是抽象的，仅定义了类并执行，没有执行效果。

3、对象

对象是具体的概念，指的是：实实在在存在的个体。

简单的说，对象就是通过类创建出来的实体。

创建对象语法：

对象名 = 类名()

调用方法语法：

对象名.方法名()

比如，通过汽车图纸（模板）制造出能跑起来的小轿车（对象）。

例如，一起来完成：

（1）用对象模拟制造出一台小轿车；

（2）小轿车能跑起来；

（3）执行程序，观察效果。

class Car:
    def run(self):
        print("汽车能跑起来...")

# 1.创建对象
# 对象名 = 类名()
car = Car()
# 2.调用方法
# 对象名.方法名()
car.run()   # 不需要给self传递值

当创建了对象和调用方法后，执行程序则有结果。

4、self关键字

self是一个Python关键字，在面向对象中，self指向了对象本身。比如，创建了一个学生对象。

self可以理解为：当前的、当前的对象

# 定义类
class Student:
    pass

# 创建对象
student = Student()

例如，一起来完成：

（1）定义一个学生类，且学生在努力学习；

（2）创建一个对象，同时输出对象名、self，了解self的含义；

（3）再到学生类中，定义一个学生睡觉的行为，并分别通过对象名、self调用方法；

（4）执行程序，观察self的效果。

# 1、定义学生类
# 类中的self只是一个模版，创建对象之后，self是指向本对象
# 如果你创建了2个对象，每个对象中都有self，每个self都指向自己的对象
class Student():
    def study(self):
        print(self)   # <__main__.Student object at 0x0000021AB977F048>
        print('学生在努力学习!')

    def sleep(self):
        print(self)  # <__main__.Student object at 0x0000021AB977F048>
        self.study()   # 同一个类中，要调用其他方法，需要使用self，self表示本对象
        print('学生要好好睡觉！')


# 2、创建学生对象
s = Student()
print(s)  # <__main__.Student object at 0x0000021AB977F048>
s.study()
s.sleep()

print('--------------下边又是创建一个新的对象----------------')

s2 = Student()
print(s2)
s2.study()
s2.sleep()

三、对象属性

1、什么是对象属性

在现实生活中，属性就表示固有特征，比如：一辆小轿车的属性有轮胎数、颜色、品牌等。

仔细观察后会发现，属性可以简单理解为与生俱来的特征，比如一个人的姓名、年龄、身高、体重等都是属性。

而属性在Python面向对象中，直接使用变量来表示。

需要注意的是，一个对象通常包含两部分：方法、属性。

总结：

（1）属性在面向对象中，可以使用变量来表示；

（2）注意：属性可以在类内部、类外部都进行获取与使用。

2、类外面访问属性

在类外面访问属性，分为：（1）添加属性（2）获取属性

说明：要访问对象中的属性，需要使用.点来操作

添加属性语法：

对象名.属性名 = 值

获取属性语法：

对象名.属性名

说明：

.点可以理解为：的

例如，一起来完成：

（1）在车类外设置车的颜色为红色、品牌；

（2）获取属性值并输出结果。

# 1、定义汽车类
class Car:
    def run(self):  # self这个参数，暂时不用管，以后也不用传参，代表本对象
        print('汽车可以跑！')


print('--------------造第一个对象------------------------')
# 2、创建Car类对象
car = Car()
# 3、通过对象来调用方法
car.run()

# 4、添加属性
car.color = 'red'
car.number = 4

# 5、获取属性
print(f'车的颜色{car.color}')  # .就是的
print(f'车的轮胎数量{car.number}')  # .就是的

print('--------------造第二个对象------------------------')
# 1、创建对象
car2 = Car()
car2.run()

# 2、添加属性
car2.brand = '宝马'


# 3、获取属性
print(f'车的品牌:{car2.brand}')  # .就是的

# 以上代码两辆车的属性都不同

注意：当没有添加属性时，无法直接获取属性结果。

3、类内部获取属性

在类内部，获取属性语法：

self.属性名

说明：可以简单的把self理解为对象本身。

在类内部获取属性可以使用【self.属性名】方式；

注意：当没有在__init__()中初始化属性时，直接在方法中调用，则会报警告信息。

四、魔法方法

1、什么是魔法方法？

魔法方法指的是：可以给Python类增加魔力的特殊方法。

有两个特点：

（1）总是被双下划线所包围；

（2）在特殊时刻会被自动调用，不需要开发者手动去调用。

魔法方法语法：

__魔法方法名__()

在Python中，常用的魔法方法有：

魔法方法名	描述信息
`__init__(self [, ...])`	构造器，当一个对象被初始化创建时，会被自动调用。
`__str__(self)`	输出对象名时，若不想直接输出内存地址值，可重写str()方法。
`__del__(self)`	当一个对象被删除或销毁时，会被自动调用。

魔法方法的前后，总是被双下划线包围着；

注意：魔法方法会在某些特殊时刻被自动调用。

在Python中，当新创建一个对象时，则会自动触发__init__()魔法方法。

魔法方法名	描述信息
`__init__(self [, ...])`	构造器，当一个对象被初始化创建时，会被自动调用。

根据是否给__init__()魔法方法传递参数值，可分为：

（1）无参__init__()方法

（2）有参__init__()方法

2、无参_init_()方法

无参__init__()方法语法：

class 类名:
	def __init__(self):
        代码
        ...

说明：当仅需在类内部使用与初始化属性时，可以使用该方法。

例如，一起来完成：

（1）给小轿车这个对象默认设置颜色和价格为：黑色、20w；

（2）创建对象后，直接获取属性结果。

# 1、定义汽车类
class Car:
    def __init__(self):
        print('init方法执行了！')
        self.color = '白色'  # 所有对象的属性变量
        self.number = 4     # 所有对象的属性变量
        brand = '宝马'       # init方法中的局部变量，只能在方法内部使用，和对象关系不大

    def run(self):  # self这个参数，暂时不用管，以后也不用传参，代表本对象
        print('汽车可以跑！')


print('--------------造第一个对象：使用默认的属性------------------------')
car = Car()  # 创建对象，会自动执行init方法
print(f'车的颜色:{car.color}')
print(f'车的轮胎数量:{car.number}')
print(f'车的品牌:{car.brand}')

print('--------------造第二个对象：使用默认的属性------------------------')
car2 = Car()  # 自动执行init方法
print(f'车的颜色:{car2.color}')
print(f'车的轮胎数量:{car2.number}')

print('--------------造第三个对象：修改默认属性------------------------')
# 修改了对象的属性之后，只是修改本对象的属性，默认属性并不会修改
car3 = Car()
car3.color = '黑色'
car3.number = 3

print(f'车的颜色:{car3.color}')
print(f'车的轮胎数量:{car3.number}')

print('--------------造第四个对象：使用默认的属性------------------------')
# 这里输出的还是默认属性
car4 = Car()  # 自动执行init方法
print(f'车的颜色:{car4.color}')
print(f'车的轮胎数量:{car4.number}')

3、有参_init_()方法

当想要在创建对象时，就设定属性值时，可以使用有参__init__()方法。

语法：

class 类名:
    def __init__(self, 参数1, 参数2,...):
        代码
        ...

说明：

（1）不需要给self传递参数值；

（2）传递参数个数的计算公式为【传递参数个数 = 定义方法后的参数总个数 - 1】。

例如，一起来完成：

（1）直接在创建车对象时，初始化设定颜色、轮胎数值；

（2）在类外部直接获取对象属性值。

# 1、定义汽车类
class Car:
    def __init__(self,color,number):
        self.color = color       # 所有对象的属性变量
        self.number = number     # 所有对象的属性变量

    def run(self):  # self这个参数，暂时不用管，以后也不用传参，代表本对象
        print('汽车可以跑！')


print('--------------造第一个对象：传入自定义属性------------------------')
car = Car('白色',number=4)  # 创建对象，会自动执行init方法
print(f'车的颜色:{car.color}')
print(f'车的轮胎数量:{car.number}')

print('--------------造第二个对象：传入自定义属性------------------------')
car2 = Car(color='黑色',number=3)  # 自动执行init方法
print(f'车的颜色:{car2.color}')
print(f'车的轮胎数量:{car2.number}')

总结：

（1）__init__()方法可以用来设置属性的默认值；

（2）注意：当要在创建对象时，直接设定属性值，则可以通过有参__init__()方法传递参数值来处理。

4、_str_()方法

内存地址值，也称为引用。表现形式有两种：

（1）十进制数 5040624，id()函数

（2）十六进制数 0x45AC6

说明：当直接输出对象名时，默认输出的是对象的内存地址值。

当在类中定义了__str__方法，则获取的是该方法返回的数据结果。

魔法方法名	描述信息
`__str__(self)`	输出对象名时，若不想直接输出内存地址值，可重写str()方法。

__str__方法语法：

class 类名:
    def __str__(self):
        代码
        ...
        return 字符串型的结果

说明：必须返回字符串型的结果。

5、_del_()方法

当删除对象时，会自动调用__del__()方法。

魔法方法名	描述信息
`__del__(self)`	当一个对象被删除或销毁时，会被自动调用。

__del__()方法语法：

class 类名:
    def __del__(self):
        代码
        ...

总结：

（1）当使用【del 对象名】时，自动调用了__del__()方法；

（2）注意：当程序执行结束时，Python垃圾回收器会自动销毁内存垃圾，此时会自动调用__del__()方法。

五、继承基础

1、定义类的几种语法

我们知道，可以使用class关键字定义类。

在类的使用中，定义方式有三种：

（1）【类名】

（2）【类名()】

（3）【类名(object)】

说明：区别在于类名后面是否加其他内容。

方式1语法：

class 类名:
    代码
    ...

方式2语法：

class 类名():
    代码
    ...

方式3语法：

class 类名(父类):   # 推荐
    代码
    ...

说明：方式3是定义类最常见的语法。

例如，一起来完成：

（1）使用方式1/2/3分别定义老师类、学生类、手机类；

（2）当成功定义后，观察类的效果。

# 1.类名
# class Teacher:
class Teacher:
    pass


# 2.类名()
class Student():  # 删除()
    pass


# 3.类名(object)
class Phone(object):   # 标准
    pass

总结：

（1）定义一个类的语法有3种，但是更规范标准的是类名(object)；

（2）注意：在实际应用中，建议都采用【类名(object)】方式来定义类。

2、什么是继承？

在现实生活中，继承一般指的是：子女继承父辈的财产。

说明：当继承了父辈的财产后，则归子女所有。

类似的，在面向对象中，当子类继承父类后，则：子类拥有了父类的属性和方法。

继承语法：

class 父类名(object):
    代码
    ...
class 子类名(父类名):
    代码
    ...

说明：

（1）建议在定义父类时，都采用【类名(object)】语法；

（2）当子类拥有了父类的属性和方法后，能提升代码的复用性。

例如，一起来完成：

（1）Father类有一个性别属性，默认为男，同时，Father跑步速度快；

（2）如果Son类也想要拥有这些属性和方法，该怎么做呢？

（3）执行程序，观察程序效果。

# 1.定义父类
class Father(object):
    def __init__(self):
        self.sex = "男"

    def run(self):
        print("跑步很快...")

# 2.定义子类
# class Son(object):
#     def __init__(self):
#         self.sex = "男"
#
#     def run(self):
#         print("跑步很快...")

# 3.改进
class Son(Father):
    pass

# 4.输出
son = Son()
print(f"属性:{son.sex}")
son.run()

总结：

（1）子类继承父类的语法是：class 子类名(父类名): ...；

（2）注意：object类可以称为基类、顶级类或超类，而案例中的Son类一般称为子类、派生类。

3、单继承

单继承指的是：一个子类继承一个父类。语法：

class 子类名(父类名):
    代码
    ...

接着，一起来听个故事。故事主线是：一个徒弟跟着老师傅学习摊煎饼……

例如，一起来完成：

（1）从前，有个摊煎饼的老师傅[Master]，在煎饼果子界摸爬滚打多年，研发了一套精湛的摊煎饼技术；

（2）渐渐地，老师傅老了，就想着把这套技术传授给他唯一的最得意的徒弟[TuDi]；

（3）试着通过初始化、无参、定义方法与单继承来模拟程序。

# 1.定义父类：老师傅
# 配方
# 摊煎饼
class Master(object):
    def __init__(self):
        self.pei_fang = "【独创古法配方】"

    def make_cake(self):
        print("老师傅用古法配方摊煎饼果子...")

# 2.定义子类：徒弟
class TuDi(Master):
    pass

# 3.创建对象
fang_ge = TuDi()
print(fang_ge.pei_fang)
fang_ge.make_cake()

总结：

（1）单继承就是一个子类继承了一个父类，语法：class 子类名(父类名): ...；

（2）注意：当子类继承了父类后，子类可以拥有父类的属性和方法。

4、多继承

多继承指的是：一个类同时继承了多个父类。

语法：

class 子类名(父类名1, 父类名2, ...):
    代码
    ...

继续，回到摊煎饼的故事主线。

例如，一起来完成：

（1）徒弟是个爱学习的好孩子，想学习更多的摊煎饼技术；

（2）于是，在百度搜索到黑马程序员学校[School]，报班来培训学习如何摊煎饼；

（3）使用多继承形式模拟程序。

# 1.定义父类：老师傅
class Master(object):
    def __init__(self):
        self.pei_fang = "【独创古法配方】"

    def make_cake(self):
        print("老师傅用古法配方摊煎饼果子...")
# 2.定义父类：学校
class School(object):
    def __init__(self):
        self.pei_fang = "【科技与狠活之黑马配方】"

    def make_cake(self):
        print("===========采用黑马配方制作煎饼果子!!")

# 3.定义子类：徒弟
class TuDi(Master,School):
    pass

总结：

（1）当一个类同时继承了多个父类时，这种行为就叫做多继承；

（2）注意：在Python面向对象中，继承包含：单继承、多继承、多层继承。

5、子类调用方法的顺序

当子类同时继承多个父类，并调用多个父类同名方法的顺序，查看时使用

类名.__mro__

类名.mro()

例如，一起来完成：

（1）可以发现老师傅[Master]、培训学校[School]都有摊煎饼方法；

（2）在徒弟对象中调用摊煎饼方法，会执行哪个父类的方法呢？

（3）思考：当给父类培训学校[School]新增编程方法后，子类能调用方法吗？

# 1.定义父类：老师傅
class Master(object):
    def __init__(self):
        self.pei_fang = "【独创古法配方】"

    def make_cake(self):
        print("老师傅用古法配方摊煎饼果子...")
# 2.定义父类：学校
class School(object):
    def __init__(self):
        self.pei_fang = "【科技与狠活之学校配方】"

    def make_cake(self):
        print("===========采用学校配方制作煎饼果子!!")

# 3.定义子类：徒弟
# 如果父类出现同名的方法，调用顺序和这里继承父类的书写顺序相同，先调用Master的make_cake，再调用School的make_cake
class TuDi(Master,School):
    def programming(self):   # 子类的特有方法，加上父类继承的方法，子类一共有三个方法
        print("====培训摊煎饼果子!")


# 4、创建子类对象
tudi = TuDi()
# 调用方法时：
# a.先去子类中去查找该方法,若存在,则直接使用
# b.如果子类没有，则去第1个父类中查找Master
# c.如果第一个父类没有，则去第2个父类中找School
# d.如果所有父类都没有，则取object找
# e.如果都没有，则报错
tudi.make_cake()
tudi.programming()

print('-------mro()查看父类方法调用顺序----------')
print(TuDi.__mro__)

总结：

（1）当子类继承父类后，可以给子类添加新的扩展方法；

（2）当要查看子类调用父类方法的顺序时，可以使用子类名.__mro__或mro()。

六、面向对象综合案例

例如，一起来完成：

（1）小方同学当前体重是100kg；

（2）每当他跑步一次时，则会减少0.5kg；

（3）每当他大吃大喝一次时，则会增加2kg；

（4）假如跑步5次后，再大吃大喝一次，体重如何？

（5）请试着采用面向对象思想来编写案例。

class Student(object):
    # 1、定义属性
    def __init__(self, name,weight):
        self.name = name    # 小方  小花
        self.weight = weight # 100  60

    # 2、定义方法
    # 每当他跑步一次时，则会减少0.5kg；
    def run(self,num):
        self.weight -= num * 0.5

    # 每当他大吃大喝一次时，则会增加2kg；
    def eat(self,num):
        self.weight += num * 2

print('----------------------')
# 定义对象
stu1 = Student('小方',100)

# 跑步5次
stu1.run(5)
# 大吃大喝1次
stu1.eat(1)

# 打印体重
print(f'当前体重:{stu1.weight}')


print('----------------------')
# 定义对象
stu1 = Student('小花',60)

# 跑步3次
stu1.run(3)
# 大吃大喝1次
stu1.eat(2)

# 打印体重
print(f'当前体重:{stu1.weight}')