python numpy 快速入门

发表于 分类于 ，

Numpy是一个功能强大的Python库，允许更高级的数据操作和数学计算。

基础篇

理解 NumPy

Numpy是一个功能强大的Python库，允许更高级的数据操作和数学计算。

什么是 NumPy?

NumPy来源于两个单词 Numerical和Python，是一个功能强大的Python库，主要用于对多维数组执行计算。

NumPy 的安装

pip install numpy

NumPy 中的数组

NumPy提供的最重要的数据结构是一个称为NumPy数组的强大对象。NumPy数组是通常的Python数组的扩展。NumPy数组配备了大量的函数和运算符，可以帮助我们快速编写各种类型计算的高性能代码。

一维Numpy数组定义
1
2
3
4
5
>>> import numpy as np

>>> my_array = np.array([1, 2, 3, 4, 5])
>>> print(my_array)
[1 2 3 4 5]
创建指定个数元素为0的数组(np.zeros)
1
2
3
4
5
6
7
>>> import numpy as np

>>> np.zeros(5)
array([0., 0., 0., 0., 0.])

>>> print(np.zeros(5))
[0. 0. 0. 0. 0.]
创建指定个数元素为1的数组(np.ones)
1
2
3
4
5
6
7
>>> import numpy as np

>>> np.ones(5)
array([1., 1., 1., 1., 1.])

>>> print(np.ones(5))
[1. 1. 1. 1. 1.]
创建指定个数元素为n的数组(np.full)
1
2
3
4
5
6
7
>>> import numpy as np

>>> np.full(5, 2)
array([2, 2, 2, 2, 2])

>>> print(np.full(5, 2))
[2 2 2 2 2]
创建单位矩阵(np.eye)
1
2
3
4
5
6
>>> np.eye(5)
array([[1., 0., 0., 0., 0.],
       [0., 1., 0., 0., 0.],
       [0., 0., 1., 0., 0.],
       [0., 0., 0., 1., 0.],
       [0., 0., 0., 0., 1.]])

NumPy中的数组操作

使用NumPy，你可以轻松地在数组上执行数学运算。例如，你可以添加NumPy数组，你可以减去它们，你可以将它们相乘，甚至可以将它们分开。 以下是一些例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import numpy as np 

a = np.array([[1.0, 2.0], [3.0, 4.0]]) 
b = np.array([[5.0, 6.0], [7.0, 8.0]]) 
sum = a + b 
difference = a - b 
product = a * b 
quotient = a / b 
print "Sum = \n", sum 
print "Difference = \n", difference 
print "Product = \n", product 
print "Quotient = \n", quotient 

# The output will be as follows: 

Sum = [[ 6. 8.] [10. 12.]]
Difference = [[-4. -4.] [-4. -4.]]
Product = [[ 5. 12.] [21. 32.]]
Quotient = [[0.2 0.33333333] [0.42857143 0.5 ]]

如你所见，乘法运算符执行逐元素乘法而不是矩阵乘法。 要执行矩阵乘法，你可以执行以下操作：

1
2
matrix_product = a.dot(b) 
print "Matrix Product = ", matrix_product

输出将是：

1
2
[[19. 22.]
[43. 50.]]

NumPy 简单入门教程

数组基础

创建一个数组
1
2
3
4
5
6
7
8
9
10
11
# 1D Array
a = np.array([0, 1, 2, 3, 4])
b = np.array((0, 1, 2, 3, 4))
c = np.arange(5)
d = np.linspace(0, 2*np.pi, 5)

print(a) # >>>[0 1 2 3 4]
print(b) # >>>[0 1 2 3 4]
print(c) # >>>[0 1 2 3 4]
print(d) # >>>[ 0.          1.57079633  3.14159265  4.71238898  6.28318531]
print(a[3]) # >>>3
1
2
3
4
5
6
7
8
# MD Array,
a = np.array([[11, 12, 13, 14, 15],
              [16, 17, 18, 19, 20],
              [21, 22, 23, 24, 25],
              [26, 27, 28 ,29, 30],
              [31, 32, 33, 34, 35]])
 
