Какие элементы могут содержаться в списке Python?

Элементы списков в Python: Полный обзор

Списки в Python — это самые гибкие контейнеры. Они могут содержать ЛЮБЫЕ объекты, включая другие контейнеры. Это одна из главных особенностей Python.

1. Встроенные примитивные типы

# Числа
numbers = [1, 2.5, 3+4j, 0x10, 0b1010, 0o77]
print(numbers)  # [1, 2.5, (3+4j), 16, 10, 63]

# Строки
strings = ["hello", 'world', """multi
line""", r"raw\nstring"]
print(strings)  # ['hello', 'world', 'multi\nline', 'raw\\nstring']

# Булевы значения
bools = [True, False, 1, 0]
print(bools)  # [True, False, 1, True]

# None
nothing = [None, "something", None]
print(nothing)  # [None, 'something', None]

2. Контейнеры внутри списков

Списки могут содержать другие контейнеры!

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

# Кортежи в списке
mixed = [(1, 2), (3, 4), (5, 6)]
for pair in mixed:
    print(pair)

# Словари в списке
users = [
    {"id": 1, "name": "Alice"},
    {"id": 2, "name": "Bob"},
    {"id": 3, "name": "Charlie"}
]
print(users[0]["name"])  # Alice

# Множества в списке
sets_list = [{1, 2, 3}, {4, 5, 6}, {7, 8, 9}]
print(sets_list[0])  # {1, 2, 3}

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

Функции — первоклассные объекты!

def greet(name):
    return f"Hello, {name}!"

def add(a, b):
    return a + b

# Функции в списке
functions = [greet, add, len, str.upper]
print(functions[0]("Alice"))  # Hello, Alice!
print(functions[1](5, 3))     # 8
print(functions[2]("hello"))  # 5
print(functions[3]("hello"))  # HELLO

# Lambda функции
operations = [
    lambda x: x + 1,
    lambda x: x * 2,
    lambda x: x ** 2
]
print(operations[0](5))  # 6
print(operations[1](5))  # 10
print(operations[2](5))  # 25

# Вызов функции из списка
callbacks = [print, len, sum]
callbacks[0]("Hello")     # Hello
callbacks[1]([1, 2, 3])   # 3
callbacks[2]([1, 2, 3])   # 6

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

class User:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def __repr__(self):
        return f"User({self.name}, {self.age})"

# Объекты в списке
users = [
    User("Alice", 30),
    User("Bob", 25),
    User("Charlie", 35)
]
print(users[0])         # User(Alice, 30)
print(users[0].name)    # Alice

# Даже классы (не объекты!) могут быть в списке
classes = [int, str, list, dict, set]
print(classes[0]("123"))  # 123
print(classes[1](123))    # '123'
print(classes[2]([1, 2])) # [1, 2]

5. Генераторы и итераторы

# Генератор функция
def count_to_n(n):
    for i in range(n):
        yield i

# Генератор в списке
gen = count_to_n(5)
generators = [gen, (x**2 for x in range(3)), iter([1, 2, 3])]

for value in generators[0]:
    print(value)  # 0, 1, 2, 3, 4

# Список из результатов генератора
gen_results = list(count_to_n(5))
print(gen_results)  # [0, 1, 2, 3, 4]

# Генераторное выражение в списке
squared_gen = (x**2 for x in range(5))
results = [squared_gen]
print(list(results[0]))  # [0, 1, 4, 9, 16]

6. Встроенные объекты

# Файловые объекты
import io
file_list = [io.StringIO("Hello"), open("data.txt")]

# Модули
import os
import sys
modules = [os, sys, __main__]

# Классы (как объекты)
from datetime import datetime
classes = [datetime, int, str, list]

# Встроенные функции
builtins = [print, len, sum, max, min, sorted]
print(builtins[1]([1, 2, 3]))  # 3

# Типы данных
types_list = [int, float, str, bool, NoneType := type(None)]
print(types_list)

7. Очень сложные типы

# Декоратор в списке
def my_decorator(func):
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__}")
        return func(*args, **kwargs)
    return wrapper

decorators = [my_decorator, staticmethod, classmethod, property]

