本篇文章给大家谈谈错误使用__new__生成类？，以及错误使用regress(line62)的知识点，同时本文还将给你拓展oracleover的使用_____________转N、python__ne

本篇文章给大家谈谈错误使用__new__生成类？，以及错误使用regress(line62)的知识点，同时本文还将给你拓展oracle over的使用_____________转N、python __new__ 和 __init__、python __new__, __del__, super、python __new__和__init__的区别等相关知识，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

• 错误使用__new__生成类？（错误使用regress(line62)）
• oracle over的使用_____________转N
• python __new__ 和 __init__
• python __new__, __del__, super
• python __new__和__init__的区别

错误使用__new__生成类？（错误使用regress(line62)）

我正在创建一些类来处理各种类型的文件共享（nfs，afp，s3，本地磁盘）等中的文件名。当用户输入时，会得到一个标识数据源（即"nfs://192.168.1.3"或"s3://mybucket/data"）的字符串。

我从具有通用代码的基类中继承特定文件系统。我感到困惑的是对象创建。我有以下内容：

import osclass FileSystem(object):    class NoAccess(Exception):        pass    def __new__(cls,path):        if cls is FileSystem:            if path.upper().startswith(''NFS://''):                 return super(FileSystem,cls).__new__(Nfs)            else:                 return super(FileSystem,cls).__new__(LocalDrive)        else:            return super(FileSystem,cls).__new__(cls,path)    def count_files(self):        raise NotImplementedErrorclass Nfs(FileSystem):    def __init__ (self,path):        pass    def count_files(self):        passclass LocalDrive(FileSystem):    def __init__(self,path):        if not os.access(path, os.R_OK):            raise FileSystem.NoAccess(''Cannot read directory'')        self.path = path    def count_files(self):        return len([x for x in os.listdir(self.path) if os.path.isfile(os.path.join(self.path, x))])data1 = FileSystem(''nfs://192.168.1.18'')data2 = FileSystem(''/var/log'')print type(data1)print type(data2)print data2.count_files()

我以为这会很好用，__new__但我读过的大多数文章都劝阻它。有没有更公认的方法来解决此问题？

答案1

小编典典

我 不
认为用__new__()做你想要的东西是不正确的。换句话说，我不同意这个问题)的公认答案，该观点认为工厂功能始终是“最佳方法”。

如果您真的想避免使用它，则唯一的选择是元类或单独的工厂函数/方法。考虑到可用的选择，将__new__()方法设置为一种（因为默认情况下是静态的）是一种完全明智的方法。

也就是说，以下是我认为是代码的改进版本。我添加了几个类方法来帮助自动查找所有子类。它们支持更好的最重要方法-
现在添加子类不需要修改__new__()方法。这意味着它现在很容易扩展，因为它有效地支持了所谓的 虚拟构造函数 。

也可以使用类似的实现将实例的创建从__new__()方法中移到单独的（静态）工厂方法中-
因此，从某种意义上说，无论使用什么名称，所示技术都是一种相对简单的编码可扩展通用工厂函数的方法它给出了。

