Переменные 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

This assignment creates an integer object with the value 300 and assigns the variable n to point to that object.

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

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

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

>>> m = n

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

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

>>> m = 400

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

Lastly, suppose this statement is executed next:

>>> n = "foo"

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

Больше нет ссылки на целочисленный объект 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 станут указывать на различные объекты.

Deep Dive: кэширование небольших целочисленных значений
Из того, что вы теперь знаете о Назначении объектов и Ссылки на объекты в 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 может быть любой длины и может состоять из прописных и строчных букв (AZ, az), цифр (0-9 ) и символ подчеркивания (_). Дополнительным ограничением является то, что, хотя имя переменной может содержать цифры, первый символ имени переменной не может быть цифрой.

Note: One of the additions to Python 3 was full Unicode support, which allows for Unicode characters in a variable name as well. You will learn about Unicode in greater depth in a future tutorial.

Например, все, перечисленные ниже, имена переменных верны:

>>> 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

There is nothing stopping you from creating two different variables in the same program called age and Age, or for that matter agE. But it is probably ill-advised. It would certainly be likely to confuse anyone trying to read your code, and even you yourself, after you’d been away from it awhile.

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

>>> 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

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

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

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

• Snake Case должен использоваться для именования функций и переменных.
• Pascal Case используется для именования классов. (PEP 8 refers to this as the “CapWords” convention.)

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

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

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

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

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

>>> for = 3
SyntaxError: invalid syntax

Заключение

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

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

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

Использованы материалы: Variables in Python

Получить в PDF