疑问
class MetaC(type):def __call__(cls, *args, **kwargs):
new_args =
return type.__call__(cls, *new_args, **kwargs)
class C(metaclass=MetaC):
def __init__(self, name):
self.name = name
c = C('FishC')
在实例化对象的时候的__call__()进行拦截后，是不是就不执行__init__()的内容？
那输入c.name是会有name属性而行输出？
@FishC 不会的。实例化对象时，__call__()方法虽然被拦截了，但它仍然会调用原来的type.__call__()方法来执行实例化过程。所以在这个例子中，__init__()方法仍然会执行，而且会将经过处理后的参数传递进去。
因此，输入c.name会输出name属性的值，即'FishC'。
以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。 class MetaC(type):
def __call__(cls, *args, **kwargs):
new_args =
return type.__call__(cls, *new_args, **kwargs)
class C(metaclass=MetaC):
def __init__(self, name):
self.name = name
c = C('FishC')
在实例化对象的时候的__call__()会进行拦截，
是不是就不执行__init__()的内容？
那输入c.name是会有name属性而行输出？
@FishC 亦又 发表于 2024-04-15 15:32
class MetaC(type):
def __call__(cls, *args, * ...
在上面的代码中，`MetaC`类是一个元类，它有一个`__call__()`方法来拦截类对象的实例化过程。在拦截过程中，它会对传入的参数进行处理，将字符串类型的参数都转换为大写。然后调用`type.__call__()`方法继续执行实例化过程。
因此，在实例化`C`类的时候，会先执行`MetaC`类的`__call__()`方法对参数进行处理，然后再执行`C`类的`__init__()`方法初始化对象。所以`c.name`会得到结果并打印出来。
我们可以将代码进行简单修改，添加打印语句来验证一下：
class MetaC(type):
def __call__(cls, *args, **kwargs):
new_args =
print("拦截的参数：", new_args)
return type.__call__(cls, *new_args, **kwargs)
class C(metaclass=MetaC):
def __init__(self, name):
self.name = name
print("执行的初始化函数")
c = C('FishC')
print(c.name)
输出结果为：
拦截的参数： ['FISHC']
执行的初始化函数
FISHC
可以看到，在实例化对象时，首先执行了元类`MetaC`的`__call__()`方法对参数进行处理，然后再执行了`C`类的`__init__()`方法初始化对象，最终输出了正确的结果。
以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。
class MetaC(type):
def __call__(cls, *args, **kwargs):
new_args =
return type.__call__(cls, *new_args, **kwargs)
class C(metaclass=MetaC):
def __init__(self, name):
self.name = name
c = C('FishC')
在实例化对象的时候的__call__()会进行拦截，
为什么会执行__init__()的内容？
那输入c.name是会有name属性而行输出？
@FishC 亦又 发表于 2024-04-15 15:34
class MetaC(type):
def __call__(cls, *args, * ...
在这个代码中，当我们实例化一个对象时，会调用元类 `MetaC` 中的 `__call__()` 方法来创建一个新的对象。在 `__call__()` 方法中，我们对传入的参数进行了筛选，并把其中的字符串转换为大写形式。然后，调用 `type.__call__()` 方法来真正创建对象。
接下来，在 `C` 类中会执行 `__init__()` 方法。这是因为 `__init__()` 是用于初始化对象的特殊方法，在对象创建完成后被调用，用于初始化对象的属性。
所以，当我们实例化对象时，会先调用元类的 `__call__()` 方法进行拦截和处理，然后再调用类 `C` 的 `__init__()` 方法来初始化对象的属性。
因此，输入 `c.name` 会返回对象的 `name` 属性，即 `'FishC'`。
以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。 类的def __init__(self)方法触发条件是什么？@FishC 亦又 发表于 2024-04-15 17:48
类的def __init__(self)方法触发条件是什么？@FishC
当创建一个类的实例时，会自动调用该类的`__init__()`方法。也就是说，每当使用类名加括号创建一个对象时，Python会自动调用`__init__()`方法。
`__init__()`方法可以用来初始化对象的属性或执行必要的设置操作。它是一个特殊的方法，以双下划线开头和结尾，这种命名约定表示它是一个特殊的方法。
下面是一个示例代码：
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
person1 = Person("Alice", 25)
print(person1.name)# 输出 "Alice"
print(person1.age) # 输出 25
在上面的代码中，`Person`类有一个`__init__()`方法，它接受`name`和`age`参数，并将它们分别赋值给对象的`name`和`age`属性。创建`person1`对象时，`__init__()`方法被自动调用，并使用提供的参数进行初始化。
以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。 元类里的__call__()方法不是拦截实例化对象的操作么？
那这个元类中__call__()方法对元类创造出的类的__init__()和__new__()方法有没有啥影响？二者是先后的执行顺序，没有覆盖么？@FishC 亦又 发表于 2024-04-15 17:56
元类里的__call__()方法不是拦截实例化对象的操作么？ ...
是的，元类中的__call__()方法用于拦截实例化对象的操作。当我们通过元类创建一个类时，如果元类定义了__call__()方法，那么在通过这个类实例化对象时，会触发元类中的__call__()方法。
元类中的__call__()方法不会直接影响到元类创建出的类的__init__()和__new__()方法。元类中的__call__()方法和类的__init__()和__new__()方法是独立的，并且执行顺序是固定的。
当我们使用元类创建一个类时，首先会调用元类的__new__()方法来创建这个类的对象（即类对象），然后再调用元类的__init__()方法来初始化这个对象。最后，这个类的对象就可以被实例化为类的实例了。
下面是一个示例代码，演示元类、类的__init__()和__new__()方法的执行顺序：
class MyMeta(type):
def __new__(cls, name, bases, attrs):
print("Entering MyMeta.__new__()")
# 创建类对象
obj = super().__new__(cls, name, bases, attrs)
print("Exiting MyMeta.__new__()")
return obj
def __init__(self, name, bases, attrs):
print("Initializing", name)
super().__init__(name, bases, attrs)
def __call__(self, *args, **kwargs):
print("Entering MyMeta.__call__()")
# 实例化对象
obj = super().__call__(*args, **kwargs)
print("Exiting MyMeta.__call__()")
return obj
class MyClass(metaclass=MyMeta):
def __new__(cls, *args, **kwargs):
print("Entering MyClass.__new__()")
obj = super().__new__(cls)
print("Exiting MyClass.__new__()")
return obj
def __init__(self):
print("Initializing MyClass")
my_obj = MyClass()
输出结果：
Entering MyMeta.__new__()
Exiting MyMeta.__new__()
Initializing MyClass
Entering MyClass.__new__()
Exiting MyClass.__new__()
Entering MyMeta.__call__()
Exiting MyMeta.__call__()
Initializing MyClass
可以看到，首先调用元类的__new__()方法创建了类对象，然后调用元类的__init__()方法初始化了这个类对象。接着，在实例化这个类对象时，先调用类的__new__()方法创建了对象，然后再调用类的__init__()方法初始化了这个对象。
以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。 在实例化对象的时候，先执行类的__new__()方法，再执行元类中__call__（）方法，再执行类中的__init__()么？@FishC 亦又 发表于 2024-04-15 19:55
在实例化对象的时候，先执行类的__new__()方法，再执 ...
哈哈，你问得真好！实例化对象的过程确实是经历了这些步骤。
首先，当我们通过类名后跟括号来实例化一个对象时，Python会首先调用该类的元类的`__call__()`方法。元类是类的类，负责创建类的实例。在`__call__()`方法中，通常会调用父类的`__new__()`方法来创建一个对象，并最终返回这个对象。
接下来，Python会调用`__new__()`方法来创建对象。`__new__()`方法是一个静态方法，负责创建一个未初始化的对象，并将其返回。
最后，Python会调用`__init__()`方法来对刚刚创建的对象进行初始化。`__init__()`方法负责给对象的属性赋予初始值。
所以，总结一下：先调用元类的`__call__()`方法创建对象，然后调用类的`__new__()`方法创建对象，最后调用类的`__init__()`方法初始化对象。
下面是一个简单的示例代码，帮你更好地理解上述过程：
class MyMetaClass(type):
def __call__(cls, *args, **kwargs):
print("调用元类的__call__()方法")
obj = super().__call__(*args, **kwargs)
return obj
class MyClass(metaclass=MyMetaClass):
def __new__(cls, *args, **kwargs):
print("调用类的__new__()方法")
obj = super().__new__(cls)
return obj
def __init__(self, *args, **kwargs):
print("调用类的__init__()方法")
my_obj = MyClass()
输出结果为：
调用元类的__call__()方法
调用类的__new__()方法
调用类的__init__()方法
希望通过这个例子能够帮助你更好地理解对象实例化的过程！如果还有疑问，欢迎继续提问哦~
以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。 元类中的__init__（）方法和__new__()方法什么时候被触发？
元类中的__init__（）方法和__new__() 和__call__()和类中的__init__（）方法和__new__()？执行起来的顺序是什么？
@FishC 亦又 发表于 2024-04-15 20:00
元类中的__init__（）方法和__new__()方法什么时候被 ...
在理解元类中的__init__()方法和__new__()方法何时被触发之前，我们先来了解一下类的创建过程。
当我们定义一个类时，Python会首先尝试在当前类的模块中查找对应的元类（如果有）。如果找不到元类，Python会继续查找类的父类，直到找到一个合适的元类或者到达object类（所有类的根类）为止。
一旦找到了元类，Python就会使用这个元类来创建类。创建类的过程中会调用元类的__new__()方法来创建类对象，并且使用元类的__init__()方法来初始化这个类对象。
继续回答第二个问题，元类中的__call__()方法是在创建类对象之后，使用这个类对象创建实例时触发的。它可以让类对象像函数一样被调用。
执行顺序大致是这样的：
1. 先执行元类的__new__()方法，用于创建类对象。
2. 接着执行元类的__init__()方法，用于初始化这个类对象。
3. 然后执行类对象的__new__()方法，用于创建实例对象。
4. 最后执行类对象的__init__()方法，用于初始化这个实例对象。
下面是一个示例代码，帮助你更好地理解：
class MetaClass(type):
def __new__(cls, name, bases, attrs):
print("元类的__new__()方法被调用")
return super().__new__(cls, name, bases, attrs)
def __init__(cls, name, bases, attrs):
print("元类的__init__()方法被调用")
super().__init__(name, bases, attrs)
def __call__(cls, *args, **kwargs):
print("元类的__call__()方法被调用")
return super().__call__(*args, **kwargs)
class MyClass(metaclass=MetaClass):
def __new__(cls, *args, **kwargs):
print("类的__new__()方法被调用")
return super().__new__(cls)
def __init__(self, *args, **kwargs):
print("类的__init__()方法被调用")
super().__init__(*args, **kwargs)
obj = MyClass()
输出结果为：
元类的__new__()方法被调用
元类的__init__()方法被调用
类的__new__()方法被调用
类的__init__()方法被调用
希望这个例子能够帮助你更好地理解元类和类的创建过程！
以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。 class MetaClass(type):
def __new__(cls, name, bases, attrs):
print("元类的__new__()方法被调用")
return super().__new__(cls, name, bases, attrs)
def __init__(cls, name, bases, attrs):
print("元类的__init__()方法被调用")
super().__init__(name, bases, attrs)
def __call__(cls, *args, **kwargs):
print("元类的__call__()方法被调用")
return super().__call__(*args, **kwargs)
class MyClass(metaclass=MetaClass):
def __new__(cls, *args, **kwargs):
print("类的__new__()方法被调用")
return super().__new__(cls)
def __init__(self, *args, **kwargs):
print("类的__init__()方法被调用")
super().__init__(*args, **kwargs)
obj = MyClass()
这个代码call方法为啥不执行？元类中的__new__() __init__() 是不是在类的定义的时候就先执行了？
@FishC 亦又 发表于 2024-04-15 20:13
class MetaClass(type):
def __new__(cls, name, ...
是的，元类的`__call__()`方法在对象被调用时执行，而不是在对象被创建时执行。在上述代码中，`MyClass`是通过`MetaClass`作为元类来创建的。当我们执行`obj = MyClass()`时，实际上会调用元类`MetaClass`的`__call__()`方法。
元类`MetaClass`的`__call__()`方法被调用后，会调用`super().__call__(*args, **kwargs)`，这里的`super()`指的是`type`类，也就是默认的元类。所以，`super().__call__(*args, **kwargs)`实际上会调用`type`的`__call__()`方法。
在`type`的`__call__()`方法中，会调用类的`__new__()`和`__init__()`方法来创建一个对象，并返回该对象。在这个过程中，`obj = MyClass()`调用的是`MyClass`类的`__new__()`和`__init__()`方法，不会再次调用元类`MetaClass`的`__new__()`和`__init__()`方法。
所以，元类中的`__new__()`和`__init__()`方法在类被定义时先执行，而非在对象被创建时执行，而元类中的`__call__()`方法在对象被调用时执行。
以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。 class MetaClass(type):
def __new__(cls, name, bases, attrs):
print("元类的__new__()方法被调用")
return super().__new__(cls, name, bases, attrs)
def __init__(cls, name, bases, attrs):
print("元类的__init__()方法被调用")
super().__init__(name, bases, attrs)
def __call__(cls, *args, **kwargs):
print("元类的__call__()方法被调用")
return super().__call__(*args, **kwargs)
class MyClass(metaclass=MetaClass):
def __new__(cls, *args, **kwargs):
print("类的__new__()方法被调用")
return super().__new__(cls)
def __init__(self, *args, **kwargs):
print("类的__init__()方法被调用")
super().__init__(*args, **kwargs)
obj = MyClass()
输出结果是啥？@FishC 亦又 发表于 2024-04-15 20:15
class MetaClass(type):
def __new__(cls, name, ...
输出结果是：
元类的__new__()方法被调用
元类的__init__()方法被调用
元类的__call__()方法被调用
类的__new__()方法被调用
类的__init__()方法被调用
以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。 元类`MetaClass`的`__call__()`方法被调用后，会调用`super().__call__(*args, **kwargs)`，这里的`super()`指的是`type`类，也就是默认的元类。所以，`super().__call__(*args, **kwargs)`实际上会调用`type`的`__call__()`方法。
在`type`的`__call__()`方法中，会调用类的`__new__()`和`__new__()`方法来创建一个对象，并返回该对象?
还是先执行__call__()方法，返回创建的类对象，再调用类中__new__() 和__new__()创建对象并进行出初始化？
@FishC 亦又 发表于 2024-04-15 20:32
元类`MetaClass`的`__call__()`方法被调用后，会调用` ...
在类的实例化过程中，首先会调用元类的`__call__()`方法。在元类的`__call__()`方法中，通常会去调用默认元类`type`的`__call__()`方法来完成实例化。
在`type`的`__call__()`方法中，首先会调用类的`__new__()`方法来创建一个对象，并返回该对象。然后，`__call__()`方法会调用类的`__init__()`方法对这个对象进行初始化。最后，`__call__()`方法将这个初始化完毕的对象返回。
所以，整体的流程是先执行`__call__()`方法，并返回创建的类对象，然后再调用类中的`__new__()`和`__init__()`方法创建对象并进行初始化。
以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。
页:
[1]
2