Python 中的空对象?

如何在 Python 中引用 null 对象?

答案

在 Python 中,“空” 对象是单例None

检查事物是否为 “无” 的最佳方法是使用身份运算符, is

if foo is None:
    ...

None ,Python 是否为空?

Python 中没有null ,而没有None 。如前所述的东西已经给出了最准确的方法来测试None作为一种价值是使用is身份运营商,测试,两个变量指向同一个对象。

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

基础

有且只能是一个None

NoneNoneType类的唯一实例,任何进一步实例化该类的尝试都将返回相同的对象,这使None成为单例。 Python 的新手经常看到提到NoneType错误消息,并想知道它是什么。这是我个人的看法是,这些消息可能只是简单地提到None以名,因为我们很快就会看到, None叶的小房间歧义。因此,如果您看到一些TypeError消息,其中提到NoneType无法执行此操作或无法执行该操作,则只知道它只是一个以无法使用的方式使用的None

另外, None是一个内置常量,一旦您启动 Python,它便可以在任何地方使用,无论是在模块,类还是函数中。相比之下, NoneType不是,您需要首先通过查询None作为其类来获取对其的引用。

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

您可以使用 Python 的标识函数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运算符

在编写代码时,您可能会想像这样来测试None

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是 “falsey”,这意味着如果强制转换为布尔值,它将返回False ;如果应用了not运算符,它将返回True 。但是请注意,它不是None独有的属性。除了False本身之外,该属性还由空列表,元组,集合,字典,字符串以及 0 以及实现__bool__()魔术方法以返回False类中的所有对象__bool__()

>>> 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()

在上面,您是要在将值专门设置为None时调用init_value() ,还是要将值设置为0 ,空字符串或空列表也触发初始化。就像我说的,要注意。通常在 Python 中, 显式要比隐式好

在实践中None

None用作信号值

在 Python 中, None一个具有特殊的地位。这是最喜欢的基准值,因为许多算法将其视为特殊值。在这种情况下,它可以用作标志,以表明某种情况需要某些特殊处理(例如,设置默认值)。

您可以将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)查询对象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)

上面的两个示例显示了如何处理对象和字典的情况,函数呢?同样,但是我们为此使用了 double asterisks 关键字参数:

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数据,则只需使用另一个测试值即可。有一种模式是,将超出有效值集的值作为数据的一部分插入数据结构中,并用于控制和测试特殊条件(例如边界,状态等)。这样的值称为哨兵 ,可以将None用作信号来使用。用 Python 创建一个哨兵很简单。

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 个不同的对象。最后,哨兵的使用是高度特质的。前哨特定于所使用的库,因此,其范围通常应限于库的内部。它不应该 “泄漏” 出去。仅当外部代码的目的是扩展或补充库的 API 时,外部代码才应意识到这一点。

它不像其他语言那样被称为 null,而是None 。此对象始终只有一个实例,因此您可以根据需要检查x is None (同一性比较),而不是x == None

在 Python 中,要表示缺少值,可以对对象使用None值( types.NoneType.None ),对字符串使用“” (或len()== 0 )。因此:

if yourObject is None:  # if yourObject == None:
    ...

if yourString == "":  # if yourString.len() == 0:
    ...

关于 “==” 和 “is” 之间的区别,使用 “==” 测试对象身份就足够了。但是,由于将 “is” 操作定义为对象标识操作,因此使用它而不是 “==” 可能更正确。不知道是否存在速度差异。

无论如何,您可以看一下:

Per Truth 值测试 ,“None” 直接测试为 FALSE,因此最简单的表达式就足够了:

if not foo: