【Python】周莫凡-Numpy & Pandas Python 教学 学习教程【笔记】

视频地址：周莫凡-Numpy & Pandas Python 教学 学习教程

numpy

列表转换为矩阵、显示维度大小

import numpy as np
array = np.array([[1,2,3],[4,5,6]])
print(array)
#维度
print('number of dim:',array.ndim)
print('shape:',array.shape)
print('size:',array.size)

创建不同的array

定义格式

#定义为int64位格式
#单精度：np.float32/64
a = np.array([1,2.1,3],dtype=np.int)
print(a.dtype)
print(a)

零矩阵，zeros（(行*列)），两个括号！
一矩阵，ones(())
空矩阵，empty，会得到接近于0的矩阵
有序矩阵，arange（起始值，终止值，步长），注意，不会取到终止值
reshape调整矩阵大小，也是双括号，要满足符合矩阵元素个数
生成线段linspace（起始值，终止值，个数），会取终止值，线段个数

a = np.zeros((3,2))
print(a)
a = np.ones((5,2))
print(a)
a = np.empty((2,4))
print(a)
a = np.arange(10,20,2)
#输出：[10 12 14 16 18]
print(a)
a = np.arange(12).reshape((3,4))
print(a)
#输出：[ 1.    3.25  5.5   7.75 10.  ]
a = np.linspace(1,10,5)
print(a)

numpy的基础运算

a = np.array([10,20,30,40])
b = np.arange(4)
print(a,b)
#减法
c = a-b
print(c)
#加法
c = a+b
print(c)
#平方
c = b**2
print(c)
#乘法
c = a*b
print(c)
#sin,cos、tan同理
c = 10*np.sin(a)
print(c)
#判断大小
print(b<3)
print(b==3)
a = np.array([[1,1],
             [0,1]])
b = np.arange(4).reshape((2,2))
print(a)
print(b)
c = a*b
#矩阵乘法用dot()
c_dot = np.dot(a,b)
#另一种矩阵乘法形式
c_dot2 = a.dot(b)
print(c)
print(c_dot)
print(c_dot2)

import numpy as np

#随机矩阵
a = np.random.random((2,4))
print(a)
#求和
print(np.sum(a))
#axis=1对行求和，axis=0对列求和
print(np.sum(a,axis=1))
print(np.sum(a,axis=0))
#最小值
print(np.min(a))
#行最大值
print(np.min(a,axis=1))
#最大值
print(np.max(a))

a = np.arange(2,14).reshape((3,4))
print(a)
#最小值的索引
print(np.argmin(a))
#最大值的索引
print(np.argmax(a))

#平均值
print(np.average(a))
#中位数
print(np.median(a))
#累加
print(np.cumsum(a))
#两个数的差
print(np.diff(a))
#找到非零的数,输出两个数据，分别表示行和列
print(np.nonzero(a))
#排序
a = np.arange(14,-2,-1).reshape((4,4))
print(a)
#每一行由小到大
print(np.sort(a))
#每一列由小到大
print(np.sort(a,axis=0))
#矩阵转置,两种写法都可以
print(np.transpose(a))
print(a.T)
#小于5的数都变成5，大于9的数都变成9，保持中间的数不变
print(np.clip(a,5,9))

numpy的索引

a = np.arange(3,15)
print(a)
#特定值
print(a[3])

#多维情况下
a = np.arange(3,15).reshape((3,4))
print(a)
#特定行或列
print(a[2])
print(a[:,1])
#特定值,两种形式都可以
print(a[1][1])
print(a[1,1])

#输出行
for row in a:
    print(a)
#输出列
for column in a.T:
    print(column)

#输出每一项
print(a.flatten())
for item in a.flat:
    print(item)

array合并

a = np.array([1,1,1])
b = np.array([2,2,2])
#向下合并
print(np.vstack((a,b)))
#向右合并
print(np.hstack((a,b)))

#将序列在行方向增加维度
print(a[np.newaxis,:])
#将序列在列方向增加维度
print(a[:,np.newaxis])
#两个序列竖着合并
print(np.hstack((a[:,np.newaxis],b[:,np.newaxis])))

#多个序列合并
a = np.array([1,1,1])[:,np.newaxis]
b = np.array([2,2,2])[:,np.newaxis]
c = np.concatenate((a,a,b,b))
print(c)
#纵向合并（行合并）
c = np.concatenate((a,a,b,b),axis=0)
print(c)
#横向合并（列合并）
c = np.concatenate((a,a,b,b),axis=1)
print(c)

