Np where python как работает

Pandas: как использовать эквивалент np.where()

Вы можете использовать функцию NumPy where() для быстрого обновления значений в массиве NumPy, используя логику if-else.

Например, в следующем коде показано, как обновить значения в массиве NumPy, соответствующие определенному условию:

import numpy as np #create NumPy array of values x = np.array([1, 3, 3, 6, 7, 9]) #update valuesin array based on condition x = np.where ((x < 5) | (x >8), x/2, x) #view updated array x array([0.5, 1.5, 1.5, 6. , 7. , 4.5]) 

Если заданное значение в массиве было меньше 5 или больше 8, мы делили значение на 2.

В противном случае мы оставили значение без изменений.

Мы можем выполнить аналогичную операцию в pandas DataFrame, используя функцию pandas where() , но синтаксис немного отличается.

Вот основной синтаксис с использованием функции NumPy where():

x = np.where (condition, value_if_true, value_if_false) 

А вот основной синтаксис с использованием функции pandas where():

df['col'] = (value_if_false). where (condition, value_if_true) 

В следующем примере показано, как использовать функцию where() в pandas на практике.

Пример: эквивалент np.where() в Pandas

Предположим, у нас есть следующие Pandas DataFrame:

import pandas as pd #create DataFrame df = pd.DataFrame() #view DataFrame print(df) A B 0 18 5 1 22 7 2 19 7 3 14 9 4 14 12 5 11 9 6 20 9 7 28 4 

Мы можем использовать следующую функцию панд where() для обновления значений в столбце A на основе определенного условия:

#update values in column A based on condition df['A'] =(df['A'] / 2). where(df['A'] < 20, df['A'] \* 2) #view updated DataFrame print(df) A B 0 9.0 5 1 44.0 7 2 9.5 7 3 7.0 9 4 7.0 12 5 5.5 9 6 40.0 9 7 56.0 4 

Если заданное значение в столбце А было меньше 20, мы умножали это значение на 2.

В противном случае мы разделили значение на 2.

Дополнительные ресурсы

В следующих руководствах объясняется, как выполнять другие распространенные операции в pandas:

numpy.where

Возвратные элементы выбираются из x или y в зависимости от condition .

Когда предоставляется только condition , эта функция является сокращением для np.asarray(condition).nonzero() . Использование напрямую nonzero предпочтительнее, так как он корректно работает с подклассами. Остальная часть этой документации охватывает только случай, когда предоставлены все три аргумента.

Parameters conditionarray_like, bool

Где True, yield x , иначе yield y .

x, yarray_like

Ценности, из которых можно выбирать. x , y и condition должны транслироваться в какой-то форме.

Returns outndarray

Массив с элементами из x , где condition — это True, и элементами из y из других мест.

Функция, которая вызывается, когда x и y опущены

Notes

Если все массивы 1-D,, where эквивалентен:

[xv if c else yv for c, xv, yv in zip(condition, x, y)] 

Examples

>>> a = np.arange(10) >>> a array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) >>> np.where(a < 5, a, 10*a) array([ 0, 1, 2, 3, 4, 50, 60, 70, 80, 90])

Это можно использовать и для многомерных массивов:

>>> np.where([[True, False], [True, True]], . [[1, 2], [3, 4]], . [[9, 8], [7, 6]]) array([[1, 8], [3, 4]])

Формы x, y и условие передаются вместе:

>>> x, y = np.ogrid[:3, :4] >>> np.where(x < y, x, 10 + y) # both x and 10+y are broadcast array([[10, 0, 0, 0], [10, 11, 1, 1], [10, 11, 12, 2]])

>>> a = np.array([[0, 1, 2], . [0, 2, 4], . [0, 3, 6]]) >>> np.where(a < 4, a, -1) # -1 is broadcast array([[ 0, 1, 2], [ 0, 2, -1], [ 0, 3, -1]])

Библиотека NumPy: всё, что нужно знать новичку

Подробный гайд по самому популярному Python-инструменту для анализа данных и обучения нейронных сетей.

Иллюстрация: A Wolker / Pexels / Colowgee для Skillbox Media

Дмитрий Зверев

Любитель научной фантастики и технологического прогресса. Хорошо сочетает в себе заумного технаря и утончённого гуманитария. Пишет про IT и радуется этому.

