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

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

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

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

first = "синий"
second = 23

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

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

first = "синий"
second = 23
print(first, second)

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

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

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

Имя переменной может содержать только латинские буквы, числа и символ нижнего подчеркивания;
Имя переменной не должно содержать пробелов;
Имя переменной не должно начинаться с цифры;
Регистр важен: var и Var это разные переменные.

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

Python с нуля. Освойте с Виртуальным ИИ-помощником!

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

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

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

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

# declare a variable var = 'new variable' print('The type of var is :',type(var)) # the type is str var = 23.0 print('Now, the type of var is :', type(var)) # the type is float

Итак, вы увидите такой результат:

Присвоение множественных переменных

Ранее вы видели о присвоении значения одной переменной. Но также можете назначить значения сразу нескольким переменным. Вы должны сохранить значение в самой правой части.

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

# assign multiple variable with the same value var1 = var2 = var3 = 'init' # print the value of each variable separately print('Value of var1 :', var1) print('Now, value of var1 :', var2) print('Again, value of var1 :', var3)

Итак, вывод следующего кода будет:

Value of var1 : init Now, value of var1 : init Again, value of var1 : init

Некоторые заметки о переменной

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

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

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

Переменные Python – руководство по применению

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

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

Что такое переменная в Python?

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

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

Переменные – это пример идентификаторов. Идентификатор используется для распознавания литералов в программе. Правила присвоения имени идентификатору приведены ниже.

