Python的魔术方法总结

魔术方法：再不需要程序员定义，本身就存在类中的方法就是魔术方法。

魔术方法通常都长这样：__名字__。

1.__str__和__repr__

为了方便记忆看如下列子

class Course:
    def __init__(self,name,period,price,teacher):
        self.name= name
        self.period = period
        self.price = price
        self.teacher = teacher

    def __str__(self):
        return 'str : %s %s %s %s' % (self.name, self.period, self.price, self.teacher)

    def __repr__(self):
        return 'repr : %s %s %s %s' % (self.name, self.period, self.price, self.teacher)
course_lst = []
python = Course('python','6 month',29800,'boss jin')
course_lst.append(python)
linux = Course('linux','5 month',25800,'oldboy')
course_lst.append(linux)
for id,course in enumerate(course_lst,1):
    # print('%s %s %s %s %s'%(id,course.name,course.period,course.price,course.teacher))
    print(id,course)
    print('%s %s'%(id,course))
    print(str(course))
    print(repr(course))
    print('%r'%course)

__str__,__repr__

__str__触发条件：

1.当你打印一个对象的时候触发

2.当你使用%格式化的时候触发

3.str强转数据类型的时候触发

__repr__:

1.__repr__是__str__的备胎

2.有__str__的时候执行__str__,没有实现__str__的时候，执行__repr__

3.repr(obj)内置函数对应的结果是__repr__的返回值

4.当你使用%r的格式化的时候 触发__repr__

2.__new__

在init之前，实例化对象的第一步是__new__创建了一个空间

class Foo:
    def __init__(self):  # 初始化方法
        print('执行了init')

    def __new__(cls, *args, **kwargs):  # 构造方法
        # object.__new__(cls)
        print('执行了new')
        return object.__new__(cls)

obj = Foo()

创造一个对象比喻成捏小人

new是把小人捏出来

init给小人穿衣服

应用：创建单例模式

class Foo:
    __instance = None

    def __init__(self, name, age):  # 初始化方法
        self.name = name
        self.age = age
        self.lst = [name]

    def __new__(cls, *args, **kwargs):  # 构造方法
        if cls.__instance is None:
            cls.__instance = object.__new__(cls)
        return cls.__instance

obj1 = Foo('alex', 20)
obj2 = Foo('egon', 22)
abc1 = Foo('cao', 33)
print(obj1.lst, obj2.lst, abc1.lst)

单列模式

3.__del__

对象的__del__是对象在被gc消除回收的时候起作用的一个方法，它的执行一般也就意味着对象不能够继续引用。

看如下列子：

class Foo:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.file = open('file', mode='w')

    def write(self):
        self.file.write('sjahgkldhgl')

    def __del__(self):  # 析构方法 ： 在删除这个类创建的对象的时候会先触发这个方法，再删除对象
        # 做一些清理工作,比如说关闭文件，关闭网络的链接，数据库的链接
        self.file.close()
        print('执行del了')

f = Foo('alex', 20)
print(f)

__del__

4.__len__

如果一个类表现得像一个list，要获取有多少个元素，就得用 len() 函数。

要让 len() 函数工作正常，类必须提供一个特殊方法__len__()，它返回元素的个数。

class A:
    def __init__(self):
        self.a = 1
        self.b = 2
    def __len__(self):
        return len(self.__dict__)
a = A()
print(len(a))
print(a.__dict__)

菲波那切数列

# 菲波那切数列
# class Fib(object):
#     def __init__(self, num):
#         a, b, L = 0, 1, []
#         for n in range(num):
#             L.append(a)
#             a, b = b, a + b
#         self.numbers = L
#
#     def __str__(self):
#         return str(self.numbers)
#
#     # __repr__ = __str__
#
#     def __len__(self):
#         return len(self.numbers)
#
#
# f = Fib(10)
# print(f)
# print(len(f))

菲波那切数列

5.__eq__

__eq__ 当判断两个对象的值是否相等时，触发此方法.

class Staff:
    def __init__(self,name,sex):
        self.name = name
        self.sex = sex
    def __eq__(self, other):
        return self.__dict__ == other.__dict__
alex = Staff('alex','不详')
alex2 = Staff('alex','不详')
alex22 = Staff('alex2','female')
print(alex == alex2)  # alex.__eq__(alex2)
print(alex2 == alex22)

6.__call__

对象后面加括号，触发执行。

class Foo:

    def __init__(self):
        pass

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

        print('__call__')

obj = Foo() # 执行 __init__
obj()       # 执行 __call__

7.__hash__

# 当一个对象的类中有"__hash__"这个方法时, 那么这个对象就可以执哈希计算

# 前提是要哈希的值是可哈希的. 哈希的不是对象, 而是可以通过对象直接执行"hash(obj)"

class A:
    def __init__(self):
        self.a = 1
        self.b = 2

    def __hash__(self):
        return hash(str(self.a)+str(self.b))
a = A()
print(hash(a))

8.item系列

__getitem__,__setitem,__delitem__

class Foo:
    def __init__(self,name):
        self.name=name

    def __getitem__(self, item):
        print(self.__dict__[item])

    def __setitem__(self, key, value):
        self.__dict__[key]=value
    def __delitem__(self, key):
        print('del obj[key]时,我执行')
        self.__dict__.pop(key)
    def __delattr__(self, item):
        print('del obj.key时,我执行')
        self.__dict__.pop(item)

f1=Foo('sb')
f1['age']=18
f1['age1']=19
del f1.age1
del f1['age']
f1['name']='alex'
print(f1.__dict__)

item系列