Python ошибка приведения типа

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

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

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

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

Ошибки могут быть разных видов:

• Синтаксические
• Недостаточно памяти
• Ошибки рекурсии
• Исключения

Разберем их по очереди.

Синтаксические ошибки (SyntaxError)

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

Рассмотрим на примере.

a = 8
b = 10
c = a b

File "", line 3
 c = a b
       ^
SyntaxError: invalid syntax

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

Недостаточно памяти (OutofMemoryError)

Ошибки памяти чаще всего связаны с оперативной памятью компьютера и относятся к структуре данных под названием “Куча” (heap). Если есть крупные объекты (или) ссылки на подобные, то с большой долей вероятности возникнет ошибка OutofMemory. Она может появиться по нескольким причинам:

• Использование 32-битной архитектуры Python (максимальный объем выделенной памяти невысокий, между 2 и 4 ГБ);
• Загрузка файла большого размера;
• Запуск модели машинного обучения/глубокого обучения и много другое;

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

Но поскольку Python использует архитектуру управления памятью из языка C (функция malloc()), не факт, что все процессы восстановятся — в некоторых случаях MemoryError приведет к остановке. Следовательно, обрабатывать такие ошибки не рекомендуется, и это не считается хорошей практикой.

Ошибка рекурсии (RecursionError)

Эта ошибка связана со стеком и происходит при вызове функций. Как и предполагает название, ошибка рекурсии возникает, когда внутри друг друга исполняется много методов (один из которых — с бесконечной рекурсией), но это ограничено размером стека.

Все локальные переменные и методы размещаются в стеке. Для каждого вызова метода создается стековый кадр (фрейм), внутрь которого помещаются данные переменной или результат вызова метода. Когда исполнение метода завершается, его элемент удаляется.

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

def recursion():
    return recursion()

recursion()

---------------------------------------------------------------------------

RecursionError                            Traceback (most recent call last)

 in 
----> 1 recursion()


 in recursion()
      1 def recursion():
----> 2     return recursion()


... last 1 frames repeated, from the frame below ...


 in recursion()
      1 def recursion():
----> 2     return recursion()


RecursionError: maximum recursion depth exceeded

Ошибка отступа (IndentationError)

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

Пример:

for i in range(10):
    print('Привет Мир!')

  File "", line 2
    print('Привет Мир!')
        ^
IndentationError: expected an indented block

Исключения

Даже если синтаксис в инструкции или само выражение верны, они все равно могут вызывать ошибки при исполнении. Исключения Python — это ошибки, обнаруживаемые при исполнении, но не являющиеся критическими. Скоро вы узнаете, как справляться с ними в программах Python. Объект исключения создается при вызове исключения Python. Если скрипт не обрабатывает исключение явно, программа будет остановлена принудительно.

Программы обычно не обрабатывают исключения, что приводит к подобным сообщениям об ошибке:

Ошибка типа (TypeError)

a = 2
b = 'PythonRu'
a + b

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

 in 
      1 a = 2
      2 b = 'PythonRu'
----> 3 a + b


TypeError: unsupported operand type(s) for +: 'int' and 'str'

Ошибка деления на ноль (ZeroDivisionError)

10 / 0

---------------------------------------------------------------------------

ZeroDivisionError                         Traceback (most recent call last)

 in 
----> 1 10 / 0


ZeroDivisionError: division by zero

Есть разные типы исключений в Python и их тип выводится в сообщении: вверху примеры TypeError и ZeroDivisionError. Обе строки в сообщениях об ошибке представляют собой имена встроенных исключений Python.

Оставшаяся часть строки с ошибкой предлагает подробности о причине ошибки на основе ее типа.

Теперь рассмотрим встроенные исключения Python.

Встроенные исключения