print(a[2,4]) # >>>25
多维数组切片
1
2
3
4
5
6
7
# MD slicing
print(a[0, 1:4]) # >>>[12 13 14]
print(a[1:4, 0]) # >>>[16 21 26]
print(a[::2,::2]) # >>>[[11 13 15]
                  #     [21 23 25]
                  #     [31 33 35]]
print(a[:, 1]) # >>>[12 17 22 27 32]
数组属性
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# Array properties
a = np.array([[11, 12, 13, 14, 15],
              [16, 17, 18, 19, 20],
              [21, 22, 23, 24, 25],
              [26, 27, 28 ,29, 30],
              [31, 32, 33, 34, 35]])

print(type(a)) # >>><class 'numpy.ndarray'>
print(a.dtype) # >>>int64
print(a.size) # >>>25
print(a.shape) # >>>(5, 5)
print(a.itemsize) # >>>8
print(a.ndim) # >>>2
print(a.nbytes) # >>>200

# dtype 数据类型
# size 数组元素的个数
# shape 数组行数和列数
# itemsize 每个项占用的字节数
# ndim 数组的维数
# nbytes 数组中的所有数据消耗掉的字节数，实际开销将稍大。

使用数组

基本操作符
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# Basic Operators
a = np.arange(25)
a = a.reshape((5, 5))

b = np.array([10, 62, 1, 14, 2, 56, 79, 2, 1, 45,
              4, 92, 5, 55, 63, 43, 35, 6, 53, 24,
              56, 3, 56, 44, 78])
b = b.reshape((5,5))

print(a + b)
print(a - b)
print(a * b)
print(a / b)
print(a ** 2)
print(a < b) print(a > b)

print(a.dot(b))

除了 dot() 之外，这些操作符都是对数组进行逐元素运算。比如 (a, b, c) + (d, e, f) 的结果就是 (a+d, b+e, c+f)。它将分别对每一个元素进行配对，然后对它们进行运算。它返回的结果是一个数组。注意，当使用逻辑运算符比如 “<” 和 “>” 的时候，返回的将是一个布尔型数组。

dot() 函数计算两个数组的点积。它返回的是一个标量（只有大小没有方向的一个值）而不是数组。

数组特殊运算符
1
2
3
4
5
6
7
8
9
10
11
12
# dot, sum, min, max, cumsum
a = np.arange(10)

print(a.sum()) # >>>45
print(a.min()) # >>>0
print(a.max()) # >>>9
print(a.cumsum()) # >>>[ 0  1  3  6 10 15 21 28 36 45]

# sum() 所有元素相加
# min() 最小元素
# max() 最大元素
# cumsum() 将第一个元素和第二个元素相加，并将计算结果存储在一个列表中，然后将该结果添加到第三个元素中，然后再将该结果存储在一个列表中。这将对数组中的所有元素执行此操作，并返回作为列表的数组之和的运行总数。

索引进阶

花式索引(Fancy indexing)
1
2
3
4
5
6
# Fancy indexing
a = np.arange(0, 100, 10)
indices = [1, 5, -1]
b = a[indices]
print(a) # >>>[ 0 10 20 30 40 50 60 70 80 90]
print(b) # >>>[10 50 90]
布尔屏蔽(Boolean masking)

布尔屏蔽是一个有用的功能，它允许我们根据我们指定的条件检索数组中的元素

1
2
3
4
5
6
7
8
9
10
11
# Boolean masking
import matplotlib.pyplot as plt

a = np.linspace(0, 2 * np.pi, 50)
b = np.sin(a)
plt.plot(a,b)
mask = b >= 0
plt.plot(a[mask], b[mask], 'bo')
mask = (b >= 0) & (a <= np.pi / 2)
plt.plot(a[mask], b[mask], 'go')
plt.show()

位运算符:

& 按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 (a & b) 输出结果 12 ，二进制解释： 0000 1100
| 按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。 (a | b) 输出结果 61 ，二进制解释： 0011 1101
^ 按位异或运算符：当两对应的二进位相异时，结果为1 (a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~ 按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1 。~x 类似于 -x-1 (~a ) 输出结果 -61 ，二进制解释： 1100 0011，在一个有符号二进制数的补码形式。
<< 左移动运算符：运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补0。 a << 2 输出结果 240 ，二进制解释： 1111 0000
>> 右移动运算符：把”>>”左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数 a >> 2 输出结果 15 ，二进制解释： 0000 1111
缺省索引(Incomplete Indexing)
1
2
3
4
5
6
# Incomplete Indexing
a = np.arange(0, 100, 10)
b = a[:5]
c = a[a >= 50]
print(b) # >>>[ 0 10 20 30 40]
print(c) # >>>[50 60 70 80 90]
Where 函数
1
2
3
4
5
6
# Where
a = np.arange(0, 100, 10)
b = np.where(a < 50) 
c = np.where(a >= 50)[0]
print(b) # >>>(array([0, 1, 2, 3, 4]),)
print(c) # >>>[5 6 7 8 9]

Python、Numpy 教程

数组(Arrays)

numpy数组是一个值网格，所有类型都相同，并由非负整数元组索引。

维数是数组的排名;

数组的形状是一个整数元组，给出了每个维度的数组大小。

Numpy还提供了许多创建数组的函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import numpy as np

a = np.zeros((2,2))   # Create an array of all zeros
print(a)              # Prints "[[ 0.  0.]
                      #          [ 0.  0.]]"

b = np.ones((1,2))    # Create an array of all ones
print(b)              # Prints "[[ 1.  1.]]"

c = np.full((2,2), 7)  # Create a constant array
print(c)               # Prints "[[ 7.  7.]
                       #          [ 7.  7.]]"

d = np.eye(2)         # Create a 2x2 identity matrix
print(d)              # Prints "[[ 1.  0.]
                      #          [ 0.  1.]]"

e = np.random.random((2,2))  # Create an array filled with random values
print(e)                     # Might print "[[ 0.91940167  0.08143941]
                             #               [ 0.68744134  0.87236687]]"

数组索引

切片(Slicing)

与Python列表类似，可以对numpy数组进行切片。由于数组可能是多维的，因此必须为数组的每个维指定一个切片

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import numpy as np

# Create the following rank 2 array with shape (3, 4)
# [[ 1  2  3  4]
#  [ 5  6  7  8]
#  [ 9 10 11 12]]
a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])

# Use slicing to pull out the subarray consisting of the first 2 rows
# and columns 1 and 2; b is the following array of shape (2, 2):
# [[2 3]
#  [6 7]]
b = a[:2, 1:3]

# A slice of an array is a view into the same data, so modifying it
# will modify the original array.
print(a[0, 1])   # Prints "2"
b[0, 0] = 77     # b[0, 0] is the same piece of data as a[0, 1]
print(a[0, 1])   # Prints "77"
整数数组索引

使用切片索引到numpy数组时，生成的数组视图将始终是原始数组的子数组。 相反，整数数组索引允许你使用另一个数组中的数据构造任意数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import numpy as np

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

# An example of integer array indexing.
# The returned array will have shape (3,) and
print(a[[0, 1, 2], [0, 1, 0]])  # Prints "[1 4 5]"

# The above example of integer array indexing is equivalent to this:
print(np.array([a[0, 0], a[1, 1], a[2, 0]]))  # Prints "[1 4 5]"

# When using integer array indexing, you can reuse the same
# element from the source array:
print(a[[0, 0], [1, 1]])  # Prints "[2 2]"

# Equivalent to the previous integer array indexing example
print(np.array([a[0, 1], a[0, 1]]))  # Prints "[2 2]"

整数数组索引的一个有用技巧是从矩阵的每一行中选择或改变一个元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import numpy as np

# Create a new array from which we will select elements
a = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])

print(a)  # prints "array([[ 1,  2,  3],
          #                [ 4,  5,  6],
          #                [ 7,  8,  9],
          #                [10, 11, 12]])"

# Create an array of indices
b = np.array([0, 2, 0, 1])

# Select one element from each row of a using the indices in b
print(a[np.arange(4), b])  # Prints "[ 1  6  7 11]"

# Mutate one element from each row of a using the indices in b
a[np.arange(4), b] += 10

print(a)  # prints "array([[11,  2,  3],
          #                [ 4,  5, 16],
          #                [17,  8,  9],
          #                [10, 21, 12]])
布尔数组索引

布尔数组索引允许你选择数组的任意元素。通常，这种类型的索引用于选择满足某些条件的数组元素。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import numpy as np

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

