Python内置方法

一、常用的内置方法

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

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

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

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

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类的派生类，从而查看类创建的过程。也就是元类。

转载于:https://www.cnblogs.com/double-W/p/10646968.html