python中的numpy库的简单使用，数组对象的属性与方法，类型等

Numpy是用于数据科学计算的基础，不但能够完成科学计算任务，还能被 用作高效地多维数据容器。用于存储和处理大型矩阵。
Python提供了一个array模块，和list不同，它直接保存数值，但是由于 Python 的array模块不支持多维，也没有各种运算函数。
Numpy 弥补了这一遗憾。Numpy提供了一种存储单一数据类型的多维数 组——ndarray(下文统称数组)

数组是用一块整体的内存来储存数据
有C和F两种储存风格
C风格指的是按行存储
F风格是按列存储

数组有哪些属性呢？
1，ndim -数组的维度
2，shape -数组的形状
3，size -数组的个数
4，dtyoe -数组的类型
5，itemsize -数组的每个元素的大小

import numpy as np

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

print('数组的维度：',a.ndim)
print('数组的元素个数：',a.size)
print('数组每个元素的大小：',a.itemsize)
print('数组的元素的类型：',a.dtype)
print('数组的形状尺寸：',a.shape)

结果

<class 'numpy.ndarray'>
[[1 2 3]
 [4 5 6]]
数组的维度： 2
数组的元素个数： 6
数组每个元素的大小： 4
数组的元素的类型： int32
数组的形状尺寸： (2, 3)

这里唯一比较难理解的可能就是维度问题了
简单点说：

a1 = np.array(1)  #纯数字就是1维
a2 = np.array([1,2,3])  #通过一个下标值确定位置的就是一维
a3 = np.array([[1,2],[3,4]])  #例如二维表，通过两个下标值确定值的位置的就是二维
a4 = np.array([[[1,2],[3,4]],[[5,6],[7,8]]])  #通过三个下标值确定位置的就是三维
print(a1.ndim)
print(a2.ndim)
print(a3.ndim)
print(a4.ndim)

结果

0
1
2
3

数组的属性看完了，来看一些生成数组对象的函数：

#左闭右开，开始值，结束值，步长
arr = np.arange(0,6,1)  #需要注意了，不是开始位置，结束位置，而是开始值，结束值
print(arr)
arr = np.arange(0,6,2)
print(arr)
arr = np.arange(0,6,0.5)
print(arr)

#左开右闭，开始值，结束值，元素个数
arr = np.linspace(0,6,12)
print(arr)
arr = np.linspace(0,5,6)
print(arr)

#等比数列，起始值为10的几次方，结束值为10的几次方，中间生成多少个参数
arr = np.logspace(1,2,20)
print(arr)
arr = np.logspace(0,3,20)
print(arr)

#生成一个二行三列的元素为0的数组
arr = np.zeros(shape=(2,3))
print(type(arr))
print('arr：\n',arr)

#生成一个二行三列的元素为1的数组
arr=np.ones(shape=(2,3))
print(type(arr))
print('arr：\n',arr)


#k=0代表对角线
# k>0代表着对角线位置的1 向上移动k个元素
# k<0代表着对角线位置的1 向下移动k个元素
#如果k超出移动范围，则生成（N,M)的零矩阵
arr=np.eye(N=3,M=3,k=0)
print(type(arr))
print('arr：\n',arr)


# diag生成一个对角举证数组，参数为对角线上的值，k=0
arr=np.diag([1,2,3,4],k=-2)
print(type(arr))
print('arr：\n',arr)
arr=np.diag([[1,2,3],[4,5,6]],k=1)
print(type(arr))
print('arr：\n',arr)


#random  生成随机数组 随机分布
#随机生成[0,1)中任意小数
#参数为 元素个数 或者要生成数组的shape
arr=np.random.random((2,3))
arr2=np.random.random(3)
print(type(arr))
print('arr：\n',arr)
print('arr：\n',arr2)


#生成符合均匀分布的[0,1)的数组
#参数为元素个数，或者行列数
arr=np.random.rand(5)
# arr=np.random.rand((5,5)) (X错误)不能为元组
print(type(arr))
print('arr：\n',arr)


#正态分布---概率分布 ---->需要大量数据支撑
# 标准正态分布
# 均值为0 标准差为1
# 均值反应的数据位置
# 标准差反映的是数据离散程度

# 生成一个符合正态分布的数组
# 生成的是标准正态分布的数组
# 参数为元素个数或者行列数
arr=np.random.randn(2,3)
print(type(arr))
print('arr：\n',arr)

#生成固定范围内的，固定形状数组
arr = np.random.randint(0,5,size=[2,3])
# 如果不传size ,生成一个随机整数。
arr2 = np.random.randint(0,5)
print(type(arr))
print('arr：\n',arr)
print('arr2：\n',arr2)

结果

======arange======
[0 1 2 3 4 5]
[0 2 4]
[0.  0.5 1.  1.5 2.  2.5 3.  3.5 4.  4.5 5.  5.5]
======linspace======
[0.         0.54545455 1.09090909 1.63636364 2.18181818 2.72727273
 3.27272727 3.81818182 4.36363636 4.90909091 5.45454545 6.        ]
