Типы чисел и операции в Python

Введение

В этой лабораторной работе вы получите фундаментальное понимание типов чисел и операций в Python. Мы рассмотрим характеристики целочисленных (integer), булевых (boolean), чисел с плавающей запятой (floating-point) и комплексных чисел (complex), включая их неизменяемость (immutability), а также то, как проверять их типы и адреса в памяти. С помощью практических упражнений вы научитесь преобразовывать между различными типами чисел и выполнять основные арифметические операции, закрепляя свои знания о числовых возможностях Python.

Изучение типов Integer и Boolean

На этом шаге мы исследуем типы данных Python — целые числа (int) и булевы значения (bool). Целые числа — это целые числа, такие как 10, -5 или 0. Булевы значения представляют одно из двух состояний: True (Истина) или False (Ложь), и являются подтипом целых чисел.

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

В рабочей среде для вас уже создан файл. В проводнике файлов WebIDE слева откройте файл ~/project/number_types.py. Добавьте в него следующий код:

## Demonstrate immutability of integers
a = 5
print(f"Initial value of a: {a}")
print(f"Type of a: {type(a)}")
print(f"ID of a: {id(a)}")

## Reassign 'a' to a new value
a = 6
print(f"\nNew value of a: {a}")
print(f"New ID of a: {id(a)}")

## Demonstrate boolean type
print("\n--- Boolean Types ---")
is_true = True
is_false = False
print(f"Value of is_true: {is_true}, Type: {type(is_true)}")
print(f"Value of is_false: {is_false}, Type: {type(is_false)}")

## Booleans behave like integers (1 and 0) in arithmetic
print(f"\nTrue + 5: {True + 5}")
print(f"False * 3: {False * 3}")

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

python ~/project/number_types.py

Вы должны увидеть вывод, похожий на следующий. Обратите внимание, что адреса памяти (ID) будут отличаться в вашей системе.

Initial value of a: 5
Type of a: <class 'int'>
ID of a: <memory_address_1>

New value of a: 6
New ID of a: <memory_address_2>

--- Boolean Types ---
Value of is_true: True, Type: <class 'bool'>
Value of is_false: False, Type: <class 'bool'>

True + 5: 6
False * 3: 0

Вывод показывает, что при переназначении a с 5 на 6 его ID изменился, что подтверждает создание нового целочисленного объекта. Он также демонстрирует, что в вычислениях True рассматривается как 1, а False — как 0.

Работа с числами с плавающей запятой

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

Давайте изучим это поведение. Снова откройте файл ~/project/number_types.py и добавьте следующий код в конец файла. Этот код продемонстрирует проблему точности и представит два способа ее решения: функцию round() для простого округления и модуль decimal для высокоточной арифметики.

## Demonstrate floating-point numbers and precision
print("\n--- Floating-Point Numbers ---")
result = 1.1 + 2.2
print(f"1.1 + 2.2 = {result}")

## Using round() for approximation
print(f"round(result, 1) = {round(result, 1)}")

## Using the decimal module for accurate calculations
from decimal import Decimal

## Pass numbers as strings to Decimal to avoid initial float inaccuracy
d1 = Decimal('1.1')
d2 = Decimal('2.2')
decimal_result = d1 + d2
print(f"Decimal('1.1') + Decimal('2.2') = {decimal_result}")

Сохраните файл и снова запустите скрипт из терминала:

python ~/project/number_types.py

Теперь ваш вывод будет включать следующий раздел:

--- Floating-Point Numbers ---
1.1 + 2.2 = 3.3000000000000003
round(result, 1) = 3.3
Decimal('1.1') + Decimal('2.2') = 3.3

Как вы можете видеть, стандартное сложение чисел с плавающей запятой 1.1 + 2.2 не дает в результате ровно 3.3. В то время как round() может помочь отформатировать вывод, модуль decimal предоставляет способ выполнять вычисления с точным десятичным представлением, давая точный ответ.

Введение в комплексные числа

Python имеет встроенную поддержку комплексных чисел, которые необходимы во многих научных и инженерных областях. Комплексное число имеет действительную и мнимую части и записывается в форме a + bj, где j обозначает мнимую единицу.

Вы можете создавать комплексные числа, используя эту нотацию или конструктор complex(real, imag). Доступ к действительной и мнимой частям можно получить с помощью атрибутов .real и .imag.

Продолжите редактирование файла ~/project/number_types.py. Добавьте следующий код в конец, чтобы изучить комплексные числа:

## Demonstrate complex numbers
print("\n--- Complex Numbers ---")
c1 = 3 + 4j
print(f"Complex number c1: {c1}")
print(f"Type of c1: {type(c1)}")
print(f"Real part of c1: {c1.real}")
print(f"Imaginary part of c1: {c1.imag}")

