数据分析-numpy的运用(多维数组的创建与矩阵计算)

1、numpy：多维数组的创建

多维数组（矩阵ndarray）
ndarray的基本属性

shape 维度的大小
ndim维度的个数
dtype数据类型

1.1 随机抽样创建

1.1.1 rand

生成指定维度的随机多维度浮点型数组,区间范围是[0,1)

'''
Create an array of the given shape and populate it with
            random samples from a uniform distribution
            over ``[0, 1)``.
'''
#随机生成范围为3层 4 行 5列 大小在0~1之间的三维数组            
nd1 = np.random.rand(3,4,5)
print(nd1)
print('维度的个数',nd1.ndim)
print('维度的形状大小',nd1.shape)
print('数据类型',nd1.dtype)  #float 64

展示
[[[0.6692067  0.2720613  0.51154113 0.82428366 0.46295541]
  [0.90008085 0.32678138 0.22799996 0.01463876 0.91932592]
  [0.94994095 0.1005888  0.97856803 0.95835044 0.4232734 ]
  [0.55823696 0.67435857 0.80571127 0.31125564 0.51347285]]

 [[0.79288383 0.87991494 0.36959603 0.83993517 0.44854427]
  [0.29233904 0.21511221 0.23838737 0.31218621 0.01570319]
  [0.63118773 0.6943842  0.42748468 0.55841017 0.58764804]
  [0.65398815 0.58153545 0.57424707 0.49788028 0.54942051]]

 [[0.9069376  0.4375912  0.12404622 0.73877842 0.91480335]
  [0.37166892 0.13312303 0.12471981 0.8086709  0.72126696]
  [0.93126097 0.11578659 0.82806954 0.91416224 0.93896591]
  [0.78597169 0.46466087 0.0921524  0.11408107 0.15356255]]]
维度的个数 3
维度的大小 (3, 4, 5)
数据类型 float64
###################

1.1.2 uniform

def uniform(low=0.0, high=1.0, size=None):

功能：从一个均匀分布[low,high)中随机采样，注意定义域是左闭右开，即包含low，不包含high.
参数介绍:

    low: 采样下界，float类型，默认值为0；
    high: 采样上界，float类型，默认值为1；
    size: 输出样本数目，为int或元组(tuple)类型，例如，size=(m,n,k), 则输出m*n*k个样本，缺省时输出1个值。

返回值：ndarray类型，其形状和参数size中描述一致。

这里顺便说下ndarray类型，表示一个N维数组对象，其有一个shape（表维度大小）和dtype（说明数组数据类型的对象），使用zeros和ones函数可以创建数据全0或全1的数组，原型：

    numpy.ones(shape,dtype=None,order='C'),

其中，shape表数组形状（m*n）,dtype表类型,ndim维度的个数
实例

nd = np.random.uniform(2)
nd2 = np.random.uniform(-1,5,size=(2,3))
print(nd2)
print(type(nd2))
print(nd2.ndim)
print(nd2.dtype)
print(nd2.shape)
--------------------------------------------------
展示：
[[3.59873373 2.60052091 0.45326737]
 [2.87653583 2.15374128 3.38291766]]
<class 'numpy.ndarray'>
2
float64
(2, 3)

1.1.3 randint

def randint(low, high=None, size=None, dtype='l'):

函数的作用是，返回一个随机整型数，范围从低（包括）到高（不包括），即[low, high)。
如果没有写参数high的值，则返回[0,low)的值。
参数如下：

• low: int
  生成的数值最低要大于等于low。
  （hign = None时，生成的数值要在[0, low)区间内）
• high: int (可选)
  如果使用这个值，则生成的数值在[low, high)区间。
• size: int or tuple of ints(可选)
  输出随机数的尺寸，比如size = (m * n* k)则输出同规模即m * n* k个随机数。默认是None的，仅仅返回满足要求的单一随机数。
• dtype: dtype(可选)：
  想要输出的格式。如int64、int等等

输出：

• out: int or ndarray of ints
  返回一个随机数或随机数数组

例子

nd3 = np.random.randint(1,20,size=(3,4))
print(nd3)

展示：
[[ 4 15 10  5]
 [11 11  2  4]
 [ 6  1 16 19]]

注意点：
1、如果没有指定最大值，只是指定了最小值，范围是[0,最小值)
2、如果有最小值，也有最大值[最小值，最大值)

总结

关键字	范围	举例	解释
rand	[0,1)	np.random.rand(数组的行和列)	取值范围只能0~1
uniform	[low,high]	np.random.uniform(low,high,size=数组大小形状)	取值范围自己取,包括小数
randint	[low,high]	np.random.randint(low,high,size=数组大小形状)	取值范围自己取,只有整数

1.2 序列创建

1.2.1 array

功能描述：将输入数据（列表的列表，元组的元组，元组的列表等）转换为矩阵形式

通过列表进行创建
nd4 = np.array([1,2,3])
[1 2 3]

通过列表嵌套列表创建
nd5 = np.array([[1,2,3],[4,5]])
[list([1, 2, 3]) list([4, 5])]

