Python数据分析学习笔记：Numpy（二）

切片和索引

ndarray对象的内容可以通过索引或切片来访问和修改，就像 Python 的内置容器对象一样。如前所述，ndarray对象中的元素遵循基于零的索引。有三种可用的索引方法类型：字段访问，基本切片和高级索引。

基本切片

基本切片是 Python 中基本切片概念到 n 维的扩展。通过将start，stop和step参数提供给内置的slice函数来构造一个 Python slice对象。此slice对象被传递给数组来提取数组的一部分。

如果只输入一个参数，则将返回与索引对应的单个项目。如果使用a:，则从该索引向后的所有项目将被提取。如果使用两个参数（以:分隔），则对两个索引（不包括停止索引）之间的元素以默认步骤进行切片。

示例：

import numpy as np

a = np.arange(10)

s = slice(2, 7, 2)

b = a[2:7:2]

c = a[2:7]

d = a[2:]

e = a[2]

print("a:",a)

print("a[s]:",a[s])

print("b:",b)

print("c:",c)

print("d:",d)

print("e:",e)

# output:

# a: [0 1 2 3 4 5 6 7 8 9]

# a[s]: [2 4 6]

# b: [2 4 6]

# c: [2 3 4 5 6]

# d: [2 3 4 5 6 7 8 9]

# e: 2

上面的描述也可用于多维ndarray。切片还可以包括省略号（…），来使选择元组的长度与数组的维度相同。如果在行位置使用省略号，它将返回包含行中元素的ndarray。

示例：

import numpy as np

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

b = a[1:]

c = a[..., 1]

d = a[1, ...]

e = a[..., 1:]

print("a:", a)

print("b:", b)

print("c:", c)

print("d:", d)

print("e:", e)

# output:

# a: [[1 2 3]

# [3 4 5]

# [4 5 6]]

# b: [[3 4 5]

# [4 5 6]]

# c: [2 4 5]

# d: [3 4 5]

# e: [[2 3]

# [4 5]

# [5 6]]

高级索引

如果一个ndarray是非元组序列，数据类型为整数或布尔值的ndarray，或者至少一个元素为序列对象的元组，我们就能够用它来索引ndarray。高级索引始终返回数据的副本。与此相反，切片只提供了一个视图。有两种类型的高级索引：整数和布尔值。

整数索引

这种机制有助于基于 N 维索引来获取数组中任意元素。每个整数数组表示该维度的下标值。当索引的元素个数就是目标ndarray的维度时，会变得相当直接。

import numpy as np

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

b = a[[0, 1, 2], [0, 1, 0]]

print("a:", a)

print("b:", b)

# output:

# a: [[1 2]

# [3 4]

# [5 6]]

# b: [1 4 5]

行索引包含所有行号，列索引指定要选择的元素。高级和基本索引可以通过使用切片:或省略号…与索引数组组合。以下示例使用slice作为列索引和高级索引。当切片用于两者时，结果是相同的。但高级索引会导致复制，并且可能有不同的内存布局。

示例：

import numpy as np

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

b = a[[0, 1, 2], [0, 1, 0]]

c = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]])

rows = np.array([[0, 0], [3, 3]])

cols = np.array([[0, 2], [0, 2]])

d = c[rows, cols]

e = c[1:4, 1:3]

f = c[1:4, [1, 2]]

print("a:", a)

print("b:", b)

print("c:", c)

print("d:", d)

print("e:", e)

print("f:", f)

# output:

# a: [[1 2]

# [3 4]

# [5 6]]

# b: [1 4 5]

# c: [[ 0 1 2]

# [ 3 4 5]

# [ 6 7 8]

# [ 9 10 11]]

# d: [[ 0 2]

# [ 9 11]]

# e: [[ 4 5]

# [ 7 8]

# [10 11]]

# f: [[ 4 5]

# [ 7 8]

# [10 11]]

布尔索引

当结果对象是布尔运算（例如比较运算符）的结果时，将使用此类型的高级索引。

示例：

import numpy as np

a = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]])

b = a[a > 5]

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

d = c[~np.isnan(c)]

e = np.array([1, 2 + 6j, 5, 3.5 + 5j])

f = e[np.iscomplex(e)]

print("a:", a)

print("b:", b)

print("c:", c)

print("d:", d)

print("e:", e)

print("f:", f)

# output:

# a: [[ 0 1 2]

# [ 3 4 5]

# [ 6 7 8]

# [ 9 10 11]]

# b: [ 6 7 8 9 10 11]

# c: [nan 1. 2. nan 3. 4. 5.]

# d: [1. 2. 3. 4. 5.]

# e: [1. +0.j 2. +6.j 5. +0.j 3.5+5.j]

# f: [2. +6.j 3.5+5.j]

广播

术语广播是指NumPy在算术运算期间处理不同形状的数组的能力。对数组的算术运算通常在相应的元素上进行。如果两个阵列具有完全相同的形状，则这些操作被无缝执行。

示例：

import numpy as np

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

b = np.array([10, 20, 30, 40])

c = a * b

print("a:", a)

print("b:", b)

print("c:", c)

# output:

# a: [1 2 3 4]