NumPy — это открытая бесплатная Python-библиотека для работы с многомерными массивами, этакий питонячий аналог Matlab. NumPy чаще всего используют в анализе данных и обучении нейронных сетей — в каждой из этих областей нужно проводить много вычислений с такими матрицами.

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

Содержание

• Самый простой способ — Anaconda
• Без лишних файлов — через PIP

• Базовые функции
• Доступ к элементам
• Создание специальных массивов
• Математические операции
• Копирование и организации
• Дополнительные возможности

Что такое NumPy и зачем она нужна

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

Библиотека частично написана на Python, а частично на C и C++ — в тех местах, которые требуют скорости. Кроме того, код NumPy оптимизирован под большинство современных процессоров. Кстати, как и у Matlab, для NumPy существуют пакеты, расширяющие её функциональность, — например, библиотека SciPy или Matplotlib.

Массивы в NumPy отличаются от обычных списков и кортежей в Python тем, что они должны состоять только из элементов одного типа. Такое ограничение позволяет увеличить скорость вычислений в 50 раз, а также избежать ненужных ошибок с приведением и обработкой типов.

Как установить NumPy

Мы установим NumPy через платформу Anaconda, которая содержит много разных библиотек для Python. А ещё покажем, как это сделать через PIP.

NumPy можно также использовать через Jupyter Notebook, Google Colab или другими средствами — как вам удобнее. Поэтому выбирайте любой способ и пойдёмте изучать его.

Самый простой способ — Anaconda

Сначала надо зайти на официальный сайт Anaconda, чтобы скачать последнюю версию Python и NumPy: есть готовые пакеты под macOS, Windows и Linux.

Затем открываем установщик, соглашаемся со всеми пунктами и выбираем место для установки.

Чтобы убедиться, что Python точно установился, открываем консоль и вводим туда команду python3 — должен запуститься интерпретатор Python, в котором можно писать код. Выглядит всё это примерно так:

Anaconda уже содержит в себе много полезностей — например, NumPy, SciPy, Pandas. Поэтому больше ничего устанавливать не нужно. Достаточно проверить, что библиотека NumPy действительно работает. Введите в интерпретаторе Python в консоли такие команды — пока не важно, что это и как работает, об этом поговорим ниже.

import numpy as np

А потом выводим значение переменной a — чтобы убедиться, что всё работает:

Должно получиться что-то вроде вывода на скриншоте:

Без лишних файлов — через PIP

Если вам не хочется скачивать огромный пакет Anaconda, вы можете установить только NumPy с помощью встроенного питоновского менеджера пакетов PIP.

Для этого сначала нужно установить Python с официального сайта. Заходим на него, переходим во вкладку Downloads и видим справа последнюю актуальную версию Python:

После этого начинается стандартная процедура: выбираем место установки и соглашаемся со всеми пунктами.

В конце нас должны поздравить.

Теперь нужно скачать библиотеку NumPy. Открываем консоль и вводим туда команду pip install numpy.

Если вдруг у вас выпала ошибка, значит, нужно написать другую похожую команду — pip3 install numpy.

Теперь у нас точно должна установиться NumPy. Правда, тут нас уже никто не поздравляет — лишь сухо отмечают, что установка завершилась успешно.

Подключаем NumPy

Перед тем как использовать NumPy, нужно подключить библиотеку в Python-коде — а вы думали, достаточно установить его? Нет, Python ещё должен узнать, что конкретно в этом проекте NumPy нам нужен.

В NumPy-массивы можно передавать не только целые числа, но и дробные:

Ещё мы можем менять значения в NumPy-массиве с помощью той же операции доступа к элементам. Например:

c = np.array([[0, 2], [4, 6]]) c[0, 0] = 1 print(c) [[1 2] [4 6]]

Мы заменили элемент из первой строки и первого столбца (элемент 0) на единицу. И наш массив успешно изменился.

Кроме отдельных элементов, можно заменять любые последовательности элементов с помощью конструкции начальный_индекс: конечный_индекс: шаг и её упрощённой версии — :.

c = np.array([[0, 2], [4, 6]]) с[0, :] = [3, 3] print(c) [[3 3] [4 6]]

Теперь в с вся первая строка заменилась на тройки. Главное при такой замене — учитывать размер строки, чтобы не возникло ошибок. Например, если присвоить первой строке вектор из трёх элементов, интерпретатор будет ругаться:

