Python数据分析系列（四 ）：python数据结构 — Numpy中的ndarray（数组）的使用

---

前言

本文主要介绍 Numpy中的ndarray（数组）的使用，其中包括用于数组创建，常用的数组算法（如排序集合运算），数组描述统计，数据聚合或分组运算，数据集的合并/连接运算的数据对齐和关系型数据运算等等。

---

一、NumPy是什么？

NumPy（Numerical Python的简称）是高性能科学计算和数学分析的基础包。有以下特征：

• 强大的ndarray对象和ufunc函数
• 精巧的函数
• 比较适合线性代数随机数处理等科学计算
• 有效的通用多维数据，可定义任意数据类型
• 无缝对接数据库

二、python中的数组

1.python中数组的形式

• 用list和tuple等数据结构表示数组

import numpy as np
list1=[1,2,3,4]
x=np.array(list1)

import numpy as np
list2=[[1,2,3],[4,5,6],[7,8,9]]
x=np.array(list2)

• array模块
  • 通过array函数创建数组
  • 提供append、insert和read等方法

import array
array.array("B",range(5))
# 输出：
# array('B', [0, 1, 2, 3, 4])

三、NumPy的ndarray

1.ndarray是什么？

• 一种N维数组。
• Numpy中基本的数据结构
• 所有元素是同一种类型
• 别名array
• 利于节省内存和提高CPU计算时间
• 有丰富的函数

2.ndarray基本概念

数组属性

• 维度（dimensions）称为轴（axes），轴的个数称为秩（rank）。
• 基本属性
  • ndarray.ndim
    返回数组的秩。
  • ndarray.shape
    返回数组的维度。
  • ndarray.size
    返回数组的元素总个数。
  • ndarray.dtype
    返回数组的元素类型。
  • ndarray.itemsize
    返回数组的元素字节大小。

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

print("数组的秩",x.ndim)
# 输出：
# 数组的秩 2

print("数组的维度",x.shape)
# 输出：
# 数组的维度 (2, 3)

print("数组的元素总个数",x.size)
# 输出：
# 数组的元素总个数 6

print("数组的元素类型",x.dtype)
# 输出：
# 数组的元素类型 int32

print("数组的元素字节大小",x.itemsize)
# 输出：
# 数组的元素字节大小 4

3.ndarray的创建函数

• numpy.array(object, dtype=None*, copy=True, order=‘K’, subok=False, ndmin=0,like=None)

创建数组

参数解释：

object：创建数组的对象，可以是一切序列对象，可以是单个值，列表，元胞等。
dtype：创建数组中的数组类型。

import numpy as np
aArray=np.array([1,2,3])
aArray
# 输出：
# array([1, 2, 3])

bArray=np.array([(1,2,3),(4,5,6)])
bArray
# 输出：
# array([[1, 2, 3],
#       [4, 5, 6]])

cArray=np.array([(1,2,3),(4,5,6)],dtype=np.float32)
cArray
# 输出：
# array([[1., 2., 3.],
#       [4., 5., 6.]], dtype=float32)

• numpy.arange(arange([start,] stop[, step,], dtype=None, *, like=None)

创建返回间隔类均匀分布的数组。

参数解释：

start：可选，起点值，默认从0开始。
stop：必需，终点值，生成元素不包括结束值。
step：可选，步长，默认步长为1。
dtype：可选，默认为None，设置显示元素的数据类型。

import numpy as np

np.arange(7) # 终点值为7，默认起点值为0，步长为1
# 输出：
# array([0, 1, 2, 3, 4, 5, 6])

np.arange(3,7) # 终点值为7，起点值为3，步长为1
# 输出：
# array([3, 4, 5, 6])

np.arange(3,7,2) # 终点值为7，起点值为3，步长为2
# 输出：
# array([3, 5])

np.arange(3,7,0.5) # 终点值为7，起点值为3，步长为0.5
# 输出：
# array([3. , 3.5, 4. , 4.5, 5. , 5.5, 6. , 6.5])

• numpy.copy(a, order=‘K’, subok=False)

深拷贝，对新生成的对象修改删除操作不会影响到原对象。

参数解释：

a：一个数组。
order：可选。{‘C’, ‘F’, ‘A’, ‘K’}，{‘C’,‘F’}是否在内存中以C或fortran（行或列）顺序复制多维数据。

import numpy as np
a=np.arange(12)
b=a  #对象复制,a,b地址一样
b.shape=(3,4) #a对象的shape也会变化
print(a,id(a))
# 输出：
# [[ 0  1  2  3]
# [ 4  5  6  7]
# [ 8  9 10 11]] 2049516001296

print(b,id(b))
# 输出：
# [[ 0  1  2  3]
# [ 4  5  6  7]
# [ 8  9 10 11]] 2049516001296

import numpy as np
a=np.arange(12)
d=np.copy(a)
d.shape=(3,4)
print(a,id(a))
# 输出：
# [ 0  1  2  3  4  5  6  7  8  9 10 11] 2049516002544

print(d,id(d))
# 输出：
# [[ 0  1  2  3]
# [ 4  5  6  7]
# [ 8  9 10 11]] 2049516000816

关于浅、深拷贝的可以参考文章：https://blog.csdn.net/sodaloveer/article/details/134968124

• numpy.empty(shape,dtype=float,order=‘C’)

根据给定的维度和数值类型返回一个新的数组，其元素不进行初始化，生成的数组元素为随机数。

参数解释：

shape：整数或者整数组成的数组。
dtype：数据类型，可选。指定输出数组的数值类型，例如numpy.int8，默认为numpy.float64。
order：可选。{‘C’,‘F’}是否在内存中以C或fortran（行或列）顺序存储多维数据。

import numpy as np
np.empty([2,3])
# 输出：
# array([[2.12199579e-314, 6.36598737e-314, 1.06099790e-313],
#       [1.48539705e-313, 1.90979621e-313, 2.33419537e-313]])
np.empty([2, 3], dtype=int)
# 输出：
# array([[1065353216, 1073741824, 1077936128],
#       [1082130432, 1084227584, 1086324736]])

• numpy.empty_like(prototype, dtype=None, order=‘K’, subok=True, shape=None)

返回与已有数组相同维度及类型的新数组。

参数解析：

prototype：数组，原型的形状和数据类型定义了返回数组的相同属性。
dtype：数据类型，可选。指定输出数组的数值类型。
order：可选。{‘C’, ‘F’, ‘A’, or ‘K’}。覆盖结果的内存布局。
subok：布尔值，可选。如果为True，那么新建的数组将使用sub-class类型的原型，否则它将是base-class数组。默认为True。
shape：int或整数序列，可选。覆盖结果的形状，如果order='K’且维数不变，将尝试保持order，否则，隐含order=‘C’。

import numpy as np
a=np.arange(9).reshape(3,3)
np.empty_like(a)
# 输出：
# array([[712861296,       477,         0],
#       [        0,       960,         0],
#       [      768,         0,         0]])

np.empty_like(a,dtype=np.float32)
# 输出：
# array([[1.36e-43, 6.45e-44, 1.40e-43],
#       [1.63e-43, 1.70e-43, 1.57e-43],
#       [1.42e-43, 6.68e-43, 0.00e+00]], dtype=float32)

• numpy.eye(N, M=None, k=0, dtype=<class ‘float’>, order=‘C’, *, like=None)

返回一个对角线是1，其他是0的二维数组。

参数解析

N：int，输出中的行数。
M：int，可选。输出中的列数，默认值为’N’。
K：int，可选。对角线的索引，默认值为0，表示是主对角线，正值指的是上对角线，负值指的是下对角线。
dtype：数据类型，可选。返回数组的数据类型。
order：可选。{‘C’,‘F’}是否在内存中以C或fortran（行或列）顺序存储多维数据。

import numpy as np
np.eye(2,dtype=int))
# 输出：
# array([[1, 0],
#        [0, 1]])

