Nump基础学习_数组的属性、副本与视图、索引与切片

1. 数组的属性

1. numpy.ndarray.ndim 用于返回数组的维数（轴的个数）也称为秩，
   一维数组的秩为 1，二维数组的秩为 2，以此类推。
2. numpy.ndarray.shape 表示数组的维度，返回一个元组，
   这个元组的长度就是维度的数目，即 ndim 属性(秩)。
3. numpy.ndarray.size 数组中所有元素的总量，相当于数组的
   shape 中所有元素的乘积，例如矩阵的元素总量为行与列的乘积。
4. numpy.ndarray.dtype ndarray 对象的元素类型。
5. numpy.ndarray.itemsize 以字节的形式返回数组中每一个元素
   的大小

import numpy as np
b = np.array([[1, 2, 3], [4, 5, 6.0]])
print(b.shape) # (2, 3)
print(b.dtype) # float64
print(b.size) # 6
print(b.ndim) # 2
print(b.itemsize) # 8

注意：在 ndarray 中所有元素必须是同一类型，否则会自动向下转换， int->float->str

import numpy as np
a = np.array([1, 2, 3, 4, 5])
print(a) # [1 2 3 4 5]
b = np.array([1, 2, 3, 4, '5'])
print(b) # ['1' '2' '3' '4' '5']#结果全为字符型
c = np.array([1, 2, 3, 4, 5.0])
print(c) # [1. 2. 3. 4. 5.]

2.副本与视图

1. 在 Numpy 中，尤其是在做数组运算或数组操作时，返回结果不是
   数组的 副本就是视图。
2. 在 Numpy 中，所有赋值运算不会为数组和数组中的任何元素创建副本。

注意：numpy.ndarray.copy() 函数创建一个副本。 对副本数据进行修改，不会影响到原始数据，它们物理内存不在同一位置。

import numpy as np
x = np.array([1, 2, 3, 4, 5, 6, 7, 8])
y = x
y[0] = -1
print(x)# [-1 2 3 4 5 6 7 8]
print(y)# [-1 2 3 4 5 6 7 8]

x = np.array([1, 2, 3, 4, 5, 6, 7, 8])
y = x.copy()
y[0] = -1
print(x)# [1 2 3 4 5 6 7 8]
print(y)# [-1 2 3 4 5 6 7 8]

数组切片操作返回的对象只是原数组的视图

import numpy as np
x = 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]])
y = x
y[::2, :3:2] = -1
print(x)
#[[-1 12 -1 14 15]
#[16 17 18 19 20]
#[-1 22 -1 24 25]
#[26 27 28 29 30]
#[-1 32 -1 34 35]]
print(y)
#[[-1 12 -1 14 15]
#[16 17 18 19 20]
# [-1 22 -1 24 25]
#[26 27 28 29 30]
#[-1 32 -1 34 35]]

3.索引与切片

数组索引机制指的是用方括号（[]）加序号的形式引用单个数组元素，它
的用处很多，比如抽取元素，选取数组的几个元素，甚至为其赋一个新值。

3.1整数索引

注意：x[ , ]要比x[ ][ ]效率要高

x = 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(x[2]) # [21 22 23 24 25]
print(x[2][1]) # 22
print(x[2, 1]) # 22

3.2切片与索引

1. 切片操作是指抽取数组的一部分元素生成新数组。对 python 列表进行切片操作得到的数组是原数组的副本，而对 Numpy 数据进行切片操作得到的数组则是指向相同缓冲区的视图。
2. 如果想抽取（或查看）数组的一部分，必须使用切片语法，也就是，把几个用冒号（ start:stop:step ）隔开的数字置于方括号内。
3. 为了更好地理解切片语法，还应该了解不明确指明起始和结束位置的情况。如省去第一个数字，numpy 会认为第一个数字是0；如省去第二个
   数字，numpy 则会认为第二个数字是数组的最大索引值；如省去最后一个数字，它将会被理解为1，也就是抽取所有元素而不再考虑间隔。

对一位数组切片

import numpy as np
x = np.array([1, 2, 3, 4, 5, 6, 7, 8])
print(x[0:2]) # [1 2]
print(x[1:5:2]) # [2 4]

对二维数组切片

import numpy as np
x = 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(x[0:2])
# [[11 12 13 14 15]
# [16 17 18 19 20]]
print(x[::2, ::2])
# [[11 13 15]
# [21 23 25]
# [31 33 35]]

注意：通过对每个以逗号分隔的维度执行单独的切片，可以对多维数组进行切片。因此，对于二维数组，第一块定义了行的切片，第二块定义了列的切片。

3.3dots 索引

NumPy 允许使用 … 表示足够多的冒号来构建完整的索引列表。
比如，如果 x 是 5 维数组：

1. x[1,2,…] 等于 x[1,2,:,:,:]
2. x[…,3] 等于 x[:,:,:,:,3]
3. x[4,…,5,:] 等于 x[4,:,:,5,:]

3.4 整数数组索引

方括号内传入多个索引值，可以同时选择多个元素

import numpy as np
x = 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]])
r = [0, 1, -1]
print(x[r])
#[[11 12 13 14 15]
#[16 17 18 19 20]
#[31 32 33 34 35]]

numpy.take（a，indices，axis = None，out = None，mode =‘raise’ ）
沿轴取数组中的元素
当axis不是None时，此函数与“fancy”索引（使用数组索引数组）的功能相同; 但是，如果您需要沿给定轴的元素，则可以更容易使用

import numpy as np
x = 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]])
r = [0, 1, 2]
print(np.take(x, r, axis=0))
# [[11 12 13 14 15]
# [16 17 18 19 20]
# [21 22 23 24 25]]

r = [0, 1, 2]
c = [2, 3, 4]
y = np.take(x, [r, c])
print(y)
# [[11 12 13]
# [13 14 15]]

3.5布尔索引

import numpy as np
x = np.array([1, 2, 3, 4, 5, 6, 7, 8])
y = x > 5
print(y)
# [False False False False False True True True]
print(x[x > 5])
# [6 7 8]

4数组迭代

apply_along_axis(func1d, axis, arr)

import numpy as np
x = 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]])
y = np.apply_along_axis(np.sum, 0, x)
print(y) # [105 110 115 120 125]
y = np.apply_along_axis(np.sum, 1, x)
print(y) # [ 65 90 115 140 165]

def my_func(x):
return (x[0] + x[-1]) * 0.5
y = np.apply_along_axis(my_func, 0, x)
print(y) # [21. 22. 23. 24. 25.]
y = np.apply_along_axis(my_func, 1, x)
print(y) # [13. 18. 23. 28. 33.]