# b: [10 20 30 40]

# c: [ 10 40 90 160]

如果两个数组的维数不相同，则元素到元素的操作是不可能的。然而，在 NumPy 中仍然可以对形状不相似的数组进行操作，因为它拥有广播功能。较小的数组会广播到较大数组的大小，以便使它们的形状可兼容。如果满足以下规则，可以进行广播：

ndim较小的数组会在前面追加一个长度为 1 的维度。
输出数组的每个维度的大小是输入数组该维度大小的最大值。
如果输入在每个维度中的大小与输出大小匹配，或其值正好为 1，则在计算中可它。
如果输入的某个维度大小为 1，则该维度中的第一个数据元素将用于该维度的所有计算。

如果上述规则产生有效结果，并且满足以下条件之一，那么数组被称为可广播的。

数组拥有相同形状。
数组拥有相同的维数，每个维度拥有相同长度，或者长度为 1。
数组拥有极少的维度，可以在其前面追加长度为 1 的维度，使上述条件成立。

示例：

import numpy as np

a = np.array([[0, 0, 0], [10, 10, 10], [20, 20, 20], [30, 30, 30]])

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

c = a + b

print("a:", a)

print("b:", b)

print("c:", c)

# output:

# a: [[ 0 0 0]

# [10 10 10]

# [20 20 20]

# [30 30 30]]

# b: [1 2 3]

# c: [[ 1 2 3]

# [11 12 13]

# [21 22 23]

# [31 32 33]]

下面的图片展示了数组b如何通过广播来与数组a兼容。

数组上的迭代

NumPy 包包含一个迭代器对象numpy.nditer。它是一个有效的多维迭代器对象，可以用于在数组上进行迭代。数组的每个元素可使用 Python 的标准Iterator接口来访问。

迭代的顺序匹配数组的内容布局，而不考虑特定的排序。这可以通过迭代上述数组的转置来看到。

示例：

import numpy as np

a = np.arange(0, 60, 5)

a = a.reshape(3, 4)

b = a.T # 转置

print("a:", a)

print("b:", b)

print("--- start print x ---")

for x in np.nditer(a):

print(x, end=" ")

print("\n--- start print y ---")

for y in np.nditer(b):

print(y, end=" ")

# output:

# a: [[ 0 5 10 15]

# [20 25 30 35]

# [40 45 50 55]]

# b: [[ 0 20 40]

# [ 5 25 45]

# [10 30 50]

# [15 35 55]]

# --- start print x ---

# 0 5 10 15 20 25 30 35 40 45 50 55

# --- start print y ---

# 0 5 10 15 20 25 30 35 40 45 50 55

迭代顺序

如果相同元素使用 F 风格顺序存储，则迭代器选择以更有效的方式对数组进行迭代。

示例：

import numpy as np

a = np.arange(0, 60, 5)

a = a.reshape(3, 4)

b = a.T # 转置

c = a.copy(order='C')

d = a.copy(order='F')

e = b.copy(order='C')

f = b.copy(order='F')

print("a:", a)

print("b:", b)

print("c:", c)

print("d:", d)

print("e:", e)

print("f:", f)

print("--- start print aC ---")

for aC in np.nditer(c):

print(aC, end=" ")

print("\n--- start print aF ---")

for aF in np.nditer(d):

print(aF, end=" ")

print("\n--- start print bC ---")

for bC in np.nditer(e):

print(bC, end=" ")

print("\n--- start print bF ---")

for bF in np.nditer(f):

print(bF, end=" ")

# output:

# a: [[ 0 5 10 15]

# [20 25 30 35]

# [40 45 50 55]]

# b: [[ 0 20 40]

# [ 5 25 45]

# [10 30 50]

# [15 35 55]]

# c: [[ 0 5 10 15]

# [20 25 30 35]

# [40 45 50 55]]

# d: [[ 0 5 10 15]

# [20 25 30 35]

# [40 45 50 55]]

# e: [[ 0 20 40]

# [ 5 25 45]

# [10 30 50]

# [15 35 55]]

# f: [[ 0 20 40]

# [ 5 25 45]

# [10 30 50]

# [15 35 55]]

# --- start print aC ---

# 0 5 10 15 20 25 30 35 40 45 50 55

# --- start print aF ---

# 0 20 40 5 25 45 10 30 50 15 35 55

# --- start print bC ---

# 0 20 40 5 25 45 10 30 50 15 35 55

# --- start print bF ---

# 0 5 10 15 20 25 30 35 40 45 50 55

修改数组的值

nditer对象有另一个可选参数op_flags。其默认值为只读，但可以设置为读写或只写模式。这将允许使用此迭代器修改数组元素。

示例：

import numpy as np

a = np.arange(0, 60, 5)

a = a.reshape(3, 4)

print("a:", a)

for x in np.nditer(a, op_flags=['readwrite']):

x[...] = 2 * x

print("a_readwrite:", a)

# output:

# a: [[ 0 5 10 15]

# [20 25 30 35]

# [40 45 50 55]]

# a_readwrite: [[ 0 10 20 30]

# [ 40 50 60 70]

# [ 80 90 100 110]]

