Можно ли в качестве аргумента функции передать список?

Можно ли в качестве аргумента функции передать список?

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

Базовый пример

def print_items(items):
    """Функция принимает список и печатает элементы"""
    for item in items:
        print(item)

# Передача списка в функцию
my_list = [1, 2, 3, 4, 5]
print_items(my_list)  # Вывод: 1 2 3 4 5

# Можно передать список прямо
print_items([10, 20, 30])  # Вывод: 10 20 30

Важная особенность: списки передаются по ссылке

Это критичный момент! Списки в Python передаются по ссылке, а не по значению. Это означает, что если вы модифицируете список внутри функции, внешний список тоже изменится:

def modify_list(items):
    items.append(999)  # Добавляем элемент внутри функции
    items[0] = 'modified'

original_list = [1, 2, 3]
print(f'До: {original_list}')  # [1, 2, 3]

modify_list(original_list)
print(f'После: {original_list}')  # ['modified', 2, 3, 999]

Оригинальный список был изменен! Это может быть и плюсом, и минусом.

Плюсы передачи списков

1. Эффективность памяти Не создается копия списка, только ссылка:

import sys

big_list = list(range(1_000_000))
print(f'Размер списка: {sys.getsizeof(big_list)} байт')  # ~8MB

def process_list(items):
    # items — это просто ссылка, не копия
    return len(items)

result = process_list(big_list)  # Быстро, без копирования

2. Гибкость Списки можно модифицировать внутри функции, если это нужно:

def sort_and_reverse(items):
    items.sort()
    items.reverse()

numbers = [3, 1, 4, 1, 5]
sort_and_reverse(numbers)
print(numbers)  # [5, 4, 3, 1, 1]

3. Множественные значения Список позволяет функции возвращать (или изменять) множество значений:

def calculate_stats(numbers):
    results = []
    results.append(sum(numbers))         # Сумма
    results.append(len(numbers))         # Количество
    results.append(sum(numbers) / len(numbers))  # Среднее
    return results

stats = calculate_stats([10, 20, 30, 40])
print(stats)  # [100, 4, 25.0]

Минусы передачи списков (побочные эффекты)

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

def remove_duplicates_bad(items):
    items = list(set(items))  # Это создает НОВЫЙ список
    return items

original = [1, 2, 2, 3]
result = remove_duplicates_bad(original)
print(f'Original: {original}')  # [1, 2, 2, 3] — не изменен
print(f'Result: {result}')      # [1, 2, 3]

# Но если использовать методы списка:
def remove_duplicates_bad2(items):
    items.clear()  # Очищаем оригинальный список!
    for item in set(items):  # items уже пустой!
        items.append(item)

original = [1, 2, 2, 3]
remove_duplicates_bad2(original)
print(original)  # [] — оригинал уничтожен!

2. Сложность тестирования Функции с побочными эффектами сложнее тестировать:

# ❌ Плохо: сложно тестировать
def sum_and_clear(items):
    total = sum(items)
    items.clear()  # Побочный эффект
    return total

# ✅ Хорошо: функция чистая
def sum_items(items):
    return sum(items)

Как безопасно передавать списки

1. Создай копию, если нужно изменить

def process_and_return_new(original_list):
    # Создаем копию, не трогаем оригинал
    working_list = original_list.copy()  # или list(original_list)
    working_list.sort()
    working_list.reverse()
    return working_list

numbers = [3, 1, 4, 1, 5]
result = process_and_return_new(numbers)
print(f'Original: {numbers}')  # [3, 1, 4, 1, 5] — не изменен
print(f'Result: {result}')      # [5, 4, 3, 1, 1]

2. Использовать tuple если изменения не нужны

def print_items(items):  # items может быть tuple
    for item in items:
        print(item)

# Теперь функция принимает immutable данные
print_items((1, 2, 3))  # Работает
print_items([1, 2, 3])  # Тоже работает

# Но внутри функции не сможем изменить
def bad_function(items):
    items.append(999)  # TypeError если items — tuple

3. Type hints и документация

from typing import List

def modify_in_place(items: List[int]) -> None:
    """Модифицирует список на месте.
    
    Args:
        items: Список, который будет изменен
    """
    items.sort()

def return_new(items: List[int]) -> List[int]:
    """Возвращает новый список, оригинал не трогает.
    
    Args:
        items: Исходный список
        
    Returns:
        Новый отсортированный список
    """
    return sorted(items)

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

Пример 1: Фильтрация списка

def keep_even_numbers(numbers):
    """Оставляет только четные числа в списке."""
    i = 0
    while i < len(numbers):
        if numbers[i] % 2 != 0:
            numbers.pop(i)
        else:
            i += 1

data = [1, 2, 3, 4, 5, 6]
keep_even_numbers(data)
print(data)  # [2, 4, 6]

Пример 2: Обработка данных (safe version)

def normalize_scores(scores):
    """Нормализует баллы от 0 до 100."""
    if not scores:
        return []
    
    min_score = min(scores)
    max_score = max(scores)
    range_score = max_score - min_score
    
    if range_score == 0:
        return [100] * len(scores)
    
    # Возвращаем новый список
    return [
        int((score - min_score) / range_score * 100)
        for score in scores
    ]

original_scores = [50, 60, 70, 80]
normalized = normalize_scores(original_scores)
print(original_scores)  # [50, 60, 70, 80] — не изменен
print(normalized)        # [0, 33, 66, 100]

Советы и best practices

1. Если нужно изменить внешний список, явно возвращай новый список или void-функцию
2. Используй type hints, чтобы показать намерение
3. Документируй, будет ли список изменен или нет
4. Предпочитай функции, которые возвращают новые значения (функциональный стиль)
5. Если список большой, избегай копирования — передавай ссылку
6. Для обработки больших данных используй generators или iterators

Вывод

Да, списки можно передавать в функции. Это основная особенность Python. Главное — понимать, что списки передаются по ссылке, и управлять побочными эффектами: