数据分析-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]]
注意点:
数组的唯维度大小必须一致

你可能感兴趣的:(数据分析)