Как объявить переменную в python без значения

Переменные в Python

Переменные — важная часть любого языка программирования. Они позволяют хранить, использовать и передавать данные.

Переменные позволяют не только удобно манипулировать данными, но и разделять их на типы, с которыми можно работать по определённым правилам. В Python они подчиняются концепциям, используемым в других языках программирования, однако они также имеют особенности, например, тип явно не объявляется.

Создание и присвоение значений

Создание переменной в Python 3 отличается от других языков программирования. Её не нужно заранее объявлять, указывать её тип, она создается в момент присваивания значения.

Чтобы создать переменную, используется символ равенства «=». Слева от которого пишут наименование, а справа — значение нужного типа. Пример:

Динамическая типизация

Такое создание переменных возможно благодаря динамической типизации.

Множественное присваивание и обмен значениями

Python позволяет программисту присвоить одно и то же значение нескольким переменным:

Кроме того, в отличие от других языков программирования Python позволяет обменять значения двух переменных —

Такая операция возможна, потому что Python используется кортеж, в который помещает значения, чтобы можно было поменять их местами.

Имена

В именах переменных в Python 3 можно использовать только буквы, цифры и символы подчеркивания. Цифры можно использовать в любой части имени, кроме начала.

И если синтаксис накладывает на программиста мало ограничений, то IT сообщество требует «хороших» имён для переменных:

• Имя должно описывать назначение. Так как код может перечитываться и изменяться множество раз, названия переменных должны быть такими, чтобы по ним можно было понять, что она хранит и для чего используется.
• Не нужно использовать транслит. Если программист хочет создать переменную, хранящую возраст программиста, он должен писать не «vozrast», а «age». Это обусловлено тем, что английский — самый используемый язык в IT, название на английском поймут все, в любом случае, можно воспользоваться переводчиком.
• Приемлемая длина. Имя должно не только отражать суть, но и быть коротким, слишком длинные названия увеличивают объем кода и ухудшают его восприятие.

Для создания хороших имён используются следующие методы:

• CamelCase (верблюжий регистр): первое слово начинается с маленькой буквы, а следующие за ним с большой. В Python CamelCase принято использовать для имён классов. Например: WorkersOfFactory .
• Snake Case: имя состоит из слов, разделенных символом подчеркивания «_», каждое слово пишут с маленькой буквы, например, hello_world . В Python Snake Case используется для имён функций, модулей и переменных. Такой стиль записи воспринимается лучше, чем CamelCase. Кроме того, он имеет несколько вариаций, которые не используются в Python: таких как запись через дефис «-» (kind-of-animals) и запись каждого слова с большой буквы (Sorted-Array-Of-Names).

Зарезервированные имена (ключевые слова)

Полный список ключевых слов можно посмотреть, набрав в интерпретаторе Python команду: help(«keywords») .

Вывод в консоль

Чтобы вывести переменную на экран, используют функцию print(). С её помощью можно вывести значение одной или нескольких переменных в форматированном выводе. Есть несколько вариантов синтаксиса вывода:

• print(«<> — число, <> — слово».format(number, word)). Например, переменная number хранит значение 5, а word хранит «пять», тогда на экран выведется: «5 — число, пять — слово».
• Можно обойтись без использования .format, достаточно писать составные части вывода через запятую: print(number, » — число», word, » — слово»).

Пустая переменная

Переменная — это ссылка на какой-то объект, она не может не содержать совсем ничего. Если программист хочет сделать его пустой (условно пустой), он присваивает ей значение None .

None используется в случаях, когда значение не определено, не существует. И хотя он не эквивалентен какому-либо значению типа bool, строке или числу, он также является объектом.

При необходимости, можно проверить содержимое переменной следующим образом:

Может использоваться, например, когда мы в переменной храним указатель на открытый файл. И когда мы этот файл закрываем, то присваиваем указателю значение None. В дальнейшем можно проверять будет перед записью или чтением данных, является ли переменная пустой.

Области видимости

В Python есть глобальная и локальная область видимости. Объявление переменных в разных областях видимости помогает избежать пересечения имён, открывает программисту новые уровни взаимодействий между ними и делает код более безопасным, делая невозможным несанкционированный доступ к механизмам работы функций.

Глобальная область видимости — это тело исполняемого скрипта. К любой переменной, объявленной в ней, можно получить доступ из любой части программы, даже из другого модуля.

