python数据分析学习笔记

python数据分析

 

目录

python数据分析

数据分析概念

python数据分析大家族

Numpy

Matplotlib

Scipy

Pandas

---

数据分析概念

概念具体介绍

python数据分析大家族：

① numpy：数据结构基础

② scipy：强大的科学计算方法（矩阵分析、信号分析、数理分析....）

③ matplotlib：丰富的可视化套件（三维图、饼图、可视图等）

④ pandas：基础数据分析套件（表）

⑤ scikit-learn：强大的数据分析建模库（回归分析 、聚类分析）

⑥ keras：人工神经网络 

---

python数据分析大家族

---

Numpy

引入模块numpy

#引入模块
import numpy as np

创建矩阵

#创建矩阵
list = [[1,3,5],[2,4,6]]
np_list = np.array(list,dtype=np.float) #矩阵的创建
#bool,int,int8/16/32/64/128,uint8/16/32/64/128,float,float16/32/64,complex64/128,String

矩阵特性 

#矩阵特性 
print("矩阵类型：")
print(type(np_list))    #类型——numpy.ndarray
print("矩阵形状：")
print(np_list.shape)    #形状——(2, 3)
print("矩阵维度：")
print(np_list.ndim)     #维度——2
print("元素数据类型：")
print(np_list.dtype)    #数据类型——64
print("元素字节大小：")
print(np_list.itemsize) #字节——8
print("元素个数：")
print(np_list.size)     #大小——6

随机矩阵生成 

#随机矩阵生成
print("零矩阵:")
print(np.zeros([3,3]))  #生成3*3的0矩阵 也可n*n*n*n*n*n*n
print("1矩阵:")
print(np.ones([3,3]))   #生成3*3的1矩阵
print("random:")
print("均匀分布rand:")
print(np.random.rand(3,3))  #生成3*3的随机矩阵
print("正太分布randn:")
print(np.random.randn(3, 3))

随机整数生成

#随机数生成
print(np.random.rand()) # 0~1的随机数
print(np.random.randn())
print("随机整数randint:")
print(np.random.randint(1,10,3)) #3个1~10的随机整数
print("随机生成指定的数choice:")
print(np.random.choice([10,20,30,40,50]))
print("beta分布:")
print(np.random.beta(1,10,100))

矩阵操作1

print("arange:")
print(np.arange(1, 11)) #生成1-10的一行10列矩阵
print("重塑矩阵行列reshape:")
print(np.arange(1,11).reshape([5,-1]))  #按1行10列矩阵重塑成5*2的矩阵，-1位自动计算列数
print("e**n exp:")
print(np.exp(list))
print("2**n exp2:")
print(np.exp2(list))
print("开方 sqrt:")
print(np.sqrt(list))
print("sin:")
print(np.sin(list))
print("log:")
print(np.log(list))

矩阵操作2

print("矩阵相加：")
list = np.arange(1,25).reshape([3,2,-1])    #生成三维2*4矩阵
print("axis下文有解释：")
print(list.sum(axis=0))     #三个二维矩阵相加       第一层 三维矩阵
print(list.sum(axis=1))     #三个二维矩阵行行相加    第二层 二维矩阵
print(list.sum(axis=2))     #三个二维矩阵列列相加    第三层 一维矩阵——每个数算一个矩阵
print("最大值：")
print(list.max(axis=0))
print("最小值：")
print(list.min(axis=0))

print("两矩阵之间进行加减乘除平方")
list = np.arange(1,5).reshape([2,2])
list2 = list
print("矩阵相应元素相乘：")
print(list*list2)   #矩阵相乘
print("※矩阵点成Dot：")
print(np.dot(list,list2))   #矩阵点成

print("矩阵行列追加concatenate:")
list = np.array([1,2,3,4]) #创建矩阵
list2 = np.copy(list)   #矩阵复制
print(np.concatenate((list,list2),axis=0))  #横向追加
print(np.vstack((list,list2)))  #竖向追加
print(np.hstack((list,list2)))  #横向追加
print("矩阵分割:")
print(np.split(list,2))

关于axis的解释：

axis主要是控制矩阵在那个位置进行矩阵操作，n维矩阵的axis的取值范围为0~n-1

三维2*4矩阵

例如，对于文中三维2*4矩阵来说，当axis=0时，矩阵操作：三维矩阵中各二维矩阵中相同位置相加，如图：

