Краткое введение в ООП
Объектно-ориентированное программирование (ООП) – технология разработки сложного программного обеспечения, в которой программа строится в виде совокупности объектов и их взаимосвязей.
Объединение данных и действий, производимых над этими данными, в единое целое, которое называется объектом – является одним из основных принципов ООП.
Основными понятиями являются понятие класса и объекта.
Класс является типом данных, определяемым пользователем и представляет собой структуру в виде данных и методов для работы с данными.
Формально Класс — это шаблон, по которому будет сделан объект.
Объект является экземпляром класса. Объект и экземпляр - это одно и то же.
Вот пример. Форма для изготовления печенья – это класс, а само печенье это объект или экземпляр класса, т.е. это конкретное изделие. Печенье имеет размеры, цвет, состав – это атрибуты класса. Также в классе описываются методы, которые предназначены для чтения или изменения данных объекта.
В Python характеристики объекта, называются атрибутами, а действия, которые мы можем проделывать с объектами, — методами. Методами в Python называют функции, которые определяются внутри класса.
Объект = атрибуты + методы
Ссылки на объекты
Что на самом деле происходит, когда вы присваиваете переменную? Это важный вопрос для Python, потому что ответ несколько отличается от того, что вы найдете во многих других языках программирования.
Python – это весьма объектно-ориентированный язык. Фактически, практически каждый элемент данных в программе Python является объектом определенного типа или класса.
Рассмотрим этот код:
ри представлении оператора print (300) интерпретатор выполняет следующие действия:
- Создает целочисленный объект
- Придает ему значение 300
- Отображает его на консоли
Вы можете видеть, что целочисленный объект создается с помощью встроенной функции type():
Переменная Python – это символическое имя, которое является ссылкой или указателем на объект. После того, как объект назначен переменной, вы можете ссылаться на объект по этому имени. Но сами данные все еще содержатся в объекте.
Например:
Это присвоение создает целочисленный объект со значением 300 и присваивает переменной n, указывающей на этот объект.
Следующий код проверяет, что n указывает на целочисленный объект:
Теперь рассмотрим следующее утверждение:
Что происходит, когда он выполняется? Python не создает другой объект. Он просто создает новое символическое имя или ссылку, m, которая указывает на тот же объект, на который указывает n.
Множественные ссылки на один объект
Далее предположим, что вы делаете это:
Теперь Python создает новый целочисленный объект со значением 400, и m становится ссылкой на него.
Ссылки на отдельные объекты
Наконец, предположим, что этот оператор выполняется следующим образом:
Теперь Python создает строковый объект со значением «foo» и делает ссылку на n.
Ссылка на целочисленный объект 300 больше не существует. Он потерян, и к нему невозможно получить доступ.
В руководствах этой серии иногда упоминается время жизни объекта. Жизнь объекта начинается с момента его создания, когда создается по крайней мере одна ссылка на него. Во время существования объекта могут быть созданы дополнительные ссылки на него, как вы видели выше, а также ссылки на него могут быть удалены. Объект как бы остается в живых, пока на него есть хотя бы одна ссылка.
Когда количество ссылок на объект падает до нуля, он становится недоступным. На этом его срок службы закончился. Python в конечном итоге заметит, что он недоступен, и освободит выделенную память, чтобы ее можно было использовать для чего-то другого. На компьютерном жаргоне этот процесс называется сборкой мусора.
Область видимости
В Python есть два типа переменных. Локальные и глобальные:
- Локальные переменные: Всякий раз, когда Python выполняет функцию, он создает локальную среду, содержащую имена переменных и параметров, назначенных внутри функции. Переменные в этой локальной среде называются локальными переменными.
- Глобальные переменные: Переменная, созданная вне функции в глобальном пространстве имен, называется глобальной переменной. Эти переменные могут быть использованы в любой функции.
Чтобы еще больше прояснить наше понимание области видимости переменных и переопределения, давайте рассмотрим этот пример:
a = 10
b = 20
c = 30
def myfunc ():
global c
a = 12
c ="Hello World"
print("Value of a inside the function: "+str(a))
print("Memory location of a inside func: "+str(id(a)))
print("Value of b inside the function: "+str(b))
print("Memory location of c inside func: "+str(id(c)))
print("Value of c inside the function: "+str(c))
myfunc()
print("Memory location of a outside func: "+str(id(a)))
print("Global variable a after running the func: "+ str(a))
print("Global variable b after running the func: "+ str(b))
print("Memory location of c outside func: "+str(id(c)))
print("Global variable c after running the func: "+ str(c))
Вывод программы:
Value of a inside the function: 12 Memory location of a inside func: 140196548835392 Value of b inside the function: 20 Memory location of c inside func: 140196486430000 Value of c inside the function: Hello World Memory location of a outside func: 140196548835328 Global variable a after running the func: 10 Global variable b after running the func: 20 Memory location of c outside func: 140196486430000 Global variable c after running the func: Hello World
Здесь я определил три глобальные переменные «a»,»b» и «c». Все они изначально представляли собой целочисленные значения.
В функции «myfunc()» я представил глобальную переменную, добавив ключевое слово «global» перед «c». И как вы видите, когда я изменил значение «c» с «30» на «Hello World», оно изменилось глобально. Однако значение «a» сохранялось только в пределах области действия функции.
Это происходит потому, что Python проверяет существование переменной в двух местах: в функции и в глобальном пространстве имен. Когда я присвоил значение «a — 12», интерпретатор обнаружил, что это значение было определено внутри функции, и напечатал его значение. Здесь переменная «a» является локальной для функции, поэтому она исчезает, когда функция завершается.
Поскольку «b» не определена внутри функции, эту переменную искали в глобальном пространстве имен. Аналогично для «с», переменная увидела ключевое слово «global» и заглянула в глобальное пространство имен. Здесь переменная «c» рассматривается как глобальная переменная, и поэтому ее значение изменяется в глобальной области.
Объявление переменной
Python — это динамически типизированный язык. Таким образом, в отличие от Java или C, когда мы инициализируем переменную, нам не нужно объявлять ее тип.
Хотя переменные представляют определенные значения, такие как «String» и «Int», имя переменной, указывающее на эти значения, необязательно должно иметь тип. Переменные — это просто ссылка на ячейку памяти.
Вы можете легко переопределить переменную, как только вы ее объявите. После повторного объявления переменной она просто указывает на другую ячейку памяти, и предыдущее значение теряется:
x = 4 type(x) x = "Test variable" type(a)
Правила объявления переменных:
- Название должно начинаться либо с «__», либо с какой-либо буквы. Название не может начинаться с каких-либо числовых значений.
- Переменные могут состоять только из буквенно-цифровых символов и символов подчеркивания (A-Z, a-z,0-9 и __).
- Переменные чувствительны к регистру. PyThon отличается от Python.
- Существуют определенные зарезервированные ключевые слова, такие как «if», «break», «class» и «del», которые не могут использоваться в качестве имен переменных. Список ключевых слов вы можете найти здесь.
Присвоение переменной
Думайте о переменной как об имени, прикрепленном к определенному объекту. В Python переменные не нужно объявлять или определять заранее, как это имеет место во многих других языках программирования. Чтобы создать переменную, вы просто присваиваете ей значение, а затем начинаете использовать. Присваивание выполняется с помощью единственного знака равенства (=):
Это читается или интерпретируется как «n присвоено значение 300». Как только это будет сделано, n можно использовать в операторе или выражении, и его значение будет заменено:
Так же, как буквальное значение может отображаться непосредственно из приглашения интерпретатора в сеансе REPL без необходимости print(), переменная может:
Позже, если вы измените значение n и используете его снова, вместо него будет подставлено новое значение:
Python также позволяет назначать цепочки, что позволяет назначать одно и то же значение нескольким переменным одновременно:
Цепное присвоение, приведенное выше, одновременно присваивает 300 переменных a, b и c.
1. Встроенная функция range.
Встроенная функция range() используется для построения числовых последовательностей. В примере используем команду и функцию range для выполнения ровно 10 итераций с выводом значения от 0 до 10.
>>> for x in range(10)
… print(x, end=’ ‘)
…0 1 2 3 4 5 6 7 8 9
При передаче только одного аргумента, последовательность будет начинаться с 0 и до значения аргумента (10), не включая его. Одна из самых распространённых ошибок, это когда разработчик предполагает, что значение аргумента функции range включается в сгенерированную последовательность.
Приведем пример с двумя аргументами. Выведем последовательность от 20 до 30.
>>> for x in range(20, 30)
… print(x, end=’ ‘)
…20 21 22 23 24 25 26 27 28 29
2.2. Создание числового списка с помощью функции range.
С помощью функции range удобно строить числовые списки.
>>> numbers = list(range(5, 25))
>>> print(numbers)
Функция range может создавать последовательности, пропуская числа в заданном диапазоне. Например, приведем пример построения списка от 0 до 100, с шагом 15.
>>> numbers = list(range(0, 100, 15))
>>> print(numbers)
С помощью цикла for и функции range можно создавать практически любой числовой список. К примеру, создадим список квадратов всех числе от 1 до 10. Операция возведения в степень обозначается двумя звездочками (**).
>>> a = []
>>> for i in range(1, 11)
… a.append(i**2)
…
>>> print(a)
На каждом цикле переменная возводится в квадрат и добавляется в список.
2.4. Перебор списка по индексам с помощью функции range
С помощью цикла и функции список можно перебирать по индексам и с каждым значением в списки, производить любые операции. Приведем пример, перебора списка по индексам, с помощью функции и функции, которая определяет длину списка.
>>> list_1 =
>>> index ((list_1)):
… list_1 += 100
…
>>> print(list_1)
В начале определим длину списка с помощью функции. Затем это значение передается функции. В нашем примере длина списка равна 6. С каждым проходом цикла , index принимает значения от 0 до 6 (не включая 6). В теле цикла мы вызываем список list_1 и обращаемся к элементам списка по индексам, равные значению переменной index. Каждое значение индекса мы увеличивает на 100. Затем с помощью функции print выводим список на экран и видим что все значения увеличены на 100.
С помощью индексов и функции мы можем объединять информацию из разных списков. В примере ниже мы имеем список с именами, а второй список с фамилиями. Выведем на экран имя и фамилию:
>>> list_4 =
>>> list_5 =
>>> index ((list_4)):
… print(list_4, list_5)
…Artem Ivanov
Serg Petrov
Georgy Sidorov
Petr Ulyanov
В результате получили общие данные на экране.
Аналогично можно создавать новые списки из двух или трех списков. Приведем пример перемножения трех списков:
>>> list_1 =
>>> list_2 =
>>> list_3 =
>>> list_new = []
>>> index ((list_1)):
… list_new.(list_1 * list_2 * list_3)
…
>>> print(list_new)
В начале мы создадим пустой новый список вне цикла, куда будем добавлять результат с помощью функции . В результате мы получим новый список с результатом перемножения предыдущих списков по индексам.
Важно помнить, что программа будет работать, если вы уверены, что списки одинаковой длины. Проверить это вы всегда можете с помощью встроенной функции .
Числовые типы
Данные, представленные как числа, являются одними из наиболее важных в программировании. В Python для работы с такими данными создано несколько типов данных:
— целочисленный,
— вещественный,
— комплексный,
— логический.
Int целое число
Понять целые числа очень просто. Самое простое определение: целые числа — это числа без дробной части. Могут быть нулём, положительными или отрицательными.
Копировать
Если есть числа, то к ним применимы математические операции. Целочисленные данные используются для исчисления разных математических выражений. Также int используется для описания количественных характеристик объектов.
Float число с плавающей точкой
Действительные или вещественные числа (числа с плавающей точкой) созданы для измерения непрерывных величин. Языки программирования не способы реализовать иррациональные или бесконечные числа, поэтому всегда есть место приближению с определенной точностью, а значит, и некоторые неточности, из-за чего возможны следующие ситуации:
Копировать
Объявление float ничем не отличаются от int:
Копировать
Не забудьте, что разделителем является точка, а не запятая! Если использовать запятую, интерпретатор Питона решит. Что имеет дело с кортежем целых чисел:
Копировать
Без этого типа, конечно же, не получится использовать сложную математику.
Complex комплексное число
Как действительные числа расширяют множество рациональных чисел, так и комплексные расширяют ряд вещественных. Яркой особенностью комплексного ряда является то, что можно извлечь корень из отрицательного числа.
В Python комплексные числа задаются с помощью функции complex():
Копировать
Комплексные числа широко применяются в сложных математических вычислениях, но, в большинстве случаев, этот тип данных Вам не пригодится.
Bool логический тип данных
Это достаточно простой для понимания тип. У bool есть всего два значения:
- Истина/Да (True);
- Ложь/Нет (False).
True эквивалентен единице, а False – нулю. Именно поэтому мы отнесли данный тип данных к числовым. Этот тип данных является наиболее часто используемым в программировании, поскольку он участвует в сравнениях, ветвлениях и циклах.
Как перебрать последовательность с помощью функции enumerate() в Python
Функция перебирает последовательность (список, кортеж, строку или словарь), одновременно отслеживая значения индексов элементов последовательности.
Давайте посмотрим на синтаксис:
Функция принимает два аргумента:
- – итерируемый объект (т.е. объект, который можно перебрать в цикле).
- – значение индекса или начальное значение счетчика. По умолчанию данный аргумент равен нулю.
Результат работы такой функции будет следующим:
# Output #
Мы получили элементы итерируемого объекта вместе с их индексами.
Возьмем пример без указания значения :
colour = list(enumerate(colour)) # Output: #
Как видите, индексирование начинается с 0, хотя мы не указывали второй аргумент при вызове функции. Всё потому, что по умолчанию значение аргумента равно 0.
Возьмем еще один пример с указанием индекса:
colour = list(enumerate(colour, 10)) # Output: #
Итак, здесь наш индекс начинается с 10, поскольку мы устанавливаем аргумент равным 10. В результате функция начинает отсчет индексов с 10.
Обратите внимание, что нужно явно указывать, хотите вы получить результат в виде списка или в виде кортежа. В нашем коде мы указывали, что хотим получить список —
Если просто вызвать функцию enumerate(), результат будет следующим:
colour = enumerate(colour) # Output: # <enumerate object at 0x7f6a97ad7c40>
Возьмем пример со словарем:
colour = {"Black": 0,
"Purple": 2,
"Brown": 4,
"Yellow": 9,
"Blue": 1}
list(enumerate(colour))
# Output:
#
Перебирая словарь, мы получаем только ключи, а не значения словаря.
Начало работы в Питоне
Первое, что делают при изучении любого языка программирования, – вывод в консоль популярного сообщения «Hello world». Немного поменяем вывод, и в пустом файле скрипта напишем следующую команду:
Print – встроенная в Python функция, которая выводит на печать переданное в нее сообщение. Запуск скрипта отобразит в терминале соответствующую фразу.
Еще одна полезная команда – input. Она позволяет как бы общаться с пользователем при помощи консоли. Исполним следующий код:
Функция input приостанавливает исполнение скрипта до тех пор, пока пользователь не введет свой ответ. Сначала в консоли потребуется представиться, а потом передать свой возраст. И лишь потом в терминале отобразится сообщение: «Рад знакомству!».
Пока что все наши операции не имели большого смысла и никак не использовались в других местах программы, но легкость Питона, уважаемые читатели, наверняка ощущается.
Обсудим базовый синтаксис языка Python:
- Любая часть кода отделяется от предыдущей переводом на новую строку (не нужно никаких точек с запятой в конце);
- Отступы внутри блоков кода (о них пойдет речь дальше) задаются 4-мя пробелами;
- Создаваемые функции и объекты отделяются друг от друга двумя пустыми строчками.
Даже если вы и забудете о сказанном, PyCharm вам напомнит: он подчеркнет синтаксические ошибки, даст подсказки по используемым функциям. Это не просто удобно, но и экономит массу времени.
Данная фраза от создателя языка свидетельствует о том, что Питон в своем синтаксисе максимально прозрачен.
Кавычки
Одинарные кавычки
Строку можно указать, используя одинарные кавычки, как например, ‘Это строка’. Любой одиночный символ в кавычках, например, ‘ю’ — это строка. Пустая строка » — это тоже строка. То есть строкой мы считаем всё, что находится внутри кавычек.
Двойные кавычки
Запись строки в одинарных кавычках это не единственный способ. Можно использовать и двойные кавычки, как например, »Это строка». Для интерпретатора разницы между записями строки в одинарных и двойных кавычках нет.
ВниманиеЕсли строка началась с двойной кавычки — значит и закончиться должна на двойной кавычке. Если внутри строки мы хотим использовать двойные кавычки, то саму строку надо делать в одинарных кавычках.
Театр »Современник»print(‘Театр »Современник»’)
Тройные кавычки
Строка, занимающая несколько строк, должна быть обрамлена тройными кавычками (» » » или »’). Например:
Правила написания идентификаторов
Есть некоторые правила написания идентификаторов. Но сначала вы должны знать, что Python чувствителен к регистру. Это означает, что имя и имя – это два разных идентификатора в Python. Вот несколько правил написания идентификаторов в Python:
- Идентификаторы могут быть комбинацией прописных и строчных букв, цифр или символа подчеркивания (_). Итак, myVariable, variable_1, variable_for_print – все это действительные идентификаторы Python.
- Идентификатор не может начинаться с цифры. Итак, пока переменная 1 действительна, переменная 1 недействительна.
- Мы не можем использовать специальные символы, такие как!, #, @,%, $ И т. Д. В нашем идентификаторе.
- Идентификатор может быть любой длины.
Хотя это жесткие правила для написания идентификаторов, также существуют некоторые соглашения об именах, которые не являются обязательными, а скорее являются хорошими примерами, которых следует придерживаться:
- Имена классов начинаются с заглавной буквы. Все остальные идентификаторы начинаются со строчной буквы.
- Если идентификатор начинается с одного символа подчеркивания в начале, это означает, что идентификатор является частным.
- Если идентификатор начинается и заканчивается двумя символами подчеркивания, это означает, что идентификатор является определяемым языком специальным именем.
- Хотя c = 10 действительно, запись count = 10 имела бы больше смысла, и было бы легче понять, что он делает, даже если вы посмотрите на свой код спустя долгое время.
- Несколько слов можно разделить знаком подчеркивания, например this_is_a_variable.
Вот пример программы для переменных в Python:
myVariable="hello world" print(myVariable) var1=1 print(var1) var2=2 print(var2)
Если вы запустите программу, результат будет таким, как на изображении ниже.
Аргументы ключевого слова(** kwargs)
Python позволяет нам вызывать функцию с аргументами ключевых слов. Такой вызов функции позволит нам передавать аргументы в случайном порядке.
Имя аргументов рассматривается как ключевое слово и сопоставляется при вызове и определении функции. Если такое же совпадение найдено, значения аргументов копируются в определение функции.
Рассмотрим следующие примеры.
Пример 1.
#function func is called with the name and message as the keyword arguments
def func(name,message):
print("printing the message with",name,"and ",message)
#name and message is copied with the values John and hello respectively
func(name = "John",message="hello")
Выход:
Пример 2. С указанием значений в другом порядке при вызове.
#The function simple_interest(p, t, r) is called with the keyword arguments the order of arguments doesn't matter in this case
def simple_interest(p,t,r):
return(p*t*r)/100
print("Simple Interest: ",simple_interest(t=10,r=10,p=1900))
Выход:
Если мы предоставим другое имя аргументов во время вызова функции, будет выдана ошибка.
Рассмотрим следующий пример.
Пример 3.
#The function simple_interest(p, t, r) is called with the keyword arguments.
def simple_interest(p,t,r):
return(p*t*r)/100
# doesn't find the exact match of the name of the arguments(keywords)
print("Simple Interest: ",simple_interest(time=10,rate=10,principle=1900))
Выход:
Python позволяет нам предоставлять сочетание необходимых аргументов и аргументов ключевого слова во время вызова функции. Однако обязательный аргумент не должен указываться после аргумента ключевого слова, т. е. после того, как аргумент ключевого слова встречается в вызове функции, следующие аргументы также должны быть аргументами ключевого слова.
Рассмотрим следующие примеры.
Пример 4.
def func(name1,message,name2):
print("printing the message with",name1,",",message,",and",name2)
#the first argument is not the keyword argument
func("John",message="hello",name2="David")
Выход:
Следующий пример вызовет ошибку из-за неправильного сочетания ключевого слова и требуемых аргументов, переданных в вызове функции.
Пример 5.
def func(name1,message,name2):
print("printing the message with",name1,",",message,",and",name2)
func("John",message="hello","David")
Выход:
Python предоставляет возможность передавать несколько аргументов ключевого слова, которые могут быть представлены как ** kwargs. Похож на * args, но сохраняет аргумент в формате словаря. Этот тип аргументов полезен, когда мы не знаем заранее количество аргументов.
Рассмотрим следующий пример:
Пример 6. Многие аргументы используют аргумент ключевого слова.
def food(**kwargs):
print(kwargs)
food(a="Apple")
food(fruits="Orange", Vagitables="Carrot")
Выход:
{'a': 'Apple'}
{'fruits': 'Orange', 'Vagitables': 'Carrot'}
Что такое переменные
Переменная – это именованный фрагмент памяти, используемый для хранения разных значений. Часть информации, на которую можно сослаться несколько раз, может быть сохранена в переменной для последующего использования или модификации. В JavaScript значение, содержащееся внутри переменной, может быть любым типом данных, включая число, строку или объект.
До спецификации языка ECMAScript 2015 (ES6), на котором основан JavaScript в данный момент, существовал только один способ объявить переменную – с использованием ключевого слова var. Потому большинство старых кодов и мануалов используют для объявления переменных только var. Давайте рассмотрим различия между var, let и const.
Ключевое слово var позволяет продемонстрировать концепцию самой переменной. В приведенном ниже примере мы объявляем переменную и присваиваем ей значение.
Это выражение состоит из нескольких частей:
- Объявление переменной с помощью ключевого слова var;
- Имя переменной (или идентификатор), username;
- Операция присваивания, представленная синтаксисом =;
- Присваиваемое значение, “8host_blog”.
Теперь можно использовать переменную username в коде. JavaScript запомнит, что username представляет значение 8host_blog.
Как упоминалось ранее, переменные могут выражаться любым типом данных JavaScript. В этом примере переменные выражаются строкой, числом, объектом, логическим значением и нулевым значением.
С помощью console.log можно просмотреть значение любой переменной:
Переменные хранят в памяти данные, которые впоследствии можно использовать или изменить. Переменные также можно переназначить и присвоить им новое значение. Простой пример ниже демонстрирует, как в переменной можно сохранить, а затем обновить пароль.
В реальной программе пароль, скорее всего, будет надежно сохранен в базе данных. Однако этот простой пример иллюстрирует ситуацию, в которой вы можете обновить значение переменной. Значение переменной password было hunter2, но ей было присвоено новое значение, hunter3, и теперь JavaScript будет использовать новое значение.
Контроль типов в Python
Рассмотрим небольшую демонстрацию того, как решался вопрос контроля типов в Python без использования аннотаций. Один из возможных вариантов (наверное самый логичный) решения данной задачи – это использование комментариев, составленных определенным образом.
Выглядит это так:
name = "John" # type: str
Мы создали переменную с именем name и предполагаем, что ее тип – str. Естественно, для самого интерпретатора Python это не имеет значения, мы, без труда можем продолжить нашу мини программу таким образом.
name = "John" # type: str print(name) name = 10 print(name)
И это будет корректно с точки зрения Python. Но если необходимо проконтролировать, что переменной name будут присваиваться значения только строкового типа, мы должны: во-первых указать в комментарии о нашем намерение – это мы сделали, во-вторых использовать специальный инструмент, который выполнит соответствующую проверку. Таким инструментом является mypy.
Установить его можно с помощью pip
python -m pip install mypy
Если мы сохраним приведенный выше код в файле type_tester.py и выполним следующую команду:
python -m mypy test_type.py
Получим такое сообщение:
test_type.py:3: error: Incompatible types in assignment (expression has type “int”, variable has type “str”)
Оно говорит о том, что обнаружено несоответствие типов в операции присваивание: переменная имеет тип “str“, а ей присвоено значение типа “int“.
Условные выражения
Работа с логическими операторами и операциями напрямую связана с условными выражениями. Бывают ситуации, когда код программы начинает ветвиться в зависимости от предыдущего результата.
Например, на сайт заходит пользователь: если ему больше 18 лет, то ему показываются все темы, а если меньше – то только некоторые. Для таких случаев используется инструкция «if…elif…else». Она может состоять из 1, 2 или более вариантов ветвления.
Рассмотрим на практике.
Результат работы скрипта:
Отметим, что комментарии в Питоне предваряются решеткой (эта часть кода не будет исполняться). В примере нам потребовалось узнать возраст пользователя. Но мы хотим получить реальное число, поэтому ограничили рамки человеческого возраста от 1 до 139 лет.
В нашем случае какой-то шутник сказал, что ему -5 лет, поэтому мы его предупредили, что так делать не стоит. Конечно, в идеале стоит сделать защиту и от дробных чисел, а также от другого неподходящего типа данных.
Результат работы скрипта:
Пользователь по ошибке вместо возраста вписал свое имя, о чем его предупредили. В других случаях мы также постарались перехватить возможные несоответствия.
Преобразование в число с плавающей точкой
Итак, функция float() используется для преобразования целочисленного значения или строки в число с плавающей точкой. Синтаксис, по сути, такой же самый, как и в предыдущем случае. В качестве аргумента функция принимает переменную или значение, которые необходимо сконвертировать.
float(57)
А этот пример демонстрирует использование переменных для преобразования целочисленного значения в число с плавающей точкой.
f = 57 print(float(f)) 57.0
Приведем еще несколько примеров.
x = float(1) # x станет 1.0
y = float(2.8) # y станет 2.8
z = float("3") # z станет 3.0
w = float("4.2") # w станет 4.2
Также можно выполнить преобразование в число с плавающей точкой еще одним способом. Но работает он не всегда. Это операция преобразования с помощью деления. Если разделить 5 на 2, в результате получится 2.5. Python это учитывает, и автоматически выполняет соответствующее преобразование.
a = 5 / 2
2.5
Но если в результате деления появляется целое число (например если делится 10 на 2), то никакого преобразования не происходит.
