Numpy模块的介绍和基本使用 ndarray类型数组的基本操作

NumPy（Numerical Python）是Python语言中做科学计算的基础库，重在数值计算，也是大部分Python科学计算库的基础。多用于在大型、多维数组上执行的数值运算。

创建ndarray类型数组

首先导入，并起别名np：

import numpy as np

接下来代码中的np就表示numpy

使用array()创建一个一维数组

创建一个ndarray类型的数组，np.array()里直接填一个由数字组成的列表

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

python_list=[1,2,3,4,5]
ndarry=np.array(python_list)

使用array()创建一个二维数组

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

一张图了解数据

数组和列表的区别是什么？

• 数组中存储的数据元素类型必须是统一类型
• 优先级：字符串>浮点型>整数

列如，现在将字符串存入数组，那么返回的数组就是字符串类型，其它同理：

np.array([[1,"www.e1yu.com",3,4],[1,2,3,4]])
# array([['1', 'www.e1yu.com', '3', '4'],
#       ['1', '2', '3', '4']], dtype='<U12')

这里还有排序sort()、max()最大值、min()最小值、切片操作跟列表都是一样的，比较简单，这里不过多介绍！

判断ndarray的维度

以下代码会返回2，表示为二维数组

data=np.array([ [1,2,3],[4,5,6] ])
print(data.ndim)

了解ndarray各维度的长度

我想知道每个维度的长度是多少，以二维数组为例，我想知道这个二维数组是几行几列：

data=np.array([ [1,2,3],[4,5,6] ])
print(data.shape)
# (2, 3)

创建一个全是0的数组，用于初始化数组

data=np.zeros(10)
print(data)
# [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]

创建一个全是1的数组：

data=np.ones(10)
print(data)
# [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]

创建一个全是1的二维数组：

data=np.ones( (4,10) ) # 四行10列
print(data)
# [[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
# [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
# [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
# [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]]

多维数组的各维度长度要用元组来表示

numpy的其它方法

创建一个4行5列的数组：

np.ones(shape=(4,5)) # shape表示形状 4行五列

创建一个从0开始，到100结束，20个数组元素：

np.linspace(10,100,num=20)
# array([ 10.        ,  14.73684211,  19.47368421,  24.21052632,
#        28.94736842,  33.68421053,  38.42105263,  43.15789474,
#        47.89473684,  52.63157895,  57.36842105,  62.10526316,
#        66.84210526,  71.57894737,  76.31578947,  81.05263158,
#        85.78947368,  90.52631579,  95.26315789, 100.        ])

创建一个从0开始，100结束，步伐为2，也就是间隔为2：

np.arange(0,100,step=2)
# array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32,
#       34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66,
#       68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98])

创建一个随机的数组，从0开始，100结束，3行4列：

np.random.randint(0,100,size=(3,4))
# array([[ 3, 88,  5, 41],
#       [ 5, 90, 85, 56],
#       [78, 42, 95, 41]])

固定随机性：

np.random.seed(1) #固定随机性，值任意
np.random.randint(0,100,size=(3,4))

numpy的常用属性

属性比较简单

data=np.random.randint(0,100,size=(3,4))
data.shape # 形状
data.ndim # 维度
data.size # 返回元素的个数
data.dtype # 数组元素类型
type(data) # 数组类型  numpy.ndarray

numpy的数据类型，arrar(dtype=?)可以设定数据类型；arr.dtype=’?’可以修改数据类型。

名称	描述
bool_	布尔型数据类型（True 或者 False）
int_	默认的整数类型（类似于 C 语言中的 long，int32 或 int64）
intc	与 C 的 int 类型一样，一般是 int32 或 int 64
intp	用于索引的整数类型（类似于 C 的 ssize_t，一般情况下仍然是 int32 或 int64）
int8	字节（-128 to 127）
int16	整数（-32768 to 32767）
int32	整数（-2147483648 to 2147483647）
int64	整数（-9223372036854775808 to 9223372036854775807）
uint8	无符号整数（0 to 255）
uint16	无符号整数（0 to 65535）
uint32	无符号整数（0 to 4294967295）
uint64	无符号整数（0 to 18446744073709551615）
float_	float64 类型的简写
float16	半精度浮点数，包括：1 个符号位，5 个指数位，10 个尾数位
float32	单精度浮点数，包括：1 个符号位，8 个指数位，23 个尾数位
float64	双精度浮点数，包括：1 个符号位，11 个指数位，52 个尾数位
complex_	complex128 类型的简写，即 128 位复数
complex64	复数，表示双 32 位浮点数（实数部分和虚数部分）
complex128	复数，表示双 64 位浮点数（实数部分和虚数部分）

修改数组元素的数据类型：

arr=np.array([1,2,3]) 
arr.dtype # dtype('int32')
arr.dtype='int8'
arr.dtype

numpy的索引操作

获取数组中某个数字（索引操作）,跟列表一样。现在获取某一个数字：

data=np.arange(10)
print(data)
print(data[5])

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

获取二维数组中某个数字：

data=np.array([ [1,2,3,4],[5,6,7,8] ])
print(data)

print(data[0][1]) # 0行1列
print(data[0,1]) # 0行1列

# [[1 2 3 4]
# [5 6 7 8]]

# 2
# 2

numpy的切片操作

获取数组中某几个数字（切片操作）

data=np.arange(10)
print(data[1:4])
# [1 2 3]

可以看到返回的效果跟列表一样。切片起始位置是0的话可以省略不写，比如data[:4]和data[0:4]得到的结果一样，切片的结束位置也是同理，这个跟列表的切片一样。如果data[:]表示切所有。

首先创建一个随机数组：

arr=np.random.randint(0,100,size=(5,7)) 

切出数组的前两行：

arr[0:2]

切出数组的前两列，通过,分割，前面为第一个维度，后面为第二个维度，冒号表示不切：

arr[:,0:2] # 逗号左边为行 右边为列

切出数组的前两行两列：

arr[0:2,0:2]

切片得到的数据对应的还是原始数据，任何修改都会反映到原始数据上

data=np.arange(10)
data_slice=data[3:6]
data_slice[2]=100
print(data)

# [  0   1   2   3   4 100   6   7   8   9]

如果想要得到一份副本，不影响原始数据：

import copy
data[3:6].copy()

数组数据的翻转，对行倒置：

arr[::-1,:]

所有元素倒置：

arr[::-1,::-1]

numpy的变形reshape

变换数组的维度

data=np.arange(10)
print(data)

print(data.reshape( (2,5) )) # 将一维数组转换为2行5列的二维数组
# [0 1 2 3 4 5 6 7 8 9]

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

现在我将16个数字，转换为3行5列的二维数组就会报错：ValueError: cannot reshape array of size 16 into shape (3,5)，所以你需要注意！

先创建一个随机的二维数组，然后将二维数组变成一维数组：

arr=np.random.randint(10,100,size=(3,4)) #创建一个二维数组 三行四列

print(arr.reshape(12,))

将一维数组编程二维数组：

arr=np.random.randint(10,100,size=(3,4))
arr_1=arr.reshape(12,)  
print(arr_1.reshape(1,12)) # 1行12列的二维数组

保证变形前数组的容量和变形后数组的容量相同，否则失败

矩阵的转置

将2行5列的二维数组转换为5行2列：

data=np.arange(10)
print(data.reshape( (2,5) ).T)

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

级联操作

将多个numpy数组进行横向或者纵向的拼接。axis轴向的理解（0：列，1：行）。

np.concatenate((arr,arr),axis=0) # 将arr和arr进行列拼接
np.concatenate((arr,arr),axis=1) # 将arr和arr进行列拼接