[0. 1. 2. 3. 4. 5.]
======logspace======
[ 10.          11.28837892  12.74274986  14.38449888  16.23776739
  18.32980711  20.69138081  23.35721469  26.36650899  29.76351442
  33.59818286  37.92690191  42.81332399  48.32930239  54.55594781
  61.58482111  69.51927962  78.47599704  88.58667904 100.        ]
[   1.            1.43844989    2.06913808    2.97635144    4.2813324
    6.15848211    8.8586679    12.74274986   18.32980711   26.36650899
   37.92690191   54.55594781   78.47599704  112.88378917  162.37767392
  233.57214691  335.98182863  483.29302386  695.19279618 1000.        ]
======zeros======
<class 'numpy.ndarray'>
arr：
 [[0. 0. 0.]
 [0. 0. 0.]]
======ones======
<class 'numpy.ndarray'>
arr：
 [[1. 1. 1.]
 [1. 1. 1.]]
======eye======
<class 'numpy.ndarray'>
arr：
 [[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
======diag======
<class 'numpy.ndarray'>
arr：
 [[0 0 0 0 0 0]
 [0 0 0 0 0 0]
 [1 0 0 0 0 0]
 [0 2 0 0 0 0]
 [0 0 3 0 0 0]
 [0 0 0 4 0 0]]
<class 'numpy.ndarray'>
arr：
 [2 6]
======random======
<class 'numpy.ndarray'>
arr：
 [[0.75122297 0.03478798 0.91065627]
 [0.6693507  0.070632   0.1071566 ]]
arr：
 [0.93847575 0.52454087 0.28859977]
======rand======
<class 'numpy.ndarray'>
arr：
 [0.66879247 0.4428368  0.90887466 0.10200142 0.12562226]
======randn======
<class 'numpy.ndarray'>
arr：
 [[-0.55263598 -0.60320808  0.00364075]
 [ 0.92193869  0.90639252 -0.31147176]]
======randint======
<class 'numpy.ndarray'>
arr：
 [[4 1 1]
 [3 2 3]]
arr2：
 0

random模块常用函数：
1，seed 确定随机数生成器的种子。
2，permutation 返回一个序列的随机排列或返回一个随机排列的范围。
3，shuffle 对一个序列进行随机排序。
4，binomial 产生二项分布的随机数。
5，normal 产生正态（高斯）分布的随机数。
6，beta 产生beta分布的随机数。
7，chisquare 产生卡方分布的随机数。
8，gamma 产生gamma分布的随机数。
9，uniform 产生在[0,1)中均匀分布的随机数。

接下来可以看一下数组形状类型的转变

import numpy as np

#先用arange生成一个一维数组
arr = np.arange(6)
print(arr)
print(arr.shape)
arr.shape = (2,3)  #将原本的形状改为（2,3），记住，改变形状也不能改变数组内元素原本的数量
print(arr)

arr = arr.reshape((2,3))  #这是第二种改变数组形状的方法
print(arr)


# dtype --数据类型
# np.int32  np.int64
# 生成数组的时候可以通过dtype来设置数据类型
arr = np.arange(6,dtype=np.float64).reshape((2,3))  #生成一个元素类型为浮点型，形状为（2,3）的数组
print("arr:\n",arr)
print("arr 数据类型:\n",arr.dtype)

# 也可以强制转化
num = np.float64(32)  #float64也可以直接转换数字
print(num)
print(type(num))  #但依旧是float64对象

# 在numpy里面 0 转化为Bool类型  为False
# 非0 转化为bool 为True
print(np.bool(1))  
print(np.bool(0))

#自定义数据类型
#这里，我们定义数组内第一个元素为字符类型，第二与第三元素为浮点类型
df = np.dtype([("name",np.str_,20),('height',np.float64),("weight",np.float64)])

arr = np.array([('bq',170.0,55.1),('sz',178.2,80.1),('yf',176.2,75.3)],dtype=df)
print(arr)
print(arr.dtype)  #打印出来的为类型的别名

结果

========改变形状========
[0 1 2 3 4 5]
(6,)
[[0 1 2]
 [3 4 5]]
[[0 1 2]
 [3 4 5]]
========转换数据类型========
arr:
 [[0. 1. 2.]
 [3. 4. 5.]]
arr 数据类型:
 float64
========强制转换数据类型========
32.0
<class 'numpy.float64'>
True
False
========自定义数据类型========
[('bq', 170. , 55.1) ('sz', 178.2, 80.1) ('yf', 176.2, 75.3)]
[('name', '<U20'), ('height', '<f8'), ('weight', '<f8')]

numpy的基本数据类型：
bool 用一位存储的布尔类型（值为TRUE或FALSE）
inti 由所在平台决定其精度的整数（一般为int32或int64）
int8 整数，范围为−128至127
int16 整数，范围为−32768至32767
int32等