Какие особенности примитивных типов данных знаешь в Python?

Особенности примитивных типов данных в Python

Python имеет несколько примитивных типов данных. Это не просто типы — они имеют особенности и подводные камни, которые влияют на производительность и поведение кода.

1. Integer (целые числа)

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

# Целые числа без ограничений размера
small = 10
large = 10**1000  # Тысячазначное число
hugest = 10**1000000  # Еще больше!

print(small)  # 10
print(len(str(large)))  # 1001 цифра

# Базы системы счисления
binary = 0b1010  # 10
octal = 0o12  # 10
hex_num = 0xA  # 10

print(binary, octal, hex_num)  # 10 10 10

# Операции
a = 10
print(a + 5)  # Сложение: 15
print(a - 3)  # Вычитание: 7
print(a * 2)  # Умножение: 20
print(a // 3)  # Целая часть деления: 3
print(a % 3)  # Остаток: 1
print(a ** 2)  # Степень: 100

# Битовые операции
print(a & 6)  # AND: 2
print(a | 6)  # OR: 14
print(a ^ 6)  # XOR: 12
print(a << 1)  # Левый сдвиг: 20
print(a >> 1)  # Правый сдвиг: 5

# Особенность: интернирование для малых чисел
a = 256
b = 256
print(a is b)  # True — один объект в памяти (optimization)

a = 257
b = 257
print(a is b)  # False — разные объекты (за пределами диапазона -5..256)

2. Float (вещественные числа)

Это числа с плавающей точкой (IEEE 754 двойной точности).

# Базовое использование
x = 3.14
y = 1e-5  # Научная нотация: 0.00001
z = float('inf')  # Бесконечность
neg_inf = float('-inf')
nan = float('nan')  # Не число

print(x, y, z)  # 3.14 1e-05 inf

# Опасность: точность
a = 0.1 + 0.2
print(a)  # 0.30000000000000004 (ошибка округления!)
print(a == 0.3)  # False (опасно!)

# ✅ Правильно: используй модуль decimal для точности
from decimal import Decimal

x = Decimal('0.1') + Decimal('0.2')
print(x)  # 0.3
print(x == Decimal('0.3'))  # True

# Операции
print(3.0 / 2)  # 1.5
print(3.0 // 2)  # 1.0
print(3.0 % 2)  # 1.0

# Сравнение с допуском
import math

a = 0.1 + 0.2
b = 0.3
print(math.isclose(a, b))  # True — безопасное сравнение

3. String (строки)

Строки в Python — неизменяемые последовательности символов (Unicode).

# Создание
s1 = 'Hello'  # Одинарные кавычки
s2 = "World"  # Двойные кавычки
s3 = '''Multi
line
string'''  # Тройные кавычки

# Unicode
s = 'Hello 🌍'  # Полная поддержка Unicode
print(len(s))  # 8 символов
print(s.encode('utf-8'))  # b'Hello \xf0\x9f\x8c\x8d'

# Индексирование и срезы
text = "Python"
print(text[0])  # 'P'
print(text[-1])  # 'n'
print(text[1:4])  # 'yth'
print(text[::-1])  # 'nohtyP' (разворот)

# Неизменяемость (immutable)
s = "Hello"
# s[0] = 'J'  # TypeError! Нельзя менять
s = "J" + s[1:]  # Так нужно
print(s)  # 'Jello'

# Интерполяция
name = 'Alice'
age = 30

# f-strings (самый современный способ)
print(f"{name} is {age} years old")  # Лучший вариант

# format
print("{} is {} years old".format(name, age))

# % formatting (старый стиль)
print("%s is %d years old" % (name, age))

# Операции со строками
s1 = "Hello"
s2 = "World"
print(s1 + " " + s2)  # Конкатенация: "Hello World"
print(s1 * 3)  # Повтор: "HelloHelloHello"
print("H" in s1)  # Проверка: True
print(s1.upper())  # "HELLO"
print(s1.lower())  # "hello"
print(s1.replace('l', 'L'))  # "HeLLo"

# Строковые методы
print("  hello  ".strip())  # "hello" (убрать пробелы)
print("a,b,c".split(','))  # ['a', 'b', 'c']
print('-'.join(['a', 'b', 'c']))  # "a-b-c"

4. Boolean (логические значения)

Тип для логических значений True и False.

# Базовое использование
true_val = True
false_val = False

print(type(True))  # <class 'bool'>

# Истинность значений
print(bool(1))  # True
print(bool(0))  # False
print(bool(""))  # False
print(bool("hello"))  # True
print(bool([]))  # False
print(bool([1, 2]))  # True
print(bool(None))  # False

# Логические операции
a = True
b = False

print(a and b)  # False
print(a or b)  # True
print(not a)  # False

# Операции сравнения
print(5 > 3)  # True
print(5 == 5)  # True
print(5 != 3)  # True
print(5 >= 5)  # True

# Цепные сравнения
x = 10
print(5 < x < 15)  # True
print(5 < x and x < 15)  # Эквивалент

# Особенность: True и False — это числа!
print(True + True)  # 2
print(True * 5)  # 5
print(False * 100)  # 0

5. None

Специальное значение, обозначающее отсутствие значения.

# Инициализация
value = None

# Проверка
if value is None:  # ✅ Правильно
    print("No value")

# ❌ Неправильно:
if value == None:  # Работает, но не идиоматично
    pass

# Использование в функциях
def get_data(optional_param=None):
    if optional_param is None:
        optional_param = []
    return optional_param

# None в коллекциях
data = [1, None, 3]
for item in data:
    if item is not None:
        print(item)

6. Complex (комплексные числа)

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

# Создание
z = 3 + 4j  # 3 + 4i
z = complex(3, 4)

print(z)  # (3+4j)
print(z.real)  # 3.0 — действительная часть
print(z.imag)  # 4.0 — мнимая часть
print(z.conjugate())  # (3-4j) — сопряженное

# Операции
z1 = 1 + 2j
z2 = 3 + 4j

print(z1 + z2)  # (4+6j)
print(z1 * z2)  # (-5+10j)
print(abs(z1))  # 2.23... — модуль

# Использование в математике
import cmath

print(cmath.sqrt(-1))  # 1j
print(cmath.exp(1j * 3.14159))  # Примерно -1 (формула Эйлера)

7. Различия между примитивными типами

Mutability (изменяемость)

# Неизменяемые (immutable): int, float, str, bool, None, tuple
immutable = (1, 2, 3)
# immutable[0] = 5  # TypeError

# Изменяемые (mutable): list, dict, set
mutable = [1, 2, 3]
mutable[0] = 5  # OK
print(mutable)  # [5, 2, 3]

# Это важно для функций!
def modify(obj):
    obj = "changed"  # Не меняет оригинал (для immutable)

text = "original"
modify(text)
print(text)  # "original" — не изменилось

def modify_list(lst):
    lst.append(999)  # Меняет оригинал!

data = [1, 2, 3]
modify_list(data)
print(data)  # [1, 2, 3, 999] — изменилось!

Производительность

import timeit

# Строки неэффективны для конкатенации
code1 = '''
s = ""
for i in range(100):
    s += str(i)  # Медленно! Каждый раз новая строка
'''

code2 = '''
parts = []
for i in range(100):
    parts.append(str(i))
s = ''.join(parts)  # Быстро!
'''

print(timeit.timeit(code1, number=1000))  # ~0.5 сек
print(timeit.timeit(code2, number=1000))  # ~0.05 сек

# Используй join() для конкатенации строк!

8. Конверсия типов

# Явная конверсия
x = int(3.14)  # 3
y = float(5)  # 5.0
z = str(42)  # "42"
b = bool(1)  # True

# С базами
hex_str = "FF"
print(int(hex_str, 16))  # 255
print(int("1010", 2))  # 10

# Неявная конверсия в операциях
result = 5 + 2.0  # int + float = float (5.0 + 2.0 = 7.0)
print(result)  # 7.0
print(type(result))  # <class 'float'>

Резюме важных особенностей

Этого достаточно, чтобы хорошо работать с примитивными типами Python!