Как объявить переменную в python – Что такое локальные и глобальные переменные в Python: подробное описание работы

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

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

Каждое значение в Python имеет тип данных. Различные типы данных в Python: Numbers, List, Tuple, Strings, Dictionary и т. д. Переменные могут быть объявлены с любым именем или даже буквами, например, a, aa, abc и т. д. В этом руководстве мы узнаем, как:

Объявить и использовать переменную

Повторно объявить переменную

Объединить переменные

Бесплатный курс «Python. Быстрый старт»

Получите курс и узнайте, как создать программу для перевода текстов на Python

Получить курс

Что такое локальные и глобальные переменные

Как удалить переменную

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

Давайте рассмотрим пример. Мы объявим переменную «а» и выведем ее.

Повторное объявление переменной

Вы можете повторно объявить переменную даже после того, как уже объявили ее один раз. Здесь у нас есть переменная, инициализированная как, f =0. Позже мы переназначим для переменной f значение «guru99″.

Пример Python 2

# Объявление переменной и ее инициализация f = 0 print f # повторное объявление переменной тоже работает f = ‘guru99’ print f

# Объявление переменной и ее инициализация f = 0 print f # повторное объявление переменной тоже работает f = ‘guru99’ print f

Пример Python 3

# Объявление переменной и ее инициализация f = 0 print(f) # повторное объявление переменной тоже работает f = ‘guru99’ print(f)

# Объявление переменной и ее инициализация f = 0 print(f) # повторное объявление переменной тоже работает f = ‘guru99’ print(f)

Объединение переменных

Посмотрим, сможете ли вы объединить разные типы данных, такие как строка и число. Например, мы объединяем «Guru» с числом «99».

В отличие от Java, который объединяет число со строкой, не объявляя число как строку, Python требует, чтобы число было объявлено как строка, иначе будет отображаться ошибка TypeError.

Для следующего кода вы получите неопределенный вывод:

a=»Guru» b = 99 print a+b

После того, как целое число объявлено как строка, мы можем объединить в выходных данных «Guru» + str («99″) = «Guru99″.

a=»Guru» b = 99 print(a+str(b))

a=»Guru» b = 99 print(a+str(b))

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

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

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

Переменная «f» является глобальной и ей присваивается значение 101, которое выводится.

Переменная f снова объявлена в функции и предполагает локальную область видимости. Ей присваивается значение «I am learning Python.», которое выводится. Эта переменная отличается от глобальной переменной «f», определенной ранее.

Бесплатный курс «Python. Быстрый старт»

Получите курс и узнайте, как создать программу для перевода текстов на Python

Получить курс

После завершения вызова функции локальная переменная f уничтожается. В строке 12, когда мы снова выводим значение «f», оно отображает значение глобальной переменной f =101.

Пример Python 2

# Объявляем переменную и инициализируем ее f = 101 print f # Глобальные и локальные переменные в функциях def someFunction(): # Глобальная f f = ‘I am learning Python’ print f someFunction() print f

# Объявляем переменную и инициализируем ее f = 101 print f # Глобальные и локальные переменные в функциях def someFunction(): # Глобальная f     f = ‘I am learning Python’     print f someFunction() print f

Пример Python 3

# Объявляем переменную и инициализируем ее f = 101 print(f) # Глобальные и локальные переменные в функциях def someFunction(): # Глобальная f f = ‘I am learning Python’ print(f) someFunction() print(f)

# Объявляем переменную и инициализируем ее f = 101 print(f) # Глобальные и локальные переменные в функциях def someFunction(): # Глобальная f     f = ‘I am learning Python’     print(f) someFunction() print(f)

Используя ключевое слово global, вы можете ссылаться на глобальную переменную внутри функции.

Переменная «f» является глобальной и ей присваивается значение 101, которое выводится на выходе

Переменная f объявляется с использованием ключевого слова global. Это НЕ локальная переменная, но та же глобальная переменная, объявленная ранее. Следовательно, когда мы выводим ее значение, результат равен 101

Мы изменили значение «f» внутри функции. После завершения вызова функции измененное значение переменной «f» сохраняется. В строке 12, когда мы снова выводим значение «f», оно отображает значение «changing global variable»

Пример Python 2

f = 101; print f # Глобальные и локальные переменные в функциях def someFunction(): global f print f f = «changing global variable» someFunction() print f

f = 101; print f # Глобальные и локальные переменные в функциях def someFunction():   global f print f f = «changing global variable» someFunction() print f

Пример Python 3

f = 101; print(f) # Глобальные и локальные переменные в функциях def someFunction(): global f print(f) f = «changing global variable» someFunction() print(f)

f = 101; print(f) # Глобальные и локальные переменные в функциях def someFunction():   global f print(f) f = «changing global variable» someFunction() print(f)

Удаление переменной

Вы также можете удалить переменную с помощью команды del «имя переменной». В приведенном ниже примере мы удалили переменную f, и когда мы приступили к ее выводу, мы получили ошибку «variable name is not defined», что означает, что вы удалили переменную.

f = 11; print(f) del f print(f)

f = 11; print(f) del f print(f)

Заключение:

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

Переменные могут быть объявлены любым именем или даже буквами, например, aa, abc и т. д.

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

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

Объявляйте локальную переменную, когда хотите использовать ее для текущей функции

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

Для удаления переменной используется ключевое слово «del».

Источник: https://www.guru99.com

Редакция: Команда webformyself.

Бесплатный курс «Python. Быстрый старт»

Получите курс и узнайте, как создать программу для перевода текстов на Python

Получить курс

webformyself.com

Pythonicway — Типы данных в Python

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

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

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

Для понимания, можете думать о переменной как о коробке, в которую можно положить любую вещь, но только определенного размера. Размер в данном примере будет типом переменной. Это не совсем верное определение, но оно дает общее представление о картине в целом.

Присвоение значения переменной:

В Python вам не нужно объявлять тип переменной вручную (как, например в С++). Объявление происходит автоматически (это называется динамическая типизация), когда вы присваиваете значение переменной. Знак равенства ( = ) используется для присвоения значения переменной.

Операнд по левую сторону от знака равно ( = ) это имя переменной, операнд по правую сторону — значение присвоенное этой переменной.

Например:

country = "Swiss" # Присвоить значение Swiss переменной под названием country
age = 23 # Присвоение значения 23 переменной age 
print country
print age

При выполнении, данный код выведет:

Swiss
23

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

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

a = b = c = 1

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

Встроенные типы данных в Python:

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

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

К стандартным типам данных в Python относят:

Числовой тип данных в Python:

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

Числовые объекты создаются, когда вы присваиваете им значение. Например:

num1 = 23
num2 = 42

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

del num1 # удаляет переменную num1
del num2, num3 # удаляет обе переменные num2 за num3 за раз

 В Python есть четыре вида числового типа данных:

• int (целое число)
• long (длинное целое число [может быть представлено в восьмеричной или шестнадцатеричной системе исчисления])
• float (число с плавающей точкой: -0.2, 0.0, 3.14159265 и т.д.)
• complex (комплексное число) 

Примеры видов числового типа данных:

int	long	float	complex
1	51924361L	0.0	3.14j
102	-0x19323L	15.20	45.j
-786	0122L	-21.9	9.322e-36j
0	0xDEFABCECBDAECBFBAEl	32.3+e18	.876j
0b10	535633629843L	-90.	-.6545+0J
-0x260	-052318172735L	-32.54e100	3e+26J
0x69	-4721885298529L	70.2-E12	4.53e-7j

Строки в Python:

Под строками в Python подразумевается набор символов между кавычками. В Python можно использовать пары одинарных либо двойных кавычек. Из строк можно взять подстроку используя оператор нарезки ( [ ] и [ : ] ) с индексами от нуля для первого символа строки и до последнего. Так же можно использовать обратную индексацию от -1 для последнего символа до начала.

Оператор плюс ( + ) для строк соединяет две строки в одну, звездочка ( * ) оператор повторения. Например:

text = "Hello, Python!"
print text[0] # Выводит первый символ
print text[0:5] # Выводит подстроку text от 0 символа до 5 (включительно с нулевым, исключая пятый)
print text[4:10] # Выведет строку от 4 символа до 10 (включая четвертый, исключая 10)
print text[0:14] # Выведет всю строку
print text[7:] # Выведет строку с 7 символа до конца
print text[:5] # Выведет строку с начала до 5 символа. Аналогично print text[0:5]
print text[:] # Выведет всю строку
print text[-1] # Выводит последний символ
print text[-1:-14] # Не сработает, выведет пустую строку
print text[::2] # Третий аргумент - шаг. Выведет каждый второй символ
print text[::-1] # Шаг отрицательный. Выведет фразу наоборот
print text + "Nice to code you" # Выведет новую строку
print text[-1] * 10 # Выведет 10 восклицательных знаков

В результате вы увидите следующее

 

Списки в Python:

Списки, пожалуй, самый универсальный составной тип данных в Python. Список состоит из элементов, разделенных запятыми, находящихся между квадратными скобками ( [ ] ). В определенной мере, списки подобны массивам в C. Единственной разницей является то, что элементы одного списка могут иметь разные типы данных.

Получить доступ к элементам, сохраненным в списке можно, точно так же, как и в строках, при помощи оператора нарезки ( [ ] и [:] ) и индексов, начиная с нуля и до конца. Знак плюс ( + ) объединяет два списка, а звездочка ( * ) — оператор повторения для списка. Например:

