Дата последнего обновления: 2019/4/13

NumPy — это пакет Python. Это означает «Числовой Python». Это библиотека, состоящая из объектов многомерного массива (ndarray) и набора подпрограмм для работы с массивами. Используя NumPy, разработчики могут делать следующее:

• Арифметические и логические операции над массивами.
• Преобразования Фурье и подпрограммы для графических манипуляций.
• Операции, связанные с линейной алгеброй. NumPy имеет встроенные функции для линейной алгебры и генерации случайных чисел.

Импортируйте модуль перед его использованием:import numpy as np

Нажмите на ссылки ниже, чтобы перейти к каждому разделу

Рекомендации по использованию 1 — Атрибуты (тип данных, форма, размеры, элементы, размер элемента, байты, порядок)

Руководство пользователя 2 — Создать (создать из существующих данных, быстро заполнить)

Руководство пользователя 3 - Операции (массивы/множества/биты/строки/статистика/операции линейной алгебры, константы, трансляция)

Руководство пользователя 4. Поиск (индекс, обход, выборка, просмотр)

Руководство пользователя 5 - Изменения (обновление, дополнение, удаление)

Руководство пользователя 6 - Рефакторинг (приведение, изменение формы, сортировка, дедупликация, разделение)

Руководство пользователя 7 - Чтение и запись (Сохранить, прочитать)

Руководство пользователя 8 - Разное (типы матриц, тензорные операции, преобразование Фурье, обработка изображений)

1. Свойства

Назад к содержанию

1. Тип данных

ndarray.dtype

Общие типы данных Numpy

dtype	type	имя типа	инструкция
np.dtype('bool')	np.bool_	логический тип	True or False
np.dtype('int8' | 'i1' | 'b')	np.int8	8-битное целое число (байт)	-2^7 to 2^7-1
np.dtype('int16' | 'i2')	np.int16	16-битное целое число	-2^15 to 2^15-1
np.dtype('int32' | 'i4' | 'int' | 'i')	np.int32	32-битное целое число	-2^31 to 2^31-1
np.dtype('int64' | 'i8')	np.int64	64-битное целое число	-2^63 to 2^63-1
np.dtype('uint8' | 'u1' | 'B')	np.uint8	8-битное целое число без знака	0 to 2^8-1
np.dtype('uint16' | 'u2')	np.uint16	16-битное целое число без знака	0 to 2^16-1
np.dtype('uint32' | 'u4' | 'uint')	np.uint32	32-битное целое число без знака	0 to 2^32-1
np.dtype('uint64' | 'u8')	np.uint64	64-битное целое число без знака	0 to 2^64-1
np.dtype('float16' | 'f2')	np.float16	с плавающей запятой половинной точности	1 бит знака + 5 бит экспоненты + 10 бит мантиссы
np.dtype('float32' | 'f4' | 'f')	np.float32	число с плавающей запятой одинарной точности	1 бит знака + 8 бит экспоненты + 23 бита мантиссы
np.dtype('float64' | 'f8' | 'float' | 'd')	np.float64	число двойной точности с плавающей запятой	1 бит знака + 11 бит экспоненты + 52 бита мантиссы
np.dtype('complex64' | 'c8')	np.complex64	64-битное комплексное число	Двойные 32-битные числа с плавающей запятой (действительная часть + мнимая часть)
np.dtype('complex128' | 'complex' | 'c16')	np.complex128	128-битное комплексное число	Двойные 64-битные числа с плавающей запятой (действительная часть + мнимая часть)
np.dtype('object' | 'O')	object	объект	Может использоваться для хранения ссылочных типов
np.dtype('string_' | 'S' | 'S1' | 'S2' ...)	np.bytes_	строка фиксированной длины	Необходимо указать длину
np.dtype('unicode' | 'U' | 'U1' | 'U2' ...)	np.str_	Строка Unicode фиксированной длины	Необходимо указать длину
np.dtype('datetime64' | 'M')	np.datetime64	дата и время	Можно указать единицу даты

Примечание: один и тот же dtype может быть объявлен несколькими строковыми идентификаторами, см. Разделение нескольких элементов. Базовый тип данных python может быть распознан numpy и преобразован в тип по умолчанию в соответствующей категории,intсоответствоватьnp.int32,floatсоответствоватьnp.float64,complexсоответствоватьnp.complex128.

dtype и преобразование типов

Получить тип dtype:dtype.typeСоздайте dtype по типу:dtype(type)

dtype и type можно сравнивать напрямую

np.dtype('int')==np.int32

порядок байтов dtype

np.dtype('<i8')

Порядок байтов определяется предустановкой "" для типа данных. «» означает обратный порядок байтов (старший байт хранится по наименьшему адресу, т. е. старший байт идет первым). В обычных условиях можно использовать настройки по умолчанию.

2. Количество элементов

ndarray.size

3. Размер подраздела элемента

ndarray.itemsize

В зависимости от типа данных каждые 8 ​​бит составляют 1 байт.

4. Всего байтов

ndarray.nbytes

Рассчитывается по размеру и размеру элемента.

5. Размеры

ndarray.ndim

Каждое измерение ndarray описывается как ось, количество измерений — это количество осей, а количество осей начинается с 0.

6. Форма

ndarray.shape

Тип Tuple, каждый бит соответствует каждой оси, например, длина направления по оси 0 составляет 10 элементов, а длина направления по оси 1 составляет 5 элементов.(10,5).

7. Схема памяти

У Numpy есть два метода хранения данных: один — C-порядок, то есть порядок строк — первый, а другой — Fortran-порядок, то есть порядок столбцов, который по умолчанию соответствует C-порядку, если он не указан явно. Из-за внутреннего механизма оптимизации в большинстве случаев между ними нет очевидной разницы, и, как правило, нет необходимости изменять настройки по умолчанию. Но при использовании таких методов, как итераторы,orderПараметр указывает порядок доступа к элементу, где «C» относится к C-порядку, а «F» относится к F-порядку.

2. Создать

Назад к содержанию

1. Создать из существующих данных

(1).Создать из списка

#一维数组
a1=np.array([1,2])
#二维数组
a2=np.array([[1.,2.],[3.,4.]])
#三维数组
a3=np.array([[[1,2],[3,4]],[[5,6],[7,8]]],dtype='float')
#以此类推

При создании многомерного массива из вложенной структуры последовательности самый внешний слой соответствует первой оси массива и так далее. второй параметрdtypeВы можете явно объявить тип данных массива, который можно передать вdtypeилиtype(примитивный тип данных python или тип данных numpy) или сdtypeСоответствующий строковый идентификатор, если он не объявлен, будет автоматически использовать наиболее подходящий тип данных в соответствии с входящими данными.

(2) Создать из кортежа

a=np.array((1,2))

иlistТот самый,listиtupleВложение такое же.

(3) Создать из словаря (неуместно)

np.array({"x1":1,"x2":2})
Out[138]: array({'x1': 1, 'x2': 2}, dtype=object)

не может быть преобразован должным образом, весьdictОн будет храниться в массиве как объект, и вы можете попробовать использовать библиотеку pandas для работы с ним.

(4) Создан из других подобных массиву структур, таких как тип изображения PIL.

from PIL import Image
image= Image.open("D:\\test.jpg")
a=np.asarray(image)

np.asarrayв большинстве случаев сnp.arrayэквивалентно, разницаnp.asarrayПредотвратит ненужное создание дубликатов, когда источник данных такжеndarrayиdtypeПри отсутствии изменений новый массив не возвращается.

2. Быстрое заполнение

(1) 0/1 заполнение

#填充0
a1=np.zeros((2,2))
#填充1
a2=np.ones((2,2))
#声明类型
a2=np.ones((2,2),dtype='int')

первый параметрshapeЭто форма массива, и ему должно быть присвоено значение; Тип данных по умолчаниюfloat64,доступныйdtypeПараметр указывает тип.

(2) Диагональная матрица

np.eye(3,3,0)
Out[151]: 
array([[ 1.,  0.,  0.],
       [ 0.,  1.,  0.],
       [ 0.,  0.,  1.]])