bool_idx = (a > 2)   # Find the elements of a that are bigger than 2;
                     # this returns a numpy array of Booleans of the same
                     # shape as a, where each slot of bool_idx tells
                     # whether that element of a is > 2.

print(bool_idx)      # Prints "[[False False]
                     #          [ True  True]
                     #          [ True  True]]"

# We use boolean array indexing to construct a rank 1 array
# consisting of the elements of a corresponding to the True values
# of bool_idx
print(a[bool_idx])  # Prints "[3 4 5 6]"

# We can do all of the above in a single concise statement:
print(a[a > 2])     # Prints "[3 4 5 6]"
数组中的数学

基本数学函数在数组上以元素方式运行，既可以作为运算符重载，也可以作为numpy模块中的函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import numpy as np

x = np.array([[1,2],[3,4]], dtype=np.float64)
y = np.array([[5,6],[7,8]], dtype=np.float64)

# Elementwise sum; both produce the array
# [[ 6.0  8.0]
#  [10.0 12.0]]
print(x + y)
print(np.add(x, y))

# Elementwise difference; both produce the array
# [[-4.0 -4.0]
#  [-4.0 -4.0]]
print(x - y)
print(np.subtract(x, y))

# Elementwise product; both produce the array
# [[ 5.0 12.0]
#  [21.0 32.0]]
print(x * y)
print(np.multiply(x, y))

# Elementwise division; both produce the array
# [[ 0.2         0.33333333]
#  [ 0.42857143  0.5       ]]
print(x / y)
print(np.divide(x, y))

# Elementwise square root; produces the array
# [[ 1.          1.41421356]
#  [ 1.73205081  2.        ]]
print(np.sqrt(x))

Numpy为在数组上执行计算提供了许多有用的函数；其中最有用的函数之一是 SUM：

1
2
3
4
5
6
7
import numpy as np

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

print(np.sum(x))  # Compute sum of all elements; prints "10"
print(np.sum(x, axis=0))  # Compute sum of each column; prints "[4 6]"
print(np.sum(x, axis=1))  # Compute sum of each row; prints "[3 7]"

你可以在这篇文档中找到numpy提供的数学函数的完整列表。

除了使用数组计算数学函数外，我们经常需要对数组中的数据进行整形或其他操作。这种操作的最简单的例子是转置一个矩阵；要转置一个矩阵，只需使用一个数组对象的T属性：

1
2
3
4
5
6
7
8
9
10
11
12
import numpy as np

x = np.array([[1,2], [3,4]])
print(x)    # Prints "[[1 2]
            #          [3 4]]"
print(x.T)  # Prints "[[1 3]
            #          [2 4]]"

# Note that taking the transpose of a rank 1 array does nothing:
v = np.array([1,2,3])
print(v)    # Prints "[1 2 3]"
print(v.T)  # Prints "[1 2 3]"
广播(Broadcasting)

广播是一种强大的机制，它允许numpy在执行算术运算时使用不同形状的数组。通常，我们有一个较小的数组和一个较大的数组，我们希望多次使用较小的数组来对较大的数组执行一些操作

例如，假设我们要向矩阵的每一行添加一个常数向量。我们可以这样做：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import numpy as np

# We will add the vector v to each row of the matrix x,
# storing the result in the matrix y
x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])
v = np.array([1, 0, 1])
y = np.empty_like(x)   # Create an empty matrix with the same shape as x

# Add the vector v to each row of the matrix x with an explicit loop
for i in range(4):
    y[i, :] = x[i, :] + v

# Now y is the following
# [[ 2  2  4]
#  [ 5  5  7]
#  [ 8  8 10]
#  [11 11 13]]
print(y)

这会凑效; 但是当矩阵 x 非常大时，在Python中计算显式循环可能会很慢。注意，向矩阵 x 的每一行添加向量 v 等同于通过垂直堆叠多个 v 副本来形成矩阵 vv，然后执行元素的求和x 和 vv。 我们可以像如下这样实现这种方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import numpy as np

# We will add the vector v to each row of the matrix x,
# storing the result in the matrix y
x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])
v = np.array([1, 0, 1])
vv = np.tile(v, (4, 1))   # Stack 4 copies of v on top of each other
print(vv)                 # Prints "[[1 0 1]
                          #          [1 0 1]
                          #          [1 0 1]
                          #          [1 0 1]]"
