Как использовать переменные в Python 3

Введение

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

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

Предпосылки

У вас должен быть установлен Python 3 и настроена среда программирования на вашем компьютере или сервере. Если у вас не настроена среда программирования, вы можете обратиться к руководствам по установке и настройке среды программирования на вашем сервере, подходящей для вашей операционной системы (Ubuntu, CentOS, Debian и т. д.).

Понимание переменных

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

Вы можете думать о переменной как о метке с именем, которое вы привязываете к значению:

Допустим, у нас есть целое число 103204934813, и мы хотим сохранить его в переменной, а не постоянно вводить длинное число снова и снова. Вместо этого давайте воспользуемся чем-то, что легко запомнить, например, переменной my_int:

Информация: Чтобы следовать примеру кода в этом руководстве, откройте интерактивную оболочку Python в вашей локальной системе, выполнив команду python3. Затем вы можете копировать, вставлять или редактировать примеры, добавляя их после приглашения >>>.

my_int = 103204934813

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

На метке написано имя переменной my_int, и она привязана к целочисленному значению 103204934813.

Фраза my_int=103204934813 — это оператор присваивания, состоящий из нескольких частей:

• имя переменной (my_int)
• оператор присваивания, также известный как знак равенства (=)
• значение, привязанное к имени переменной (103204934813)

Вместе эти три части составляют инструкцию, которая присваивает переменной my_int значение целого числа 103204934813.

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

Как только мы установим my_int равным значению 103204934813, мы сможем использовать my_int вместо целого числа, поэтому давайте распечатаем его :

print(my_int)

Output
103204934813

Используя переменные, мы можем быстро и легко выполнять математические операции. С my_int=103204934813 давайте вычтем целочисленное значение 813:

print(my_int - 813)

Output
103204934000

В этом примере Python вычисляет за нас, вычитая 813 из переменной my_int, чтобы получить сумму 103204934000.

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

x = 76 + 145

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

Давайте продолжим и напечатаем x:

print(x)

Output
221

Python вернул значение 221, поскольку переменная x была установлена равной сумме 76 и 145.

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

my_string = 'Hello, World!'
my_flt = 45.06
my_bool = 5 > 9 #A Boolean value will return either True or False
my_list = ['item_1', 'item_2', 'item_3', 'item_4']
my_tuple = ('one', 'two', 'three')
my_dict = {'letter': 'g', 'number': 'seven', 'symbol': '&'}

Если вы напечатаете любую из вышеуказанных переменных, Python вернет значение, эквивалентное этой переменной. Например, давайте поработаем с оператором присваивания для типа данных list выше:

my_list = ['item_1', 'item_2', 'item_3', 'item_4']
print(my_list)

Output
['item_1', 'item_2', 'item_3', 'item_4']

Мы передали значение списка [item_1, item_2, item_3, item_4] в переменную my_list, а затем использовали функцию print() для распечатайте это значение, вызвав my_list.

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

Именование переменных: правила и стиль

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

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

Следуя приведенным выше правилам, давайте рассмотрим как допустимые, так и недопустимые имена переменных:

Еще кое-что, о чем следует помнить при именовании переменных, это то, что они чувствительны к регистру, а это означает, что my_int, MY_INT, My_Int и mY_iNt — совершенно разные переменные. Вам следует избегать использования одинаковых имен переменных в программе, чтобы гарантировать, что и вы, и ваши нынешние и будущие соавторы смогут правильно использовать ваши переменные.

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

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

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

Переназначение переменных

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

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

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

Давайте сначала назначим x как целое число, а затем переназначим его как строку:

#Assign x to be an integer
x = 76
print(x)

#Reassign x to be a string
x = "Sammy"
print(x)

Output
76
Sammy

Пример выше показывает, что мы можем сначала присвоить переменной x значение целого числа, а затем переназначить переменную x, присвоив ей на этот раз значение строка.

Если бы мы переписали программу так:

x = 76
x = "Sammy"
print(x)

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

Output
Sammy

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

Множественное назначение

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

С помощью множественного присвоения вы можете установить для переменных x, y и z значение целого числа 0 :

x = y = z = 0
print(x)
print(y)
print(z)

Output
0
0
0

В этом примере все три переменные (x, y и z) назначаются одной и той же ячейке памяти. Каждое из них равно значению 0.

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

j, k, l = "shark", 2.05, 15
print(j)
print(k)
print(l)

Output
shark
2.05
15

В приведенном выше примере переменная j была присвоена строке shark, переменная k была присвоена float 2.05 , а переменной l было присвоено целое число 15.

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

Глобальные и локальные переменные

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

Глобальные переменные существуют вне функций. Локальные переменные существуют внутри функций.

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

#Create a global variable, outside of a function
glb_var = "global"

#Define a function
def var_function():
    lcl_var = "local" #Create a local variable, inside function
    print(lcl_var)

#Call function to print local variable
var_function()

#Print global variable outside function
print(glb_var)

Output
local
global

Вышеприведенная программа присваивает глобальную переменную glb_var вне какой-либо функции, а затем определяет функцию var_function(). Внутри функции назначается локальная переменная с именем lcl_var, которая затем распечатывается. Программа завершается вызовом var_function() и последующей печатью glb_var.

Поскольку glb_var является глобальной переменной, мы можем ссылаться на нее в var_function(). Давайте изменим небольшую программу выше, чтобы сделать это:

glb_var = "global"

def var_function():
    lcl_var = "local"
    print(lcl_var)
    print(glb_var) #Print glb_var within function

var_function()
print(glb_var)

Output
local
global
global

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

Что, если мы попытаемся вызвать локальную переменную вне функции?

glb_var = "global"

def var_function():
    lcl_var = "local"
    print(lcl_var)

print(lcl_var)

Output
NameError: name 'lcl_var' is not defined

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

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

num1 = 5 #Global variable

def my_function():
    num1 = 10 #Use the same variable name num1
    num2 = 7 #Assign local variable

    print(num1) #Print local variable num1
    print(num2) #Print local variable num2

#Call my_function()
my_function()

#Print global variable num1
print(num1)

Output
10
7
5

Поскольку локальная переменная num1 назначается локально внутри функции, при вызове этой функции мы видим, что num1 равен локальному значению 10. . Когда мы выводим глобальное значение num1 после вызова my_function(), мы видим, что глобальная переменная num1 по-прежнему равна значению 5.

Присвоить глобальные переменные внутри функции можно с помощью оператора Python global:

def new_shark():
    #Assign variable as global
    global shark
    shark = "Sammy"

#Call new_shark() function
new_shark()

#Print global variable shark
print(shark)

Output
Sammy

Несмотря на то, что переменная shark была назначена локально в функции new_shark(), она доступна вне функции из-за оператора global, использованного ранее. присваивание переменной внутри функции. Благодаря этому оператору global, когда мы вызываем print(shark) вне функции, мы не получаем ошибки. Хотя вы можете присвоить глобальную переменную внутри функции, вам, скорее всего, не придется делать это часто, и вы должны ошибаться в сторону читабельного кода.

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

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

Заключение

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