np.eye(3,3,1)
Out[150]: 
array([[ 0.,  1.,  0.],
       [ 0.,  0.,  1.],
       [ 0.,  0.,  0.]])

первый параметрNЭто длина оси 0, и ей должно быть присвоено значение; второй параметрMЭто длина 1 оси, и это то же самое, что и при отсутствии значения.Nзначение соответствует; первый параметрkЭто смещение по диагонали, значение по умолчанию равно 0, положительные числа смещены вверх, а отрицательные числа смещены вниз. Диагональные матрицы фиксируются как двумерные массивы.

(3) Матрица тождества

np.identity(1)
Out[5]: array([[ 1.]])

np.identity(2)
Out[6]: 
array([[ 1.,  0.],
       [ 0.,  1.]])

первый параметрnДля одинаковой длины оси ей должно быть присвоено значение; Матрица идентичности фиксируется в виде двумерного массива.

(4) Введите указанное значение

a=np.full((2,2),'a')

первый параметрshapeЭто форма массива, и ему должно быть присвоено значение; второй параметрfill_valueЧтобы заполнить значение, значение должно быть присвоено.

(5) Заполнение нулевого значения

a=np.empty((2,2))

первый параметрshapeДля формы массива должно быть присвоено значение. Создает массив без инициализации его значений.

(6) Создать со ссылкой на существующую форму массива

a=np.ones((2,2))
a2=np.zeros_like(a)
a3=np.full_like(a,'a')

(7) Арифметическая последовательность

#方法一
a1=np.arange(0,100,1)
#方法二
a2=np.linspace(0,99,100)

Способ первый, аналогичныйrangeфункция, по умолчаниюintтип, Три параметра: начало, конец, размер шага (интервал раньше закрывается, а затем открывается); Метод 2, линейное пространство, по умолчаниюfloatтип, иrangeНе то же самое, конечное значение включено в интервал по умолчанию, И третий параметр — это не размер шага, а количество элементов.

(8) Случайное число

случайное число с плавающей запятой

#[0,1]浮点随机数
a1=np.random.rand(5,5)
#标准正太分布随机数
a2=np.random.randn(5,5)

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

Целое случайное число

#产生指定范围的整数随机数
a=np.random.randint(0,10,(4,3))

первый параметрlowУказывает нижний предел интервала и должен быть присвоен значение; второй параметрhighУказывает верхнюю границу интервала, если она не задана, будетlowкак верхний предел и 0 как нижний предел; третий параметрsizeУказывает форму массива, и функция возвращает скалярное значение, если ей не присвоено значение.

Нормально распределенные случайные числа

a=np.random.normal(100,10,(4,3))

первый параметрlocпредставляет собой среднее значение распределения; второй параметрscaleпредставляет стандартное отклонение распределения; третий параметрsizeУказывает форму массива, и функция возвращает скалярное значение, если ей не присвоено значение.

Равномерно распределенные случайные числа

a=np.random.uniform(0,10,(4,3))

первый параметрlowУказывает нижний предел интервала и должен быть присвоен значение; второй параметрhighУказывает верхнюю границу интервала, если она не задана, будетlowкак верхний предел и 0 как нижний предел; третий параметрsizeУказывает форму массива, и функция возвращает скалярное значение, если ей не присвоено значение.

Случайные числа с распределением Пуассона

a=np.random.poisson(1.0,(4,3))

первый параметрlam– коэффициент лямбда; второй параметрsizeУказывает форму массива, и функция возвращает скалярное значение, если ей не присвоено значение.

(9) Данные сетки

X,Y=np.mgrid[1:2:2j,1:3:3j]

X
Out[27]: 
array([[ 1.,  1.,  1.],
       [ 2.,  2.,  2.]])

Y
Out[28]: 
array([[ 1.,  2.,  3.],
       [ 1.,  2.,  3.]])

x=np.array([1,2,3])
y=np.array([1,2])
X,Y=np.meshgrid(x,y)

X
Out[36]: 
array([[1, 2, 3],
       [1, 2, 3]])

Y
Out[37]: 
array([[1, 1, 1],
       [2, 2, 2]])

np.mgridДанные сетки получаются напрямую путем выбора индекса,jУказывает количество шагов и включает в себя значение остановки, удалитьjЭтот элемент представляет размер шага и не содержит стоп-значения, первый бит индекса объявляетXРост в направлении оси 0, второй бит индекса объявляетYрост в направлении оси 1, тоXиYШироковещательная передача до того же размера и т. д., когда индексных бит больше.np.meshgridПостроить данные сетки на основе существующих данных, следуйтеmgridОтличие, первый параметр представляет собой вектор, представляющий прирост в направлении второй оси, второй параметр соответствует первой оси, третий параметр соответствует третьей оси, четвертый параметр соответствует четвертой оси, а затем И так на. Данные с координатной сеткой часто используются для построения графиков.

(10).

a1=np.zeros((2,2))
a2=np.copy(a1)

3. Операция

Назад к содержанию

1. Операторы

Numpy перегружает операторы в python, которые могут реализовывать операции с массивами с помощью того же использования.

Операции с массивами и скалярными значениями

a=np.arange(0, 4)

a
Out[192]: array([0, 1, 2, 3])

a+1
Out[193]: array([1, 2, 3, 4])

a*2
Out[194]: array([0, 2, 4, 6])

Массивы и операции с массивами

a1=np.arange(0, 4);a2=np.arange(4, 8)

a1,a2
Out[200]: (array([0, 1, 2, 3]), array([4, 5, 6, 7]))

a1+a2
Out[201]: array([ 4,  6,  8, 10])

a2**a1
Out[202]: array([  1,   5,  36, 343], dtype=int32)

2. Скалярнозначные функции

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

унарная функция

функция	эффект	инструкция
np.abs	абсолютная величина	Вычислить абсолютное значение float/integer/complex
np.fabs	абсолютная величина	Вычислить абсолютное значение числа с плавающей запятой/целого числа быстрее (?)
np.sqrt	квадратный корень	x^0.5
np.square	квадратный	x^2
np.log	Натуральный логарифм	-
np.log2	логарифм по основанию 2	-
np.log10	логарифм по основанию 10
np.log1p	Натуральный логарифм x+1	Используется для обеспечения достоверности расчета, когда значение слишком мало.
np.ceil	Округлен	-
np.floor	округлить вниз	-
np.rint	округление	-
np.around	округляет указанное количество цифр	второй параметрdecimalsдля округления цифр
np.exp	натуральный индекс	e^x
np.sign	символическое значение	Три значения: 1 (положительное), 0 (0), -1 (отрицательное)
np.modf	Разделить дробные и целые части	возвращает как два отдельных массива
np.isnan	Определите, является ли это NaN	Возвращает массив логического типа
np.isfinite	определить, является ли он плохим	Значение не inf, не NaN; возвращает логический массив
np.isinf	определить, является ли он плохим	Значение — inf или -inf; возвращает логический массив
np.sin,np.sinh	синус, гиперболический синус	-
np.cos,np.cosh	косинус, гиперболический косинус	-
np.tan,np.tanh	тангенс, гиперболический тангенс	-
np.arcsin,np.arcsinh	арксинус, обратный гиперболический синус	-
np.arccos,np.arccosh	Арккосинус, аркгиперболический косинус	-
np.arctan,np.arctanh	арктангенс, арктангенс гиперболический	-
np.logical_not	логическое не	-

Многофункциональный

функция	эффект	инструкция
np.add(a1,a2)	добавить	a1+a2
np.sub(a1,a2)	вычесть	a1-a2
np.multiply(a1,a2)	умножить	a1*a2
np.divide(a1,a2)	разделять	a1/a2
np.power(a1,a2)	Возведение в степень	a1**a2
np.floor_divide(a1,a2)	Делимый	a1//a2
np.mod(a1,a2)	по модулю	a1%a2
np.maxinum(a1,a2,a3)	максимальное значение	Поэлементное сравнение, возвращающее массив всех максимальных значений
np.fmax(a1,a2,a3)	Максимальное значение (без учета NaN)	Поэлементное сравнение, возвращающее массив всех максимальных значений
np.mininum(a1,a2,a3)	минимум	Поэлементное сравнение, возвращающее массив всех минимальных значений
np.fmin(a1,a2,a3)	Минимальное значение (без учета NaN)	Поэлементное сравнение, возвращающее массив всех минимальных значений
np.copysign(a1,a2)	копировать символ	Скопируйте символ a2 в a1
np.greater(a1,a2)	больше, чем	a1>a2
np.greater_equal(a1,a2)	больше или равно	a1>=a2
np.less(a1,a2)	меньше, чем	a1<a2
np.less_equal(a1,a2)	меньше или равно	a1<=a2
np.equal(a1,a2)	равный	a1==a2
np.not_equal(a1,a2)	не равно	a1!=a2
np.logical_and(a1,a2)	логический и	-
np.logical_or(a1,a2)	логический или	-
np.logical_xor(a1,a2)	логическое исключающее ИЛИ	-

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

Агрегатные функции уменьшают размерность массива, обычно указывая направление оси.axisАгрегировать, результирующий массив уменьшается на одно измерение, агрегируется по всем направлениям осей, если направление не указано, и результатом является скалярное значение. Большинство методов объектов ndarray можно вызывать либо статически, либо напрямую.

функция	эффект	инструкция
np.sum	сумма	-
np.mean	Средняя стоимость	-
np.max	максимальное значение	-
np.min	минимум	-
np.prod	Умножить	-
np.any	по крайней мере один правда	вернуть Истина/Ложь
np.all	все правда	вернуть Истина/Ложь

np.maxиnp.minсоответствующийnp.argmaxиnp.argminМетод используется для возврата индекса, подробности см. в главе «Поиск».

(ниже приведены некоторые примеры)

np.sum

a=np.array([[1,3],[4,2]])

a
Out[314]: 
array([[1, 3],
       [4, 2]])

a.sum()
Out[315]: 10

a.sum(axis=0)
Out[316]: array([5, 5])

a.sum(axis=1)
Out[317]: array([4, 6])

np.all

a=np.array([[True,False],[True,True]])

a
Out[323]: 
array([[ True, False],
       [ True,  True]], dtype=bool)

a.all()
Out[324]: False

a.all(axis=0)
Out[325]: array([ True, False], dtype=bool)

4. Составные статистические функции.

функция	эффект	инструкция
np.cumsum	накапливать	-
np.cumprod	умножить	-
np.std	среднеквадратичное отклонение	((a-a.mean())**2).sum()/a.size
np.var	дисперсия	np.sqrt(((a-a.mean())**2).sum()/a.size)
np.average	средневзвешенное	третий параметрweightsэто вес; ndarray не имеет соответствующего метода
np.bincount	количество бинов	Поддерживаются только целые числа, интервал биннинга автоматически генерируется в соответствии с максимальным и минимальным значениями, а интервал равен 1.
np.histogram	Статистика гистограммы	второй параметрbinsУкажите метод биннинга, чемnp.bincountболее гибкий

(ниже приведены некоторые примеры)

np.cumsum

a=np.array([[1,3],[4,2]])

a.cumsum()
Out[319]: array([ 1,  4,  8, 10], dtype=int32)

a.cumsum(axis=0)
Out[320]: 
array([[1, 3],
       [5, 5]], dtype=int32)

np.average

a=np.array([[1,3],[4,2]])
w=np.array([[0.4,0.1],[0.2,0.3]])

np.average(a)
Out[333]: 2.5

np.average(a,weights=w)
Out[334]: 2.1000000000000001

5. Строковые функции

функция	эффект	инструкция
np.char.add	Добавление строки	Выполнить добавление строки поэлементно
np.char.multiply	Повтор строки	второй параметрiна количество повторений
np.char.center	центральная струна	второй параметрwidthдлина, третий параметрfillcharзаполнить символ
np.char.capitalize	заглавные буквы	-
np.char.title	Сделать заглавной первую букву слова	-
np.char.lower	Преобразовать в нижний регистр	-
np.char.upper	преобразовать в верхний регистр	-
np.char.split	Разделение строки	второй параметрsepявляется разделителем, возвращает массив списка
np.char.splitlines	разделение строк	Разделить по новой строке, вернуть массив списка
np.char.strip	Удалить указанные символы из головы и хвоста	второй параметрcharsперсонаж, который нужно удалить
np.char.join	Объединить символы с указанным разделителем	первый параметрsepкак разделитель
np.char.replace	заменить строку	второй параметрoldстарая строка, третий параметрnewэто новая строка
np.char.decode	расшифровка	вызовите str.decode для каждого элемента
np.char.encode	кодирование	вызовите str.encode для каждого элемента

(ниже приведены некоторые примеры)

np.char.add

a1=np.array(['a','b']);a2=np.array(['c','d'])

np.char.add(a1,a2)
Out[302]: 
array(['ac', 'bd'],
      dtype='<U2')

np.char.multiply

a=np.array(['a','b'])

np.char.multiply(a,3)
Out[304]: 
array(['aaa', 'bbb'],
      dtype='<U3')

np.char.center

a=np.array(['a','b'])

np.char.center(a,10,'*')
Out[306]: 
array(['****a*****', '****b*****'],
      dtype='<U10')

np.char.split

a=np.array(['a,b','c,d'])

np.char.split(a,',')
Out[308]: array([list(['a', 'b']), list(['c', 'd'])], dtype=object)

np.char.join

a=np.array(['ab','cd'])

np.char.join(',',a)
Out[310]: 
array(['a,b', 'c,d'],
      dtype='<U3')

a=np.array(['a,b','c,d'])

np.char.join(',',np.char.split(a,','))
Out[312]: 
array(['a,b', 'c,d'],
      dtype='<U3')

Обратите внимание, что этот метод не может реализовать статистические вычисления для многомерных массивов. Когда элемент массива является строкой, каждый элемент в строке объединяется; когда элемент массива представляет собой последовательность строк, строки в последовательности объединяются. Это операция, обратная расщеплению.

6. Операции линейной алгебры

функция	эффект	инструкция
np.dot(a1,a2)	скалярное произведение	В многомерном массиве последняя ось a1 и предпоследняя ось a2 используются как размерность вектора, который можно рассматривать как стопку векторов
np.vdot(a1,a2)	вектор скалярное произведение	Многомерные массивы будут расширены и рассчитаны
np.inner(a1,a2)	вектор внутреннего продукта	Многомерные массивы будут иметь последнюю ось как размерность вектора
np.matmul(a1,a2)	матричное произведение	При многомерном массиве последние две оси будут использоваться как размерности матрицы, которую можно рассматривать как массив матриц.
np.linalg.det(a)	определитель	Определитель описывает влияние линейного преобразования, представленного матрицей, на «объем».
np.linalg.solve(A,b)	Решите систему линейных уравнений	Решите систему линейных уравнений Ax = b, где A — матрица коэффициентов (квадратная матрица), а b — постоянная матрица
np.linalg.lstsq(A,b)	Решите систему линейных уравнений	Найдите решение системы линейных уравнений Ax = b методом наименьших квадратов, где A — матрица коэффициентов, а b — матрица констант.
np.linalg.inv(a)	Обратная матрица	AB=BA=E, E — единичная матрица, тогда B — обратная матрица A
np.linalg.pinv(a)	Обобщенная обратная матрица	Можно вводить неквадратные матрицы
np.linalg.eig(a)	Собственные значения и собственные векторы	вернуть два массива
np.linalg.qr(a)	Ортогональное разложение	-
np.linalg.svd(a)	сингулярное разложение	-
ndarray.T	Транспонировать	Транспонирование одномерных массивов недопустимо

(ниже приведены некоторые примеры)

np.dot, np.vdot, np.inner, np.matmul

a=np.array([1,2]);b=np.array([[3,4],[5,6]])

np.dot(a,a), np.vdot(a,a), np.inner(a,a), np.matmul(a,a)
Out[340]: (5, 5, 5, 5)

np.dot(a,b), np.dot(b,a)
Out[341]: (array([13, 16]), array([11, 17]))

np.vdot(a,b)
Traceback (most recent call last):

  File "<ipython-input-358-f2388a21d848>", line 1, in <module>
    np.vdot(a,b)

ValueError: cannot reshape array of size 4 into shape (2,)

np.inner(a,b), np.inner(b,a)
Out[343]: (array([11, 17]), array([11, 17]))

np.matmul(a,b), np.matmul(b,a)
Out[344]: (array([13, 16]), array([11, 17]))

np.dot(b,b)
Out[345]: 
array([[29, 36],
       [45, 56]])

np.vdot(b,b)
Out[346]: 86

np.inner(b,b)
Out[347]: 
array([[25, 39],
       [39, 61]])

np.matmul(b,b)
Out[348]: 
array([[29, 36],
       [45, 56]])

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

dotМассив рассматривается как набор векторов, последняя ось первого массива и предпоследняя ось второго массива используются в качестве оси вектора, и каждый вектор извлекается для попарного сопоставления для операции скалярного произведения, поэтому эти два оси должны быть одинаковой длины. Например,a.shape=(2,3,4),b.shape=(5,4,6),ноnp.dot(a,b).shape=(2,3,5,6). В двумерном случае реализованным вычислением является умножение матриц.

vdotПравило относительно простое, массив будет развернут в вектор, а затем будет вычислено скалярное произведение.sizeПоследовательный.

innerиdotАналогично, но правила проще Оба массива используют последнюю ось как ось вектора, то есть длина последней оси должна быть одинаковой. Например,a.shape=(2,3,4),b.shape=(5,6,4),ноnp.dot(a,b).shape=(2,3,5,6).

matmulвычисляется для матриц, иdotТочно так же он представляет матричное умножение в двумерном случае.Более двух измерений рассматриваются как массивы, элементы которых являются матрицами.Два массива, участвующие в операции, принимают две последние оси в качестве осей матрицы и выполняют умножение матрицы поэлементно и трансляция на другие оси. Например,a.shape=(1,3,4),b.shape=(5,4,6),ноnp.dot(a,b).shape=(5,3,6),еслиa.shape=(2,3,4), вычисление сообщит об ошибке, поскольку правила широковещательной рассылки не соблюдены.

7. Установите операции

функция	эффект	инструкция
np.intersect1d(x, y)	перекресток	xиyобщие элементы
np.union1d(x, y)	союз	xиyвсе элементы
np.setdiff1d(x, y)	установить разницу	xсуществует в,yэлементы, которых нет в
np.setxor1d(x, y)	установить исключающее ИЛИ	xиyэксклюзивный элемент

Вышеупомянутый метод работает для одномерных массивов.

(ниже приведены некоторые примеры)

x=np.array([1,3,4])
y=np.array([2,3,5])

np.intersect1d(x,y)
Out[812]: array([3])

np.union1d(x,y)
Out[813]: array([1, 2, 3, 4, 5])

np.setdiff1d(x,y)
Out[814]: array([1, 4])

np.setxor1d(x,y)
Out[815]: array([1, 2, 4, 5])

8. Битовые операции

функция	эффект	инструкция
np.invert	побитовое отрицание	равно~оператор
np.bitwise_and	побитовое И	равно&оператор
np.bitwise_or	побитовое ИЛИ	равно\|оператор
np.bitwise_xor	Побитовое исключающее ИЛИ	равно^оператор
np.left_shift	битовый сдвиг влево	равно<<оператор
np.right_shift	битовый сдвиг вправо	равно>>оператор

(ниже приведены некоторые примеры)

a=np.array([2,3,5,8,13])
b=np.array([3,4,7,11,18])

np.invert(a)
Out[860]: array([ -3,  -4,  -6,  -9, -14], dtype=int32)

bin(a[4]),bin(~a[4])
Out[862]: ('0b1101', '-0b1110')

np.bitwise_and(a,b)
Out[863]: array([2, 0, 5, 8, 0], dtype=int32)

bin(a[3]),bin(b[3]),bin(a[3]&b[3])
Out[865]: ('0b1000', '0b1011', '0b1000')

np.invertДля целых чисел со знаком возьмите дополнение до единицы соответствующего двоичного числа, затем +1. В двоичной форме старший бит равен 0 для положительных чисел, а старший бит равен 1 для отрицательных чисел.

9. Трансляция

Когда numpy выполняет вычисления между массивами разной формы, он будет автоматически транслироваться по оси с недостаточной длиной и длиной 1. Когда размеры несовместимы, он будет заполнен вперед, что требует, чтобы длина следующей оси была одинаковой или чтобы одна из длин была равна 1, то есть длины осей сравниваются сзади наперед, например формы (a, b, c) и (b), c) могут быть рассчитаны, (a,b,c) и (b,1) могут быть рассчитаны, (a,b,c) и (a,b,1) ) вычисляется, (a,b,c) и (a),b) невычислимы, (a,b,c) и (a,c,b) невычислимы.

a1=np.zeros((2,3,4))
a2=np.random.randint(0,10,(3,4))
a3=np.random.randint(0,10,(2,3))
a4=np.random.randint(0,10,(2,3,1))

a1+a2
Out[418]: 
array([[[ 3.,  6.,  0.,  6.],
        [ 9.,  6.,  3.,  4.],
        [ 2.,  3.,  1.,  5.]],

       [[ 3.,  6.,  0.,  6.],
        [ 9.,  6.,  3.,  4.],
        [ 2.,  3.,  1.,  5.]]])

a1+a3
Traceback (most recent call last):

  File "<ipython-input-419-d778f9717621>", line 1, in <module>
    a1+a3

ValueError: operands could not be broadcast together with shapes (2,3,4) (2,3) 

a1+a4
Out[420]: 
array([[[ 0.,  0.,  0.,  0.],
        [ 9.,  9.,  9.,  9.],
        [ 1.,  1.,  1.,  1.]],

       [[ 4.,  4.,  4.,  4.],
        [ 0.,  0.,  0.,  0.],
        [ 2.,  2.,  2.,  2.]]])

10. Константы

Имя свойства	постоянное имя	ценность
np.e	натуральный индекс	2.718281828459045
np.pi	ЧИСЛО ПИ	3.141592653589793
np.euler_gamma	постоянная Эйлера	0.5772156649015329
np.inf	гигантский	-
np.nan	нечисловой	-

4. Найдите

Назад к содержанию

1. Индекс

пройти черезndarray[index1,index2...]Укажите индекс в виде .

(1) Позиционирующие элементы

a=np.array([[1,2],[3,4]])

a[1,1]
Out[453]: 4

(2) Срез данных

a[:,1]
Out[454]: array([2, 4])

a[0:1,:]
Out[455]: array([[1, 2]])

пройти черезlow:highФорма ограничивает диапазон индекса, интервал закрыт спереди и открыт сзади, а верхний и нижний пределы оставлены пустыми, что указывает на отсутствие ограничений. Скалярный индекс приводит к исчезновению соответствующего измерения, а индекс диапазона — нет.

(3) Обратный индекс

a[-1,:-1]
Out[457]: array([3])

-nУказывает n-й последний.

(4) Выберите пошагово

a[0:2:2]
Out[458]: array([[1, 2]])

пройти черезlow:high:stepФорма определяет диапазон индекса и размер шага.

(5) Инверсия последовательности

a[::-1]
Out[459]: 
array([[3, 4],
       [1, 2]])

равноa[-1:-len(a)-1:-1].

(6) Булев индекс

a>2
Out[460]: 
array([[False, False],
       [ True,  True]], dtype=bool)

(a>2)&(a<4)
Out[461]: 
array([[False, False],
       [ True, False]], dtype=bool)

a[(a>2)&(a<4)]
Out[462]: array([3])

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

(7) Индекс массива

a[[0,1],[1]]
Out[463]: array([2, 4])

a[[0,1],[1,0]]
Out[464]: array([2, 3])

Индекс, который будет выбран на соответствующей оси, передается в виде массива.Когда индекс массива передается на нескольких осях, индекс будет соответствовать один к одному. Список поддержки, кортеж, ndarray, поддержка обратного индекса.

(8) Подробный пример

Получить первый столбец строки, где второй столбец больше 2

a[a[:,1]>2,0]
Out[465]: array([3])

Получить верхний угловой элемент двумерного массива

a[[0,-1]][:,[0,-1]]
Out[466]: 
array([[1, 2],
       [3, 4]])

a[[0,0,-1,-1],[0,-1,0,-1]].reshape((2,2))
Out[467]: 
array([[1, 2],
       [3, 4]])

используется здесьreshapeМетод рефакторинга будет рассмотрен в главе о рефакторинге.

(9) Получить позицию, указанную логическим индексом

a>2
Out[473]: 
array([[False, False],
       [ True,  True]], dtype=bool)

np.where(a>2)
Out[474]: (array([1, 1], dtype=int64), array([0, 1], dtype=int64))

a[np.where(a>2)]
Out[476]: array([3, 4])

np.where(a>2,a,-a)
Out[477]: 
array([[-1, -2],
       [ 3,  4]])

Когда вводится только массив, он вызывается внутриnonzeroметод, возвращаемое значениеtuple, содержащий последовательность значений индекса по каждой оси. через второй параметрxи третий параметрy, вы можете выполнять различные вычисления для элементов в зависимости от того, выполняются ли условия, и возвращать массив той же формы.

(10) Поиск конкретного значения

Укажите последовательность значений

a=np.arange(5)

np.isin(a,[3,4])
Out[656]: array([False, False, False,  True,  True], dtype=bool)

второй параметрtest_elementsВозвращает логический индекс для указанной последовательности значений.

поиск по значению

a=np.array([1,3,5,7,9])

np.searchsorted(a,[3,6])
Out[684]: array([1, 3], dtype=int64)

первый параметрaЭто одномерный массив в порядке возрастания, невозрастающий порядок можно указать четвертым параметромsorter=np.argsort(a), второй параметрvвставлять по мере необходимостиaЗначение или последовательность значений, третий аргументsideдля суда,'left'выражатьa[i-1] < v <= a[i],'right'выражатьa[i-1] <= v < a[i]. Этот метод будет искать каждый элемент v для соответствующей позиции вставки в возрастающем массиве a один за другим, возвращая индекс массива.

нулевой

a=np.array([np.nan,1,2,3])

np.isnan(a)
Out[662]: array([ True, False, False, False], dtype=bool)

Возвращает логический индекс.

(11) Метод возврата индекса

функция	эффект	инструкция
np.argsort	вернуть отсортированный индекс	-
np.argmax	Возвращает индекс максимального значения	-
np.argmin	Возвращает индекс минимального значения	-
np.argpartition	Возвращает индекс раздела	второй параметрkthЗадает индекс элемента, который будет использоваться для разделения
np.argwhere	Возвращает индекс значения, соответствующего условию	иnp.whereАналогично, но форма возвращаемого значения менее пригодна для индексации
np.where	Возвращает индекс значения, соответствующего условию	-
np.isin	Возвращает логический индекс, определяющий, находится ли элемент в указанном списке.	второй параметрtest_elementsдля указанной последовательности значений
np.isnan	Возвращает логический индекс, чтобы определить, является ли элемент nan	-
np.searchsorted	Возвращает позицию вставки значения, которое должно быть вставлено в восходящей последовательности	первый параметрa— восходящий одномерный массив, второй параметрvзначение для вставки
np.digitize	Возвращает сгруппированный индекс	второй параметрbinsУкажите метод биннинга

2. Траверс

(1) Обход структуры последовательности

a=np.array([[1,2],[3,4]])

for buf1 in a:
    for buf2 in buf1:
        print(buf2)

(2) Обход индекса

for i in range(a.shape[0]):
    for j in range(a.shape[1]):
        print(a[i,j])

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

(3) Быстрый обход итератора

for item in np.nditer(a):
    print(item)

Порядок выбора элементов по умолчанию соответствует структуре памяти массива, а не стандартному порядку C или Fortran. Это разработано для повышения эффективности использования, отражая то, что по умолчанию требуется доступ только к каждому элементу, независимо от его конкретного порядка. доступныйorderпараметры для указания определенного порядка доступа к массиву.

(4) Обход тайлового итератора

for item in a.flat:
    print(item)

Преобразует массив в одномерный итератор.

3. Отбор проб

(1) Отбор проб без замены

a=np.array([[1,2],[3,4]])
idx=np.random.choice(np.arange(a.shape[0]),size=1,replace=False)

a[idx]
Out[508]: array([[3, 4]])

(2).Отбор проб с заменой

idx=np.random.randint(0,a.shape[0],size=3)

a[idx]
Out[512]: 
array([[1, 2],
       [3, 4],
       [1, 2]])

также можно использоватьnp.random.choice(np.arange(a.shape[0]),size=3)Сгенерировать индекс. Все вышеперечисленное представляет собой выборку в одном направлении оси.Если вы хотите выполнить выборку в нескольких направлениях осей, поскольку структура массива неизбежно будет разрушена после выборки, рекомендуется сначала расширить ось, используемую для выборки, например, с помощьюreshapeметод, см. пример ниже, наreshapeОписание метода находится в главе Рефакторинг.

(3) Выборка направления по нескольким осям

a=np.array([[[1,2],[3,4]],[[5,6],[7,8]]])
a2=a.reshape((2,4))
idx=np.random.randint(0,a2.shape[0],size=2)

a2[:,idx]
Out[527]: 
array([[1, 2],
       [5, 6]])

4. Просмотр

После индексной нарезки массива обычно возвращается представление исходного массива, и данные не будут скопированы полностью, поэтому операция обновления в этом случае затронет исходный массив и все представления. доступныйndarray.view()метод для получения полного представления, эквивалентныйndarray[:,:,...]. Если вы хотите преобразовать представление в копию, вы можете использоватьndarray.copy()метод.

a=np.array([[1,2],[3,4]])
a2=a[1,:]

a2
Out[544]: array([3, 4])

a2[:]=0

a
Out[546]: 
array([[1, 2],
       [0, 0]])

В. Изменения

Назад к содержанию

1. Обновить

(1) Обновить весь массив

a=np.array([[1,2],[3,4]])

a=a+1

a
Out[557]: 
array([[2, 3],
       [4, 5]])

a[:,:]=a-1

a
Out[559]: 
array([[1, 2],
       [3, 4]])

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

(2) Обновить указанное местоположение

a[a>2]+=1

a
Out[570]: 
array([[1, 2],
       [4, 5]])

a[a>2]=a[a>2]+1

a
Out[572]: 
array([[1, 2],
       [5, 6]])

a[0,:]=0

a
Out[574]: 
array([[0, 0],
       [5, 6]])

a[a>2]=[3,4]

a
Out[576]: 
array([[0, 0],
       [3, 4]])

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

(3) Заполнение фиксированного значения

a.fill(1)

a
Out[10]: 
array([[1, 1],
       [1, 1]])

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

2. Усиление

(1).Вставить

a=np.array([[1,2],[3,4]])

np.insert(a,1,[5,6],axis=0)
Out[578]: 
array([[1, 2],
       [5, 6],
       [3, 4]])

второй параметрobjиндекс позиции вставки, третий параметрvaluesвставляемое значение, которое должно соответствовать форме среза в указанном направлении оси или соответствовать правилам вещания, четвертый параметрaxisявляется заданной осью. Не влияет на исходный массив, возвращает копию.

(2).Дополнительно

np.append(a,[[5,6]],axis=0)
Out[578]: 
array([[1, 2],
       [3, 4],
       [5, 6]])

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

(3).

np.c_[a,a]
Out[589]: 
array([[1, 2, 1, 2],
       [3, 4, 3, 4]])

np.column_stack((a,a))
Out[590]: 
array([[1, 2, 1, 2],
       [3, 4, 3, 4]])

np.concatenate((a,a),axis=1)
Out[591]: 
array([[1, 2, 1, 2],
       [3, 4, 3, 4]])

np.r_[a,a]
Out[592]: 
array([[1, 2],
       [3, 4],
       [1, 2],
       [3, 4]])

