Как присвоить число в питоне

ПРИСВАИВАНИЕ И СОЗДАНИЕ ОБЪЕКТОВ В PYTHON

Для присваивания значений переменным в Python служит оператор «=«.

Выражение, стоящее справа от оператора присваивания, вычисляется, и полученное значение присваивается переменной, стоящей слева от оператора присваивания. При этом предыдущее значение, хранящееся в переменной, стирается и заменяется на новое. Если такой переменной не существует, то она создается и в нее записывается значение.

Создание переменных и объектов в Python происходит с помощью оператора присваивания.

Оператор » присвоить переменной a значение 5″.

Cложить значения 5 и 3, результат присвоить переменной x (записать в переменную x).

x = 5 + 3 

Прибавить 4 к значению, хранящемуся в переменной a, полученный результат присвоить переменной b (записать в переменную b).

b = a + 4 

Прибавить 1 к значению, хранящемуся в переменной b, полученный результат присвоить переменной b (записать в переменную b).

b = b + 1 

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

В правой части значение переменной может использоваться много раз:

c = b * b + 3 * b 

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

Множественное присваивание (позиционное присваивание) в Python реализуется следующим образом:

a, b, c = 5, 3, 1 

В результате выполнения этой строки кода в переменной a окажется число 5, в переменной b — 3, в переменной c — 1. Количество значений и количество переменных справа и слева от оператора присваивания должно совпадать. При множественном присваивании порядок присваивания формируется слева направо.

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

a, b = 5, 3 a, b = b, a print(a, b) 

Множественное присваивание со списками

list1 = [5, 3, 1] a, b, c = list1 

В переменной a окажется число 5, в переменной b — 3, в переменной c — 1.

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

Аналогичным образом это работает и для кортежей.

Множественное присваивание со строками

str1 = "make" a, b, c, d = str1 

В a окажется «m», в b — «a», в c — «k», в d — «e».

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

Каскадное присваивание

Python поддерживает каскадное присваивание:

a = b = c = 5 

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

Инициализация переменных

Любая переменная, использующаяся в выражении, должна существовать.

Допустим, мы написали следующую программу:

a = 5 b = 3 d = a + b + c print(d) 

При ее запуске мы получим сообщение об ошибке «NameError: name ‘c’ is not defined» , которое говорит нам, что переменная «c» не определена.

Действительно, переменной «c» в нашей программе не существует и при вычислении выражения a + b + c интерпретатор Python столкнулся с этой проблемой. Попробуем исправить эту ситуацию.

a = 5 b = 3 c = 2 d = a + b + c print(d) 

Теперь всё нормально и после запуска программы мы получим результат вычислений.

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

Следующий код вернет ошибку «NameError: name ‘k’ is not defined» .

k = k + 1 print(k) 

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

Чтобы код нормально работал, следует создать переменную k, присвоив ей, например, 0. Это называется инициализировать переменную.

k = 0 k = k + 1 print(k) 

Составное присваивание

В составном операторе присваивания используются арифметические операторы.

Пример сложения с присваиванием:

a = 2 a += 5 print(a) 

Составной оператор += прибавляет к переменной значение выражения справа от оператора присваивания и записывает получившийся результат в эту переменную.

a += 5 эквивалентно a = a + 5.

Составные операторы присваивания используются для сокращения записи.

Таблица с составными операторами присваивания и их эквивалентами

Как присвоить число в питоне

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

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

Например, создадим переменную:

name = "Tom"

Здесь определена переменная name , которая хранит строку «Tom».

В пайтоне применяется два типа наименования переменных: camel case и underscore notation .

Camel case подразумевает, что каждое новое подслово в наименовании переменной начинается с большой буквы. Например:

userName = "Tom"

Underscore notation подразумевает, что подслова в наименовании переменной разделяются знаком подчеркивания. Например:

user_name = "Tom"

И также надо учитывать регистрозависимость, поэтому переменные name и Name будут представлять разные объекты.

# две разные переменные name = "Tom" Name = "Tom"

Определив переменную, мы можем использовать в программе. Например, попытаться вывести ее содержимое на консоль с помощью встроенной функции print :

name = "Tom" # определение переменной name print(name) # вывод значения переменной name на консоль

Например, определение и применение переменной в среде PyCharm:

Отличительной особенностью переменной является то, что мы можем менять ее значение в течение работы программы:

name = "Tom" # переменной name равна "Tom" print(name) # выводит: Tom name = "Bob" # меняем значение на "Bob" print(name) # выводит: Bob

Типы данных

Переменная хранит данные одного из типов данных. В Python существует множество различных типов данных. В данном случае рассмотрим только самые базовые типы: bool , int , float , complex и str .

Логические значения

Тип bool представляет два логических значения: True (верно, истина) или False (неверно, ложь). Значение True служит для того, чтобы показать, что что-то истинно. Тогда как значение False , наоборот, показывает, что что-то ложно. Пример переменных данного типа:

isMarried = False print(isMarried) # False isAlive = True print(isAlive) # True

Целые числа

Тип int представляет целое число, например, 1, 4, 8, 50. Пример

age = 21 print("Возраст:", age) # Возраст: 21 count = 15 print("Количество:", count) # Количество: 15

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

Для указания, что число представляет двоичную систему, перед числом ставится префикс 0b :

a = 0b11 b = 0b1011 c = 0b100001 print(a) # 3 в десятичной системе print(b) # 11 в десятичной системе print(c) # 33 в десятичной системе

Для указания, что число представляет восьмеричную систему, перед числом ставится префикс 0o :

a = 0o7 b = 0o11 c = 0o17 print(a) # 7 в десятичной системе print(b) # 9 в десятичной системе print(c) # 15 в десятичной системе

Для указания, что число представляет шестнадцатеричную систему, перед числом ставится префикс 0x :

a = 0x0A b = 0xFF c = 0xA1 print(a) # 10 в десятичной системе print(b) # 255 в десятичной системе print(c) # 161 в десятичной системе

Стоит отметить, что в какой-бы системе мы не передали число в функцию print для вывода на консоль, оно по умолчанию будет выводиться в десятичной системе.

Дробные числа

Тип float представляет число с плавающей точкой, например, 1.2 или 34.76. В качесте разделителя целой и дробной частей используется точка.

height = 1.68 pi = 3.14 weight = 68. print(height) # 1.68 print(pi) # 3.14 print(weight) # 68.0

Число с плавающей точкой можно определять в экспоненциальной записи:

x = 3.9e3 print(x) # 3900.0 x = 3.9e-3 print(x) # 0.0039

Число float может иметь только 18 значимых символов. Так, в данном случае используются только два символа — 3.9. И если число слишком велико или слишком мало, то мы можем записывать число в подобной нотации, используя экспоненту. Число после экспоненты указывает степень числа 10, на которое надо умножить основное число — 3.9.

Комплексные числа

Тип complex представляет комплексные числа в формате вещественная_часть+мнимая_часть j — после мнимой части указывается суффикс j

complexNumber = 1+2j print(complexNumber) # (1+2j)

Строки

Тип str представляет строки. Строка представляет последовательность символов, заключенную в одинарные или двойные кавычки, например «hello» и ‘hello’. В Python 3.x строки представляют набор символов в кодировке Unicode

message = "Hello World!" print(message) # Hello World! name = 'Tom' print(name) # Tom

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

text = ("Laudate omnes gentes laudate " "Magnificat in secula ") print(text)

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

''' Это комментарий ''' text = '''Laudate omnes gentes laudate Magnificat in secula Et anima mea laudate Magnificat in secula ''' print(text)

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

Управляющие последовательности в строке

Строка может содержать ряд специальных символов — управляющих последовательностей. Некоторые из них:

• \\ : позволяет добавить внутрь строки слеш
• \’ : позволяет добавить внутрь строки одинарную кавычку
• \» : позволяет добавить внутрь строки двойную кавычку
• \n : осуществляет переход на новую строку
• \t : добавляет табуляцию (4 отступа)

Применим несколько последовательностей:

text = "Message:\n\"Hello World\"" print(text)

Консольный вывод программы:

Message: "Hello World"

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

path = "C:\python\name.txt" print(path)

Здесь переменная path содержит некоторый путь к файлу. Однако внутри строки встречаются символы «\n», которые будут интерпретированы как управляющая последовательность. Так, мы получим следующий консольный вывод:

C:\python ame.txt

Чтобы избежать подобной ситуации, перед строкой ставится символ r

path = r"C:\python\name.txt" print(path)

Вставка значений в строку

Python позволяет встравивать в строку значения других переменных. Для этого внутри строки переменные размещаются в фигурных скобках <>, а перед всей строкой ставится символ f :

userName = "Tom" userAge = 37 user = f"name: age: " print(user) # name: Tom age: 37

В данном случае на место будет вставляться значение переменной userName. Аналогично на вместо будет вставляться значение переменной userAge.

Динамическая типизация

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

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

При этом в процессе работы программы мы можем изменить тип переменной, присвоив ей значение другого типа:

userId = "abc" # тип str print(userId) userId = 234 # тип int print(userId)

С помощью встроенной функции type() динамически можно узнать текущий тип переменной:

userId = «abc» # тип str print(type(userId)) # userId = 234 # тип int print(type(userId)) #

Переменные в Python: что это такое и какие они бывают

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

Иллюстрация: Оля Ежак для Skillbox Media

Иван Стуков
Журналист, изучает Python. Любит разбираться в мелочах, общаться с людьми и понимать их.

Если вы откроете любую программу в Python, то, скорее всего, увидите много таких равенств:

Как давать имена переменным

Создавая переменную на языке Python, программисты придумывают ей названия по определённым правилам именования:

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