my_list =[True, 786, 3.14, 'text', 70.2]
second_list =[123, 'text']

print my_list          # Напечатает весь список
print my_list[0]       # Напечатает первый элемент списка
print my_list[1:3]     # Напечатает элементы списка со второго по третий 
print my_list[2:]      # Напечатает элементы списка начиная с третьего
print second_list *2  # Напечатает удвоенный список
print my_list + second_list # Напечатает объединенные списки 

В результате вы увидите:

[True, 786, 3.14, 'text', 70.2]
True
[786, 3.14]
[3.14, 'text', 70.2]
[123, 'text', 123, 'text']
[True, 786, 3.14, 'text', 70.2, 123, 'text']

Кортежи в Python:

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

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

my_tuple =(True, 786, 3.14, 'text', 70.2)
second_tuple =(123, 'text') 

print my_tuple # Печатает весь кортеж
rint my_tuple[0] # Печатает первый элемент
print second_tuple *2 # Печатает удвоенный кортеж
print my_tuple + second_tuple # Печатает объединенные кортежи

В результате вы получите:

(True, 786, 3.14, 'text', 70.2)
True
(123, 'text', 123, 'text')
(True, 786, 3.14, 'text', 70.2, 123, 'text')

При этом, следующие действия доступны для списков и недоступны для кортежей:

my_list = ["Rome", 23, ["cat","dog"], True, 3.14]
my_tuple = ("Rome", 23, ["cat","dog"], True, 3.14)

my_list[0] = "Paris" # Замена значения первого элемента сработает для списка
my_tuple[0] = "Paris" # Та же операция для кортежа вызовет ошибку

Словари в Python:

Словари в Python это неотсортированная колекция элементов, доступ к которым осуществляется по ключу. То есть, каждому ключу словаря соответствует определенное значение. Ключом может быть любой неизменяемый тип данных (число, строка, кортеж), значением — любой тип данных.

Пары ключ, значение словаря заключаются в фигурные скобки ( { } ). Есть несколько способов создания словарей:

my_dict = { } # Создаем пустой словарь
my_dict["country"] = "Mexico" # Присваиваем ключу country значение Mexico
print my_dict["country"] # Выведет Mexico

# Заполнение словаря при инициализации
another_dict = {"number":23, 2: True, "my_list":[1,2,3]}
print another_dict.keys() # Напечатает список всех ключей
print another_dict.values() # Напечатает список всех значений

Данный код выведет следующее:

Обратите внимание, что ключи и значения выводятся не в том порядке, в котором мы их задавали.

Сеты в Python:

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

Создать сеты можно следующими способами:

# Создание пустого сета
s = set()
# Создание сета инициализацией
s = {"hi", "bye"}

Для добавление элемента в сет используется метод add, для удаления — pop или remove. Добавление в сет уже существующего элемента не повлияет на сет. Сеты обладают множеством методов для работы с уникальными элементами, например difference — возвращает элементы сета отсутствующие в другом сете, intersection — наоборот, возвращает елементы сета присутствующие в другом сете.

Преобразование типов данных:

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

Функция	Описание
int(x [,base])	Преобразовывает х в целое число. Например, int(12.4) -> 12
long(x [,base] )	Преобразовывает х в long. Например, long(20) -> 20L
float(x)	Преобразовывает х в число с плавающей точкой. Например float(10) -> 10.0
complex(real [,imag])	Создает комплексное число. Например complex(20) -> (20+0j)
str(x)	Преобразовывает х в строку. Например str(10) -> ’10’
tuple(s)	Преобразовывает s в кортеж. Например tuple(«hello») -> ( «h»,»e»,»l»,»l»,»o» )
list(s)	Преобразовывает s в список. Например list(«Python») -> [ «P»,»y»,»t»,»h»,»o»,»n» ]
dict(d)	Создает словарь из d. Например dict( [ (1,2), (3,4) ] ) -> { 1:2, 3:4 }

pythonicway.com

Переменные в Python: теория с примерами

Всем привет!

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

Объявление переменных

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

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

В данном примере мы создаем две переменные: foo и bar. Первая переменная содержит число, а вторая строку. Подробнее о типах в Python в следующем уроке. Как видите, для того чтобы присвоить переменной значение достаточно слева от оператора = указать ее имя, а с права ее значение. Если во время присваивания такой переменной нет, то интерпретатор Python’a создаст новую переменную с указанным именем и присвоит ей указанное значение.

Переменные в Python следует именовать в нижнем регистре и слова разделять нижним подчеркиванием: _. Например: max_age, init_state.

После объявления переменной мы можем ее использовать в любом выражении. В нашем примере, мы передали переменную bar в функцию print().

Вот результат работы программы:

Мы также можем указать значение для нескольких переменных за одну операцию:

a, b, c = 1, 1 + 1, ‘three’