Первым символом переменной должна быть буква или знак подчеркивания(_).
Все символы, кроме первого, могут быть: буквой из нижнего регистра(az), верхнего регистра(AZ), знаком подчеркивания или цифры(0-9).
Имя идентификатора не должно содержать пробелов или специальных символов(!, @, #,%, ^, &, *).
Имя идентификатора не должно быть похоже ни на одно ключевое слово, определенное в языке.
Имена идентификаторов чувствительны к регистру; например, my name и MyName не совпадают.
Примеры действительных идентификаторов: a123, _n, n_9 и т. д.
Примеры недопустимых идентификаторов: 1a, n% 4, n 9 и т. д.

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

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

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

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

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

Python – это объектно-ориентированный язык программирования; каждый элемент данных принадлежит к определенному типу класса. Рассмотрим следующий пример.

print("John")

John

Объект Python создает целочисленный объект и отображает его на консоли. В приведенном выше операторе печати мы создали строковый объект. Давайте проверим его тип с помощью встроенной функции Python type().

type("John")

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

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

a = 50

Переменная целочисленного объекта

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

Предположим, мы присвоили целочисленное значение 50 новой переменной b.

Переменная b

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

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

Новое значение переменной b

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

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

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

a = 50 b = a print(id(a)) print(id(b)) # Reassigned variable a a = 500 print(id(a))

140734982691168 140734982691168 2822056960944

Мы присвоили b = a, a и b обе точки на один и тот же объект. Когда мы проверили их с помощью функции id(), она вернула то же число. При a = 500 функция ссылается на новый идентификатор объекта.

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

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

name = "Devansh" age = 20 marks = 80.50 print(name) print(age) print(marks)

Devansh 20 80.5

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

name = "A" Name = "B" naMe = "C" NAME = "D" n_a_m_e = "E" _name = "F" name_ = "G" _name_ = "H" na56me = "I" print(name,Name,naMe,NAME,n_a_m_e, NAME, n_a_m_e, _name, name_,_name, na56me)

A B C D E D E F G F I

В приведенном выше примере мы объявили несколько допустимых имен переменных, таких как name, _name_ и т. д. Но такие имена не рекомендуется присваивать, потому что, когда мы пытаемся прочитать код, это может создать путаницу. Имя переменной должно быть описательным, чтобы код был более читабельным.

Ключевые слова из нескольких слов могут быть созданы следующим способом.

Camel Case – каждое слово или сокращение в середине начинается с заглавной буквы, пробелов нет. Например – nameOfStudent, valueOfVaraible и т. д.
Pascal Case – это то же самое, что и Camel Case, но здесь первое слово заглавное. Например – NameOfStudent и т. д.
Snake Case – слова разделяются подчеркиванием. Например – name_of_student и т. д.

Множественное присвоение

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

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

1. Присвоение одного значения нескольким переменным:

x=y=z=50 print(x) print(y) print(z)

50 50 50

2. Присвоение нескольких значений нескольким переменным:

a,b,c=5,10,15 print a print b print c

5 10 15

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

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

В Python есть два типа переменных – локальная переменная и глобальная переменная. Давайте в них разберемся.

Локальная переменная

Локальные переменные – это переменные, которые объявлены внутри функции и имеют область видимости внутри функции.

# Declaring a function def add(): # Defining local variables. They has scope only within a function a = 20 b = 30 c = a + b print("The sum is:", c) # Calling a function add()

The sum is: 50

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

add() # Accessing local variable outside the function print(a)

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

Мы пытались использовать локальные переменные вне их области видимости; программа выдала NameError.

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

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

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

# Declare a variable and initialize it x = 101 # Global variable in function def mainFunction(): # printing a global variable global x print(x) # modifying a global variable x = 'Welcome To Javatpoint' print(x) mainFunction() print(x)

101 Welcome To Javatpoint Welcome To Javatpoint

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

Удаление переменных

Мы можем удалить переменную с помощью ключевого слова del. Синтаксис приведен ниже.

В следующем примере мы создаем переменную x и присваиваем ей значение. Мы удалили переменную x и напечатали ее, получаем ошибку «переменная x не определена». Переменная x больше не будет использоваться в будущем.

# Assigning a value to x x = 6 print(x) # deleting a variable. del x print(x)

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? Рассмотрим следующий пример.

# A Python program to display that we can store # large numbers in Python a = 10000000000000000000000000000000000000000000 a = a + 1 print(type(a)) print(a)

 10000000000000000000000000000000000000000001

Как видно из приведенного выше примера, мы присвоили переменной x большое целочисленное значение и проверили ее тип. Он напечатал class . Следовательно, нет ограничения числа битов, и мы можем расширить до предела памяти.

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

Печать одиночных и множественных переменных в Python

Мы можем распечатать несколько переменных в одном операторе печати. Ниже приведен пример одно- и многократной печати значений.

Пример – 1 (печать одной переменной)

# printing single value a = 5 print(a) print((a))

Пример – 2 (печать нескольких переменных)

a = 5 b = 6 # printing multiple variables print(a,b) # separate the variables by the comma Print(1, 2, 3, 4, 5, 6, 7, 8)

5 6 1 2 3 4 5 6 7 8

2. Переменные

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

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

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

Зачастую данные — это больше чем 2 символа.
Обычно к ним нужно обращаться по несколько раз.

Где используется?

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

Правила использования

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

Частые ошибки

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

Примеры использования переменных

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

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

 
>>> sun_to_earth = 149597970 
>>> sun_to_earth = sun_to_earth + 1 
>>> print(sun_to_earth) 
149597971

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

Разберем код примера:

Сначала создается переменная sun_to_earth , и ей присваивается значение 149597970.
Переменной sun_to_earth присваивается новое значение — 149597971.
Выполняется функция print , которая выводит текущее значение переменной, то есть, 149597971.

Советы:

Название переменной всегда расположено слева при присваивании. А значение, которое нужно присвоить, располагается справа.
В Python (и любом другом языке программирования) очень важно правильно выбирать название переменной, ведь к ней придется часто обращаться:
- Кое-какие названия являются зарезервированными в Python, поэтому их использовать нельзя: print, true, false, count, sum и так далее. Со временем вы все их узнаете.
- Названия переменных должны начинаться с символа алфавита или нижнего подчеркивания.
- Если начать переменную с символа или нижнего подчеркивания, то после в нее можно включать и цифры.
- Названия переменных чувствительны к регистру. Если был использован символ в верхнем регистре, то именно так и нужно обращаться к переменой в будущем.
Практические соглашения именования переменных:
- Можно добавлять небольшой суффикс, чтобы не путать переменную с ключевым словом Python: var_number , var_true , v_start , v_close, the_class, the_one, the_name. Креативность разрешена, главное, чтобы система оставалась понятной.
- Лучше не использовать переменную в один символ, только если это цикл или любая другая короткая операция. Такие имена как a, x, y, z начинают путать уже спустя пару минут после того, как их впервые использовали.
- Слова рекомендуется разделять нижним подчеркиванием: cars_сounted, doors_сlosed, dogs_saved, ships_fixed и так далее. Это повышает читаемость переменных. Сравните: timeinmoscow и time_in_moscow.
- Рекомендуется (часто требуется) использовать латиницу и английские слова. Так ваш код будут понимать больше разработчиков.

 
>>> dogs_name = "Шарик" 
>>> dogs_kind = "Сенбернар" 
>>> print("Его зовут " , dogs_name , ". Он ", dogs_kind, ".", sep="") 
Его зовут Шарик. Он Сенбернар.

Это отличный пример применения не только переменной, но и функции print , ведь в последней используются сразу текст и значение переменной. Плюс, названия переменных выбраны очень удачно. Названия для переменных — тема субъективная, поэтому достаточно использовать то, что удобно для вас.

В одной строке можно присвоить сразу несколько переменных. Вот пример: