# Шпаргалка по NumPy

> Все примеры из шпаргалки DataCamp по NumPy, проверенные в NumPy 2.4, и для каждого картинка того, что происходит с массивом. Строки, которые больше не работают в NumPy 2, исправлены.

- Published: 2026-11-15
- URL: https://latentstate.dev/ru/posts/numpy-cheatsheet/
- Topics: Machine Learning

---

Все примеры из [шпаргалки DataCamp по NumPy](https://assets.datacamp.com/blog_assets/Numpy_Python_Cheat_Sheet.pdf), запущенные в NumPy 2.4. У каждого есть код и картинка. Картинки рисуются запуском того же кода, поэтому показывают то, что NumPy действительно возвращает.

Как читать картинки: закрашенная ячейка - та, которую операция выбирает, читает или выдаёт. Толстая рамка отмечает ячейки, которые шаг только что записал. Пунктирные бледные ячейки - значения, которые NumPy повторяет при broadcasting. Маленькие числа в углу ячейки показывают порядок элементов. Серые числа по краям - индексы, от нуля.

Где исходная шпаргалка в NumPy 2 падает или ошибается, пример исправлен, а в тексте сказано, что изменилось. Примеры используют эти массивы:

```python
import numpy as np

a = np.array([1, 2, 3])
b = np.array([(1.5, 2, 3), (4, 5, 6)], dtype=float)
c = np.array([[(1.5, 2, 3), (4, 5, 6)], [(3, 2, 1), (4, 5, 6)]], dtype=float)
d = np.arange(10, 25, 5)
e = np.full((2, 2), 7)
f = np.eye(2)
g = a - b
```

## Создание массивов

### 1D, 2D, 3D

Оси нумеруются снаружи внутрь, ось 0 - это первый индекс. В 2D-массиве ось 0 идёт по строкам, в 3D-массиве - по блокам.

```python
a = np.array([1, 2, 3])
b = np.array([(1.5, 2, 3), (4, 5, 6)], dtype=float)
c = np.array([[(1.5, 2, 3), (4, 5, 6)], [(3, 2, 1), (4, 5, 6)]], dtype=float)
```

![Оси нумеруются снаружи внутрь, ось 0 - это первый индекс](https://latentstate.dev/_astro/fig-arrays-light.BOZNUXfr.png)

## Заготовки

### np.zeros

Новый массив заданной формы, заполненный нулями. Тип по умолчанию float64, поэтому `0.`.

```python
np.zeros((3, 4))
```

![Новый массив заданной формы, заполненный нулями](https://latentstate.dev/_astro/fig-zeros-light.DjBvXOAE.png)

### np.ones

Единицы, здесь 16-битные целые. Форма (2, 3, 4) - это 2 блока по 3 строки и 4 столбца.

```python
np.ones((2, 3, 4), dtype=np.int16)
```

![Единицы, здесь 16-битные целые](https://latentstate.dev/_astro/fig-ones-light.BT8Tgj8O.png)

### np.arange

Значения от start до stop с фиксированным шагом. Сам stop не входит, поэтому 25 в результате нет.

```python
d = np.arange(10, 25, 5)
```

![Значения от start до stop с фиксированным шагом](https://latentstate.dev/_astro/fig-arange-light.F6J7Cu-4.png)

### np.linspace

Заданное число равномерно расставленных значений, оба конца включены. 9 точек от 0 до 2 дают шаг 0.25.

```python
np.linspace(0, 2, 9)
```

![Заданное число равномерно расставленных значений, оба конца включены](https://latentstate.dev/_astro/fig-linspace-light.B_RBYKTg.png)

### np.full

Любая форма, заполненная одной константой.

```python
e = np.full((2, 2), 7)
```

![Любая форма, заполненная одной константой](https://latentstate.dev/_astro/fig-full-light.sgYa-FMN.png)

### np.eye

Единичная матрица: единицы на диагонали, нули в остальных местах.

```python
f = np.eye(2)
```

![Единичная матрица: единицы на диагонали, нули в остальных местах](https://latentstate.dev/_astro/fig-eye-light.BDhKr61V.png)

### np.random.random

Равномерно распределённые случайные числа от 0 (включительно) до 1 (не включая). В новом коде обычно пишут `np.random.default_rng().random((2, 2))`.

```python
np.random.random((2, 2))
```

![Равномерно распределённые случайные числа от 0 (включительно) до 1 (не включая)](https://latentstate.dev/_astro/fig-random-light.Dp5vQaNY.png)

### np.empty

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

```python
np.empty((3, 2))
```

![Выделяет память, но не инициализирует её](https://latentstate.dev/_astro/fig-empty-light.BB5LvVF9.png)

## Ввод-вывод

### np.save, np.load

`np.save` записывает один массив в бинарном формате NumPy .npy и сам добавляет расширение. В файле небольшой заголовок с типом и формой, затем сырые байты: 3 значения int64 занимают 24 байта.

```python
np.save('my_array', a)
np.load('my_array.npy')
```

![np.save записывает один массив в бинарном формате NumPy .npy и сам добавляет расширение](https://latentstate.dev/_astro/fig-save-load-light.BZZTtXo3.png)

### np.savez

Несколько массивов в одном несжатом архиве .npz. Массивы, переданные по позиции, получают имена arr_0, arr_1 и так далее; чтобы задать имена, передайте их ключами: `np.savez('array.npz', a=a, b=b)`. Сжатый архив делает `np.savez_compressed`.

```python
np.savez('array.npz', a, b)
np.load('array.npz')['arr_1']
```

![Несколько массивов в одном несжатом архиве .npz](https://latentstate.dev/_astro/fig-savez-light.CMLwSGRW.png)

### np.savetxt, np.loadtxt

Обычный текст, одна строка массива на строку файла. Формат по умолчанию `%.18e`, поэтому каждое число пишется как float, и `loadtxt` читает обратно float. Для целых передайте `fmt='%d'`.

```python
np.savetxt('myarray.txt', a, delimiter=' ')
np.loadtxt('myarray.txt')
```

![Обычный текст, одна строка массива на строку файла](https://latentstate.dev/_astro/fig-savetxt-loadtxt-light.CKNf7kBR.png)

### np.genfromtxt

Как `loadtxt`, но справляется с пропусками: пустое поле становится `nan`.

```python
np.genfromtxt('my_file.csv', delimiter=',')
```

![Как loadtxt, но справляется с пропусками: пустое поле становится nan](https://latentstate.dev/_astro/fig-genfromtxt-light.DI3lL46B.png)

## Типы данных

### dtypes

Тип задаёт, сколько байт занимает один элемент. Несколько имён из исходной шпаргалки в NumPy 2 удалены. `np.complex`, `np.object`, `np.string_` и `np.unicode_` теперь называются `np.complex128`, `np.object_`, `np.bytes_` и `np.str_`. Ещё шпаргалка называет float32 двойной точностью, но это одинарная точность; двойная - float64. Массив object хранит 8-байтовые указатели, а unicode-строка занимает 4 байта на символ.

```python
np.int64       # signed 64-bit integer
np.float32     # single-precision float
np.complex128  # complex number, two float64
np.bool        # True / False
np.object_     # any Python object
np.bytes_      # fixed-length byte string, e.g. 'S5'
np.str_        # fixed-length unicode string, e.g. 'U5'
```

![Тип задаёт, сколько байт занимает один элемент](https://latentstate.dev/_astro/fig-dtypes-light.DN_NTJz6.png)

## Свойства массива

### a.shape

Размер по каждой оси в виде кортежа. У 1D-массива это кортеж из одного элемента.

```python
a.shape
```

![Размер по каждой оси в виде кортежа](https://latentstate.dev/_astro/fig-shape-light.CHRZAx73.png)

### len

`len` считает только первую ось, поэтому у 2D-массива это число строк, а не число элементов.

```python
len(b)    # len(a) is 3
```

![len считает только первую ось, поэтому у 2D-массива это число строк, а не число элементов](https://latentstate.dev/_astro/fig-len-light.ChOg6bq5.png)

### b.ndim

Число осей.

```python
b.ndim
```

![Число осей](https://latentstate.dev/_astro/fig-ndim-light.Blsl3XTC.png)

### e.size

Общее число элементов, произведение размеров формы.

```python
e.size
```

![Общее число элементов, произведение размеров формы](https://latentstate.dev/_astro/fig-size-light.Bx6CbHrS.png)

### b.dtype

Тип элементов: как объект dtype и как его имя.

```python
b.dtype
b.dtype.name
```

![Тип элементов: как объект dtype и как его имя](https://latentstate.dev/_astro/fig-dtype-light.COH4EhJz.png)

### b.astype

Приводит к другому типу и возвращает копию. Из float в int дробная часть отбрасывается, поэтому 1.5 становится 1.

```python
b.astype(int)
```

![Приводит к другому типу и возвращает копию](https://latentstate.dev/_astro/fig-astype-light.rHxGw5dI.png)

## Справка

### np.info

Печатает документацию любого объекта NumPy. `help()` тоже работает.

```python
np.info(np.ndarray.dtype)
```

![Печатает документацию любого объекта NumPy](https://latentstate.dev/_astro/fig-info-light.DtdQwdfS.png)

## Арифметика

### a - b

Поэлементно. У a форма (3,), у b - (2, 3), поэтому NumPy растягивает a на каждую строку b (пунктирная строка). Функция делает то же самое.

```python
g = a - b
np.subtract(a, b)
```

![Поэлементно](https://latentstate.dev/_astro/fig-subtract-light.BtuoPbOM.png)

### b + a

Сложение, broadcasting тот же. Для broadcasting порядок операндов не важен.

```python
b + a
np.add(b, a)
```

![Сложение, broadcasting тот же](https://latentstate.dev/_astro/fig-add-light.C_nyVKmj.png)

### a / b

`/` всегда возвращает float, даже для двух целочисленных массивов. Целочисленное деление - `//`.

```python
a / b
np.divide(a, b)
```

![/ всегда возвращает float, даже для двух целочисленных массивов](https://latentstate.dev/_astro/fig-divide-light.Cew5vTqg.png)

### a * b

`*` умножает поэлементно. Это не матричное произведение, оно делается через `dot` или `@`, ниже.

```python
a * b
np.multiply(a, b)
```

![* умножает поэлементно](https://latentstate.dev/_astro/fig-multiply-light.C2px3VEj.png)

### np.exp

Поэлементные математические функции сохраняют форму. Здесь e в степени каждого элемента.

```python
np.exp(b)
```

![Поэлементные математические функции сохраняют форму](https://latentstate.dev/_astro/fig-exp-light.CHKHTXXc.png)

### np.sqrt

Квадратный корень каждого элемента.

```python
np.sqrt(b)
```

![Квадратный корень каждого элемента](https://latentstate.dev/_astro/fig-sqrt-light.DwJHRfNY.png)

### np.sin

Синус каждого элемента, в радианах.

```python
np.sin(a)
```

![Синус каждого элемента, в радианах](https://latentstate.dev/_astro/fig-sin-light.BKPCxagT.png)

### np.cos

Косинус каждого элемента, в радианах.

```python
np.cos(b)
```

![Косинус каждого элемента, в радианах](https://latentstate.dev/_astro/fig-cos-light.DgPZFwYb.png)

### np.log

Натуральный логарифм каждого элемента: log(1) равен 0. Другие основания - `np.log10` и `np.log2`.

```python
np.log(a)
```

![Натуральный логарифм каждого элемента: log(1) равен 0](https://latentstate.dev/_astro/fig-log-light.CDtLlI4O.png)

### e.dot(f)

Матричное произведение: каждая ячейка результата - строка e, умноженная на столбец f и просуммированная. f - единичная матрица, поэтому результат равен e.

```python
e.dot(f)
e @ f
```

![Матричное произведение: каждая ячейка результата - строка e, умноженная на столбец f и просуммированная](https://latentstate.dev/_astro/fig-dot-light.DiVzQ192.png)

## Сравнение

### a == b

Поэлементное сравнение даёт массив bool и растягивается так же, как арифметика.

```python
a == b
```

![Поэлементное сравнение даёт массив bool и растягивается так же, как арифметика](https://latentstate.dev/_astro/fig-equal-light.bPr6rDXS.png)

### a < 2

Сравнение с числом сравнивает с ним каждый элемент.

```python
a < 2
```

![Сравнение с числом сравнивает с ним каждый элемент](https://latentstate.dev/_astro/fig-less-light.Wj_WxhKY.png)

### np.array_equal

Один bool на весь массив: True, только если совпадают и форма, и все значения. Здесь формы разные.

```python
np.array_equal(a, b)
```

![Один bool на весь массив: True, только если совпадают и форма, и все значения](https://latentstate.dev/_astro/fig-array-equal-light.CfOQ4Ldh.png)

## Агрегатные функции

### a.sum

Сумма всех элементов.

```python
a.sum()
```

![Сумма всех элементов](https://latentstate.dev/_astro/fig-sum-light.Cjb-HNLK.png)

### a.min

Наименьший элемент. Его индекс даёт `a.argmin()`.

```python
a.min()
```

![Наименьший элемент](https://latentstate.dev/_astro/fig-min-light.Iwl2wCLh.png)

### b.max(axis=0)

С `axis=0` свёртка идёт вдоль оси 0, вниз по строкам, поэтому каждый столбец даёт одно значение. В шпаргалке написано «максимум строки», но при `axis=0` это максимум каждого столбца.

```python
b.max(axis=0)
```

![С axis=0 свёртка идёт вдоль оси 0, вниз по строкам, поэтому каждый столбец даёт одно значение](https://latentstate.dev/_astro/fig-max-axis0-light.BzAIC9Ys.png)

### b.cumsum(axis=1)

Накопленная сумма вдоль каждой строки. Форма не меняется.

```python
b.cumsum(axis=1)
```

![Накопленная сумма вдоль каждой строки](https://latentstate.dev/_astro/fig-cumsum-axis1-light.v-JsqyES.png)

### a.mean

Среднее арифметическое всех элементов.

```python
a.mean()
```

![Среднее арифметическое всех элементов](https://latentstate.dev/_astro/fig-mean-light.DZWvzVue.png)

### np.median

Метода `b.median()` нет, строка из шпаргалки падает с AttributeError. Нужен `np.median`. Значений шесть, поэтому медиана - среднее двух средних, 3 и 4.

```python
np.median(b)
```

![Метода b.median() нет, строка из шпаргалки падает с AttributeError](https://latentstate.dev/_astro/fig-median-light.BUkGI1VF.png)

### np.corrcoef

Метода `a.corrcoef()` тоже нет. `np.corrcoef` считает каждую строку переменной и возвращает матрицу их корреляций. Две строки b коррелируют почти идеально.

```python
np.corrcoef(b)
```

![Метода a.corrcoef() тоже нет](https://latentstate.dev/_astro/fig-corrcoef-light.BbeoY1p-.png)

### np.std

Стандартное отклонение по всем элементам. По умолчанию для генеральной совокупности (`ddof=0`); для выборочного передайте `ddof=1`.

```python
np.std(b)
```

![Стандартное отклонение по всем элементам](https://latentstate.dev/_astro/fig-std-light.B2GzsjAN.png)

## Копирование

### a.view

Представление (view) делит память с оригиналом, поэтому запись через h меняет и a.

```python
h = a.view()
h[0] = 9
```

![Представление (view) делит память с оригиналом, поэтому запись через h меняет и a](https://latentstate.dev/_astro/fig-view-light.Ch4MOlFP.png)

### a.copy

`a.copy()` и `np.copy(a)` делают независимую копию, поэтому a не меняется.

```python
h = a.copy()    # or np.copy(a)
h[0] = 9
```

![a.copy() и np.copy(a) делают независимую копию, поэтому a не меняется](https://latentstate.dev/_astro/fig-copy-light.ieZbCo0c.png)

## Сортировка

### x.sort

Сортирует на месте и возвращает None; `np.sort(x)` вместо этого возвращает отсортированную копию. a из шпаргалки уже отсортирован, поэтому здесь x.

```python
x = np.array([3, 1, 2])
x.sort()
```

![Сортирует на месте и возвращает None; np.sort(x) вместо этого возвращает отсортированную копию](https://latentstate.dev/_astro/fig-sort-light.-j2kwGFU.png)

### c.sort(axis=0)

Сортирует вдоль оси 0: каждая позиция сортируется между двумя блоками. Не на месте только 3 и 1 в углу, поэтому меняются только они.

```python
c.sort(axis=0)
```

![Сортирует вдоль оси 0: каждая позиция сортируется между двумя блоками](https://latentstate.dev/_astro/fig-sort-axis0-light.CGuTC-ax.png)

## Выборка, срезы, индексация

### a[2]

Элемент с индексом 2.

```python
a[2]
```

![Элемент с индексом 2](https://latentstate.dev/_astro/fig-index-1d-light.BGAcGvBf.png)

### b[1, 2]

Строка 1, столбец 2. То же, что `b[1][2]`, но за одну операцию индексации вместо двух.

```python
b[1, 2]
```

![Строка 1, столбец 2](https://latentstate.dev/_astro/fig-index-2d-light.Cs56IgKq.png)

### a[0:2]

Start включается, stop - нет: индексы 0 и 1.

```python
a[0:2]
```

![Start включается, stop - нет: индексы 0 и 1](https://latentstate.dev/_astro/fig-slice-1d-light.DOl9e9-5.png)

### b[0:2, 1]

Строки 0 и 1 столбца 1. Одиночный индекс убирает свою ось, поэтому результат одномерный.

```python
b[0:2, 1]
```

![Строки 0 и 1 столбца 1](https://latentstate.dev/_astro/fig-slice-column-light.CtU8ATBr.png)

### b[:1]

Срез сохраняет ось: `b[:1]` - двумерный массив из одной строки, а `b[0]` был бы одномерным. То же, что `b[0:1, :]`.

```python
b[:1]
```

![Срез сохраняет ось: b[:1] - двумерный массив из одной строки, а b[0] был бы одномерным](https://latentstate.dev/_astro/fig-slice-row-light.DYIrF5Cc.png)

### c[1, ...]

`...` заменяет столько `:`, сколько нужно, поэтому `c[1, ...]` - это `c[1, :, :]`, второй блок. В шпаргалке вывод напечатан с лишней скобкой; результат двумерный.

```python
c[1, ...]
```

![](https://latentstate.dev/_astro/fig-ellipsis-light.Du-Vd-H6.png)

### a[::-1]

Отрицательный шаг идёт назад. Маленькие числа показывают, откуда пришёл каждый элемент. Результат - view, а не копия.

```python
a[::-1]
```

![Отрицательный шаг идёт назад](https://latentstate.dev/_astro/fig-reverse-light.VzTJAIrN.png)

### a[a < 2]

Массив bool в роли индекса оставляет элементы, где стоит True. Результат всегда одномерный и всегда копия.

```python
a[a < 2]
```

![Массив bool в роли индекса оставляет элементы, где стоит True](https://latentstate.dev/_astro/fig-boolean-index-light.3E40GldB.png)

### b[[1, 0, 1, 0], [0, 1, 2, 0]]

Два списка индексов складываются в пары (1, 0), (0, 1), (1, 2) и (0, 0). Маленькие числа показывают порядок. Fancy indexing возвращает копию.

```python
b[[1, 0, 1, 0], [0, 1, 2, 0]]
```

![Два списка индексов складываются в пары (1, 0), (0, 1), (1, 2) и (0, 0)](https://latentstate.dev/_astro/fig-fancy-index-light.C0FBa4eD.png)

### b[[1, 0, 1, 0]][:, [0, 1, 2, 0]]

Сначала строки 1, 0, 1, 0, затем столбцы 0, 1, 2, 0 этого результата: сетка 4x4 с повторёнными строками и столбцами. За один шаг то же делает `b[np.ix_([1, 0, 1, 0], [0, 1, 2, 0])]`.

```python
b[[1, 0, 1, 0]][:, [0, 1, 2, 0]]
```

![Сначала строки 1, 0, 1, 0, затем столбцы 0, 1, 2, 0 этого результата: сетка 4x4 с повторёнными строками и столбцами](https://latentstate.dev/_astro/fig-fancy-grid-light.Ddh5fQ3Z.png)

### a[1:3] = 1

Этого нет в шпаргалке: присваивание через срезы. `a[1:3]` - сокращение для `a[1:3, :]`, а одно число справа растягивается на все выбранные ячейки. Для строк не подряд берётся список: `a[[0, 3]] = 1`.

```python
a = np.zeros((4, 4))
a[1:3] = 1     # rows 1 and 2
a[:, 3] = 1    # column 3
```

![Этого нет в шпаргалке: присваивание через срезы](https://latentstate.dev/_astro/fig-fill-rows-column-light.CoPpWLIz.png)

## Изменение формы

### np.transpose

Меняет оси местами: строка 0 становится столбцом 0. `.T` - короткая запись, а двойное транспонирование возвращает b.

```python
i = np.transpose(b)
i.T
```

![Меняет оси местами: строка 0 становится столбцом 0](https://latentstate.dev/_astro/fig-transpose-light.DICjJtO-.png)

### b.ravel

Вытягивает в одномерный массив построчно.

```python
b.ravel()
```

![Вытягивает в одномерный массив построчно](https://latentstate.dev/_astro/fig-ravel-light.DWXaHihx.png)

### g.reshape

Те же данные в новой форме, порядок элементов сохраняется. `-1` значит «вычисли этот размер сам». В шпаргалке написано `-2`; NumPy это принимает, но документировано именно `-1`.

```python
g.reshape(3, -1)
```

![Те же данные в новой форме, порядок элементов сохраняется](https://latentstate.dev/_astro/fig-reshape-light.0xNUqlTP.png)

### resize

В шпаргалке `h.resize` вызывается у view, и это падает с `ValueError: cannot resize this array: it does not own its data`. У массива, который владеет своими данными, метод работает на месте и дополняет нулями. Функция `np.resize` возвращает новый массив и повторяет данные.

```python
h = b.copy()
h.resize((2, 6))
np.resize(b, (2, 6))
```

![В шпаргалке h.resize вызывается у view, и это падает с ValueError: cannot resize this array: it does not own its data](https://latentstate.dev/_astro/fig-resize-light.CD7iYe2_.png)

## Добавление и удаление элементов

### np.append

Вытягивает оба массива и склеивает их в новый одномерный. Чтобы сохранить форму, передайте `axis=`.

```python
np.append(a, b)
```

![Вытягивает оба массива и склеивает их в новый одномерный](https://latentstate.dev/_astro/fig-append-light.BP5YksoL.png)

### np.insert

Вставляет 5 перед индексом 1 и возвращает новый массив. Массив NumPy никогда не растёт на месте.

```python
np.insert(a, 1, 5)
```

![Вставляет 5 перед индексом 1 и возвращает новый массив](https://latentstate.dev/_astro/fig-insert-light.D3SzLpF6.png)

### np.delete

Удаляет индекс 1 и возвращает новый массив.

```python
np.delete(a, [1])
```

![Удаляет индекс 1 и возвращает новый массив](https://latentstate.dev/_astro/fig-delete-light.DJNVp8qu.png)

## Объединение массивов

### np.concatenate

Склеивает массивы вдоль уже существующей оси.

```python
np.concatenate((a, d), axis=0)
```

![Склеивает массивы вдоль уже существующей оси](https://latentstate.dev/_astro/fig-concatenate-light.Cb6K8VMG.png)

### np.vstack

Складывает строки: a становится первой строкой, за ней идут строки b.

```python
np.vstack((a, b))
```

![Складывает строки: a становится первой строкой, за ней идут строки b](https://latentstate.dev/_astro/fig-vstack-light.yz5EkPx5.png)

### np.r_

Сокращённая запись в стиле индексации, склеивает вдоль оси 0; здесь то же, что `np.vstack((e, f))`.

```python
np.r_[e, f]
```

![Сокращённая запись в стиле индексации, склеивает вдоль оси 0; здесь то же, что np.vstack((e, f))](https://latentstate.dev/_astro/fig-r--light.B_WToGc4.png)

### np.hstack

Склеивает бок о бок, вдоль оси 1.

```python
np.hstack((e, f))
```

![Склеивает бок о бок, вдоль оси 1](https://latentstate.dev/_astro/fig-hstack-light.CPa_iYbb.png)

### np.column_stack

Делает из одномерных массивов столбцы. `np.c_[a, d]` даёт тот же результат.

```python
np.column_stack((a, d))
np.c_[a, d]
```

![Делает из одномерных массивов столбцы](https://latentstate.dev/_astro/fig-column-stack-light.D7ofaN5U.png)

## Разбиение массивов

### np.hsplit

Делит на 3 равные части вдоль оси 1; у одномерного массива это его единственная ось. Результат - список массивов.

```python
np.hsplit(a, 3)
```

![Делит на 3 равные части вдоль оси 1; у одномерного массива это его единственная ось](https://latentstate.dev/_astro/fig-hsplit-light.Uag_u_ud.png)

### np.vsplit

Делит вдоль оси 0 на 2 части, здесь это два блока c. Значения, которые шпаргалка печатает для этой строки, неверны; на картинке настоящие.

```python
np.vsplit(c, 2)
```

![Делит вдоль оси 0 на 2 части, здесь это два блока c](https://latentstate.dev/_astro/fig-vsplit-light.CBaIZeaL.png)
