python基础知识

437 阅读6分钟

面向对象的魔法方法

  • 魔法方法:类中定义的双下方法都称为魔法方法

  • 不需要人为调用 在特定的条件下回自动触发运行

  • __init__创建空对象之后自动触发给对象添加独有的数据

      1.__init__
              对象添加独有数据的时候自动触发
      2.___str__
              对象被执行打印操作的时候自动触发
      3.__call__
              对象加括号调用的时候自动触发
      4.__getattr__
              对象点不存在的名字的时候自动触发
      5.__getattribute__
              对象点名字就会自动触发 有它的存在就不会执行上面的__getattr__
      6.__setattr__
              给对象添加或者修改数据的时候自动触发  对象.名字 = 值
      7.__enter__
              当对象被当做with上下文管理操作的开始自动触发 并且该方法返回什么 as后面的变量名就会接收到什么
      8.__exit__
              with上下文管理语法运行完毕之后自动触发(子代码结束)
              
    

魔法方法笔试题

  • 补全下列代码使得运行不报错即可

      class Context:
              pass
          with Context() as f:
              f.do_something()
    
      class Context:
          def do_something(self):
              pass
          def __enter__(self):
              return self
          def __exit__(self, exc_type, exc_val, exc_tb):
              pass
      with Context() as f:
          f.do_something()
    
  • 自定义字典类型并让字典能够通过句点符的方式操作键值对

      class MyDict(dict):
      def __setattr__(self, key, value):
          self[key] = value
    
      def __getattr__(self, item):
          return self.get(item)
      obj = MyDict()
      obj.name = 'jason'
      obj.pwd = 18
      obj.hobby = 'read'
      # print(obj)
      print(obj.name)
      print(obj.pwd)
      print(obj.hobby)
      # print(obj)
      # print(obj)  # 字典存储的数据  {}
      # print(obj.__dict__)  # 字典对象名称空间  {'name': 'jason'}
    
      print(type(obj))
      
      
    

元类简介

  • 推导步骤1:如何查看数据的数据类型

      s1 = 'hello world'   str()
      l1 = [11, 22, 33, 44]   list()
      d1 = {'name': 'jason', 'pwd': 123}   dict()
      t1 = (11, 22, 33, 44)   tuple()
      print(type(s1))   <class 'str'>
      print(type(l1))   <class 'list'>
      print(type(d1))   <class 'dict'>
      print(type(t1))   <class 'tuple'>
    
  • 推导步骤2:其实type方法是用来查看产生对象的类名

       class Student:
           pass
       obj = Student()
       print(type(obj))   
       <class '__main__.Student'>
    
  • 推导步骤3:python中一切皆对象 我们好奇type查看类名显示的是什么

      class Student:
          pass
      obj = Student()
      print(type(obj))   <class '__main__.Student'>
      print(type(Student))   <class 'type'>
      class A:pass
      class B:pass
      print(type(A), type(B))
    
  • 结论:我们定义的类其实都是由type类产生的>>>:元类(产生类的类)

创建类的两种方式

  • 方式1:使用关键字class

      class Teacher:
          school_name = '老女儿'
          def func1(self):pass
      print(Teacher)
      print(Teacher.__dict__)
    
  • 方式2:利用元类type type(类名,类的父类,类的名称空间)

      cls = type('Student', (object,), {'name':'jason'})
      print(cls)
      print(cls.__dict__)
    
  • 名称空间的产生

      1.手动写键值对:针对绑定方法不好定义
      2.内置方法exec:能够运行字符串类型的代码并产生名称空间
    

定制元类的产生行为

  • 推导

      对象是由类名加括号产生的    __init__
      类是由元类加括号产生的      __init__
    
  • 所有的类必须首字母大写 否则无法产生

  • 自定义元类 继承type的类也称之为元类

     class MyMetaClass(type):
      def __init__(self, what, bases=None, dict=None):
          # print('what', what)
          # print('bases', bases)
          # print('dict', dict)
          if not what.istitle():
              raise TypeError('类名首字母应该大写')
          super().__init__(what, bases, dict)
          
    
  • 指定类的元类:利用关键字metaclass指定类的元类

      class myclass(metaclass=MyMetaClass):
          desc = '元类很有趣  但是很狗 '
    
      class Student(metaclass=MyMetaClass):
          info = '我是学生 我很听话'
      print(Student)
      print(Student.__dict__)
      
    

魔法方法之双下new

class MyMetaClass(type):
    def __call__(self, *args, **kwargs):
        * 1.产生一个空对象(骨架)
        obj = self.__new__(self)
        * 2.调用__init__给对象添加独有的数据(血肉)
        self.__init__(obj,*args, **kwargs)
        * 3.返回创建好的对象
        return obj


class Student(metaclass=MyMetaClass):
    def __init__(self, name):
        self.name = name

obj = Student('jason')
print(obj.name)
    

设计模式简介

  • 什么是设计模式?

      设计模式用于表示开发人员用于创建软件或Web应用程序的模式。这些模式是根据需求分析选择的。模式描述问题的解决方案,何时何地应用解决方案以及实施的后果。
    
      设计模式是经过总结、优化的,对我们经常会碰到的一些编程问题的可重用解决方案。一个设计模式并不像一个类或一个库那样能够直接作用于我们的代码。反之,设计模式更为高级,它是一种必须在特定情形下实现的一种方法模板。设计模式不会绑定具体的编程语言。一个好的设计模式应该能够用大部分编程语言实现(如果做不到全部的话,具体取决于语言特性)。
    
  • 三种最基本的设计模式:

      创建模式:提供实例化的方法,为适合的状况提供相应的对象创建方法。
      结构化模式:通常用来处理实体之间的关系,使得这些实体能够更好地协同工作。
      行为模式:用于在不同的实体建进行通信,为实体之间的通信提供更容易,更灵活的通信方法。
    
  • 设计模式六大原则

      开闭原则:一个软件实体如类、模块和函数应该对扩展开放,对修改关闭。
      里氏替换原则:所有引用基类(父类)的地方必须能透明地使用其子类的对象。
      依赖倒置原则:高层模块不应该依赖低层模块,二者都应该依赖其抽象;抽象不应该依赖细节;细节应该依赖抽象。
      接口隔离原则:使用多个专门的接口,而不使用单一的总接口,即客户端不应该依赖那些它不需要的接口。
      迪米特法则:一个软件实体应当尽可能少地与其他实体发生相互作用。
      单一职责原则:不要存在多于一个导致类变更的原因。通俗的说,即一个类只负责一项职责。
    
  • 设计模式的结构

python设计模式结构

模式名称: 以简短有效的方式描述了模式。
模式动机: 描述了模式的作用。
模式实用性: 描述了适用模式的情况列表。
参与者与后果: 参与者包括参与设计模式的类和对象,以及该模式存在的后果列表。
  • 常用的Python设计模式

      Python是一种开源脚本语言。它具有支持多种设计模式的库。python的语法易于理解,并使用英语关键字。Python提供了对下面提到的设计模式列表的支持。这些设计模式将在教程中进行讲解。
    
      模型-视图-控制器模式
      单例模式
      工厂模式
      建造者模式
      原型模式
      外观模式
      命令模式
      适配器模式
      装饰模式
      代理模式
      责任链模式
      观察者模式
      状态模式
      策略模式
      模板模式
      享元模式
      抽象工厂模式
      面向对象模式
    
  • 使用设计模式的好处

      模式为开发人员提供了针对特定问题的经过尝试和测试的解决方案的选择。
      所有设计模式都是与语言无关的。
      模式有助于实现沟通并维护良好的文档。
      它包括成就记录,以减少项目的任何技术风险。
      设计模式使用起来非常灵活并且易于理解。