Чтобы получить доступ к глобальной переменной из функции, необходимо использовать ключевое слово global, оно показывает интерпретатору, что нужно использовать находящуюся в глобальной области видимости. Кроме того, если функция не находит в своём теле нужную переменную, она автоматически ищет её в глобальной области видимости скрипта и использует.

Локальная область видимости недоступна для редактирования из вне, любая переменная, объявленная внутри функции будет находиться в локальной области видимости, это позволяет использовать одно и то же имя много раз в одной программе, защитить функцию от ненужных изменений и упростить написание кода.

В 3 версии Python было добавлено ключевое слово nonlocal . Оно позволяет получить доступ к переменной из локальной области видимости функции, при условии, что программист пытается получить доступ из другой вложенной функции. Пример:

Удаление

Для удаления переменной в Python 3 можно воспользоваться функцией del() , в качестве аргумента в которую нужно передать её имя. Пример:

Заключение

Python даёт программисту все необходимое для работы с переменными, он предоставляет и такие инструменты, которых нет в других языках программирования, например, обмен значений.

Python делает работу с переменными очень простой, он позволяет не объявлять их типы, присваивать уже существующей значение другого типа и поддерживает работу с областями видимости.

Класс None в Python

В Python ничего не используется для определения нулевых переменных и объектов. None не является экземпляром класса NoneType.

Этот класс является одноэлементным, что означает, что может быть только один его экземпляр. Фактически, все переменные, которым присвоено значение none, указывают на один и тот же объект в Python.

1. Отсутствие объявления и назначения

Начнем с объявления переменной и присвоения ей значения None. Запустите следующую строку кода в записной книжке Python.

Теперь мы можем продолжить и напечатать значение переменной.

На выходе мы получаем «None».

2. Печать «type» переменной, присвоенной None

Как вы думаете, какой тип переменной должен быть назначен None?

Распечатаем его, используя следующую строку кода:

Мы получаем результат как:

Это соответствует тому, что мы обсуждали выше. Переменная, присвоенная None, указывает на экземпляр класса NoneType.

Существует только один экземпляр класса NoneType, поэтому все переменные, для которых установлено значение NULL, указывают на один и тот же объект.

Фактически, мы можем сравнить идентификаторы двух разных переменных, для которых установлено значение None.

Мы видим, что None, a и b имеют одинаковые идентификаторы объектов.

3. Сравнение переменной со значением None

Давайте воспользуемся оператором ‘==’ и ‘is’ для сравнения переменной, для которой установлено значение None.

Вы также можете использовать None в качестве условия в операторах if. Посмотрим, как это сделать.

4. Использование с условными операторами

Давайте использовать переменные, для которых установлено значение None в условиях If.

Мы видим, что переменная, установленная как None, работает как false. Мы можем использовать это для проверки переменных, для которых установлено значение None в наших программах.

Вы также можете использовать условие с «Not».

5. Отсутствие возврата из функции

Если мы не устанавливаем возвращаемое значение для функции, то по умолчанию возвращается None.

Мы можем проверить это с помощью следующего фрагмента кода:

Идентификатор в выходных данных такой же, как идентификаторы, которые были напечатаны выше.

Заключение

Это краткое руководство было посвящено None in Python. Мы установили, что все переменные, для которых установлено значение None, указывают на один и тот же экземпляр класса NoneType. Мы также рассмотрели, как использовать тип данных None в качестве условия в операторах If.

Возможно ли только объявить переменную без присвоения какого-либо значения в Python?

так что он инициализирован None? Кажется, что Python позволяет это, но как только вы обращаетесь к нему, он дает сбой. Это возможно? Если нет, то почему?

РЕДАКТИРОВАТЬ: Я хочу сделать это для таких случаев:

Дублировать

(того же автора) (того же автора)

Похожие страницы:

задан 19 марта ’09, 20:03

Можете выложить небольшую программу, которая вызывает это, пожалуйста. — Preet Sangha

Вы разместили повторяющийся вопрос, голосуя за закрытие этого вопроса в пользу другого. — Jerub

Есть еще некоторая разница, здесь речь идет о невозможности использовать переменную просто путем объявления. — Joan Venge

