问题：什么是无值？
我一直在研究Python，并且阅读了一章描述了它的None价值，但不幸的是，这本书在某些方面并不十分清楚。我认为，如果我在那分享我的问题，我会找到答案。
我想知道None价值是什么，您将其用于什么？
而且，我没有得到本书的这一部分：
将值None赋给变量是将其重置为其原始的空状态的一种方法。
那是什么意思？
答案很棒，尽管由于我对计算机世界的了解不足（我还没有了解类，对象等），所以我对大多数答案都不了解。这句话是什么意思？
将值None赋给变量是将其重置为其原始的空状态的一种方法。
最后：
最后，我从寻找不同的答案中得到了答案。我必须感谢所有抽出宝贵时间来帮助我的人（尤其是Martijn Pieters和DSM），我希望我可以选择所有答案作为最佳答案，但是选择仅限于一个。所有的答案都很好。
I have been studying Python, and I read a chapter which describes the None value, but unfortunately this book isn’t very clear at some points. I thought that I would find the answer to my question, if I share it there.
I want to know what the None value is and what do you use it for?
And also, I don’t get this part of the book:
Assigning a value of None to a variable is one way to reset it to
its original, empty state.
What does that mean?
The answers were great, although I didn’t understand most of answers due to my low knowledge of the computer world (I haven’t learned about classes, objects, etc.). What does this sentence mean?
Assigning a value of None to a variable is one way to reset it
to its original, empty state.
Final:
Finally I’ve got my answer from looking to different answers. I must appreciate all the people who put their times to help me (especially Martijn Pieters and DSM), and I wish that I could choose all answers as the best, but the selection is limited to one. All of the answers were great.
回答 0
Martijn的答案解释了NonePython中的内容，并正确指出该书具有误导性。由于Python程序员通常不会说
将值None赋给变量是将其重置为其原始的空状态的一种方法。
很难以一种有意义的方式来解释布里格斯的意思，并解释为什么这里没有人对此感到满意。一个类推可能会有所帮助：
在Python中，变量名称就像贴在对象上的标签。每个标签上都有一个唯一的名称，并且一次只能在一个对象上，但是如果需要，您可以在同一对象上放置多个标签。当你写
F = "fork"
您将标签“ F”放在字符串对象上"fork"。如果你再写
F = None
您将标签移动到None对象。
Briggs想让您想象的是，您没有写贴纸"F"，但已经在F贴纸上了None，您所做的就是将其从None移到"fork"。因此F = None，如果我们决定将其None视为，则在键入时，您会将其“重置为原始的空状态” empty state。
我可以看到他的意思，但这是一种不好的观察方式。如果启动Python并输入print(F)，则会看到
>>> print(F)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'F' is not defined
这NameError意味着Python无法识别这个名字F，因为没有这样的标签。如果Briggs是正确的并且F = None重置F为原始状态，那么它应该现在在那里，并且我们应该看到
>>> print(F)
None
就像我们在键入F = None并贴上贴纸后所做的一样None。
这就是所有的事情。实际上，Python附带了一些已经粘贴到对象上的标签（内置名称），但是其他一些标签则需要使用诸如F = "fork"and A = 2和这样的行来编写c17 = 3.14，然后再将其粘贴在其他对象上（例如F = 10or F = None；它们都是一样的） ）
Briggs假装您可能要写的所有可能的贴纸均已粘贴到该None对象上。
Martijn’s answer explains what None is in Python, and correctly states that the book is misleading. Since Python programmers as a rule would never say
Assigning a value of None to a variable is one way to reset it to
its original, empty state.
it’s hard to explain what Briggs means in a way which makes sense and explains why no one here seems happy with it. One analogy which may help:
In Python, variable names are like stickers put on objects. Every sticker has a unique name written on it, and it can only be on one object at a time, but you could put more than one sticker on the same object, if you wanted to. When you write
F = "fork"
you put the sticker “F” on a string object "fork". If you then write
F = None
you move the sticker to the None object.
What Briggs is asking you to imagine is that you didn’t write the sticker "F", there was already an F sticker on the None, and all you did was move it, from None to "fork". So when you type F = None, you’re “reset[ting] it to its original, empty state”, if we decided to treat None as meaning empty state.
I can see what he’s getting at, but that’s a bad way to look at it. If you start Python and type print(F), you see
>>> print(F)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'F' is not defined
and that NameError means Python doesn’t recognize the name F, because there is no such sticker. If Briggs were right and F = None resets F to its original state, then it should be there now, and we should see
>>> print(F)
None
like we do after we type F = None and put the sticker on None.
So that’s all that’s going on. In reality, Python comes with some stickers already attached to objects (built-in names), but others you have to write yourself with lines like F = "fork" and A = 2 and c17 = 3.14, and then you can stick them on other objects later (like F = 10 or F = None; it’s all the same.)
Briggs is pretending that all possible stickers you might want to write were already stuck to the None object.
回答 1
None只是通常用于表示“空”或“此处无值”的值。它是一个信号对象 ; 它仅具有含义，因为Python文档说明了它的含义。
在给定的Python解释器会话中，该对象只有一个副本。
例如，如果您编写一个函数，但该函数不使用显式return语句，None则返回该函数。这样，使用函数进行编程就大大简化了；一个函数总是返回某些东西，即使它只是那个None对象。
您可以明确地对其进行测试：
if foo is None:
# foo is set to None
if bar is not None:
# bar is set to something *other* than None
另一个用途是为函数提供可选参数，默认为“空”：
def spam(foo=None):
if foo is not None:
# foo was specified, do something clever!
该函数spam()有一个可选参数。如果在spam()未指定的情况下进行调用，则会为其指定默认值None，从而易于检测是否使用参数调用了该函数。
其他语言也有类似的概念。SQL有NULL; JavaScript具有undefined 和 null，等等。
请注意，在Python中，变量通过使用而存在。您无需先声明变量，因此Python 中没有真正的空变量。那么，将变量设置None为与将其设置为默认的空值是不同的。None也是一个值，尽管该值通常用于表示空白。您正在阅读的书在这一点上具有误导性。
None is just a value that commonly is used to signify ’empty’, or ‘no value here’. It is a signal object; it only has meaning because the Python documentation says it has that meaning.
There is only one copy of that object in a given Python interpreter session.
If you write a function, and that function doesn’t use an explicit return statement, None is returned instead, for example. That way, programming with functions is much simplified; a function always returns something, even if it is only that one None object.
You can test for it explicitly:
if foo is None:
# foo is set to None
if bar is not None:
# bar is set to something *other* than None
Another use is to give optional parameters to functions an ’empty’ default:
def spam(foo=None):
if foo is not None:
# foo was specified, do something clever!
The function spam() has a optional argument; if you call spam() without specifying it, the default value None is given to it, making it easy to detect if the function was called with an argument or not.
Other languages have similar concepts. SQL has NULL; JavaScript has undefined and null, etc.
Note that in Python, variables exist by virtue of being used. You don’t need to declare a variable first, so there are no really empty variables in Python. Setting a variable to None is then not the same thing as setting it to a default empty value; None is a value too, albeit one that is often used to signal emptyness. The book you are reading is misleading on that point.
回答 2
这就是Python文档必须说的None：
types.NoneType的唯一值。当没有将默认参数传递给函数时，通常不使用None来表示缺少值。
在版本2.4中更改：分配为None是非法的，并引发SyntaxError。
注意不能重新分配名称None和debug（分配给它们，即使作为属性名称，也会引发SyntaxError），因此可以将它们视为“ true”常量。
让我们确认None第一个的类型
print type(None)
print None.__class__
输出量
<type 'NoneType'>
<type 'NoneType'>
基本上，NoneType数据类型与int，float等类似。您可以在8.15中查看Python中可用的默认类型列表。types —内置类型的名称。
并且，None是NoneType类的实例。因此，我们可能要创建None自己的实例。让我们尝试一下
print types.IntType()
print types.NoneType()
输出量
0
TypeError: cannot create 'NoneType' instances
很明显，无法创建NoneType实例。我们不必担心价值的独特性None。
让我们检查一下我们是如何None内部实现的。
print dir(None)
输出量
['__class__', '__delattr__', '__doc__', '__format__', '__getattribute__',
'__hash__', '__init__', '__new__', '__reduce__', '__reduce_ex__',
'__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
除了__setattr__，所有其他均为只读属性。因此，我们无法更改的属性None。
让我们尝试为添加新属性 None
setattr(types.NoneType, 'somefield', 'somevalue')
setattr(None, 'somefield', 'somevalue')
None.somefield = 'somevalue'
输出量
TypeError: can't set attributes of built-in/extension type 'NoneType'
AttributeError: 'NoneType' object has no attribute 'somefield'
AttributeError: 'NoneType' object has no attribute 'somefield'
上面看到的语句分别产生这些错误消息。这意味着，我们不能在None实例上动态创建属性。
让我们检查一下分配东西时会发生什么None。根据文档，它应该抛出SyntaxError。这意味着，如果我们向分配了某些内容None，则该程序将根本不会执行。
None = 1
输出量
SyntaxError: cannot assign to None
我们已经确定
None 是…的实例 NoneTypeNone 不能有新属性- 的现有属性
None无法更改。
- 我们无法创建的其他实例
NoneType
- 我们甚至不能通过
None给它分配值来更改对它的引用。
因此，如文档中所述，None实际上可以将其视为true constant。
很高兴知道None:)
This is what the Python documentation has got to say about None:
The sole value of types.NoneType. None is frequently used to represent
the absence of a value, as when default arguments are not passed to a
function.
Changed in version 2.4: Assignments to None are illegal and raise a
SyntaxError.
Note The names None and debug cannot be reassigned (assignments to
them, even as an attribute name, raise SyntaxError), so they can be
considered “true” constants.
Let’s confirm the type of None first
print type(None)
print None.__class__
Output
<type 'NoneType'>
<type 'NoneType'>
Basically, NoneType is a data type just like int, float, etc. You can check out the list of default types available in Python in 8.15. types — Names for built-in types.
And, None is an instance of NoneType class. So we might want to create instances of None ourselves. Let’s try that
print types.IntType()
print types.NoneType()
Output
0
TypeError: cannot create 'NoneType' instances
So clearly, cannot create NoneType instances. We don’t have to worry about the uniqueness of the value None.
Let’s check how we have implemented None internally.
print dir(None)
Output
['__class__', '__delattr__', '__doc__', '__format__', '__getattribute__',
'__hash__', '__init__', '__new__', '__reduce__', '__reduce_ex__',
'__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
Except __setattr__, all others are read-only attributes. So, there is no way we can alter the attributes of None.
Let’s try and add new attributes to None
setattr(types.NoneType, 'somefield', 'somevalue')
setattr(None, 'somefield', 'somevalue')
None.somefield = 'somevalue'
Output
TypeError: can't set attributes of built-in/extension type 'NoneType'
AttributeError: 'NoneType' object has no attribute 'somefield'
AttributeError: 'NoneType' object has no attribute 'somefield'
The above seen statements produce these error messages, respectively. It means that, we cannot create attributes dynamically on a None instance.
Let us check what happens when we assign something None. As per the documentation, it should throw a SyntaxError. It means, if we assign something to None, the program will not be executed at all.
None = 1
Output
SyntaxError: cannot assign to None
We have established that
None is an instance of NoneTypeNone cannot have new attributes- Existing attributes of
None cannot be changed.
- We cannot create other instances of
NoneType
- We cannot even change the reference to
None by assigning values to it.
So, as mentioned in the documentation, None can really be considered as a true constant.
Happy knowing None :)
回答 3
您所指的书显然是试图大大简化的含义None。Python的变量不具备初始，空状态- Python的变量绑定（只），他们定义的时候。如果不给它一个值，就不能创建一个Python变量。
>>> print(x)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'x' is not defined
>>> def test(x):
... print(x)
...
>>> test()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: test() takes exactly 1 argument (0 given)
>>> def test():
... print(x)
...
>>> test()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 2, in test
NameError: global name 'x' is not defined
但是有时候您想让一个函数根据变量是否定义而具有不同的含义。您可以创建默认值为的参数None：
>>> def test(x=None):
... if x is None:
... print('no x here')
... else:
... print(x)
...
>>> test()
no x here
>>> test('x!')
x!
None在这种情况下，此值是特殊值并不十分重要。我可以使用任何默认值：
>>> def test(x=-1):
... if x == -1:
... print('no x here')
... else:
... print(x)
...
>>> test()
no x here
>>> test('x!')
x!
…但是None到处都有给我们带来两个好处：
- 我们不必选择
-1含义不明确的特殊值，并且
- 实际上，我们的函数可能需要
-1作为普通输入处理。
>>> test(-1)
no x here
哎呀！
因此，这本书在使用“ 重设 ”一词时通常会产生一些误导–分配None名称是向程序员发出信号，表明该值未在使用中，或者该函数应以某种默认方式运行，但需要重设一个值要恢复其原始的未定义状态，您必须使用del关键字：
>>> x = 3
>>> x
3
>>> del x
>>> x
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'x' is not defined
The book you refer to is clearly trying to greatly simplify the meaning of None. Python variables don’t have an initial, empty state – Python variables are bound (only) when they’re defined. You can’t create a Python variable without giving it a value.
>>> print(x)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'x' is not defined
>>> def test(x):
... print(x)
...
>>> test()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: test() takes exactly 1 argument (0 given)
>>> def test():
... print(x)
...
>>> test()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 2, in test
NameError: global name 'x' is not defined
but sometimes you want to make a function mean different things depending on whether a variable is defined or not. You can create an argument with a default value of None:
>>> def test(x=None):
... if x is None:
... print('no x here')
... else:
... print(x)
...
>>> test()
no x here
>>> test('x!')
x!
The fact that this value is the special None value is not terribly important in this case. I could’ve used any default value:
>>> def test(x=-1):
... if x == -1:
... print('no x here')
... else:
... print(x)
...
>>> test()
no x here
>>> test('x!')
x!
…but having None around gives us two benefits:
- We don’t have to pick a special value like
-1 whose meaning is unclear, and
- Our function may actually need to handle
-1 as a normal input.
>>> test(-1)
no x here
oops!
So the book is a little misleading mostly in its use of the word reset – assigning None to a name is a signal to a programmer that that value isn’t being used or that the function should behave in some default way, but to reset a value to its original, undefined state you must use the del keyword:
>>> x = 3
>>> x
3
>>> del x
>>> x
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'x' is not defined
回答 4
其他答案已经很好地解释了None的含义。但是，我仍然想通过一个例子对此进行更多说明。
例：
def extendList(val, list=[]):
list.append(val)
return list
list1 = extendList(10)
list2 = extendList(123,[])
list3 = extendList('a')
print "list1 = %s" % list1
print "list2 = %s" % list2
print "list3 = %s" % list3
现在尝试猜测上面列表的输出。好吧，答案令人惊讶地如下：
list1 = [10, 'a']
list2 = [123]
list3 = [10, 'a']
但为什么？
许多人会错误地期望list1等于[10]，list3等于[‘a’]，以为每次调用extendList时，list参数将被设置为其默认值[]。
但是，实际发生的情况是，在定义函数时，仅会创建一次新的默认列表，然后在每次调用extendList且未指定list参数的情况下都使用同一列表。这是因为默认参数中的表达式是在定义函数时计算的，而不是在调用函数时计算的。
因此，list1和list3在同一默认列表上运行，而list2在它创建的单独列表上运行（通过传递其自己的空列表作为list参数的值）。
“无”救星：（修改上面的示例以产生所需的行为）
def extendList(val, list=None):
if list is None:
list = []
list.append(val)
return list
list1 = extendList(10)
list2 = extendList(123,[])
list3 = extendList('a')
print "list1 = %s" % list1
print "list2 = %s" % list2
print "list3 = %s" % list3
使用此修订的实现，输出将是：
list1 = [10]
list2 = [123]
list3 = ['a']
注意 -贷记至toptal.com的示例
Other answers have already explained meaning of None beautifully. However, I would still like to throw more light on this using an example.
Example:
def extendList(val, list=[]):
list.append(val)
return list
list1 = extendList(10)
list2 = extendList(123,[])
list3 = extendList('a')
print "list1 = %s" % list1
print "list2 = %s" % list2
print "list3 = %s" % list3
Now try to guess output of above list. Well, the answer is surprisingly as below:
list1 = [10, 'a']
list2 = [123]
list3 = [10, 'a']
But Why?
Many will mistakenly expect list1 to be equal to [10] and list3 to be equal to [‘a’], thinking that the list argument will be set to its default value of [] each time extendList is called.
However, what actually happens is that the new default list is created only once when the function is defined, and that same list is then used subsequently whenever extendList is invoked without a list argument being specified. This is because expressions in default arguments are calculated when the function is defined, not when it’s called.
list1 and list3 are therefore operating on the same default list, whereas list2 is operating on a separate list that it created (by passing its own empty list as the value for the list parameter).
‘None’ the savior: (Modify example above to produce desired behavior)
def extendList(val, list=None):
if list is None:
list = []
list.append(val)
return list
list1 = extendList(10)
list2 = extendList(123,[])
list3 = extendList('a')
print "list1 = %s" % list1
print "list2 = %s" % list2
print "list3 = %s" % list3
With this revised implementation, the output would be:
list1 = [10]
list2 = [123]
list3 = ['a']
Note – Example credit to toptal.com
回答 5
None is a singleton object (meaning there is only one None), used in many places in the language and library to represent the absence of some other value.
For example:
if d is a dictionary, d.get(k) will return d[k] if it exists, but None if d has no key k.
Read this info from a great blog: http://python-history.blogspot.in/
回答 6
所有这些都是很好的答案，但是我认为还有更多的原因可以解释None。
想象一下，您在婚礼上收集了RSVP。您想记录每个人是否参加。如果他们正在参加，请设置person.attending = True。如果他们不参加，您设置person.attending = False。如果尚未收到任何RSVP，则person.attending = None。这样，您可以区分无信息None和否定答案。
All of these are good answers but I think there’s more to explain why None is useful.
Imagine you collecting RSVPs to a wedding. You want to record whether each person will attend. If they are attending, you set person.attending = True. If they are not attending you set person.attending = False. If you have not received any RSVP, then person.attending = None. That way you can distinguish between no information – None – and a negative answer.
回答 7
我喜欢代码示例（以及水果），所以让我告诉你
apple = "apple"
print(apple)
>>> apple
apple = None
print(apple)
>>> None
没有意味着什么，没有价值。
没有一个计算结果为False。
I love code examples (as well as fruit), so let me show you
apple = "apple"
print(apple)
>>> apple
apple = None
print(apple)
>>> None
None means nothing, it has no value.
None evaluates to False.
回答 8
largest=none
smallest =none
While True :
num =raw_input ('enter a number ')
if num =="done ": break
try :
inp =int (inp)
except:
Print'Invalid input'
if largest is none :
largest=inp
elif inp>largest:
largest =none
print 'maximum', largest
if smallest is none:
smallest =none
elif inp<smallest :
smallest =inp
print 'minimum', smallest
print 'maximum, minimum, largest, smallest
largest=none
smallest =none
While True :
num =raw_input ('enter a number ')
if num =="done ": break
try :
inp =int (inp)
except:
Print'Invalid input'
if largest is none :
largest=inp
elif inp>largest:
largest =none
print 'maximum', largest
if smallest is none:
smallest =none
elif inp<smallest :
smallest =inp
print 'minimum', smallest
print 'maximum, minimum, largest, smallest