axis=0

 

axis=0

当axis=1时，矩阵操作：三维矩阵中的各二维矩阵中的行行相加（一维矩阵相同位置添加），如图：

axis=1

 

 

axis=1

当axis=1时，矩阵操作：三维矩阵中的各二维矩阵中的各一维矩阵内的元素相加，如图：

axis=2

 

线性方程组

print("单位矩阵：")
print(np.eye(3))
list = np.array([[1,2],
                 [3,4]])
print("逆矩阵inv:")
print(inv(np.eye(3)))
print("转置矩阵T:")
print(list.transpose())
print("行列式Det：")
print(det(list))
print("特征值和特征向量eig：")
print(eig(list))    #第一个array为特征值，第二个为特征向量

print("解方程组：")
y = np.array([[5.], [7.]])
print(solve(list,y))    #list * x = y
print("FFT：")
print(np.fft.fft(np.array([1,1,1,1,1,1])))
print("相关系数Coef：")
print(np.corrcoef([1,0,1],[0,2,1]))
print("一元多次函数Poly：")
print(np.poly1d([6,3,1]))

---

Matplotlib

绘画一副简单图

 1. 引入模块

import numpy as np
import matplotlib.pyplot as plt

2. 绘图

x=np.linspace(-np.pi,np.pi,60,endpoint=True)    #创建线性点
c,s = np.cos(x),np.sin(x)
plt.figure(1)   #创建自定义图像，编号为1  figure(num=None, figsize=None, dpi=None, facecolor=None, edgecolor=None, frameon=True)
plt.plot(x,c,color="red",linewidth=1.0,linestyle="--",label="COS",alpha=0.5) #plot(x,y,fmt,kwargs(可通过关键字配置)) 颜色、线宽、线样式、标签、透明度
plt.plot(x,s,"r *",label="SIN")
plt.title("COS & SIN")
plt.show()

3. 结果

 坐标轴自定义设置

print("坐标轴设置")
ax=plt.gca()    #得到坐标轴
ax.spines["right"].set_color("none")    #取消右边框
ax.spines["top"].set_color("none")
# 设置底边的移动范围，移动到y轴的0位置

ax.spines["left"].set_position(('data',0)) #左边框居中 ('data', 0):移动轴的位置到交叉轴的指定坐标,相对偏移0
ax.spines["bottom"].set_position(('data',0))
ax.xaxis.set_ticks_position("bottom")   #x坐标轴数据信息的位置
ax.yaxis.set_ticks_position("right")

print("自定义坐标轴显示信息")
plt.xticks([-np.pi, -np.pi/2, 0, np.pi/2, np.pi],
           [r'$-\pi$', r'$-\pi/2$', r'$0$', r'$+\pi/2$', r'$+\pi$'])
plt.yticks(np.linspace(-1,1,5,endpoint=True))
print("自定义坐标轴信息显示样式")
for lable in ax.get_xticklabels()+ax.get_yticklabels():
    lable.set_fontsize(12)
    lable.set_bbox(dict(facecolor="white",edgecolor="None",alpha=0.1))
plt.legend(loc="upper left")    #图例的位置
plt.grid()  #网格线
#plt.axis([-1,1,-0.5,1]) #缩小范围x轴-1~1，y轴-0.5~1
plt.show()

图像填充与注释点

print("图像填充")
plt.fill_between(x,np.abs(x)<0.5,c,c>0.5,color="green",alpha=0.25)  #fill_betwween(横轴，横轴范围，纵轴，纵轴范围)

print("注释点")
t=1
print("画线：plot([x起点,y起点],[x终点,y终点],颜色,线宽,线型)")
plt.plot([t,t],[0,np.cos(t)],"y",linewidth=3,linestyle="--")    #plot([x起点,y起点],[x终点,y终点],颜色,线宽,线型)
print("添加注释：annotate(注释内容,xy=(注释点x,注释点y),xycoords='data',注释偏移,注释内容坐标,注释属性)")
plt.annotate("cos(Π/2)",xy=(t,np.cos(t)),xycoords="data",xytext=(+10,+30),
             textcoords="offset points",arrowprops=dict(arrowstyle="->",connectionstyle="arc3,rad=.2"))
plt.show()

散点图

