numpy基本操作

#基本的数据类型ndarray

#python list
v=[0.5,0.75,1.0,1.5,2.0]
x=[0.15,0.75,1.0,1.5,2.0]
y=[0.25,0.75,1.0,1.5,2.0]
m=[v,x,y]

#numpy的结构  ndarray里面的数据类型都是相同的，而list里面是可以存放任意的数据
import numpy as np
import warnings: warnings.simplefilter('ignore')
%matplotlib inline
from matplotlib import pyplot as plt#画图
import seaborn#格式化的库
a=np.array([0,0.5,1.0,1.5,2.0])  #将list转化为 numpy.ndarray，并且可以修改
#切片，都是遵循左闭右开的
a[2:]
a[:2]
a[0]=1#可以修改

#数学统计
#a.sum()
#a.std()标准差
#a.cumsum()累计求和
#a.cumprod()累计乘积
#numpy的切片其实是一种引用，不是拷贝赋值，所以是不会再一次占用更多的内存，并且是可以修改的，会影响数据源,但是list并不影响数据源
#例子
a=np.array([0,0.5,1.0,1.5,2.0])
#切片
a_sub=a[1,3]
a_sub[0]=100
#现在在a里面的0.5也变成100了
#办法
a_sub=a[1:3].copy()
#将array里面的数据类型进行转化
arr=np.array([1,2,3,4,5,6,7,8,9])
arr.dtype#查看数据类型
float_arr=arr.astype(np.float)
float_arr.dtype#查看数据类型

向量化操作

list1=[0,0.5,1.0,1.5,2.0]
list1*2  #重复出现的列表
a=np.array([1,2,3,4,5,6,7,8,9])
a*2#这就实现了每个数字乘以2
b=np.array(range(10))
a+b #每个对应的数字相加
#加减乘除都是一样的，元素集的计算
b=np.random.standard_normal(100000000)
#产生标准正态分布随机数
c=list(b)
%time c=[i*2 for i in c]
%time 2*b
比较时间

一些通用的函数

np.sqrt(a)#支持向量化操作

数据索引与切片

b=np.array([a,a**2])
b[0]#返回第一行
b.sum()#所有元素求和
b.sum(axis=0)#按列求和
b.sum(axis=1)#按行求和
#条件索引
year_arr=np.array([[2000,2001,2000],[2005,2002,2009],[2001,2003,2010]])
filtered_arr=year_arr[year_arr>=2005]
#多条件选股
filtered_arr=year_arr[(year_arr>=2005)&(year_arr%2==0)]
#或用|，不能用 and 和or


#np.where 满足条件数据选出来
arr=np.random.randn(3,4)#三行四列的随机数
print(arr)
#np.where(条件判断，True：，False：)
np.where(arr>0,1,-1)

#np.sign(arr)正的返回1，负的返回负1

arr=np.random.randn(3,4)
print(np.any(arr>0))#返回布尔型
#是否有数字大于0
print(np.all(arr>0))#是否全部大于0



#重述
arr=np.random.randn(3,4)
b=arr.reshape((2,6))#变成2行六列

#将int转变为浮点型
b=np.array(b,dtype=np.float)


#创建ndaarray
I=range(10)
data=np.array(I)
print(data.shape)#返回维数

#嵌套转化为ndarray
I2=[range(10),range(10)]
data=np.array(I2)


c=np.zeros((2,3,4),dtype='i')     
#零矩阵，2维（个）数据，三行四列，int
c=np.ones((2,3))
#一矩阵
d=np.ones_like(c,dtype='f',order='c')
#和c结构一样全是1的矩阵，浮点数
e=np.empty((3,4))#并不一定是空值

#等分5到15等分成11等分
g=np.linspace(5,15,11)
g.shape#有几个数字

np.arrange(0,10,1)
#reshape
np.reshape((3,5))#三行五列

g=np.arrange(10).reshape(2,5)


g=np.linspace(1,15,15.reshape(3,5)
g=np.resize(g,(3,1))  #三行数字，1，2，3按顺序取

g=np.resize(g,(5,4))#数字不够时，从头开始取

#转置
g.transpose()


np.hstack((n,2*n))
#对于n矩阵进行横向拓展，右边拓展的矩阵向量化操作全变为元素乘以2的矩阵

np.vstack((n,2*n))
下方扩展
n.flatten（order='c'）#全部换成一维的数组,按行展开
n.flatten（order='F'）#按列展开

#vectorization
r=np.random.standard_normal((4,3))
s=np.random.standard_normal((1,3))
import random
np.random.seed(10)#随机种子锁定随机数
r=np.random.standard_normal((4,3))

#r+s广播
#s是一行的，所以s就会变成四行三列的相同的结构，然后向量组相加

#np与函数结合
def f(x):
	return x*x
f(r)
#math下的函数不可以

a=np.sin(np.arrange(100000000))
#速度是最快的

#求解线性方程组
a=np.array([3,1],[1,2])
b=np.array([9,8])
x=np.linalg.solve(a,b)#解得方程组的解
#矩阵乘法ndarray
np.dot(a,x)

#矩阵
a=np.matrix([[3,1],[1,2]])
x=np.matrix([2,3])
a*x.T#转置

```python
import numpy as np
a=np.random.standard_normal((2,6))
#两行六列随机数
np.round(a,3)#保留三位小数

np.random.rand(6,5)
a=np.random.random(6,5)#智能接受list或者tuple，需要有一个变量接受
np.random.seed(10)
np.random.randn(4,4)#标准正态分布

np.random.randint(-5,3,size=(2,2))#两行两列

np.random.choice(10,8)# 从0——9随机选8个。是可以重复的
list1=['lenove','sansung','mote','xioaminf','dkjsf']
np.random.choice(list1,size=(3,3),p=[0.1,0.6,0.1,0.1,0.1])
#p代表每一个list里面的的有一个随机的概率，顺序一一对应

#回归计算

n=np.array[1,2,3,4,5]
m=n*5+2
reg=np.polyfit(n,m,1)#1代表自由度线性  线性回归
画图
slop，intercept=np.polyfit(m,n,1)

#np
np.polyval[[3,0,1],5]
#[3,0,1]是回归系数，5是自变量，然后返回因变量



np.random.seed(100)
data=np.random.standaer_normal((5,100))
#生成了五行100列的随机数据
x=np.arrange(len(data.cumsum()))#长度
y=data.cumsum()
rg1=np.polyfit(x,y,2)#二次回归系数，没有扰动项

画图

%matplotlib inline
from matplotlib import pyplot as plt
plt.figure(figsize=(10, 6)) 
plt.plot(x, y, 'r', label='data') 
plt.plot(x, np.polyval(rg1, x), 'b--', label='linear') 
plt.plot(x, np.polyval(rg2, x), 'g-.', label='quadratic') 
plt.plot(x, np.polyval(rg3, x), 'm:', label='cubic') 
plt.legend(loc=0)