Python面向对象
目录
一、面向对象的概念
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}')总结：
（1）在类内部调用或获取属性时，可以使用self.属性名方式
（2）当通过对象来调用方法时，可以使用【self.方法名()】方式
（3）我们会发现，对于魔法方法的使用，会在某些特殊时刻自动被调用；
（4）在学习面向对象知识时，我们会发现总结起来就是五个字：一切皆对象.
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