c = np.array([[0, 2], [4, 6]]) c[0, :] = [3, 3, 3] Traceback (most recent call last): File "", line 1, in ValueError: could not broadcast input array from shape (3,) into shape (2,)

Текст ошибки сообщает, что нельзя присвоить одномерному массиву с размером 2 массив размером 3.

Создание специальных массивов

Мы научились создавать массивы любой размерности. Но иногда хочется создать их с уже заполненными значениями — например, забить все ячейки нулями или единицами. NumPy может и это.

Массив из нулей. Чтобы создать его, используем функцию zeros.

a = np.zeros((2, 2)) print(a) [[0. 0.] [0. 0.]]

Первое, что нужно помнить, — как задавать размер. Он задаётся кортежем (2, 2). Если указать размер без скобок, то снова получим ошибку:

a = np.zeros(2, 2) Traceback (most recent call last): File "", line 1, in TypeError: Cannot interpret '2' as a data type

А всё потому, что без скобок NumPy расценивает второй элемент (число 2) как тип данных, который должен быть указан для параметра dtype.

Если указать только одно число, создастся вектор размером два элемента. В этом случае уже не нужно ставить дополнительные скобки:

a = np.zeros(2) print(a) [0. 0.]

Ещё стоит отметить, что элементам по умолчанию присваивается тип float64. Это дробные числа, которые занимают в памяти 64 бита, или 8 байт. Если нужны именно целые числа, то мы по старой схеме указываем это в параметре dtype — через запятую:

a = np.zeros(2, dtype='int32') print(a) [0 0]

Массив из единиц. Он создаётся точно так же, как и из нулей, но используется функция ones:

b = np.ones((4, 2, 2), dtype='int32') print(b) [[[1 1] [1 1]] [[1 1] [1 1]] [[1 1] [1 1]] [[1 1] [1 1]]]

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

Массив из произвольных чисел. Иногда бывает нужно заполнить массив какими-то отличными от нуля и единицы числами. В этом поможет функция full:

c = np.full((2, 2), 5) print(c) [[5 5] [5 5]]

Здесь мы сначала указали, какой размер должен быть у массива через кортеж, — (2,2), а затем число, которым мы хотим заполнить все его элементы, — 5.

Равно как и у функций zeros и ones, элементы по умолчанию будут иметь тип float64. А размер должен передаваться в виде кортежа — (2, 2).

Массив случайных чисел. Он создаётся с помощью функции random.rand:

d = np.random.rand(3, 2) print(d) [[0.76088962 0.14281283] [0.32124888 0.34894434] [0.66903093 0.72899792]]

Получилось что-то странное. Но так и должно быть — ведь NumPy генерирует случайные числа в диапазоне от 0 до 1 с восемью знаками после запятой.

Ещё одна странность — то, как задаётся размер. Здесь это нужно делать не через кортеж (3, 2), а просто указывая размерности через запятую. Всё потому, что в функции random.rand нет параметра dtype.

Чтобы создать массив случайных чисел, нужно воспользоваться функцией random.randint:

e = np.random.randint(-5, 10, size=(4, 4)) print(e) [[ 3 1 -4 3] [ 0 -2 5 3] [ 5 -1 9 2] [ 0 -4 9 -2]]

У нас получился массив размером четыре на четыре — size=(4, 4) — с целыми числами из диапазона от –5 до 10. Как и в предыдущем случае, создаётся такой массив слегка странно — но такова жизнь NumPy-программистов.

Единичная матрица. Она нужна тем, кто занимается линейной алгеброй. По диагонали такой матрицы элементы равны единице, а все остальные элементы — нулю. Создаётся она с помощью функции identity или eye:

i = np.identity(4) print(i) [[1. 0. 0. 0.] [0. 1. 0. 0.] [0. 0. 1. 0.] [0. 0. 0. 1.]]

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

И всё также можно указать тип элементов с помощью параметра dtype:

i = np.identity(4, dtype='int32') print(i) [[1 0 0 0] [0 1 0 0] [0 0 1 0] [0 0 0 1]]

Математические операции

Массивы из NumPy поддерживают все стандартные арифметические операции — например, сложение, деление, вычитание. Работает это поэлементно:

a = np.array([1, 2, 3, 4]) print(a) [1 2 3 4] print(a + 3) [4 5 6 7]

К каждому элементу a прибавилось число 3, а размерность не изменилась. Все остальные операции работают точно так же:

print(a - 2) [-1 0 1 2] print(a * 2) [2 4 6 8] print(a / 2) [0.5 1. 1.5 2.] #Здесь тип элементов приведён к 'float64' print(a ** 2) [1 4 9 16]

Ещё можно проводить любые математические операции с массивами одинакового размера:

a = np.array([[1, 2], [3, 4]]) b = np.array([[2, 2], [2, 2]]) print(a + b) [[3 4] [5 6]] print(a * b) [[2 4] [6 8]] print(a ** b) [[ 1 4] [ 9 16]]

Здесь каждый элемент a складывается, умножается и возводится в степень на элемент из такой же позиции массива b.

Кроме примитивных операций, в NumPy можно проводить и более сложные — например, вычислить косинус:

a = np.array([[1, 2], [3, 4]]) print(np.cos(a)) [[ 0.54030231 -0.41614684] [-0.9899925 -0.65364362]]

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

Ещё к массивам можно применять различные операции из линейной алгебры, математической статистики и так далее. Давайте для примера перемножим матрицы по правилам линейной алгебры:

a = np.ones((2, 3)) print(a) [[1. 1. 1.] [1. 1. 1.]] b = np.full((3, 2), 2) print(b) [[2 2] [2 2] [2 2]] print(np.matmul(a, b)) [[6. 6.] [6. 6.]]

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

Копирование и организация

Если в NumPy вы присвоите массив другой переменной, то просто создадите ссылку на него. Разберём на примере:

a = np.array([1, 2, 3]) b = a b[0] = 5 print(b) [5 2 3] print(a) [5 2 3]

Как мы видим, при изменении b меняется также и a. Дело в том, что массивы в NumPy — это только ссылки на области в памяти. Поэтому, когда мы присвоили a переменной b, на самом деле мы просто присвоили ей ссылку на первый элемент a в памяти.

Чтобы создать независимую копию a, используйте функцию copy:

a = np.array([1, 2, 3]) b = a.copy() b[0] = 5 print(b) [5 2 3] print(a) [1 2 3]

Ещё мы можем менять размер массива с помощью функции reshape:

a = np.array([[1, 2, 3, 4], [5, 6, 7, 8]]) print(a) [[1 2 3 4] [5 6 7 8]] b = a.reshape((4, 2)) print(b) [[1 2] [3 4] [5 6] [7 8]]

Изначально размер a был 2 на 4. Мы переделали его под 4 на 2. Заметьте: новые размеры должны соответствовать количеству элементов. В противном случае Python вернет ошибку:

a = np.array([[1, 2, 3, 4], [5, 6, 7, 8]]) b = a.reshape((4, 3)) Traceback (most recent call last): File "", line 1, in ValueError: cannot reshape array of size 8 into shape (4,3)

Ещё NumPy позволяет нам «наслаивать» массивы друг на друга и соединять их с помощью функций vstack и hstack:

v1 = np.array([1, 2, 3]) v2 = np.array([9, 8, 7]) v3 = np.vstack([v1, v2]) print(v3) [[1 2 3] [9 8 7]]

Здесь мы создали двумерный массив из двух векторов одинакового размера, которые «поставили» друг на друга. То же самое можно сделать и горизонтально:

h1 = np.ones((2, 4)) h2 = np.zeros((2, 2)) h3 = np.hstack((h1, h2)) print(h3) [[1. 1. 1. 1. 0. 0.] [1. 1. 1. 1. 0. 0.]]

К массиву из единиц справа присоединился массив из нулей. Главное — чтобы количество строк в обоих было одинаковым, иначе вылезет ошибка:

h1 = np.ones((2, 4)) h2 = np.zeros((3, 2)) h3 = np.hstack((h1, h2)) Traceback (most recent call last): File "", line 1, in File "", line 5, in hstack File "/Users/Dmitry/opt/anaconda3/lib/python3.9/site-packages/numpy/core/shape_base.py", line 345, in hstack return _nx.concatenate(arrs, 1) File "", line 5, in concatenate ValueError: all the input array dimensions for the concatenation axis must match exactly, but along dimension 0, the array at index 0 has size 2 and the array at index 1 has size 3

