目录
1.面向对象编程思想
1.编程思想
2.面向过程编程思想
3.面向对象编程思想
例 面向对象报名案例分析
面向过程与面向对象的区别
2.面向对象专业术语
1.组成
2.对象（object）
3.类：
1.引入类的原因
2.定义：
3.类的定义和和使用
1.面向对象开发步骤：
2.定义一个类：
4.类的实例化
5.类的self关键字
6.创建_ _ init _ _( )方法（初始化方法）
7.创建类的实例方法
实例方法与一般函数的区别：
8.创建类的静态方法
9.创建类的属性
4.类的属性
1.属性的概念
2.创建实例属性（默认的对象属性）
3.在类的外面添加属性和获取属性
4.在类的内部获取外部定义的属性
5.魔术方法
1.定义
2._ _ str _ _ ( )方法
3._ _ del _ _( )方法
6面向对象的综合案例
1.例1 ：定义学员信息类，包含姓名、成绩属性， 定义成绩打印方法（90分及以上显示优秀，80分及以上显示良好，70分及以上显示中等，60分及以上显示合格，60分以下显示不及格）
分析：
2.例2：小明体重75.0公斤，小明每次跑步会减掉0.50公斤，小明每次吃东西体重增加1公斤
解析：
3.例3：编写Prime类实现输出大于m且紧随m的k个素数
解析：
4.例4：编写Mysort类实现整数升序排序
解析：
1.面向对象编程思想
1.编程思想
人们用计算机解决问题的一种思维方式，Python支持两种，面向过程和面向对象两种方式
2.面向过程编程思想
总结 --- 自顶向下，逐步细化
程序的主体是函数，一个函数就是一个封装模块，实现代码重用和模块化编程
例 报名学习，可以分成哪些步骤：开始 -> 学院提出报名，提供相关资料 - > 学生缴纳费用、获得缴费凭证 - > 教师凭借学生缴费进行分班 - > 班级增加学生信息 - > 结束，以上步骤依次执行即可
3.面向对象编程思想
面向对象就是编程时尽可能去模拟现实世界，现实世界中，任何一个操作或者业务逻辑的实现都需要一个实体来完成，实体是动作的支配者，没有实体就没有动作发生
思考上述报名过程，动词 --- 提出、提供、获得、缴费、分班、增加等
有动词就有实现该动作的实体
例 面向对象报名案例分析
1.分析哪些动作由哪些实体发出的
学生 --- 提出报名
学生 --- 提供资料
学生 --- 缴费
机构 --- 收费
教师 --- 分班
班级 --- 在增加学生信息
一共四个实体 --- 学生、机构、教师、班级
2. 定义这些实体，为其增加相应的属性和功能
属性 --- 实体的固有特征，就是以前面向过程中的变量 如：
| 实体 | 属性 |
|---|---|
| 手机 | 价格、品牌、操作系统、颜色、尺寸 |
| 人 | 身高、体重、姓名、年龄、学历、电话、籍贯等 |
功能 --- 实体可以完成的动作，在面向对象术语中，功能就是封装的函数或方法
报名实体与属性：
3.让实体执行相应的功能和动作
学生 --- 提出报名
学生 --- 提供相应资料
教师 --- 等级学生信息
学生 --- 缴费
机构 --- 收费
教师 --- 分配教室
班级 --- 增加学生信息
面向过程与面向对象的区别
1.都可以实现代码重用和模块化编程，面向对象的模块化程度更深，数据也更封闭更安全
2.面向对象思维方法更贴近显示生活更容易解决大型的复杂业务逻辑
3.从前期开发角度来看，面向对象比面向过程更复杂，但从维护和扩展角度来说，面向对象比面向过程更简单
4.面向过程的代码执行效率比面向对象的效率要高
2.面向对象专业术语
1.组成
OOA --- 面向对象分析
OOD --- 面向对象设计
OOP --- 面向对象编程
2.对象（object）
定义 --- 是一个抽象的概念，现实世界万物皆为对象，对象就是事物存在的实体，如：一个人、一杯酒
一个对象分为2个部分 ：
静态部分 --- 属性、可观存在，不可忽视，如：人的性别
动态部分 --- 行为，对象执行的操作，如：人跑步
对象使用属性保存数据，使用方法管理数据
3.类：
Python中使用类产生对象，使用类规定对象的属性和方法，想要得到对象首先必须有类
1.引入类的原因
显示实体都要有一个类别
2.定义：
具有相同或相似的属性和动作的一组实体的集合
一个对象所具有的的特征信息都是由类决定的，但对象又可以具有不同的特征信息
3.类的定义和和使用
1.面向对象开发步骤：
1.设计一个类
2.使用类名创建对象，创建对象又有2步：
1. 内存中为对象分配空间
2. 调用出书话方法_ _ init_ _( )为对象初始化
2.定义一个类：
经典类：
class 类名：
'''类的信息'''
全局属性
类方法代码块
新式类：
class 类名（参数）：
'''类的信息'''
全局属性
类方法代码块
注意：
1.类名字命名时遵守一般标识符规则
2.为了和方法区分，应使用大驼峰命名法：类名中每个单词的首字母要大写，不能使用下划线，实例名和方法名都应小写，单词小写并在单词之间增加下划线
class Person():
# 属性
# 方法（函数）
def eat(self):
print('强子喜欢吃皮蛋')
def drink(self):
print('强子喜欢喝酒')
class Geese:
'''大雁类'''
pass特别注意：
类本质也是一个对象
Python一切皆为对象，类是一个特殊的对象，即类对象
类对象运行也会被加载到内存中
类对象在内存中只有一份，可以创建出多个对象实例
4.类的实例化
定义完类之后并不会立刻创建实例对象，必须更具类实例化创建出对象才可进行处理
类只是对象的一种规范，类本身什么也做不了，必须利用类得到对象，该过程称为类的实例化
格式 ---
对象名 = 类名( )例
# 1.定义一个类
class Person():
def eat(self):
print('强子喜欢吃皮蛋')
def drink(self):
print('强子喜欢喝酒')
# 2.实例化对象
p1 = Person()
# 3.调用对象的方法实现功能
p1.eat()
p1.drink()
结果：
强子喜欢吃皮蛋
强子喜欢喝酒
每一个对象都有自己的独立存储空间，保存各自的不同属性，多个对象的方法在内存中只有一份，在调用时，需要把对象的引用传递给方法内部
在编程过程中，对于有相同属性和方法的对象，为了避免重复定义，可以将这些对象归纳抽象为一个类
5.类的self关键字
定义 --- 是一个Python关键字
作用 --- 指向类实例对象本身，用于访问类中的属性和方法，在方法调用时会自动传递参数self
# 1.定义一个类
class Person():
def eat(self):
print('强子喜欢吃皮蛋')
print(self)
# 2.实例化对象
p1 = Person()
p2 = Person()
# 3.调用对象的方法实现功能
p1.eat()
p2.eat()
结果：
强子喜欢吃皮蛋
<__main__.Person object at 0x000001C7FFB49FD0>
强子喜欢吃皮蛋
<__main__.Person object at 0x000001C7FFB49FA0>总结 --- 类中self就是实例化对象的本身
6.创建_ _ init _ _( )方法（初始化方法）
Python中 _ _ xx _ _ ( ) 函数称为魔术方法，指具有特殊功能的函数
类创建后可以手动创建一个_ _ init _ _( )方法，
作用 --- 在创建一个对象时默认被调用的不需要手动调用
例
class Geese:
'''大雁类'''
def __init__(self, beak, wing, claw):
print('我是大雁类')
print(beak)
print(wing)
print(claw)
beak1 = '有较长'
wang1 = '翅膀长'
claw1 = '爪子为'
wil = Geese(beak1, wang1, claw1)注意：
1. _ _ init _ _( )方法 必须包含一个参数self，位置也必须是第一个，self本质是指向对象本身，没写实例或位置不对会报错
2._ _ init _ _( )方法 双线划线开头和结尾
3. _ _ init _ _( )方法 可以自己定义一些参数，都好隔开
例
class Person():
# 初始化实例对象
def __init__(self, name, age):
self.name = name
self.age = age
# 实例化对象并传入初始化的参数
p1 =Person('fff',18)
#调用p1对象自身的属性
print(p1.name)
print(p1.age)7.创建类的实例方法
类的成员主要由实例方法和数据组成
实例方法本质是类中定义的函数
格式 ---
def 方法名（self，其他形参）:
方法体方法名 --- 一般小写字母开头
self --- 必要参数，标识类的实例
其他参数 --- 多个参数使用逗号隔开
方法体 --- 实现方法具体的功能程序段
实例方法与一般函数的区别：
Python的函数是实现某个功能，实例化方法是类中的一个行为，是类的一部分
使用格式 --- 实例化对象.方法名(实参)
class Geese:
'''大雁类'''
def __init__(self, beak, wing, claw):
print('我是大雁类')
self.beak = beak
self.wing = wing
self.claw = claw
def fly(self, state):
print(state)
beak1 = '有较长'
wang1 = '翅膀长'
claw1 = '爪子为'
wil = Geese(beak1, wang1, claw1)
print(wil.beak)
wil.fly('飞行时候为人字形或一字型')
结果：
我是大雁类
有较长
飞行时候为人字形或一字型
Process finished with exit code 0
8.创建类的静态方法
作用 --- 在开发时，如果需要在类中封装一个方法，这个方法：既不需要访问属性或者调用实例方法，也不需要访问类属性或者调用类方法，
注意：
一般用于打印提示、帮助信息 等
格式 --- @staticmethod --- 其用于修饰类中的方法，使其可以在不创建类实例的情况下进行调用
优点 --- 执行效率高，该方法一般被称为静态方法。
注意：
静态方法不可以引用类中的属性或方法，其参数列表也不需要约定默认参数self。
例
class Game(object):
# 开始游戏，打印游戏功能菜单
@staticmethod # 装饰器声明下面方法为静态方法
def menu():
print('1.开始游戏')
print('2.游戏暂停')
print('3.退出游戏')
Game.menu() # 不需要创建对象：stu1 = Game()，通过 类名.方法名 调用9.创建类的属性
定义 --- 在类中并且在函数体外部的属性变量，类属性可以在类的所有实例之间共享，是一种公共的属性，一般记录类的相关特征。
类属性 --- 可以通过类名或对象名访问
class Geese:
'''大雁类'''
neck = '脖子较长'
wing = '翅膀振动频率高'
leg = '腿位于身体中心支点'
geese1 = Geese()
print(Geese.neck) # 通过 类名.属性名 访问
print(Geese.wing)
print(geese1.leg) # 通过 对象名.属性名 访问
示例图：
注意：
类属性一旦变更，所有对象的属性都会变化
class Geese:
'''大雁类'''
neck = '脖子较长'
wing = '翅膀振动频率高'
leg = '腿位于身体中心支点'
geese1 = Geese()
geese2 = Geese()
print(geese1.neck)
print(geese2.neck)注意：
不能使用 对象.属性 = 值 方法进行赋值，这只会增加第一个属性，而不会影响类属性
4.类的属性
1.属性的概念
Python中，任何一个对象都应该由两部分组成：属性+方法
属性 --- 即特征，如 : 人的姓名、年龄、升高、体重 ... 都是对象的属性
对象属性 --- 既可以在类外面创建和获取，也能在类里面创建和获取
2.创建实例属性（默认的对象属性）
定义 --- 定义在类犯法中的属性，只作用于当前对象
class Geese:
'''大雁类'''
def __init__(self):
self.neck = '脖子贼长' # 对象属性
geese1 = Geese()
geese2 = Geese()
geese1.neck = '脖子再长有我的长'
print(geese1.neck)
print(geese2.neck) # 值不变3.在类的外面添加属性和获取属性
格式 --- 对象名.属性名 = 值
例：
class Person:
pass
p1 = Person()
p1.name = '老王'
p1.age = 22
p1.adress = '显示雁塔区电子城街道金融路3号'
p2 = Person()
print(p2.name) # 报错，name 是p1的对象属性，私有4.在类的内部获取外部定义的属性
class Person:
def speak(self):
print(f'我的名字:{self.name},我的年龄：{self.age},我的地址：{self.adress}')
p1 = Person()
p1.name = '老王'
p1.age = 22
p1.adress = '雁塔区电子城街道金融路3号'
p1.speak()
结果：
我的名字:老王,我的年龄：22,我的地址：雁塔区电子城街道金融路3号5.魔术方法
1.定义
在Python中，_ _ xxx _ _ ( ) 的函数叫做魔术方法，指的是具有特殊功能的函数，如之前讲过的 _ _ init_ _( )
2._ _ str _ _ ( )方法
如果使用print输出对象的时候，默认打印对象的内存地址
如果类定义了 _ _ str _ _( )方法，那么就会打印出从这个方法中return的数据
例：
class Car():
def __init__(self, brand, model, color):
self.brand = brand
self.model = model
self.color = color
def __str__(self):
return f'汽车品牌:{self.brand},汽车型号:{self.model},汽车颜色:{self.color}'
model3 = Car('奔驰', 'S600', '黑色')
print(model3)
结果：
汽车品牌:奔驰,汽车型号:S600,汽车颜色:黑色上例中print（model3）若类中无_ _str _ _()方法则默认输出对象的首地址，若有则输出return后的结果
3._ _ del _ _( )方法
又称为删除方法或析构方法
当删除对象时，解释器会自动调用
例
class Car():
def __init__(self, brand, model, color):
self.brand = brand
self.model = model
self.color = color
def __str__(self):
return f'汽车品牌:{self.brand},汽车型号:{self.model},汽车颜色:{self.color}'
def __del__(self):
print('\n')
print(f'{self}对象已删除')
model3 = Car('奔驰', 'S600', '黑色')
print(model3)
# 删除对象modle3
del model3 # 自动调用__del()方法
结果：
汽车品牌:奔驰,汽车型号:S600,汽车颜色:黑色
汽车品牌:奔驰,汽车型号:S600,汽车颜色:黑色对象已删除注意：
_ _ del _ _( ) 方法一般用于输出提示、关闭文件、关闭数据库等后续操作
6面向对象的综合案例
1.例1 ：定义学员信息类，包含姓名、成绩属性， 定义成绩打印方法（90分及以上显示优秀，80分及以上显示良好，70分及以上显示中等，60分及以上显示合格，60分以下显示不及格）
分析：
实体 --- 学院
属性 --- 姓名、成绩
方法 --- 打印成绩
# 例1 定义学员信息类，包含姓名、成绩属性， 定义成绩打印方法（90分及以上显示优秀，80分及以上显示良好，70分及以上显示中等，60分及以上显示合格，60分以下显示不及格）
# 1.创建学员类
class Student():
# 2.定义学员的属性
def __init__(self, name, score):
self.name = name
self.score = score
def print_grade(self):
if self.score >= 90:
print(f'学院姓名:{self.name},学员成绩:{self.score},优秀')
elif self.score >= 80:
print(f'学院姓名:{self.name},学员成绩:{self.score},良好')
elif self.score >= 70:
print(f'学院姓名:{self.name},学员成绩:{self.score},中等')
elif self.score >= 60:
print(f'学院姓名:{self.name},学员成绩:{self.score},合格')
else:
print(f'学院姓名:{self.name},学员成绩:{self.score},不及格')
return 0
name1 = input('请输入要查询的学员的姓名：')
score1 = int(input('请输入该学员成绩：'))
student1 = Student(name1, score1)
print(student1.print_grade())
结果：
请输入要查询的学员的姓名：方方
请输入该学员成绩：65
学院姓名:方方,学员成绩:65,合格2.例2：小明体重75.0公斤，小明每次跑步会减掉0.50公斤，小明每次吃东西体重增加1公斤
解析：
实体 --- 小明
属性 --- 姓名、体重
方法 ---
跑步：体重减少0.5公斤
吃饭 ：体重增加1公斤
# 例2 小明体重75.0公斤，小明每次跑步会减掉0.50公斤，小明每次吃东西体重增加1公斤
class Student():
def __init__(self, name, weight):
self.name = name
self.weight = weight
def run(self):
self.weight -= 0.5
def eat(self):
self.weight += 1
def __str__(self):
return f'姓名：{self.name},目前体重:{self.weight}Kg'
ff = Student('方方', 54)
print(ff) # 利用str魔术方法返回信息
ff.eat()
print(ff)
ff.run()
print(ff)
结果：
姓名：方方,目前体重:54Kg
姓名：方方,目前体重:55Kg
姓名：方方,目前体重:54.5Kg3.例3：编写Prime类实现输出大于m且紧随m的k个素数
解析：
实体 ---数字
属性 --- m，k
方法 --- 判断素数实现大于m且紧随m的k个素数
class Pirme():
def __init__(self, start_value, num):
self.start_value = start_value
self.num = num
def print_num(self):
count = 0
i = self.start_value
while count < self.num:
for j in range(2, i):
if i % j == 0:
break
else:
count += 1
print(i, end=' ')
i += 1
m = int(input('请输入起始值：'))
k = int(input('请输入查找个数：'))
prime1 = Pirme(m, k)
prime1.print_num()
结果：
请输入起始值：5
请输入查找个数：3
5 7 11 4.例4：编写Mysort类实现整数升序排序
解析：
实体 --- list列表
属性 --- list 、len
方法 --- 选择升序排序
# 例4 编写Mysort类实现整数升序排序
class Mysort():
def __init__(self, list1):
self.list1 = list1
self.len = len
def selection_sort(self):
if len(self.list1) == 0:
return '数据不能为空'
self.list1 = list(self.list1) # 将字符串数字转为字符串列表
self.list1 = [int(self.list1[i]) for i in range(len(self.list1))] # 将字符串列表转为整数列表
# 选择法排序
for i in range(len(self.list1) - 1):
for j in range(i + 1, len(self.list1)):
if self.list1[i] > self.list1[j]:
self.list1[i], self.list1[j] = self.list1[j], self.list1[i]
return self.list1
list2 = input('请输入需要排序的序列：')
mysort1 = Mysort(list2)
print(mysort1.selection_sort())
结果：
请输入需要排序的序列：15237
[1, 2, 3, 5, 7]
