二、面向对象概念: 面向过程的程序设计的核心是过程（流水线式思维），过程即解决问题的步骤，面向过程的设计就好比精心设计好一条流水线，考虑周全什么时候处理什么东西。
优点: 极大地降低了写成学的复杂度，只需要顺着执行的步骤，堆叠代码即可
缺点: 一套流水线或者流程就是用来解决一个问题，如果修改代码就都得改变
三、类
优点: 解决了程序的扩展性。对某一个对象单独修改，会立刻反映到整个体系中，如对游戏中一个人物参数的特征和技能修改都很容易。
缺点:可控性差，无法向面向过程的程序设计流水线式的可以很精准的预测问题的处理流程与结果，面向对象的程序一旦开始就由对象之间的交互解决问题，即便是上帝也无法预测最终结果。于是我们经常看到一个游戏人某一参数的修改极有可能导致阴霸的技能出现，一刀砍死3个人，这个游戏就失去平衡。
3.1类对象
- 概念: 是具有相同特殊的一类事物(人, 鸟, 猫)
- 对象/实例: 具有的某一事物
- 实例化: 类到对象的过程(实例化=类名(类参数)
类对象支持两种操作: 属性引用和实例化.
属于引用和Python中所有的属性引用一样的标准语法: obj.name
3.2 对象和self在每个类中都可以定义个特殊的: init 初始化方法, 子啊实例化类创建对象时自动执行,即: 对象=类()
class Message:
def __init__(self, content):
self.data = content
def send_email(self, email):
data = "给{}发邮件，内容是：{}".format(email, self.data)
print(data)
def send_wechat(self, vid):
data = "给{}发微信，内容是：{}".format(vid, self.data)
print(data)
# 对象 = 类名() # 自动执行类中的 __init__ 方法。
# 1. 根据类型创建一个对象，内存的一块 区域 。
# 2. 执行__init__方法，模块会将创建的那块区域的内存地址当self参数传递进去。 往区域中(data="注册成功")
msg_object = Message("注册成功")
msg_object.send_email("wupeiqi@live.com") # 给wupeiqi@live.com发邮件，内容是：注册成功
msg_object.send_wechat("Kevin") # 给Kevin发微信，内容是：注册成功
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aD9HhwNm-1652743207347)(D:studypythonPython博客day17day17.assetsimage-20220506194743778-16518376683161.png)]
-
对象: 让我们可以在他啊的内部先封装一个部分数据, 以后想要使用时, 再去里面获取
-
self: 在类中的方法需要由这个类的对象来触发并执行(对象, 方法名), 且在执行是会自动将对象当做参数传递给self, 以供方法中获取对象中已封装的值
-
注意: 除了self默认参数以外, 方法中的参数的定义和执行与函数相同.
面向对象的思想: 将一些数据封装到对象中,在执行方法时, 再去对象 中获取.
函数式的思想: 函数内部需要的数据均通过参数的形式传递.
3.2 场景成员self, 本质上就是一个参数, 这个参数是Python内部提供, 其本质上就是调用当前方法的那个对象
对象: 基于类实例化出来的一块内存, 默认里面没有数据, 经过类的__init__方法,可以在内存中初始化一些数据
- 实例变量: 属性对象, 只能对过对象调用
- 类方法, 属于类,通过对象调用或通过类调用
class Person:
def __init__(self, n1, n2):
# 实例变量
self.name = n1
self.age = n2
# 绑定方法
def show(self):
msg = "我叫{}，今年{}岁。".format(self.name, self.age)
print(msg)
def all_message(self):
msg = "我是{}人，我叫{}，今年{}岁。".format(Person.country, self.name, self.age)
print(msg)
def total_message(self):
msg = "我是{}人，我叫{}，今年{}岁。".format(self.country, self.name, self.age)
print(msg)
# 执行绑定方法
p1 = Person("Kevin",20)
p1.show()
# 或
# p1 = Person("Kevin齐",20)
# Person.show(p1)
# 初始化，实例化了Person类的对象叫p1
p1 = Person("Kevin",20)
3.3 应用示例
-
将数据封装到一个对象，便于以后使用。
class UserInfo: def __init__(self, name, pwd,age): self.name = name self.password = pwd self.age = age def run(): user_object_list = [] # 用户注册 while True: user = input("用户名：") if user.upper() == "Q": break pwd = input("密码") # user_object对象中有：name/password user_object = UserInfo(user, pwd,19) # user_dict = {"name":user,"password":pwd} user_object_list.append(user_object) # user_object_list.append(user_dict) # 展示用户信息 for obj in user_object_list: print(obj.name, obj.password) 总结： - 数据封装到对象，以后再去获取。 - 规范数据（约束）
2.将数据分装到对象中，在方法中对原始数据进行加工处理。
def __init__(self, current_page, per_page_num=10):
self.per_page_num = per_page_num
if not current_page.isdecimal():
self.current_page = 1
return
current_page = int(current_page)
if current_page < 1:
self.current_page = 1
return
self.current_page = current_page
def start(self):
return (self.current_page - 1) * self.per_page_num
def end(self):
return self.current_page * self.per_page_num
user_list = ["用户-{}".format(i) for i in range(1, 3000)]
# 分页显示，每页显示10条
while True:
page = input("请输入页码：")
# page，当前访问的页码
# 10，每页显示10条数据
# 内部执行Pagination类的init方法。
pg_object = Pagination(page, 20)
page_data_list = user_list[ pg_object.start() : pg_object.end() ]
for item in page_data_list:
print(item)
3.根据类创建多个对象，在方法中对对象中的数据进行修改。
class Police:
"""警察"""
def __init__(self, name, role):
self.name = name
self.role = role
if role == "队员":
self.hit_points = 200
else:
self.hit_points = 500
def show_status(self):
""" 查看警察状态 """
message = "警察{}的生命值为:{}".format(self.name, self.hit_points)
print(message)
def bomb(self, terrorist_list):
""" 投炸弹，炸掉恐怖分子 """
for terrorist in terrorist_list:
terrorist.blood -= 200
terrorist.show_status()
"""
p1 = Police("Kevin","队员")
p1.show_status()
p1.bomb(["Leena","Jake"])
p2 = Police("Kevin","队长")
p2.show_status()
p2.bomb(["Leena","lenl"])
"""
class Terrorist:
""" 恐怖分子 """
def __init__(self, name, blood=300):
self.name = name
self.blood = blood
def shoot(self, police_object):
""" 开枪射击某个警察 """
police_object.hit_points -= 5
police_object.show_status()
self.blood -= 2
def strafe(self, police_object_list):
""" 扫射某些警察 """
for police_object in police_object_list:
police_object.hit_points -= 8
police_object.show_status()
def show_status(self):
""" 查看恐怖分子状态 """
message = "恐怖分子{}的血量值为:{}".format(self.name, self.blood)
print(message)
"""
t1 = Terrorist('alex')
t2 = Terrorist('李杰',200)
"""
def run():
# 1.创建3个警察
p1 = Police("武沛齐", "队员")
p2 = Police("苑昊", "队员")
p3 = Police("于超", "队长")
# 2.创建2个匪徒
t1 = Terrorist("alex")
t2 = Terrorist("eric")
# alex匪徒射击于超警察
t1.shoot(p3)
# alex扫射
t1.strafe([p1, p2, p3])
# eric射击苑昊
t2.shoot(p2)
# 武沛齐炸了那群匪徒王八蛋
p1.bomb([t1, t2])
# 武沛齐又炸了一次alex
p1.bomb([t1])
if __name__ == '__main__':
run()
四. 面向对象的三大特性总结:
- 且做数据封装
- 封装数据+ 方法对 数据进进行加工处理
- 创建捅一类的数据且数据可以具有相同的功能(方法)
4.1封装
- 封装
- 继承
- 多态
4.2继承将同一类方法封装到了一个类中, 例如上述示例中: 匪徒的额想管方法都卸载terrorist类中,经常的相关方法都卸载Police类中
将数据封装到了对象中, 在实例化一个对象是, 可以通过__init__初始化方法在对象中封装一些数据, 便于以后使用
传统的理念中有：儿子可以继承父亲的财产。
在面向对象中也有这样的理念，即：子类可以继承父类中的方法和类变量（不是拷贝一份，父类的还是属于父类，子类可以继承而已）。
父类->子类
基类->派生类
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UsJXlivU-1652743207348)(D:studypythonPython博客day17day17.assetsimage-20220506201516028-16518393183452.png)]
class Base:
def func(self):
print("Base.func")
class Son(Base):
def show(self):
print("Son.show")
s1 = Son()
s1.show()
s1.func() # 优先在自己的类中找，自己没有才去父类。
s2 = Base()
s2.func()
class Base:
def f1(self):
pass
class Foo(Base):
def f2(self):
pass
class Bar(Base):
def f3(self):
pass
o1 = Foo()
o1.f2()
o1.f1()
4.3多态注意:
1.执行对象.方法时，优先去当前对象所关联的类中找，没有的话才去她的父类中查找。
2.Python支持多继承：先继承左边、再继承右边的。
多态指的是一类食物有多重形态(比如: 老师. 下课铃响了(), 学生.下课铃响了(), 老师执行的是下班的操作, 学生执行的是放学的操作,虽然二者消息一样,但是执行的效果不同)
例如:动物很多中,(狗狗, 猫咪, 老虎)
python自带多态：
多态：同一类事物的多种状态
python里处处都是多态，只是我们一般发现不了
操作的时候不需要关心这个对象的数据类型，你只要用就行了
静态多态性（了解就好）
鸭子类型（如果两个类里面都有相同的方法，但是他们的类里面没有任何继承）
序列（str,list,tuple）：有顺序的数据集合，这三个没有任何继承