Эта ошибка говорит, что количество строк не совпадает.

Дополнительные возможности

NumPy поддерживает другие полезные функции, которые используются реже, но знать о которых полезно. Например, одна из таких функций — чтение файлов с жёсткого диска.

Чтение данных из файла. Допустим, у нас есть файл data.txt с таким содержимым:

1,2,3,5,6,7 8,1,4,2,6,4 9,0,1,7,3,4

Мы можем записать числа в NumPy-массив с помощью функции genfromtxt:

filedata = np.genfromtxt('data.txt', delimiter=',') filedata = filedata.astype('int32') print(filedata) [[1 2 3 5 6 7] [8 1 4 2 6 4] [9 0 1 7 3 4]]

Сначала мы достали данные из файла data.txt через функцию genfromtxt. В ней нужно указать считываемый файл, а затем разделитель — чтобы NumPy понимал, где начинаются и заканчиваются числа. У нас разделителем будет ,.

Затем нам нужно привести числа к формату int32 с помощью функции astype, передав в неё нужный нам тип.

Булевы выражения. Ещё одна из возможностей NumPy — булевы выражения для элементов массива. Они позволяют узнать, какие элементы отвечают определённым условиям — например, больше ли каждое число массива 50.

Допустим, у нас есть массив a и мы хотим проверить, действительно ли все его элементы больше 5:

a = np.array([[1, 5, 8], [3, 4, 2]]) print(a > 5) [[False False True] [False False False]]

На выходе — массив с «ответом» для каждого элемента: больше ли он числа 5. Если меньше или равно, то стоит False, иначе — True.

С помощью булевых выражений можно составлять и более сложные конструкции — например, создавать новые массивы из элементов, которые отвечают определённым условиям:

a = np.array([[1, 5, 8], [3, 4, 2], [2, 6, 7]]) print(a[a > 3]) [5 8 4 6 7]

Мы получили вектор, состоящий из элементов массива a, которые больше трёх.

Что важно запомнить

• NumPy — это библиотека для эффективной работы с массивами любого размера. Она достигает высокой производительности, потому что написана частично на C и C++ и в ней соблюдается принцип локальности — она хранит все элементы последовательно в одном месте.
• Перед тем как использовать NumPy в коде, его нужно подключить с помощью команды import numpy as np.
• Основа NumPy — массив. Чтобы его создать, нужно использовать функцию array и передать туда список в качестве первого аргумента. Вторым аргументом через dtype можно указать тип для всех элементов — например, int16 или float32. По умолчанию для целых чисел указывается int32, а для десятичных — float64.
• Функция ndim позволяет узнать, сколько измерений у массива; shape — его структуру (сколько столбцов и строк); dtype — какой тип у элементов; size — количество элементов; itemsize — сколько байтов занимает один элемент; nbytes — сколько всего памяти занимает массив.
• К элементам массива можно обращаться с помощью оператора [], где указываются индексы нужного элемента. Важно помнить, что индексация начинается с нуля. А ещё в NumPy можно выбирать сразу целые строки или столбцы с помощью оператора : и его продвинутой версии — начальный_индекс: конечный_индекс: шаг.
• Функции zeros, ones, full, random.rand, random.randint, identity и eye помогают быстро создать массивы любого размера с заполненными элементами.
• Все арифметические операции, которые доступны в Python, применимы и к массивам NumPy. Главное — помнить, что операции проводятся поэлементно. А для сложных операций, таких как вычисление производной, также есть свои функции.
• NumPy-массивы нельзя просто присвоить другой переменной, чтобы скопировать. Для этого существует функция copy. А чтобы поменять структуру данных, можно применить функции reshape, vstack и hstack.
• Ещё в NumPy есть дополнительные функции — например, чтение из файла с помощью ​​genfromtxt и булевы выражения, которые позволяют выбирать элементы из набора данных по заданным условиям.

Читайте также:

• Как установить библиотеку в Python: руководство для новичка
• «Я удивился, когда написал код, а он заработал»: как живёт начинающий Python-разработчик
• Библиотеки в программировании: для чего нужны и какими бывают

NumPy, часть 1: начало работы

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

Установка NumPy

На linux - пакет python3-numpy (или аналогичный для вашей системы), или через pip. Ну или же собирать из исходников https://sourceforge.net/projects/numpy/files/NumPy/.