Как объясняет ваш первый вопрос, на самом деле нет такой вещи, как объявление переменной в мире Python. — Harley Holcombe

почему никто никогда не сказал «просто присвоить ему», потому что переменные не существуют до того, как они будут присвоены периоду. И переменные в python не содержат информацию о типе. Объекты делают это. Переменные предназначены только для удержания объекта в этот момент времени. Кроме того, приведенная выше программа должна выдать исключение NameError в первой строке. (Это то, что я получаю как в 2.X, так и в 3.X) — osirisgothra

14 ответы

Почему бы просто не сделать это:

Python является динамическим, поэтому вам не нужно ничего объявлять; они существуют автоматически в первой области, в которой они назначены. Итак, все, что вам нужно, это обычный старый оператор присваивания, как указано выше.

Это хорошо, потому что вы никогда не получите неинициализированную переменную. Но будьте осторожны — это не значит, что вы не получите неверно инициализированные переменные. Если вы что-то инициализируете None , убедитесь, что это то, что вы действительно хотите, и назначьте что-нибудь более значимое, если сможете.

ответ дан 19 мар ’09, в 22:03

Я собирался это сделать, но просто неявно думал, что так и будет. — Джоан Венге

Дело в том, чтобы это было явным, а не неявным. Не гадать, каково начальное значение. Неудивительно, что неинициализированная переменная вызывает исключение или волшебным образом имеет полезное значение. — С.Лотт

Единственная проблема, с которой я столкнулся, заключалась в том, что я отслеживал счетчик (minValue), и каждый раз, когда значение было ниже, я устанавливал его как новое minValue. Если я изначально объявил minValue как None, то, по-видимому, он все равно ниже любых чисел, с которыми я его сравнивал. В итоге я просто инициализировал его на sys.maxint — Ти Джей Биддл

. они существуют автоматически в первой области, в которой они назначены. Итак, вам нужно выследить это первое задание и понять его. фу! — Эд Рэндалл

Я искренне рекомендую вам прочитать В других языках есть «переменные» (Я добавил это как связанную ссылку) — через две минуты вы узнаете, что у Python есть «имена», а не «переменные».

ответ дан 04 мар ’15, в 21:03

Вы также можете написать val = val or any_object для его инициализации. — Золтан

@ Zoltán: он прерывается, если допустимое значение val равно «false», например, ноль или пусто. Использовать is чтобы проверить, является ли значение None . — JFS

После прочтения статьи по предоставленной ссылке она кажется не более чем семантической софистикой. — Андрей П.

В Python 3.6+ для этого можно использовать аннотации переменных:

PEP 484 представил подсказки типов, также известные как аннотации типов. Хотя основное внимание уделялось аннотациям функций, в нем также было введено понятие комментариев типа для аннотирования переменных:

PEP 526 направлен на добавление синтаксиса в Python для аннотирования типов переменных (включая переменные класса и переменные экземпляра) вместо их выражения в комментариях:

Кажется, это более точно соответствует тому, что вы спрашивали: «Можно ли только объявить переменную без присвоения какого-либо значения в Python?»

Я не уверен, что вы пытаетесь сделать. Python — очень динамичный язык; обычно вам не нужно объявлять переменные, пока вы не собираетесь их назначать или использовать. Я думаю, что ты хочешь просто

который присвоит значение None к переменной foo .

РЕДАКТИРОВАТЬ: Что вы на самом деле похоже, хочу сделать вот что:

На примере такого короткого кода немного сложно сказать, действительно ли это правильный стиль, но он is более «питонический» способ работы.

РЕДАКТИРОВАТЬ: ниже комментарий JFS (размещен здесь, чтобы показать код)

Не имеет отношения к вопросу OP, но приведенный выше код можно переписать как:

ПРИМЕЧАНИЕ: если some_condition() вызывает исключение, тогда found не связан.
ПРИМЕЧАНИЕ: если len (sequence) == 0, то item не связан.

Приведенный выше код не рекомендуется. Его цель — проиллюстрировать, как работают локальные переменные, а именно, «определена ли» переменная, может быть определено только во время выполнения в этом случае. Предпочтительный способ:

ответ дан 20 мар ’09, в 07:03

Есть ли разница между динамическим языком и очень динамичным языком? — Гэвин Миллер