y = x + vv  # Add x and vv elementwise
print(y)  # Prints "[[ 2  2  4
          #          [ 5  5  7]
          #          [ 8  8 10]
          #          [11 11 13]]"

Numpy广播允许我们在不实际创建v的多个副本的情况下执行此计算。考虑这个需求，使用广播如下：

1
2
3
4
5
6
7
8
9
10
11
import numpy as np

# We will add the vector v to each row of the matrix x,
# storing the result in the matrix y
x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])
v = np.array([1, 0, 1])
y = x + v  # Add v to each row of x using broadcasting
print(y)  # Prints "[[ 2  2  4]
          #          [ 5  5  7]
          #          [ 8  8 10]
          #          [11 11 13]]"

y=x+v行即使x具有形状(4，3)和v具有形状(3,)，但由于广播的关系，该行的工作方式就好像v实际上具有形状(4，3)，其中每一行都是v的副本，并且求和是按元素执行的。

将两个数组一起广播遵循以下规则：

  1. 如果数组不具有相同的rank，则将较低等级数组的形状添加1，直到两个形状具有相同的长度。
  2. 如果两个数组在维度上具有相同的大小，或者如果其中一个数组在该维度中的大小为1，则称这两个数组在维度上是兼容的。
  3. 如果数组在所有维度上兼容，则可以一起广播。
  4. 广播之后，每个数组的行为就好像它的形状等于两个输入数组的形状的元素最大值。
  5. 在一个数组的大小为1且另一个数组的大小大于1的任何维度中，第一个数组的行为就像沿着该维度复制一样

创建 Numpy 数组的不同方式

创建Numpy数组有三种不同的方法：

  1. 使用Numpy内部功能函数
  2. 从列表等其他Python的结构进行转换
  3. 使用特殊的库函数

使用Numpy内部功能函数

Numpy具有用于创建数组的内置函数。

创建一个一维的数组
1
2
import Numpy as np
array = np.arange(20)
创建一个二维数组
1
2
import Numpy as np
array = np.arange(20).reshap(4,5)
创建三维数组及更多维度
1
2
import Numpy as np
array = np.arange(27).reshap(3,3,3)
创建一个填充零的数组
1
2
import numpy as np
array = np.zeros((2,4))
创建一个填充1的数组
1
2
import numpy as np
array = np.ones((2,4))
创建一个空的数组

它的初始内容是随机的，取决于内存的状态

1
2
import numpy as np
array = np.empty((2,3))
创建一个填充给定值的数组
1
2
import numpy as np
array = np.full((2,2), 3)

创建一个单位矩阵

1
2
import numpy as np
array = np.eye(3)
创建指定的时间间隔的数组
1
2
import numpy as np
array = np.linspace(0, 10, num=4)

从Python列表转换

1
2
3
import numpy as np
array1 = np.array([4,5,6])
array2 = np.array([(1,2,3), (4,5,6)])

使用特殊的库函数

1
2
import numpy as np
array = np.random.random((2,2))

进阶篇

NumPy数据分析问答

导入numpy作为np，并查看版本

1
2
3
4
5
import numpy as np

np.__version__

# '1.15.4'

如何创建一维数组

1
2
3
arr = np.arange(10)

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

如何创建一个布尔数组

1
2
3
4
5
6
7
8
9
10
# 创建一个numpy数组元素值全为True（真）的数组

np.full((3, 3), True, dtype=bool)

# > array([[ True,  True,  True],
# >        [ True,  True,  True],
# >        [ True,  True,  True]], dtype=bool)

# Alternate method:
np.ones((3,3), dtype=bool)

如何从一维数组中提取满足指定条件的元素？

1
2
3
4
5
6
# 从 arr 中提取所有的奇数

arr = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
arr[arr % 2 == 1]

#  array([1, 3, 5, 7, 9])

如何用numpy数组中的另一个值替换满足条件的元素项？

1
2
3
4
5
6
# 将arr中的所有奇数替换为-1

arr = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
arr[arr % 2 == 1] = -1

# array([ 0, -1,  2, -1,  4, -1,  6, -1,  8, -1])

如何在不影响原始数组的情况下替换满足条件的元素项？

