NumPy学习笔记

code
numpy
python
NumPy基础操作、数组运算、广播机制等核心功能的学习记录。
发布于

2026年8月14日

Numpy学习

代码 
import numpy as np
print(np.__version__)
1.23.5
代码 
# 设定数组
a = np.array([1, 2, 3])
b = np.array([
    [1, 2],
    [3, 4]
])
print(a)
print("*"*10)
print(b)
[1 2 3]
**********
[[1 2]
 [3 4]]
代码 
# 设置最小维数
a = np.array([1, 2, 3, 4, 5], ndmin =  4)  
print(a)
print(a.shape)
[[[[1 2 3 4 5]]]]
(1, 1, 1, 5)
代码 
# dtype参数
a = np.array([1 + 2j,  2,  3], dtype = complex)  
print (a)
[1.+2.j 2.+0.j 3.+0.j]
代码 
# 转换dtype参数
b = np.dtype(int)
print(b)
# int8, int16, int32, int64 可以用字符串'i1', 'i2', 'i4', 'i8'代替
int32
代码 
# 首先创建结构化数据类型
student_dtype=np.dtype(
[
    ('name','U10'),
    ('age','i4'),
    ('score','f4')
]
)
print(student_dtype)
print("*"*20)
# 创建变量，因为前面设定的新的数据类型，这样各变量之间数据类型就很清楚了
data=np.array(
[
    ('Tom',20,90.5),
    ('Bob',21,88)
],
dtype=student_dtype
)
# 读取某一个类型
print(data['name'])
[('name', '<U10'), ('age', '<i4'), ('score', '<f4')]
********************
['Tom' 'Bob']
代码 
# ndarray.ndim 查看维度
a = np.arange(24)
print(a.ndim)
b = a.reshape(2, 4 ,3) # reshape可以调整数组大小，要求总元素量保持不变
print(b.ndim)
1
3
代码 
# ndarray.shape 查看形状
print(a.shape)
print(b.shape)
(24,)
(2, 4, 3)
代码 
# ndarray.itemsize 以字节的形式返回数组中每一个元素的大小
# 数组的 dtype 为 int8（一个字节）  
x = np.array([1,2,3,4,5], dtype = np.int8)  
print (x.itemsize)
# 数组的 dtype 现在为 float64（八个字节） 
y = np.array([1,2,3,4,5], dtype = np.float64)  
print (y.itemsize)
1
8
代码 
# numpy.empty 创建一个未初始化数组
x = np.empty([3,2], dtype = np.float32) 
print (x) # 输出结果为随机值，因为还未初始化
[[0.    1.875]
 [0.    2.   ]
 [0.    2.125]]
代码 
# numpy.zeros 创建指定大小的数组，数组元素以 0 来填充：
x = np.zeros((5, 3))     
print(x)
# numpy.ones 一样的意思
[[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]
代码 
# numpy.zeros_like 用于创建一个与给定数组具有相同形状的数组，数组元素以 0 来填充
a = np.arange(12).reshape(2, 2, 3)
b = np.zeros_like(a)
print(b)
# numpy.ones_like 一样的意思
[[[0 0 0]
  [0 0 0]]

 [[0 0 0]
  [0 0 0]]]
代码 
# np.asarray可以将已有的列表，元组等转为ndarray
x = [1, 2, 3] # 列表
a = np.asarray(x)
print(a)
print("*"*20)
x = (1, 2, 3) # 元组
a = np.asarray(x)
print(a)
print("*"*20)
x =  [(1,2,3),(4,5)] # 元组列表
a = np.asarray(x)  
print (a)
[1 2 3]
********************
[1 2 3]
********************
[(1, 2, 3) (4, 5)]
C:\Users\13422\AppData\Local\Temp\ipykernel_2320\1205389202.py:11: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.
  a = np.asarray(x)
代码 
# numpy.frombuffer用于实现动态数组
s =  b'Hello World' 
a = np.frombuffer(s, dtype =  'S1')  
print (a)
[b'H' b'e' b'l' b'l' b'o' b' ' b'W' b'o' b'r' b'l' b'd']
代码 
# numpy.fromiter 方法从可迭代对象中建立 ndarray 对象，返回一维数组。
# 使用 range 函数创建列表对象  
list=range(5)
it=iter(list)  # iter是py自带的迭代器，放入后，next(it)输出0，再next(it)输出1
 
# 使用迭代器创建 ndarray 
x=np.fromiter(it, dtype=float)
print(x)
[0. 1. 2. 3. 4.]
代码 
# numpy.arange创建数值范围并返回 ndarray 对象   np.arange(start, end, step, dtype)
x = np.arange(5)  
print (x)
x = np.arange(10,20,2)  
print (x)
[0 1 2 3 4]
[10 12 14 16 18]
代码 
# numpy.linspace用于创建一个一维数组，数组是一个等差数列构成的  np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
a = np.linspace(1,10,10)
print(a)
print("*"*20)
a = np.linspace(1,1,10)
print(a)
print("*"*20)
a = np.linspace(10, 20,  5, endpoint = False)   # 将 endpoint 设为 false，不包含终止值
print(a)
print("*"*20)
a = np.linspace(10, 20,  5, endpoint = True, retstep= True)   # retstep= True 可以看到间距
print(a)
[ 1.  2.  3.  4.  5.  6.  7.  8.  9. 10.]
********************
[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
********************
[10. 12. 14. 16. 18.]
********************
(array([10. , 12.5, 15. , 17.5, 20. ]), 2.5)
代码 
# numpy.logspace 函数用于创建一个于等比数列   np.logspace(start, stop, num, endpoint=True, base=10.0, dtype=None)
a = np.logspace(1.0, 2.0, 10)   # 默认底数是10    1.0 = 10, 2.0 = 10^2 = 100
print (a)
a = np.logspace(0, 9, 10, base=2) # 将对数的底数设置为 2
print (a)
[ 10.          12.91549665  16.68100537  21.5443469   27.82559402
  35.93813664  46.41588834  59.94842503  77.42636827 100.        ]
[  1.   2.   4.   8.  16.  32.  64. 128. 256. 512.]
代码 
# slice 切割出一个新的数组
a = np.arange(10)
s = slice(2,7,2)   # 从索引 2 开始到索引 7 停止，间隔为2
print (a[s])
print("*"*20)

# 实际上没有必要这么麻烦
a = np.arange(10)  
b = a[2:7:1]   # 从索引 2 开始到索引 7 停止，间隔为 1
print(b)
print("*"*20)

# 多维数组
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print(a)
# 从某个索引处开始切割
print('从数组索引 a[1:] 处开始切割')
print(a[1:])
print("*"*20)

#切片还可以包括省略号 …，来使选择元组的长度与数组的维度相同。
print (a[...,1])   # 第2列元素
[2 4 6]
********************
[2 3 4 5 6]
********************
[[1 2 3]
 [3 4 5]
 [4 5 6]]
从数组索引 a[1:] 处开始切割
[[3 4 5]
 [4 5 6]]
********************
[2 4 5]
代码 
# 整数数组索引是指使用一个数组来访问另一个数组的元素。这个数组中的每个元素都是目标数组中某个维度上的索引值。
# 以下实例获取数组中 (0,0)，(1,1) 和 (2,0) 位置处的元素。
x = np.array([[1,  2],  [3,  4],  [5,  6]]) 
y = x[[0,1,2],  [0,1,0]]  
print (y)
print("*"*20)

x = np.array([[  0,  1,  2],[  3,  4,  5],[  6,  7,  8],[  9,  10,  11]])  
print ('我们的数组是：' )
print (x)
print ('\n')
rows = np.array([[0,0],[3,3]]) 
cols = np.array([[0,2],[0,2]]) 
y = x[rows,cols]  
print  ('这个数组的四个角元素是：')
print (y)
[1 4 5]
********************
我们的数组是：
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]


这个数组的四个角元素是：
[[ 0  2]
 [ 9 11]]
代码 
# 布尔索引
x = np.array([[  0,  1,  2],[  3,  4,  5],[  6,  7,  8],[  9,  10,  11]])  
print ('我们的数组是：')
print (x)
print ('\n')
# 现在我们会打印出大于 5 的元素  
print  ('大于 5 的元素是：')
print (x[x >  5])
我们的数组是：
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]