np.row_stack((a,a))
Out[593]: 
array([[1, 2],
       [3, 4],
       [1, 2],
       [3, 4]])

np.concatenate((a,a),axis=0)
Out[594]: 
array([[1, 2],
       [3, 4],
       [1, 2],
       [3, 4]])

np.stack((a,a),axis=0)
Out[595]: 
array([[[1, 2],
        [3, 4]],

       [[1, 2],
        [3, 4]]])

np.c_иnp.column_stackсостоит в том, чтобы складывать вдоль оси 1, другие длины осей должны быть одинаковыми или соответствовать правилам вещания, что эквивалентноnp.concatenate(axis=1).np.r_иnp.row_stackсостоит в том, чтобы складывать вдоль оси 0, другие длины осей должны быть одинаковыми или соответствовать правилам вещания, что эквивалентноnp.concatenate(axis=0).np.stackдолжен складываться вдоль новой оси, все длины осей должны быть одинаковыми или удовлетворять правилам вещания.

(4).Повторить

a.repeat(3,axis=1)
Out[93]: 
array([[1, 1, 1, 2, 2, 2],
       [3, 3, 3, 4, 4, 4]])

a.reshape((2,2,1)).repeat(3,axis=2)
Out[96]: 
array([[[1, 1, 1],
        [2, 2, 2]],

       [[3, 3, 3],
        [4, 4, 4]]])

a.repeat(3).reshape((2,2,3))
Out[98]: 
array([[[1, 1, 1],
        [2, 2, 2]],

       [[3, 3, 3],
        [4, 4, 4]]])

np.tile(a,2)
Out[99]: 
array([[1, 2, 1, 2],
       [3, 4, 3, 4]])

np.tile(a,[2,2])
Out[100]: 
array([[1, 2, 1, 2],
       [3, 4, 3, 4],
       [1, 2, 1, 2],
       [3, 4, 3, 4]])

np.tile(a.ravel(),2)
Out[101]: array([1, 2, 3, 4, 1, 2, 3, 4])

repeatМетод повторяет элементы в массиве, что можно сделать с помощьюaxisПараметр указывает направление оси.По умолчанию массив будет расширяться и повторяться в уникальном направлении оси. Может быть сопоставленndarray.reshapeДублируйте элемент на новой оси.tileМетод повторяет массив, обратите внимание, что повторяется весь массив, а не один элемент, и одинаковые элементы в результате не обязательно находятся рядом друг с другом.

3. Удалить

(1) Индексная фильтрация

a[~(a[0]==1),:]
Out[616]: array([[3, 4]])

Отфильтруйте по индексу, чтобы получить массив с удаленным указанным содержимым.

(2) Метод удаления

np.delete(a,[0,1],axis=0)
Out[617]: array([], shape=(0, 2), dtype=int32)

Получить массив с удаленным содержимым указанной позиции индекса с помощью соответствующего метода. второй параметрobjпозиция индекса, третий параметрaxisдля указанной оси.

6. Рефакторинг

Назад к содержанию

1. Преобразование типов

a=np.array([[1,2],[3,4]])

a.dtype
Out[620]: dtype('int32')

a=a.astype('float64')

a.dtype
Out[622]: dtype('float64')

a=np.int32(a)

a.dtype
Out[624]: dtype('int32')

использоватьndarray.astypeМетод или метод с тем же именем типа данных может преобразовать тип.Чтобы узнать, какой тип данных поддерживает numpy, см. главу об атрибутах. Возвращает новый массив после преобразования типа.

2. Ремоделирование

(1) Изменить форму

a=np.array([[1,2],[3,4]])

a.reshape((1,4))
Out[626]: array([[1, 2, 3, 4]])

a.reshape((-1,4))
Out[627]: array([[1, 2, 3, 4]])

Объявите новую фигуру с аргументом типа tuple. Позволяет новую ось размером -1, что означает автоматический расчет. Изменить количество элементов до и послеsizeНужно быть последовательным. Расположение элементов на оси должно складываться от последней оси к предыдущей оси, как показано на рисунке ниже.orderПараметр указывает другой метод упорядочения. Взаимное расположение осей не меняется, поэтому может потребоваться объединение некоторых сложных деформаций.transposeилиswapaxesИспользуется этот тип метода переключения осей.

(2).Плитка

a.ravel()
Out[640]: array([1, 2, 3, 4])

a.flatten()
Out[641]: array([1, 2, 3, 4])

Свести массив в вектор, эквивалентный reshape((-1,)), доступный черезorderПараметр указывает другой метод упорядочения.

(3).Транспонировать

a.T
Out[643]: 
array([[1, 3],
       [2, 4]])

Когда массив одномерный, транспонирование недопустимо. Когда массив двумерный, это транспонирование матрицы. Когда массив более чем двумерный, первая и последняя оси меняются местами.

(4) Обмен осями

a.swapaxes(0,1)
Out[646]: 
array([[1, 3],
       [2, 4]])

a.transpose([1,0])
Out[647]: 
array([[1, 3],
       [2, 4]])

swapaxesТолько две оси могут быть указаны для перестановки одновременно,transposeВсе оси могут быть переупорядочены.

3. Сортировать

(1) Прямая сортировка

a=np.array([[2,3],[1,4]])

np.sort(a,axis=None)
Out[735]: array([1, 2, 3, 4])

a.sort(axis=0)

a
Out[737]: 
array([[1, 3],
       [2, 4]])

ndarray.sortбудет отсортирован непосредственно по исходному массиву, который можно передать через первый параметрaxisУкажите ось сортировки, и каждый вектор вдоль оси будет отсортирован отдельно, по умолчанию-1, указание оси, отличной от последней оси, создает временную копию данных при сортировке, поэтому сортировка по последней оси выполняется быстрее. Эквивалентный методnp.sort, который возвращает отсортированную копию, а также может указыватьaxis=None, массив будет расширен и переупорядочен. Когда размеры массива имеют реальное значение, прямая сортировка нарушит структуру данных и даст неожиданные результаты, в этом случае требуется косвенная сортировка.

(2) Косвенная сортировка

a=np.array([[2,3,5],[1,1,4],[1,2,3]])

a
Out[741]: 
array([[2, 3, 5],
       [1, 1, 4],
       [1, 2, 3]])

idx1=np.argsort(a[:,0])

a[idx1]
Out[743]: 
array([[1, 1, 4],
       [1, 2, 3],
       [2, 3, 5]])

idx2=np.lexsort((a[:,0],a[:,2]))

a[idx2]
Out[745]: 
array([[1, 2, 3],
       [1, 1, 4],
       [2, 3, 5]])

argsortМожет использоваться для косвенной сортировки по одному ключу,lexsortМожет использоваться для многоключевой косвенной сортировки.

(3) Случайная сортировка

a=np.arange(12).reshape((3,4))

a
Out[764]: 
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

np.random.shuffle(a)

a
Out[766]: 
array([[ 4,  5,  6,  7],
       [ 0,  1,  2,  3],
       [ 8,  9, 10, 11]])

idx=np.random.permutation(a.shape[1])

a[:,idx]
Out[769]: 
array([[ 4,  5,  7,  6],
       [ 0,  1,  3,  2],
       [ 8,  9, 11, 10]])

метод первыйnp.random.shuffleСлучайная сортировка может производиться только по первой оси, второй способ — поnp.random.permutation, метод тоже может только случайным образом сортировать по первой оси, но во входном параметреxзаintКогда тип выбран, np.arange(x) будет отсортирован случайным образом, что может быстро сгенерировать неупорядоченный индекс, а затем получить неупорядоченный массив с помощью поиска по индексу.

(4) Сортировка разделов

a=np.array([2,3,1,5,4,0,8])

np.partition(a,1)
Out[800]: array([0, 1, 3, 5, 4, 2, 8])

np.partition(a,4)
Out[801]: array([0, 1, 2, 3, 4, 5, 8])