外部循环

nditer类的构造器拥有flags参数，它可以接受下列值：

序号	参数及描述
1.	c_index 可以跟踪 C 顺序的索引
2.	f_index 可以跟踪 Fortran 顺序的索引
3.	multi-index 每次迭代可以跟踪一种索引类型
4.	external_loop 给出的值是具有多个值的一维数组，而不是零维数组

示例：

import numpy as np

a = np.arange(0, 60, 5)

a = a.reshape(3, 4)

print("a:", a)

print("--- start print x ---")

for x in np.nditer(a, flags=['external_loop'], order='F'):

print(x, end=" ")

# output:

# a: [[ 0 5 10 15]

# [20 25 30 35]

# [40 45 50 55]]

# --- start print x ---

# [ 0 20 40] [ 5 25 45] [10 30 50] [15 35 55]

广播迭代

如果两个数组是可广播的，nditer组合对象能够同时迭代它们。假设数组a具有维度 3X4，并且存在维度为 1X4 的另一个数组b，则使用以下类型的迭代器（数组b被广播到a的大小）。

示例：

import numpy as np

a = np.arange(0, 60, 5)

a = a.reshape(3, 4)

b = np.array([1, 2, 3, 4], dtype=int)

print("a:", a)

print("b:", b)

print("--- start print x,y ---")

for x, y in np.nditer([a, b]):

print("%d:%d" % (x, y), end=" ")

# output:

# a: [[ 0 5 10 15]

# [20 25 30 35]

# [40 45 50 55]]

# b: [1 2 3 4]

# --- start print x,y ---

# 0:1 5:2 10:3 15:4 20:1 25:2 30:3 35:4 40:1 45:2 50:3 55:4

数组操作

NumPy包中有几个例程用于处理ndarray对象中的元素。它们可以分为以下类型：

修改形状

序号	形状及描述
1.	reshape 不改变数据的条件下修改形状
2.	flat 数组上的一维迭代器
3.	flatten 返回折叠为一维的数组副本
4.	ravel 返回连续的展开数组

numpy.reshape这个函数在不改变数据的条件下修改形状，它接受如下参数：

numpy.reshape(arr, newshape, order=’C’)

其中：

arr：要修改形状的数组
newshape：整数或者整数数组，新的形状应当兼容原有形状
order：’C’为 C 风格顺序，’F’为 F 风格顺序，’A’为保留原顺序。

示例：

import numpy as np

a = np.arange(8)

b = a.reshape(4, 2)

print("a:", a)

print("b:", b)

# output:

# a: [0 1 2 3 4 5 6 7]

# b: [[0 1]

# [2 3]

# [4 5]

# [6 7]]

numpy.ndarray.flat该函数返回数组上的一维迭代器，行为类似 Python 内建的迭代器。

示例：

import numpy as np

a = np.arange(8).reshape(2, 4)

b = a.flat[5]

print("a:", a)

print("b:", b)

# output:

# a: [[0 1 2 3]

# [4 5 6 7]]

# b: 5

numpy.ndarray.flatten该函数返回折叠为一维的数组副本，函数接受下列参数：ndarray.flatten(order=’C’)

其中：order：’C’ – 按行，’F’ – 按列，’A’ – 原顺序，’k’ – 元素在内存中的出现顺序。

示例：

import numpy as np

a = np.arange(8).reshape(2, 4)

b = a.flatten()

c = a.flatten(order='F')

print("a:", a)

print("b:", b)

print("c:", c)

# output:

# a: [[0 1 2 3]

# [4 5 6 7]]

# b: [0 1 2 3 4 5 6 7]

# c: [0 4 1 5 2 6 3 7]

numpy.ravel这个函数返回展开的一维数组，并且按需生成副本。返回的数组和输入数组拥有相同数据类型。这个函数接受两个参数。

numpy.ravel(a, order=’C’)

构造器接受下列参数：order：’C’ – 按行，’F’ – 按列，’A’ – 原顺序，’k’ – 元素在内存中的出现顺序。

示例：

import numpy as np

a = np.arange(8).reshape(2, 4)

b = a.ravel()

c = a.ravel(order='F')

print("a:", a)

print("b:", b)

print("c:", c)

# output:

# a: [[0 1 2 3]

# [4 5 6 7]]

# b: [0 1 2 3 4 5 6 7]

# c: [0 4 1 5 2 6 3 7]

翻转操作

序号	操作及描述
1.	transpose 翻转数组的维度
2.	ndarray.T 和self.transpose()相同
3.	rollaxis 向后滚动指定的轴
4.	swapaxes 互换数组的两个轴

numpy.transpose这个函数翻转给定数组的维度。如果可能的话它会返回一个视图。函数接受下列参数：numpy.transpose(arr, axes)

其中：

arr：要转置的数组
axes：整数的列表，对应维度，通常所有维度都会翻转。

numpy.ndarray.T该函数属于ndarray类，行为类似于numpy.transpose。

示例：

import numpy as np

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

b = np.transpose(a)

c = a.T

print("a:", a)

print("b:", b)

print("c:", c)

# output:

# a: [[ 0 1 2 3]