# Works in Python 2 and 3.import osimport reclass FileSystem(object):    class NoAccess(Exception): pass    class Unknown(Exception): pass    # Regex for matching "xxx://" where x is any non-whitespace character except for ":".    _PATH_PREFIX_PATTERN = re.compile(r''\s*([^:]+)://'')    @classmethod    def _get_all_subclasses(cls):        """ Recursive generator of all class'' subclasses. """        for subclass in cls.__subclasses__():            yield subclass            for subclass in subclass._get_all_subclasses():                yield subclass    @classmethod    def _get_prefix(cls, s):        """ Extract any file system prefix at beginning of string s and            return a lowercase version of it or None when there isn''t one.        """        match = cls._PATH_PREFIX_PATTERN.match(s)        return match.group(1).lower() if match else None    def __new__(cls, path):        """ Create instance of appropriate subclass using path prefix. """        path_prefix = cls._get_prefix(path)        for subclass in cls._get_all_subclasses():            if subclass.prefix == path_prefix:                # Using "object" base class method avoids recursion here.                return object.__new__(subclass)        else:  # No subclass with matching prefix found (& no default defined)            raise FileSystem.Unknown(                ''path "{}" has no known file system prefix''.format(path))    def count_files(self):        raise NotImplementedErrorclass Nfs(FileSystem):    prefix = ''nfs''    def __init__ (self, path):        pass    def count_files(self):        passclass LocalDrive(FileSystem):    prefix = None  # Default when no file system prefix is found.    def __init__(self, path):        if not os.access(path, os.R_OK):            raise FileSystem.NoAccess(''Cannot read directory'')        self.path = path    def count_files(self):        return sum(os.path.isfile(os.path.join(self.path, filename))                     for filename in os.listdir(self.path))if __name__ == ''__main__'':    data1 = FileSystem(''nfs://192.168.1.18'')    data2 = FileSystem(''c:/'')  # Change as necessary for testing.    print(type(data1).__name__)  # -> Nfs    print(type(data2).__name__)  # -> LocalDrive    print(data2.count_files())  # -> <some number>

Python 3.6+更新

上面的代码可在Python 2和3.x中使用。但是，在Python
3.6中，object为named添加了一个新的类方法，__init_subclass__()该方法通过使用子类自动创建子类的“注册表”来简化子类的查找，而不必像上述_get_all_subclasses()方法那样递归地检查每个子类。

# Requires Python 3.6+import osimport reclass FileSystem(object):    class NoAccess(Exception): pass    class Unknown(Exception): pass    # Regex for matching "xxx://" where x is any non-whitespace character except for ":".    _PATH_PREFIX_PATTERN = re.compile(r''\s*([^:]+)://'')    _registry = {}  # Registered subclasses.    @classmethod    def __init_subclass__(cls, /, path_prefix, **kwargs):        super().__init_subclass__(**kwargs)        cls._registry[path_prefix] = cls  # Add class to registry.    @classmethod    def _get_prefix(cls, s):        """ Extract any file system prefix at beginning of string s and            return a lowercase version of it or None when there isn''t one.        """        match = cls._PATH_PREFIX_PATTERN.match(s)        return match.group(1).lower() if match else None    def __new__(cls, path):        """ Create instance of appropriate subclass. """        path_prefix = cls._get_prefix(path)        subclass = FileSystem._registry.get(path_prefix)        if subclass:            # Using "object" base class method avoids recursion here.            return object.__new__(subclass)        else:  # No subclass with matching prefix found (and no default).            raise FileSystem.Unknown(                f''path "{path}" has no known file system prefix'')    def count_files(self):        raise NotImplementedErrorclass Nfs(FileSystem, path_prefix=''nfs''):    def __init__ (self, path):        pass    def count_files(self):        passclass LocalDrive(FileSystem, path_prefix=None):  # Default file system.    def __init__(self, path):        if not os.access(path, os.R_OK):            raise FileSystem.NoAccess(''Cannot read directory'')        self.path = path    def count_files(self):        return sum(os.path.isfile(os.path.join(self.path, filename))                     for filename in os.listdir(self.path))if __name__ == ''__main__'':    data1 = FileSystem(''nfs://192.168.1.18'')    data2 = FileSystem(''c:/'')  # Change as necessary for testing.    print(type(data1).__name__)  # -> Nfs    print(type(data2).__name__)  # -> LocalDrive    print(data2.count_files())  # -> <some number>    try:        data3 = FileSystem(''foobar://42'')  # Unregistered path prefix.    except FileSystem.Unknown as exc:        print(str(exc), ''- raised as expected'')    else:        raise RuntimeError(              "Unregistered path prefix should have raised Exception!")

oracle over的使用_____________转N

python __new__ 和 __init__

概述

new 和 init 是类实例化的过程中被调用的方法， new 负责对象的创建，相当于构造器或者构造函数； init 负责对象初始化。 使用频率上， init 较多会被使用。