Сортировка разделов — это неполная сортировка, используемая в ситуациях, когда не требуется получение полной отсортированной последовательности. Этот метод гарантирует толькоkthЭлементы в указанной позиции сортируются правильно, другие элементы, меньшие, чем этот элемент, перемещаются вперед, а более крупные — назад. Может использоваться для быстрого поиска k-го по величине или k-го по величине элемента. также доступны черезndarray.partitionперечислить,axisПараметр задает направление оси и соответствующийnp.argpartitionИспользуется для получения секционированного индекса.

4. Дедупликация

a=np.array([3,2,2,3,1,1,4])

np.unique(a,return_index=True,return_inverse=True,return_counts=True,axis=None)
Out[776]: 
(array([1, 2, 3, 4]),
 array([4, 1, 0, 6], dtype=int64),
 array([2, 1, 1, 2, 0, 0, 3], dtype=int64),
 array([2, 2, 2, 1], dtype=int64))

a=np.array([[1,3],[2,4],[1,3]])

np.unique(a,axis=0)
Out[778]: 
array([[1, 3],
       [2, 4]])

axisУказывает ось дедупликации, по умолчаниюNoneМассив будет расширен, а затем дедуплицирован. Возвращаемое значение one — это упорядоченный список значений после дедупликации; Возвращаемое значение 2 — это индекс уникального значения в исходном массиве, только вreturn_index=Trueпри условии; Возвращаемое значение 3 — это индекс исходного массива, который необходимо восстановить в соответствии с уникальным значением.return_inverse=Trueпри условии; Возвращаемое значение четыре — это количество вхождений уникального значения только вreturn_counts=Trueпри условии, когда.

5. Сплит

(1) Разделение индекса

a=np.arange(9).reshape((3,3))

a[:2,:],a[2:,:]
Out[781]: 
(array([[0, 1, 2],
        [3, 4, 5]]), array([[6, 7, 8]]))

a[a>2],a[~(a>2)]
Out[782]: (array([3, 4, 5, 6, 7, 8]), array([0, 1, 2]))

idx=np.random.permutation(a.shape[0])
sp_idx=int(a.shape[0]*0.8)

a[idx[:sp_idx]],a[idx[sp_idx:]]
Out[792]: 
(array([[3, 4, 5],
        [6, 7, 8]]), array([[0, 1, 2]]))

Наиболее гибкий способ, сложные разбиения требуют написания большего количества кода, и другие методы могут использоваться для создания индексов для разбиения, например использованиеnp.digitizeДелайте биннинг.

(2) Раздельный метод

a=np.arange(8)

np.split(a,2)
Out[803]: [array([0, 1, 2, 3]), array([4, 5, 6, 7])]

np.split(a,[2,5])
Out[805]: [array([0, 1]), array([2, 3, 4]), array([5, 6, 7])]

a=a.reshape((2,4))

a
Out[807]: 
array([[0, 1, 2, 3],
       [4, 5, 6, 7]])

np.split(a,[1,3],axis=1)
Out[809]: 
[array([[0],
        [4]]), array([[1, 2],
        [5, 6]]), array([[3],
        [7]])]

второй параметрindices_or_sectionsуказать метод разделения,intТип представляет количество равных частей, а тип одномерного массива представляет значение индекса, используемое для деления, например[2,5]значит делится наa[:2],a[2:5],a[5:]. третий параметрaxisНаправление оси может быть указано.

7. Чтение и письмо

Назад к содержанию

numpy может использовать выделенныйnpyиnpzформат или обычныйtxtформат храненияndarrayДанные.

1. Сохранить

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

np.save('D:\\out.npy',a)

np.savez('D:\\out.npz',a,b=b)

np.savetxt('D:\\out.txt',b,fmt="%d", delimiter=",")

Расширение можно не указывать, оно будет выполнено автоматически. Не удалось создать папку автоматически.saveдля сохранения одного массива какnpyфайл формата.savezдля сохранения нескольких массивов какnpzformat, массивы, передаваемые без аргументов ключевого слова, автоматически именуются какarr_0,arr_1,....savetxtдля сохранения одного массива какtxtформат файла, параметрыfmtЗадает преобразование строки при сохранении, параметрdelimiterУкажите разделитель, обратите внимание, что при чтении также необходимо указывать разделитель. Установка разделителя недействительна для одномерных массивов, а массивы с более чем двумя измерениями не подходят для сохранения этим методом.

2. Загрузить

np.load('D:\\out.npy')
Out[835]: array([1, 2, 3, 4])

npz=np.load('D:\\out.npz')

npz['arr_0']
Out[837]: array([1, 2, 3, 4])

npz['b']
Out[838]: 
array([[5, 6],
       [7, 8]])

np.loadtxt('D:\\out.txt',dtype='int',delimiter=',')
Out[841]: 
array([[5, 6],
       [7, 8]])

np.loadчитатьnpzфайл формата получитNpzFileобъекта, то по заданному при сохранении имени[]Индекс может получить каждый массив.

8. Другие

Назад к содержанию

1. Тип матрицы

numpy предоставляет специальный матричный объектmatrix,основан наndarrayПосле дальнейшей инкапсуляции некоторые операции, связанные с матрицей, могут выполняться быстрее, но по сравнению сndarrayПреимуществ в производительности нет, а размерность ограничена 2D, поэтому не рекомендуется.

(1).Создать

m1=np.matrix([[1,2],[3,4]])

m1
Out[81]: 
matrix([[1, 2],
        [3, 4]])

Создано сndarrayпохожий.

(2).ndarrayвзаимное преобразование

a=np.array([[5,6],[7,8]])
m2=np.matrix([[5,6],[7,8]])

np.asmatrix(a)
Out[84]: 
matrix([[5, 6],
        [7, 8]])

np.matrix(a)
Out[85]: 
matrix([[5, 6],
        [7, 8]])

np.asarray(m2)
Out[88]: 
array([[5, 6],
       [7, 8]])

np.array(m2)
Out[89]: 
array([[5, 6],
       [7, 8]])

m2.base
Out[90]: 
array([[5, 6],
       [7, 8]])

(3) Матричные операции

m1*m2
Out[94]: 
matrix([[19, 22],
        [43, 50]])

m1.I
Out[95]: 
matrix([[-2. ,  1. ],
        [ 1.5, -0.5]])

m1.T
Out[96]: 
matrix([[1, 3],
        [2, 4]])

оператор*используется вmatrixвыше представляет матричное умножение, которое эквивалентноnp.dot(m1,m2), для реализации поэлементного умножения вам нужно использоватьnp.multiply(m1,m2).matrix.Tпредставляет транспонированную матрицу,matrix.Iпредставляет обратную матрицу.matrixМожно использовать большую частьndarrayметод, такой какmax,sum,sortЖдать.

2. Тензорные операции

Тензоры — это обобщение таких понятий, как векторы и матрицы.Скаляр — это тензор ранга 0, вектор — это тензор ранга 1, а матрица — это тензор ранга 2. numpy обеспечивает обобщенную операцию скалярного произведения тензораnp.tensordot.

a=np.arange(1,9).reshape((2,2,2))
b=np.arange(1,5).reshape((2,2))

a
Out[4]: 
array([[[1, 2],
        [3, 4]],

       [[5, 6],
        [7, 8]]])

b
Out[5]: 
array([[1, 2],
       [3, 4]])

np.tensordot(a,b,axes=1)
Out[8]: 
array([[[ 7, 10],
        [15, 22]],

       [[23, 34],
        [31, 46]]])

np.tensordot(a,b,axes=(-1,0))
Out[9]: 
array([[[ 7, 10],
        [15, 22]],

       [[23, 34],
        [31, 46]]])

np.tensordot(a,b,axes=2)
Out[10]: array([30, 70])

np.tensordot(a,b,axes=([-2,-1],[0,1]))
Out[12]: array([30, 70])

np.dot(a,b)
Out[13]: 
array([[[ 7, 10],
        [15, 22]],

       [[23, 34],
        [31, 46]]])

np.tensordot(a,b,axes=(-1,-2))
Out[14]: 
array([[[ 7, 10],
        [15, 22]],

       [[23, 34],
        [31, 46]]])

