python面向对象的三大特性

2023-01-31 00:01:33 特性 面向对象 三大

一、 封装

  • 广义的封装 :类中的成员
  • 狭义的封装 :私有成员
    • 表象:__名字
    • 实际:_类名__名字
    • 要求:只能在类的内部使用,既不能在类的外部调用,也不能在子类中使用
  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)

二、 继承

  • 所有的查找名字(调用方法和属性)都是先找自己的,自己没有找父类
  • 如果自己和父类都有,希望自己和父类都调用,super()/指定类名直接调
  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 是哪个类创建的,就从此类开始找,自己没有就找父类
    • 多继承,如果一个派生类有多个基类,执行对象.方法时,优先在自己的类中找,如果没有,就从左到右依次从基类中找

三、 多态

  • 一个类表现出来的多种状态 --> 多个类表现出相似的状态
  1. 基本内容:多种形态/多种类型,python本身就是多态的

    def func(arg): # 多种类型,很多事物
        arg.send() # 必须具有send方法,呱呱叫
  2. 面试题:什么是鸭子模型?

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

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

相关文章