zoukankan      html  css  js  c++  java

  • Python内置方法

    一、常用的内置方法

    • 1、__new__ 和 __init__： __new__ 构造方法 、__init__初始化函数

    　　　　1、__new__方法是真正的类构造方法，用于产生实例化对象（空属性）。重写__new__方法可以控制对象的产 生过程。也就是说会通过继承object的new方法返回一个内存空间（self)，给后面的init使用。

    　　　　2、__init__方法是初始化方法，负责对实例化对象进行属性值初始化，此方法必须返回None，__new__方法 必须返回一个对象。

    　　　　3、重写__init__方法可以控制对象的初始化过程。相当于在给object之前，添加了我们重写的内容

     
     
     
    ​x
     
     
     
     
    class Foo:
        def __new__(cls, *args, **kwargs):
            print('in new')   # 先执行
            obj = object.__new__(cls) # 使用object返回一个内存空间self，这里可以吧cls理解为指针也就是Foo里的指针
            print(obj)    #<__main__.Foo object at 0x02FF6D90>
            return obj
    ​
        def __init__(self):
            print('init',self)   # 后执行 init <__main__.Foo object at 0x02FF6D90>
    ​
    Foo()
    ​
    #单例模式 ：类无论实例化多少次，对象只能是一个
    class Student:
        __instance = None  
        def __new__(cls, *args, **kwargs):  # 这里的cls是表示来自Student，此时还没有生成self
            if not cls.__instance:   
                cls.__instance = object.__new__(cls)
            return cls.__instance
        def sleep(self):
            print('sleeping...')
    ​
    stu1 = Student()
    stu2 = Student()
    print(id(stu1), id(stu2))  # 两者输出相同
    print(stu1 is stu2)  # True
     

    • 2、__str__ 和__repr__

      • 两者的目的都是为了显式的显示对象的一些必要信息，方便查看和调试。

      • __str__被print默认调用，__repr__被控制台输出时默认调用。即，使用__str__控制用户展示，使用__repr__控制调试展示。

         
         
         
        #默认所有类继承object类，object类应该有一个默认的str和repr方法，打印的是对象的来源以及对应的内存地址
        class Student:
            def __init__(self, name, age):
                self.name = name
                self.age = age
        ​
        stu = Student('zlw', 26)
        print(stu)  # <__main__.Student object at 0x0000016ED4BABA90>
        ​
        # 自定义str来控制print的显示内容，str函数必须return一个字符串对象
        ​
        #__str__
        class Course:
            def __init__(self,name,price,period):
                self.name = name
                self.price = price
                self.period = period
            def __str__(self):
                '''1、打印这个对象的时候 自动触发__str__'''
                '''2、使用%s进行字符串的拼接的时候 自动触发__str__'''
                return '%s,%s,%s'%(self.name,self.price,self.period)
        ​
        python = Course('python',25000,'6 months')
        print(python)      # python,25000,6 months
        print('course %s'%python)  # course python,25000,6 months
        print(f'course {python}')  # course python,25000,6 months
        # 如果 不实现str方法,那么对象打印出来只是一串地址，因为object中有str，给你兜着.
        l = [1,2,3]
        # l是对象,打印的时候直接显示的是元素
        print(l)  #打印列表，因为它是列表的对像，所以有自己的父类的str
        ​
        #repr
        class Course:
            def __init__(self,name,price,period):
                self.name = name
                self.price = price
                self.period = period
        ​
            def __repr__(self):   # 备胎
                return '%s,%s,%s'%(self.name,self.price,self.period)
        ​
            def __str__(self):
                return self.name
        ​
            # __repr__ = __str__  # 效果和上面定义__repr__一样
        ​
        python = Course('python',25000,'6 months')
        print(python)    # python
        print('course %s'%python)  #course python
        print(f'course {python}')  #course python
        print(repr(python))     # python,25000,6 months，使用的__repr__的打印，显然此时要打印的对像str不行
        print('course %r'%python)  #course python,25000,6 months
        ​
        #总结：
        # 如果str存在,repr也存在
            # 那么print(obj)和使用字符串格式化format,%s这两种方式 调用的都是__str__
            # 而repr(obj)和%r格式化字符串,都会调用__repr__
        # 如果str不存在,repr存在
            # 那么print(obj),字符串格式化format,%s,%r 和repr(obj)都调用__repr__
        # 如果str存在,repr不存在
            # 那么print(obj)和使用字符串格式化format,%s这两种方式 调用的都是__str__
            # repr(obj)和%r格式化字符串 都会打印出内存地址，入最上例
            
        # 打印对象 先走自己的str,如果没有,走父类的,如果除了object之外的所有父类都没有str
        # 再回来,找自己的repr,如果自己没有,再找父类的，理论上来说，最好还是使用repr
         

    • 3、__call__：对象() 自动触发__call__中的内容

      • __call__方法提供给对象可以被执行的能力，就像函数那样

      • 拥有__call__方法的对象，使用callable可以得到True的结果，可以使用（）执行，执行时，可以传入参数，也可以返回值。所以我们可以使用__call__方法来实现实例化对象作为装饰器

         
         
         
        # 检查一个函数的输入参数个数, 如果调用此函数时提供的参数个数不符合预定义，则无法调用。
        ​
        # 单纯函数版本装饰器
        def args_num_require(require_num):
            def outer(func):
                def inner(*args, **kw):
                    if len(args) != require_num:
                        print('函数参数个数不符合预定义，无法执行函数')
                        return None
        ​
                    return func(*args, **kw)
                return inner
            return outer
        ​
        @args_num_require(2)
        def show(*args):
            print('show函数成功执行!')
        ​
        show(1)  # 函数参数个数不符合预定义，无法执行函数
        show(1,2) # show函数成功执行!
        show(1,2,3)  # 函数参数个数不符合预定义，无法执行函数
        ​
        # 实例对象版本装饰器
        class Checker:
            def __init__(self, require_num):
                self.require_num = require_num
        ​
            def __call__(self, func):
                self.func = func
        ​
                def inner(*args, **kw):
                    if len(args) != self.require_num:
                        print('函数参数个数不符合预定义，无法执行函数')
                        return None
        ​
                    return self.func(*args, **kw)
                return inner
        ​
        @Checker(2)
        def show(*args):
            print('show函数成功执行!')
        ​
        show(1)  # 函数参数个数不符合预定义，无法执行函数
        show(1,2) # show函数成功执行!
        show(1,2,3)  # 函数参数个数不符合预定义，无法执行函数
        ​
        #补充：
        class A:
            def call(self):
                print('in call')
            def __call__(self, *args, **kwargs):
                print('in __call__')
        ​
        A()()  # in __call__  
        obj.call()  #in call
         

    • 4、__del__ 析构方法，python中的清洁阿姨，周期性

      • __del__用于当对象的引用计数为0时自动调用。

      • __del__一般出现在两个地方：1、手工使用del减少对象引用计数至0，被垃圾回收处理时调用。2、程序结束时自动调用。

      • __del__一般用于需要声明在对象被删除前需要处理的资源回收操作，比如文件的关闭。

         
         
         
        xxxxxxxxxx
         
         
         
         
        import time
        class A:
            def __init__(self,name,age):
                self.name = name
                self.age = age
            def __del__(self):
                # 只和del obj语法有关系,在执行del obj之前会来执行一下__del__中的内容
                print('执行我啦')
        ​
        a = A('alex',84)
        print(a.name)
        print(a.age)
        # del a   # 这个变量已经没了 手动删除，再打印a，报错
        #time.sleep(1)
                    # 在所有的代码都执行完毕之后,所有的值都会被python解释器回收
        ​
        # 手工调用del 可以将对象引用计数减一，如果减到0，将会触发垃圾回收
        class Student:
            def __del__(self):
                print('调用对象的del方法，此方法将会回收此对象内存地址')
        ​
        stu = Student()  
        print(stu)  # <__main__.Student object at 0x002FEB70>
        del stu     # 调用对象的__del__方法回收此对象内存地址
        print(stu)  # 报错
        ​
        # 程序自动调用__del__函数
        class Student:
            def __del__(self):
                print('调用对象的del方法，此方法将会回收此对象内存地址')
        ​
        stu = Student()  # 程序直接结束，也会调用对象的__del__方法回收地址，打印里面的内容‘调用对象……’
        ​
        #总结：
        # python解释器清理内存：
            # 1.我们主动删除 del obj
            # 2.python解释器周期性删除
            # 3.在程序结束之前 所有的内容都需要清空
        #补充：再涉及文件操作时，还是要主动关闭文件句柄。
        ​
        class A:
            def __init__(self,path):
                self.f = open(path,'w')
            def __del__(self):
                '''归还一些操作系统的资源的时候使用'''
                '''包括文件网络数据库连接'''
                self.f.close()
        ​
        a = A('userinfo')
         

    • 5、__getitem__、__setitem__、__delitem__ : 给列表、元组、等有序类型的索引使用

      • 重写此系列方法可以模拟对象成列表或者是字典，即可以使用key-value的类型。

         
         
         
        xxxxxxxxxx
         
         
         
         
        class StudentManager:
            li = []
            dic = {}
        ​
            def add(self, obj):
                self.li.append(obj)
                self.dic[obj.name] = obj
        ​
            def __getitem__(self, item):
                if isinstance(item, int):
                    # 通过下标得到对象
                    return self.li[item]
                elif isinstance(item, slice):
                    # 通过切片得到一串对象
                    start = item.start
                    stop = item.stop
                    return [student for student in self.li[start:stop]]
                elif isinstance(item, str):
                    # 通过名字得到对象
                    return self.dic.get(item, None)
                else:
                    # 给定的key类型错误
                    raise TypeError('你输入的key类型错误!')
        ​
        class Student:
            manager = StudentManager()
        ​
            def __init__(self, name):
                self.name = name
        ​
                self.manager.add(self)  # 将自己的名字传入
        ​
            # def __str__(self):
            #     return f'学生: {self.name}'
        ​
            # __repr__ = __str__ #没有这个会在切片时 打印两个地址
            def __repr__(self):  # 备胎上 ，如果没有上面的话就用这个 替补，或则直接使用这个
                return f'学生: {self.name}'
        ​
        stu1 = Student('小明')
        stu2 = Student('大白')
        stu3 = Student('小红')
        stu4 = Student('胖虎')
        ​
        # 当做列表使用
        print(Student.manager[0])  # 学生: 小明
        print(Student.manager[-1])  # 学生: 胖虎
        print(Student.manager[1:3])  # [学生: 大白, 学生: 小红]
        ​
        # 当做字典使用
        print(Student.manager['胖虎'])  # 学生: 胖虎
        ​
         

    • 6、with：的上下文处理

      • __enter__、__exit__这两个方法的重写可以让我们对一个对象使用with方法来处理工作前的准备，以及工作之后的清扫行为。用好了可以提升我们的代码质量

         
         
         
        xxxxxxxxxx
         
         
         
         
        #1、运用在数据库中
        class MySQL:
            def connect(self):
                print('启动数据库连接，申请系统资源')
        ​
            def execute(self):
                print('执行sql命令，操作数据')
        ​
            def finish(self):
                print('数据库连接关闭，清理系统资源')
        ​
            def __enter__(self):  # with的时候触发，并赋给as变量，必须要有enter
                self.connect()
                return self  # 将实例化的空间返回，给as后面的变量
        ​
            def __exit__(self, exc_type, exc_val, exc_tb):  # 离开with语句块时触发
                self.finish()
        ​
        with MySQL() as mysql:  # 首先实例化Mysql，mysql接受作为对象
            mysql.execute()
            
        # 结果:
        # 启动数据库连接，申请系统资源
        # 执行sql命令，操作数据
        # 数据库连接关闭，清理系统资源
        ​
        #2、最简单的
        class File:
            def __enter__(self):
                print('start')
        ​
            def __exit__(self, exc_type, exc_val, exc_tb):
                print('exit')
        with File():
            print('wahaha')
        #执行顺序：start  wahaha   exit
        ​
        #3、手写一个文件操作类：
        import pickle
        class myopen:
            def __init__(self,path,mode='r'):
                self.path = path
                self.mode = mode
        ​
            def __enter__(self):
                print('start')
                self.f = open(self.path,mode=self.mode)  #打开一个文件句柄
                return self.f
        ​
            def __exit__(self, exc_type, exc_val, exc_tb):
                self.f.close()
                print('exit')
        ​
        with myopen('userinfo','a') as f:  #初始化myopen，返回的实例化结果给f
            f.write('hello,world')
        ​
        #4、添加功能
        class MypickleDump:
            def __init__(self,path,mode = 'ab'):
                self.path = path
                self.mode = mode
        ​
            def __enter__(self):
                self.f = open(self.path,self.mode)
                return self
        ​
            def dump(self,obj):
                pickle.dump(obj,self.f)
        ​
            def __exit__(self, exc_type, exc_val, exc_tb):
                self.f.close()
        ​
        with MypickleDump('pickle_file') as pickle_obj:
            pickle_obj.dump({1,2,3})
            pickle_obj.dump({1,2,3})
            pickle_obj.dump({1,2,3})
            
         #另写一个加载类
        class MypickelLoad:
            def __init__(self,path,mode='rb'):
                self.path = path
                self.mode = mode
        ​
            def __enter__(self):
                self.f = open(self.path,self.mode)
                return self
        ​
            def loaditer(self):
                while True:
                    try:
                        ret = pickle.load(self.f)
                        yield ret   #做成生成器
                    except EOFError:
                        break
        ​
            def __exit__(self, exc_type, exc_val, exc_tb):
                self.f.close()
        ​
        with MypickelLoad('pickle_file') as mypic:
            for obj in mypic.loaditer():
                print(obj)
                
         #合并两个类
        with MypickleDump('pickle_file') as obj:
            obj.dump({1,2,3,4})
        ​
        with MypickelLoad('pickle_file') as obj:
           for i in  obj.loaditer():
               print(i)
        ​
         

    二、了解的内置方法

    • 1、__doc__ 表述类的描述信息

    • 2、__module__ 和 __class__ 前者显示当前操作对象在哪个模块

       
       
       
      xxxxxxxxxx
       
       
       
       
      from lib.aa import C #这里假如有这么个模块
      

      obj = C()
      

      print obj.__module__  # 输出 lib.aa，即：输出模块
      

      print obj.__class__      # 输出 lib.aa.C，即：输出类
      

      

      

      

      

      

       
      


      

      

      • 

    • 

      3、__dict__ 　类或对象中的所有成员
      

      

       
      

       
      

       
      

      

      

      

      

      

      

      xxxxxxxxxx
      

      

       
      

       
      

      

      

       
      

       
      

      class Province:
      

      

      

          country = 'China'
      

          def __init__(self, name, count):
      

              self.name = name
      

              self.count = count
      

      

          def func(self, *args, **kwargs):
      

              print 'func'
      

      

      # 获取类的成员，即：静态字段、方法、
      

      print（Province.__dict__）
      

      # 输出：{'country': 'China', '__module__': '__main__', 'func': <function func at 0x10be30f50>, '__init__': <function __init__ at 0x10be30ed8>, '__doc__': None}
      

      

      obj1 = Province('HeBei',10000)
      

      print（obj1.__dict__）
      

      # 获取 对象obj1 的成员
      

      # 输出：{'count': 10000, 'name': 'HeBei'}
      

      

      obj2 = Province('HeNan', 3888)
      

      print（obj2.__dict__）
      

      # 获取 对象obj1 的成员
      

      # 输出：{'count': 3888, 'name': 'HeNan'}
      

      ​
      

      

      

      

      

      

       
      


      

      

      • 

    • 

      4、__getslice__、__setslice__、__delslice__：给切片使用
      

      • 

    • 

      5、__metaclass__ :其用来表示该类由 谁 来实例化创建
      

        

      • 类默认是由 type 类实例化产生，type类中如何实现的创建类？类又是如何创建对象？
        • 

      • 类中有一个属性 __metaclass__，其用来表示该类由 谁 来实例化创建，所以，我们可以为 __metaclass__ 设置一个type类的派生类，从而查看 类 创建的过程。也就是元类。
        • 

      

      img
      


      • 

    



    


    

    
    
                
    
                
              
    • 
              
    
              
  • 

                相关阅读:
    
                
                  在不给spring管理的类中获取类
                    
    poi操作excel
                    
    闭包
                    
    输入url的过程发生了什么？
                    
    跨域
                    
    函数节流-防抖函数
                    
    预解析-案例
                    
    移动端适配方案
                    
    实现元素水平居中和垂直居中的几种方法
                    
    css小知识点
                    
                        
              
    • 
              
    
              
  • 
                原文地址：https://www.cnblogs.com/double-W/p/10646968.html
              
    • 

            

          



          
          

            

            

          

        

      

      



      

      

        

          Copyright © 2011-2022 走看看