fig = plt.figure()
ax = fig.add_subplot(331) #fig.add_subplot(xyz) x*y表格中的第z个表格
n=128
X = np.random.normal(0,1,n)
Y = np.random.normal(0,1,n)
T = np.arctan2(Y,X)
#plt.axes([0.025,0.025,0.95,0.95])
ax.scatter(X,Y,s=75,c=T,alpha=.3)
plt.xlim(-1.5,1.5), plt.xticks([])  #坐标显示范围及自定义显示的值
plt.ylim(-1.5,1.5), plt.yticks([])
plt.axis()  #关于坐标轴的大小 https://blog.csdn.net/jose_M/article/details/105594038
plt.title("scatter")
plt.xlabel("x")
plt.ylabel("y")

图在本章最后

柱状图

ax = fig.add_subplot(332)
n=10
X = np.arange(n)
Y1 = (1-X/float(n))*np.random.uniform(0.5,1.0,n)
Y2 = (1-X/float(n))*np.random.uniform(0.5,1.0,n)
print("定义柱状图样式")
ax.bar(X,+Y1,facecolor='#9999ff',edgecolor='white')
ax.bar(X,-Y2, facecolor='#ff9999', edgecolor='white')
print("定义每个柱上的显示内容")
for x,y in zip(X,Y1):
    plt.text(x+0.4,y+0.05,'%.2f'%y,ha='center',va='bottom',fontdict={'size':6}) #plt.text(输出信息的x坐标，输出信息的y坐标,fmt)
for x,y in zip(X,Y2):
    plt.text(x+0.4,-y-0.05,'%.2f'%y,ha='center',va='top',fontdict={'size':6})
    plt.text(x+0.4,-y-0.05,'%.2f'%y,ha='center',va='top')

 饼状图

fig.add_subplot(333)
n=20
Z=np.ones(n)
Z[-1]*=2
plt.pie(Z,explode=Z*.05,colors=['%f'%(i/float(n)) for i in range(n)],labels=['%.2f'%(i/float(n)) for i in range(n)]) #
plt.gca().set_aspect("equal")   #正圆而不是椭圆
plt.xticks([]),plt.yticks([])

极坐标

fig.add_subplot(334,polar=True)
n=20
theta = np.arange(0.0,2*np.pi,2*np.pi/n)
radii = 10*np.random.rand(n)
plt.polar(theta,radii)   #折现连接
#plt.plot(theta, radii)  # 折现连接

heatmap

#引入模块 
from matplotlib import cm

fig.add_subplot(335)
data = np.random.rand(5,5)
cmap = cm.Blues
map = plt.imshow(data,interpolation='nearest',cmap=cmap,aspect='auto',vmin=0,vmax=1)

 3D

#引入模块 
from mpl_toolkits.mplot3d import Axes3D

ax = fig.add_subplot(336,projection='3d')
ax.scatter(1,1,3,s=100)

 轮廓图

fig.add_subplot(313)
def f(x,y):
    return (1-x/2+x**5+y**3)*np.exp(-x**2-y**2)
n=256
x=np.linspace(-3,3,n)
y=np.linspace(-3,3,n)
X,Y=np.meshgrid(x,y)
plt.contour(X,Y,f(X,Y),10,alpha=.75,camp=plt.cm.hot)
plt.savefig('./data/fig.png')
plt.show()

 以上几个图的输出：

---

Scipy

积分计算 

#引入积分模块
from scipy.integrate import quad,dblquad,nquad

print("一重积分")
print(quad(lambda x:np.exp(-x),0,np.inf))   #函数，积分上限，积分下限
print("二重积分")
print(dblquad(lambda t,x:np.exp(-x*t)/t**3,0,np.inf, lambda x:1, lambda x:np.inf)) #二元函数，外积分上限，外积分下限，内积分上限，内积分下限
print("n重积分")
def f(x,y):
    return x*y
def bound_y():  #积分上下限
    return [0,0.5]
def bound_x(y): #
    return [0,1-2*y]
print(nquad(f,[bound_x,bound_y]))

 优化器

#引入模块 
from scipy.optimize import minimize

def rosen(x):   #定义函数
    return sum(100.0*(x[1:]-x[:-1]**2.0)**2.0 + (1-x[:-1])**2.0)
x0=np.array([1.3,0.7,0.8,1.9,2.4])
res=minimize(rosen,x0,method="nelder-mead",options={"xtol":1e-8,"disp":True}) #最小优化
print("ROSE　MINI:",res)

 插值

