主要介绍了numpy库的基础函数及简单使用，文中的注意部分，添加了作者的一些理解，以及与R语言的不同之处，作为作者的笔记

1.numpy的基本属性

导入numpy库，传统上numpy别名为np
方法array，创建数组

import numpy as np #导入numpy库并取别名为np
array=np.array([[1,2,3],
                [4,5,6],
                [7,8,9]])#新建一个数组

print(array)#输出数组
[[1 2 3]
 [4 5 6]
 [7 8 9]]

属性ndim，数组维度

print(array.ndim)#数组维度
2

注：[[[1,2,3],
[4,5,6],
[7,8,9]]]
是3维的数组

属性shape，数组形状

print(array.shape)#数组形状
(3, 3)#第一个3是3行，第二个3是3列

属性size，数组大小（数组中元素的个数）

print(array.size)#数组大小（数组中元素的个数）
9

属性dtype，数组中元素类型

print(array.dtype)#数组中元素类型
int32

注：二维数组其实就是矩阵

2.创建array

array方法，创建数组时指定元素类型

a=np.array([1,2,3],dtype=np.int32)#创建数组时指定元素类型
print(a.dtype)
int32

array方法，创建数组时指定元素类型（浮点型）

b=np.array([1,2,3],dtype=np.float)#（浮点型）
print(b.dtype)
float64

array方法，创建一维数组

c=np.array([1,2,3])#创建一维数组
print(c)
[1 2 3]

array方法，创建二维数组（矩阵）**[[[1,2,3]]]三维数组

d=np.array([[1,2,3],
          [4,5,6]])#创建二维数组（矩阵）**[[[1,2,3]]]三维数组
print(d)
[[1 2 3]
 [4 5 6]]

zeros方法，创建指定行列数量的数值全为0数组

zero=np.zeros((2,3))#创建指定行列数量的数值全为0数组
print(zero)
[[0. 0. 0.]
 [0. 0. 0.]]

#ones方法，创建指定行列数量的数值全为1数组