a, b, c = 1, 1 + 1, ‘three’

В итоге мы получим следующие:

• a: значение 1 типа int
• b: два числа будут просуммированы и результат (2) будет записан в b
• c: в данном случае мы просто запишем строку в c

Данная операция называться деструктуризация и ее мы подробнее рассмотрим в уроке про списки в Python. Сейчас важно знать, что данная операцию может быть выполнена в три действия с тем же результатом:

a = 1 b = 1 + 1 c = ‘three’

a = 1 b = 1 + 1 c = ‘three’

Теперь давайте рассмотрим в каком случае Python будет создавать новую переменную, а в каком будет использовать существующую.

Область видимости переменной

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

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

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

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

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

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

Выполнив данный код вы увидите следующие:

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

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

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

Данный код выведет две двойки. Это связано с тем, что функция f обновляет не локальную переменную, а глобальную.

Использование переменной внешней функции (nonlocal)

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



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

Константы

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

UP = 1 RIGHT = 2 DOWN = 3 LEFT = 4

UP = 1 RIGHT = 2 DOWN = 3 LEFT = 4

Операторы присваивания

В Python для увеличения скорости написания кода предусмотрены сокращения для часто используемых операторов:

• += тоже что x = x + ...
• -= тоже что x = x - ...
• *= тоже что x = x  * ...
• /= тоже что x = x / ...
• %= тоже что x = x % ...

Пример:

Тест по теме: переменные в Python

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

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

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

If loading fails, click here to try again

Тест по уроку «Переменные в Python». Он поможет вам лучше усвоить материал.

Количество оставшихся вопросов: 4.

Задание

В рамках данного урока поэкспериментируйте с переменными. Попробуйте разные операторы, такие как +, -, * и т.д.

Поделиться ссылкой:

codelessons.ru

Создание переменных в Python 3 и присвоение значений — Объявление имени и вывод значения

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

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

Создание и присвоение значений

Создание переменной в Python 3 отличается от других языков программирования. Её не нужно заранее объявлять, указывать её тип, она создается в момент присваивания значения.

Чтобы создать переменную, используется символ равенства “=”. Слева от которого пишут наименование, а справа — значение нужного типа. Пример:

name = "Александр" # Типа str (строка)
age = 15 # Типа int (целое число)

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

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

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

Множественное присваивание и обмен значениями

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

a = b = c = 5 # Все (a, b и с) хранят значение 5

Кроме того, в отличие от других языков программирования Python позволяет обменять значения двух переменных –

a = 5, b = 3, с = 7
a, b = b, a # Теперь a = 3, а b = 5
a, b, c = c, a, b # Можно обменивать значения не только для двух

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

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

Имена

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

И если синтаксис накладывает на программиста мало ограничений, то IT сообщество требует “хороших” имён для переменных:

• Имя должно описывать назначение. Так как код может перечитываться и изменяться множество раз, названия переменных должны быть такими, чтобы по ним можно было понять, что она хранит и для чего используется.
• Не нужно использовать транслит. Если программист хочет создать переменную, хранящую возраст программиста, он должен писать не “vozrast”, а “age”. Это обусловлено тем, что английский — самый используемый язык в IT, название на английском поймут все, в любом случае, можно воспользоваться переводчиком.
• Приемлемая длина. Имя должно не только отражать суть, но и быть коротким, слишком длинные названия увеличивают объем кода и ухудшают его восприятие.

Для создания хороших имён используются следующие методы:

• CamelCase (верблюжий регистр): первое слово начинается с маленькой буквы, а следующие за ним с большой. В Python CamelCase принято использовать для имён классов. Например: WorkersOfFactory.
• Snake Case: имя состоит из слов, разделенных символом подчеркивания “_”, каждое слово пишут с маленькой буквы, например, hello_world. В Python Snake Case используется для имён функций, модулей и переменных. Такой стиль записи воспринимается лучше, чем CamelCase. Кроме того, он имеет несколько вариаций, которые не используются в Python: таких как запись через дефис “-” (kind-of-animals) и запись каждого слова с большой буквы (Sorted-Array-Of-Names).

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

Нельзя назвать переменную именем, которое уже зарезервировано, как ключевое слово. В Python есть около 33 зарезервированных имён: def, True, False, break и так далее.

Полный список ключевых слов можно посмотреть, набрав в интерпретаторе Python команду: help("keywords").

Вывод в консоль

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

• print(“{} – число, {} – слово”.format(number, word)). Например, переменная number хранит значение 5, а word хранит “пять”, тогда на экран выведется: “5 — число, пять — слово”.
• Можно обойтись без использования .format, достаточно писать составные части вывода через запятую: print(number, ” – число”, word, ” – слово”).

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

Пустая переменная