class A(object):

    def __new__(cls):
        return object.__new__(cls)

    def __init__(self):
        self.instance_method()

    def instance_method(self):
        print ''success!''

newA = A()

区别

参数

new 的第一个参数是 cls，表示类本身。

而 init 类似一般的实例方法， 第一个参数是 self，表示实例。我们可以看到 init 方法运行之前， 实例已经可以被使用了（self参数）。实例上的其他的方法也是可以使用的了。

调用时机

当我们创建类的对象时， new 先被调用，返回一个对象，对象引用作为参数传递给 init__， 然后对象属性被初始化。__init 方法不能返回任何数据。

__new__ --->(创建对象) --> __init__(self)

使用

只有很少的时候需要自己编写 new 方法，比如单例模式。大多数情况下，只需要关心实例的初始化，初始化过程中属性的分配，以及是否调用其他的实例方法。

以上代码和经验仅在 Python(2.7) 得到验证。

python __new__, __del__, super

1. __new__()  类“构造器”方法

__new__()方法是类的构造器，返回类实例。Python 用户可以对内建类型进行派生，因此，需要一种途径来实例化不可变对象，比如，派生字符串，数字，等等。在这种情况下，解释器则调用类的__new__()方法，__new__()会调用父类的__new__()来创建对象（向上代理）。调用__new__时，需要一个传入参数 cls，cls就是__new__方法返回的实例所属的类。

>>> class float2(float):
	def __new__(cls, arg = 0):
		return round(float.__new__(cls, arg),2)
>>> a = float2(1.3333)
>>> a
1.33

2. __del__() 类"解构器"方法

由于 Python 具有垃圾对象回收机制（靠引用计数)，这个函数要直到该实例对象所有的引用都被清除掉后才会执行。

del 语句删除一个对象的引用，当引用计数为0时，会调用__del__方法。Python 中的解构器是在实例释放前提供特殊处理功能的方法，它们通常没有被实现，因为实例很少被显式释放。

3. super()

super()函数在新式类中引入，用这个函数可以找出的父类，然后调用父类相关的属性。一般情况下，程序员可能仅仅采用非绑定方式调用祖先类方法。super语法如下：

super(type[, obj])

给出 type, super()“返回此 type 的父类”。如果你希望父类被绑定,你可以传入 obj 参数(obj必须是 type 类型的).否则父类不会被绑定。obj 参数也可以是一个类型，但它应当是 type 的一个子类。通常，当给出 obj 时：

    如果 obj 是一个实例，isinstance(obj,type)就必须返回 True

    如果 obj 是一个类或类型，issubclass(obj,type)就必须返回 True

来看看单例模式如何实现，最简单的想到使用类属性。

>>> class Singleton(object):
    _instance  = None
    def __new__(cls, *args, **kwargs):
	print cls.__name__, Singleton.__name__    
        if not cls._instance:
            cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
        return cls._instance

>>> a = Singleton()
Singleton Singleton
>>> b = Singleton()
Singleton Singleton
>>> id(a),id(b)
(47568656L, 47568656L)

类Singleton定义中，cls实际就是Singleton，隐藏可以写成

cls._instance = super(cls, cls).__new__(cls, *args, **kwargs)

python __new__和__init__的区别

__new__和__init__的区别

# new 是用来控制对象的生成过程,在对象生成之前
# init 是用来完善对象的
# 如果new方法不返回对象，则不会调用init方法

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

    def __init__(self, name):
        print("in init")
        self.name = name


if __name__ == ''__main__'':
    user = User(name="abc")

今天关于错误使用__new__生成类？和错误使用regress(line62)的分享就到这里，希望大家有所收获，若想了解更多关于oracle over的使用_____________转N、python __new__ 和 __init__、python __new__, __del__, super、python __new__和__init__的区别等相关知识，可以在本站进行查询。

本文标签：

• 错误使用new生成类
• regress(line62)错误
• 类对象初始化
• 程序调试技巧