综合
nd4 = np.array([1,2,3])
nd5 = np.array([[1,2,3],[4,5,6]])
print(nd4)
print(nd4.ndim)
print(nd4.shape)
print(nd5)
print(nd5.ndim)
print(nd5.shape)

[1 2 3]
1
(3,)
[[1 2 3]
 [4 5 6]]
2
(2, 3)

1.2.2 zeros

print(np.zeros((4,4)))
[[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]
注意点：
1、创建的数组里面的数据为0
2、默认的数据类型是float
3、可以指定其他的数据类型

1.2.3 ones

1.2.4 arange

nd6 = np.arange(10)
print(nd6)
nd7 = np.arange(0,10)
print(nd7)
nd8 = np.arange(0,10,2)
print(nd8)

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

注意点：
1、只填写一位数[0，这位)
2、填写两位[最低位，最高位)
3、填写3位数[最低位，高位，步长）
4、创建的是一维数组
5、等同于np.array(range())

总结

关键字	范围	举例	解释
array	所需要转的序列	np.array([1,2,3,4])
zeros	0	np.zeros((数组的行,列))	数组全有0排列,数组的行,列自己定
ones	1	np.ones((数组的行,列))	数组全有1排列,数组的行,列自己定
arange	[low,high]	np.arange(low,high).resheap(数组的行,列)	取值范围自己取,只有整数,数组形状自己定(能够整齐排列的都可以)

1.3 数组重新排列–shuffle

print('##########################')
nd9 = np.arange(10)
print(nd9)
nd10 = nd9.reshape(2,5)
print(nd10)
print(nd9)

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

注意点：
1、有返回值，返回新的数组，原始数组不受影响
2、进行维度大小的设置的过程中，要注意数据的个数，注意元素的个数

shuffle :打乱顺序从新排列

print('###################')
nd11 = np.arange(10)
print(nd11)
nd12 = np.random.shuffle(nd11)
print(nd12)
print(nd11)
展示
###################
[0 1 2 3 4 5 6 7 8 9]
None
[5 6 1 8 7 9 2 4 0 3]

注意点：
1、在原始数据集上做的操作
2、将原始数组的元素进行重新排列，打乱顺序
3、shuffle这个没有返回值

两个可以配合使用，先打乱，再重新排列

1.4 astype数据类型的转换

print('########################')
nd13 = np.arange(10,dtype=np.int64)
print(nd13)
nd14 = nd13.astype(np.float64)
print(nd14)
print(nd13)


注意点：
1、astype（）不在原始数组做操作，有返回值，返回的是更改数据类型的新数组
2、在创建新数组的过程中，有dtype参数进行指定

数组转列表

print(list(arr1))
print(arr1.tolist())

总结

关键字	作用	举例	解释
shuffle	打乱顺序重新排列	nd11 = np.arange(10) nd12 = np.random.shuffle(nd11)	1.在原始数据集上做的操作2、将原始数组的元素进行重新排列，打乱顺序
astype	转换数据类型	np.arange(10,dtype=np.int64)	1、astype（）不在原始数组做操作，有返回值，返回的是更改数据类型的新数组2、在创建新数组的过程中，有dtype参数进行指定

2、numpy的矩阵计算

2.1 相加(下标相同的相加)

注意:元素个数必须相同

arr1 = np.arange(1,6)
arr2 = np.array([10,20,30,40,50])
print(arr1)
print(arr2)
print(arr1+arr2)
展示：
[1 2 3 4 5]
[10 20 30 40 50]
[11 22 33 44 55]
注意点：
1.一维数组的元素个数是相同的，不然无法完成广播
2.按照数组对应的下标来进行算术运算,返回一个新的数组,同时保证数组的元素是一致的

一维数组与多维数组(数组列数必须相同)

import numpy as np

arr1 = np.arange(1,6)
arr2 = np.array([10,20,30,40,50])
arr3 = arr1.reshape((1,5))
arr4 = arr2.reshape((1,5))
print('相乘')
print(arr4*arr3)
print('与单独的一个数据')
print(arr4*100)
print(arr4*100.0)
print('--------------------------')
arr5 = np.array([0,1,2,3,4])
print(arr4+arr5)

展示
相乘
[[ 10  40  90 160 250]]
与单独的一个数据
[[1000 2000 3000 4000 5000]]
[[1000. 2000. 3000. 4000. 5000.]]
--------------------------
[[10 21 32 43 54]]
注意点:
数组的唯维度大小必须一致

多维和多维(维度必须相同即行列必须一致) | 与单独的一个数据

import numpy as np

arr1 = np.arange(1,6)
arr2 = np.array([10,20,30,40,50])
arr3 = arr1.reshape((1,5))
arr4 = arr2.reshape((1,5))
print('相乘')
print(arr4*arr3)
print('与单独的一个数据')
print(arr4*100)
print(arr4*100.0)
print('--------------------------')
arr5 = np.array([0,1,2,3,4])
print(arr4+arr5)

展示
相乘
[[ 10  40  90 160 250]]
与单独的一个数据
[[1000 2000 3000 4000 5000]]
[[1000. 2000. 3000. 4000. 5000.]]
--------------------------
[[10 21 32 43 54]]
注意点:
数组的唯维度大小必须一致