Переменная — это ссылка на какой-то объект, она не может не содержать совсем ничего. Если программист хочет сделать его пустой (условно пустой), он присваивает ей значение None.

None используется в случаях, когда значение не определено, не существует. И хотя он не эквивалентен какому-либо значению типа bool, строке или числу, он также является объектом.

При необходимости, можно проверить содержимое переменной следующим образом:

a = None
if a is None:
    print('значение равно None')
else:
    print('другое значение')

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

Области видимости

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

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

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

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

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

def count():
    n = 0
    def inc():
        n += 1 # Вызовется ошибка, функция не может получить доступ
        nonlocal n
        n += 1 # К n из внешней функции прибавится 1
        return n
    inc()
    return n # будет равна 1 (если закомментировать строку с ошибкой)

Удаление

Для удаления переменной в Python 3 можно воспользоваться функцией del(), в качестве аргумента в которую нужно передать её имя. Пример:

a = 5
del(a)
print(a) # Произойдёт исключение

Заключение

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

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

all-python.ru

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

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

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

Значения переменной в Python

Например, вам надо выполнить какие-то математические вычисления и у вас есть два числа: 70 и 30. Чтобы каждый раз не вводить эти числа, вы положите их в переменные: a и b, которые будете подставлять вместо чисел. Получается, что числа – это значения переменных.

a = 70
b = 30

a + b
100

a – b
40

Переменная может хранить не только число, но и целое выражение.

x = 345 + 355

Вывод результата значения переменной x:

print (x)
700

А какие ещё бывают значения? Значения переменных делятся по типу данных, с левой стороны – название типа данных.

• int — целое число 1, 2, 25, 100
• float — число с плавающей точкой 3.3 / 5.8
• str — строки, состоящие из символов в Unicode, ‘доброе утро’
• boolean — логическое значение True (5 > 2) / False (3 > 7)
• list – список, [‘user_1’, ‘user_2’, ‘user_3’, ‘user_4’]
• tuple – кортеж, (‘one’, ‘two’, ‘three’)
• set — коллекция
• dist — словарь, ключ / значение, {‘dog’: ‘собака’, ‘cat’: ‘кошка’}

Объявление переменных в Python

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

x=5 // создание переменной
print(x)
x = 5

Переменную можно изменить, положив в неё новое значение. При следующем присваивании, значение переменной заменяется.

x=10 // изменение значения переменной
print(x)
x = 10

Можно создавать сколько угодно разных переменных.

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

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

Список ключевых слов:

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

user_pass
userPass

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

Переменная в Python хранит в себе не само значение, а лишь ссылку на него. Поэтому легко можно заменять одно значение переменной на другое. Например, в переменной a хранилось число 10, мы присвоили ей значение другого типа – строку ‘I love Python’.

a=10
a='I love Python'

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

• числовые
• логические
• строковые
• списки
• коллекции
• словарные

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

Как узнать тип значения переменной?

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

Тип значения переменной целое число:

password=1234
type (password)
<class 'int'>

Тип значения переменной вещественное число:

result=1.2
type (result)
<class 'float'>

Заключение

Если вы решили освоить один из наиболее популярных языков программирования – Python и хотите изучить его в кратчайшие сроки. Я могу рекомендовать вам мой видеокурс: «Программирование на Python с Нуля до Гуру». Наверняка вы спросите: «Кто я такой, чтобы вы приобрели именно мой видеокурс?» Перейдите по этой ссылке и вы получите исчерпывающий ответ.

• Создано 14.10.2019 10:30:56
• Михаил Русаков

