Python中的空对象？

2024-04-24 13:22:50 发布

您现在位置：Python中文网/ 问答频道 /正文
1750 3


Tags： python
3条回答
网友
1楼 · 编辑于 2024-04-24 13:22:50

None，Python为空？

Python中没有null，而是有None。如前所述，最准确的测试方法是使用None标识运算符，该运算符测试两个变量引用同一对象。

>>> foo is None
True
>>> foo = 'bar' 
>>> foo is None
False

基础知识

有且只能有一个None

None是类NoneType的唯一实例，任何进一步实例化该类的尝试都将返回相同的对象，这将使None成为一个单例。Python的新手经常看到提到NoneType的错误消息，并想知道它是什么。我个人认为，这些消息可以简单地用名字提及None，因为，正如我们不久将看到的，None没有什么含糊不清的余地。所以，如果你看到一些TypeError消息提到NoneType不能这样做或不能那样做，只要知道它只是一个None正在使用的方式，它不能

另外，None是一个内置常量，只要启动Python，它就可以在任何地方使用，无论是在模块、类还是函数中。NoneType相反，您需要首先通过查询其类的None来获取对它的引用。

>>> NoneType
NameError: name 'NoneType' is not defined
>>> type(None)
NoneType

您可以使用Python的identity函数id()检查None的唯一性。它返回分配给一个对象的唯一编号，每个对象都有一个。如果两个变量的id相同，那么它们实际上指向同一个对象。

>>> NoneType = type(None)
>>> id(None)
10748000
>>> my_none = NoneType()
>>> id(my_none)
10748000
>>> another_none = NoneType()
>>> id(another_none)
10748000
>>> def function_that_does_nothing(): pass
>>> return_value = function_that_does_nothing()
>>> id(return_value)
10748000

None无法覆盖

在较旧版本的Python（2.4之前）中，可以重新分配None，但现在不行了。甚至不作为类属性或在函数的范围内。

# In Python 2.7
>>> class SomeClass(object):
...     def my_fnc(self):
...             self.None = 'foo'
SyntaxError: cannot assign to None
>>> def my_fnc():
        None = 'foo'
SyntaxError: cannot assign to None

# In Python 3.5
>>> class SomeClass:
...     def my_fnc(self):
...             self.None = 'foo'
SyntaxError: invalid syntax
>>> def my_fnc():
        None = 'foo'
SyntaxError: cannot assign to keyword

因此，可以安全地假设所有None引用都是相同的。没有“自定义”None。

要测试None，请使用is运算符

在编写代码时，您可能会尝试像这样测试Noneness：

if value==None:
    pass

或是测试像这样的谎言

if not value:
    pass

你需要理解其中的含义，以及为什么说清楚往往是个好主意。

案例1：测试值是否为None

为什么这么做

value is None

而不是

value==None

第一个相当于：

id(value)==id(None)

而表达式value==None实际上是这样应用的

value.__eq__(None)

如果值真的是None，那么您将得到您期望的结果。

>>> nothing = function_that_does_nothing()
>>> nothing.__eq__(None)
True

在大多数情况下，结果都是相同的，但是__eq__()方法打开了一扇大门，这扇大门将使对准确性的任何保证失效，因为它可以在类中重写以提供特殊的行为。

想想这个班。

>>> class Empty(object):
...     def __eq__(self, other):
...         return not other

所以你在None上试一下，它就起作用了

>>> empty = Empty()
>>> empty==None
True

但它也适用于空字符串

>>> empty==''
True

但是

>>> ''==None
False
>>> empty is None
False

案例2：使用None作为布尔值

以下两个测试

if value:
    # do something

if not value:
    # do something

实际上被评估为

if bool(value):
    # do something

if not bool(value):
    # do something

None是一个“false”，意味着如果强制转换为布尔值，它将返回False，如果应用not运算符，它将返回True。但是请注意，它不是None唯一的属性。除了False本身之外，该属性还由空列表、元组、集合、dict、字符串以及0以及实现__bool__()幻数方法以返回False的类中的所有对象共享。

>>> bool(None)
False
>>> not None
True

>>> bool([])
False
>>> not []
True

>>> class MyFalsey(object):
...     def __bool__(self):
...         return False
>>> f = MyFalsey()
>>> bool(f)
False
>>> not f
True

因此，当以以下方式测试变量时，请特别注意测试中包含或排除的内容：

def some_function(value=None):
    if not value:
        value = init_value()

在上面，您是指当值被特别设置为init_value()时调用init_value()，还是指设置为0的值、空字符串或空列表也应该触发初始化。就像我说的，小心点。在Python中，explicit通常比implicit好。

None实践中

None用作符号铝值

None在Python中有一个特殊的状态。它是最受欢迎的基线值，因为许多算法将其视为异常值。在这种情况下，它可以用作一个标志，表示条件需要一些特殊处理（例如设置默认值）。

您可以将None赋给函数的关键字参数，然后显式测试它。

def my_function(value, param=None):
    if param is None:
        # do something outrageous!