大于 5 的元素是：
[ 6  7  8  9 10 11]
代码 
# 花式索引 一维数组
x = np.arange(9)
print(x)
# 一维数组读取指定下标对应的元素
print("-------读取下标对应的元素-------")
x2 = x[[0, 6]] # 使用花式索引
print(x2) 
print(x2[0])
print(x2[1])
[0 1 2 3 4 5 6 7 8]
-------读取下标对应的元素-------
[0 6]
0
6
代码 
x=np.arange(32).reshape((8,4))
print(x)
# 二维数组读取指定下标对应的行
print("-------读取下标对应的行-------")
print (x[[4,2,1,7]])
[[ 0  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]]
-------读取下标对应的行-------
[[16 17 18 19]
 [ 8  9 10 11]
 [ 4  5  6  7]
 [28 29 30 31]]
代码 
# 使用 np.ix_ 传入多个索引数组。np.ix_ 函数就是输入两个数组，产生笛卡尔积的映射关系。
# 例如A={a,b}, B={0,1,2}
#A×B={(a, 0), (a, 1), (a, 2), (b, 0), (b, 1), (b, 2)}
#B×A={(0, a), (0, b), (1, a), (1, b), (2, a), (2, b)}

x=np.arange(32).reshape((8,4))
print(x)
print("*"*20)
print (x[np.ix_([1,5,7,2],[0,3,1,2])])
[[ 0  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]]
********************
[[ 4  7  5  6]
 [20 23 21 22]
 [28 31 29 30]
 [ 8 11  9 10]]
代码 
# 广播机制
a = np.array([
    [0, 0, 0],
    [10, 10, 10],
    [20, 20, 20],
    [30, 40, 50],
    [30, 50, 60],
])
b = np.array([0, 1, 2])

print(a+b)
[[ 0  1  2]
 [10 11 12]
 [20 21 22]
 [30 41 52]
 [30 51 62]]
代码 
# 迭代器numpy.nditer

a = np.arange(6).reshape(2,3)
print ('原始数组是：')
print (a)
print ('\n')
print ('迭代输出元素：')
for x in np.nditer(a):    # np.nditer(a, order='F')   or np.nditer(a.T, order='C')  F是列序优先，C是行序优先,默认为C
    print (x, end=", " )
print ('\n')

for x in np.nditer(a, order='F'):    
    print (x, end=", " )
print ('\n')

for x in iter(a):
    print(x, end=", ")
原始数组是：
[[0 1 2]
 [3 4 5]]


迭代输出元素：
0, 1, 2, 3, 4, 5, 

0, 3, 1, 4, 2, 5, 

[0 1 2], [3 4 5],
代码 
# numpy.ndarray.flat 是一个数组元素迭代器
a = np.arange(9).reshape(3,3) 
print ('原始数组：')
for row in a:
        print(row)
 
#对数组中每个元素都进行处理，可以使用flat属性，该属性是一个数组元素迭代器：
print ('迭代后的数组：')
for element in a.flat:
    print (element)
原始数组：
[0 1 2]
[3 4 5]
[6 7 8]
迭代后的数组：
0
1
2
3
4
5
6
7
8
代码 
# numpy.ndarray.flatten 返回一份数组拷贝，对拷贝所做的修改不会影响原始数组 
# order：'C' -- 按行，'F' -- 按列，'A' -- 原顺序，'K' -- 元素在内存中的出现顺序。
a = np.arange(8).reshape(2,4)
 
print ('原数组：')
print (a)
print ('\n')
# 默认按行
print ('展开的数组：')
print (a.flatten())
print ('\n')
print ('以 F 风格顺序展开的数组：')
print (a.flatten(order = 'F'))      

# numpy.ravel 作用一致，但是返回的是数组视图，修改会影响原始数组，即二者内存一致。
原数组：
[[0 1 2 3]
 [4 5 6 7]]


展开的数组：
[0 1 2 3 4 5 6 7]