one=np.ones((3,4))#创建指定行列数量的数值全为1数组
print(one)
[[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]

empty方法，创建指定行列数量的数值全接近于0数组（但不等于0）

empty=np.empty((3,2))#创建指定行列数量的数值全接近于0数组（但不等于0）
print(empty)
[[2.33e-321 2.33e-321]
 [5.89e-321 5.89e-321]
 [6.03e-321 6.03e-321]]

arange方法，创建数组

e=np.arange(10)#创建[0-9]的数组，arange方法，默认从0开始，数值间隔是1，且左闭右开，因此取不到10
print(e)
[0 1 2 3 4 5 6 7 8 9]

arange方法，设置初始值为4，末尾值为12（但取不到末尾值，如下结果），数值间隔默认为1

f=np.arange(4,12)#初始值为4，末尾值为12（但取不到末尾值，如下结果）
print(f)
[ 4  5  6  7  8  9 10 11]

arange方法，指定了初始值，末尾值以及数值间隔

g=np.arange(1,20,3)#指定了初始值，数值间隔以及末尾值
print(g)
[ 1  4  7 10 13 16 19]

reshape方法，可以指定生成数组的维度，（行，列）

h=np.arange(8).reshape((2,4))#reshape方法可以指定生成数组的维度，（行，列）
print(h)
[[0 1 2 3]
 [4 5 6 7]]

3.numpy的基本运算

注：注释中涉及到对应位置的两个矩阵的运算时，这两个矩阵必须有相同的行列数量。
array方法，生成矩阵

arr1=np.array([[1,2,3],
              [4,5,6]])
arr2=np.array([[1,1,2],
               [2,3,3]])#生成矩阵
print(arr1)
print(arr2)
[[1 2 3]
 [4 5 6]]
 
[[1 1 2]
 [2 3 3]]

python基本数学运算（加，减，乘，除，幂运算，取余，取整）

print(arr1+arr2)#对应位置相加
print(arr1-arr2)#对应位置相减
print(arr1*arr2)#对应位置相乘
print(arr1/arr2)#对应位置相除
print(arr1**arr2)#对应位置幂运算
print(arr1%arr2)#对应位置取余
print(arr1//arr2)#对应位置取整
print(arr1+2)#所有的元素都加2 （-也一样）
print(arr1*10)#所有的元素都乘以10 （/也一样）
[[2 3 5]
 [6 8 9]]
 
 [[0 1 1]
 [2 2 3]]

[[ 1  2  6]
 [ 8 15 18]]

[[1.         2.         1.5       ]
 [2.         1.66666667 2.        ]]
 
[[  1   2   9]
 [ 16 125 216]]

[[0 0 1]
 [0 2 0]]

[[1 2 1]
 [2 1 2]]

[[3 4 5]
 [6 7 8]]

[[10 20 30]
 [40 50 60]]

运算符>，判断哪些元素大于3

arr3=arr1>3#判断哪些元素大于3
print(arr3)
[[False False False]
 [ True  True  True]]

方法dot，矩阵乘法

arr4=np.ones((3,5))
print(arr4)
np.dot(arr1,arr4)#矩阵乘法
arr1.dot(arr4)#矩阵乘法
[[1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]]
 
array([[ 6.,  6.,  6.,  6.,  6.],
       [15., 15., 15., 15., 15.]])
       
array([[ 6.,  6.,  6.,  6.,  6.],
       [15., 15., 15., 15., 15.]])

“T”实现矩阵转置

print(arr1.T)#矩阵转置
print(np.transpose(arr1))#矩阵转置
[[1 4]
 [2 5]
 [3 6]]
 
[[1 4]
 [2 5]
 [3 6]]

4.随机数生成以及矩阵的运算

random.random方法，生成3行2列从0到1的随机数

sample1=np.random.random((3,2))#生成3行2列从0到1的随机数
print(sample1)
[[0.0091066  0.88726298]
 [0.67338957 0.7218163 ]
 [0.83577629 0.31244609]]

random.normal方法，生成3行2列符合标准正态分布的随机数

sample2=np.random.normal(size=(3,2))#生成3行2列符合标准正态分布的随机数
print(sample2)
[[-0.5937719  -1.68314692]
 [-2.17329162 -1.24606196]
 [-0.64061484  0.8684897 ]]

random.randint方法，生成3行2列从0到10的随机整数（左闭右开）

sample3=np.random.randint(0,10,size=(3,2))#生成3行2列从0到10的随机整数（左闭右开）
print(sample3)
[[3 6]
 [1 6]
 [9 2]]

sum方法，求和

np.sum(sample1)#求和
3.4397978414661368

min方法，求最小值

np.min(sample1)#求最小值
0.009106601657770219

max方法，求最大值

np.max(sample1)#求最大值
0.8872629810672253

sum(matrix,axis=0/1)方法,对矩阵列/行求和
对矩阵列求和

np.sum(sample1,axis=0)#对矩阵列求和
array([1.51827246, 1.92152538])

对矩阵行求和

np.sum(sample1,axis=1)#对矩阵行求和
array([0.89636958, 1.39520588, 1.14822238])

#argmin方法，求最小值的索引（python中矩阵索引从0开始，横着数。R中矩阵索引从1开始，竖着数。）

np.argmin(sample1)#求最小值的索引（python中矩阵索引从0开始，横着数。R中矩阵索引从1开始，竖着数。）
0

argmax方法，求最大值的索引

np.argmax(sample1)#求最大值的索引
1

mean方法，求平均值

print(np.mean(sample1))#求平均值
print(sample1.mean())#求平均值
0.5732996402443561

0.5732996402443561

median方法，求中位数

np.median(sample1)#求中位数
0.6976029390777937

sqrt方法，开方

np.sqrt(sample1)#开方
array([[0.09542852, 0.94194638],
       [0.82060318, 0.84959773],
       [0.91420801, 0.55896878]])

random.randint方法，生成1行10列从0到10的随机整数（左闭右开）

sample4=np.random.randint(0,10,size=(1,10))#生成1行10列从0到10的随机整数（左闭右开）
print(sample4)
[[0 5 1 8 1 4 0 8 7 2]]

sort方法，排序

np.sort(sample4)#排序
array([[0, 0, 1, 1, 2, 4, 5, 7, 8, 8]])

sort方法参数为矩阵时，对矩阵的每一行进行排序

np.sort(sample1)#对矩阵的每一行进行排序
array([[0.0091066 , 0.88726298],
       [0.67338957, 0.7218163 ],
       [0.31244609, 0.83577629]])

clip方法，设置最大值和最小值，小于2的变成2，大于7的变成7

np.clip(sample4,2,7)#小于2的变成2，大于7的变成7
array([[2, 5, 2, 7, 2, 4, 2, 7, 7, 2]])

注：numpy中绝大多数区间都是左闭右开

5.numpy的索引

注：numpy中索引从0开始，python中负号(-)索引表示倒数第几个数据，例如-1代表数组倒数第一个元素即末尾元素a = np.array([1,2,3]),a[-1]=3 。而R中索引从1开始，负号(-)索引则代表删除这一索引下的元素，例如a <- c(1,2,3),a[-1]=2,3

生成数据

arr1=np.arange(2,14)
print(arr1)
[ 2  3  4  5  6  7  8  9 10 11 12 13]

第二个位置的数据

print(arr1[2])#第二个位置的数据
4

第一到第四个位置的数据

print(arr1[1:4])#第一到第四个位置的数据（左闭右开，因此不包括第四个）
[3 4 5]

倒数第一个位置的数据

print(arr1[-1])#倒数第一个位置的数据
13

第二到倒数第一个位置的数据

print(arr1[2:-1])#第二到倒数第一个位置的数据（左闭右开，因此不包括倒数第一个）
[ 4  5  6  7  8  9 10 11 12]

注：":“左边默认为0，”:"右边默认为倒数第一个位置（且包括这个位置）
从第0个位置到第五个位置的数据

print(arr1[:5])#从第0个位置到第五个位置的数据（左闭右开，因此不包括倒数第五个）
[2 3 4 5 6]

从倒数第二个位置到末尾位置数据(且包括末尾位置数据)

print(arr1[-2:])#从倒数第二个位置到末尾位置数据
[12 13]

reshape函数，将数组调整为矩阵

arr2=arr1.reshape(3,4)#将数组调整为矩阵
print(arr2)
[[ 2  3  4  5]
 [ 6  7  8  9]
 [10 11 12 13]]

注意：在python的矩阵中基本单位为行，而在R中矩阵（matrix）的基本单位为每个单元（即一个数值），R中数据框（data.frame）的基本单元为列（理解为向量就是竖着排列的，而data.frame就是多向量的组合）
（python中矩阵中每个单元（即一个数值）的索引从0开始，横着数。R中矩阵和数据框索引从1开始，竖着数。）
在一些判断条件下（即需要返回索引值的函数），上面（）中说的就是如何找到满足条件的元素（即一个数值）在矩阵和数据框中的位置。

返回位置为1的行(可以证明在python的矩阵中基本单位为行)

print(arr2[1])#返回位置为1的行
[6 7 8 9]

返回位置在1行1列的数据
注意：第二种方式类似R，R和python都是 ','左面是行， ','左面是列。

print(arr2[1][1])#返回位置在1行1列的数据
print(arr2[1,1])#返回位置在1行1列的数据
7

7

返回位置为2的列（即返回第三列）
注意：在R中arr2[,2]为返回第二列

print(arr2[:,2])#返回位置为2的列
[ 4  8 12]

注意：以下for循环证明python中矩阵的基本单位为行
迭代行

for i in arr2:#迭代行
    print(i)
[2 3 4 5]
[6 7 8 9]
[10 11 12 13]

迭代列

for i in arr2.T:#迭代列
    print(i)
[ 2  6 10]
[ 3  7 11]
[ 4  8 12]
[ 5  9 13]

迭代单元（迭代每个单元，即每个数值）
注：.flat可以实现数据格式的扁平化（以我目前的理解就是将多维数据格式拉到一维），arr2.flat实现了从二维数组即矩阵拉倒一维数组的操作

for i in arr2.flat:#迭代单元（迭代每个单元，即每个数值）
    print(i)
2
3
4
5
6
7
8
9
10
11
12
13

扁平化案例：
源字典为
{‘a’:{‘b’:1,‘c’:2},‘d’:{‘e’:3,‘f’:{‘g’:4}}}
扁平化后
{‘a.b’: 1, ‘a.c’: 2, ‘d.e’: 3, ‘d.f.g’: 4}