Python面向对象

继承下的派生实际应用

  import datetime
  import json

  class MyJsonEncoder(json.JSONEncoder):
      def default(self, o):
          # 形参o就是即将要被序列化的数据对象
          # print('重写了', o)
          '''将o处理成json能够序列化的类型即可'''
          if isinstance(o,datetime.datetime):
              return o.strftime('%Y-%m-%d %X')
          elif isinstance(o, datetime.date):
              return o.strftime('%Y-%m-%d')
          return super().default(o)  # 调用父类的default(让父类的default方法继续执行 防止有其他额外操作)

  d1 = {'t1': datetime.datetime.today(), 't2': datetime.date.today()}
  res = json.dumps(d1, cls=MyJsonEncoder)
  print(res)
  """

  """
  TypeError: Object of type 'datetime' is not JSON serializable
  json不能序列化python所有的数据类型 只能是一些基本数据类型
      json.JSONEncoder

  1.手动将不能序列化的类型先转字符串
      {'t1': str(datetime.datetime.today()), 't2': str(datetime.date.today())}
  2.研究json源码并重写序列化方法
      研究源码发现报错的方法叫default
          raise TypeError("Object of type '%s' is not JSON serializable" % o.__class__.__name__)
      我们可以写一个类继承JSONEncoder然后重写default方法
  """

面向对象三大特征之封装

  # 封装的含义
	将类中的某些名字'隐藏'起来 不让外界直接调用
    隐藏的目的是为了提供专门的通道去访问 在通道内可以添加额外的功能
  # 代码实操
   class Student(object):
       school = '清华大学'
       __label = '逆来顺受'  # 由于python崇尚自由 所以并没有真正的隐藏  而是自动转换成了特定的语法
       def __init__(self, name, age):
           self.name = name
           self.age = age
       def choose_course(self):
           print('%s正在选课'%self.name)
   stu1 = Student('jason', 18)
   print(stu1.school)  # 清华大学
   print(stu1.name)  # jason
   print(stu1.age)  # 18
   print(stu1.__label)
   print(Student.__dict__)  # '_Student__label': '逆来顺受'
   print(Student._Student__label)
   print(stu1._Student__label)

  class Student(object):
      __school = '清华大学'
      def __init__(self, name, age):
          self.__name = name
          self.__age = age
      # 专门开设一个访问学生数据的通道(接口)
      def check_info(self):
          print("""
          学生姓名:%s
          学生年龄:%s
          """ % (self.__name, self.__age))
      # 专门开设一个修改学生数据的通道(接口)
      def set_info(self,name,age):
          if len(name) == 0:
              print('用户名不能为空')
              return
          if not isinstance(age,int):
              print('年龄必须是数字')
              return
          self.__name = name
          self.__age = age

  stu1 = Student('jason', 18)
  stu1.check_info()
  stu1.set_info('jasonNB',28)
  stu1.check_info()
  stu1.set_info('','haha')

  """
  如何封装名字
      在变量名的前面加上两个下划线__
  封装的功能只在类定义阶段才能生效!!!
      在类中封装其实也不是绝对的 仅仅是做了语法上的变形而已
          __变量名       >>>     _类名__变量名
  我们虽然指定了封装的内部变形语法 但是也不能直接去访问
      看到了就表示这个属性需要通过特定的通道(接口)去访问
  """

  """
  将数据隐藏起来就限制了类外部对数据的直接操作，然后类内应该提供相应的接口来允许类外部间接地操作数据，
      接口之上可以附加额外的逻辑来对数据的操作进行严格地控制
      
  目的的是为了隔离复杂度，例如ATM程序的取款功能,该功能有很多其他功能组成
      比如插卡、身份认证、输入金额、打印小票、取钱等，而对使用者来说,只需要开发取款这个功能接口即可,其余功能我们都可以隐藏起来
  """

property

  property就是将方法伪装成数据

  """
  可扩扩展:
  	体质指数（BMI）=体重（kg）÷身高^2（m）
  """
  有时候很多数据需要经过计算才可以获得 
  	但是这些数据给我们的感觉应该属于数据而不是功能
    	BMI指数>>>:应该属于人的数据而不是人的功能
  class Person(object):
      def __init__(self, name, height, weight):
          self.__name = name
          self.height = height
          self.weight = weight
      @property
      def BMI(self):
          # print('%s的BMI指数是:%s' % (self.name, self.weight / (self.height ** 2)))
          return '%s的BMI指数是:%s' % (self.__name, self.weight / (self.height ** 2))

   p1 = Person('jason', 1.83, 77)
   p1.BMI()  # 22.9
   print(p1.BMI)
   p2 = Person('eason',1.90,85)
   p2.BMI()  # 23.5
   print(p2.BMI)
   p3 = Person('xd',1.85,100)
   p3.BMI()  # 29.2
   print(p3.BMI)
   p4 = Person('xd',1.5,34)
   p4.BMI()  # 15.1
   print(p4.BMI)

面向对象三大特性之多态

  # 什么是多态
      一种事物的多种形态
      eg:
        水 固态 液体  气态
        动物  猫、狗、猪
  # 多态性
  class Animal(object):
      def speak(self):
          pass

  class Cat(Animal):
      def speak(self):
          print('喵喵喵')

  class Dog(Animal):
      def speak(self):
          print('汪汪汪')

  class Pig(Animal):
      def speak(self):
          print('哼哼哼')

  """
  上述场景下 虽然体现了事物的多态性 但是并没有完整的体现出来
  因为现在不同的形态去叫 需要调用不同的方法 不够一致
      
      只要你是动物 那么你想要说话 就应该调用一个相同的方法 这样便于管理
  """
  # c1 = Cat()
  # d1 = Dog()
  # p1 = Pig()
  # c1.speak()
  # d1.speak()
  # p1.speak()
  """
  面向对象的多态性其实在很早之前就已经接触过了
  """
  # s1 = 'hello world'
  # l1 = [1, 2, 3, 4]
  # d1 = {'name': 'jason', 'pwd': 123}
  # print(len(s1))
  # print(len(l1))
  # print(len(d1))
  """
  多态性的好处在于增强了程序的灵活性和可扩展性，比如通过继承Animal类创建了一个新的类，实例化得到的对象obj，可以使用相同的方式使用obj.speak()

  面向对象的多态性也需要python程序员自己去遵守

  虽然python推崇的是自由 但是也提供了强制性的措施来实现多态性
      不推荐使用
  """
  # import abc
  # 指定metaclass属性将类设置为抽象类，抽象类本身只是用来约束子类的，不能被实例化
  # class Animal(metaclass=abc.ABCMeta):
  #     @abc.abstractmethod # 该装饰器限制子类必须定义有一个名为talk的方法
  #     def talk(self): # 抽象方法中无需实现具体的功能
  #         pass
  # class Person(Animal): # 但凡继承Animal的子类都必须遵循Animal规定的标准
  #     def talk(self):
  #         pass
  # p1=Person() # 若子类中没有一个名为talk的方法则会抛出异常TypeError，无法实例化

  """
  由多态性衍生出一个鸭子类型理论
      只要你看着像鸭子 走路像鸭子 说话像鸭子 那么你就是鸭子!!!
  """

  # 鸭子类型的实战案例
  """
  在linux系统中有一句话>>>:一切皆文件!!!
      内存可以存取数据
      硬盘可以存取数据
      ...
      那么多有人都是文件
  """
  class Memory(object):
      def read(self):
          pass
      def write(self):
          pass
  class Disk(object):
      def read(self):
          pass
      def write(self):
          pass
  # 得到内存或者硬盘对象之后 只要想读取数据就调用read 想写入数据就调用write 不需要考虑具体的对象是谁

面向对象之反射

  # 什么是反射
  专业解释: 指程序可以访问、检测和修改本身状态或者行为的一种能力
  大白话: 其实就是通过字符串来操作对象的数据和功能

  # 反射需要掌握的四个方法
  hasattr(): 判断对象是否含有字符串对应的数据或者功能
  getattr(): 根据字符串获取对应的变量名或者函数名
  setattr(): 根据字符串给对象设置键值对(名称空间中的名字)
  delattr(): 根据字符串删除对象对应的键值对(名称空间中的名字)


  # 反射实际应用
  class Student(object):

      school = '清华大学'

  def get(self):
      pass


  # 编写一个小程序 判断Student名称空间中是否含有用户指定的名字 如果有则取出展示
  # print(Student.__dict__)
  '''字符串的school 跟 变量名school差距大不大?  本质区别'''
  guess_name = input('请输入你想要查找的名字>>>:').strip()
  # 不使用反射不太容易实现
  print(hasattr(Student, 'school'))  # True
  print(hasattr(Student, 'get'))  # True
  print(hasattr(Student, 'post'))  # False

  print(getattr(Student, 'school'))  # 清华大学
  print(getattr(Student, 'get'))  # <function Student.get at 0x10527a8c8>

  guess_name = input('请输入你想要查找的名字>>>:').strip()
  if hasattr(Student, guess_name):
      target_name = getattr(Student, guess_name)
      if callable(target_name):
          print('类中有一个功能名字是%s'%guess_name,target_name)
      else:
          print('类中有一个数据名字是%s'%guess_name,target_name)
  else:
      print('类中没有该名字')

  setattr(Student, 'level', '贵族学校')
  print(Student.__dict__)


  def index():
      pass

  obj = Student()
  setattr(obj, '血量', 10000)
  setattr(obj, '功能', index)
  print(obj.__dict__)
  delattr(obj, '功能')
  print(obj.__dict__)
  """
  什么时候使用反射 可以记固定的口诀
  	以后只要在业务中看到关键字 
  		对象 和 字符串(用户输入、自定义、指定) 那么肯定用反射
  """

反射实际案例

  # 利用反射获取配置文件中的配置信息
  """一切皆对象 文件也是对象"""
  import settings
  dir(settings)  # 获取对象中所有可以使用的名字
  getattr(settings, 'NAME')


  class FtpServer:
       def serve_forever(self):
           while True:
               inp=input('input your cmd>>: ').strip()
               cmd,file=inp.split()
               if hasattr(self,cmd): # 根据用户输入的cmd，判断对象self有无对应的方法属性
                   func=getattr(self,cmd) # 根据字符串cmd，获取对象self对应的方法属性
                   func(file)
       def get(self,file):
           print('Downloading %s...' %file)
       def put(self,file):
           print('Uploading %s...' %file)

  obj = FtpServer()
  obj.serve_forever()