前言

   最近开始学习Data anaysis，将numpy入门学习日记分享出来，也当做个记录。

 【Numpy官网学习地址】：Click Here

   备注：

        我尽可能的将官网快速教程中的case都贴出来了，但越往下越发现这个库是真的庞大，教程也是由浅及深，后面会涉及到向量、线性代数等高数概念，这个日记中不会提到，需要的话自行前往官网查看。这个日记分为两个Section，加起来可能占到官网快速教程中的case的80%左右，入门Numpy足矣。

    Numpy日记 Section.2

正文

import numpy as np

#基本的几种数组创建方式
a = np.arange(0,10) #创建一维数组
b = a.reshape(2,5)  #临时变换为二维数组

a_ = np.array([[1,2,3],range(1,4)])  #创建二维数组
print(a_,'\n',a_.ndim)  #打印数组和其维数

a0 = [1,2,4]
aa = np.array(a0)#创建一维数组


#数组类型：：指定数组元素类型来创建数组

a1 = np.float32(range(9))
a1_used_mem = a1.itemsize*a1.size #32/8*9

a2 = np.int_(range(3))
a3 = np.arange(-5,5,dtype=np.uint)

#创建指定size的数组，zeros，ones，empty
a4 = np.zeros((2,3,4))
a5 = np.ones((2,3,4))
a6 = np.empty((2,3,4))
print(a6,1111)
#三个数表示维数是3，第一个数2表示结果包含两个2维数组（维数-1），第二个指定每个二维数组的列长，
# 第三个指定每个二维数组的行长(这是shape传入三个数的情况)


#指定范围内取指定元素个数生成数组
a7 = np.linspace(0,2,9,dtype=np.float16)


#打印大型数组的所有内容
np.set_printoptions(threshold=np.nan)
a8 = np.arange(100000,dtype=np.int_)
a8 = a8.reshape((10,10000))


#数组的算术运算,例举部分
a9 = np.array([10,20,30,40])
t = np.arange(4)
a99_ = a9 - t  #差  [10 19 28 37]
a99x = t**2 #幂  [0 1 4 9]
a99sin = np.sin(a9)  #正弦值    [-0.54402111  0.91294525 -0.98803162  0.74511316]

#判断数组的每个元素是否满足某个条件
a10 = np.array([1,2,4,66])
a10_ = 3 < a10  #  [False False  True  True]
a11 = np.array([0,2,4,66])
a11_ = (a10 == a11)  # [False  True  True  True] 不加括号也行

#dot 代表矩阵的乘法运算，点积:dot product
# 计算方式：数组A的第一行与数组B的第一列的对应各元素乘积之和->作为结果数组的第一行第一列位置的元素值。
a10 = np.array([[1,2],
                [4,5]])

a11 = np.array([[2,4],
                [3,2]])

a10_11 = a10.dot(a11) #区别于* ,后者是对应位置元素简单相乘得到结果数组
dot_10_11 = np.dot(a10,a11)  #结果同上

# 关于+=  *=的运算方式
a12 = np.ones((3,4),dtype=np.int32)  #int 可换成np.int32,但区别于np.int8 /int16等，数字表示单个元素占用内存的bit大小，8即8bit=1byte
a12 += 9  #该运算会直接修改a12 ，不会产生新变量
a12 *= 2  #a12变成shape 为(3,4)的全20二维数组

#对两个不同元素类型的数组进行算术运算时，结果数组的元素类型将会是更精确或更常见的那一类。
a13 = np.zeros((2,2),dtype=int) #创建一个二维全0数组对象
t1 = np.linspace(0,np.pi,4) #创建一个一维数组，4个元素， np.pi=π=3.141592653589793
t1 = t1.reshape(2,2)   #变换为二维

a13_t1 = a13 + t1  #两个多维数组(矩阵)长宽一致/形状吻合/shape相等，才可以进行算术运算

#print(a13.dtype,t1.dtype)
#a13的dtype是np.int32(=python中的int), t1的是np.float64 ,运算后的结果数组dtype选择更精确的float64


#大部分一元运算，如求和，最大最小值等都可以使用np自带的方法快速实现
a14 = np.random.random((2,3)) #创建一个随机二维数组，shape为2,3
a14_sum = a14.sum() #最大a14.max()  最小a14.min()

#如何针对列和行进行运算，如求每列/每行的和、最大最小值
a15 = np.arange(12).reshape(3,4)
a15_col = a15.sum(axis=0)
a15_row = a15.max(axis=1)
#print(a15_col,a15_row)  #[12 15 18 21] [ 3  7 11]


#如何方便的应用数学中的函数，如exp，开平方等
#需要用到np中的通用函数

a16 = np.array([0,1,2])
a16_exp = np.exp(a16) #[ 1. ,  2.71828183,  7.3890561 ]
a16_sqrt = np.sqrt(a16)  #[0.    1.    1.41421356] 对0开方不会报错
a16_add = np.add(a16,range(3),dtype=float) #[0. 2. 4.]   可直接和list进行算术运算,可以指定dtype


