python面向对象的三大特性

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、 继承

• 全部的查找名字（调用方法和属性）都是先找本身的，本身没有找父类
• 若是本身和父类都有，但愿本身和父类都调用，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 是哪一个类建立的，就今后类开始找，本身没有就找父类
   • 多继承，若是一个派生类有多个基类，执行对象.方法时，优先在本身的类中找，若是没有，就从左到右依次从基类中找

3、 多态

• 一个类表现出来的多种状态 --> 多个类表现出类似的状态

1. 基本内容：多种形态/多种类型，python自己就是多态的

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

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

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

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