以 F 风格顺序展开的数组：
[0 4 1 5 2 6 3 7]
代码 
# numpy.transpose 函数用于对换数组的维度
a = np.arange(12).reshape(3,4)
 
print ('原数组：')
print (a )
print ('\n')
 
print ('对换数组：')
print (np.transpose(a))  # 等价于np.transpose(a) = a.T
原数组：
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]


对换数组：
[[ 0  4  8]
 [ 1  5  9]
 [ 2  6 10]
 [ 3  7 11]]
代码 
# numpy.rollaxis 函数向后滚动特定的轴到一个特定位置
a = np.arange(8).reshape(2,2,2)
print ('原数组：')
print (a)
print ('获取数组中一个值：')
print(np.where(a==6))   
print(a[1,1,0])  # 为 6
print ('\n')

# 将轴 2 滚动到轴 0（宽度到深度）
print ('调用 rollaxis 函数：')
b = np.rollaxis(a,2,0)
print (b)
# 查看元素 a[1,1,0]，即 6 的坐标，变成 [0, 1, 1]
# 最后一个 0 移动到最前面
print(np.where(b==6))   
print ('\n')
# 将轴 2 滚动到轴 1：（宽度到高度）
print ('调用 rollaxis 函数：')
c = np.rollaxis(a,2,1)
print (c)
# 查看元素 a[1,1,0]，即 6 的坐标，变成 [1, 0, 1]
# 最后的 0 和 它前面的 1 对换位置
print(np.where(c==6))   
print ('\n')
原数组：
[[[0 1]
  [2 3]]

 [[4 5]
  [6 7]]]
获取数组中一个值：
(array([1], dtype=int64), array([1], dtype=int64), array([0], dtype=int64))
6


调用 rollaxis 函数：
[[[0 2]
  [4 6]]

 [[1 3]
  [5 7]]]
(array([0], dtype=int64), array([1], dtype=int64), array([1], dtype=int64))


调用 rollaxis 函数：
[[[0 2]
  [1 3]]

 [[4 6]
  [5 7]]]
(array([1], dtype=int64), array([0], dtype=int64), array([1], dtype=int64))
代码 
# numpy.expand_dims 函数通过在指定位置插入新的轴来扩展数组形状
x = np.array(([1,2],[3,4]))
 
print ('数组 x：')
print (x)
print ('\n')
y = np.expand_dims(x, axis = 0)
 
print ('数组 y：')
print (y)
print ('\n')
 
print ('数组 x 和 y 的形状：')
print (x.shape, y.shape)
print ('\n')
# 在位置 1 插入轴
y = np.expand_dims(x, axis = 1)
 
print ('在位置 1 插入轴之后的数组 y：')
print (y)
print ('\n')
 
print ('x.ndim 和 y.ndim：')
print (x.ndim,y.ndim)
print ('\n')
 
print ('x.shape 和 y.shape：')
print (x.shape, y.shape)

# numpy.squeeze 函数从给定数组的形状中删除一维的条目，函数格式如下：
数组 x：
[[1 2]
 [3 4]]


数组 y：
[[[1 2]
  [3 4]]]


数组 x 和 y 的形状：
(2, 2) (1, 2, 2)


在位置 1 插入轴之后的数组 y：
[[[1 2]]

 [[3 4]]]


x.ndim 和 y.ndim：
2 3


x.shape 和 y.shape：
(2, 2) (2, 1, 2)
代码 
# numpy.concatenate 函数用于沿指定轴连接相同形状的两个或多个数组
# numpy.concatenate((a1, a2, ...), axis)
 
a = np.array([[1,2],[3,4]])
 
print ('第一个数组：')
print (a)
print ('\n')
b = np.array([[5,6],[7,8]])
 
print ('第二个数组：')
print (b)
print ('\n')
# 两个数组的维度相同
 
print ('沿轴 0 连接两个数组：')
print (np.concatenate((a,b)))
print ('\n')
 
print ('沿轴 1 连接两个数组：')
print (np.concatenate((a,b),axis = 1))

# numpy.hstack 是 numpy.concatenate 的便捷封装，用于沿着第二轴（axis=1）水平堆叠数组。
# numpy.vstack 是 numpy.concatenate 的便捷封装，用于沿着第一轴（axis=0）垂直堆叠数组。
第一个数组：
[[1 2]
 [3 4]]


第二个数组：
[[5 6]
 [7 8]]


沿轴 0 连接两个数组：
[[1 2]
 [3 4]
 [5 6]
 [7 8]]


沿轴 1 连接两个数组：
[[1 2 5 6]
 [3 4 7 8]]
代码 
# numpy.split 函数沿特定的轴将数组分割为子数组  numpy.split(ary, indices_or_sections, axis)多维度可以在aixs设置轴
a = np.arange(9)
 
print ('第一个数组：')
print (a)
print ('\n')
 
print ('将数组分为三个大小相等的子数组：')
b = np.split(a,3)
print (b)
print ('\n')
 
print ('将数组在一维数组中表明的位置分割：')
b = np.split(a,[4,7])
print (b)
# numpy.hsplit 函数用于水平分割数组，通过指定要返回的相同形状的数组数量来拆分原数组。
# numpy.vsplit 沿着垂直轴分割，其分割方式与hsplit用法相同。
第一个数组：
[0 1 2 3 4 5 6 7 8]


将数组分为三个大小相等的子数组：
[array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])]


将数组在一维数组中表明的位置分割：
[array([0, 1, 2, 3]), array([4, 5, 6]), array([7, 8])]
代码 
# numpy.resize 函数返回指定大小的新数组。
a = np.array([[1,2,3],[4,5,6]])
 
print ('第一个数组：')
print (a)
print ('\n')
print ('第一个数组的形状：')
print (a.shape)
print ('\n')

b = np.resize(a, (3,2))
print ('第二个数组：')
print (b)
print ('\n')
print ('第二个数组的形状：')
print (b.shape)
print ('\n')
# 要注意 a 的第一行在 b 中重复出现，因为尺寸变大了
 
print ('修改第二个数组的大小：')
b = np.resize(a,(3,3))
print (b)
第一个数组：
[[1 2 3]
 [4 5 6]]


第一个数组的形状：
(2, 3)


第二个数组：
[[1 2]
 [3 4]
 [5 6]]


第二个数组的形状：
(3, 2)


修改第二个数组的大小：
[[1 2 3]
 [4 5 6]
 [1 2 3]]
代码 
# numpy.append函数在数组的末尾添加值。 追加操作会分配整个数组，并把原来的数组复制到新数组中。 此外，输入数组的维度必须匹配否则将生成ValueError。
a = np.array([[1,2,3],[4,5,6]])
 
print ('第一个数组：')
print (a)
print ('\n')
 
print ('向数组添加元素：')
print (np.append(a, [7,8,9]))
print ('\n')
 
print ('沿轴 0 添加元素：')
print (np.append(a, [[7,8,9]],axis = 0))
print ('\n')
 
print ('沿轴 1 添加元素：')
print (np.append(a, [[5,5,5],[7,8,9]],axis = 1))

# numpy.insert 函数在给定索引之前，沿给定轴在输入数组中插入值。 
# numpy.delete 函数返回从输入数组中删除指定子数组的新数组。 这两个函数如果未提供轴参数，则输入数组将展开。
第一个数组：
[[1 2 3]
 [4 5 6]]


向数组添加元素：
[1 2 3 4 5 6 7 8 9]


沿轴 0 添加元素：
[[1 2 3]
 [4 5 6]
 [7 8 9]]


沿轴 1 添加元素：
[[1 2 3 5 5 5]
 [4 5 6 7 8 9]]
代码 
# numpy.unique 函数用于去除数组中的重复元素。   numpy.unique(arr, return_index, return_inverse, return_counts)
# arr：输入数组，如果不是一维数组则会展开
# return_index：如果为true，返回新列表元素在旧列表中的位置（下标），并以列表形式储
# return_inverse：如果为true，返回旧列表元素在新列表中的位置（下标），并以列表形式储
# return_counts：如果为true，返回去重数组中的元素在原数组中的出现次数
a = np.array([5,2,6,2,7,5,6,8,2,9])
 
print ('第一个数组：')
print (a)
print ('\n')
 