# [ 4 5 6 7]

# [ 8 9 10 11]]

# b: [[ 0 4 8]

# [ 1 5 9]

# [ 2 6 10]

# [ 3 7 11]]

# c: [[ 0 4 8]

# [ 1 5 9]

# [ 2 6 10]

# [ 3 7 11]]

数组的连接

序号	数组及描述
1.	concatenate 沿着现存的轴连接数据序列
2.	stack 沿着新轴连接数组序列
3.	hstack 水平堆叠序列中的数组（列方向）
4.	vstack 竖直堆叠序列中的数组（行方向）

numpy.concatenate数组的连接是指连接。此函数用于沿指定轴连接相同形状的两个或多个数组。该函数接受以下参数。numpy.concatenate((a1, a2, …), axis)

其中：

a1, a2, …：相同类型的数组序列
axis：沿着它连接数组的轴，默认为 0

示例：

import numpy as np

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

b = np.array([[5, 6], [7, 8]])

c = np.concatenate((a, b))

d = np.concatenate((a, b), axis=1)

print("a:", a)

print("b:", b)

print("c:", c)

print("d:", d)

# output:

# a: [[1 2]

# [3 4]]

# b: [[5 6]

# [7 8]]

# c: [[1 2]

# [3 4]

# [5 6]

# [7 8]]

# d: [[1 2 5 6]

# [3 4 7 8]]

numpy.stack此函数沿新轴连接数组序列。此功能添加自 NumPy 版本 1.10.0。需要提供以下参数。numpy.stack(arrays, axis)

其中：

arrays：相同形状的数组序列
axis：返回数组中的轴，输入数组沿着它来堆叠

示例：

import numpy as np

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

b = np.array([[5, 6], [7, 8]])

c = np.stack((a, b), 0)

d = np.stack((a, b), 1)

print("a:", a)

print("b:", b)

print("c:", c)

print("d:", d)

# output:

# a: [[1 2]

# [3 4]]

# b: [[5 6]

# [7 8]]

# c: [[[1 2]

# [3 4]]

# [[5 6]

# [7 8]]]

# d: [[[1 2]

# [5 6]]

# [[3 4]

# [7 8]]]

numpy.hstack numpy.stack函数的变体，通过堆叠来生成水平的单个数组。

示例：

import numpy as np

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

b = np.array([[5, 6], [7, 8]])

c = np.hstack((a, b))

print("a:", a)

print("b:", b)

print("c:", c)

# output:

# a: [[1 2]

# [3 4]]

# b: [[5 6]

# [7 8]]

# c: [[1 2 5 6]

# [3 4 7 8]]

numpy.vstack numpy.stack函数的变体，通过堆叠来生成竖直的单个数组。

示例：

import numpy as np

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

b = np.array([[5, 6], [7, 8]])

c = np.vstack((a, b))

print("a:", a)

print("b:", b)

print("c:", c)

# output:

# a: [[1 2]

# [3 4]]

# b: [[5 6]

# [7 8]]

# c: [[1 2]

# [3 4]

# [5 6]

# [7 8]]

数组分割

序号	数组及操作
1.	split 将一个数组分割为多个子数组
2.	hsplit 将一个数组水平分割为多个子数组（按列）
3.	vsplit 将一个数组竖直分割为多个子数组（按行）

numpy.split 该函数沿特定的轴将数组分割为子数组。函数接受三个参数：numpy.split(ary, indices_or_sections, axis)

其中：

ary：被分割的输入数组
indices_or_sections：可以是整数，表明要从输入数组创建的，等大小的子数组的数量。如果此参数是一维数组，则其元素表明要创建新子数组的点。
axis：默认为 0

示例：

import numpy as np

a = np.arange(9)

b = np.split(a, 3)

c = np.split(a, [4, 7])

print("a:", a)

print("b:", b)

print("c:", c)

# output:

# a: [0 1 2 3 4 5 6 7 8]

# b: [array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])]

# c: [array([0, 1, 2, 3]), array([4, 5, 6]), array([7, 8])]

numpy.hsplit numpy.hsplit是split()函数的特例，其中轴为 1 表示水平分割，无论输入数组的维度是什么。

示例：

import numpy as np

a = np.arange(16).reshape(4, 4)

b = np.hsplit(a, 2)

print("a:", a)

print("b:", b)

# output:

# a: [[ 0 1 2 3]

# [ 4 5 6 7]

# [ 8 9 10 11]

# [12 13 14 15]]

# b: [array([[ 0, 1],

# [ 4, 5],

# [ 8, 9],

# [12, 13]]), array([[ 2, 3],

# [ 6, 7],

# [10, 11],

# [14, 15]])]

numpy.vsplit numpy.vsplit是split()函数的特例，其中轴为 0 表示竖直分割，无论输入数组的维度是什么。下面的例子使之更清楚。

示例：

import numpy as np

a = np.arange(16).reshape(4, 4)

b = np.vsplit(a, 2)

print("a:", a)

print("b:", b)

# output:

# a: [[ 0 1 2 3]

# [ 4 5 6 7]

# [ 8 9 10 11]

# [12 13 14 15]]