Копирование материалов разрешается только с указанием автора (Михаил Русаков) и индексируемой прямой ссылкой на сайт (http://myrusakov.ru)!

Добавляйтесь ко мне в друзья ВКонтакте: http://vk.com/myrusakov.
Если Вы хотите дать оценку мне и моей работе, то напишите её в моей группе: http://vk.com/rusakovmy.

Если Вы не хотите пропустить новые материалы на сайте,
то Вы можете подписаться на обновления: Подписаться на обновления

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

Если Вам понравился сайт, то разместите ссылку на него (у себя на сайте, на форуме, в контакте):

myrusakov.ru

Python | Переменные и типы данных

Переменные и типы данных

Последнее обновление: 10.09.2019

Переменная хранит определенные данные. Название переменной в Python должно начинаться с алфавитного символа или со знака подчеркивания и может содержать алфавитно-цифровые символы и знак подчеркивания. И кроме того, название переменной не должно совпадать с названием ключевых слов языка Python. Ключевых слов не так много, их легко запомнить: and, as, assert, break, class, continue, def, del, elif, else, except, False, finally, for, from, global, if, import, in, is, lambda, None, nonlocal, not, or, pass, raise, return, True, try, while, with, yield.

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

name = "Tom"

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

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

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

userName = "Tom"

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

user_name = "Tom"

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

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

• boolean — логическое значение True или False

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

• float — представляет число с плавающей точкой, например, 1.2 или 34.76

• complex — комплексные числа

• str — строки, например «hello». В Python 3.x строки представляют набор символов в кодировке Unicode

• bytes — последовательность чисел в диапазоне 0-255

• byte array — массив байтов, аналогичен bytes с тем отличием, что может изменяться

• list — список

• tuple — кортеж

• set — неупорядоченная коллекция уникальных объектов

• frozen set — то же самое, что и set, только не может изменяться (immutable)

• dict — словарь, где каждый элемент имеет ключ и значение

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

x = 3.9e3
print(x)  # 3900.0

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

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

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

user_id = "12tomsmith538"  # тип str
print(user_id)

user_id = 234  # тип int
print(user_id)

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

user_id = "12tomsmith538"
print(type(user_id))  # <class 'str'>

user_id = 234
print(type(user_id))  # <class 'int'>

metanit.com

изучение с нуля # 1. Синтаксис.

Этот курс познакомит вас с объектно-ориентированным, интерпретируемым языком программирования — Python.

Это перевод курса Python на сайте www.codecademy.com. Так как там он предоставлен только в английском виде — появилась идея перевести его на русский. По мере появления перевода других частей  они будут добавляться сюда.

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

Большая часть курса написана Eric Weinstein.

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

UPD: Продолжения перевода этого курса не будет, по крайней мере в обозримом будущем. Вместо него — в процессе перевода новый цикл, от tutorialspoint.com — Курс Python с нуля

Python Syntax

Часть 1. Переменные и типы данных

Часть 2. Пробелы и выражения

Часть 3. Комментарии

Часть 4. Математические операции

Часть 5. Заключение

Закрепление знаний

Часть 1. Переменные и типы данных

1. Добро пожаловать в Летающий Цирк.

Python — это мощный и гибкий язык программирования, который можно использовать для разработки web-приложений, для написания декстопных программ с графическим интерфейсом (GUI), на нём можно разрабатывать игры и многое другое.

Python это:

• язык программирования высокого уровня, то есть чтение кода на Python и написание кода на нём очень простое — он весьма схож с обычным английским языком;
• интерпретируемый — то есть, вам не потребуется специальный компилятор скриптов, чтобы писать на Python и запускать его скрипты;
• он объектно-ориентированный, то есть — позволяет пользователям управлять структурами данных, называемыми «объекты«, для построения и выполнения программ, мы обсудим объекты позже, в нашем курсе.;
• весёлый в изучении и использовании. Python получил своё название в честь Летающего Цирка Монти Пайтона (Monty Python’s Flying Circus), и примеры в коде и учебники часто ссылаются на это шоу и включают в себя шутки, что бы сделать изучения языка более интересным.

Этот курс не предполагает каких-либо знаний у вас о Python в частности, или о программировании в целом.

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

Одним из наиболее важных понятий в программировании является понятие «переменная«. Переменными называют слово/идентификатор, которое содержит единственное значение. Например, предположим что вам требуется число 5 в вашей программе, но вы не хотите использовать его немедленно. Вы можете назначить переменную, назовём её «spam« которая имеет значение «5» и хранит его для использования в дальнейшем:

>>> spam = 5

Объявить переменную в Python очень просто — просто указываете имя/идентификатор, как spam и используете знак = для присвоения ей значения — всё готово!

Давайте зададим переменной my_variable значение 10, и посмотрим его вывод:

>>> my_variable = 10
>>> my_variable
10

3. Типы данных

Отлично, теперь мы можем вызывать значение 10 просто вызывая переменную my_variable где угодно, когда нам потребуется.

В этом случае, тип данных переменной my_variable является integer (положительное или отрицательное целое число). В Python на сегодняшний день существует три типа данных: integers, floats (дробные числительные, например 1.970) и booleans (логический тип данных, который может принимать значение либо True (истина), либо False (ложно)).

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

Никогда не используйте кавычки ( ‘ или « ) при определении логических True или False, и всегда указывайте их с Большой буквы. Python — регистро-зависимый язык, и значения для true, truE или True будут совершенно разными. Что касается кавычек, мы начнём использовать их, когда дойдём до изучения последовательностей (strings), которые будут обсуждать в следующих частях.

Давайте установим такие значения нашим переменным:

1. my_int to the value 7
2. my_float to the value 1.23
3. my_bool to the value True

Python detected the following datatypes:
my_int is of <type ‘int’>
my_float is of <type ‘float’>
my_bool is of <type ‘bool’>

4. Переназначение данных

Теперь вы знаете как объявлять переменные и присваивать им разные значения. Так же, вы узнали о трёх типах данных — integers, floats, и booleans.

Вы можете переназначить значение переменной в любое время. Если сначала вы установили для переменной my_int значение 7, но потом решили изменить его на 3 — просто скажите Python-у: my_int = 3 — и он изменит значение этой переменной:

>>> my_int = 7
>>> my_int
7
>>> my_int = 3
>>> my_int
3

Часть 2. Пробелы и выражения

1. Что такое операторы

Вы можете думать о выражениях (statements) Python-a как о простых фразах в английском: это наименьшие объекты в языке, которые имеют смысл. Как, например — «Я«, «люблю» и «Спам» не являются простыми выраженими сами по себе и не несут смысловой нагрузки, но «Я люблю спам» — это уже фраза, имеющая определённое значение. Так же переменные и типы данных не являются выражениями сами по себе, но они являются «строительными блоками», из которых формируются выражения.

Продолжая аналогию с выражения ясно, что нам нужны определённые правила пунктуации, что бы определить где заканчивается одно выражения и начинается другое. Если вы знакомы с JavaScript, вы знаете что в нём операторы заканчиваются символом точки с запятой — » ; «. В Python операторы разделяются пробелами. Так же, как вы не можете в JavaScript вынести часть кода за пределы ограничивающих его точки с запятой, так же не сможете обойти пробел в Python-е.

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

Возьмём, например, скрипт с таким кодом:

def spam():
eggs = 12
return eggs
print spam()

При его выполнении — мы получим сообщени от интерпретатора Python-a об ошибке:

File «./codeacademy_example_1.py», line 5
eggs = 12
^
IndentationError: expected an indented block

Вот само описание: «expected an indented block» — ожидаются отступы блока.

2. Пробелы — значит Правильные отступы

Запомните ошибку, которую вы получили в предыдущем примере: «ожидаются отступы блока«. Вы будете получать такое же сообщение везде, где в коде Python вы будете неправильно использовать пробелы. Если вы ранее изучали JavaScript — думайте о неправильном использовании пробелов в Python как о неправильном использовании символов ; или {} в JS. Если вы используете неправильные знаки препинания, смысл ваших слов может совершенно измениться:

Крестьянин сказал — «Ведьма превратила меня в лягушку!».

Или:

«Крестьянин, — сказала ведьма, — превратил меня в лягушку!».

Понимаете, что мы имеем ввиду?

Давайте правильно расставим отступы в коде с помощью клавиши табуляции Tab на вашей клавиатуре — один раз на второй строке перед eggs, и ещё раз на строке 3 перед return:

def spam():

eggs = 12
return eggs

print spam()

3. Про интерпретатор

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

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

Давайте дадим задачу интепретатору назначить значение True для переменной spam, и False — для eggs:

>>> spam = True
>>> eggs = False
>>> spam
True
>>> eggs
False
>>> print spam, eggs
True False

Часть 3. Комментарии

1. Однострочные комментарии

Вы можете добавлять заметки в ваш код, устанавливая символ # (hash) в начале строки. Эти строки в коде называются комментариями, и они игнорируются интерпретатором — они совершенно не влияют на исполнение кода. Это просто текстовые замечания, написанные программистами что бы дать некоторые инструкции или пояснения к конкретной части программы.

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

2. Многострочные комментарии

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

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

«»»Я программист, и я счастлив.
Я ем Мивину и запиваю её чаем!»»»

Часть 4. Математические операции

1. Арифметические операторы

Выражения в Python не ограничены только простыми выражениями типа spam = 3. Они могут так же включать в себя математические выражения, использующие арифметические операторы (arithmetic operators).

Есть шесть таких арифметических операторов, которые мы и будем рассматривать:

1. Сложение (Addition) (+)
2. Вычитание (Subtraction) (-)
3. Умножение (Multiplication) (*)
4. Деление (Division) (/)
5. Возведение в квадрат (Exponentiation) (**)
6. Деление с остатком (Modulo) (%)

Давайте начнём со сложения. Установим значение переменной big_var равным сумме 1 + 2:

>>> big_var = 3 + 2
>>> big_var
5

2. Вычитание (Subtraction)

Теперь — попробуем вычитание.

Мы уже посчитали, что значение переменной big_var равняется 5, но теперь хотим уменьшить его. Укажем интерпретатору переназначить значение переменной, выполнив вычитание 5 — 2:

>>> big_var = 5 — 2
>>> big_var
3

3. Умножение (Multiplication)

Теперь — давайте попробуем выполнить умножение.

Рыцарь, который сказал «Ni!» сказал это дважды. Давайте сделаем это 20 раз, умножив 2 * 10:

>>> ni = 2 * 10
>>> ni
20

4. Деление (Division)

Немного подумав, мы решили что 20 «Ni!» будет слишком много. Давайте используем деление, что бы уменьшить значение до 5:

>>> ni = 20 / 4
>>> ni
5

5. Возведение в степень (Exponentiation)

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

Арифметический оператор ** возводит первое число — base, в значение второго числа — exponent. Так, если вы наберёте 2 ** 3 — вы получите 8 (2 ** 3 это тоже самое, что 2 * 2 * 2 — обе операции дадут значение 8). 5 ** 2 = 25, 2 ** 4 = 16 и так далее.

Итак, наш дровосек очень голоден, и хочет съесть сразу 100 яиц. Давайте установим значение переменной eggs равным 100, используя Exponentiation:

>>> eggs = 10**2
>>> eggs
100

6. Деление с остатком (Modulo)

Теперь у нас множество яиц. Надеюсь — вы оставили место в комнате для spam? (что тут имеется ввиду — затрудняюсь сказать… вероятно — мясные консервы производителя Spam — прим. перевод.)

Наша последняя арифметическая операция — деление с остатком, modulo (так же называемая modulus). Modulo возвращает остаток, полученный в результате деления (division) двух целых (integer) чисел.

Так, если вы попросите интерпретатор посчитать значение 5 % 2 — вы получите результат 1 (т.к. 2 входит в 5 дважды и даёт остаток 1). 10 % 5 = 0, 113 % 100 = 13 и так далее. Давайте у становим значение переменной spam равным 1, используя modulo:

>>> spam = 45 % 22
>>> spam
1

Часть 5. Заключение.

1. Соберём всё в одном

Итак, вы изучили такие понятия в Python:

• Переменные, которые заключают в себе значения;
• Типы данных, такие как integers, floats, и booleans;
• Пробелы, и почему они так важны;
• Операнды, и чем они схожи с фразами в английском языке;
• Комментарии, и почему они так нужны в вашем коде;
• Арифметические действия и оператыры, такие как +, -, *, /, **, и %)