#引入模块 
from pylab import *

x=np.linspace(0,1,10)
y=np.sin(2*np.pi*x)

#引入模块 
from scipy.interpolate import interp1d

li=interp1d(x,y,kind="cubic")
x_new=np.linspace(0,1,5)
y_new=li(x_new)
figure()
plot(x,y,"r")
plot(x_new,y_new,"k")
#show()
print(y_new)

 矩阵运算

#引入模块
from scipy import linalg as lg

arr = np.array([[1,2],[3,4]])
print("行列式Det:",lg.det(arr))
print("逆矩阵Inv:",lg.inv(arr))
b = np.array([6,14])
print("求解Sol:",lg.solve(arr,b))
print("Eig:",lg.eig(arr))
print("Lu:", lg.lu(arr))
print("Qr:", lg.qr(arr))
print("Svd:", lg.svd(arr))
print("Schur:", lg.schur(arr))

 以上输出：

一重积分
(1.0000000000000002, 5.842606996763696e-11)
二重积分
(0.3333333333366853, 1.3888461883425516e-08)
n重积分
(0.010416666666666668, 4.101620128472366e-16)
Optimization terminated successfully.
         Current function value: 0.000000
         Iterations: 432
         Function evaluations: 717
ROSE　MINI:  final_simplex: (array([[1.        , 1.        , 1.        , 1.        , 1.        ],
       [1.        , 1.        , 1.        , 1.        , 0.99999999],
       [1.        , 1.        , 1.        , 1.        , 0.99999999],
       [1.        , 1.        , 1.        , 1.        , 1.        ],
       [1.        , 1.        , 1.        , 1.        , 1.        ],
       [1.        , 1.        , 1.        , 1.        , 1.00000001]]), array([5.45394704e-17, 1.05152403e-16, 1.75976054e-16, 2.41065889e-16,
       2.63548476e-16, 2.66925636e-16]))
           fun: 5.453947036310182e-17
       message: 'Optimization terminated successfully.'
          nfev: 717
           nit: 432
        status: 0
       success: True
             x: array([1., 1., 1., 1., 1.])
[ 0.00000000e+00  9.99912161e-01  1.11022302e-16 -9.99912161e-01
 -2.44929360e-16]
行列式Det: -2.0
逆矩阵Inv: [[-2.   1. ]
 [ 1.5 -0.5]]
求解Sol: [2. 2.]
Eig: (array([-0.37228132+0.j,  5.37228132+0.j]), array([[-0.82456484, -0.41597356],
       [ 0.56576746, -0.90937671]]))
Lu: (array([[0., 1.],
       [1., 0.]]), array([[1.        , 0.        ],
       [0.33333333, 1.        ]]), array([[3.        , 4.        ],
       [0.        , 0.66666667]]))
Qr: (array([[-0.31622777, -0.9486833 ],
       [-0.9486833 ,  0.31622777]]), array([[-3.16227766, -4.42718872],
       [ 0.        , -0.63245553]]))
Svd: (array([[-0.40455358, -0.9145143 ],
       [-0.9145143 ,  0.40455358]]), array([5.4649857 , 0.36596619]), array([[-0.57604844, -0.81741556],
       [ 0.81741556, -0.57604844]]))
Schur: (array([[-0.37228132, -1.        ],
       [ 0.        ,  5.37228132]]), array([[-0.82456484, -0.56576746],
       [ 0.56576746, -0.82456484]]))

---

Pandas

引入模块

 

 

import numpy as np
import pandas as pd
from pylab import *

 数据结构

#数据结构
s = pd.Series([i*2 for i in range(1,11)])    #可定义索引，加index
print(s)
print(type(s))
dates = pd.date_range("20170301",periods=8)
print(dates)
df = pd.DataFrame(np.random.randn(8,5),index=dates,columns=list("ABCDE")) #np.random.randn(8,5)--八行五列正态分布随机数
print(df)
# df = pd.DataFrame({"A":1,"B":pd.Timestamp("20170301"),"C":pd.Series(1,index=list(range(4)),dtype="float32"),"D":np.array([3]*4,dtype="float32"),"E":pd.Categorical(["police","student","teacher","doctor"])})
# print(df)

 基础属性使用

