s21day19 python笔记

时间：2025-03-05 16:03:26

s21day19 python笔记

一、面向对象的基本知识

1.1 基本格式

# 定义类
class 类名:
    def 方法名(self,name):
        print(name)
        return 123
    def 方法名(self,name):
        print(name)
        return 123
    def 方法名(self,name):
        print(name)
        return 123

# 调用类中的方法
# 1.创建该类的对象
obj = 类名()
# 2.通过对象调用方法
result = obj.方法名('alex')
print(result)

1.2 应用场景

  1. 应用场景：遇到很多函数，需要给函数进行归类和划分

  2. 什么时候用面向对象？
    • 函数（业务功能）比较多，可以使用面向对象来进行归类
    • 想要做数据封装（创建字典存储数据时，面向对象）
    • 游戏示例：创建一些角色并且根据角色需要再创建人物

二、面向对象的三大特性

2.1 封装

  1. 对象的作用：存储一些值，以后方便自己使用

    class File:
    def read(self):
        with open(self.xxxxx, mode='r', encoding='utf-8') as f:
            data = f.read()
        return data

    def write(self, content):
        with open(self.xxxxx, mode='a', encoding='utf-8') as f:
            f.write(content)

# # 实例化了一个File类的对象
obj1 = File()
# # 在对象中写了一个xxxxx = 'test.log'
obj1.xxxxx = "test.log"
# # 通过对象调用类中的read方法，read方法中的self就是obj。
# # obj1.read()
obj1.write('alex')

# 实例化了一个File类的对象
obj2 = File()
# 在对象中写了一个xxxxx = 'test.log'
obj2.xxxxx = "info.txt"
# 通过对象调用类中的read方法，read方法中的self就是obj。
# obj2.read()
obj2.write('alex')

  2. 封装的作用：将数据封装到对象，方便使用

    class Person:
    def __init__(self,n,a,g): # 初始化方法（构造方法），给对象的内部做初始化。
        self.name = n
        self.age = a
        self.gender = g

    def show(self):
        temp = "我是%s,年龄：%s,性别：%s " % (self.name, self.age, self.gender,)
        print(temp)

# 类() 实例化对象，自动执行此类中的 __init__方法。
p1 = Person('李兆琪',19,'男')
p1.show()

p2 = Person('利奇航',19,'男')
p2.show()

  3. 总结

    • 如果写代码时，函数比较多比较乱

      • 可以将函数归类并放到同一个类中

      • 函数如果有一个反复使用的公共值，则可以放到对象中

    # 示例：循环让用户输入：用户名/密码/邮箱。 输入完成后再进行数据打印。
# 以前的写法：
USER_LIST = []
while True:
    user = input('请输入用户名：')
    pwd = input('请输入密码：')
    email = input('请输入邮箱：')
    temp = {'username':user,'password':pwd,'email':email}
    USER_LIST.append(temp)
for item in USER_LIST:
    temp = "我的名字：%s,密码：%s,邮箱%s" %(item['username'],item['password'],item['email'],)
    print(temp)

# 面向对象写法一：
class Person:
    def __init__(self,user,pwd,email):
        self.username = user
        self.password = pwd
        self.email = email

USER_LIST = [对象(用户/密码/邮箱),对象(用户/密码/邮箱),对象(用户/密码/邮箱)]
while True:
    user = input('请输入用户名：')
    pwd = input('请输入密码：')
    email = input('请输入邮箱：')
    p = Person(user,pwd,email)
    USER_LIST.append(p)
for item in USER_LIST:
    temp = "我的名字：%s,密码：%s,邮箱%s" %(item.username,item.password,item.email,)
    print(temp)

# 面向对象写法二：
class Person:
    def __init__(self,user,pwd,email):
        self.username = user
        self.password = pwd
        self.email = email
 def info(self):
        return "我的名字：%s,密码：%s,邮箱%s" %(item.username,item.password,item.email,)

USER_LIST = [对象(用户/密码/邮箱),对象(用户/密码/邮箱),对象(用户/密码/邮箱)]
while True:
    user = input('请输入用户名：')
    pwd = input('请输入密码：')
    email = input('请输入邮箱：')
    p = Person(user,pwd,email)
    USER_LIST.append(p)
for item in USER_LIST:
    msg = item.info()
    print(msg)

2.2 继承

  1. 基本内容

    # 父类(基类)
class Base:
    def f1(self):
        pass
# 子类（派生类）
class Foo(Base):
    def f2(self):
        pass

# 创建了一个子类的对象
obj = Foo()
# 执行对象.方法时，优先在自己的类中找，如果没有就是父类中找
obj.f2()
obj.f1()

# 创建了一个父类的对象
obj = Base()
obj.f1()

  2. 总结

    • 什么时候才能用到继承？
      • 多个类中如果有公共的方法，可以放到基类中避免重复编写
    • 继承关系中的查找方法的顺序时，注意事项：
      • self 到底是谁？
      • self 是哪个类创建的，就从此类开始找，自己没有就找父类。
    • 多继承，如果一个派生类有多个基类，执行对象.方法时，优先在自己的类中找，如果没有，就从左到右依次从基类中找

2.3 多态

  1. 基本内容：多种形态/多种类型，鸭子模型

    def func(arg): # 多种类型，很多事物
    arg.send() # 必须具有send方法，呱呱叫

  2. 面试题：什么是鸭子模型?

    对于一个函数而言，Python对于参数的类型不会限制，那么传入参数时就可以是各种类型，在函数中如果有例如：arg.send方法，那么就是对于传入类型的一个限制（类型必须有send方法），这就是鸭子模型

    类似于上述的函数我们认为只要能呱呱叫的就是鸭子（只有有send方法，就是我们想要的类型）

ps：day18考试没学新内容，就没写笔记

相关文章