## Creating a complex number with the constructor
c2 = complex(5, -2)
print(f"\nComplex number c2: {c2}")
print(f"Real part of c2: {c2.real}")
print(f"Imaginary part of c2: {c2.imag}")

Сохраните файл и снова запустите скрипт из терминала:

python ~/project/number_types.py

Новый вывод будет следующим:

--- Complex Numbers ---
Complex number c1: (3+4j)
Type of c1: <class 'complex'>
Real part of c1: 3.0
Imaginary part of c1: 4.0

Complex number c2: (5-2j)
Real part of c2: 5.0
Imaginary part of c2: -2.0

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

Преобразование между типами чисел

Python предоставляет встроенные функции для преобразования между различными типами чисел, такими как int(), float() и complex(). Это называется приведением типов (type casting).

• int(x): Преобразует x в целое число. При преобразовании числа с плавающей запятой оно отбрасывает (обрезает) десятичную часть, а не округляет.
• float(x): Преобразует x в число с плавающей запятой.
• complex(real, imag): Создает комплексное число.

Давайте попрактикуемся в преобразовании типов. Добавьте следующий код в конец вашего скрипта ~/project/number_types.py:

## Demonstrate type conversion
print("\n--- Type Conversion ---")

## Convert float to int (truncation)
float_num = 9.9
int_num = int(float_num)
print(f"float_num = {float_num}")
print(f"int(float_num) = {int_num}")

## Convert int to float
int_val = 10
float_val = float(int_val)
print(f"\nint_val = {int_val}")
print(f"float(int_val) = {float_val}")

## Convert string to number
str_num = "123.45"
converted_float = float(str_num)
converted_int = int(float(str_num)) ## Must convert to float first
print(f"\nstr_num = '{str_num}'")
print(f"float(str_num) = {converted_float}")
print(f"int(float(str_num)) = {converted_int}")

Сохраните файл и снова запустите скрипт:

python ~/project/number_types.py

Теперь вывод будет включать этот раздел:

--- Type Conversion ---
float_num = 9.9
int(float_num) = 9

int_val = 10
float(int_val) = 10.0

str_num = '123.45'
float(str_num) = 123.45
int(float(str_num)) = 123

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

Выполнение основных арифметических операций

Python поддерживает все стандартные арифметические операции. Когда вы выполняете операцию с операндами разных числовых типов (например, int и float), Python автоматически "расширяет" (widens) результат до более общего типа. Иерархия выглядит так: int -> float -> complex.

Вот общие операторы:

• + (Сложение)
• - (Вычитание)
• * (Умножение)
• / (Деление — всегда дает результат типа float)
• // (Целочисленное деление — делит и округляет вниз до ближайшего целого числа)
• % (Остаток от деления — возвращает остаток от деления)
• ** (Возведение в степень)

В завершение нашего исследования добавим финальный раздел в ~/project/number_types.py для практики этих операций.

## Demonstrate basic arithmetic operations
print("\n--- Basic Arithmetic Operations ---")
a = 10
b = 3

print(f"{a} + {b} = {a + b}")
print(f"{a} - {b} = {a - b}")
print(f"{a} * {b} = {a * b}")
print(f"{a} / {b} = {a / b}")
print(f"{a} // {b} = {a // b}")
print(f"{a} % {b} = {a % b}")
print(f"{a} ** {b} = {a ** b}")

## Demonstrate mixed-type operations
print("\n--- Mixed-Type Operations ---")
int_op = 5
float_op = 2.5
result_mixed = int_op * float_op
print(f"{int_op} (int) * {float_op} (float) = {result_mixed} ({type(result_mixed)})")

Сохраните файл и запустите полный скрипт:

python ~/project/number_types.py

Финальный вывод будет включать:

--- Basic Arithmetic Operations ---
10 + 3 = 13
10 - 3 = 7
10 * 3 = 30
10 / 3 = 3.3333333333333335
10 // 3 = 3
10 % 3 = 1
10 ** 3 = 1000

--- Mixed-Type Operations ---
5 (int) * 2.5 (float) = 12.5 (<class 'float'>)

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

Резюме

В этой лабораторной работе вы заложили прочную основу в отношении числовых типов данных Python. Вы узнали о целых числах (integers), булевых значениях (booleans), числах с плавающей запятой (floats) и комплексных числах (complex numbers). Вы изучили концепцию неизменяемости (immutability) и использовали функции id() и type() для инспекции объектов. Вы попрактиковались в работе с проблемами точности чисел с плавающей запятой с помощью модуля decimal, в преобразовании между различными типами чисел с использованием int(), float() и complex(), а также в выполнении ряда арифметических операций. Эти знания имеют решающее значение для любых дальнейших задач программирования или анализа данных в Python.