# Numpy

import numpy as np

# 数据类型

numpy中可以有如下数据类型 可以接收list，tuple

# 创建数组

数组的元素类型必须相同，且初始化之后就无法修改类型！可以通过a.astype(np.float)生成指定类型新数组

• np.array()
  • np.array([[数组],[数组]],dtype=np.表中数据类型)
  • 默认元素类型为int32,可以使用dtype指定
• np.arange(n)
  • np.arange(x,y,dtype=np.表中数据类型)
  • 创建从x到y的一维数组。默认从0开始
• np.linspace(x,y,n,endpoint=True)
  • 从x到y生成n个等距离浮点数一维数组
  • endpoint默认True
• np.zeros((x,y))/np.ones((x,y))
  • 生成x行y列的全0/1数组
• np.zeros_like(size)/np.ones_like(size)
  • 生成规模为size的全0/1数组，想要创造和其他数组规模一致的全0-1数组使用
• np.full((x,y),n)/np.empty((x,y))
  • 生成x行y列的全n/随机未初始化数组
• np.full_like(array,n)
  • 生成和array规模一致的全n数组
• np.identity(n)
  • 生成和对角线为1的n*n数组
• np.diag([一维数组],k=0)
  • 把以一维数组作为对角线k为偏移生成数组。规模由一维数组决定
• np.eye(x,y,k=0,dtype=np.int)
  • 生成x行y列的数组
  • 默认情况下输出的是对角线全1，其余全0的方阵，如果k为正整数，则在右上方第k条对角线全1其余全0，k为负整数则在左下方第k条对角线全1其余全0。
• numpy.asarray(iterable, dtype = None, order = None)
  • 传入列表, 列表的元组, 元组, 元组的元组, 元组的列表，多维数组，指定类型和行列优先("C","F")
• numpy.fromiter(iterable, dtype, count=-1)
  • 传入可迭代对象，默认-1数据全部读取
• np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)
  • 生成数列之后取㏒对数，底默认为10
  • start 序列的起始值
  • stop 序列的终止值为
  • num 要生成的等步长的样本数量，默认为50
  • endpoint 该值为 ture 时，数列中中包含stop值，反之不包含，默认是True。
  • base 对数 log 的底数
  • dtype ndarray 的数据类型

import numpy as np
a=np.array([1,2,3])#从序列生成数组
b=np.arange(1,10,2,dtype=np.float32)#顺序生成数组默认0，步长为2，有头没尾
c=np.linspace(1,10,8,endpoint=True)#1到10生成8个等距float,默认有尾
d=np.zeros((3,3))#x行y列的0数组
e=np.ones((4,5))#x行y列的1数组
f=np.full((4,5),7)#按照给定维度填充n生成的数组
g=np.empty((5,7))#随机未初始化的5行7列的空数组
h=np.eye(5,5,k=1,dtype=np.float)#x行y列,k默认为0全1对角线在中间。
x=(1,2,3,4,7,5,3,12)
i=np.asarray(x,dtype=np.float16,)#和np.array一样，不过可以用于迭代对象
j=np.logspace(1,16,num=10,endpoint=True, base=10.0)

a : [1 2 3] 

b : [1. 3. 5. 7. 9.] 

c : [ 1.          2.28571429  3.57142857  4.85714286  6.14285714  7.42857143
  8.71428571 10.        ] 

d : [[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]] 

e : [[1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]] 

f : [[7 7 7 7 7]
 [7 7 7 7 7]
 [7 7 7 7 7]
 [7 7 7 7 7]] 

g : [[ 0.00000000e+000  6.95302574e-310  1.19563886e-321              nan
   2.97400229e+222  2.31261091e-152  9.16526748e+242]
 [ 5.22864484e-067 -1.07080412e-237 -5.74085429e-208 -2.95588219e+191
   9.16526748e+242  7.97805968e-072  6.32300962e+233]
 [ 5.38210304e+228 -2.84647293e+198 -1.52258944e-156 -4.01320607e-020
   9.66537616e-070 -3.50225744e-015  2.28638615e-074]
 [-4.09008785e-203 -2.58641119e-247 -1.72482363e-063  6.32301179e+233
   7.92680158e-061  6.74108423e+199  6.90383683e-072]
 [ 6.12271013e+223  2.33365045e+030 -2.77780087e+179 -2.14709960e+186
  -1.48714169e-087  2.20892736e+161  1.32211967e-320]] 

h : [[0. 1. 0. 0. 0.]
 [0. 0. 1. 0. 0.]
 [0. 0. 0. 1. 0.]
 [0. 0. 0. 0. 1.]
 [0. 0. 0. 0. 0.]] 

i : [ 1.  2.  3.  4.  7.  5.  3. 12.] 

j : [1.00000000e+01 4.64158883e+02 2.15443469e+04 1.00000000e+06
 4.64158883e+07 2.15443469e+09 1.00000000e+11 4.64158883e+12
 2.15443469e+14 1.00000000e+16] 

# 从外部读取

# Random的数据分布

• np.random.random((2,3))
  • np.rand()
  • 2(x)行3(y)列的0-1之间的随机浮点数
• np.random.randint(0,10,(3,2))
  • 给定size和范围的随机整数，有头没尾（直接+1不就有尾了🤔
  • random_integers和这个一样不过这个是有头有尾的(已不推荐使用)
  • 0-10之间的两行三列的随机整数
• np.random.randn(size)
  • 产生给定siez大小的正态分布样本组成的数组，直接调用返回一个数
• np.random.random((2,3))
  • 2(x)行3(y)列的0-1之间的随机浮点数
• random.randrange(start, stop, step)
  • 返回以start开始，stop结束，step为步长的列表中的随机整数，三个参数均为整数（或者小数位为0），若start大于stop时 ，setp必须为负数.step不能是0.
• random.uniform(n1, n2)
  • 接受两个数字参数，返回两个数字区间的一个浮点数，不要求val1小于等于val2
• np.random.choice(x,(size))
  • 从x一维数组中随机选数组成给定size的数组
• np.random.shuffle(f)
  • 对自身起作用,只能这样调用
  • np.random.permutation(f)效果相同不过不对自身起作用而是返回
  • 打乱数组
• np.random.seed(5)
  • seed(n)设置随机数种子值，默认系统根据时间来自己选择这个值，此时每次生成的随机数因时间差异而不同
  • 在设置种子之后，本次程序运行使用random产生随机数的时候会根据这个值来产生
• numpy.random.normal(loc=0.0, scale=1.0, size=None)
  • loc：float此概率分布的均值（对应着整个分布的中心centre）
  • scale：float此概率分布的标准差（对应于分布的宽度，scale越大越矮胖，scale越小，越瘦高）
  • 正态分布，np.random.randn使用标准正态分布（μ=0,σ=1）也就是默认参数
    

a=np.random.random(10)#产生给定siez大小的0-1随机数组
b=np.random.rand(10)#等价于random
c=np.random.randn(5)#产生给定siez大小的正态分布样本组成的数组，直接调用返回一个数
d=np.random.randint(1,10,(2,3))
x=np.array([8,8,7,7])
e=np.random.choice(x,(3,4))#从数组里随机选取
f=np.arange(1,11,2)
g=np.random.permutation(f)#返回一个打乱的
np.random.shuffle(f)#对自身起作用,只能这样调用
num=0
np.random.seed(5)
while(num<5):
    print((np.random.random(),np.random.random()))
    num+=1
np.random.seed(5)
print((np.random.random(),np.random.random()))
print((np.random.random(),np.random.random()))
print((np.random.random(),np.random.random()))
for k,v in {'a':a,'b':b,'c':c,'d':d,'e':e,'f':f,'g':g,'h':h,'i':i,'j':j}.items():
    print(k,":",v,'\n')

(0.22199317108973948, 0.8707323061773764)
(0.20671915533942642, 0.9186109079379216)
(0.48841118879482914, 0.6117438629026457)
(0.7659078564803156, 0.5184179878729432)
(0.29680050157622195, 0.18772122866125163)
(0.22199317108973948, 0.8707323061773764)
(0.20671915533942642, 0.9186109079379216)
(0.48841118879482914, 0.6117438629026457)
a : [0.20671916 0.91861091 0.48841119 0.61174386 0.76590786 0.51841799
 0.2968005  0.18772123 0.08074127 0.7384403 ] 

b : [0.44130922 0.15830987 0.87993703 0.27408646 0.41423502 0.29607993
 0.62878791 0.57983781 0.5999292  0.26581912] 

c : [-0.98060789 -0.85685315 -0.87187918 -0.42250793  0.99643983] 

d : [[4 2 8]
 [4 2 6]] 

e : [[7 8 7 7]
 [7 7 8 7]
 [7 8 8 7]] 

f : [3 5 9 1 7] 

g : [5 9 3 1 7] 

h : [[0. 1. 0. 0. 0.]
 [0. 0. 1. 0. 0.]
 [0. 0. 0. 1. 0.]
 [0. 0. 0. 0. 1.]
 [0. 0. 0. 0. 0.]] 

i : [ 1.  2.  3.  4.  7.  5.  3. 12.] 

j : [1.00000000e+01 4.64158883e+02 2.15443469e+04 1.00000000e+06
 4.64158883e+07 2.15443469e+09 1.00000000e+11 4.64158883e+12
 2.15443469e+14 1.00000000e+16] 

# 数组的属性

属性不是函数；NumPy 数组的维数称为秩（rank），一维数组的秩为 1，二维数组的秩为 2，以此类推。在 NumPy中，每一个线性的数组称为是一个轴（axis），也就是维度（dimensions）

• ndarray.ndim 秩，即轴的数量或维度的数量
• ndarray.shape 数组的维度，对于数组，n 行 m 列
• ndarray.size 数组元素的总个数，相当于 .shape 中 n*m 的值
• ndarray.dtype ndarray 对象的元素类型
• ndarray.itemsize ndarray 对象中每个元素的大小，以字节为单位
• ndarray.flags ndarray 对象的内存信息
• ndarray.real ndarray元素的实部
• ndarray.imag ndarray 元素的虚部

a=np.array([1,4,5,7,3,2,3,5,7,6,4,2,2]dtype=np.float16).reshap()
#---结果---

a.ndim: 2 

a.shape: (2, 6) 

a.dtype: float16 

a.size: 12 

a.itemsize: 2 

a.flags:   C_CONTIGUOUS : True
 F_CONTIGUOUS : False
 OWNDATA : False
 WRITEABLE : True
 ALIGNED : True
 WRITEBACKIFCOPY : False
 UPDATEIFCOPY : False 
 
a.real: [[1. 4. 5. 7. 3. 2.]
 [3. 5. 7. 6. 4. 2.]] 
 
a.imag: [[0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0.]]

自定义类型

可以使用自定义类型的np，不过有这功夫为啥不去用pandas
np.dtype([('book','S40'),('version',np.int)])

mytype=np.dtype({"names":['book','version'],'formats':['S40',np.int]})
mytype=np.dtype([('book','S40'),('version',np.int)])#这样定义更习惯一些
mybook=np.array([('a',1),('b',2)],dtype=mytype)
mybook['book']
mybook['book'][0]

#---结果---

mytype: [('book', 'S40'), ('version', '<i4')] 
mybook: [(b'a', 1) (b'b', 2)] 
mybook["book"]: [b'a' b'b'] 
mybook["book"][0]: b'a'

# 四则运算

定义数组 a=np.array([1,2,3,4])
b=np.array([10,20,30,40])

加减，次方，相乘，每一项都分别相乘,乘数字也是一样的

• a+b->[11 22 33 44]
• a**2->[ 1 4 9 16]
• a*b->[ 10 40 90 160]

把每一项都做sin操作，把每一项都求sin，cos，tan，cot同理

• x=np.sin(a)

比较，返回一个同等规模的数组，该数组的项为每一项进行比较操作之后的结果，满足就为Ture，不满足就False

• x=(b<30)
• 支持与(and)或(or)非(not)
  

数组相乘的两种方法

• np.dot(a1,b1)==a1.dot(b1)

求一个数组所有元素的

• x=np.max(a) 最大
• x=np.min(a) 最小
• x=np.sum(a) 和

分别对行/列（用axis控制1行0列）求最大值最小值求和

• x=np.max(a,axis=1) 对行求最大
• x=np.min(a,axis=0) 对列求最小
• x=np.sum(a,axis=0) 对列求和

判等

• （a==b）.all()
  • 直接使用（a==b）是个同规模TorF数组，需要使用all
• np.any（a，axis=None，out=None）
  • a是类数组对象，只要a中（或者某个指定的轴中）有一个元素是True，则返回True，否则返回False。
  • array.any()可以直接调用
• np all（a，axis=None，out=None）
  • 如果类数组对象a（或者某个指定的轴中）所有元素都是True，则返回True，否则返回False。
  • array.all()可以直接调用

自定义处理函数
可以自定义处理函数，对每个值进行处理np.frompyfunc(func,nin,nout)func函数名字，nin接受几个参数，nout返回几个对象

import numpy as np
def a(x,y):
    return (x+y)/(x-y)
x=np.arange(1,11)
y=np.random.uniform(1,100,(10,))
myfun=np.frompyfunc(a,2,1)
myfun(x,y)

array([-1.0313295805710363, -1.0912359523752801, -3.1601351032809557,
       -1.1439328568074587, -1.2993873174977089, -1.2692649558730051,
       -1.1620112787552441, -1.6895206519886756, -1.3278806829928869,
       -1.8810816890174227], dtype=object)

# 排序搜索计数

排序函数

• np.sort(a, axis, kind='quicksort', order)
  • axis不填就变一维
  • order可以指定排序字段，在自定义数据结构时用

• np.argsort(x)
  • 返回数组从小到大的索引值
  • x=np.array([2,4,5,3,-10,1])；np.argsort(x) ：[4 5 0 3 1 2]

• np.lexsort(x)
  • 多数组排序,等用到再看吧。

x = np.linspace(3, 9, 100).reshape(10,10)
np.random.shuffle(x)
np.sort(x,axis=1,kind='heapsort')
------------------------------------------------
x=np.arange(0,32).reshape(2,4,4)
np.random.shuffle(x[0,3,...])
np.random.shuffle(x[1,...,0])
x,np.argsort(x[0])
------------------------------------------------

array([[6.03030303, 6.09090909, 6.15151515, 6.21212121, 6.27272727,
        6.33333333, 6.39393939, 6.45454545, 6.51515152, 6.57575758],
       [8.45454545, 8.51515152, 8.57575758, 8.63636364, 8.6969697 ,
        8.75757576, 8.81818182, 8.87878788, 8.93939394, 9.        ],
       [4.21212121, 4.27272727, 4.33333333, 4.39393939, 4.45454545,
        4.51515152, 4.57575758, 4.63636364, 4.6969697 , 4.75757576],
       [7.24242424, 7.3030303 , 7.36363636, 7.42424242, 7.48484848,
        7.54545455, 7.60606061, 7.66666667, 7.72727273, 7.78787879],
       [4.81818182, 4.87878788, 4.93939394, 5.        , 5.06060606,
        5.12121212, 5.18181818, 5.24242424, 5.3030303 , 5.36363636],
       [6.63636364, 6.6969697 , 6.75757576, 6.81818182, 6.87878788,
        6.93939394, 7.        , 7.06060606, 7.12121212, 7.18181818],
       [7.84848485, 7.90909091, 7.96969697, 8.03030303, 8.09090909,
        8.15151515, 8.21212121, 8.27272727, 8.33333333, 8.39393939],
       [5.42424242, 5.48484848, 5.54545455, 5.60606061, 5.66666667,
        5.72727273, 5.78787879, 5.84848485, 5.90909091, 5.96969697],
       [3.        , 3.06060606, 3.12121212, 3.18181818, 3.24242424,
        3.3030303 , 3.36363636, 3.42424242, 3.48484848, 3.54545455],
       [3.60606061, 3.66666667, 3.72727273, 3.78787879, 3.84848485,
        3.90909091, 3.96969697, 4.03030303, 4.09090909, 4.15151515]])