np.inner(a,b)
Out[15]: 
array([[[ 5, 11],
        [11, 25]],

       [[17, 39],
        [23, 53]]])

np.tensordot(a,b,axes=(-1,-1))
Out[16]: 
array([[[ 5, 11],
        [11, 25]],

       [[17, 39],
        [23, 53]]])

первые два параметраaиb— два тензора, участвующих в операции. третий параметрaxesИспользуется для указания оси усадки, полный формат похож на([a_axis1,a_axis2,...],[b_axis1,b_axis2,...]), две последовательности задаются отдельноaиbОсь оси, элементы в направлении оси будут соответствовать, умножаться и добавляться в соответствии с указанным порядком; вы можете использовать(a_axis,b_axis)Форма определяет только одну ось; быть пригодным для использованияintБыстрое обозначение типаaв последних N осях иbПервые оси N в середине используются для усадки, т.е.0равно([],[]), соответствующий операции тензорного произведения,1равно([-1],[0]), соответствующий операции тензорного внутреннего произведения,2равно([-2,-1],[0,1]), соответствующий операции двойного сжатия тензора,axesЗначение по умолчанию2.np.dot,np.innerТакие операции можно рассматривать как частные случаи представления этой функции,np.dot(a1,a2)равноnp.tensordot(a1,a2,axes=(-1,-2)),np.inner(a1,a2)равноnp.tensordot(a1,a2,axes=(-1,-1)).

3. Преобразование Фурье

(1) Последовательность частот

np.fft.fftfreq(10,1.0)
Out[12]: array([ 0. ,  0.1,  0.2,  0.3,  0.4, -0.5, -0.4, -0.3, -0.2, -0.1])

Возвращает частоту дискретизации преобразования Фурье, первый аргументnдлина окна,intтип, второй параметрd— интервал выборки (обратный частоте выборки), значение по умолчанию — 1,0, а единица возвращаемого значения соответствует единице интервала выборки. Последовательность возвращаемых значений рассчитывается как: еслиnчетное число,f = [0, 1, ..., n/2-1, -n/2, ..., -1] / (d*n); еслиnнечетное число,f = [0, 1, ..., (n-1)/2, -(n-1)/2, ..., -1] / (d*n).

(2) Быстрое преобразование Фурье

x=np.cos(np.linspace(0,2*np.pi,30))
y=np.fft.fft(x)
x2=np.fft.ifft(y)

np.abs(x2-x).max()
Out[16]: 3.8864883384594504e-16

np.fftиnp.ifftОперации, обратные друг другу, используемые для одномерного быстрого преобразования Фурье, послеnp.fftПреобразованную последовательность можно получитьnp.ifftПриблизительное приведение к исходной последовательности. второй параметрnУкажите длину выходной оси преобразования, обрезку избыточной длины и 0, если она недостаточна; третий параметрaxisУказывает ось, используемую для преобразования, по умолчанию последняя ось.

(3) Сдвиг частоты

x=np.linspace(0,2*np.pi,8)
y=np.fft.fft(x)
y2=np.fft.fftshift(y)
y3=np.fft.ifftshift(y2)

np.abs(y3-y).max()
Out[32]: 0.0

np.fftshiftиnp.ifftshiftОбратные операции для перемещения постоянной составляющей выходного сигнала преобразования Фурье в центр спектра. второй параметрaxisОсь для использования для передачи может быть указана.

4. Обработка изображений

Данные изображения хранятся в виде массива и могут бытьPILБиблиотека считывает изображение, а затем преобразует данные изображения вndarrayвыполнить расчетную обработку. Вот некоторые обычаиnumpyСотрудничатьPILМетоды обработки данных изображения:

(1) Создание образа, чтение, масштабирование и сохранение

from PIL import Image
image1= Image.open("D:\\test.jpg")

image1.size
Out[3]: (1015, 610)

image2=image1.resize((500,300))
image2.save("D:\\test2.jpg")
image0=Image.new('RGB',image2.size)

image2
Out[7]: 

Image.openиспользуется для открытия изображения,modeМожно установить режим чтения, чаще всего используется'L'оттенки серого и'RGB'Карты цветов, как правило, автоматически сопоставляются, и их не нужно настраивать. изображение объектаresizeметод масштабирования изображения, параметр размера начинается сtupleтип(width,height)входящий формат. изображение объектаsaveметод сохранения изображения, либо используя расширение файла в пути сохранения, либоformatПараметр указывает тип файла сохранения,qualityПараметр может установить качество сохраняемого изображения в диапазоне от 1 (худшее) до 95 (лучшее), по умолчанию 75.Image.newдля создания нового образа,modeрежим указания параметра,sizeУкажите размер. существуетIPython, вы можете напрямую ввести имя переменной изображения для отображения изображения.

(2) Преобразование между изображениями и массивами

a=np.asarray(image2)

a.shape
Out[8]: (300, 500, 3)

image3=Image.fromarray(a,'RGB')

np.asarrayилиnp.arrayПреобразование изображений вndarray,np.asarrayвернуть данные изображенияndarrayВид вида, который нельзя изменить. В зависимости от типа различается и форма полученного массива, есть две наиболее распространенные формы, получаемая при преобразовании изображения в градациях серого:(height,width)Массив , цветовая карта преобразуется, чтобы получить форму(height,width,channel)массив ,channelцветовой канал,RGBв режимеchannel=3, соответствующие красному, зеленому и синему соответственно.Image.fromarrayможетndarrayПреобразовать в изображение, доступное черезmodeПараметр задает шаблон, который будет автоматически сопоставляться с формой массива по умолчанию.Когда шаблон указан, форма массива также должна сопоставляться. Обратите внимание, что массив для изображения должен бытьuint8тип данных, значение0~255, если не совпадает, требуется другое преобразование.

(3) Пиксельный рисунок

a0=np.array(image0)
a0+=np.random.randint(0,256,a.shape,dtype='uint8')
image4=Image.fromarray(a0)
image4.putpixel((0,0),(255,255,255))

image4 
Out[14]: 

изображение объектаputpixelМетод может добавить один пиксель, первый параметрxyот(x,y)Форма объявляет позицию для добавления точки пикселя, второй параметрvalueУкажите значение точки пикселя, например,LСкалярное значение в режиме оттенков серого,RGBВ режиме цветовой карты это(r,g,b)Формаtuple, значения находятся в0~255между. Этот метод может рисовать только один пиксель за раз, что неэффективно. Когда требуется пакетное рисование, рекомендуется преобразовать вndarrayиметь дело с. используется в приведенном выше примереndarrayМетод добавляет случайный цвет к каждому пикселю нового изображения.

(4) Преобразование изображений в оттенках серого в цветные.

a2=np.asarray(image2,dtype='float')

a5=(11*a2[:,:,0]+16*a2[:,:,1]+5*a2[:,:,2])/32
image5=Image.fromarray(np.uint8(a5))

a6=a5.repeat(3).reshape(a5.shape+(3,))
image6=Image.fromarray(np.uint8(a6))

image5
Out[77]: 

Цветное изображение в изображение в градациях серого,L=11*R+16*G+5*BРаботает только одна формула, есть и другие доступные формулы. Преобразование изображения в градациях серого в цветное относительно простое, т. е. копирование значения в градациях серого вRGBНа 3 каналах цвет после преобразования по-прежнему серый, потому что изображение в градациях серого не имеет информации о цвете.Даже если цветное изображение преобразуется в изображение в градациях серого, а затем обратно в цветное изображение, информация о цвете также будет потеряна. .

(5) Отразить, повернуть и обрезать изображения

a2=np.asarray(image2)

Image.fromarray(a2[::-1,::-1,:])
Out[85]: 

Image.fromarray(a2.transpose([1,0,2]))
Out[90]: 

Image.fromarray(a2[:150,:,:])
Out[91]:

В приведенном выше примере показаны три случая переворота влево-вправо + переворот вверх-вниз, переворот влево-вправо + поворот против часовой стрелки на 90° и перехват верхней части. можно получить вращение и переворот вверх-вниз и влево-вправо. Точное вращение требует использования матричных операций, которые здесь не раскрываются.