print ('第一个数组的去重值：')
u = np.unique(a)
print (u)
print ('\n')
 
print ('去重数组的索引数组：')
u,indices = np.unique(a, return_index = True)
print (indices)
print ('\n')
 
print ('我们可以看到每个和原数组下标对应的数值：')
print (a)
print ('\n')
 
print ('去重数组的下标：')
u,indices = np.unique(a,return_inverse = True)
print (u)
print ('\n')
 
print ('下标为：')
print (indices)
print ('\n')
 
第一个数组：
[5 2 6 2 7 5 6 8 2 9]


第一个数组的去重值：
[2 5 6 7 8 9]


去重数组的索引数组：
[1 0 2 4 7 9]


我们可以看到每个和原数组下标对应的数值：
[5 2 6 2 7 5 6 8 2 9]


去重数组的下标：
[2 5 6 7 8 9]


下标为：
[1 0 2 0 3 1 2 4 0 5]
代码 
print ('使用下标重构原数组：')
print (u[indices])
print ('\n')
 
print ('返回去重元素的重复数量：')
u,indices = np.unique(a,return_counts = True)
print (u)
print (indices)
使用下标重构原数组：
[5 2 6 2 7 5 6 8 2 9]


返回去重元素的重复数量：
[2 5 6 7 8 9]
[3 2 2 1 1 1]
代码 
# 位运算
import numpy as np

arr1 = np.array([True, False, True], dtype=bool)
arr2 = np.array([False, True, False], dtype=bool)

result_and = np.bitwise_and(arr1, arr2)  # 与
result_or = np.bitwise_or(arr1, arr2)  # 或
result_xor = np.bitwise_xor(arr1, arr2)  # 异或
result_not = np.bitwise_not(arr1) # 取反

print("AND:", result_and)  # [False, False, False]
print("OR:", result_or)    # [True, True, True]
print("XOR:", result_xor)  # [True, True, True]
print("NOT:", result_not)  # [False, True, False]

# 按位取反
arr_invert = np.invert(np.array([1, 2], dtype=np.int8))  # int8对应8位, 1 代表 00000001 ，取反变为11111110 对应-2    或者说invert(x) = -(x+1)
print("Invert:", arr_invert)  # [-2, -3]    注意dtype的类型

# 左移位运算
arr_left_shift = np.left_shift(5, 2)  # 从101->10100  从5->20
print("Left Shift:", arr_left_shift)  # 20

# 右移位运算
arr_right_shift = np.right_shift(10, 1) # 从1010->0101  从10->5
print("Right Shift:", arr_right_shift)  # 5
AND: [False False False]
OR: [ True  True  True]
XOR: [ True  True  True]
NOT: [False  True False]
Invert: [-2 -3]
Left Shift: 20
Right Shift: 5
代码 
# numpy.char.add() 函数依次对两个数组的元素进行字符串连接。

import numpy as np 
 
print ('连接两个字符串：')
print (np.char.add(['hello'],[' xyz']))
print ('\n')
 
print ('连接示例：')
print (np.char.add(['hello', 'hi'],[' abc', ' xyz']))

# numpy.char.multiply() 函数执行多重连接。
print(np.char.multiply('SBLSR  ', 5))
连接两个字符串：
['hello xyz']