array分割

a = np.arange(12).reshape((3,4))
print(a)
#对列分割，分成4块
print(np.split(a,2,axis=1))
#不等量的分割
print(np.array_split(a,3,axis=1))
#横向分割
print(np.vsplit(a,3))
#纵向分割
print(np.hsplit(a,2))

numpy中b=a，代表b就是a，a变的话b同时跟着变，并且会传递给其他变量
copy()可以只赋值

a = np.arange(4)
print(a)
b = a
c = a
d = b
a[0]=11
b is a

copy ＆ deep copy

a = np.arange(4)
print(a)
b = a
c = a
d = b
a[0]=11
print(b is a)
b = a.copy()

pandas

pandas类似字典型的numpy
DataFrame创建一个大型矩阵，index为索引值，可以自定义，column为列索引

import numpy as np
import pandas as pd

s = pd.Series([1,3,4,np.nan,44,1])
print(s)

#自定义行和列名字
dates = pd.date_range('20160101',periods=6)
print(dates)
df = pd.DataFrame(np.random.randn(6,4),index=dates,columns=['a','b','c','d'])
print(df)

#若不自定义行列名字，会自动编号
df = pd.DataFrame(np.arange(12).reshape((3,4)))
print(df)

#字典的方式定义DataFrame
df = pd.DataFrame({'A':1,
                   'B':np.array([3]*4,dtype='int32'),
                   'C':pd.Categorical(['test','train','test','train']),
                   'D':pd.Timestamp('20130102'),
                   'E':pd.Series(1,index=list(range(4)),dtype='float32'),
                   'F':'foo'})
print(df)
#输出数据形式
print(df.dtypes)
#输出行的序号
print(df.index)
#输出列的名字
print(df.columns)
#输出数据
print(df.values)
#计算平均值方差等，只能计算数字
print(df.describe())
#转置
print(df.T)

#对索引排序,axis=1对第一行排序（字母那行），ascending为False倒序
print(df.sort_index(axis=1,ascending=False))
print(df.sort_index(axis=0,ascending=False))
#对数值排序,对C排序
print(df.sort_values(by='C'))

选择数据

dates = pd.date_range('20160101',periods=6)
df = pd.DataFrame(np.arange(24).reshape((6,4)),index=dates,columns=['A','B','C','D'])
print(df)

#选择第A列,两种都可以
print(df['A'])
print(df.A)

#选择多行
print(df[0:3])
print(df['20160101':'20160103'])
#选择多列
print(df[['A','B']])

###################################################
#以标签loc来选择一行
print(df.loc['20160102'])
#以loc来选择一列
print(df.loc[:,['A','B']])
#以loc来选择指定行和列
print(df.loc['20160104':,['A','B']])


###################################################
#以位置iloc来选择
print(df.iloc[3:5,1:3])
print(df.iloc[[1,3,5],1:3])

###################################################
#以位置iloc和标签loc来混合选择
print(df.ix[:3,['A','C']])

###################################################
#对A筛选大于8的行，同时打印出其他列
print(df[df.A>8])

设置值

dates = pd.date_range('20130101',periods=6)
df = pd.DataFrame(np.arange(24).reshape((6,4)),index=dates,columns=['A','B','C','D'])
df.iloc[2,2]=222
print(df)

df.loc['20130101','B']=222
print(df)

df.A[df.A>4]=0
print(df)

df[df.B>9]=0
print(df)

df['F'] = np.nan
print(df)

df['E'] = pd.Series([1,2,3,4,5,6],index=pd.date_range('20130101',periods=6))
print(df)

处理丢失数据

dates = pd.date_range('20130101',periods=6)
df = pd.DataFrame(np.arange(24).reshape((6,4)),index=dates,columns=['A','B','C','D'])
df.iloc[0,1] = np.nan
df.iloc[1,2] = np.nan
print(df)

#丢失掉包含NaN的行，any表示只要包含任何一个的话就丢掉,若为all，则要所有都为nan
print(df.dropna(axis=0,how='any'))

#填入新数据
print(df.fillna(value=0))

#判断是否确实
print(df.isnull())
#判断是否有任何一个等于NaN
print(np.any(df.isnull())==True)

导入导出

官方文档：http://pandas.pydata.org/pandas-docs/stable/io.html