Есть отличная статья, объясняющая различные оси типизации языка программирования и то, как они являются континуумами, а не логическими значениями; к сожалению, я никогда не смогу найти эту статью снова, когда захочу процитировать ее 🙁 Я считаю Python «очень динамичным», потому что он находится на дальнем конце нескольких осей. — Kquinn

Что ж, если вы хотите проверить, определена ли переменная или нет, то почему бы не проверить, есть ли она в массивах locals () или globals ()? Ваш код переписан:

Если вы ищете локальную переменную, замените globals () на locals ().

Обычно я инициализирую переменную чем-то, что обозначает тип, например

Если это будет объект, не инициализируйте его, пока не создадите его экземпляр:

ответ дан 19 мар ’09, в 22:03

Прежде всего, мой ответ на вопрос, который вы изначально задали.

В: Как узнать, определена ли переменная в каком-то месте моего кода?

A: Читайте исходный файл, пока не увидите строку, в которой определена эта переменная.

Но, кроме того, вы привели пример кода, в котором есть различные варианты, которые довольно питоничны. Вам нужен способ сканирования последовательности элементов, соответствующих условию, поэтому вот несколько решений:

Очевидно, что в этом примере вы можете заменить raise с return None в зависимости от того, чего вы хотели достичь.

Если вам нужно все, что соответствует условию, вы можете сделать это:

Есть еще один способ сделать это с помощью yield что я не буду показывать вам, потому что это довольно сложно в том, как это работает.

Присваивание переменным в Python значения None

Является ли хорошим тоном присваивание переменным в Python значения None? Допустим, у меня есть переменная n, в которую я хочу занести какое-то значение из списка k, путём перебора циклом и проверки условия. Но я хочу и дальше использовать переменную n в своей программе. Как я знаю, в Python при объявлении переменной обязательна инициализация, но я не знаю каким значением её инициализировать. Правильна ли такая практика?

Решил написать ответ, потому что все-таки есть случаи, когда инициализация переменных значением None имеет смысл.

Как я знаю, в Python при объявлении переменной обязательна инициализация.

Начиная с Python 3.6 можно объявлять переменные с аннотацией типа без инициализации:

Но тогда для проверки "инициализированности" переменной (для локальной или глобальной переменной, не поля класса) придется использовать конструкцию ‘some_var’ in locals() или ‘some_var’ in globals() , что не очень красиво, ИМХО (вообще практически никогда не стоит использовать locals() и globals() ). Если проверять заполненность переменной не нужно, то это неплохой вариант (но объявление с инициализацией лучше).

Для проверки полей класса можно использовать hasattr , что на мой взгляд вполне допустимо (см. п.3 ниже).

В целом нет никаких правил, запрещающих инициализировать переменную значением None . Типичные варианты использования:

Начальное значение переменной в которую будет будет записано одно из значений из последовательности при проходе по ней циклом. Типичный пример — начальное значение для максимума/минимума последовательности по какому-то критерию (можно конечно брать значение первого элемента за минимум/максимум, но тогда сначала нужно проверить, что последовательность не пустая)

Начальное/неопределенное состояние для конечного автомата

Начальные значения при "объявлении" полей объекта внутри метода __init__ . Например PyCharm фактически требует, чтобы все поля объекта были инициализированы внутри __init__ (попытку записи в поле не объявленное внутри __init__ PyCharm выделяет как предупреждение). Можно было бы на это правило и забить (отключить в настройках), но в этом есть смысл — удобно, когда все поля объекта объявлены в одном месте.

В этом случае также имеет смысл аннотацией показывать предполагаемый тип поля:

Также начиная с Python 3.6 поля можно объявлять с аннотацией типа просто как self.a: int без инициализации, инициализированность поля в этом случае можно проверять с помощью hasattr(self, ‘a’) (не факт что это хороший вариант, я бы все-таки использовал вариант с инициализацией None ).

Думаю, это не все варианты, возможно что-то забыл.

Также нужно понимать, что инициализация переменной значением None "на всякий случай" не убережет вас от невнимательности, и вместо падения программы с исключением NameError или AttributeError у вас может вылезти значение None там где оно совсем не ожидалось, и возможно будет сложнее отловить откуда оно взялось, чем в случае выбрасывания исключения (см. принцип Fail Fast). Я бы рекомендовал по возможности инициализировать переменные вменяемыми значениями, а не None .