BaseException
 +-- SystemExit
 +-- KeyboardInterrupt
 +-- GeneratorExit
 +-- Exception
      +-- StopIteration
      +-- StopAsyncIteration
      +-- ArithmeticError
      |    +-- FloatingPointError
      |    +-- OverflowError
      |    +-- ZeroDivisionError
      +-- AssertionError
      +-- AttributeError
      +-- BufferError
      +-- EOFError
      +-- ImportError
      |    +-- ModuleNotFoundError
      +-- LookupError
      |    +-- IndexError
      |    +-- KeyError
      +-- MemoryError
      +-- NameError
      |    +-- UnboundLocalError
      +-- OSError
      |    +-- BlockingIOError
      |    +-- ChildProcessError
      |    +-- ConnectionError
      |    |    +-- BrokenPipeError
      |    |    +-- ConnectionAbortedError
      |    |    +-- ConnectionRefusedError
      |    |    +-- ConnectionResetError
      |    +-- FileExistsError
      |    +-- FileNotFoundError
      |    +-- InterruptedError
      |    +-- IsADirectoryError
      |    +-- NotADirectoryError
      |    +-- PermissionError
      |    +-- ProcessLookupError
      |    +-- TimeoutError
      +-- ReferenceError
      +-- RuntimeError
      |    +-- NotImplementedError
      |    +-- RecursionError
      +-- SyntaxError
      |    +-- IndentationError
      |         +-- TabError
      +-- SystemError
      +-- TypeError
      +-- ValueError
      |    +-- UnicodeError
      |         +-- UnicodeDecodeError
      |         +-- UnicodeEncodeError
      |         +-- UnicodeTranslateError
      +-- Warning
           +-- DeprecationWarning
           +-- PendingDeprecationWarning
           +-- RuntimeWarning
           +-- SyntaxWarning
           +-- UserWarning
           +-- FutureWarning
           +-- ImportWarning
           +-- UnicodeWarning
           +-- BytesWarning
           +-- ResourceWarning

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

• Try: он запускает блок кода, в котором ожидается ошибка.
• Except: здесь определяется тип исключения, который ожидается в блоке try (встроенный или созданный).
• Else: если исключений нет, тогда исполняется этот блок (его можно воспринимать как средство для запуска кода в том случае, если ожидается, что часть кода приведет к исключению).
• Finally: вне зависимости от того, будет ли исключение или нет, этот блок кода исполняется всегда.

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

Ошибка прерывания с клавиатуры (KeyboardInterrupt)

Исключение KeyboardInterrupt вызывается при попытке остановить программу с помощью сочетания Ctrl + C или Ctrl + Z в командной строке или ядре в Jupyter Notebook. Иногда это происходит неумышленно и подобная обработка поможет избежать подобных ситуаций.

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

try:
    inp = input()
    print('Нажмите Ctrl+C и прервите Kernel:')
except KeyboardInterrupt:
    print('Исключение KeyboardInterrupt')
else:
    print('Исключений не произошло')

Исключение KeyboardInterrupt

Стандартные ошибки (StandardError)

Рассмотрим некоторые базовые ошибки в программировании.

Арифметические ошибки (ArithmeticError)

• Ошибка деления на ноль (Zero Division);
• Ошибка переполнения (OverFlow);
• Ошибка плавающей точки (Floating Point);

Все перечисленные выше исключения относятся к классу Arithmetic и вызываются при ошибках в арифметических операциях.

Деление на ноль (ZeroDivisionError)

Когда делитель (второй аргумент операции деления) или знаменатель равны нулю, тогда результатом будет ошибка деления на ноль.

try:  
    a = 100 / 0
    print(a)
except ZeroDivisionError:  
    print("Исключение ZeroDivisionError." )
else:  
    print("Успех, нет ошибок!")

Исключение ZeroDivisionError.

Переполнение (OverflowError)

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

try:  
    import math
    print(math.exp(1000))
except OverflowError:  
    print("Исключение OverFlow.")
else:  
    print("Успех, нет ошибок!")

Исключение OverFlow.

Ошибка утверждения (AssertionError)

Когда инструкция утверждения не верна, вызывается ошибка утверждения.

Рассмотрим пример. Предположим, есть две переменные: a и b. Их нужно сравнить. Чтобы проверить, равны ли они, необходимо использовать ключевое слово assert, что приведет к вызову исключения Assertion в том случае, если выражение будет ложным.

try:  
    a = 100
    b = "PythonRu"
    assert a == b
except AssertionError:  
    print("Исключение AssertionError.")
else:  
    print("Успех, нет ошибок!")

Исключение AssertionError.

Ошибка атрибута (AttributeError)

При попытке сослаться на несуществующий атрибут программа вернет ошибку атрибута. В следующем примере можно увидеть, что у объекта класса Attributes нет атрибута с именем attribute.

class Attributes(obj):
    a = 2
    print(a)