На Windows на том же сайте есть exe установщики. Или, если возникают проблемы, рекомендую ещё хороший сборник библиотек http://www.lfd.uci.edu/~gohlke/pythonlibs/#numpy.

Начинаем работу

Основным объектом NumPy является однородный многомерный массив (в numpy называется numpy.ndarray). Это многомерный массив элементов (обычно чисел), одного типа.

Наиболее важные атрибуты объектов ndarray:

ndarray.ndim - число измерений (чаще их называют "оси") массива.

ndarray.shape - размеры массива, его форма. Это кортеж натуральных чисел, показывающий длину массива по каждой оси. Для матрицы из n строк и m столбов, shape будет (n,m). Число элементов кортежа shape равно ndim.

ndarray.size - количество элементов массива. Очевидно, равно произведению всех элементов атрибута shape.

ndarray.dtype - объект, описывающий тип элементов массива. Можно определить dtype, используя стандартные типы данных Python. NumPy здесь предоставляет целый букет возможностей, как встроенных, например: bool_, character, int8, int16, int32, int64, float8, float16, float32, float64, complex64, object_, так и возможность определить собственные типы данных, в том числе и составные.

ndarray.itemsize - размер каждого элемента массива в байтах.

ndarray.data - буфер, содержащий фактические элементы массива. Обычно не нужно использовать этот атрибут, так как обращаться к элементам массива проще всего с помощью индексов.

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

В NumPy существует много способов создать массив. Один из наиболее простых - создать массив из обычных списков или кортежей Python, используя функцию numpy.array() (запомните: array - функция, создающая объект типа ndarray):

Функция array() трансформирует вложенные последовательности в многомерные массивы. Тип элементов массива зависит от типа элементов исходной последовательности (но можно и переопределить его в момент создания).

Можно также переопределить тип в момент создания:

Функция array() не единственная функция для создания массивов. Обычно элементы массива вначале неизвестны, а массив, в котором они будут храниться, уже нужен. Поэтому имеется несколько функций для того, чтобы создавать массивы с каким-то исходным содержимым (по умолчанию тип создаваемого массива — float64).

Функция zeros() создает массив из нулей, а функция ones() — массив из единиц. Обе функции принимают кортеж с размерами, и аргумент dtype:

Функция eye() создаёт единичную матрицу (двумерный массив)

Функция empty() создает массив без его заполнения. Исходное содержимое случайно и зависит от состояния памяти на момент создания массива (то есть от того мусора, что в ней хранится):

Для создания последовательностей чисел, в NumPy имеется функция arange(), аналогичная встроенной в Python range(), только вместо списков она возвращает массивы, и принимает не только целые значения:

Вообще, при использовании arange() с аргументами типа float, сложно быть уверенным в том, сколько элементов будет получено (из-за ограничения точности чисел с плавающей запятой). Поэтому, в таких случаях обычно лучше использовать функцию linspace(), которая вместо шага в качестве одного из аргументов принимает число, равное количеству нужных элементов:

fromfunction(): применяет функцию ко всем комбинациям индексов

Печать массивов

Если массив слишком большой, чтобы его печатать, NumPy автоматически скрывает центральную часть массива и выводит только его уголки.

Если вам действительно нужно увидеть весь массив, используйте функцию numpy.set_printoptions:

И вообще, с помощью этой функции можно настроить печать массивов "под себя". Функция numpy.set_printoptions принимает несколько аргументов:

precision : количество отображаемых цифр после запятой (по умолчанию 8).

threshold : количество элементов в массиве, вызывающее обрезание элементов (по умолчанию 1000).

edgeitems : количество элементов в начале и в конце каждой размерности массива (по умолчанию 3).

linewidth : количество символов в строке, после которых осуществляется перенос (по умолчанию 75).

suppress : если True, не печатает маленькие значения в scientific notation (по умолчанию False).

nanstr : строковое представление NaN (по умолчанию 'nan').

infstr : строковое представление inf (по умолчанию 'inf').

formatter : позволяет более тонко управлять печатью массивов. Здесь я его рассматривать не буду, можете почитать здесь (на английском).

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

Подписывайтесь, чтобы не пропустить 🙂

Для вставки кода на Python в комментарий заключайте его в теги