A brief introduction to the three methods __init__, __new__ and __call__ in python

This article mainly introduces you to the relevant information about the __init__, __new__ and __call__ methods in python. The article introduces it in detail through the example code, which has certain reference and learning value for everyone. Friends who need it can For reference study, let’s follow the editor and take a look.

Preface

This article mainly introduces to you the relevant content about the __init__, __new__ and __call__ methods in python, and share it for your reference. Let’s learn for reference. Not much to say below, let’s take a look at the detailed introduction:

Everything has a process from creation, use, to death. In the object-oriented programming model of programming language, Objects also have a similar fate: creation, initialization, use, and garbage collection. Different stages are executed by different methods (roles).

When defining a class, the most commonly used method is the __init__ method, while __new__ and __call__ are used less frequently. This article attempts to help you understand the correct use and application scenarios of these three methods. Explain them separately.

I won’t discuss too much about Python’s new-style classes and old-style classes in this article, because old-style classes are a concept in Python 2. Now almost no one will use old-style classes anymore. New-style classes must explicitly inherit object. In Python3, there are only new-style classes, which inherit object by default and do not need to be specified explicitly. The codes in this article are all discussed based on Python3.

__init__ method

__init__ method is responsible for the initialization of the object. Before the system executes this method, the object already exists, otherwise What to initialize? Let’s look at the example first:

# class A(object): python2 必须显示地继承object
class A:
 def __init__(self):
  print("__init__ ")
  super(A, self).__init__()

 def __new__(cls):
  print("__new__ ")
  return super(A, cls).__new__(cls)

 def __call__(self): # 可以定义任意参数
  print('__call__ ')

A()

Output

##

__new__
__init__

From the output result, the __new__ method is called first, An instance object is returned, and __init__ is called. The __call__ method has not been called. We will leave this to the end. Let’s talk about the first two methods first, slightly rewritten as:

def __init__(self):
 print("__init__ ")
 print(self)
 super(A, self).__init__()

def __new__(cls):
 print("__new__ ")
 self = super(A, cls).__new__(cls)
 print(self)
 return self

Output:

__new__ 
<__main__.A object at 0x1007a95f8>
__init__ 
<__main__.A object at 0x1007a95f8>

Judging from the output results, the return value of the __new__ method is the instance object of the class. This instance object will be passed to the self parameter defined in the __init__ method so that the instance object can be correctly ground initialization.

If the __new__ method does not return a value (or returns None), then __init__ will not be called. This makes sense, because the instance object has not been created, and calling init has no meaning. In addition, Python also stipulates that __init__ can only return a None value, otherwise an error will be reported. This is left for everyone to try.

__init__ method can be used to do some initialization work, such as initializing the state of the instance object:

def __init__(self, a, b):
 self.a = a
 self.b = b
 super(A, self).__init__()

In addition, the __init__ method except self The parameters defined outside must be consistent or equivalent to the parameters in the __new__ method except the cls parameter.

class B:
 def __init__(self, *args, **kwargs):
  print("init", args, kwargs)

 def __new__(cls, *args, **kwargs):
  print("new", args, kwargs)
  return super().__new__(cls)

B(1, 2, 3)

# 输出

new (1, 2, 3) {}
init (1, 2, 3) {}

__new__ Method

Generally we will not override this method unless you know for sure How to do it, when will you care about it? It is used as a constructor to create objects. It is a factory function dedicated to producing instance objects. One of the famous design patterns, the singleton pattern, can be implemented through this method. You may use it when writing framework-level code yourself. We can also find its application scenarios from open source code, such as the micro Web framework Bootle.

class BaseController(object):
 _singleton = None
 def __new__(cls, *a, **k):
  if not cls._singleton:
   cls._singleton = object.__new__(cls, *a, **k)
  return cls._singleton

This code comes from https://github.com/bottlepy/bottle/blob/release-0.6/bottle.py

This is passed The __new__ method is a way to implement the singleton mode. If the instance object exists, just return the instance directly. If it does not exist, create an instance first and then return. Of course, there is more than one way to implement the singleton pattern. The Zen of Python says:

There should be one-- and preferably only one --obvious way to do it.

Use one method, it is best to have only one method to do one thing

__call__ method

About the __call__ method, no Not to mention a concept first, that is, callable objects. Our usual custom functions, built-in functions and classes are all callable objects, but anything that can apply a pair of brackets () to an object can be called It is a callable object. To determine whether the object is a callable object, you can use the function callable

If the __call__ method is implemented in the class, then the instance object will also become a callable object. Let’s go back to the beginning. That example:

a = A()
print(callable(a)) # True

a is an instance object and also a callable object, then I can call it like a function. Try:

a() # __call__

很神奇不是，实例对象也可以像函数一样作为可调用对象来用，那么，这个特点在什么场景用得上呢？这个要结合类的特性来说，类可以记录数据（属性），而函数不行（闭包某种意义上也可行），利用这种特性可以实现基于类的装饰器，在类里面记录状态，比如，下面这个例子用于记录函数被调用的次数：

class Counter:
 def __init__(self, func):
  self.func = func
  self.count = 0

 def __call__(self, *args, **kwargs):
  self.count += 1
  return self.func(*args, **kwargs)

@Counter
def foo():
 pass

for i in range(10):
 foo()

print(foo.count) # 10

在 Bottle 中也有 call 方法 的使用案例，另外，stackoverflow 也有一些关于 call 的实践例子，推荐看看，如果你的项目中，需要更加抽象化、框架代码，那么这些高级特性往往能发挥出它作用。

总结

The above is the detailed content of A brief introduction to the three methods __init__, __new__ and __call__ in python. For more information, please follow other related articles on the PHP Chinese website!