try:
    obj = Attributes()
    print(obj.attribute)
except AttributeError:
    print("Исключение AttributeError.")

2
Исключение AttributeError.

Ошибка импорта (ModuleNotFoundError)

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

import nibabel

---------------------------------------------------------------------------

ModuleNotFoundError                       Traceback (most recent call last)

 in 
----> 1 import nibabel


ModuleNotFoundError: No module named 'nibabel'

Ошибка поиска (LookupError)

LockupError выступает базовым классом для исключений, которые происходят, когда key или index используются для связывания или последовательность списка/словаря неверна или не существует.

Здесь есть два вида исключений:

• Ошибка индекса (IndexError);
• Ошибка ключа (KeyError);

Ошибка ключа

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

try:  
    a = {1:'a', 2:'b', 3:'c'}  
    print(a[4])  
except LookupError:  
    print("Исключение KeyError.")
else:  
    print("Успех, нет ошибок!")

Исключение KeyError.

Ошибка индекса

Если пытаться получить доступ к индексу (последовательности) списка, которого не существует в этом списке или находится вне его диапазона, будет вызвана ошибка индекса (IndexError: list index out of range python).

try:
    a = ['a', 'b', 'c']  
    print(a[4])  
except LookupError:  
    print("Исключение IndexError, индекс списка вне диапазона.")
else:  
    print("Успех, нет ошибок!")

Исключение IndexError, индекс списка вне диапазона.

Ошибка памяти (MemoryError)

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

Ошибка имени (NameError)

Ошибка имени возникает, когда локальное или глобальное имя не находится.

В следующем примере переменная ans не определена. Результатом будет ошибка NameError.

try:
    print(ans)
except NameError:  
    print("NameError: переменная 'ans' не определена")
else:  
    print("Успех, нет ошибок!")

NameError: переменная 'ans' не определена

Ошибка выполнения (Runtime Error)

Ошибка «NotImplementedError»
Ошибка выполнения служит базовым классом для ошибки NotImplemented. Абстрактные методы определенного пользователем класса вызывают это исключение, когда производные методы перезаписывают оригинальный.

class BaseClass(object):
    """Опередляем класс"""
    def __init__(self):
        super(BaseClass, self).__init__()
    def do_something(self):
	# функция ничего не делает
        raise NotImplementedError(self.__class__.__name__ + '.do_something')

class SubClass(BaseClass):
    """Реализует функцию"""
    def do_something(self):
        # действительно что-то делает
        print(self.__class__.__name__ + ' что-то делает!')

SubClass().do_something()
BaseClass().do_something()

SubClass что-то делает!



---------------------------------------------------------------------------

NotImplementedError                       Traceback (most recent call last)

 in 
     14
     15 SubClass().do_something()
---> 16 BaseClass().do_something()


 in do_something(self)
      5     def do_something(self):
      6         # функция ничего не делает
----> 7         raise NotImplementedError(self.__class__.__name__ + '.do_something')
      8
      9 class SubClass(BaseClass):


NotImplementedError: BaseClass.do_something

Ошибка типа (TypeError)

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

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

try:
    a = 5
    b = "PythonRu"
    c = a + b
except TypeError:
    print('Исключение TypeError')
else:
    print('Успех, нет ошибок!')

Исключение TypeError

Ошибка значения (ValueError)

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

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

try:
    print(float('PythonRu'))
except ValueError:
    print('ValueError: не удалось преобразовать строку в float: 'PythonRu'')
else:
    print('Успех, нет ошибок!')

ValueError: не удалось преобразовать строку в float: 'PythonRu'

Пользовательские исключения в Python

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

Это можно сделать, создав новый класс, который будет наследовать из класса Exception в Python.

class UnAcceptedValueError(Exception):   
    def __init__(self, data):    
        self.data = data
    def __str__(self):
        return repr(self.data)

Total_Marks = int(input("Введите общее количество баллов: "))
try:
    Num_of_Sections = int(input("Введите количество разделов: "))
    if(Num_of_Sections < 1):
        raise UnAcceptedValueError("Количество секций не может быть меньше 1")
except UnAcceptedValueError as e:
    print("Полученная ошибка:", e.data)

Введите общее количество баллов: 10
Введите количество разделов: 0
Полученная ошибка: Количество секций не может быть меньше 1

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

Недостатки обработки исключений в Python