# b: [array([[0, 1, 2, 3],

# [4, 5, 6, 7]]), array([[ 8, 9, 10, 11],

# [12, 13, 14, 15]])]

添加/删除元素

序号	元素及描述
1.	resize 返回指定形状的新数组
2.	append 将值添加到数组末尾
3.	insert 沿指定轴将值插入到指定下标之前
4.	delete 返回删掉某个轴的子数组的新数组
5.	unique 寻找数组内的唯一元素

numpy.resize此函数返回指定大小的新数组。如果新大小大于原始大小，则包含原始数组中的元素的重复副本。该函数接受以下参数。numpy.resize(arr, shape)

其中：

arr：要修改大小的输入数组
shape：返回数组的新形状

示例：

import numpy as np

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

b = np.resize(a, (3, 2))

c = np.resize(a, (3, 3))

print("a:", a)

print("b:", b)

print("c:", c)

# output:

# a: [[1 2 3]

# [4 5 6]]

# b: [[1 2]

# [3 4]

# [5 6]]

# c: [[1 2 3]

# [4 5 6]

# [1 2 3]]

numpy.append此函数在输入数组的末尾添加值。附加操作不是原地的，而是分配新的数组。此外，输入数组的维度必须匹配否则将生成ValueError。

函数接受下列函数：numpy.append(arr, values, axis)

其中：

arr：输入数组
values：要向arr添加的值，比如和arr形状相同（除了要添加的轴）
axis：沿着它完成操作的轴。如果没有提供，两个参数都会被展开。

示例：

import numpy as np

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

b = np.append(a, [7, 8, 9])

c = np.append(a, [[7, 8, 9]], axis=0)

d = np.append(a, [[5, 5, 5], [7, 8, 9]], axis=1)

print("a:", a)

print("b:", b)

print("c:", c)

print("d:", d)

# output:

# a: [[1 2 3]

# [4 5 6]]

# b: [1 2 3 4 5 6 7 8 9]

# c: [[1 2 3]

# [4 5 6]

# [7 8 9]]

# d: [[1 2 3 5 5 5]

# [4 5 6 7 8 9]]

numpy.insert此函数在给定索引之前，沿给定轴在输入数组中插入值。如果值的类型转换为要插入，则它与输入数组不同。插入没有原地的，函数会返回一个新数组。此外，如果未提供轴，则输入数组会被展开。insert()函数接受以下参数：numpy.insert(arr, obj, values, axis)

其中：

arr：输入数组
obj：在其之前插入值的索引
values：要插入的值
axis：沿着它插入的轴，如果未提供，则输入数组会被展开

示例：

import numpy as np

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

b = np.insert(a, 3, [11, 12])

c = np.insert(a, 1, [11], axis=0)

d = np.insert(a, 1, 11, axis=1)

print("a:", a)

print("b:", b)

print("c:", c)

print("d:", d)

# output:

# a: [[1 2]

# [3 4]

# [5 6]]

# b: [ 1 2 3 11 12 4 5 6]

# c: [[ 1 2]

# [11 11]

# [ 3 4]

# [ 5 6]]

# d: [[ 1 11 2]

# [ 3 11 4]

# [ 5 11 6]]

numpy.delete 此函数返回从输入数组中删除指定子数组的新数组。与insert()函数的情况一样，如果未提供轴参数，则输入数组将展开。该函数接受以下参数：Numpy.delete(arr, obj, axis)

其中：

arr：输入数组
obj：可以被切片，整数或者整数数组，表明要从输入数组删除的子数组
axis：沿着它删除给定子数组的轴，如果未提供，则输入数组会被展开

示例：

import numpy as np

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

b = np.delete(a, 5)

c = np.delete(a, 1, axis=1)

d = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

e = np.delete(a, np.s_[::2])

print("a:", a)

print("b:", b)

print("c:", c)

print("d:", d)

print("e:", e)

# output:

# a: [[ 0 1 2 3]

# [ 4 5 6 7]

# [ 8 9 10 11]]

# b: [ 0 1 2 3 4 6 7 8 9 10 11]

# c: [[ 0 2 3]

# [ 4 6 7]

# [ 8 10 11]]

# d: [ 1 2 3 4 5 6 7 8 9 10]

# e: [ 1 3 5 7 9 11]

numpy.unique 此函数返回输入数组中的去重元素数组。该函数能够返回一个元组，包含去重数组和相关索引的数组。索引的性质取决于函数调用中返回参数的类型。

numpy.unique(arr, return_index, return_inverse, return_counts)

其中：

arr：输入数组，如果不是一维数组则会展开
return_index：如果为true，返回输入数组中的元素下标
return_inverse：如果为true，返回去重数组的下标，它可以用于重构输入数组
return_counts：如果为true，返回去重数组中的元素在原数组中的出现次数

示例：

import numpy as np

a = np.array([5, 2, 6, 2, 7, 5, 6, 8, 2, 9])

b = np.unique(a)

print("a:", a)

print("b:", b)

u, indices = np.unique(a, return_index=True)

print(indices)

u, indices = np.unique(a, return_inverse=True)

print(indices)

u, indices = np.unique(a, return_counts=True)

