目录

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 = nameself.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 = beakself.wing = wingself.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 = brandself.model = modelself.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 = brandself.model = modelself.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 = nameself.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 = nameself.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.5Kg

3.例3：编写Prime类实现输出大于m且紧随m的k个素数

解析：

        实体 ---数字

        属性 --- m，k

        方法 --- 判断素数实现大于m且紧随m的k个素数

class Pirme():def __init__(self, start_value, num):self.start_value = start_valueself.num = num
​def print_num(self):count = 0i = self.start_valuewhile count < self.num:for j in range(2, i):if i % j == 0:breakelse:count += 1print(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 = list1self.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]