Что такое переменная в python простым языком

Как работают переменные в Python

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

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

Но как теперь получить доступ к созданному объекту? 🤷‍♀️

Для этого и существуют переменные — они дают возможность удобно работать с объектами используя имена вместо адресов.

Простыми словами переменная в Python — это просто имя, прикрепленное к определенному объекту

a = 123 print(a) > 123 print(type(a)) print(id(a)) 1827204944

🍏 🍊 Приведем простую аналогию: Представьте, что у вас есть много непрозрачных бутылок, а сами вы занимаетесь производством фруктовых соков. Однажды вы выжали фрукты и в один сосуд налили апельсиновый сок, а во второй — яблочный. После этого ёмкости были запечатаны. Резонный вопрос: как теперь выяснить содержимое отдельно взятой бутылки?

Ответ: предварительно их подписать. Сделав это, вы будете точно знать, что находится в бутылках, а значит, сможете производить с ними дальнейшие операции: назначать цену, сортировать, отправлять на продажу и так далее.

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

Переменные, объекты и ссылки

Для понимания работы переменных, необходимо разобрать, что происходит, когда вы создаете новую переменную и присваиваете ей значение?

В данном примере происходит следующее:

Важно : переменная в Python не хранит значение напрямую — она хранит лишь ссылку на объект

Теперь посмотрим что произойдет, если одной переменой присвоить другую переменную:

b = a print(id(a)) > 1827204576 print(id(b)) > 1827204576

Предположим, что в какой-то момент вы захотели поменять значение переменной b :

b = 500 print(id(a)) > 1827204576 print(id(b)) > 56754272

В данном примере Python создал новый объект типа int, и теперь переменная b ссылается на новый объект.

Рассмотрим еще один пример:

b = «tree» print(id(b)) > 54134048

b = «tree», переменная b теперь ссылается на новый объект строкового типа

На объект типа int со значением 500 больше никто не ссылается. Следовательно, он больше не доступен и будет удален сборщиком мусора (тем самым освободим немного памяти).

Идентификатор объекта (Object Identity)

Идентификатор объекта — это адрес объекта в памяти.

a = b = 1 print(id(a)) > 1593636784 print(id(b)) > 1593636784 print(id(1)) > 1593636784

Видно, что объект здесь всего один. А a и b — по-разному названные переменные, которые на него ссылаются. Проверить равенство идентификаторов можно с помощью оператора is :

Работа с переменными

Именование переменных

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

Это жёсткий внутренний закон языка, помимо которого есть свод более мягких, но не менее важных правил, и они говорят нам:

Список зарезервированных слов

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

False, class, finally, is, return, None, continue, for, lambda, try, True, def, from, nonlocal, whileand, del, global, not, with, as, elif, if, or, yield, assert, else, import, pass, break, except, in, raise.

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

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

Импорт переменной в Python

Чтобы импортировать переменную из другого файла, используем в начале текущего файла следующую конструкцию:

# файл main.py space_ship = ‘Millenium Falcon’ # файл second.py from main import space_ship print(space_ship) > Millenium Falcon

Проверка существования переменной

Чтобы выяснить, есть ли в программе переменная (например cat ), ищем вхождения строки с её названием в словарях, возвращаемых функциями locals() (локальная видимость) и globals() (глобальная видимость):

if «cat» in locals(): # … if «cat» in globals(): # …

Удаление переменной

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

please_dont = ‘alive’ del(please_dont) print(please_dont) > Traceback (most recent call last): print(please_dont) NameError: name ‘please_dont’ is not defined

Что означает звездочка перед переменной?

Символ * перед именем переменной может означать несколько вещей.

status = [‘open’, ‘close’] print(status) > [‘open’, ‘close’] print(*status) > open close

def summer(*terms): sum = 0 for term in terms: sum = sum + term return sum print(summer(2)) > 2 print(summer(3, 3)) > 6 print(summer(4, 43, 1)) > 48

def setCreator(some_list): return <*some_list[1:]>weapons = [‘bow’, ‘pike’, ‘sword’, ‘dagger’] print(setCreator(weapons)) > <'dagger', 'pike', 'sword'>print(type(setCreator(weapons))) >

Область видимости: локальные и глобальные переменные