#读取
data = pd.read_csv('student.csv')
#存储
data.to_pickle('student.pickle')

DataFrame合并concat

axies=0代表竖向，1代表横向

df1 = pd.DataFrame(np.ones((3,4))*0,columns=['A','B','C','D'])
df2 = pd.DataFrame(np.ones((3,4))*1,columns=['A','B','C','D'])
df3 = pd.DataFrame(np.ones((3,4))*2,columns=['A','B','C','D'])
print(df1)
print(df2)
print(df3)

#竖向排序，index重新排序
res = pd.concat([df1,df2,df3],axis=0,ignore_index=True)
print(res)

#############################################################
df1 = pd.DataFrame(np.ones((3,4))*0,columns=['A','B','C','D'])
df2 = pd.DataFrame(np.ones((3,4))*1,columns=['B','C','D','E'])
#默认为outer模式
res = pd.concat([df1,df2])
print(res)
#只考虑两者都有的部分
res = pd.concat([df1,df2],join = 'inner')
print(res)

#############################################################
df1 = pd.DataFrame(np.ones((3,4))*0,columns=['A','B','C','D'],index=[1,2,3])
df2 = pd.DataFrame(np.ones((3,4))*1,columns=['B','C','D','E'],index=[2,3,4])
#按照df1的index进行合并,因为df2没有index=1所以会出现Nan
res = pd.concat([df1,df2],axis=1,join_axes=[df1.index])
print(res)

#############################################################
df1 = pd.DataFrame(np.ones((3,4))*0,columns=['A','B','C','D'])
df2 = pd.DataFrame(np.ones((3,4))*1,columns=['A','B','C','D'])
df3 = pd.DataFrame(np.ones((3,4))*1,columns=['A','B','C','D'])
#append往下加数据
res = df1.append(df2,ignore_index=True)
print(res)
res = df1.append([df2,df3])
print(res)
#只添加单独一行
s1 = pd.Series([1,2,3,4],index=['A','B','C','D'])
res = df1.append(s1,ignore_index=True)
print(res)

合并Merge

#以key来合并
res = pd.merge(left,right,on='key')
#若有两个key,默认为inner模式,how=['left','right','outer','inner']四种模式
res = pd.mergr(left,right,on=['key1','key2'])
#outer模式
res = pd.mergr(left,right,on=['key1','key2'],how='outer')
#right保留key右边的数据，left空的数据为Nan，left相反
#indicator会显示_merge，并显示合并方式
res = pd.mergr(left,right,on='key1',how='outer',indicator=True)
#同时可以命名_merge的名字
res = pd.mergr(left,right,on='key1',how='outer',indicator='indicator_column')

#自定义index方法
left = pd.DataFrame({'A': ['A0', 'A1', 'A2'],
                     'B': ['B0', 'B1', 'B2']},
                     index=['K0', 'K1', 'K2'])
right = pd.DataFrame({'C': ['C0', 'C2', 'C3'],
                      'D': ['D0', 'D2', 'D3']},
                     index=['K0', 'K2', 'K3'])
#以index为合并依据
res = pd.merge(left, right, left_index=True, right_index=True, how='outer')
print(res)

#

boys = pd.DataFrame({'k': ['K0', 'K1', 'K2'], 'age': [1, 2, 3]})
girls = pd.DataFrame({'k': ['K0', 'K0', 'K3'], 'age': [4, 5, 6]})
print(boys)
print(girls)
#使用suffixes解决overlapping的问题
res = pd.merge(boys, girls, on='k', suffixes=['_boy', '_girl'], how='inner')
print(res)
res = pd.merge(boys, girls, on='k', suffixes=['_boy', '_girl'], how='outer')
print(res)

plots画图

#生成序列
data = pd.Series(np.random.randn(1000),index=np.arange(1000))
#累加
data = data.cumsum()

#DataFrame
data = pd.DataFrame(np.random.randn(1000,4),
                    index=np.arange(1000),
                    columns=list('ABCD'))
data = data.cumsum()
#输出前5行数据，默认为5
print(data.head())
#plot方法
#'bar','hist','box','area','scatter','hexbin','pie'
#data.plot()
ax = data.plot.scatter(x='A',y='B',color='DarkBlue',label='Class 1')
#将数据画在同一张图上
data.plot.scatter(x='A',y='C',color='DarkGreen',label='Class 2',ax=ax)
plt.show()