Давайте соберём все наши знания в одно целое, и заставим это всё поработать.

• напишем однострочный комментарий;
• объявим переменную monty и установим её значение равным True;
• объявим вторую переменную, и устанвоим её значеине раыным 1.234;
• объявим третью переменную, и установим её значение равнывм python в степени 2.

>>> monty = True
>>> python = 1.234
>>> monty_python  = python ** 2
>>> monty_python
1.522756

Закрепление знаний

1. Ваша любимая еда.

Этот раздел написан специально для закрепления материала первого раздела — Python Syntax.

Итак, вы только что заказали прекрасную порцию вкусного мяса (spam) и яиц (eggs).

Вот как это выглядит в цифрах:

Стоимость еды (meal): $44.50

Надбавка ресторана (tax): 6.75%

Чаевые (tip): 15%

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

Для начала, давайте зададим значение переменной meal равным 44.50:

>>> meal = 44.50
>>> meal
44.5

2. Ресторанная надбавка

Теперь — давайте создадим значение для переменной надбавка.

Надбавка стоимости вашей еды составит 6.75%. Так как мы будем иметь дело с дробными числами, а не с процентами, давайте переведём это значение в float, т.е. дробное десятичное число. Для этого — поделим 6.75 на 100, в результате мы получим обычное десятичное число.