Сначала терминология. Область видимости или пространство имен — это место в программном коде, где переменной было присвоено значение.

Существуют три разные области видимости:

2 Нелокальная. Если внутри функции определена другая функция, то переменная внутри внешнего def будет нелокальной для def внутреннего. То есть сделать вот так не получится:

Поэтому для корректной работы нужно использовать ключевое слово nonlocal :

num = 42 def globalExample(n): res = n + num return res print(globalExample(1)) > 43

Статические переменные

Статическая переменная сохраняет свое значение между вызовами функций.

Звучит очень похоже на определение глобальной переменной, однако в том-то и дело, что статическая переменная может быть и локальной.

Самих по себе статических переменных в Питоне нет

Источник

Самоучитель

Переменные в Python для начинающих

Любая программы состоит из набора команд и данных. Так вот, чтобы хранить данные, в любом языке программирования, и Python не исключение, есть такое понятие как переменные.

Переменная это не что иное, как имя, с помощью которого можно обратиться к данным, сохраненным в памяти компьютера. Другими словами, переменная — это именованная область памяти. Чтобы создать переменную и назначить ей значение используется оператор присваивания. Вот несколько примеров того, как создается, или, как говорят программисты, «объявляется» переменная

Синтаксис «объявления» прост: достаточно написать имя переменной, знак «=» и значение переменной. У разных переменных могут быть разные типы данных. В нашем примере переменная first является строкой, а переменная second — числом. В Python, кроме строк и чисел, есть и другие типы данных. Если вы начинающий программист и не знаете, что такое типы данных, не переживайте, об этом будет рассказано чуть позже.

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

Попробуйте запустить такую программу и посмотрите, что она выведет на экран.

Имена переменных

Следует придерживаться нескольких несложных правил при выборе имен переменных:

Имя переменной может содержать только латинские буквы, числа и символ нижнего подчеркивания;

Имя переменной не должно содержать пробелов;

Имя переменной не должно начинаться с цифры;

Регистр важен: var и Var это разные переменные.

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

Источник

Переменные

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

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

Именование идентификаторов

Переменные являются примером идентификаторов. Правила присвоения имени идентификатору приведены ниже.

Объявление переменных и присвоение значений

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

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

Оператор = используется для присвоения значения переменной.

Ссылки на объекты

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

Давайте разберем следующий пример

На изображении выше переменная a относится к целочисленному объекту.

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

Идентификация объекта

140734982691168 140734982691168 2822056960944

Имена переменных в python

Мы уже обсуждали, как объявить допустимую переменную. Имена переменных могут быть любой длины, могут содержать прописные и строчные буквы (от A до Z, от a до z), цифры (0-9) и символ подчеркивания(_). Рассмотрим следующий пример допустимых имен переменных.

Рассмотрим следующие имена допустимых переменных.

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

Множественная инициализация переменных в Python

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

Мы можем применять множественные присваивания двумя способами: либо присваивая одно значение нескольким переменным, либо присваивая несколько значений нескольким переменным. Рассмотрим следующий пример.

Значения будут присваиваться в том порядке, в котором появляются переменные.

Типы переменных Python

Локальные переменные в Python

В приведенном выше коде мы объявили функцию add() и назначили несколько переменных внутри функции. Эти переменные будут называться локальными переменными, которые имеют область видимости только внутри функции. Если мы попытаемся использовать их вне функции, то получим следующую ошибку.

The sum is: 50 print(a) NameError: name ‘a’ is not defined

Глобальные переменные в Python

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

101 Welcome To Javatpoint Welcome To Javatpoint

В приведенном выше коде мы объявляем глобальную переменную x и присваиваем ей значение. Затем мы определили функцию и обратились к объявленной переменной с помощью ключевого слова global внутри функции. Теперь мы можем изменить ее значение. Затем мы присвоили переменной x новое строковое значение.

Удаление переменной в Python

6 Traceback (most recent call last): File «C:/Users/DEVANSH SHARMA/PycharmProjects/Hello/multiprocessing.py», line 389, in print(x) NameError: name ‘x’ is not defined

Максимально возможное значение целого числа в Python

В отличие от других языков программирования, в Python нет типов данных long int или float. Он рассматривает все целочисленные значения как тип данных int. Здесь возникает вопрос. Какое максимальное значение может хранить переменная в Python? Рассмотрим следующий пример.

В Python нет специального типа данных для хранения больших чисел.

Вывод одной или нескольких переменных в Python

Источник

Переменные в Python — подробное руководство

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

Правила для определения переменной Python

Есть несколько правил для определения переменной python.

Примеры допустимых имен

Примеры недопустимых имен

Как объявить переменную в Python?

Python — это язык с динамической типизацией. Нам не нужно указывать тип переменной при ее объявлении. Переменная определяется знаком равенства. Левая часть содержит имя переменной, а правая часть — значение.

Давайте посмотрим на несколько примеров объявления.

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

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

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

Как вывести значение?

Мы можем использовать функцию Python print() для печати и вывода значения. Давайте посмотрим на несколько примеров.

Советы

Если вы посмотрите на приведенные выше фрагменты кода, имена переменных случайны. Они не передают значения. Есть несколько рекомендаций, которым следует придерживаться.

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

Как напечатать тип?

Мы не указываем тип переменной в программах на Python. Мы можем использовать функцию type() для определения типа.

Какие существуют типы?

Тип переменной Python — это тип данных ее значения. Python — это объектно-ориентированный язык программирования. Все в Python — это объект. Итак, переменные всегда являются экземпляром класса.

Область видимости переменной Python

Область видимости определяет область доступности переменной в программе. Переменные Python имеют две области действия:

Локальная

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

Давайте посмотрим на другой пример локальной переменной, определенной внутри класса. Область видимости — это класс для этого сценария.

Вывод: NameError: name ‘class_foo_var’ is not defined

Глобальная

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

Переменные, определенные внутри блоков кода, такие как if-else, for loop, while loop, try-except и т. Д., Добавляются в глобальную область видимости при условии, что код, объявляющий переменную, был выполнен. Давайте разберемся в этом на простом примере.

Var_else не определен, потому что код внутри блока else не был выполнен.

Давайте посмотрим на другой пример с блоком try-except.

Мы можем получить доступ, определенным внутри блока try и except, потому что они обе были выполнены.

Удаление

Статическая

Переменные, определенные внутри класса, доступны по имени класса. Их также называют статическими, потому что они принадлежат классу.

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

Краткое описание функций globals() и locals()

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

global ключевое слово

Мы можем получить доступ к глобальной переменной внутри функции. Но мы не можем это изменить. Мы должны использовать ключевое слово global чтобы изменить значение глобальной переменной внутри функции.

Посмотрим, что произойдет, когда мы попытаемся изменить значение внутри функции.

Причина проста. Когда мы используем оператор присваивания для изменения значения «name», он начинает обрабатываться как локальная переменная. Таким образом, доступ к нему внутри функции print() сбрасывает, потому что он не определен в этот момент.

Давайте используем ключевое слово global, чтобы изменить значение глобальной переменной.

nonlocal ключевое слово

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

Источник

Python переменные

Оглавление Присвоение переменной Типы переменных в Python Ссылки на объекты Идентичность объекта Имена переменных Зарезервированные слова (ключевые слова) Вывод Вот…

Вот что вы узнаете из этого руководства: вы узнаете, как каждый элемент данных в программе Python может быть описан абстрактным термином-объектом, и вы узнаете, как управлять

Присвоение переменной

Думайте о переменной как об имени, прикрепленном к определенному объекту. В Python переменные не нужно объявлять или определять заранее, как это имеет место во многих других языках программирования. Чтобы создать переменную, вы просто присваиваете ей значение, а затем начинаете использовать. Присваивание выполняется с помощью единственного знака равенства (=):

Это читается или интерпретируется как «n присвоено значение 300». Как только это будет сделано, n можно использовать в операторе или выражении, и его значение будет заменено:

Так же, как буквальное значение может отображаться непосредственно из приглашения интерпретатора в сеансе REPL без необходимости print(), переменная может:

Позже, если вы измените значение n и используете его снова, вместо него будет подставлено новое значение:

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

Цепное присвоение, приведенное выше, одновременно присваивает 300 переменных a, b и c.

Типы переменных в Python

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

Это ограничение не распространяется на переменные в Python. В Python переменной может быть присвоено значение одного типа, а затем повторно присвоено значение другого типа:

Ссылки на объекты

Что на самом деле происходит, когда вы присваиваете переменную? Это важный вопрос для Python, потому что ответ несколько отличается от того, что вы найдете во многих других языках программирования.

Python – это весьма объектно-ориентированный язык. Фактически, практически каждый элемент данных в программе Python является объектом определенного типа или класса.

Рассмотрим этот код:

ри представлении оператора print (300) интерпретатор выполняет следующие действия:

Вы можете видеть, что целочисленный объект создается с помощью встроенной функции type():

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

Это присвоение создает целочисленный объект со значением 300 и присваивает переменной n, указывающей на этот объект.

Следующий код проверяет, что n указывает на целочисленный объект:

Теперь рассмотрим следующее утверждение:

Что происходит, когда он выполняется? Python не создает другой объект. Он просто создает новое символическое имя или ссылку, m, которая указывает на тот же объект, на который указывает n.

Множественные ссылки на один объект

Далее предположим, что вы делаете это:

Теперь Python создает новый целочисленный объект со значением 400, и m становится ссылкой на него.

Ссылки на отдельные объекты

Наконец, предположим, что этот оператор выполняется следующим образом:

Теперь Python создает строковый объект со значением «foo» и делает ссылку на n.

Ссылка на целочисленный объект 300 больше не существует. Он потерян, и к нему невозможно получить доступ.

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

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

Идентичность объекта

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

Глубокое погружение: кэширование малых целочисленных значений

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

Здесь m и n по отдельности назначаются целочисленным объектам, имеющим значение 30. Но в этом случае id (m) и id (n) идентичны!

В целях оптимизации интерпретатор создает объекты для целых чисел в диапазоне [-5, 256] при запуске, а затем повторно использует их во время выполнения программы. Таким образом, когда вы назначаете отдельные переменные целочисленному значению в этом диапазоне, они фактически будут ссылаться на один и тот же объект.

Имена переменных

В примерах, которые вы видели до сих пор, использовались короткие, лаконичные имена переменных, такие как m и n. Но имена переменных могут быть более подробными. Фактически, это обычно полезно, потому что это делает назначение переменной более очевидным с первого взгляда.

Официально имена переменных в Python могут быть любой длины и могут состоять из прописных и строчных букв (A-Z, a-z), цифр (0-9) и символа подчеркивания (_). Дополнительным ограничением является то, что, хотя имя переменной может содержать цифры, первый символ имени переменной не может быть цифрой.

Примечание. Одним из дополнений к Python 3 была полная поддержка Unicode, которая также позволяет использовать символы Unicode в имени переменной. Вы узнаете о Unicode более подробно в одном из будущих руководств.

Например, все следующие допустимые имена переменных:

Но это не так, потому что имя переменной не может начинаться с цифры:

Обратите внимание, что регистр имеет значение. Строчные и прописные буквы – это не одно и то же. Также важно использование символа подчеркивания. Каждое из следующего определяет разные переменные:

Ничто не мешает вам создать две разные переменные в одной программе под названием age и Age, или, если на то пошло, agE. Но, вероятно, это опрометчиво. Это, безусловно, могло бы сбить с толку любого, кто пытается прочитать ваш код, и даже вас самого, после того, как вы какое-то время отдалились от него.

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

Все они, вероятно, лучший выбор, чем n, ncg и т.п. По крайней мере, вы можете сказать по имени, что должно представлять значение переменной.

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

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

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

Руководство по стилю кода Python, также известное как PEP 8, содержит соглашения об именах, в которых перечислены рекомендуемые стандарты для имен различных типов объектов. PEP 8 включает следующие рекомендации:

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

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

В Python 3.6 есть 33 зарезервированных ключевых слова:

Вы можете просмотреть этот список в любое время, набрав help («ключевые слова») интерпретатору Python. Зарезервированные слова чувствительны к регистру и должны использоваться точно так, как показано. Все они полностью строчные, за исключением False, None и True.

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

Вывод

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

Теперь вы хорошо разбираетесь в некоторых типах данных Python и знаете, как создавать переменные, которые ссылаются на объекты этих типов.

Источник