У использования исключений есть свои побочные эффекты, как, например, то, что программы с блоками try-except работают медленнее, а количество кода возрастает.

Дальше пример, где модуль Python timeit используется для проверки времени исполнения 2 разных инструкций. В stmt1 для обработки ZeroDivisionError используется try-except, а в stmt2 — if. Затем они выполняются 10000 раз с переменной a=0. Суть в том, чтобы показать разницу во времени исполнения инструкций. Так, stmt1 с обработкой исключений занимает больше времени чем stmt2, который просто проверяет значение и не делает ничего, если условие не выполнено.

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

import timeit
setup="a=0"
stmt1 = '''
try:
    b=10/a
except ZeroDivisionError:
    pass'''

stmt2 = '''
if a!=0:
    b=10/a'''

print("time=",timeit.timeit(stmt1,setup,number=10000))
print("time=",timeit.timeit(stmt2,setup,number=10000))

time= 0.003897680000136461
time= 0.0002797570000439009

Выводы!

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

Обработка исключений — один из основных факторов, который делает код готовым к развертыванию. Это простая концепция, построенная всего на 4 блоках: try выискивает исключения, а except их обрабатывает.

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

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

Преобразование типов

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

1. Неявное преобразование типов.
2. Явное приведение типов.

Неявное преобразование типов

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

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

# Преобразуем целое число в число с плавающей точкой
num_int = 123
num_float = 1.23

num_new = num_int + num_float

print("Тип данных в num_int:", type(num_int))
print("Тип данных в num_float:", type(num_float))

print("Значение num_new:", num_new)
print("Тип данных в num_new:", type(num_new))

Вывод:

Тип данных в num_int: <class 'int'>
Тип данных в num_float: <class 'float'>
Значение num_new: 124.23
Тип данных в num_new: <class 'float'>

В программе выше:

• мы сложили две переменные num_int и num_float, сохранили значение в num_new.
• мы вывели на экран типы данных всех трех объектов соответственно;
• в выводе мы видим, что тип данных num_int — целое число, а тип данных num_float — вещественное число.
• кроме того, мы видим, что num_new имеет тип данных с плавающей запятой, потому что Python всегда преобразует меньший по диапазону тип в больший, чтобы избежать потери данных.

Теперь давайте попробуем сложить строку и целое число и посмотрим, как Python с этим справится.

# Складываем строку и целое число
num_int = 123
num_str = "456"

print("Тип данных в num_int:", type(num_int))
print("Тип данных в num_str:", type(num_str))

print(num_int + num_str)

Вывод:

Тип данных в num_int: <class 'int'> 
Тип данных в num_str: <class 'str'>
 Traceback (most recent call last): 
File "python", line 7, in <module> 
TypeError: unsupported operand type(s) for +: 'int' and 'str'

В программе выше: 

• мы сложили две переменные num_int и num_str.
• как видно из вывода, мы получили TypeError — Python не может использовать неявное преобразование в таких случаях.

Однако в Python есть решение для таких ситуаций — это явное приведение.

Явное приведение типов

В явном преобразовании программист сам заменяет текущий тип данных объекта на требуемый. Для этого используются встроенные функции, такие как int (), float (), str () и т. д., чтобы выполнить явное преобразование типов.

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

Синтаксис

<требуемый_тип_данных>(выражение)

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

# Складываем строку и целое число с помощью явного преобразования
num_int = 123
num_str = "456"

print("Тип данных в num_int:", type(num_int))
print("Тип данных в num_str до явного приведения:", type(num_str))

num_str = int(num_str)
print("Тип данных в num_str после явного приведения:", type(num_str))

num_sum = num_int + num_str

print("Сумма num_int и num_str:", num_sum)
print("Тип данных полученной суммы:", type(num_sum))

Вывод:

Тип данных в num_int: <class 'int'>
Тип данных в num_str до явного приведения: <class 'str'>
Тип данных в num_str после явного приведения: <class 'int'>
Сумма num_int и num_str: 579
Тип данных полученной суммы: <class 'int’>

В программе выше:

• мы сложили переменные num_str и num_int;
• для выполнения сложения мы преобразовали num_str из строкового типа в целочисленный, используя функцию int ();
• после преобразования num_str в целочисленное значение Python уже может сложить эти две переменные;
• мы получили значение num_sum, его тип данных — целое число.