1
2
3
4
5
6
7
# 将arr中的所有奇数替换为-1，而不改变arr

arr =  np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
out = np.where(arr % 2 ==1, -1, arr)
print(out)

# [ 0 -1  2 -1  4 -1  6 -1  8 -1]

如何改变数组的形状？

1
2
3
4
5
6
7
# 将一维数组转换为2行的2维数组

arr = np.arange(10)
arr.reshape(2, -1)  # Setting to -1 automatically decides the number of cols

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

如何垂直叠加两个数组？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 垂直堆叠数组a和数组b
a = np.arange(10).reshape(2,-1)
b = np.repeat(1, 10).reshape(2,-1)

# Answers
# Method 1:
np.concatenate((a, b), axis=0)

# Method 2:
np.vstack((a, b))

# Method 3:
np.r_[a, b]

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

如何水平叠加两个数组?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 将数组a和数组b水平堆叠
a = np.arange(10).reshape(2,-1)
b = np.repeat(1, 10).reshape(2,-1)

# Answers
# Method 1:
np.concatenate((a, b), axis=1)

# Method 2:
np.hstack((a, b))

# Method 3:
np.c_[a, b]

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

如何在无硬编码的情况下生成numpy中的自定义序列？

1
2
3
4
5
6
7
8
9
10
11
12
13
# 创建以下模式而不使用硬编码。只使用numpy函数和下面的输入数组a。
# 给定：
#   a = np.array([1,2,3])
# 期望的输出：
#   array([1, 1, 1, 2, 2, 2, 3, 3, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3])

# Method 1:
np.r_[np.repeat(a, 3), np.tile(a, 3)]

# Method 2:
np.concatenate((np.repeat(a, 3), np.tile(a, 3)), axis=0)

# array([1, 1, 1, 2, 2, 2, 3, 3, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3])

如何获取两个numpy数组之间的公共项？

1
2
3
4
5
6
7
8
9
10
11
12
# 获取数组a和数组b之间的公共项。
# 给定：
# a = np.array([1,2,3,2,3,4,3,4,5,6])
# b = np.array([7,2,10,2,7,4,9,4,9,8])
# 期望的输出：
# array([2, 4])

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

# array([2, 4])

如何从一个数组中删除存在于另一个数组中的项？

1
2
3
4
5
6
7
8
9
10
11
12
13
# 从数组a中删除数组b中的所有项
# 给定：
# a = np.array([1,2,3,4,5])
# b = np.array([5,6,7,8,9])
# 期望的输出：
# array([1,2,3,4])

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

# From 'a' remove all of 'b'
np.setdiff1d(a,b)
# array([1, 2, 3, 4])

如何得到两个数组元素匹配的位置？

1
2
3
4
5
6
7
8
9
10
11
12
# 获取a和b元素匹配的位置。
# 给定：
# a = np.array([1,2,3,2,3,4,3,4,5,6])
# b = np.array([7,2,10,2,7,4,9,4,9,8])
# 期望的输出：
# (array([1, 3, 5, 7]),)

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

np.where(a == b)
# > (array([1, 3, 5, 7]),)

如何从numpy数组中提取给定范围内的所有数字？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 获取5到10之间的所有项目。
# 给定：
# a = np.array([2, 6, 1, 9, 10, 3, 27])
# 期望的输出：
# (array([6, 9, 10]),)

# Method 1:
index = np.where((a >= 5 & a <= 10))
a[index]

# Method 2:
a[np.where(np.logical_and(a>=5, a<=10))]

# Method 3:
a[(a >= 5) & (a <= 10)]

# Method 4:
a[np.logical_and(a >= 5, a <= 10)]

如何创建一个python函数来处理scalars并在numpy数组上工作？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
# 转换适用于两个标量的函数maxx，以处理两个数组。
# 给定：
# def maxx(x, y):
#    """Get the maximum of two items"""
#    if x >= y:
#        return x
#    else:
#        return y
# maxx(1, 5)
# > 5
# 期望的输出：
# a = np.array([5, 7, 9, 8, 6, 4, 5])
# b = np.array([6, 3, 4, 8, 9, 7, 1])
# pair_max(a, b)
# > array([ 6.,  7.,  9.,  8.,  9.,  7.,  5.])

