面向对象编程

• 面向对象，python中支持两种编程方式，来写代码，分别是：函数式编程和面向对象

  • 函数式：

    # 定义函数，在函数中实现功能
    def func():
    	print("一个NB的功能")
    

  • 面向对象

    calss FOO(object):
    	def func(self):
            print("一个NB的功能")
    # 实例化对象
    obj = FOO()
    # 执行类中的方法
    obj.func()
    

1.初识面向对象

想要通过面向对象去实现某个或某些功能 需要2步：

• 定义类，在类中定义方法，在方法中实现具体的功能
• 实例化类得到一个对象，通过对行去调用并执行方法

class Message:

    def send_email(self, email, content):
        data = "给{}发邮件，内容是：{}".format(email, content)
        print(data)


if __name__ == '__main__': 
    # 实例化一个类 msg_object,创建了一块区域
    msg_object = Message()
    msg_object.send_email("于金龙", "阿龙的代码在报错")

注意：

• 1.类名称首字母大写&驼峰式命名；-
• 2.python 3之后默认类都继承object；-
• 3，在类中编写的函数称为方法；
• 4.每个方法的第一个参数是self

类中可以右多个方法：

例子：

# -*- coding: UTF-8 -*-
# @Project ：luffycity 
# @File    ：面向编程.py
# @Author  ：于金龙
# @IDE     ：PyCharm 
# @Date    ：2024/4/7 15:18
class Message:

    def send_email(self, email, content):
        data = "给{}发邮件，内容是：{}".format(email, content)
        print(data)

    def send_message(self, email, content):
        data = "给{}发消息，内容是：{}".format(email,
        print(data)


if __name__ == '__main__':
    msg_object = Message()
    msg_object.send_email("于金龙", "阿龙的代码在报错")
 

1.1 每个类中都可以定义个特殊的：__init__的初始化方法

class Message():
    def __init__(self, content):
        self.data = content

    def send_mail(self, email):
        print("给{}发邮件，内容是：{}".format(email, self.data))

    def send_message(self):
        print("给{}发消息，内容是{}".format(self.data, self.data))

    # 对象 = 类名（） # 自动执行类中的：__init__方法。
    # 1.根据类型创建一个对象，内存的一块区域
    # 2.执行__init__方法，模块会将创建的区域的内存地址当self参数传递进去。  往区域中（data="注册成功"）


msg_object = Message("注册成功")
msg_object.send_mail("<EMAIL>")

login_object = Message('登录成功')
login_object.send_message("<EMAIL>")

下面的图的对应的上面代码实现

面向对象的思想：将一些数据封装到对象中，在执行方法时，再去对象中获取。

函数式思想：函数内部需要的数据均通过参数的形式传递。

• self，本质上就是一个参数。这个参数是内部提供，其实是本质上就是调用当前方法的那个对象。
• 对象，基于基于类实例化出来的"一块内存"，默认里面是没有数据的：经过__init__方法，可以在内存中初始化一些数据。

应用实例：

# TODO:将数据封装到一个对象，以便于以后使用

class userInfo:
    def __init__(self, name, pwd):
        self.name = name
        self.password = pwd


def run():
    user_object_list = []
    while True:
        user = input("用户名：")
        if user.upper() == 'Q':
            break
        pwd = input("密码")
        user_info_object = userInfo(user, pwd)
        user_object_list.append(user_info_object)
    for obj in user_object_list:
        print(obj.name, obj.password)



if __name__ == '__main__':
    run()
#  总结：
1.将数据分装到对象
2.规范数据（做约束）

注意：用字典表示也可以做封装，只不过字典在从操作的时候还需要自己写key值，面向对象.即可获取到封装对象的数据

# TODO:将数据分装到对象中在方法对原始数据进行加工数据
# # 数据准备
user_list = ["用户{}".format(i) for i in range(1, 3000)]
# # 之前的思路（非面向对象方式编程）
# while True:
#     page = int(input("输入页数"))
#     start_page = (page - 1) * 10
#     end_page = page * 10
#     page_list = user_list[start_page:end_page]
#     for item in page_list:
#         print(item)


class Pagination:
    def __init__(self, current_page, page_len=10):
        self.page_len = page_len
        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.page_len

    def end(self):
        return self.current_page * 10


if __name__ == '__main__':
    while True:
        page = input("输入页码")
		# 分页显示 
        pg_object = Pagination(page,10)
        page_data_list = user_list[pg_object.start():pg_object.end()]
        for item in page_data_list:
            print(item)

class Police:
    def __init__(self, name, role):
        self.name = name
        if role == "队员":
            self.hit_points = 200
        else:
            self.hit_points = 500

    def status(self):
        message = "警察{}的血值为{}".format(self.name, self.hit_points)
        print(message)

    def bomb(self, t_list):
        for t in t_list:
            t.bool -= 8
            t.show_status()


class Terrorist:
    def __init__(self, name, bool=300):
        self.bool = bool
        self.name = name

    def shoot(self, police_object):
        police_object.hit_points -= 5
        police_object.status()

    def strafe(self, police_object_list):
        for police_object in police_object_list:
            police_object.hit_points -= 8
            police_object.status()

    def show_status(self):
        message = "恐怖分子{}，血量值为{}".format(self.name, self.bool)
        print(message)


if __name__ == '__main__':
    r1 = Police("于金龙", "队长")
    r2 = Police("r1", "队员")

    s1 = Terrorist("T1")
    s2 = Terrorist("T1")
    # 警察炸恐怖份子
    r1.bomb([s1, s2])
    # 恐怖分子扫射警察
    s1.strafe([r1, r2])
    # 恐怖分子设计
    s1.shoot(r2)

总结：

• 仅做数据封装
• 封装数据+方法再对数据进行加工
• 创建同一类的数据且同类数据具有相同的功能（方法）
• 相比函数可以更加规范简洁的实现一些功能

1.2 常见成员

在编写面向对象相关代码时，最常见的成员有：

• 实例变量，属于对象只能通过对象调用
• 绑定方法,属于类，同对象调用或通过类调用

注意：处理上面两个还有其他的成员

• 绑定方法

class Message():
    def __init__(self, content):
        self.data = content
	# 绑定方法
    def send_mail(self, email):
        print("给{}发邮件，内容是：{}".format(email, self.data))

    def send_message(self, email):
        print("给{}发消息，内容是{}".format(email, self.data))

    # 对象 = 类名（） # 自动执行类中的：__init__方法。
    # 1.根据类型创建一个对象，内存的一块区域
    # 2.执行__init__方法，模块会将创建的区域的内存地址当self参数传递进去。  往区域中（data="注册成功"）


p1 = Message("注册成功")
p1.send_mail("<EMAIL>")
# 第二种方法：直接在类中调用方法，但是类不自动赋值self（不常用）
p1 = Message("注册成功")
Message.send_mail("<EMAIL>")

实例参数

class Message():
	# 实例变量
    def __init__(self, content):
        self.data = content
# 实例化了一个对象，对象内的带有实例化的值self.data = content
p1 = Message("注册成功")
p1.send_mail("<EMAIL>")
# 实例变量属于对象只能通过对象进行调用

2.面向对象-三大特征

2.1 封装

封装主要体现：

• 将同一类的方法封装到一个类中
• 将数据封装到了对象种，在实例化一个对象时，可以通过__init__初始化在对象中封装一些数据，以便以后使用

2.2 继承

在传统的理念中有：儿子可以继承父亲的财产

在面向对象中也有这样的理念，即：子类可以继承父类中的方法和类变量(这里的继承并不是拷贝一份，父类的还是属于父类，子类可以继承而已)。

优先在自己类中找，找不到再去父类中查找

class Base:
    def func(self):
        print("Base.func")


class Son(Base):
    def show(self):
        print("Son.func")


s1 = Son()
s1.func()
s1.show()  # 优先在自己的类中找，自己没有才去父类

多态继承

class TCPServer:
    def f1(self):
        print('TCPServer')


class ThreadingMinIn:
    pass


class ThreadedTCPServer(TCPServer, ThreadingMinIn):
    def run(self):
        print("before")
        self.f1()
        print('after')


obj = ThreadedTCPServer()
obj.run()

# 多继承的顺序是自左向右的顺序进行继承

>>> before
>>> TCPServer
>>> after

小结：

• 执行对象时，方法时，优先当前对象所关联中找，没有的话才去他的父类中查找
• python支持多继承：先继承左边、再继承右边的。
• 去self对应的那个类中去获取成员，没有就按继承关系向上查找

2.3 多态

多态，按字面翻译其实就是多种形态。

其他编程语言中，时不允许这种类编写的。

在python中则不一样，由于python对数据类中没有任何限制，所有他天生支持多态

class Email(object):
    def send(self):
        print("发邮件")


class Message(object):
    def send(self):
        print("发消息")


v1 = Email()
v1.send()

v2 = Message()
v2.send()

在程序设计中，这种情况被称为鸭子类型，是一种动态类型的一种风格，在鸭子类型中关注点在于对象的行为，能在什么；而不是对象所属的类型，例如：这个鸟走起来像鸭子、游泳像鸭子，叫起来也像鸭子，那么这只鸟就是鸭子

总结

• 封装，将方法或者数据封装到对象中，以便后面进行使用
• 继承，将类中的公共方法提升到基类中
• 多态，python默认支持多态（这种被称为鸭子类型），最简单的记住下面这段代码即可

def func(arg):
    v1 = arg.copy()  # 浅拷贝
    print(v1)
# func("阿龙的代码在爆粗")
func([11, 22, 33, 44])


int("发消息")


v1 = Email()
v1.send()

v2 = Message()
v2.send()

在程序设计中，这种情况被称为鸭子类型，是一种动态类型的一种风格，在鸭子类型中关注点在于对象的行为，能在什么；而不是对象所属的类型，例如：这个鸟走起来像鸭子、游泳像鸭子，叫起来也像鸭子，那么这只鸟就是鸭子

总结

• 封装，将方法或者数据封装到对象中，以便后面进行使用
• 继承，将类中的公共方法提升到基类中
• 多态，python默认支持多态（这种被称为鸭子类型），最简单的记住下面这段代码即可

def func(arg):
    v1 = arg.copy()  # 浅拷贝
    print(v1)
# func("阿龙的代码在爆粗")
func([11, 22, 33, 44])