-----------------------------------------------------------------   
x:array([[[ 0,  1,  2,  3],
         [ 4,  5,  6,  7],
         [ 8,  9, 10, 11],
         [13, 12, 15, 14]],
 
        [[20, 17, 18, 19],
         [28, 21, 22, 23],
         [16, 25, 26, 27],
         [24, 29, 30, 31]]]),
         
x,np.argsort(x[0]):
array([[0, 1, 2, 3],
        [0, 1, 2, 3],
        [0, 1, 2, 3],
        [1, 0, 3, 2]], dtype=int64)    

搜索处理函数

• np.where(condition, [x, y])
  • 满足condition就返回x,不满足就返回y
  • 没给x，y只给了condition就返回满足condition的元素坐标，返回元组套array，维度应该满足原数组的维度。
  • np.nonzero(a)返回非零元素的的索引，速度约为你自己写的1.6倍😶
  • np.extract(condition,x)可以直接把元素抽出来变成一维数组
• np.select(conditionlist,choicelist,default=0)
  • 多条件筛选，数组可以输入多个，条件也可以有多个，支持与或非，看官网例子
• np.choose(a, choices, out=None, mode='raise')
  • 接受一个int型数组a
  • 默认raise，
• np.piecewise(x, cond, func)
  • 你可以把她想像成一个map函数，嗯就这样
  • 和select一个用法，见下例
• np.choose(x,[n1,n2....])
  • 具体干嘛用的，咱也不知道，咱也不敢问
  • 其实是做映射用的,x中的数值会被一一映射为n1，n2...所以元素种类个数一定要相同
• argmax(a)和argmin(a)
  • 返回最大值和最小值的下标。如果不指定axis，就返回一维化之后的数组下标。
  • np.nanargmin(a, axis=None)这个可以无视NaN，最大值也同样
  • np.argmax(np.bincount(a))找出a中出现最多的元素

a=np.random.randint(1,10,5)
np.where(a>3,"xxx",1) # 1
 
a = np.random.randint(1,100,8).reshape(2,2,2)
b=np.where(a>4) # 2
np.extract(a>4,a)
------------------------------------------------
x = np.arange(10)
condlist = [x<3, x>5]
choicelist = [x, x**2]
np.select(condlist, choicelist)
------------------------------------------------
x = np.linspace(3, 9, 100) 
cond = [x < 3, (3 <= x) & (x <= 9), x > 9]
func = [0, lambda x : (x - 3) / (9 - 3), 1]
np.piecewise(x, cond, func)
------------------------------------------------
a=np.array([3,4,6,3,3,3,3,3,3,3,45,12,2,1,1,23])
np.argmax(np.bincount(a))
------------------------------------------------

Click to See More Results

array(['xxx', 'xxx', 'xxx', '1', '1'], dtype='<U11') #1

(array([[[ 1, 97], # 2
         [14, 97]],
 
        [[70, 60],
         [41, 63]]])
         
 (array([0, 0, 0, 1, 1, 1, 1], dtype=int64),
  array([0, 1, 1, 0, 0, 1, 1], dtype=int64),
  array([1, 0, 1, 0, 1, 0, 1], dtype=int64)))
  
array([33, 10, 48, 92, 91, 90, 59, 97]))
--------------------------------------------------