def maxx(x, y):
    """Get the maximum of two items"""
    if x >= y:
        return x
    else:
        return y

pair_max = np.vectorize(maxx, otypes=[float])

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

pair_max(a, b)
# > array([ 6.,  7.,  9.,  8.,  9.,  7.,  5.])

如何交换二维numpy数组中的两列？

1
2
3
4
5
6
7
8
9
10
11
12
# 在数组arr中交换列1和2。

# Input
arr = np.arange(9).reshape(3,3)
arr

# Solution
arr[:, [1,0,2]]

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

如何交换二维numpy数组中的两行？

1
2
3
4
5
6
7
8
9
10
# 交换数组arr中的第1和第2行

# Input
arr = np.arange(9).reshape(3,3)

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

如何反转二维数组的行？

1
2
3
4
5
6
7
8
9
10
# 反转二维数组arr的行。

# Input
arr = np.arange(9).reshape(3,3)

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

如何反转二维数组的列

1
2
3
4
5
6
7
8
9
10
# 反转二维数组arr的列

# Input
arr = np.arange(9).reshape(3,3)

# Solution
arr[:, ::-1]
# > array([[2, 1, 0],
# >        [5, 4, 3],
# >        [8, 7, 6]])

如何创建包含5到10之间随机浮动的二维数组？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 创建一个形状为5x3的二维数组，以包含5到10之间的随机十进制数。
# Input
arr = np.arange(9).reshape(3,3)

# Solution Method 1:
rand_arr = np.random.randint(low=5, high=10, size=(5,3)) + np.random.random((5,3))
# print(rand_arr)

# Solution Method 2:
rand_arr = np.random.uniform(5,10, size=(5,3))
print(rand_arr)
# > [[ 8.50061025  9.10531502  6.85867783]
# >  [ 9.76262069  9.87717411  7.13466701]
# >  [ 7.48966403  8.33409158  6.16808631]
# >  [ 7.75010551  9.94535696  5.27373226]
# >  [ 8.0850361   5.56165518  7.31244004]]

如何在numpy数组中只打印小数点后三位？

只打印或显示numpy数组rand_arr的小数点后3位。

给定：

1
rand_arr = np.random.random((5,3))

答案：

1
2
3
4
5
6
7
8
9
10
11
12
13
# Input
rand_arr = np.random.random((5,3))

# Create the random array
rand_arr = np.random.random([5,3])

# Limit to 3 decimal places
np.set_printoptions(precision=3)
rand_arr[:4]
# > array([[ 0.443,  0.109,  0.97 ],
# >        [ 0.388,  0.447,  0.191],
# >        [ 0.891,  0.474,  0.212],
# >        [ 0.609,  0.518,  0.403]])

如何通过e式科学记数法（如1e10）来打印一个numpy数组？

问题：通过e式科学记数法来打印rand_arr（如1e10）

给定：

1
2
3
4
5
6
7
8
# Create the random array
np.random.seed(100)
rand_arr = np.random.random([3,3])/1e3
rand_arr

# > array([[  5.434049e-04,   2.783694e-04,   4.245176e-04],
# >        [  8.447761e-04,   4.718856e-06,   1.215691e-04],
# >        [  6.707491e-04,   8.258528e-04,   1.367066e-04]])

期望的输出：

1
2
3
# > array([[ 0.000543,  0.000278,  0.000425],
# >        [ 0.000845,  0.000005,  0.000122],
# >        [ 0.000671,  0.000826,  0.000137]])

答案：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# Reset printoptions to default
np.set_printoptions(suppress=False)

# Create the random array
np.random.seed(100)
rand_arr = np.random.random([3,3])/1e3
rand_arr
# > array([[  5.434049e-04,   2.783694e-04,   4.245176e-04],
# >        [  8.447761e-04,   4.718856e-06,   1.215691e-04],
# >        [  6.707491e-04,   8.258528e-04,   1.367066e-04]])
np.set_printoptions(suppress=True, precision=6)  # precision is optional
rand_arr
# > array([[ 0.000543,  0.000278,  0.000425],
# >        [ 0.000845,  0.000005,  0.000122],
# >        [ 0.000671,  0.000826,  0.000137]])

其他篇

-------------本文结束感谢您的阅读-------------