Создадим переменную tax и установим её значение равным десятичному значению 6.75%:

>>> tax = 6.75 / 100
>>> tax
0.0675

3. Чаевые

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

Перед тем, как с читать общую стоимость, давайте установим значение для переменной tip в размере 15%. Опять-таки, эта цифра в процентах — так что нам надо поделить 15.0 на 100, чтобы получить десятичное значение:

>>> meal = 44.50
>>> tax = 0.0675
>>> tip = 15.0 / 100
>>> tip
0.15

4. Переназначем значение в одну строку

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

Мы видели в предыдущих уроках, что мы можем переназначать значение переменной когда нам потребуется. Например, мы можем установить значение переменной spam = 7 в одном месте программы, и позже изменить его на другое, указав spam = 3.

Давайте переназначим значение переменной meal на значение meal + meal * tax. Вы можете менять значение переменной, применяя в новом значении её старое значение:

>>> meal = 44.50
>>> tax = 0.0675
>>> tip = 0.15
>>> meal = 44.50 + 44.50 * 0.0675
>>> print meal
47.50375

5. Второй куплет похож на первый

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

Теперь, когда значение переменной meal равно стоимости food + tax, давайте зададим новую переменную total, которая будет содержать значение равное meal + meal * tip. Это действие очень похоже на выполненное только что.

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

Установим значение total в качестве суммы meal + meal * tip:

>>> meal = 44.50
>>> tax = 0.0675
>>> tip = 0.15
>>> meal = meal + meal * tax
>>> total = meal + meal * tip
>>> print(«%.2f» % total)
54.63

На этом упражнение закончено, и вы можете переходить ко второй части — Python: изучение с нуля # 2. Strings and Console Output.

rtfm.co.ua