连接示例：
['hello abc' 'hi xyz']
SBLSR  SBLSR  SBLSR  SBLSR  SBLSR
代码 
# numpy.char.center() 函数用于将字符串居中，并使用指定字符在左侧和右侧进行填充。
print (np.char.center('Runoob', 20,fillchar = '*'))
# numpy.char.capitalize() 函数将字符串的第一个字母转换为大写：
# numpy.char.title() 函数将字符串的每个单词的第一个字母转换为大写：
# numpy.char.lower() 函数对数组的每个元素转换为小写。它对每个元素调用 str.lower。
# numpy.char.upper() 函数对数组的每个元素转换为大写。它对每个元素调用 str.upper。
# numpy.char.split() 通过指定分隔符对字符串进行分割，并返回数组。默认情况下，分隔符为空格。
# numpy.char.splitlines() 函数以换行符作为分隔符来分割字符串，并返回数组。 \n，\r，\r\n 都可用作换行符。
# numpy.char.strip() 函数用于移除开头或结尾处的特定字符。
# numpy.char.join() 函数通过指定分隔符来连接数组中的元素或字符串
# numpy.char.replace() 函数使用新字符串替换字符串中的所有子字符串。
*******Runoob*******
代码 
# numpy.around() 函数返回指定数字的四舍五入值。
a = np.array([1.0,5.55,  123,  0.567,  25.532])  
print  ('原数组：')
print (a)
print ('\n')
print ('舍入后：')
print (np.around(a))
print (np.around(a, decimals =  1))
print (np.around(a, decimals =  -1))  # decimals: 舍入的小数位数。 默认值为0。 如果为负，整数将四舍五入到小数点左侧的位置
原数组：
[  1.      5.55  123.      0.567  25.532]


舍入后：
[  1.   6. 123.   1.  26.]
[  1.    5.6 123.    0.6  25.5]
[  0.  10. 120.   0.  30.]
代码 
# numpy.floor() 返回小于或者等于指定表达式的最大整数，即向下取整。
a = np.array([-1.7,  1.5,  -0.2,  0.6,  10])
print ('提供的数组：')
print (a)
print ('\n')
print ('修改后的数组：')
print (np.floor(a))
提供的数组：
[-1.7  1.5 -0.2  0.6 10. ]


修改后的数组：
[-2.  1. -1.  0. 10.]
代码 
# numpy.ceil() 返回大于或者等于指定表达式的最小整数，即向上取整。
a = np.array([-1.7,  1.5,  -0.2,  0.6,  10])  
print  ('提供的数组：')
print (a)
print ('\n')
print ('修改后的数组：')
print (np.ceil(a))
提供的数组：
[-1.7  1.5 -0.2  0.6 10. ]


修改后的数组：
[-1.  2. -0.  1. 10.]
代码 
# numpy.amin() 用于计算数组中的元素沿指定轴的最小值。
a = np.array([[3,7,5],[8,4,3],[2,4,9]])  
print ('我们的数组是：')
print (a)
print ('\n')
print ('调用 amin() 函数：')
print (np.amin(a, 1))
print ('\n')
print ('再次调用 amin() 函数：')
print (np.amin(a, 0))
print ('\n')
print ('调用 amax() 函数：')
print (np.amax(a))
print ('\n')
print ('再次调用 amax() 函数：')
print (np.amax(a, axis =  0))
我们的数组是：
[[3 7 5]
 [8 4 3]
 [2 4 9]]


调用 amin() 函数：
[3 3 2]


再次调用 amin() 函数：
[2 4 3]


调用 amax() 函数：
9


再次调用 amax() 函数：
[8 7 9]
代码 
# numpy.argmax() 和 numpy.argmin()函数分别沿给定轴返回最大和最小元素的索引。
# numpy.nonzero() 函数返回输入数组中非零元素的索引。
# numpy.where() 函数返回输入数组中满足给定条件的元素的索引。
# numpy.extract() 函数根据某个条件从数组中抽取元素，返回满条件的元素。
代码 
# 简单的赋值不会创建数组对象的副本。 相反，它使用原始数组的相同id()来访问它。 id()返回 Python 对象的通用标识符，类似于 C 中的指针。
# 此外，一个数组的任何变化都反映在另一个数组上。 例如，一个数组的形状改变也会改变另一个数组的形状。
a = np.arange(6)  
print ('我们的数组是：')
print (a)
print ('调用 id() 函数：')
print (id(a))
print ('a 赋值给 b：')
b = a 
print (b)
print ('b 拥有相同 id()：')
print (id(b))
print ('修改 b 的形状：')
b.shape =  3,2  
print (b)
print ('a 的形状也修改了：')
print (a)
我们的数组是：
[0 1 2 3 4 5]
调用 id() 函数：
2545648018416
a 赋值给 b：
[0 1 2 3 4 5]
b 拥有相同 id()：
2545648018416
修改 b 的形状：
[[0 1]
 [2 3]
 [4 5]]
