Какие типы данных можно хранить в массиве?

Типы данных в Python массивах

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

Python Lists (списки)

Список в Python может хранить данные любого типа, так как это гетерогенная коллекция:

# Все типы данных в одном списке
mixed_list = [
    42,                           # int
    3.14,                        # float
    "hello",                     # str
    True,                        # bool
    [1, 2, 3],                  # list
    {"key": "value"},           # dict
    (1, 2),                      # tuple
    {1, 2, 3},                   # set
    None,                        # NoneType
    lambda x: x * 2,             # function
]

for item in mixed_list:
    print(type(item), item)

Основные примитивные типы

1. Числовые типы

# Целые числа (int)
integers = [1, 42, -10, 0, 1000000]

# Числа с плавающей точкой (float)
floats = [3.14, 2.718, -0.5, 1.0]

# Комплексные числа (complex)
complex_nums = [1+2j, 3-4j]

2. Строки (str)

strings = ["hello", "world", "", "многострочная\nстрока"]

# Спецсимволы
special = ["\t", "\n", "\\"]

3. Логические значения (bool)

booleans = [True, False]

4. None

nones = [None, None]

Коллекции

1. Списки (list) — изменяемые

lists = [
    [1, 2, 3],
    ["a", "b", "c"],
    [1, "mixed", 3.14]
]

# Вложенные списки (многомерные)
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
print(matrix[0][1])  # 2

2. Кортежи (tuple) — неизменяемые

tuples = [
    (1, 2, 3),
    ("a", "b"),
    (1,),  # кортеж с одним элементом
]

3. Словари (dict)

dicts = [
    {"name": "Alice", "age": 30},
    {"id": 1, "value": 42},
    {"nested": {"key": "value"}}
]

print(dicts[0]["name"])  # Alice

4. Множества (set) — неупорядоченные, уникальные

sets = [
    {1, 2, 3},
    {"apple", "banana"},
    set()  # пустое множество
]

Специальные типы

1. Функции и методы

def my_func():
    return 42

functions = [
    my_func,
    lambda x: x * 2,
    print,
    len,
    str.upper
]

# Вызвать функцию из списка
result = functions[1](5)  # 10

2. Классы и объекты

class Person:
    def __init__(self, name):
        self.name = name

people = [
    Person("Alice"),
    Person("Bob"),
    {"name": "Charlie", "type": "dict"}
]

print(people[0].name)  # Alice

3. Диапазоны (range)

ranges = [
    range(5),
    range(1, 10),
    range(0, 10, 2)
]

print(list(ranges[0]))  # [0, 1, 2, 3, 4]

Типизированные массивы (array module)

Для больших объемов однородных данных используется модуль array:

import array

# Массив целых чисел (экономнее памяти)
int_array = array.array('i', [1, 2, 3, 4, 5])

# Массив float'ов
float_array = array.array('f', [1.1, 2.2, 3.3])

# Поддерживаемые типы кодов:
# 'b' — signed byte
# 'i' — signed integer
# 'f' — float
# 'd' — double

print(int_array[0])  # 1
int_array.append(6)

NumPy arrays

Для научных вычислений используется NumPy:

import numpy as np

# Одномерный массив
arr1d = np.array([1, 2, 3, 4])
print(arr1d[0])  # 1

# Двумерный массив
arr2d = np.array([[1, 2, 3], [4, 5, 6]])
print(arr2d[1, 2])  # 6

# С явным типом данных
floats = np.array([1, 2, 3], dtype=np.float32)

# Типы данных NumPy:
# int8, int16, int32, int64
# uint8, uint16, uint32, uint64
# float32, float64
# complex64, complex128
# bool

print(floats.dtype)  # float32

Практический пример

# Студент с разными атрибутами
student = [
    "Alice",          # str — имя
    20,               # int — возраст
    3.85,             # float — средний балл
    [90, 85, 92],     # list — оценки
    {"math": 90, "english": 85},  # dict — оценки по предметам
    True              # bool — активный студент
]

print(student[0])      # Alice
print(student[2])      # 3.85
print(student[3][0])   # 90
print(student[4]["math"])  # 90

Типизация при объявлении (Type Hints)

from typing import List, Dict, Tuple, Union

# Список целых чисел
numbers: List[int] = [1, 2, 3]

# Список смешанных типов
mixed: List[Union[int, str]] = [1, "two", 3]

# Список словарей
people: List[Dict[str, Union[str, int]]] = [
    {"name": "Alice", "age": 30},
    {"name": "Bob", "age": 25}
]

# Кортеж фиксированной длины
point: Tuple[int, int, int] = (1, 2, 3)

# Callable (функции)
operations: List[callable] = [int, str, float]

Ограничения при выборе типов

# Изменяемые типы (list, dict, set) нельзя использовать как ключи словаря
valid_dict = {1: "a", "key": "b", (1, 2): "c"}  # OK

# invalid_dict = {[1, 2]: "a"}  # TypeError! list не hashable
# invalid_dict = {{"key": "val"}: "a"}  # TypeError! dict не hashable

# Но можно использовать tuple
valid_dict = {(1, 2): "a"}  # OK

Проверка типа

data = [1, "hello", 3.14, None, [1, 2]]

for item in data:
    print(type(item))
    
    if isinstance(item, int):
        print(f"{item} is integer")
    elif isinstance(item, str):
        print(f"{item} is string")
    elif isinstance(item, float):
        print(f"{item} is float")
    elif isinstance(item, list):
        print(f"{item} is list")
    elif item is None:
        print(f"{item} is None")

Вывод

Пython списки и другие коллекции гибки и могут хранить данные любых типов. Это мощная особенность, но требует дисциплины при работе с кодом. Используй type hints для явного указания ожидаемых типов.