np.eye(3,k=1))
# 输出：
# array([[0., 1., 0.],
#        [0., 0., 1.],
#        [0., 0., 0.]])

• numpy.fromfile(file, dtype=float, count=-1, sep=‘’, offset=0, *, like=None)

根据文本或二进制文件中的数据构建一个数组。

参数解析：

file：file或str或path
dtype：数据类型，可选。返回数组的数据类型，对于二进制文件，它用于确定文件中各项的大小和字节顺序。
count：int，要读取的项目数，-1表示所有项目（即完整文件）。
sep：str，如果文件是文本文件，则项目之间的分隔符，空（“”）分隔符表示文件应被视为二进制文件。分隔符中的空格（" "）匹配零个或多个空格字符。仅由空格组成的分隔符必须至少匹配一个空格。
offset：int，与文件当前位置的偏移量（以字节为单位）。仅允许用于二进制文件。

import numpy as np
a=np.arange(12)
a.shape=(3,4)
a.tofile("a.bin") #将数组中的数据以二进制格式写入文件。
b1=np.fromfile('a.bin',dtype=np.float)
b2=np.fromfile('a.bin',dtype=np.int)
b3=np.fromfile('c.bin',dtype=np.int32)

• numpy.fromfunction(function, shape, *, dtype=<class ‘float’>, like=None, **kwargs)

通过对每个坐标执行函数来构造数组。返回调用function结果，因此fromfuntion的外形完全由function决定，如果function返回标量值，则fromfuntion的形状将与shape参数不匹配。

参数解析：

function：该函数使用 N 个参数调用，其中 N 是 shape 的等级。每个参数代表数组沿特定轴变化的坐标。例如，如果 shape 是 (2, 2) ，则参数将为 array([[0, 0], [1, 1]]) 和 array([[0, 1], [0, 1]])。
shape：输出数组的形状，它还确定传递给function的坐标数组的形状。
dtype：传递给function的坐标数组的数据类型，默认情况下，dtype为浮点型float。
like：允许创建非NumPy数组的引用对象，如果like传入的类似数组支持__array_function__协议，则结果将由它定义，在这种情况下，它确保创建一个与通过此参数传入的数组对象兼容的数组对象。

import numpy as np

def func1(x,y):
	return 10*x+y
b=np.fromfunction(func1,(5,4),dtype=np.int)
b

# 输出：
# array([[ 0,  1,  2,  3],
#        [10, 11, 12, 13],
#        [20, 21, 22, 23],
#        [30, 31, 32, 33],
#        [40, 41, 42, 43]])


np.fromfunction(lambda i,j:i=j,(3,3),dtype=int)
# 输出：
# array([[ True, False, False],
#        [False,  True, False],
#        [False, False,  True]])

• numpy.identity(n, dtype=None, *, like=None)

返回一个单位矩阵，单位矩阵指主对角线上是1的方阵。

参数解析：

n：是输出n*n对角阵的行数（或列数）。
dtype：数据类型，可选。返回数组的数据类型，默认情况下，dtype为浮点型float。若dtype设为“bool”，则返回对角线元素为True其余元素为Flase的方阵。

import numpy as np
np.identity(3)
# 输出：
# array([[1., 0., 0.],
#        [0., 1., 0.],
#        [0., 0., 1.]])

np.identity(3,dtype=bool)
# 输出：
# array([[ True, False, False],
#        [False,  True, False],
#        [False, False,  True]])

• numpy.linspace(start,stop,num=50, endpoint=True, retstep=False, dtype=None, axis=0)

返回间隔类均匀分布的数值序列。

参数解析：