array([ 0,  1,  2,  0,  0,  0, 36, 49, 64, 81]

--------------------------------------------------
array([0.        , 0.01010101, 0.02020202, 0.03030303, 0.04040404,
       0.05050505, 0.06060606, 0.07070707, 0.08080808, 0.09090909,
       0.1010101 , 0.11111111, 0.12121212, 0.13131313, 0.14141414,
       0.15151515, 0.16161616, 0.17171717, 0.18181818, 0.19191919,
       0.2020202 , 0.21212121, 0.22222222, 0.23232323, 0.24242424,
       0.25252525, 0.26262626, 0.27272727, 0.28282828, 0.29292929,
       0.3030303 , 0.31313131, 0.32323232, 0.33333333, 0.34343434,
       0.35353535, 0.36363636, 0.37373737, 0.38383838, 0.39393939,
       0.4040404 , 0.41414141, 0.42424242, 0.43434343, 0.44444444,
       0.45454545, 0.46464646, 0.47474747, 0.48484848, 0.49494949,
       0.50505051, 0.51515152, 0.52525253, 0.53535354, 0.54545455,
       0.55555556, 0.56565657, 0.57575758, 0.58585859, 0.5959596 ,
       0.60606061, 0.61616162, 0.62626263, 0.63636364, 0.64646465,
       0.65656566, 0.66666667, 0.67676768, 0.68686869, 0.6969697 ,
       0.70707071, 0.71717172, 0.72727273, 0.73737374, 0.74747475,
       0.75757576, 0.76767677, 0.77777778, 0.78787879, 0.7979798 ,
       0.80808081, 0.81818182, 0.82828283, 0.83838384, 0.84848485,
       0.85858586, 0.86868687, 0.87878788, 0.88888889, 0.8989899 ,
       0.90909091, 0.91919192, 0.92929293, 0.93939394, 0.94949495,
       0.95959596, 0.96969697, 0.97979798, 0.98989899, 1.        ])

计数

• np.isnan(arr).sum()
  • 统计nan的个数
• count_nonzero(a[, axis])
  • 统计非0元素个数
• np.unique(a,return_counts=True)
  • 一维化，去重，统计元素出现次数
• np.argmax(np.bincount(line))
  • 最大元素的坐标

import numpy as np
a=np.array([2,4,6,2,45,12,2,1,1,23]).reshape(2,5)
np.unique(a,return_counts=True)
结果:
((array([ 1,  2,  4,  6, 12, 23, 45]),
  array([2, 3, 1, 1, 1, 1, 1], dtype=int64)),

-------------------------------------------------
a=np.array([0,7])
np.bincount(a)# 数字的出现次数，会从最大到最小先去重一遍，然后统计次数。
-------------------------------------------------
结果：array([1, 0, 0, 0, 0, 0, 0, 1], dtype=int64)分别是 最小0-7最大 每个数字的出现次数。

# 切片索引

np数组使用数组和轴描述数组的规模。维度从1开始算起，每增加一维嵌套就多一层。轴只是从0开始计数的数组，更符合计算机的计数习惯.切片和py中的list十分相似
x=a[开始:结束:步长]
逆序x[::-1]
切片还可以包括省略号…来使选择元组的长度与数组的维度相同,不过单次切片只能出现一次,这个地方还是有代码说服力强。

a=a.reshape(3,3)
y=np.arange(18).reshape(2,3,3)
y,y[1,...,:2]

#---结果---
y:
array([[[ 0,  1,  2],
        [ 3,  4,  5],
        [ 6,  7,  8]],

       [[ 9, 10, 11],
        [12, 13, 14],
        [15, 16, 17]]])

y[1,...,:2]:
array([[ 9, 10],
       [12, 13],
       [15, 16]])

高维数组索引

获取数组中的元素,对于一维数组来说x[n]获取下标为n的元素。高维数组使用元组或者序列的方式取下标。娶不到最高维的时候就会直接取出该维度的列表

a=np.arange(9)
a,a[1]#一维数组取下标
a=a.reshape(3,3)
#高维数组三种取下标的方式
y=np.arange(18).reshape(2,3,3)
x = y[0,1,2],y[0,1,0]

#---结果---
a: [[0 1 2]
 [3 4 5]
 [6 7 8]] 
a[0]: [0 1 2] 
a[0][1]: 1 
a[1,2]: 5 
a[(1,2)]: 5 
x:(5, 3)

花式索引(数组索引)

只用数组作为索引可以一次性取出多个值并组成列表。
x[[1,2,1]]->取出第0轴下标为1，2，1（重复就可以取出同样的元素）

列表可以作为元组下标的一个元素，可配合元组下标使用
x[[1,2,1],[0,1,1]]->取出第0轴下标为1，2，1；取出第一轴下标为0,1,1的元素。
最后组成一个一维数组

布尔索引

布尔索引通过布尔运算（如：比较运算符）来获取符合指定条件的元素的数组。
还是使用上面的y,选出大于3的元素
y[y>3]->array([ 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17]) 也可返回满足条件的同规模数组，判断是不是复数等

x=y>5
a = np.array([1,  2+6j,  5,  3.5+5j])  
a[np.iscomplex(a)]

x:array([[[False, False, False],
        [False, False, False],
        [ True,  True,  True]],

       [[ True,  True,  True],
        [ True,  True,  True],
        [ True,  True,  True]]])
a[np.iscomplex(a)]:[2.0+6.j  3.5+5.j]        

# 数组操作

重新分配维度

c=np.arange(1,101,dtype=np.float32).reshape(-1,1,2)
#第0轴懒得数，第一轴1个元素，第二轴两个元素....
d=np.arange(1,101,dtype=np.float32).reshape(-1)
#弄成只有一个轴，数量不知道
e=np.arange(1,101,dtype=np.float32)
e.rsize(1,-1)

c: [(0)[(1)[(2)  1.   2.]]#注意第0 轴，第一轴,第二轴

 [[  3.   4.]]

 [[  5.   6.]]

 [[  7.   8.]]

 [[  9.  10.]]

 [[ 11.  12.]]

 [[ 13.  14.]]

 [[ 15.  16.]]

 [[ 17.  18.]]

 [[ 19.  20.]]

 [[ 21.  22.]]

 [[ 23.  24.]]

 [[ 25.  26.]]

 [[ 27.  28.]]

 [[ 29.  30.]]

 [[ 31.  32.]]

 [[ 33.  34.]]

 [[ 35.  36.]]

 [[ 37.  38.]]

 [[ 39.  40.]]

 [[ 41.  42.]]

 [[ 43.  44.]]

 [[ 45.  46.]]

 [[ 47.  48.]]

 [[ 49.  50.]]

 [[ 51.  52.]]

 [[ 53.  54.]]

 [[ 55.  56.]]

 [[ 57.  58.]]

 [[ 59.  60.]]

 [[ 61.  62.]]

 [[ 63.  64.]]

 [[ 65.  66.]]

 [[ 67.  68.]]

 [[ 69.  70.]]

 [[ 71.  72.]]

 [[ 73.  74.]]

 [[ 75.  76.]]

 [[ 77.  78.]]

 [[ 79.  80.]]

 [[ 81.  82.]]

 [[ 83.  84.]]

 [[ 85.  86.]]

 [[ 87.  88.]]

 [[ 89.  90.]]

 [[ 91.  92.]]

 [[ 93.  94.]]

 [[ 95.  96.]]

 [[ 97.  98.]]

 [[ 99. 100.]]] 
d: [  1.   2.   3.   4.   5.   6.   7.   8.   9.  10.  11.  12.  13.  14.
  15.  16.  17.  18.  19.  20.  21.  22.  23.  24.  25.  26.  27.  28.
  29.  30.  31.  32.  33.  34.  35.  36.  37.  38.  39.  40.  41.  42.
  43.  44.  45.  46.  47.  48.  49.  50.  51.  52.  53.  54.  55.  56.
  57.  58.  59.  60.  61.  62.  63.  64.  65.  66.  67.  68.  69.  70.
  71.  72.  73.  74.  75.  76.  77.  78.  79.  80.  81.  82.  83.  84.
  85.  86.  87.  88.  89.  90.  91.  92.  93.  94.  95.  96.  97.  98.
  99. 100.] 
e: [[  1.   2.   3.   4.   5.   6.   7.   8.   9.  10.  11.  12.  13.  14.
   15.  16.  17.  18.  19.  20.  21.  22.  23.  24.  25.  26.  27.  28.
   29.  30.  31.  32.  33.  34.  35.  36.  37.  38.  39.  40.  41.  42.
   43.  44.  45.  46.  47.  48.  49.  50.  51.  52.  53.  54.  55.  56.
   57.  58.  59.  60.  61.  62.  63.  64.  65.  66.  67.  68.  69.  70.
   71.  72.  73.  74.  75.  76.  77.  78.  79.  80.  81.  82.  83.  84.
   85.  86.  87.  88.  89.  90.  91.  92.  93.  94.  95.  96.  97.  98.
   99. 100.]]
   

一维化原数组

a=np.arange(1,11,dtype=np.float32).reshape(-1,1,2)#也是有头没尾注意
b=a.ravel()

a: [[[ 1.  2.]]

 [[ 3.  4.]]

 [[ 5.  6.]]

 [[ 7.  8.]]

 [[ 9. 10.]]] 
b: [ 1.  2.  3.  4.  5.  6.  7.  8.  9. 10.] 

转置和高维数组转置

a=np.arange(1,11,dtype=np.float32).reshape(-1,1,2)#也是有头没尾注意
b=np.transpose(a)
c=a.T

a: [[[ 1.  2.]]

 [[ 3.  4.]]

 [[ 5.  6.]]

 [[ 7.  8.]]

 [[ 9. 10.]]] 
b: [[[ 1.  3.  5.  7.  9.]]

 [[ 2.  4.  6.  8. 10.]]] 
c: [[[ 1.  3.  5.  7.  9.]]

 [[ 2.  4.  6.  8. 10.]]]

轴交换&自然对数

a=np.arange(1,11,dtype=np.float32).reshape(-1,1,2)
#也是有头没尾注意
b=a.swapaxes(2,1)
#交换2轴和1轴
c=a.transpose(0,2,1)
#第0轴还是第0轴，第一轴转到第二轴，第二轴转到第一轴，不能扔掉一个轴
d=np.exp(a)
e=np.exp(2)
#当是1的时候返回e
print('a:',a,"\nb:",b,'\nc:',c,'\nd:',d,'\ne:',e)

a: [[[ 1.  2.]]

 [[ 3.  4.]]

 [[ 5.  6.]]

 [[ 7.  8.]]

 [[ 9. 10.]]] 
b: [[[ 1.]
  [ 2.]]

 [[ 3.]
  [ 4.]]

 [[ 5.]
  [ 6.]]

 [[ 7.]
  [ 8.]]

 [[ 9.]
  [10.]]] 
c: [[[ 1.]
  [ 2.]]

 [[ 3.]
  [ 4.]]

 [[ 5.]
  [ 6.]]

 [[ 7.]
  [ 8.]]

 [[ 9.]
  [10.]]] 
d: [[[2.7182817e+00 7.3890562e+00]]

 [[2.0085537e+01 5.4598148e+01]]

 [[1.4841316e+02 4.0342880e+02]]

 [[1.0966332e+03 2.9809580e+03]]

 [[8.1030840e+03 2.2026465e+04]]] 
e: 7.38905609893065

# 合并拆分

水平组合:

x=np.arange(1,10)
y=np.arange(91,100,1)
np.hstack((y,x))# y在前
np.hstack((x,y))# y在后
效果等同于
np.concatenate((x,y),axis=1)

合并是有顺序的，hstack水平合并必须要第0轴的元素维度一致

垂直组合:

x=np.arange(1,10)
y=np.arange(91,100,1)
np.vstack((y,x))# y在前
np.vstack((x,y))# y在后
效果等同于
np.concatenate((x,y),axis=0)

合并也是有顺序的，vstack垂直合并必须第1轴的元素维度一致

水平	垂直

也可以直接调用 stack ，它的组合要求必须要有 相同的维度 ，你可以指定维度合并：

x=np.arange(1,10)
y=np.arange(91,100,1)
np.stack((x,y),axis=0)
np.stack((x,y),axis=1)
np.stack((x,y),axis=2)

axis=0:第0轴第一维最好理解，就只是简单的合并了两个原来的0轴。
array([[[ 1,  2,  3],
        [ 4,  5,  6],
        [ 7,  8,  9]],

       [[91, 92, 93],
        [94, 95, 96],
        [97, 98, 99]]])


axis=1:在第1轴，第二维合并，把第1轴的数组进行两两合并，维度也上升了
array([[[ 1,  2,  3],
        [91, 92, 93]],

       [[ 4,  5,  6],
        [94, 95, 96]],

       [[ 7,  8,  9],
        [97, 98, 99]]])
        
        
axis=2:在第二轴（第三维）把每个元素进行合并，每个元素合并之后增加了一维
array([[[ 1, 91],
        [ 2, 92],
        [ 3, 93]],

       [[ 4, 94],
        [ 5, 95],
        [ 6, 96]],

       [[ 7, 97],
        [ 8, 98],
        [ 9, 99]]])

每个轴之间的合并规则了解一下，后面的以此类推了，二维数组用处最广泛。

深度组合
x=np.dstack((x,y))作用就是直接在第n轴进行组合（最高维）相当于np.stack((x,y),axis=n)

拆分

x=np.split(x,n or [n1,n2],axis=1 or 0 )
对x，指定第n或数个n1,n2 行 竖直 1，列 水平 0拆分

import numpy as np
x=np.linspace(1,10,20).reshape((4,5))
print(x)
x=np.split(x,[2,3],axis=1)#第2列，第3列后面分别进行拆分，拆成个数组😔
x

[[ 1.          1.47368421  1.94736842  2.42105263  2.89473684]
 [ 3.36842105  3.84210526  4.31578947  4.78947368  5.26315789]
 [ 5.73684211  6.21052632  6.68421053  7.15789474  7.63157895]
 [ 8.10526316  8.57894737  9.05263158  9.52631579 10.        ]]

[array([[1.        , 1.47368421],
        [3.36842105, 3.84210526],
        [5.73684211, 6.21052632],
        [8.10526316, 8.57894737]]), 
array([[1.94736842],
        [4.31578947],
        [6.68421053],
        [9.05263158]]), 
array([[ 2.42105263,  2.89473684],
        [ 4.78947368,  5.26315789],
        [ 7.15789474,  7.63157895],
        [ 9.52631579, 10.        ]])]

np.hsplit()和vsplit()直接封装了axis的两个函数真贴心🐢

追加&插入&删除

x=np.append(a,b,axis=1 or 0)追加
x=np.delete(x,n or [n1,n2] ,axis=0)删除第n行/列
x=np.insert(x,n or [n1,n2],values,axis=1)在第n行/列处插入

x=np.array([[1.       , 1.47368421],
           [3.36842105, 3.84210526],
           [5.73684211, 6.21052632],
           [8.10526316, 8.57894737]])
values=[1,2]    
np.append(x,[[1,2]],axis=0)
np.delete(x,2,axis=0)
np.insert(x,2,values,axis=0)
np.insert(x,[1,2],values,axis=0)
np.insert(x,[1,2],values,axis=1)

np.append(x,[[1,2]],axis=0):
array([[1.        , 1.47368421],
       [3.36842105, 3.84210526],
       [5.73684211, 6.21052632],
       [8.10526316, 8.57894737],
       [1.        , 2.        ]])
       
np.delete(x,2,axis=0):       
array([[1.        , 1.47368421],
       [3.36842105, 3.84210526],
       [8.10526316, 8.57894737]])

np.insert(x,2,values,axis=0):
array([[1.        , 1.47368421],
       [3.36842105, 3.84210526],
       [1.        , 2.        ],
       [5.73684211, 6.21052632],
       [8.10526316, 8.57894737]])

np.insert(x,[1,2],values,axis=0):       
array([[1.        , 1.47368421],
       [1.        , 2.        ],
       [3.36842105, 3.84210526],
       [1.        , 2.        ],
       [5.73684211, 6.21052632],
       [8.10526316, 8.57894737]])
       
np.insert(x,[1,2],values,axis=1):       
array([[1.        , 1.        , 1.47368421, 2.        ],
       [3.36842105, 1.        , 3.84210526, 2.        ],
       [5.73684211, 1.        , 6.21052632, 2.        ],
       [8.10526316, 1.        , 8.57894737, 2.        ]])                            

# 广播机制

两数组规模（形状）相同的话会对应相乘，如果不同自动触发广播
insert函数那里就触发了广播,官方给的说法是:

• 让所有输入数组都向其中shape最长的数组看齐，shape中不足的部分都通过在前面加1补齐
• 输出数组的shape是输入数组shape的各个轴上的最大值
• 如果输入数组的某个轴和输出数组的对应轴的长度相同或者其长度为1时，这个数组能够用来计算，否则出错
• 当输入数组的某个轴的长度为1时，沿着此轴运算时都用此轴上的第一组值

如果不看例子的话

🤔🤔🤔🤔🤔🤔🤔🤔🤔🤔🤔
🤔🤔🤔🤔🤔🤔🤔🤔🤔🤔🤔
🤔🤔🤔🤔🤔🙄🤔🤔🤔🤔🤔
🤔🤔🤔🤔🤔🤔🤔🤔🤔🤔🤔
🤔🤔🤔🤔🤔🤔🤔🤔🤔🤔🤔

官方给的例子，其实就是满足两个条件

• a不懂
• b不懂

# 副本和视图

字面意思，副本是在内存里完整的复制了一次，视图就参考sql里的视图概念（原理肯定不一样，会对原来的数据有影响。

副本和视图

# 线代矩阵

数学矩阵是线性代数里面的内容，不及格的回去复习。👻
创建矩阵使用np.mat(),np.matrix(),矩阵必须是二维的我们有时候也会直接把二维数组当作矩阵来处理。

• np.mat()
  • 字符串创建
  • 数组创建
  • 矩阵为参数创建新矩阵
  • 使用矩阵名字字符串参数创建矩阵
• np.matrix()
  • 会直接创建一个copy变成matrix
  • 其他用法参考mat

创建和斐波那契

俩矩阵相乘的时候直接用*和np.dot()就一样了。矩阵运算和数组运算等效，并不会额外增加性能消耗。
矩阵是数组的子类，所有数组操作都对矩阵有效。矩阵在数学上不一定有逆但是在实践中可以直接求它的逆，如果没报错就有，报错了就没有逆。

转置 共轭 逆 秩

分别是T or np.getT()，H，I，np.linalg.matrix_rank(A)

上面的那几个

# 矩阵的应用

矢量运算

矢量是相对于标量来说的。标量只有大小没有方向，矢量既有大小又有方向在numpy中用一维数组表示。np.array([a1,a2，a3,...]),有序。
矢量与标量之间的运算即标量与矢量的每一个数相乘。矢量之间的加减法就是每个元素之间对应加减

标量积和矢量积

又称内积点积，两矢量相乘的一种方式，结果为一标量 a·b=∑ (i-n)a1b1+a2b2+a3b3+···+anbn

有np.inner(a,b)，二维的时候内积如下

矢量积的运算由np.cross()运算三维的矢量积，运算规则如下图

np.outer的用法

张量积

np.tensordot() 啥是张量积

多项式

np.ployld() 不同多项式之间可以进行加减乘除积分微积分运算，求根由根求多项式(一元二次三次方程怎么解来着)，多项式拟合，都是支持的。

# Linear Algebra

np.linalg专门做线性代数的 解线性方程组

见线性代数库参考

# 文件读写

numpy自己有个格式是npy文件

• load(),save()
  • 默认数组是以未压缩的原始二进制格式保存在扩展名为 .npy 文件。
• savze()
  • 将多个数组写入文件，默认数组以未压缩的原始二进制格式保存在 .npz 文件。
• loadtxt(),savetxt()
  • 处理文本文件(.txt 等)

csv excel json

# Pandas

import pandas as pd numpy pandas和Scipy+matplotlib无缝贴合，而且和后面的机器学习库也是配合精妙。
一直弄不完numpy，先不急着开坑

# Matplotlib

import matplotlib.pyplot as plt
Matplotlib允许我们配置绝大部分的东西，图片大小和分辨率（dpi）、线宽、颜色、风格、坐标轴、坐标轴以及网格的属性、文字与字体属性等。不过默认的已经够你玩的了很少用到，用到再去查就好。

# 最基本的图形

使用魔法命令在第一行 %matplotlib 运行一下，会出现一个RStudio的窗口，你所做的改动会实时的展现出来。

通过画一个最基本的图形看看使用pyplot的流程使用MATLAB风格
PS:如果你是在jupyter使用了上面的魔法命令，那就不用show

import numpy as np
import matplotlib.pyplot as plt
x = np.arange(0, 2*np.pi, 0.01)//生成np数组
y = np.sin(x)//生成np数组
plt.plot(x, y)//生成plt
plt.show()//显示

生成一个pyplot对象plt，每一个程序文件只需要一个 plt.show()

创建Figure对象

这东西类似于一张画布，fig=plt.figure() or实例化 plt.Figure()（一般不这样干
参数:
fig=figure(num=None, figsize=None, dpi=None, facecolor=None, edgecolor=None, frameon=True)

• num:图像编号或名称，数字为编号 ，字符串为名称
• figsize:指定figure的宽和高，单位为英寸；
• dpi 参数指定绘图对象的分辨率，即每英寸多少个像素，缺省值为80
• facecolor:背景颜色
• edgecolor:边框颜色
• frameon:是否显示边框

使用fig对象+面向对象风格画图

import numpy as np
import matplotlib.pyplot as plt
x=np.linspace(0,2*np.pi,100)
y1=np.sin(x)
y2=np.cos(x)
fig=plt.figure()
ax=fig.add_axes([0.1,0.1,0.8,0.8])
ax.plot(x,y2)
ax.plot(x,y1)
fig.savefig("x.png")#直接在程序目录下保存

plt函数和ax对象方法:

# 标题和坐标系

需要更高定制性参见matplotlib.ticker官方文档

• plt.title(u'正弦曲线', fontdict={'size':20})
  • 设置标题
• plt.xlabel(u'弧度', fontdict={'size':16})
  • 显示横轴名称
• plt.ylabel(u'正弦值', fontdict={'size':16})
  • 显示纵轴名称
• plt.grid(color="gray")
  • 显示网格
  • 网格参数列表

• plt.xlim((2,10))
  • 为这个坐标系设置范围元组
  • 有返回值一个元组范围
  • ylim同理
• plt.xticks(np.linspace(0,5,11)))
  • 为这个坐标系设置刻度
  • 会自己分配间距等等
  • 不一定位数越高越精确，找合适的

fig=plt.figure()
ax=fig.add_axes([0.1,0.1,0.8,0.8])
x=np.arange(0.0,5.0,0.2)
y=np.exp(-x) *np.cos(2*np.pi*x)
ax.grid(color='gray')#灰色的网格线
ax.plot(x,y)
ax.set_xlabel("it is x")#设置x轴的标注
ax.set_xlim(-2,10)#设置了x轴范围
#ax.set_ylim(-2,10)

刻度是由短线和短线附近的文本组成的，这些对象都有对应的设置器。

• locator 对象，描述刻度“刻线”，当执行ax.yaxis.set_major_locator（plt.NullLocator()）之后，刻线不在在了，即使有“标示”也没有意义了，正所谓“皮之不存，毛将薄附”。
• formater 对象描述刻度的“标示”，所以ax.xaxis.set_major_formatertplt.NullFomater()）之后X轴没有了标示，只有刻线了----刻线可以单独存在，类似于刻度尺，在刻度尺上不是每条刻线都有标示。

# 绘制子图

插曲 显示图片
代码我放这里了，我也没搞懂原理：

from sklearn.datasets import fetch_olivetti_faces
faces=fetch_olivetti_faces().images
fig,ax=plt.subplots(5,5,figsize=(5,5))
fig.subplots_adjust(hspace=0,wspace=0)
for i in range(5):
    for j in range(5):
        ax[i,j].xaxis.set_major_locator(plt.NullLocator())
        ax[i,j].yaxis.set_major_locator(plt.NullLocator())
        ax[i,j].imshow(faces[10*i+j],cmap="bone")
        

• fig,ax=plt.subplots(2,1,sharex='col',sharey='row')

  • 0轴方向为2，1轴方向为1生成2x1个坐标系分区
  • 返回值有两个，一个是Figure和Axes容器，容器是一个序列对象，里面有好多ax坐标系
  • 可以直接取出对象画图ax[0],plot(np.linspace(0,2*np.pi,10),np.sin(np.linspace(0,2 *np.pi,10)))
    
    
    

• fig.subplots_adjust(left=None,bottom=None,right=None,wspace=None,hspace=None)

  • wspace,hspace是分区之间空隙宽和高

#-*-coding:utf-8-*-
#SettingCode here
__author__ = "a_little_rubbish"
__date__ = "2019-04-11 13:27"

#import your model here
import matplotlib.pyplot as plt
import numpy as np

from matplotlib.ticker import MultipleLocator,FormatStrFormatter

t=np.linspace(0,100,100)
s=9.8*np.power(t,2)/2
fig,ax=plt.subplots(figsize=(8,4))
ax.plot(t,s)

ax.set_ylabel("displacement")
ax.set_xlim(0,100)
ax.set_xlabel('time')

xmajor_locator =MultipleLocator(20)#①
xmajor_formatter=FormatStrFormatter('%1.1f')#②
xminor_locator=MultipleLocator(5)

ymajor_locator=MultipleLocator(10000)
ymajor_formatter=FormatStrFormatter('%1.1f')
yminor_locator=MultipleLocator(5000)

ax.xaxis.set_major_locator(xmajor_locator)#③
ax.xaxis.set_major_formatter(xmajor_formatter)#④

ax.yaxis.set_major_locator(ymajor_locator)
ax.yaxis.set_major_formatter(ymajor_formatter)

ax.xaxis.set_minor_locator(xminor_locator)#⑤
ax.yaxis.set_minor_locator(yminor_locator)

ax.grid(True,which='major')
ax.grid(True,which='minor')

for i in ax.xaxis.get_major_ticks():#⑥
    i.label1.set_fontsize(16)
plt.show()
fig.savefig('xx.jpg')#保存图片

程序的解释：
刻度轴是有主次之分的，from matplotlib.ticker import MultipleLocator，FormatStrFormatter 所引入的 MultipleLocator 类就是用于设置刻度的倍数的
例如①中的含义就是X轴的“主刻线”是20的倍数，即对于程序中，X轴上每20是一个“主刻线”。

FormatStrFormatter用于设置“标示”的显示格式，例如②中规定了“主刻度”的“标示”的显示格式为小数点后要有1位小数。
①和②所建立的对象分别作为参数用于③和④。ax.xaxis得到的是X轴Axes对象，它具有以下两个方法：set_major_locator()设置“主刻线”；set_major_formater()设置相应的“标示”。 ⑤中的set_major_locator()设置“次刻线”，因为“次刻线”不需要标示，所以就没有使用set_major_formatter()函数，不过也可以尝试使用。
用同样的方法可以设置Y轴的刻度。 最后，⑥通过循环ax.xaxis.get_major_ticks()得到x轴的主刻度，然后在⑦中对每个主刻度的“标示”字号进行设置，比默认字号大一

• plt.subplot(x,y,z....)
  • 等价于fig.add_subplot()
  • 获得分区的某一个子图给plt
  • 接下来可以设置plt.text(0.2x,0.5y,str('xxx'),fontsize=18,withdash=False,ha='center',with)文字
    
    

画一个小坐标系
fig.add_axes([left,bottom,width,height] left,bottom表示距离画布左侧和底部的距离，width,height表示子图的宽高。这四个值都是取0-1，并表示百分比。 ·

import numpy as np 
import matplotlib.pyplot as plt 
fig=plt.figure()
ax1=fig.add_axes([0.1,0.1,0.8,0.8])
ax1=fig.add_axes([0.6,0.5,0.2,0.3])

ax.shape可以查看当前的对象容器的序列，通过下标拿到Axes对象可以做一些设置。不使用多个画布分区的时候，可以在同一张画布上有多个坐标系
布局

• g=plt.GridSpec(3,3,hspace=0.3,wspace=0.3)
  • 划分了3-3等格,间距为0.3，0.3
  • 使用plt.subplot(g[n:m])划分区域，见代码

import numpy as np 
import matplotlib.pyplot as plt 
fig=plt.figure()
g=plt.GridSpec(3,3,hspace=0.4,wspace=0.4)
#布局规定了间隔不需要fig.subplots_adjust(hspace=0.4,wspace=0.4) 
plt.subplot(g[0,0])
plt.subplot(g[:2,1:])
plt.subplot(g[1:,0])
plt.subplot(g[2,1:])

# 绘图

plt.plot() or ax.plot() 函数完成

• 颜色，由 color='#A52A2A' 参数控制
  • 1.x版本和2.x(使用的)有改动，2.x变为category10调色板+hex16进制颜色值字符串控制。
  • 默认自己填充色彩
• 线型，由 linestyle='dashdot' 控制
  • 参考线型表，默认为实线
• 标注点，由 marker='o' 控制
  • 可选o圆形，D菱形，h六边形
  • markersize=整数int，标记大小
  • markerfacecolor='' 标记颜色
  • markerevery=[1,2,3] 在1，2，3处进行标记
• 线粗细，由 linewidth=整数int 控制
• 标签 label='起个名吧'
  • 给曲线一个名字，一般配合legend图例使用

#-*-coding:utf-8-*-
#SettingCode here
__author__ = "a_little_rubbish"
__date__ = "2019-04-11 15:06"

#import your model here
import matplotlib.pyplot as plt
import matplotlib.colors as colors
import matplotlib.cm as cmx
import numpy as np
#your class&function here

curves=[np.random.random(20) for i in range(10)]#随机数组
values=range(10)#随机整数

fig=plt.figure()#产生画布
ax=fig.add_subplot(111)#添加了一个子图？？大小参数是怎么回事？？只有一个
jet=cm=plt.get_cmap("jet")#获得颜色表
cnorm=colors.Normalize(vmax=values[-1],vmin=0)#也是设置颜色
scalar_map=cmx.ScalarMappable(norm=cnorm,cmap=jet)#画布颜色映射

lines=[]#线数组
for i in range(len(curves)):#数组长度
    line=curves[i]#拿到数组
    color_val=scalar_map.to_rgba(values[i])#利用颜色表取出颜色
    color_text=('color:(%4.2f,%4.2f,%4.2f)'%(color_val[0],color_val[1],color_val[2]))#颜色框上的文本
    ret_line,=ax.plot(line,color=color_val,label=color_text)#画上图
    lines.append(ret_line)#添加到线数组中去

handles,labels=ax.get_legend_handles_labels()#设置图例
ax.legend(handles,labels,loc='upper right')#放置图例
plt.plot()
plt.show()

截图2019-04-11_15-53-41.png

import numpy as np 
import matplotlib.pyplot as plt 
fig=plt.figure()
x=np.random.random(10)#np.random的用法
plt.plot(x,2*x,linestyle=':',marker='o',markersize=9,markerfacecolor='b',markevery=[2,4,6])
x

# 图例

就右上角的小标志那个东西。

plt.legend(loc='upper right') 右上角一个小图例。

• loc="" 位置
  • 参照下表,可直接而用编号代替
• handle=(line1,line2) 给line1和line2画图例
• bbox_to_anchor=(x0,y0,width,height) 把小盒子固定在任意位置
  • x0,y0是盒子左下角相对于坐标轴左下角的位置0~1的浮点数
  • width,height是盒子宽高，也是0~1的浮点数
• frameon=
• fontsize=
• ncol=
• framealpha=
• shadow=
• fancybox=
• borderpad=

import numpy as np 
import matplotlib.pyplot as plt 
fig=plt.figure()
a=np.arange(0,3,.02)
b=np.arange(0,3,.02)
c=np.exp(a)#怎么用来着
d=c[::-1]
plt.plot(a,c,'k--',label="Model")
plt.plot(a,d,'r:',label="Data")
plt.plot(a,c+d,'b-',label="Total")
plt.legend(loc='upper right')

有前面的%matplotlib的时候直接省略下面几句，写的时候要注意添加上

# 散点图

只有一些散点，暂时没有规律的数据

#-*-coding:utf-8-*-
#SettingCode here
__author__ = "a_little_rubbish"
__date__ = "2019-04-11 16:14"

#import your model here
import numpy as np
import matplotlib.pyplot as plt
fig=plt.figure()
rng=np.random.RandomState(0)#伪随机数发生器
x=rng.randn(100)#得到符合高斯分布的100个数组成的数组
y=rng.randn(100)
colors=rng.randn(100)
sizes=1000*rng.randn(100)
plt.scatter(x,y,c=colors,s=sizes,alpha=0.3)#透明度颜色
plt.colorbar()#显示颜色条
plt.show()

参数表：

• plt.scatter()
  • x,y两个数组，表示点坐标
  • s=None点大小默认我也不知道
  • marker=None标记，参考标记表
  • cmap=None
  • norm=None
  • vmin=None
  • vmax=None
  • alpha=None透明度0-1
  • linewidths=None边缘线宽度
  • verts=None
  • edgecolors=None边缘颜色
  • hold=None
  • data=None
    
    ------matplotlib文档

scatter会根据点的大小颜色对每个点进行渲染，各个点不相同，plot不会：(

# 柱形图

普通柱形图

import numpy as np 
import matplotlib.pyplot as plt 
import pandas as pd
fig=plt.figure()

data=[2,10,6,8,7]
position=[i for i in range (1,6)]
plt.bar(x=position,height=data)#这个bar
plt.bar(x=position,height=data,width=0.4,bottom=[3,0,5,0,1])#上面的注释掉再试试这个bar
plt.grid(True)
plt.show()

基本参数：

• x 每根柱子中间所在的坐标位置 [num]
• height 每根柱子的高度 [int]
• width 柱子宽度int
• bottom 柱子底部与坐标轴的距离，默认None等于0 int
• color 颜色可以多种颜色。str
• edgecolor柱边缘颜色str
• linestyle边缘线线型-线型表
• linewidth边缘线宽度int
• hatch填充中间的内部图形str
• tick_label刻度标识，默认数字 [num/str]

import numpy as np 
import matplotlib.pyplot as plt 
import pandas as pd
fig=plt.figure()
data=[2,10,6,8,7]
position=[i for i in range (1,6)]
labels=[i for i in "abcde"]
plt.bar(x=position,height=data,width=0.4,bottom=[3,0,5,0,1],
        color='r',edgecolor='#ff7f00',linestyle='--',
       linewidth=2,hatch='x',tick_label=labels)
plt.grid(True)
plt.show()

啊奇丑无比的图

堆叠柱状图和簇状
ab两组同维数据，把b设置为

import numpy as np 
import matplotlib.pyplot as plt 
import pandas as pd
fig=plt.figure()
a=[2,10,6,8,7]
b=[3,3,4,9,1]
position=[i for i in range (1,6)]
labels=[i for i in "abcde"]
plt.bar(position,a,label='a',color='b')
plt.bar(position,b,label='b',color='g',bottom=a)#注意这个bottom
plt.legend(loc='upper right')

position=np.arange(1,6)
a=np.random.random(5)
b=np.random.random(5)

totalWidth=0.8
n=2
width=totalWidth/n#把宽度分成两半
position=position-(totalWidth-width)/n#
print('width:',width,'position:',position,'totalWidth-width:',totalWidth-width)
plt.bar(position,a,label='a',color='#39abd2',width=width)
plt.bar(position+width,b,label='b',color='#0a84ff',width=width)#注意宽度

颜色好看点了

柱状图差不多了

# 条形图

就是柱状图横过来

position=np.arange(1,6)
a=np.random.random(5)
plt.barh(position,a)

参数和上面的一模一样，拿过来用就是了。
不太一样的是正负柱状图：

position=np.arange(1,6)
a=np.random.random(5)
b=np.random.random(5)

plt.barh(position,a,label='a',color='#ff481f')
plt.barh(position,-b,label='b',color='#05c7da')#注意这里是-b

# 箱线图

一种很有用的图。鉴于笔者懒，就不写那么多了，自己看图吧(~￣▽￣)~

fig,ax=plt.subplots(1,2)
data=[1,5,9,6]
ax[0].boxplot([data])#注意这个形式
ax[0].grid()
ax[1].boxplot([data],showmeans=True)#显示均值
ax[0].grid()

可以设置vert=True竖过来显示
异常点显示为sym='r*'
meanline=False均值线，但一般中位数常用线段表示，让他默认false就挺好的
简单箱线图，啥都能显示，牛逼不（？？？

pandas其实也能直接画，不过我会了这个一定不会去学那个的。
装饰挺麻烦的:

#-*-coding:utf-8-*-
#SettingCode here
__author__ = "a_little_rubbish"
__date__ = "2019-04-12 15:45"

#import your model here
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
fig=plt.figure(1,figsize=(9,6))

np.random.seed(123)
d1=np.random.normal(100,10,200)
d2=np.random.normal(80,30,200)
d3=np.random.normal(90,20,200)
d4=np.random.normal(70,25,200)
data=[d1,d2,d3,d4]

ax=fig.add_subplot(111)#fig.add_subplot(1, 1, 1)
bp=ax.boxplot(data,patch_artist=True)

for b in bp['boxes']:
    b.set(color='#07718c',linewidth=2)
    b.set(facecolor='#2c6ee5')

for w in bp['whiskers']:
    w.set(color='#07718c',linewidth=6)

for c in bp['caps']:
    c.set(color='#a34ce2', linewidth=2)

for m in bp['medians']:
    m.set(color='#dbac3f', linewidth=2)

for f in bp['fliers']:
    f.set(color='#2c6ce5', alpha=0.2,marker='^')
plt.show()

# 饼图

饼图其实是很重要的一种统计图。参数如下： plt.pie

• x 一维的数据源
• explode =None扇面偏离，和x规模一致的数据，在图上显示出来和其他扇面的距离
• labels =None标识和x规模一致的字符串数组
• colors =None 16进制颜色
• autopc t=None 按照规定格式显示百分比例如'%1.1f%%'
• pctdistance =0.6
• shadow =False 阴影
• labeldistance =1.1 标识的距离
• startangle =None 第一个扇形开始的角度
• radius =None 半径大小
• counterclock =True
• wedgeprops =None
• textprops =None
• center =(0,0)
• frame =False
• rotatelabels =False
• hold =None
• data =None

import numpy as np 
import matplotlib.pyplot as plt 
import pandas as pd
fig=plt.figure()

x=[i for i in range(2,10,2)]
print(len(x))
fig,ax=plt.subplots()
labels=['A','B','C',"D"]
colors=[i for i in 'rgby']
explode=[0,0.1,0,0]
plt.pie(x,explode=explode,colors=colors,autopct='%1.1f%%',
       shadow=True,startangle=90,radius=1.2)
ax.set(aspect='equal',title='Pie')#注意set的用法,左边有set右边无

# 直方图

柱形图一般是每个柱子单独渲染，然而直方图是一块渲染，因为直方图的数据的部分时候会符合正态分布。
直方图是一种统计报告图，由一个个的长条形组成，但是直方图用长条形的面积表示频数，所以长条形的高度表示频数组距，宽度表示组距，其长度和宽度均有意义。当宽度相同时，一般就用长条形长度表示频数。直方图一般用来描述等距数据，柱状图一般用来描述名称（类别）数据或顺序数据。直观上，直方图各个长条形是衔接在一起的，表示数据间的数学关系；条形图各长条形之间留有空隙，区分不同的类。

plt.hist

• x
• bins=None 这个参数指定柱子的个数,也就是总共有几条条状图
• range=None =（x,y）筛选数据范围，默认是最小到最大的取值范围
• density=None 设置为True是频率图，默认是频数图
• normed=None 已被density替代
• weights=None
• cumulative=False 设置为True会把前面的值都累加起来
• bottom=None 可以像柱状图一样叠加
• histtype='bar' 柱主子类型bar, barstacked, step, stepfilled
• align='mid' 对齐方式，一般都是居中
• orientation='vertical' 水平或垂直方向显示
• rwidth=None 柱子与柱子之间的距离，默认是0
• log=False
• color=None 直方图16进制颜色
• edgecolor 直方图边框颜色
• label=None 标签
• stacked=False
• hold=None
• data=None

左图：

# -*- coding:utf-8 -*-
import numpy as np
import matplotlib.mlab as mlab
import matplotlib.pyplot as plt

# 谁便生成一堆数据
mu = 100  # 均值
sigma = 15  # 标准差
x = mu + sigma * np.random.randn(10000)

num_bins = 50
# the histogram of the data
n, bins, patches = plt.hist(x, num_bins, density=1, color='blue', alpha=0.5)


# 添加正态分布曲线（这个很好看
y = mlab.normpdf(bins, mu, sigma)
plt.plot(bins, y, 'r--')


plt.xlabel('Smarts')
plt.ylabel('Probability')
plt.title(r'Histogram of IQ: $\mu=100$, $\sigma=15$')

# Tweak spacing to prevent clipping of ylabel
plt.subplots_adjust(left=0.15)
plt.show()

注意添加曲线的那一步
右图

import matplotlib.pyplot as plt
#概率分布直方图  
#正态分布  
mean = 100 #均值为100  
sigma = 1  #标准差为1
x=mean+sigma*np.random.randn(10000)  
fig,(ax0,ax1) = plt.subplots(nrows=2,figsize=(9,6))  #产生俩画布
ax0.hist(x,100,density=1,color='yellowgreen',alpha=0.75)  #第二个参数是柱子宽一些还是窄一些，越大越窄越密  
##pdf概率分布图，一万个数落在某个区间内的数有多少个  
ax0.set_title('pdf')  
ax1.hist(x,20,density=1,color='pink',alpha=0.75,cumulative=True,rwidth=0.8)  
#cdf累计概率函数，cumulative累计。比如需要统计小于5的数的概率  
ax1.set_title("cdf")  
fig.subplots_adjust(hspace=0.4)  
plt.show()

# 三维曲线图

三维目前还不常用，用到去查ax.plot3D？ 三维坐标还蛮好看的，接收到ax对象之后画图之前from mpl_toolkits import mplot3d，设置ax=plt.axes(projection='3d')