Приведём несколько примеров.

• Какие имена можно давать переменным: x, X, xyz, _x_y_z, XYZ, xyz_123, _123, x1Y2z2.
• Как нельзя называть переменные: 1, 1x, x y z, x&y.

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

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

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

x = 1.2 y = 'строка'

Теперь x и y ссылаются на другие объекты с другими адресами. И так как больше ни одна переменная не ссылается на объект по адресу 2056817043856, то его автоматически удалит сборщик мусора.

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

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

x = y = z = 4

print(x, y, z) >>> 4 4 4

Для присвоения разных значений тоже есть способ:

x, y, z = 1, 'игрек', ['список', 'со', 'строками'] print(x, y, z) >>> 1 игрек ['список', 'со', 'строками']

Импорт переменных

Если переменную нужно импортировать из другого файла, то используют конструкцию from import .

Например, у нас есть файл variables1.py:

name = 'Виктория' age = 23 city = 'Москва'

Используем переменную name в файле variables2.py:

from variables1 import name print(name) >>> Виктория

При этом доступа к другим переменным из variables1.py в таком случае нет:

from variables1 import name print(age) >>> NameError: name 'age' is not defined

Чтобы импортировать несколько переменных, их можно перечислить через запятую:

from variables1 import name, age print(name, age) >>> Виктория 23

Для импорта всех объектов после import ставят звёздочку *:

from variables1 import * print(name, age, city) >>> Виктория 23 Москва

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

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

x = 4 del x print(x) >>> NameError: name 'x' is not defined

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

Все переменные существуют внутри определённой области видимости. В Python их три:

• локальная — внутри одной функции;
• глобальная — внутри целой программы (py-файла);
• нелокальная — внутри двух смежных функций (внутренней и внешней).

Переменные, которые принадлежат к той или иной области видимости, образуют её пространство имён.

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

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

def local_namespace(): x = 4 x = x ** 2 return x print(local_namespace()) >>> 16

Мы можем, как обычно, распоряжаться x: изменять значение, проводить операции, возвращать — но только до тех пор, пока мы делаем это внутри функции local_namespace().

Если мы решим обратиться к x где-то в другой части программы, то интерпретатор её просто не увидит:

def local_namespace(): x = 4 x = x ** 2 return x print(x) >>> NameError: name 'x' is not defined

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

x = 4 def local_namespace(): x = x ** 2 return x print(local_namespace()) >>> UnboundLocalError: local variable 'x' referenced before assignment

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

x = 4 def local_namespace(): y = x ** 2 return y print(x) print(local_namespace()) >>> 4 >>> 16

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

x = 0 def local_namespace(): x = 4 x = x ** 2 return x print(x) print(local_namespace()) >>> 0 >>> 16

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

Любая переменная, которую объявляют вне функций, является глобальной. Она существует в пространстве имён всего py-файла.

Как мы показали выше, к ней можно обратиться внутри функции, но нельзя изменять. Чтобы исправить это, существует ключевое слово global:

x = 4 def local_namespace(): global x x = x ** 2 return x print(local_namespace()) >>> 16

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

def local_namespace(): global x x = 4 return x print(local_namespace()) print(x) >>> 4 >>> 4

Нелокальные переменные

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

Их создают с помощью ключевого слова nonlocal.

def nonlocal_namespace(): x = 4 def local_namespace(): nonlocal x x = x ** 2 return x return local_namespace() print(nonlocal_namespace()) >>> 16

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

def nonlocal_namespace(): x = 4 def local_namespace(): nonlocal x x = x ** 2 return x return local_namespace() print(x) >>> NameError: name 'x' is not defined

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

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

Ключом в этих словарях является строка с именем переменной — так можно проверить её существование:

name = 'Виктория' if 'name' in globals(): print(True) >>> True

Также из этого словаря по имени переменной можно достать её значение:

name = 'Виктория' if 'name' in globals(): print(globals().get('name')) >>> Виктория

Точно так же можно делать и в локальной области видимости:

def local_namespace(): name = 'Виктория' if 'name' in locals(): print(locals().get('name')) local_namespace() >>> Виктория

Максимально возможное значение переменной

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

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

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

Для печати в Python используется функция print(). С её помощью можно вывести как одиночную переменную, так и несколько, перечислив их через запятую:

name, age, city = 'Виктория', 23, 'Москва' print(name) print(name, age, city) >>> Виктория >>> Виктория 23 Москва

Также в Python можно форматировать печать переменных. Для этого предусмотрено несколько способов, но самый удобный из них — f-строки. Нужно передать функции print() строку c буквой f перед ней. Сами переменные указываются в фигурных скобках: .

name, age, city = 'Виктория', 23, 'Москва' print(f'Имя: . Возраст: . Город: .') >>> Имя: Виктория. Возраст: 23. Город: Москва.

C=777 print(c)

a=10 print(a,b) b=20