Python переменные

22 августа, 2020

Подписывайся на наш канал в Telegram, чтобы ежедневно совершенствоваться в Python. Там выходят задачи, полезные советы и сливы платных курсов - перейти

Оглавление

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

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

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

>>> n = 300

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

>>> print(n)
300

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

>>> n
300

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

>>> n = 1000
>>> print(n)
1000
>>> n
1000

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

>>> a = b = c = 300
>>> print(a, b, c)
300 300 300

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

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

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

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

>>> var = 23.5
>>> print(var)
23.5

>>> var = "Now I'm a string"
>>> print(var)
Now I'm a string

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

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

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

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

>>> print(300)
300

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

  • Создает целочисленный объект
  • Придает ему значение 300
  • Отображает его на консоли

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

>>> type(300)
<class 'int'>

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

Например:

>>> n = 300

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

Variable reference diagram

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

>>> print(n)
300
>>> type(n)
<class 'int'>

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

>>> m = n

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

Python variable references to the same object (illustration)
Множественные ссылки на один объект

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

>>> m = 400

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

References to separate objects in Python (diagram)
Ссылки на отдельные объекты

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

>>> n = "foo"

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

Python variable reference illustration

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

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

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

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

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

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

>>> n = 300
>>> m = n
>>> id(n)
60127840
>>> id(m)
60127840

>>> m = 400
>>> id(m)
60127872

После присвоения m = n, m и n оба указывают на один и тот же объект, что подтверждается тем фактом, что id (m) и id (n) возвращают одно и то же число. После переназначения m на 400, m и n указывают на разные объекты с разными идентификаторами.


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

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

>>> m = 300
>>> n = 300
>>> id(m)
60062304
>>> id(n)
60062896

С оператором m = 300 Python создает целочисленный объект со значением 300 и устанавливает m в качестве ссылки на него. Затем n аналогичным образом присваивается целочисленному объекту со значением 300, но не тому же объекту. Таким образом, они имеют разные идентификаторы, что вы можете проверить по значениям, возвращаемым id().

Но учтите это:

>>> m = 30
>>> n = 30
>>> id(m)
1405569120
>>> id(n)
1405569120

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

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

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

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

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

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

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

>>> name = "Bob"
>>> Age = 54
>>> has_W2 = True
>>> print(name, Age, has_W2)
Bob 54 True

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

>>> 1099_filed = False
SyntaxError: invalid token

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

>>> age = 1
>>> Age = 2
>>> aGe = 3
>>> AGE = 4
>>> a_g_e = 5
>>> _age = 6
>>> age_ = 7
>>> _AGE_ = 8

>>> print(age, Age, aGe, AGE, a_g_e, _age, age_, _AGE_)
1 2 3 4 5 6 7 8

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

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

>>> numberofcollegegraduates = 2500
>>> NUMBEROFCOLLEGEGRADUATES = 2500
>>> numberOfCollegeGraduates = 2500
>>> NumberOfCollegeGraduates = 2500
>>> number_of_college_graduates = 2500

>>> print(numberofcollegegraduates, NUMBEROFCOLLEGEGRADUATES,
... numberOfCollegeGraduates, NumberOfCollegeGraduates,
... number_of_college_graduates)
2500 2500 2500 2500 2500

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

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

  • Camel Case: второе и последующие слова пишутся с заглавной буквы, чтобы границы слов было легче увидеть. (Предположительно, в какой-то момент кого-то поразило, что прописные буквы, разбросанные по всему имени переменной, отдаленно напоминают верблюжьи горбы.)
    • Пример: numberOfCollegeGraduates
  • Pascal Case: идентично Camel Case, за исключением того, что первое слово также написано с большой буквы.
    • Пример: NumberOfCollegeGraduates
  • Snake Case: слова разделены подчеркиванием.
    • Пример: number_of_college_graduates

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

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

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

  • Для имен функций и переменных следует использовать Snake Case.
  • Для имен классов следует использовать регистр Pascal. (PEP 8 называет это соглашением «CapWords».)

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

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

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

Python
Keywords
   
Falsedefifraise
Nonedelimportreturn
Trueelifintry
andelseiswhile
asexceptlambdawith
assertfinallynonlocalyield
breakfornot
classfromor
continueglobalpass

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

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

>>> for = 3
SyntaxError: invalid syntax

Вывод

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

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


Совершенствуй знания каждый день у нас в Телеграм-каналах

Вопросы, реклама — VK | Telegram