#其他常用操作，如排序
a17 = np.array([[3,2,1],[2,3,0]])
a17_sort = np.sort(a17) #[[1 2 3],[0 2 3]]
a17_sort_no_axis = np.sort(a17,axis=None)  #[0 1 2 2 3 3]，转换为一维数组
a17_sort_for_col = np.sort(a17,axis=0)  #对每列元素进行排序
a17_sort_for_row = np.sort(a17,axis=1)  #对每行元素排序，等效于np.sort(a17)


#退一取整:floor，进一取整:ceil, 均值
a18 = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])
a18_floor = np.floor(a18) #[-2. -2. -1.  0.  1.  1.  2.]  使元素值尽量减小
a18_ceil = np.ceil(a18)  #[-1. -1. -0.  1.  2.  2.  2.]  使元素值尽量增大
a18_ave = np.average(a18) #元素平均值  0.2857142857142857,也可以传axis参数
print(a18_ave)


#矩阵内的元素累加:cumsum  若不传参,会将任意大小的矩阵视为一维数组，
# 然后进行元素累加产生新的一维数组
a19 = np.arange(12).reshape(3,4)
print(a19)
a19_reduce = a19.cumsum()  #[ 0  1  3  6 10 15...]
# 第一个数不变，第二个数为前两个数的和，第三个数为前三个数的和，类推


#一维数组的索引、分片、遍历 [和list用法大部分一致]
a20 = np.arange(0,20,2)**3  #每个元素进行立方运算
a20_5 = a20[5]
a20_f1 = a20[-1]
a20_5_to_10 = a20[5:10]
a20_3_colon = a20[::2]
for i in a20:print(i)

#多维数组的索引、分片用法
def f(x,y):
    return 10*x+y
a21 = np.fromfunction(f, (5,4), dtype=int) #使用函数构建一个二维数组,断电调试可观察构建过程
a21_2 = a21[2]  # 一个一维数组
a21_comma_2_3 = a21[2,3] # 一个元素
a21_colon_2 = a21[2:3]  # 一个二维数组
a21_comma_colon_02_f1 = a21[0:2,-1]
a21_comma_colon_f1 = a21[:,-1]
a21_comma_colon_ = a21[:,:] # all

#无逗号时，索引引指定哪个/哪些较低一维的数组
#逗号分隔时，逗号前的索引指定哪个/哪些较低一维的数组,逗号后的索引，对前面索引出来的数组进行再索引，可理解为递归索引
#续上一行，例如此处案例是个二维数组，逗号前的索引就是索引出符合条件的一维数组，逗号后的索引就是对前者输出的一维数组进行再次索引，
# 一维数组的索引结构就好比list的索引
#若是对一个三维（以上的）数组进行操作，同理，注意观察结果

a21_3_ndim = np.zeros((2,3,4)) #创建一个3维数组，包含两个2维数组，每个2维数组3行4列
a21_3_ndim[0] = 1
#print(a21_3_ndim)
a21_3_ndim[1:2] = 2
#print(a21_3_ndim)
a21_3_ndim[0:1,-1] = 0.5
#print(a21_3_ndim)
a21_3_ndim[-1,2,-1] = 0.1
#只有多维数组的情况下才会出现2个逗号(以上)的索引用法，因为定位到元素的索引步骤会随着维度的增加而增加

#3个点的用法：在遇到多维数组的情况下，[...]可用来代替部分索引的编写，类似py3中的*rest用法
a21_3_ndim[...,-1] = 0.2 #同 [:,:,-1]
a21_3_ndim[0,0,...] = 0.4 #同 [0,0,:]


# for i in a21_3_ndim:print(i) #对多维（N）数组进行遍历的的时候
# 输出的一级变量遍历永远是（N-1）维数组,若是一维数组，则直接输出元素


#高级索引用法 ：“数组索引”
# https://docs.scipy.org/doc/numpy/user/quickstart.html#fancy-indexing-and-index-tricks
a22 = np.array([[1, 2], [3, 4], [5, 6]]) #一个二维数组
a22_ad_index_1 = a22[[0,1,2],[0,1,0]] #[1 4 5] 第一个数组进行第一次索引，第二个数组对前者得出的结果进行二次索引,多练习可领会
a22_ad_index_2 = a22[[0],[0]] #[1]
a22_ad_index_3 = a22[[0]] #[[1 2]]

#高级索引得到的结构始终是一个ndarray对象
a22_t = np.ones((5,4,5))  #创建一个3维数组，包含5个2维数组，每个2维数组4行5列
#print(a22_t)
a22_t[[-2,-1], [0,1]] = 2
#print(a22_t)
a22_t[[-2,-1], [0,1], [1,2]] = 3
#print(a22_t)

#高级索引之布尔类型索引
a22_t1 = np.arange(4)
a22_t1[a22_t1>1] = 6
print(a22_t1)  #[0 1 6 6]


#取出每列或每行中最大(小)值的索引
a22_t2 = np.array([range(3),range(3,6),[2,11,1]])
print(a22_t2)
print(a22_t2.argmax(axis=1))  #[2 2 1]
#axis=0表示按列，  1表示按行  ， argmin：取出最小值的索引