print(indices)

# output:

# a: [5 2 6 2 7 5 6 8 2 9]

# b: [2 5 6 7 8 9]

# [1 0 2 4 7 9]

# [1 0 2 0 3 1 2 4 0 5]

# [3 2 2 1 1 1]

位操作

下面是 NumPy 包中可用的位操作函数。

序号	操作及描述
1.	bitwise_and 对数组元素执行位与操作
2.	bitwise_or 对数组元素执行位或操作
3.	invert 计算位非
4.	left_shift 向左移动二进制表示的位
5.	right_shift 向右移动二进制表示的位

bitwise_and 通过np.bitwise_and()函数对输入数组中的整数的二进制表示的相应位执行位与运算。
bitwise_or 通过np.bitwise_or()函数对输入数组中的整数的二进制表示的相应位执行位或运算。

示例：

import numpy as np

a, b = 13, 17

print("bin_a:", bin(a))

print("bin_b:", bin(b))

c = np.bitwise_and(a, b)

d = np.bitwise_or(a, b)

print("bitwise_and:", c)

print("bitwise_or:", d)

# output:

# bin_a: 0b1101

# bin_b: 0b10001

# bitwise_and: 1

# bitwise_or: 29

invert 此函数计算输入数组中整数的位非结果。对于有符号整数，返回补码。注意，np.binary_repr()函数返回给定宽度中十进制数的二进制表示。

示例：

import numpy as np

a = np.invert(np.array([13], dtype=np.uint8))

b = np.binary_repr(13, width=8)

c = np.binary_repr(242, width=8)

print("13 的位反转:", a)

print("13 的二进制表示：", b)

print("242 的二进制表示：", c)

# output:

# 13 的位反转: [242]

# 13 的二进制表示： 00001101

# 242 的二进制表示： 11110010

left_shift numpy.left shift()函数将数组元素的二进制表示中的位向左移动到指定位置，右侧附加相等数量的 0。

right_shift numpy.right_shift()函数将数组元素的二进制表示中的位向右移动到指定位置，左侧附加相等数量的 0。

示例：

import numpy as np

a = np.left_shift(10, 2)

b = np.right_shift(40, 2)

c = np.binary_repr(10, width=8)

d = np.binary_repr(40, width=8)

print("将 10 左移两位：", a)

print("将 40 右移两位：", b)

print("10 的二进制表示：", c)

print("40 的二进制表示：", d)

# output:

# 将 10 左移两位： 40

# 将 40 右移两位： 10

# 10 的二进制表示： 00001010

# 40 的二进制表示： 00101000

字符串函数

以下函数用于对dtype为numpy.string_或numpy.unicode_的数组执行向量化字符串操作。它们基于 Python 内置库中的标准字符串函数。

序号	函数及描述
1.	add() 返回两个str或Unicode数组的逐个字符串连接
2.	multiply() 返回按元素多重连接后的字符串
3.	center() 返回给定字符串的副本，其中元素位于特定字符串的中央
4.	capitalize() 返回给定字符串的副本，其中只有第一个字符串大写
5.	title() 返回字符串或 Unicode 的按元素标题转换版本
6.	lower() 返回一个数组，其元素转换为小写
7.	upper() 返回一个数组，其元素转换为大写
8.	split() 返回字符串中的单词列表，并使用分隔符来分割
9.	splitlines() 返回元素中的行列表，以换行符分割
10.	strip() 返回数组副本，其中元素移除了开头或者结尾处的特定字符
11.	join() 返回一个字符串，它是序列中字符串的连接
12.	replace() 返回字符串的副本，其中所有子字符串的出现位置都被新字符串取代
13.	decode() 按元素调用str.decode
14.	encode() 按元素调用str.encode

这些函数在字符数组类（numpy.char）中定义。较旧的 Numarray 包包含chararray类。 numpy.char类中的上述函数在执行向量化字符串操作时非常有用。

numpy.char.add() 函数执行按元素的字符串连接。

示例：

a = np.char.add(['hello'],[' xyz'])

b = np.char.add(['hello', 'hi'],[' abc', ' xyz'])

print("a:", a)

print("b:", b)

# output:

# a: ['hello xyz']

# b: ['hello abc' 'hi xyz']

numpy.char.multiply() 这个函数执行多重连接。

示例：

import numpy as np

a = np.char.multiply('Hello ', 3)

print("a:", a)

# output:

# a: Hello Hello Hello

numpy.char.center() 此函数返回所需宽度的数组，以便输入字符串位于中心，并使用fillchar在左侧和右侧进行填充。

示例：

import numpy as np

a = np.char.center('hello', 20, fillchar='*')

print("a:", a)

# output:

# a: *******hello********

numpy.char.capitalize() 函数返回字符串的副本，其中第一个字母大写

numpy.char.title() 返回输入字符串的按元素标题转换版本，其中每个单词的首字母都大写。

numpy.char.lower() 函数返回一个数组，其元素转换为小写。它对每个元素调用str.lower。

numpy.char.upper() 函数返回一个数组，其元素转换为大写。它对每个元素调用str.upper。

示例：

import numpy as np