在尝试获取对象的属性时，可以将其作为默认值返回，然后在执行特殊操作之前显式测试该属性。

value = getattr(some_obj, 'some_attribute', None)
if value is None:
    # do something spectacular!

默认情况下，字典的get()方法在尝试访问不存在的密钥时返回None：

>>> some_dict = {}
>>> value = some_dict.get('foo')
>>> value is None
True

如果试图使用下标符号访问它，则会引发KeyError

>>> value = some_dict['foo']
KeyError: 'foo'

同样，如果您试图弹出一个不存在的项

>>> value = some_dict.pop('foo')
KeyError: 'foo'

您可以使用通常设置为None的默认值来抑制它

value = some_dict.pop('foo', None)
if value is None:
    # booom!

None用作标志和有效值

上面描述的None的用法适用于它不被视为有效值的情况，而更像是执行特殊操作的信号。然而，有些情况下，知道None来自何处有时很重要，因为即使它被用作信号，它也可能是数据的一部分。

当您使用getattr(some_obj, 'attribute_name', None)返回None查询对象的属性时，不会告诉您尝试访问的属性是设置为None还是完全不在对象中。同样的情况，当从像some_dict.get('some_key')这样的字典访问密钥时，您不知道some_dict['some_key']是否丢失，或者它是否刚刚设置为None。如果需要这些信息，通常的处理方法是直接尝试从try/except构造中访问属性或键：

try:
    # equivalent to getattr() without specifying a default
    # value = getattr(some_obj, 'some_attribute')
    value = some_obj.some_attribute
    # now you handle `None` the data here
    if value is None:
        # do something here because the attribute was set to None
except AttributeError:
    # we're now hanling the exceptional situation from here.
    # We could assign None as a default value if required.
    value = None 
    # In addition, since we now know that some_obj doesn't have the
    # attribute 'some_attribute' we could do something about that.
    log_something(some_obj)

与dict类似：

try:
    value = some_dict['some_key']
    if value is None:
        # do something here because 'some_key' is set to None
except KeyError:
    # set a default 
    value = None
    # and do something because 'some_key' was missing
    # from the dict.
    log_something(some_dict)

上面两个例子展示了如何处理对象和字典的情况，函数呢？同样的事情，但是我们使用双星号关键字参数：

def my_function(**kwargs):
    try:
        value = kwargs['some_key'] 
        if value is None:
            # do something because 'some_key' is explicitly 
            # set to None
    except KeyError:
        # we assign the default
        value = None
        # and since it's not coming from the caller.
        log_something('did not receive "some_key"')

None仅用作有效值

如果您发现您的代码中充斥着上述try/except模式，只是为了区分None标志和None数据，那么只需使用另一个测试值。存在这样一种模式，即在有效值集之外的值作为数据结构中数据的一部分插入，并用于控制和测试特殊条件（例如边界、状态等）。这样的值称为asentinel，它可以用None作为信号的方式使用。在Python中创建一个sentinel很简单。

undefined = object()

上面的undefined对象是唯一的，不会做任何程序感兴趣的事情，因此它是None作为标志的极好替代。一些警告适用，更多的是在代码之后。

有功能的

def my_function(value, param1=undefined, param2=undefined):
    if param1 is undefined:
        # we know nothing was passed to it, not even None
        log_something('param1 was missing')
        param1 = None


    if param2 is undefined:
        # we got nothing here either
        log_something('param2 was missing')
        param2 = None

带着迪克特

value = some_dict.get('some_key', undefined)
if value is None:
    log_something("'some_key' was set to None")

if value is undefined:
    # we know that the dict didn't have 'some_key'
    log_something("'some_key' was not set at all")
    value = None

带着一个物体

value = getattr(obj, 'some_attribute', undefined) 
if value is None:
    log_something("'obj.some_attribute' was set to None")
if value is undefined:
    # we know that there's no obj.some_attribute
    log_something("no 'some_attribute' set on obj")
    value = None

正如我之前提到的，定制哨兵会附带一些警告。首先，它们不是像None这样的关键字，所以python不保护它们。您可以随时覆盖上面的undefined，在定义它的模块中的任何地方，所以要注意如何公开和使用它们。接下来，由object()返回的实例不是单例，如果调用10次，您将得到10个不同的对象。最后，使用哨兵是非常特殊的。sentinel是特定于它所使用的库的，因此它的范围通常应该限制在库的内部。它不应该“泄露”出去。只有当外部代码的目的是扩展或补充库的API时，它们才应该意识到这一点。

网友
2楼 · 编辑于 2024-04-24 13:22:50

在Python中，“null”对象是singletonNone。

检查“不存在”的最佳方法是使用标识运算符is：

if foo is None:
    ...
网友
3楼 · 编辑于 2024-04-24 13:22:50

它不像其他语言那样被称为null，而是^{}。此对象始终只有一个实例，因此如果需要，可以检查与x is None（标识比较）的等价性，而不是x == None。

相关问题 更多 >

    编程相关推荐