# Context manager в списке
class MyContext:
    def __enter__(self):
        print("Entering")
        return self
    
    def __exit__(self, *args):
        print("Exiting")

contexts = [MyContext()]

with contexts[0]:
    print("Inside context")

# Исключения в списке
exceptions = [ValueError, TypeError, KeyError, AttributeError]
try:
    int("abc")
except exceptions[0] as e:
    print(f"Caught: {e}")

# Объекты с __call__ (callable объекты)
class CallableClass:
    def __call__(self, x):
        return x * 2

callables = [CallableClass(), lambda x: x + 1]
print(callables[0](5))  # 10
print(callables[1](5))  # 6

8. Циклические ссылки (опасность!)

# Список может содержать ссылку на себя!
my_list = [1, 2, 3]
my_list.append(my_list)  # Циклическая ссылка!
print(my_list)  # [1, 2, 3, [...]]

# Доступ к себе
my_list[3] is my_list  # True
my_list[3][3][3]  # Бесконечность

# Опасность: Бесконечный цикл
# for item in my_list:
#     print(item)  # Зависит навсегда!

9. Примеры реальных использований

# Полиморфизм: Список разных типов объектов
class Shape:
    def area(self):
        raise NotImplementedError

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
    
    def area(self):
        return 3.14 * self.radius ** 2

class Square(Shape):
    def __init__(self, side):
        self.side = side
    
    def area(self):
        return self.side ** 2

# Разные типы в одном списке
shapes = [Circle(5), Square(4), Circle(3)]
for shape in shapes:
    print(shape.area())  # Вызывает нужный метод

# Список обработчиков (паттерн Command)
def handle_click():
    print("Clicked!")

def handle_hover():
    print("Hovering!")

event_handlers = [handle_click, handle_hover, lambda: print("Other")]
for handler in event_handlers:
    handler()

# Конфигурация с разными типами
config = [
    "app_name",          # строка
    8000,                # число
    True,                # булево
    {"host": "localhost"},  # словарь
    ["admin", "user"],   # список
    lambda: "version"    # функция
]

# Стратегии в списке
strategies = {
    "quick_sort": lambda arr: sorted(arr),
    "bubble_sort": lambda arr: sorted(arr),  # Simplified
    "custom": lambda arr: arr[::-1]
}
chosen = strategies["quick_sort"]
print(chosen([3, 1, 2]))  # [1, 2, 3]

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

# isinstance работает для всех типов
my_list = [1, "hello", 3.14, [], {}, None]

for item in my_list:
    print(f"{item}: {type(item).__name__}")

# Фильтрация по типам
only_strings = [item for item in my_list if isinstance(item, str)]
only_numbers = [item for item in my_list if isinstance(item, (int, float))]
only_containers = [item for item in my_list if isinstance(item, (list, dict))]

print(only_strings)    # ['hello']
print(only_numbers)    # [1, 3.14]
print(only_containers) # [[], {}]

Ограничения

# Хеширующиеся объекты в списке (неизменяемые)
hashable = [1, "hello", (1, 2), frozenset({3, 4})]

# НЕ хеширующиеся (изменяемые)
unhashable = [[], {}, set(), [1, 2]]

# Можно положить в словарь или set только хеширующиеся
d = {1: "one", "two": 2, (3, 4): "tuple"}  # OK
# d = {[1, 2]: "list"}  # TypeError: unhashable type: 'list'

Тип элементов может быть ANY!

# Абсолютно всё может быть в списке
chaos = [
    1,                          # int
    "hello",                    # str
    [1, 2, 3],                  # list
    (4, 5, 6),                  # tuple
    {"key": "value"},           # dict
    {7, 8, 9},                  # set
    lambda x: x + 1,            # function
    print,                      # built-in
    ValueError,                 # exception class
    None,                        # NoneType
    True,                        # bool
    3.14,                        # float
    1+2j,                        # complex
    b"bytes",                    # bytes
    bytearray(b"array"),        # bytearray
    range(5),                    # range
]

for i, item in enumerate(chaos):
    print(f"{i}: {type(item).__name__} = {item}")

Это главная гибкость Python — списки могут содержать абсолютно что угодно!