a 的形状也修改了：
[[0 1]
 [2 3]
 [4 5]]
代码 
# ndarray.view() 方会创建一个新的数组对象，该方法创建的新数组的维数变化不会改变原始数据的维数。
# 最开始 a 是个 3X2 的数组
a = np.arange(6).reshape(3,2)  
print ('数组 a：')
print (a)
print ('创建 a 的视图：')
b = a.view()  
print (b)
print ('两个数组的 id() 不同：')
print ('a 的 id()：')
print (id(a))
print ('b 的 id()：' )
print (id(b))
# 修改 b 的形状，并不会修改 a
b.shape =  2,3
print ('b 的形状：')
print (b)
print ('a 的形状：')
print (a)
# 使用切片创建视图修改数据会影响到原始数组
数组 a：
[[0 1]
 [2 3]
 [4 5]]
创建 a 的视图：
[[0 1]
 [2 3]
 [4 5]]
两个数组的 id() 不同：
a 的 id()：
2545648018224
b 的 id()：
2545647689520
b 的形状：
[[0 1 2]
 [3 4 5]]
a 的形状：
[[0 1]
 [2 3]
 [4 5]]
代码 
# ndarray.copy() 函数创建一个副本。 对副本数据进行修改，不会影响到原始数据，它们物理内存不在同一位置。
a = np.array([[10,10],  [2,3],  [4,5]])  
print ('数组 a：')
print (a)
print ('创建 a 的深层副本：')
b = a.copy()  
print ('数组 b：')
print (b)
# b 与 a 不共享任何内容  
print ('我们能够写入 b 来写入 a 吗？')
print (b is a)
print ('修改 b 的内容：')
b[0,0]  =  100  
print ('修改后的数组 b：')
print (b)
print ('a 保持不变：')
print (a)
数组 a：
[[10 10]
 [ 2  3]
 [ 4  5]]
创建 a 的深层副本：
数组 b：
[[10 10]
 [ 2  3]
 [ 4  5]]
我们能够写入 b 来写入 a 吗？
False
修改 b 的内容：
修改后的数组 b：
[[100  10]
 [  2   3]
 [  4   5]]
a 保持不变：
[[10 10]
 [ 2  3]
 [ 4  5]]
代码 
# np.dot()对于两个一维的数组，计算的是这两个数组对应下标元素的乘积和(数学上称之为向量点积)；
# 对于二维数组，计算的是两个数组的矩阵乘积；
# 对于多维数组，它的通用计算公式如下，即结果数组中的每个元素都是：数组a的最后一维上的所有元素与数组b的倒数第二位上的所有元素的乘积和：

a = np.array([[1,2],[3,4]])
b = np.array([[11,12],[13,14]])
print(np.dot(a,b))   # [[1*11+2*13, 1*12+2*14],[3*11+4*13, 3*12+4*14]]
[[37 40]
 [85 92]]
代码 
# numpy.vdot() 函数是两个向量的点积。 如果第一个参数是复数，那么它的共轭复数会用于计算。 如果参数是多维数组，它会被展开。
a = np.array([[1,2],[3,4]]) 
b = np.array([[11,12],[13,14]]) 
 
# vdot 将数组展开计算内积
print (np.vdot(a,b))   # 1*11 + 2*12 + 3*13 + 4*14 = 130
130
代码 
# numpy.inner() 函数返回一维数组的向量内积。对于更高的维度，它返回最后一个轴上的和的乘积。
print (np.inner(np.array([1,2,3]),np.array([0,1,0]))) # 等价于 1*0+2*1+3*0

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

b = np.array([[
        [8, 9],
        [10, 11]
    ],
    [
        [12, 13],
        [14, 15]
    ]])

print(np.inner(a, b))
2
[[[[  9  11]
   [ 13  15]]

  [[ 43  53]
   [ 63  73]]]


 [[[ 77  95]
   [113 131]]

  [[111 137]
   [163 189]]]]
代码 
# numpy.matmul 函数返回两个数组的矩阵乘积。
# numpy.linalg.inv() 函数计算矩阵的乘法逆矩阵
# numpy 可以运用于保存数据与读取数据