Что надо запомнить:

• Преобразование типов — это преобразование объекта из одного типа данных в другой.
• Неявное преобразование типов автоматически выполняется интерпретатором Python.
• Python не допускает потери данных при неявном преобразовании типов.
• Явное преобразование типов также называется приведением типов. Типы данных преобразуются пользователем с помощью встроенных функций.
• В явном приведении типов может произойти потеря данных, поскольку мы принудительно приводим объект к определенному типу.

Ситуация: начинающий программист более-менее освоил JavaScript и перешёл к Python. Чтобы освоить новый язык на практике, программист решил переписать свой старый проект с JavaScript на Python и столкнулся с таким фрагментом:

var a = 2;
var b = ' ствола';
var c = a + b;

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

a = 2
b = ‘ ствола’
c = a + b

Но при запуске проекта компьютер указал на последнюю строку и выдал ошибку:

Exception has occurred: TypeError
unsupported operand type(s) for +: ‘int’ and ‘str’

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

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

Что делать с ошибкой Exception has occurred: TypeError

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

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

a = 2
b = ‘ ствола’
c = str(a) + b

Команда str() не меняет тип и содержимое переменной a, но зато компьютер понимает, что это временно стало строкой, и спокойно её складывает со второй строкой.

Prerequisites: Python Data Types

Type Casting is the method to convert the variable data type into a certain data type in order to the operation required to be performed by users. In this article, we will see the various technique for typecasting.

There can be two types of Type Casting in Python –

• Implicit Type Casting
• Explicit Type Casting

Implicit Type Conversion

In this,  methods, Python converts data type into another data type automatically. In this process, users don’t have to involve in this process. 

Output:

<class 'int'>
<class 'float'>
10.0
<class 'float'>
21.0
<class 'float'>

Explicit Type Casting

In this method, Python need user involvement to convert the variable data type into certain data type in order to the operation required.

Mainly in type casting can be done with these data type function:

• Int() : Int() function take float or string as an argument and return int type object.
• float() : float() function take int or string as an argument and return float type object.
• str() : str() function take float or int as an argument and return string type object.

Let’s see some example of type casting:

Type Casting int to float:

Here, we are casting integer object to float object with float() function.

Output:

5.0
<class 'float'>

Type Casting float to int:

Here, we are casting float data type into integer data type with int() function.

Output:

5
<class 'int'>

Type casting int to string:

Here, we are casting int data type into string data type with str() function.

Output:

5
<class 'str'>

Type Casting string to int:

Here, we are casting string data type into integer data type with int() function.

Output:

5
<class 'int'>

Type Casting String to float:

Here, we are casting string data type into float data type with float() function.

Output:

5.9
<class 'float'>

Prerequisites: Python Data Types

Type Casting is the method to convert the variable data type into a certain data type in order to the operation required to be performed by users. In this article, we will see the various technique for typecasting.

There can be two types of Type Casting in Python –

• Implicit Type Casting
• Explicit Type Casting

Implicit Type Conversion

In this,  methods, Python converts data type into another data type automatically. In this process, users don’t have to involve in this process. 

Output:

<class 'int'>
<class 'float'>
10.0
<class 'float'>
21.0
<class 'float'>

Explicit Type Casting

In this method, Python need user involvement to convert the variable data type into certain data type in order to the operation required.

Mainly in type casting can be done with these data type function:

• Int() : Int() function take float or string as an argument and return int type object.
• float() : float() function take int or string as an argument and return float type object.
• str() : str() function take float or int as an argument and return string type object.

Let’s see some example of type casting:

Type Casting int to float:

Here, we are casting integer object to float object with float() function.

Output:

5.0
<class 'float'>

Type Casting float to int:

Here, we are casting float data type into integer data type with int() function.

Output:

5
<class 'int'>

Type casting int to string:

Here, we are casting int data type into string data type with str() function.

Output:

5
<class 'str'>

Type Casting string to int:

Here, we are casting string data type into integer data type with int() function.

Output:

5
<class 'int'>

Type Casting String to float:

Here, we are casting string data type into float data type with float() function.

Output:

5.9
<class 'float'>

Ввод и вывод данных

Назад в начало

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

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

a = 10

A = 20

a и А — это разные переменные, регистр ввода имеет значение

Типы данных

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

int — целочисленный тип (1, 192, 781287)

float — вещественный (дробный) (1.12312, 1231.12378718)

str — строковый тип (обязательно пишется в кавычках) (‘Hello world’)

bool — булевый тип (имеет всего два значения: True и False)

Приведение типов

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

a = 10

b = str(a) # b — это строка

с = int(b) # c — это снова число

d = 10.78

e = int(d) # e равно 10

Функция print

Функция print выводит переданные в неё аргументы в стандартный поток вывода. Что же такое стандартный поток вывода? Standart output или stdout называется потоком вывода, местом, куда мы выводим наш текстовый контент. По умолчанию стандартный поток вывода равен sys.stdout и поэтому вывод осуществляется в консоль.

Функция print все переданные в неё аргументы в стандартный поток вывода. Например:

print(1)

print(‘Hello world!’)

print(False)

print(1.5, 2.0, 10, True, ‘username’)

print(‘Hello’ + ‘ ‘ + ‘world’ + ‘!’)

# 1

# Hello world!

# False

# 1.5 2.0 10 True username

# Hello world!

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

# Во-первых:

print(1)

print(2)

# 1

# 2

# Во-вторых:

print(‘Hello’, ‘world’)

# Hello world

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

print(1, end=‘ ‘)

print(2, end=‘ ‘)

print(3, end=‘ ‘)

# 1 2 3

print(1, end=»—»)

print(2, end=‘-‘)

print(3, end=»—»)

# 1-2-3-

print(1, end=‘-я выведусь после первого print-‘)

print(2, end=‘-a я после второго-‘)

print(3, end=‘-я выведусь после третьего-‘)

# 1-я выведусь после первого print-2-a я после второго-3-я выведусь после третьего-

Рассмотрим второй параметр функции print — sep, sep от английского separator (разделитель). По умолчанию параметр sep равен ‘ ‘. Время для экспериментов ╰(▔∀▔)╯.

print(1, 2, 3, 4)

print(1, 2, 3, 4, sep=‘+++’)

print(1, 2, 3, 4, sep=‘разделитель’)

print(1, 2, 3, 4, sep=‘(◕‿◕)’)

print(1, 2, 3, 4, sep=‘(ﾉ◕ヮ◕)ﾉ*:･ﾟ✧’)

# 1 2 3 4

# 1+++2+++3+++4

# 1разделитель2разделитель3разделитель4

# 1(◕‿◕)2(◕‿◕)3(◕‿◕)4

# 1(ﾉ◕ヮ◕)ﾉ*:･ﾟ✧2(ﾉ◕ヮ◕)ﾉ*:･ﾟ✧3(ﾉ◕ヮ◕)ﾉ*:･ﾟ✧4

Функция input

Функция input является функцией стандартного ввода (stdin). Ее главная задача — это передача введенных пользователем данных в функцию.

name = input()

print(‘Hello, ‘ + name)

Функция input может принимать всего лишь один аргумент — строку, которая выведется перед кареткой ввода

name = input(‘Enter your name: ‘)

print(‘Hello, ‘ + name)

Функция input возвращает строковый тип данных

Строки можно складывать друг с другом — это называется конкатенацией или объединением

number = input()

print(type(number))

#

Поэтому если мы напишем такой код, то он будет работать некорректно:

number1 = input()

number2 = input()

print(number1 + number2)

# Ввод:

# 1

# 2

# Вывод:

# 12

Поэтому необходимо преобразовать строковый тип в целочисленный (str в int)

number1 = int(input())

number2 = int(input())

print(number1 + number2)

# Ввод:

# 1

# 2

# Вывод:

# 3

Всегда проверяйте тип полученных данных, это поможет вам избежать большого количества ошибок. К слову, если вы что-то напутали с типами переменных, то Python выдаст ошибку TypeError (ошибка типа)

Решение задач

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

2. Пользователь вводит свое имя и фамилию. Выведите:

Hello, имя фамилия

# На месте слов с % должны быть введенные данные

3. Посчитайте сумму трех введенных целых чисел

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

5. Дано число, выведите предыдущее и следущее за ним числа в таком формате:

# Число равно 10

Число предшествующее числу 10 равно 9

Число следующее за числом 10 равно 11

6. Вводятся имя и возраст. Выведите, где введенное имя = Максим, а возраст = 20

Привет, Максим! Ваш возраст равен 20!