Ответ 1

В Python объект "null" является singleton None.

Лучшим способом проверки вещей для "Noneness" является использование оператора тождества is:

if foo is None:
    ...

Ответ 2

Он не называется null, как на других языках, но None. Всегда есть только один экземпляр этого объекта, поэтому вы можете проверить эквивалентность с x is None (сравнение идентичности) вместо x == None, если хотите.

Ответ 3

None, Питон ноль?

Там нет null в Python, вместо этого None. Как было сказано уже самый точный способ проверить, что что - то не было дано None как значение использовать is оператор, который проверяет, что две переменные ссылаются на один и тот же объект.

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

Основы

Существует и может быть только один None

None является единственным экземпляром класса NoneType и любые дальнейшие попытки создания экземпляра этого класса будут возвращать тот же объект, что делает None одиночным. Новички в Python часто видят сообщения об ошибках, в которых упоминается NoneType и задаются вопросом, что это такое. По моему личному мнению, в этих сообщениях может быть просто упомянуто None по имени, потому что, как мы вскоре увидим, None оставляет мало места для двусмысленности. Так что если вы видите некоторые TypeError сообщение, которое указывает, что NoneType не может это сделать, или не можете сделать это, просто знаю, что это просто один None что не используется таким образом, что она не может.

Кроме того, None является встроенной константой, и как только вы запускаете Python, он доступен для использования везде, будь то в модуле, классе или функции. NoneType от NoneType, вам нужно сначала получить ссылку на него, запросив None для его класса.

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

Вы можете проверить уникальность None с помощью функции id() 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

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

При написании кода у вас может возникнуть соблазн проверить нонесс, как это:

if value==None:
    pass

Или проверить на ложь, как это

if not value:
    pass

Вы должны понимать последствия и почему это часто хорошая идея, чтобы быть явным.

Случай 1: проверка значения None

зачем это

value is None

скорее, чем

value==None

Первый эквивалентен:

id(value)==id(None)

Принимая во внимание, что value==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 а при применении оператора not он вернет True. Однако обратите внимание, что это не свойство, уникальное для None. Помимо самого False, свойство совместно используется пустыми списками, кортежами, наборами, диктовками, строками, а также 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() когда значение установлено специально на None, или вы имели в виду, что значение, равное 0, или пустая строка, или пустой список, также должны инициировать инициализацию. Как я уже сказал, будьте внимательны. Как это часто бывает в Python, явное лучше, чем неявное.

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 запись, KeyError бы 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 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 no obj.some_attribute
    log_something("no 'some_attribute' set on obj")
    value = None

Как я упоминал ранее, таможенные стражи идут с некоторыми оговорками. Во-первых, они не являются ключевыми словами, такими как None, поэтому python не защищает их. Вы можете перезаписать свой undefined выше в любое время, в любом месте модуля, который он определил, поэтому будьте осторожны с тем, как вы их выставляете и используете. Далее, экземпляр, возвращаемый object(), не является одноэлементным, если вы сделаете этот вызов 10 раз, вы получите 10 разных объектов. Наконец, использование часового очень своеобразно. Часовой является специфическим для библиотеки, в которой он используется, и поэтому его область действия, как правило, должна быть ограничена внутренними компонентами библиотеки. Это не должно "вытекать" наружу. Внешний код должен узнавать об этом, только если их целью является расширение или дополнение API библиотеки.

Ответ 4

В Python для представления отсутствия значения вы можете использовать значение None (types.NoneType.None) для объектов и "" (или len() == 0) для строк. Поэтому:

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

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

Относительно разницы между "==" и "is", тестирование для идентификации объекта с использованием "==" должно быть достаточным. Однако, поскольку операция "есть" определяется как операция идентификации объекта, вероятно, правильнее использовать ее, а не "==" . Не уверен, есть ли даже разница в скорости.

В любом случае, вы можете посмотреть:

• Python Встроенные константы doc.
• Python Проверка правды.

Ответ 5

Per Проверка значения истины, 'None' напрямую проверяется как FALSE, поэтому простейшего выражения будет достаточно:

if not foo:

Ответ 6

Как импортировать переменную, которой присвоено значение none, из другого файла?

Позвольте сказать;

v= 2
x = 3

def kk():

    return ''

y = None

or 
w = 2

e = 4

def ij():

    pass

class ur(bb):

    def __init__(self, arg)

    pass

d = None

Остальные значения импортируются, кроме переменной, которой присвоен тип none. Как импортировать тип "нет" из другого файла?