start：参数数值范围的起始点，如果设置为0，则结果的第一个数为0，该参数必须提供。
stop：参数数值范围的终止点，通常为结果的最后一个值，如果修改endpoint=False，则结果中不包括该值。
num：int，可选，控制结果中有多少个元素，如num=5，则输出数组个数5，默认值为50。
endpoint：bool，可选，决定终止值 （stop参数指定）是否被包含在结果数组中，如果endpoin=True，结果中包括终止值，反之不包括，默认为True。
dtype：数据类型，可选，决定输出数组的数据类型，如果没有给定dtype参数，则数据类型根据’start‘和’stop’进行推断，

import numpy as np
np.linspace(2,3,num=5)
# 输出：
# array([2.  , 2.25, 2.5 , 2.75, 3.  ])

np.linspace(0,100,num=11)
# 输出：
# array([  0.,  10.,  20.,  30.,  40.,  50.,  60.,  70.,  80.,  90., 100.])

np.linspace(1,5,4,endpoint=False)
# 输出：
# array([1., 2., 3., 4.])

np.linspace(start = 0, stop = 100, num = 5, dtype = int)
# 输出：
# array([  0,  25,  50,  75, 100])

• numpy.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None, axis=0)

在指定的范围内生成等比数列数据的函数。以10为底数取对数，比如生成从10的1次方到10的4次方之间4个数，可以使用logspace(1, 4, 4)函数。

参数解析：

start：base**start序列的起始值。
stop：base**start序列的最终值，除非endpoint 为False。。
num：int，可选。要生成的样本数。默认值为50。
endpoint：bool，可选。如果为True，则停止的是最后一个样本，否则不包括在内。默认值为True。
base：float，可选。日志空间的基础。ln（samples）/ ln（base）（或log_base（samples））中元素之间的步长是一致的。
dtype：数据类型，可选，输出数组的类型。
axis：int，可选。

import numpy as np
np.logspace(0,3,4) # 生成10的0次方到10的3次方之间4个数
# 输出：
# array([   1.,   10.,  100., 1000.])

np.logspace(0,5,6,base=2) #生成2的0次方到2的5次方之间6个数。
# 输出：
# array([ 1.,  2.,  4.,  8., 16., 32.])

• numpy.mgrid[start : end : step]

返回多维结构，常见的如2D、3D图形。

参数解析：

start：开始坐标。
stop：结束坐标。
step：步长。步长为复数表示总共个数，左闭右闭，步长为实数表示间隔，左闭右开。

import numpy as np 
np.mgrid[-5:5:3j]
# 输出：
# array([-5.,  0.,  5.])

np.mgrid[-5:5:3]
# 输出：
# array([-5, -2,  1,  4])

# 二维数组,x和y都是3*3的数组，x跨行方向即列方向与第一个参数一致，y为跨列方向即行方向与第二个参数一致。
x,y=np.mgrid[-5:5:3j,-2:2:3j]
x
# 输出：
# array([[-5., -5., -5.],
#       [ 0.,  0.,  0.],
#       [ 5.,  5.,  5.]])
y
# 输出：
# array([[-2.,  0.,  2.],
#        [-2.,  0.,  2.],
#        [-2.,  0.,  2.]])

# 三维数组,三维数组内的二维数组是由第一个参数-5:5:3j决定，为3，二维数组的行数由第二个参数决定，为3，二维数组的列数由第三个参数决定，为3。
x,y,z=np.mgrid[-5:5:3j,-2:2:3j,-1:1:3j]
x
# 输出：
# array([[[-5., -5., -5.],
#         [-5., -5., -5.],
#         [-5., -5., -5.]],

#        [[ 0.,  0.,  0.],
#         [ 0.,  0.,  0.],
#         [ 0.,  0.,  0.]],

#        [[ 5.,  5.,  5.],
#         [ 5.,  5.,  5.],
#         [ 5.,  5.,  5.]]])
y
# 输出：
# array([[[-2., -2., -2.],
#         [ 0.,  0.,  0.],
#         [ 2.,  2.,  2.]],

#        [[-2., -2., -2.],
#         [ 0.,  0.,  0.],
#         [ 2.,  2.,  2.]],

