---
title: Списки
seo:
  title: Списки — Data Analyst
  description: Тема «Списки» для собеседования Data Analyst. Как развернуть список? Как работает умножение списка?
---

[Все темы Data Analyst](/data-analyst)

## <strong>Как развернуть список?</strong> [#q-14bee738d69b8105b50bdda995b9d393]

В Python список можно развернуть несколькими способами&#58;

1. <strong>Используя срезы</strong>&#58; Это наиболее простой и часто
   используемый способ.

   ```python
   my_list = [1, 2, 3, 4, 5]
   reversed_list = my_list[::-1]
   ```

1. <strong>С помощью метода</strong> <code>reverse&#40;&#41;</code>&#58; Этот
   метод изменяет список на месте, не создавая новый.

   ```python
   my_list = [1, 2, 3, 4, 5]
   my_list.reverse()
   ```

1. <strong>С использованием функции</strong> <code>reversed&#40;&#41;</code>
   &#58; Эта функция возвращает итератор, который возвращает элементы списка в
   обратном порядке.

   ```python
   my_list = [1, 2, 3, 4, 5]
   reversed_list = list(reversed(my_list))
   ```

Срез и list(reversed(...)) создают новый список. Метод reverse() изменяет исходный список и возвращает None; reversed() сам по себе возвращает итератор.

:::note[Ссылки для изучения]

1. [Строки, кортежи, списки в Python](https://education.yandex.ru/handbook/python/article/stroki-kortezhi-spiski)
   :::

---

## <strong>Как работает умножение списка?</strong> [#q-14bee738d69b816986b3c78dddda9271]

Умножение списка в Python создает новый список, повторяя исходный список заданное количество раз.

Пример&#58;

```python
my_list = [1, 2, 3]
result = my_list * 3
print(result)  # [1, 2, 3, 1, 2, 3, 1, 2, 3]
```

В этом примере список <code>my_list</code> умножается на <code>3</code>, что приводит к созданию нового списка <code>result</code>, который содержит элементы <code>my_list</code>, повторенные три раза подряд.

:::note[Ссылки для изучения]

1. [Строки, кортежи, списки в Python](https://education.yandex.ru/handbook/python/article/stroki-kortezhi-spiski)
   :::

---

## <strong>Как объединить списки в Python?</strong> [#q-14bee738d69b81efb493c4a6209c8921]

В Python списки можно объединить несколькими способами&#58;

1. <strong>Используя оператор</strong> <code>&#43;</code>&#58;

   ```python
   list1 = [1, 2, 3]
   list2 = [4, 5, 6]
   combined_list = list1 + list2
   ```

1. <strong>Используя метод</strong> <code>extend&#40;&#41;</code>&#58;

   ```python
   list1 = [1, 2, 3]
   list2 = [4, 5, 6]
   list1.extend(list2)
   ```

1. <strong>Используя списковое выражение</strong>&#58;

   ```python
   list1 = [1, 2, 3]
   list2 = [4, 5, 6]
   combined_list = list1 + list2
   ```

Оператор + создаёт новый список, а extend() изменяет исходный список на месте и возвращает None.

:::note[Ссылки для изучения]

1. [Строки, кортежи, списки в Python](https://education.yandex.ru/handbook/python/article/stroki-kortezhi-spiski)
   :::

---

## <strong>В чем разница между глубокой и мелкой копиями?</strong> [#q-14bee738d69b8114b10bc4a22e1fa22c]

Разница между глубокой и мелкой копиями в Python связана с тем, как копируются вложенные структуры данных, такие как списки или словари&#58;

<strong>Мелкая копия (</strong>
<code>shallow copy</code>
<strong>)</strong>&#58;

- Создается новый объект, но вложенные объекты остаются ссылками на оригинальные объекты.

- Изменения вложенных объектов в копии будут отражены в оригинале.

- Для создания мелкой копии можно использовать метод <code>&#46;copy&#40;&#41;</code> у списка или словаря или функцию <code>copy&#46;copy&#40;&#41;</code> из модуля <code>copy</code>.

Пример мелкой копии списка&#58;

```python
import copy

list1 = [1, [2, 3]]
list2 = copy.copy(list1)

list2[1][0] = 4
print(list1)  # [1, [4, 3]]
print(list2)  # [1, [4, 3]]
```

<strong>Глубокая копия (</strong>
<code>deep copy</code>
<strong>)</strong>&#58;

- Создается новый объект и рекурсивно копируются все вложенные объекты.

- Изменения в глубокой копии не влияют на оригинал и наоборот.

- Для создания глубокой копии можно использовать функцию <code>copy&#46;deepcopy&#40;&#41;</code> из модуля <code>copy</code>.

Пример глубокой копии списка&#58;

```python
import copy

list1 = [1, [2, 3]]
list2 = copy.deepcopy(list1)

list2[1][0] = 4
print(list1)  # [1, [2, 3]]
print(list2)  # [1, [4, 3]]
```

Таким образом, при работе с изменяемыми вложенными структурами данных важно понимать разницу между мелкой и глубокой копиями для предотвращения неожиданных побочных эффектов.

:::note[Ссылки для изучения]

1. [Строки, кортежи, списки в Python](https://education.yandex.ru/handbook/python/article/stroki-kortezhi-spiski)
   :::

---

## <strong>В чем разница между списками и массивами?</strong> [#q-14bee738d69b81628878c52e1ac8ace3]

Основные различия между списками (<code>list</code>) и массивами в контексте Python&#58;

{/* prettier-ignore */}
1. <strong>Использование</strong>&#58;

    - <strong>Списки (</strong><code>list</code><strong>)</strong>&#58; универсальная структура данных, которая может содержать элементы различных типов и изменяться в размере.

    - <strong>Массивы</strong>&#58; в Python обычно используются массивы из библиотеки <code>numpy</code> (<code>numpy&#46;array</code>). Они предназначены для работы с числовыми данными и обеспечивают эффективные операции над большими объемами данных.

1. <strong>Типы данных</strong>&#58;

    - <strong>Списки (</strong><code>list</code><strong>)</strong>&#58; могут содержать элементы различных типов данных (например, числа, строки, другие списки и т.д.).

    - <strong>Массивы</strong>&#58; обычно содержат элементы одного типа данных (например, только числа типа <code>float</code> или <code>int</code>).

1. <strong>Производительность</strong>&#58;

    - <strong>Массивы</strong>&#58; операции с массивами из <code>numpy</code> обычно выполняются более эффективно благодаря оптимизированным внутренним реализациям.

    - <strong>Списки (</strong><code>list</code><strong>)</strong>&#58; менее эффективны для числовых вычислений из-за динамической природы и возможности хранения различных типов данных.

1. <strong>Изменяемость</strong>&#58;

    - Оба типа данных в Python изменяемы и могут изменяться в размере, однако массивы <code>numpy</code> предпочтительны для операций, которые требуют изменения больших объемов данных из-за своей эффективной реализации и оптимизации.

:::note[Ссылки для изучения]

1. [Строки, кортежи, списки в Python](https://education.yandex.ru/handbook/python/article/stroki-kortezhi-spiski)
   :::

---

## <strong>Как объединить два массива?</strong> [#q-14bee738d69b812ea516df3a299275db]

В Python, особенно если речь идет о массивах из библиотеки NumPy, для объединения двух массивов можно использовать функцию <code>numpy&#46;concatenate&#40;&#41;</code> или оператор <code>&#43;</code> для списков (если мы говорим о стандартных списках Python)&#58;

1. <strong>Для списков (стандартных массивов в Python)</strong>&#58;

   ```python
   array1 = [1, 2, 3]
   array2 = [4, 5, 6]
   combined_array = array1 + array2
   ```

1. <strong>Для массивов NumPy</strong>&#58;

   ```python
   import numpy as np

   array1 = np.array([1, 2, 3])
   array2 = np.array([4, 5, 6])
   combined_array = np.concatenate((array1, array2))
   ```

В обоих случаях <code>combined_array</code> будет содержать объединенные элементы <code>array1</code> и <code>array2</code>.

:::note[Ссылки для изучения]

1. [Строки, кортежи, списки в Python](https://education.yandex.ru/handbook/python/article/stroki-kortezhi-spiski)
   :::

---

## <strong>Что такое срезы списка? Как их делать?</strong> [#q-14bee738d69b8108a651e1d619a4edbf]

Срезы списка в Python позволяют извлекать подмножество элементов из списка по заданным индексам. Они делаются с использованием синтаксиса <code>&#91;start&#58;stop&#58;step&#93;</code>, где&#58;

- <code>start</code>&#58; начальный индекс (включительно), с которого начинается
  срез (по умолчанию 0).

- <code>stop</code>&#58; конечный индекс (исключительно), на котором
  заканчивается срез (по умолчанию длина списка).

- <code>step</code>&#58; шаг (по умолчанию 1), определяющий интервал между
  выбранными элементами.

Примеры использования срезов&#58;

```python
my_list = [1, 2, 3, 4, 5]

# Получение элементов с индексами от 1 до 3 (не включая 3)
slice1 = my_list[1:3]
# slice1 = [2, 3]

# Получение элементов с индексами от 0 до 4 с шагом 2
slice2 = my_list[0:4:2]
# slice2 = [1, 3]

# Получение элементов с индексами от 2 до конца списка
slice3 = my_list[2:]
# slice3 = [3, 4, 5]

# Получение элементов с индексами от начала до 3 (не включая 3)
slice4 = my_list[:3]
# slice4 = [1, 2, 3]

# Получение элементов с индексами в обратном порядке
slice5 = my_list[::-1]
# slice5 = [5, 4, 3, 2, 1]
```

:::note[Ссылки для изучения]

1. [Строки, кортежи, списки в Python](https://education.yandex.ru/handbook/python/article/stroki-kortezhi-spiski)
   :::

---

## <strong>Как работают</strong> <code>any&#40;&#41;</code> <strong>и</strong> <code>all&#40;&#41;</code><strong>?</strong> [#q-14bee738d69b813bbb59e0ed3a882c18]

Функции <code>any&#40;&#41;</code> и <code>all&#40;&#41;</code> в Python предназначены для работы с итерируемыми объектами (например, списками, кортежами) и возвращают булевое значение <code>True</code> или <code>False</code> в зависимости от условий&#58;

{/* prettier-ignore */}
1. <code>any&#40;iterable&#41;</code>&#58;

    - Возвращает <code>True</code>, если хотя бы один элемент в итерируемом объекте истинный (не равен <code>False</code>, <code>0</code>, <code>None</code> или пустой объект).

    - Если все элементы ложные, возвращает <code>False</code>.

    Пример&#58;

    ```python
    list1 = [True, False, True]
    result = any(list1)
    print(result)  # Вывод: True
    ```

1. <code>all&#40;iterable&#41;</code>&#58;

    - Возвращает <code>True</code>, если все элементы в итерируемом объекте истинные (не равны <code>False</code>, <code>0</code>, <code>None</code> или пусты).

    - Если хотя бы один элемент ложный, возвращает <code>False</code>.

    Пример&#58;

    ```python
    list2 = [True, True, False]
    result = all(list2)
    print(result)  # Вывод: False
    ```

Обе функции полезны для проверки условий в списке или других структурах данных, где требуется быстро выяснить, содержит ли объект хотя бы одно истинное или все элементы истинные.

:::note[Ссылки для изучения]

1. [Строки, кортежи, списки в Python](https://education.yandex.ru/handbook/python/article/stroki-kortezhi-spiski)
   :::

---

## <strong>Как удалить из списка дубликаты?</strong> [#q-14bee738d69b819dbba5d8b549877caa]

Для удаления дубликатов из списка в Python можно использовать несколько подходов. Вот два основных способа&#58;

{/* prettier-ignore */}
1. <strong>С использованием типа данных set</strong>&#58;

    - Преобразовать список в множество (<code>set</code>), так как множество автоматически удаляет дубликаты.

    - Преобразуйте множество обратно в список, если нужен результат типа list. Исходный порядок при этом не восстанавливается.

    ```python
    my_list = [1, 2, 2, 3, 4, 4, 5]
    unique_items = list(set(my_list))
    ```

    Этот метод прост и эффективен, однако не сохраняет порядок элементов изначального списка.

1. <strong>С использованием списка и цикла</strong>&#58;

    - Создать новый список и добавлять в него элементы из исходного списка, если они еще не встречались.

    ```python
    my_list = [1, 2, 2, 3, 4, 4, 5]
    unique_items = []
    for item in my_list:
        if item not in unique_items:
            unique_items.append(item)
    ```

    Этот метод сохраняет порядок элементов, но менее эффективен по времени выполнения, особенно для больших списков.

Выбор метода зависит от конкретной задачи&#58; использование множества (<code>set</code>) предпочтительно для простого удаления дубликатов, если порядок не важен, в то время как цикл и проверка позволяют сохранить порядок элементов, но могут быть менее эффективными.

:::note[Ссылки для изучения]

1. [Строки, кортежи, списки в Python](https://education.yandex.ru/handbook/python/article/stroki-kortezhi-spiski)
   :::

---

## <strong>В чем разница между</strong> <code>append</code> <strong>и</strong> <code>extend</code><strong>?</strong> [#q-14bee738d69b81168b07d322adabb9a4]

Разница между методами <code>append&#40;&#41;</code> и <code>extend&#40;&#41;</code> в Python заключается в способе добавления элементов в конец списка&#58;

{/* prettier-ignore */}
1. <code>append&#40;&#41;</code>&#58;

    - Добавляет элемент в конец списка как один элемент.

    - Принимает один аргумент, который может быть любым типом данных (число, строка, объект и т.д.).

    Пример&#58;

    ```python
    my_list = [1, 2, 3]
    my_list.append(4)
    print(my_list)  # Вывод: [1, 2, 3, 4]
    ```

1. <code>extend&#40;&#41;</code>&#58;

    - Расширяет список, добавляя элементы из итерируемого объекта (например, другого списка) в конец текущего списка.

    - Принимает один аргумент, который должен быть итерируемым объектом (список, кортеж, строка и т.д.).

    Пример&#58;

    ```python
    my_list = [1, 2, 3]
    another_list = [4, 5, 6]
    my_list.extend(another_list)
    print(my_list)  # Вывод: [1, 2, 3, 4, 5, 6]
    ```

Таким образом, <code>append&#40;&#41;</code> добавляет один элемент в конец списка, а <code>extend&#40;&#41;</code> добавляет элементы из другого итерируемого объекта в конец текущего списка, расширяя его.

:::note[Ссылки для изучения]

1. [Строки, кортежи, списки в Python](https://education.yandex.ru/handbook/python/article/stroki-kortezhi-spiski)
   :::

---

## <strong>В чем разница между</strong> <code>remove</code><strong>,</strong> <code>del</code> <strong>и</strong> <code>pop</code><strong>?</strong> [#q-14bee738d69b81438e78c036885990b6]

В Python есть три основных способа удаления элементов из списка, каждый из которых имеет свои особенности&#58;

{/* prettier-ignore */}
1. <code>remove&#40;&#41;</code>&#58;

    - Удаляет первое вхождение указанного значения из списка.

    - Если значение не найдено, возникает ошибка <code>ValueError</code>.

    Пример&#58;

    ```python
    my_list = [1, 2, 3, 2]
    my_list.remove(2)
    print(my_list)  # Вывод: [1, 3, 2]
    ```

1. <code>del</code>&#58;

    - Удаляет элемент по индексу или срезу.

    - Не возвращает значение элемента.

    - Позволяет удалить несколько элементов за раз, используя срезы.

    Пример удаления элемента по индексу&#58;

    ```python
    my_list = [1, 2, 3]
    del my_list[1]
    print(my_list)  # Вывод: [1, 3]
    ```

    Пример удаления элементов с использованием среза&#58;

    ```python
    my_list = [1, 2, 3, 4, 5]
    del my_list[1:3]
    print(my_list)  # Вывод: [1, 4, 5]
    ```

1. <code>pop&#40;&#41;</code>&#58;

    - Удаляет элемент по индексу и возвращает его значение.

    - Если индекс не указан, удаляется и возвращается последний элемент списка.

    Пример удаления и получения значения элемента по индексу&#58;

    ```python
    my_list = [1, 2, 3]
    popped_value = my_list.pop(1)
    print(my_list)      # Вывод: [1, 3]
    print(popped_value) # Вывод: 2
    ```

:::note[Ссылки для изучения]

1. [Строки, кортежи, списки в Python](https://education.yandex.ru/handbook/python/article/stroki-kortezhi-spiski)
   :::
