Python中的null对象？-Java 学习之路

891

我如何在Python中引用null对象？

6 回答

0
在Python中，为了表示缺少值，可以对对象使用None值（types.NoneType.None），对字符串使用“”（或len（）== 0） . 因此：
```
if yourObject is None:  # if yourObject == None:
    ...

if yourString == "":  # if yourString.len() == 0:
    ...
```
关于“==”和“is”之间的区别，使用“==”测试对象标识应该足够了 . 但是，由于操作“is”被定义为对象标识操作，因此使用它可能更正确，而不是“==” . 不确定是否存在速度差异 .

无论如何，你可以看看：
- Python Built-in Constants doc页面 .
- Python Truth Value Testing doc页面 .
回复于 2024-04-25T02:40:18+08:00
1223
如何从另一个文件导入分配值为none的变量？

我们说吧;

v = 2 x = 3

def kk（）：
```
return ''
```
y =无

或w = 2

e = 4

def ij（）：
```
pass
```
class ur（bb）：
```
def __init__(self, arg)

pass
```
d =无其他值导入，但赋值为none类型的变量除外 . 如何从其他文件导入无类型？
回复于 2024-04-25T02:40:18+08:00
26
无，Python是null？

在Python中没有 null ，而是 None . 如前所述，测试某些东西的最准确方法是使用 None 身份运算符，该运算符测试两个变量引用同一个对象 .
```
>>> foo is None
True
>>> foo = 'bar' 
>>> foo is None
False
```
基础知识

只有一个没有

None 是类 NoneType 的唯一实例，并且实例化该类的任何进一步尝试都将返回相同的对象，这使 None 成为单例 . Python的新手经常会看到提及 NoneType 的错误消息，并想知道它是什么 . 我个人认为，这些消息可能只是简单地提及 None 因为，正如我们很快就会看到的那样， None 几乎没有任何模棱两可的余地 . 因此，如果你看到一些 TypeError 消息提到 NoneType 可以做到这一点，那就知道它只是一个以不可能的方式使用的 None .

此外， None 是一个内置常量，一旦启动Python，它就可以在任何地方使用，无论是在模块，类还是函数中 . 相比之下 NoneType 不是，你需要首先通过查询 None 来获取它的引用 .
```
>>> NoneType
NameError: name 'NoneType' is not defined
>>> type(None)
NoneType
```
你可以检查 None 's uniqueness with Python'的身份功能 id() . 它返回分配给对象的唯一编号，每个对象都有一个 . 如果两个变量的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
```
无法覆盖

在更旧版本的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 引用都是相同的 . 没有"custom" 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 是"falsey"，意味着如果强制转换为布尔值，它将返回 False ，如果应用 not 运算符，它将返回 True . 但请注意，它不是 None 独有的属性 . 除了 False 本身之外，该属性由空列表，元组，集合，dicts，字符串以及0以及实现 __bool__() magic方法的类中的所有对象共享以返回 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()
```
在上面，你的意思是当值专门设置为 None 时调用 init_value() ，或者你的意思是设置为 0 的值，或空字符串，或空列表也应该触发初始化 . 就像我说的那样，要小心 . 因为Python中的情况通常比隐式更好 .

在实践中没有

无用作信号值

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 来自哪里是很重要的，因为即使它被用作信号，它也可能是数据的一部分 .

当您使用 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)
```
以上两个例子说明了如何处理对象和字典的情况，函数怎么样？同样的事情，但我们使用双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"')
```
无仅用作有效值

如果您发现您的代码充满了上述 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个不同的对象 . 最后，使用哨兵是非常特殊的 . 哨兵特定于图书馆's used in and as such its scope should generally be limited to the library' s内部 . 它不应该是_197955的API .
回复于 2024-04-25T02:40:18+08:00
57
在Python中，'null'对象是单例 None .

检查"Noneness"的最佳方法是使用标识运算符 is ：
```
if foo is None:
    ...
```
回复于 2024-04-25T02:40:18+08:00
47

它不像其他语言那样被称为null，而是None . 此对象始终只有一个实例，因此如果需要，可以检查 x is None （身份比较）而不是 x == None 的等效性 .

回复于 2024-04-25T02:40:18+08:00
1
Per Truth value testing，'None'直接测试为FALSE，所以最简单的表达式就足够了：
```
if not foo:
```
回复于 2024-04-25T02:40:18+08:00

Python中的null对象？

6 回答

无，Python是null？

基础知识

只有一个没有

无法覆盖

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

案例1：测试值是否为None

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

在实践中没有

无用作信号值

无用作标志和有效值

无仅用作有效值

相关问题