数据分析-numpy的运用(多维数组的创建与矩阵计算)
数据分析
- 1、numpy：多维数组的创建
- 1.1 随机抽样创建
- 1.1.1 rand
- 1.1.2 uniform
- 1.1.3 randint
- 总结
- 1.2 序列创建
- 1.2.1 array
- 1.2.2 zeros
- 1.2.3 ones
- 1.2.4 arange
- 总结
- 1.3 数组重新排列--shuffle
- 1.4 astype数据类型的转换
- 数组转列表
- 总结
- 2、numpy的矩阵计算
- 2.1 相加(下标相同的相加)
- 一维数组与多维数组(数组列数必须相同)
- 多维和多维(维度必须相同即行列必须一致) | 与单独的一个数据
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]]
注意点:
数组的唯维度大小必须一致