#        [[-2., -2., -2.],
#         [ 0.,  0.,  0.],
#         [ 2.,  2.,  2.]]])
z
# 输出：
# array([[[-1.,  0.,  1.],
#         [-1.,  0.,  1.],
#         [-1.,  0.,  1.]],

#        [[-1.,  0.,  1.],
#         [-1.,  0.,  1.],
#         [-1.,  0.,  1.]],

#        [[-1.,  0.,  1.],
#         [-1.,  0.,  1.],
#         [-1.,  0.,  1.]]])

• numpy.ogrid[start : end : step]

打开的多维“网格网格”的实例。它在索引时返回一个开放的（即不充实的）网格，因此每个返回的数组只有一个维度大于1。输出数组的维数和数目等于索引维数。
ogrid函数产生的数组，第一个数组是以纵向产生的，即数组第二维的大小始终为1。第二个数组是以横向产生的，即数组第一维的大小始终为1。

参数解析：

start：开始坐标。
stop：结束坐标。
step：步长。步长为复数表示总共个数，左闭右闭，步长为实数表示间隔，左闭右开。

import numpy as np
np.ogrid[-1:1:5j]
# 输出：
# array([-1. , -0.5,  0. ,  0.5,  1. ])

np.ogrid[0:5:1,0:5:1]
# 输出：
# [array([[0],
#         [1],
#         [2],
#         [3],
#         [4]]),
#  array([[0, 1, 2, 3, 4]])]

• numpy.ones(shape, dtype=None, order=‘C’, *, like=None)

返回给定形状和数据类型的新数组，其中元素的值设置为1。

参数解析：

shape：一个整数类型或一个整数元组，用于定义数组的大小。如果仅指定一个整数类型变量，则返回一维数组。如果指定的是整数元组，则返回给定形状的数组。
dtype：数据类型，可选，默认值为float。用于指定数组的数据类型。
order：可选。{‘C’,‘F’}是否在内存中以C或fortran（行或列）顺序存储多维数据。

import numpy as np
np.ones(5)
# 输出：
# array([1., 1., 1., 1., 1.])

np.ones(5,dtype=int)
# 输出：
# array([1, 1, 1, 1, 1])

np.ones((2,1))
# 输出：
# array([[1.],
#        [1.]])

• numpy.ones_like(a, dtype=None, order=‘K’, subok=True, shape=None)

返回一个形状类型跟a一样，用1填充的数组。

参数解析：

a：类似数组的输入。
dtype：数据类型，可选，默认值为float。用于指定数组的数据类型。
order：可选。{‘C’,‘F’}是否在内存中以C或fortran（行或列）顺序存储多维数据。

import numpy as np
a=np.arange(6)
a.shape=(2,3)
np.ones_like(a)
# 输出：
# array([[1, 1, 1],
#        [1, 1, 1]])

• numpy.zeros(shape, dtype=float, order=‘C’, *, like=None)

返回给定形状和数据类型的新数组，其中元素的值设置为0。

参数解析：

shape：一个整数类型或一个整数元组，用于定义数组的大小。如果仅指定一个整数类型变量，则返回一维数组。如果指定的是整数元组，则返回给定形状的数组。
dtype：数据类型，可选，默认值为float。用于指定数组的数据类型。
order：可选。{‘C’,‘F’}是否在内存中以C或fortran（行或列）顺序存储多维数据。

import numpy as np
np.zeros(5)
# 输出：
# array([0., 0., 0., 0., 0.])

np.zeros((5,0),dtype=int)
# 输出：
# array([], shape=(5, 0), dtype=int32)

np.zeros((2,1))
# 输出：
# array([[0.],
#        [0.]])

• numpy.zeros_like(a, dtype=None, order=‘K’, subok=True, shape=None)

返回一个形状类型跟a一样，用0填充的数组。

参数解析：

a：类似数组的输入。
dtype：