a = np.char.capitalize(['hello', 'world'])

b = np.char.title(['hello', 'world'])

c = np.char.lower(['Hello', 'World'])

d = np.char.upper(['hello', 'world'])

print("a:", a)

print("b:", b)

print("c:", c)

print("d:", d)

# output:

# a: ['Hello' 'World']

# b: ['Hello' 'World']

# c: ['hello' 'world']

# d: ['HELLO' 'WORLD']

numpy.char.split() 此函数返回输入字符串中的单词列表。默认情况下，空格用作分隔符。否则，指定的分隔符字符用于分割字符串。

numpy.char.splitlines() 函数返回数组中元素的单词列表，以换行符分割。

示例：

import numpy as np

a = np.char.split('hello how are you?')

b = np.char.split('TutorialsPoint,Hyderabad,Telangana', sep=',')

c = np.char.splitlines('hello\nhow are you?')

d = np.char.splitlines('hello\rhow are you?')

print("a:", a)

print("b:", b)

print("c:", c)

print("d:", d)

# output:

# a: ['hello', 'how', 'are', 'you?']

# b: ['TutorialsPoint', 'Hyderabad', 'Telangana']

# c: ['hello', 'how are you?']

# d: ['hello', 'how are you?']

numpy.char.strip() 函数返回数组的副本，其中元素移除了开头或结尾处的特定字符。

示例：

import numpy as np

a = np.char.strip('ashok arora', 'a')

b = np.char.strip(['arora', 'admin', 'java'], 'a')

print("a:", a)

print("b:", b)

# output:

# a: shok aror

# b: ['ror' 'dmin' 'jav']

numpy.char.join() 这个函数返回一个字符串，其中单个字符由特定的分隔符连接。

示例：

import numpy as np

a = np.char.join(':', 'dmy')

b = np.char.join([':', '-'], ['dmy', 'ymd'])

print("a:", a)

print("b:", b)

# output:

# a: d:m:y

# b: ['d:m:y' 'y-m-d']

numpy.char.replace() 这个函数返回字符串副本，其中所有字符序列的出现位置都被另一个给定的字符序列取代。

示例：

import numpy as np

a = np.char.replace('He is a good boy', 'is', 'was')

print("a:", a)

# output:

# a: He was a good boy

numpy.char.decode() 这个函数在给定的字符串中使用特定编码调用str.decode()。

numpy.char.encode() 此函数对数组中的每个元素调用str.encode函数。默认编码是utf_8，可以使用标准 Python 库中的编解码器。

示例：

import numpy as np

a = np.char.encode('hello', 'cp500')

b = np.char.decode(a, 'cp500')

print("a:", a)

print("b:", b)

# output:

# a: b'\x88\x85\x93\x93\x96'

# b: hello

算数函数

NumPy 包含大量的各种数学运算功能。 NumPy 提供标准的三角函数，算术运算的函数，复数处理函数等。

三角函数

NumPy 拥有标准的三角函数，它为弧度制单位的给定角度返回三角函数比值。arcsin，arccos，和arctan函数返回给定角度的sin，cos和tan的反三角函数。

示例：

import numpy as np

a = np.array([0, 30, 45, 60, 90])

b = np.sin(a * np.pi / 180)

c = np.cos(a * np.pi / 180)

d = np.tan(a * np.pi / 180)

print("a:", a)

print("b:", b)

print("c:", c)

print("d:", d)

# output:

# a: [ 0 30 45 60 90]

# b: [0. 0.5 0.70710678 0.8660254 1. ]

# c: [1.00000000e+00 8.66025404e-01 7.07106781e-01 5.00000000e-01

# 6.12323400e-17]

# d: [0.00000000e+00 5.77350269e-01 1.00000000e+00 1.73205081e+00

# 1.63312394e+16]

舍入函数

numpy.around() 这个函数返回四舍五入到所需精度的值。该函数接受以下参数：numpy.around(a,decimals)

其中：

序号	参数及描述
1.	a 输入数组
2.	decimals 要舍入的小数位数。默认值为0。如果为负，整数将四舍五入到小数点左侧的位置

示例：

import numpy as np

a = np.array([1.0, 5.55, 123, 0.567, 25.532])

b = np.around(a)

c = np.around(a, decimals=1)

d = np.around(a, decimals=-1)

print("a:", a)

print("b:", b)

print("c:", c)

print("d:", d)

# output:

# a: [ 1. 5.55 123. 0.567 25.532]

# b: [ 1. 6. 123. 1. 26.]

# c: [ 1. 5.6 123. 0.6 25.5]

# d: [ 0. 10. 120. 0. 30.]

numpy.floor() 此函数返回不大于输入参数的最大整数。即标量x 的下限是最大的整数i ，使得i <= x。注意在Python中，向下取整总是从 0 舍入。

numpy.ceil() 此函数返回输入值的上限，即，标量x的上限是最小的整数i ，使得i> = x。

示例：

import numpy as np

a = np.array([-1.7, 1.5, -0.2, 0.6, 10])

b = np.floor(a)

c = np.ceil(a)

print("a:", a)

print("b:", b)

print("c:", c)

# output:

# a: [-1.7 1.5 -0.2 0.6 10. ]

# b: [-2. 1. -1. 0. 10.]

# c: [-1. 2. -0. 1. 10.]

算数运算

用于执行算术运算（如add()，subtract()，multiply()和divide()）的输入数组必须具有相同的形状或符合数组广播规则。

示例：

import numpy as np

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

b = np.array([10, 10, 10])

c = np.add(a, b)

d = np.subtract(a, b)

e = np.multiply(a, b)

f = np.divide(a, b)

print("a:", a)

print("b:", b)

print("c:", c)

print("d:", d)

print("e:", e)

print("f:", f)

# output:

# a: [[0. 1. 2.]

# [3. 4. 5.]

# [6. 7. 8.]]

# b: [10 10 10]

# c: [[10. 11. 12.]

# [13. 14. 15.]

# [16. 17. 18.]]

# d: [[-10. -9. -8.]

# [ -7. -6. -5.]

# [ -4. -3. -2.]]

# e: [[ 0. 10. 20.]

# [30. 40. 50.]

# [60. 70. 80.]]

# f: [[0. 0.1 0.2]

# [0.3 0.4 0.5]

# [0.6 0.7 0.8]]

numpy.reciprocal() 此函数返回参数逐元素的倒数，由于 Python 处理整数除法的方式，对于绝对值大于 1 的整数元素，结果始终为 0，对于整数 0，则发出溢出警告。

示例：

import numpy as np

a = np.array([0.25, 1.33, 1, 0, 100])

b = np.reciprocal(a)

c = np.array([100], dtype=int)

d = np.reciprocal(c)

print("a:", a)

print("b:", b)

print("c:", c)

print("d:", d)

# output:

# F:/np_learn/demo.py:6: RuntimeWarning: divide by zero encountered in reciprocal

# a: [ 0.25 1.33 1. 0. 100. ]

# b = np.reciprocal(a)

# b: [4. 0.7518797 1. inf 0.01 ]

# c: [100]

# d: [0]

numpy.power() 此函数将第一个输入数组中的元素作为底数，计算它与第二个输入数组中相应元素的幂。

示例：

import numpy as np

a = np.array([10, 100, 1000])

b = np.power(a, 2)

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

d = np.power(a, c)

print("a:", a)

print("b:", b)

print("c:", c)

print("d:", d)

# output:

# a: [ 10 100 1000]

# b: [ 100 10000 1000000]

# c: [1 2 3]

# d: [ 10 10000 1000000000]

numpy.mod() 此函数返回输入数组中相应元素的除法余数。函数numpy.remainder()也产生相同的结果。

示例：

import numpy as np

a = np.array([10, 20, 30])

b = np.array([3, 5, 7])

c = np.mod(a, b)

d = np.remainder(a, b)

print("a:", a)

print("b:", b)

print("c:", c)

print("d:", d)

# output:

# a: [10 20 30]

# b: [3 5 7]

# c: [1 0 2]

# d: [1 0 2]

以下函数用于对含有复数的数组执行操作。

real()返回复数类型参数的实部。
imag()返回复数类型参数的虚部。
conj()返回通过改变虚部的符号而获得的共轭复数。
angle()返回复数参数的角度。函数的参数是degree。如果为true，返回的角度以角度制来表示，否则为以弧度制来表示。

示例：

import numpy as np

a = np.array([-5.6j, 0.2j, 11., 1 + 1j])

b = np.real(a)

c = np.imag(a)

d = np.conj(a)

e = np.angle(a)

f = np.angle(a, deg=True)

print("a:", a)

print("b:", b)

print("c:", c)

print("d:", d)

print("e:", e)

print("f:", f)

# output:

# a: [-0.-5.6j 0.+0.2j 11.+0. j 1.+1. j]

# b: [-0. 0. 11. 1.]

# c: [-5.6 0.2 0. 1. ]

# d: [-0.+5.6j 0.-0.2j 11.-0. j 1.-1. j]

# e: [-1.57079633 1.57079633 0. 0.78539816]

# f: [-90. 90. 0. 45.]

未完待续…

打赏作者

微信支付

支付宝

Python数据分析学习笔记：Numpy（二）

切片和索引

基本切片

高级索引

广播

数组上的迭代

迭代顺序

修改数组的值

外部循环

广播迭代

数组操作

修改形状

翻转操作

数组的连接

数组分割

添加/删除元素

位操作

字符串函数

算数函数

三角函数

舍入函数

算数运算

使用 Scikit-learn 的进行 KNN 分类

K-近邻算法KNN学习笔记

使用Prophet进行时间序列预测

发表评论取消回复

Python数据分析学习笔记：Numpy（二）

切片和索引

基本切片

高级索引

广播

数组上的迭代

迭代顺序

修改数组的值

外部循环

广播迭代

数组操作

修改形状

翻转操作

数组的连接

数组分割

添加/删除元素

位操作

字符串函数

算数函数

三角函数

舍入函数

算数运算

使用 Scikit-learn 的进行 KNN 分类

K-近邻算法KNN学习笔记

使用Prophet进行时间序列预测

发表评论 取消回复

发表评论取消回复