print(df.head(3))   #前三行
print(df.tail(3))   #后三行
print(df.index)     #行索引（'2017-03-01', '2017-03-02', '2017-03-03'...）
print(df.values)    #值：8×5随机正态分布数
print(df.T)         #行列互换
print(df.sort_index(axis=1,ascending=False))    #排序
print(df.describe())    #每行的各种信息:count,mean,std,min,25%,50%,75%,max

数据查询

print("行（列）选取（单维度选取）：df[]")
print(type(df["A"]))    #每列都是Series
print(df[:3])   #前三行
print(df["20170301":"20170304"])    #01-04
print("区域选取（多维选取）：df.loc[]，df.iloc[]，df.ix[]")
print(df.loc[dates[0]]) #第一行
print(df.loc["20170301":"20170304",["B","D"]])  #01-04的B、D列
print("iloc:")
print(df.iloc[1:3,2:4]) #2-3行 3-4列
print("iloc:")
print(df.iloc[0,2]) #1行C(3)列的值
print("单元格选取（点选取）：df.at[]，df.iat[]")
print("at:",df.at[dates[0],"C"])  #第一行的C列的值
print("iat:",df.iat[0,2])   #1行C(3)列的值 ilos=at=iat
print("A<0 B>0:")
print(df[df.B>0][df.A<0])   #A列小于0，B列大于0的行
print("表格中大于0的数值:")
print(df[df>0])
print("表格F列是否有10或者12:")
sl = pd.Series(list(range(10, 18)), index=pd.date_range("20170301", periods=8))
df["F"] = sl
print(df[df.F.isin([10,12])])
print(df[df.isin([10, 12])])    #表格中有10行

 数据结构修改

sl = pd.Series(list(range(10,18)),index=pd.date_range("20170301",periods=8))    #创建Series类
df["F"]=sl  #将sl列添加到df中
print(df)
df.at[dates[0],"A"]=0   #第一行A列值赋为0
print(df)
df.iat[1,1]=1   #2行B列的值赋为1
df.loc[:,"D"]=np.array([4]*len(df)) #所有行的D列赋值为4   numpy.ndarray与Series都可
print(df)
df2=df.copy()   #复制
df2[df2>0]=-df2 #所有值大于0都取相反数
print(df2)

 缺失值

df1 = df.reindex(index=dates[:4],columns=list("ABCD")+["G"])    #取前四行ABCDG列
df1.loc[dates[0]:dates[1],"G"]=1    #前两行...
df1.loc[dates[1]:dates[2], "G"] = 2
print(df1)
print(df1.dropna()) #去除值为NaN的行
print(df1.fillna(value=1))  #用1填充

 表统计与整合

print("各行的平均值:")
print(df.mean())
print("各行的方差:")
print(df.var())
s=pd.Series([1,2,4,np.nan,5,7,9,10],index=dates)    #定义索引 np.nan为NaN
print(s)
print(s.shift(2))   #行向下平移2，1、2行缺失的为NaN
print(s.diff()) #value=差 2-1 4-2 Nan-4 ...
print("各数字的出现的次数:")
print(s.value_counts()) #各数字的出现的次数
print("前n-1行的累加值:")
print(df.apply(np.cumsum))  #每行显示的是前n-1行的累加值
print("每行的极差:")
print(df.apply(lambda x:x.max()-x.min()))

数据结构连接

pieces = [df[:3],df[-3:]]
print(pd.concat(pieces))

left = pd.DataFrame({"key":["x","y"],"value":[1,2]})
right = pd.DataFrame({"key":["x","z"],"value":[2,4]})
print("LEFT:",left)
print("RIGHT:",right)
print(pd.merge(left,right,on="key",how="outer"))
df3 = pd.DataFrame({"A":["a","b","c","b"],"B":list(range(4))})
print(df3)
print(df3.groupby("A").sum())

透视表 

时间序列 

t_exam = pd.date_range("20170301",periods=10,freq="S")
print(t_exam)

绘图

ts = pd.Series(np.random.randn(1000),index=pd.date_range("20170301",periods=1000))
ts = ts.cumsum()
#引入模块 from pylab import *
ts.plot()
show()

 

文件操作 

df6 = pd.read_csv("./data/test.csv")
print(df6)
df7 = pd.read_excel("./data/test.xlsx","Sheet1")
print(df7)
df6.to_csv("./data/test2.csv")
df7.to_excel("./data/test2.xlsx")