pandas学习之代码片段

导入numpy和pandas

import numpy as np #引入numpy并命名为np
import pandas as pd#引入pandas并命名为为pd

pandas创建列表

1.1写入固定值创建一维列表

s = pd.Series([1,3,6,np.nan,44,1])#创建 一个pandas列表
print(s)#输出列表样式

1.2连续的时间序列

dates = pd.date_range('20160101',periods=6)#创建一个连续的时间序列
print(dates)

1.3按照默认的从0开始的数字创建矩阵

df1 = pd.DataFrame(np.arange(12).reshape((3,4)))#按照默认的从0开始的数字创建矩阵
print(df1)

1.4按照给定的行列名称生成矩阵

dates = pd.date_range('20160101',periods=6)#创建一个连续的时间序列
a = np.array(['a','b','c','d'])#单维矩阵

df = pd.DataFrame(np.random.randn(6,4),index=dates,columns=a)#按照给定的行列名称生成

print(df)

1.5按照字典的方式给每一列单独赋值

df2 = pd.DataFrame({'A' : 1.,
                    'B' : pd.Timestamp('20130102'),
                    'C' : pd.Series(1,index=list(range(4)),dtype='float32'),
                    'D' : np.array([3] * 4,dtype='int32'),
                    'E' : pd.Categorical(["test","train","test","train"]),
                    'F' : 'foo'})
#用字典的方式创建矩阵 （每一列单独赋值，可以不同类型）
                    
print(df2)

pandas矩阵操作

2.1矩阵转置

print(df2.T)#矩阵行边列，列变行 

2.2矩阵按行列索引排序

print(df2.sort_index(axis=1, ascending=False))#按照列名进行排序从大到小
print(df2.sort_index(axis=0, ascending=False))#按照行名进行排序从大到小
print(df2.sort_index(axis=1, ascending=True))#按照列名进行排序从小到大
print(df2.sort_index(axis=0, ascending=True))#按照行名进行排序从小到大

2.3矩阵按行或列数值排序

print(df2.sort_values(by='E'))#对E列的值进行排序(其他值也会跟着变化)

pandas输出矩阵信息

3.1打印每一列的数据类型

print(df2.dtypes)#打印每一列的数据类型

3.2打印每一行的序号

print(df2.index)#打印每一行的序号

3.3打印每一列的序号

print(df2.columns)#打印每一列的序号

3.4打印描述

df2.describe()#打印描述，只能运算数字形式

选择数据进行输出

4.1带行列索引输出矩阵

print(df2)

4.2只打印矩阵的值

print(df2.values)#只打印pandas矩阵的值

4.3按索引打印一整行或一整列数据

print(df['A'])#打印A这一列的所有数值
print(df.A)#打印A这一列的所有数值

4.4按索引进行切片打印

print(df[0:3])#切片进行选取（左闭右开）
print(df['20130102':'20130104'])

4.5按标签进行选择或切片打印

print(df.loc['20130102'])#按照标签进行选择
print(df.loc[:,['A','B']]) #按照行列两个标签进行选择 （：是所有的意思）
print(df.loc['20130102',['A','B']])#按照行列两个标签进行选择

4.6按位置进行选择或切片

print(df.iloc[3,1])#按照数据位置进行选取（第n+1行/第n+1列）
print(df.iloc[3:5,1:3])#按照数据位置切片进行选取（行切片/列切片）
print(df.iloc[[1,3,5],1:3])#按照离散的值进行选取（离散值/离散值）

4.7按标签和位置进行混合选择数据

print(df.ix[:3,['A','C']])#可以又进行位置又按照标签进行筛选（行标签或行位置/列标签或列位置）

4.8按逻辑进行选择数据

print(df[df.A>8])#按照逻辑进行筛选（打印那一个标签/条件）（显示一组数据）

pandas设置值

5.1位置直接赋值

df.iloc[2,2] = 1111 #按位置直接赋值

5.2按标签直接赋值

df.loc['20130101','B'] = 2222 #按标签直接赋值

5.3按逻辑进行一整行赋值

df[df.A>4] = 0#按逻辑进行一整行赋零

5.4按逻辑进行单个元素直接赋值

df.A[df.A>4] = 0#按逻辑进行单个元素直接赋值

pandas添加新数据

6.1添加一列全部为空

df['F'] = np.nan#添加一列全部为空

6.2添加有数据的一列

df['E'] = pd.Series([1,2,3,4,5,6], index=pd.date_range('20130101',periods=6)) 
#创建一个新的序列，在整体贴如就得矩阵（必须对齐）

pandas处理丢失数据

7.1丢弃空值

df.dropna(
    axis=0,     # 0: 对行进行操作; 1: 对列进行操作
    how='any'   # 'any': 只要存在 NaN 就 drop 掉; 'all': 必须全部是 NaN 才 drop 
    ) #如果有空数据就整行或整列丢掉

7.2空数据默认处理成某个数据

df.fillna(value=0)#所有的空数据默认处理成某个数据

7.3判断空数据

df.isnull() #判断哪一个是缺失数据 是就返回True 不是返回False

7.4判断数据中是不是有缺失数据

np.any(df.isnull()) == True  #判断数据中是不是有缺失数据

7.5判断数据中是不是全是缺失数据

np.all(df.isnull()) == True  #判断数据中是不是全是缺失数据

pandas数据导入和导出

8.1数据导入

data = pd.read_csv('student.csv')#读取csv文件 文件名
#其他格式可以看https://pandas.pydata.org/pandas-docs/stable/user_guide/io.html

8.2数据保存

data.to_pickle('student.pickle')#存放成pickle格式 文件名
#其他格式可以看https://pandas.pydata.org/pandas-docs/stable/user_guide/io.html

pandas按索引合并（concat）

9.1纵向合并pandas数据

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'])
#concat纵向合并
res = pd.concat([df1, df2, df3], axis=0)
print(res)

9.2横向合并pandas

res = pd.concat([df1, df2, df3], axis=1)#横向合并
print(res)

9.3纵向合并重新定义索引

res = pd.concat([df1, df2, df3], axis=0, ignore_index=True)#纵向合并索引重新定义
print(res)

9.4横向合并重新定义索引

res = pd.concat([df1, df2, df3], axis=1, ignore_index=True)#横向合并索引重新定义
print(res)

9.5纵向外合并

#定义资料集
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])
#外合并 不一样的地方用NaN填充
res = pd.concat([df1, df2], axis=0, join='outer',sort = True)
#外合并 不一样的地方用NaN填充并重新设置索引
res = pd.concat([df1, df2], axis=0, join='outer', ignore_index=True,sort = True)

9.6纵向内合并

#内合并，只合并相同的地方，不同的地方丢弃
res = pd.concat([df1, df2], axis=0, join='inner'，sort = True)
#內合并 并重新设置索引
res = pd.concat([df1, df2], axis=0, join='inner', ignore_index=True)

9.7参照其中一个数据进行合并

#定义资料集
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])

#参照哪个进行合并，如果被参照的对象没有那种索引就丢弃，如果有但被合并的元素没有就填充NaN
res = pd.concat([df1, df2], axis=1, join_axes=[df1.index])

9.8用append合并数据

#定义资料集
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'])
s1 = pd.Series([1,2,3,4], index=['a','b','c','d'])

#将df2合并到df1的下面，以及重置index，并打印出结果
res = df1.append(df2, ignore_index=True)
#合并多个df，将df2与df3合并至df1的下面，以及重置index，并打印出结果
res = df1.append([df2, df3], ignore_index=True)
#合并series，将s1合并至df1，以及重置index，并打印出结果
res = df1.append(s1, ignore_index=True)

pandas 按索引和数值合并（merge）

10.1按照单个列索引进行合并

import pandas as pd

#定义资料集并打印出
left = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
                             'A': ['A0', 'A1', 'A2', 'A3'],
                             'B': ['B0', 'B1', 'B2', 'B3']})
right = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
                              'C': ['C0', 'C1', 'C2', 'C3'],
                              'D': ['D0', 'D1', 'D2', 'D3']})

print(left)
#    A   B key
# 0  A0  B0  K0
# 1  A1  B1  K1
# 2  A2  B2  K2
# 3  A3  B3  K3

print(right)
#    C   D key
# 0  C0  D0  K0
# 1  C1  D1  K1
# 2  C2  D2  K2
# 3  C3  D3  K3

#依据key column合并，并打印出
res = pd.merge(left, right, on='key')

print(res)
     A   B key   C   D
# 0  A0  B0  K0  C0  D0
# 1  A1  B1  K1  C1  D1
# 2  A2  B2  K2  C2  D2
# 3  A3  B3  K3  C3  D3

10.2按照多个列索引进行合并

import pandas as pd

#定义资料集并打印出
left = pd.DataFrame({'key1': ['K0', 'K0', 'K1', 'K2'],
                      'key2': ['K0', 'K1', 'K0', 'K1'],
                      'A': ['A0', 'A1', 'A2', 'A3'],
                      'B': ['B0', 'B1', 'B2', 'B3']})
right = pd.DataFrame({'key1': ['K0', 'K1', 'K1', 'K2'],
                       'key2': ['K0', 'K0', 'K0', 'K0'],
                       'C': ['C0', 'C1', 'C2', 'C3'],
                       'D': ['D0', 'D1', 'D2', 'D3']})

print(left)
#    A   B key1 key2
# 0  A0  B0   K0   K0
# 1  A1  B1   K0   K1
# 2  A2  B2   K1   K0
# 3  A3  B3   K2   K1

print(right)
#    C   D key1 key2
# 0  C0  D0   K0   K0
# 1  C1  D1   K1   K0
# 2  C2  D2   K1   K0
# 3  C3  D3   K2   K0

#依据key1与key2 columns进行合并，并打印出四种结果['left', 'right', 'outer', 'inner']
res = pd.merge(left, right, on=['key1', 'key2'], how='inner')
print(res)
#    A   B key1 key2   C   D
# 0  A0  B0   K0   K0  C0  D0
# 1  A2  B2   K1   K0  C1  D1
# 2  A2  B2   K1   K0  C2  D2

res = pd.merge(left, right, on=['key1', 'key2'], how='outer')
print(res)
#     A    B key1 key2    C    D
# 0   A0   B0   K0   K0   C0   D0
# 1   A1   B1   K0   K1  NaN  NaN
# 2   A2   B2   K1   K0   C1   D1
# 3   A2   B2   K1   K0   C2   D2
# 4   A3   B3   K2   K1  NaN  NaN
# 5  NaN  NaN   K2   K0   C3   D3

res = pd.merge(left, right, on=['key1', 'key2'], how='left')
print(res)
#    A   B key1 key2    C    D
# 0  A0  B0   K0   K0   C0   D0
# 1  A1  B1   K0   K1  NaN  NaN
# 2  A2  B2   K1   K0   C1   D1
# 3  A2  B2   K1   K0   C2   D2
# 4  A3  B3   K2   K1  NaN  NaN

res = pd.merge(left, right, on=['key1', 'key2'], how='right')
print(res)
#     A    B key1 key2   C   D
# 0   A0   B0   K0   K0  C0  D0
# 1   A2   B2   K1   K0  C1  D1
# 2   A2   B2   K1   K0  C2  D2
# 3  NaN  NaN   K2   K0  C3  D3

10.3按照列索引进行合并并显示合并记录

import pandas as pd

#定义资料集并打印出
df1 = pd.DataFrame({'col1':[0,1], 'col_left':['a','b']})
df2 = pd.DataFrame({'col1':[1,2,2],'col_right':[2,2,2]})

print(df1)
#   col1 col_left
# 0     0        a
# 1     1        b

print(df2)
#   col1  col_right
# 0     1          2
# 1     2          2
# 2     2          2

# 依据col1进行合并，并启用indicator=True，最后打印出
res = pd.merge(df1, df2, on='col1', how='outer', indicator=True)
print(res)
#   col1 col_left  col_right      _merge
# 0   0.0        a        NaN   left_only
# 1   1.0        b        2.0        both
# 2   2.0      NaN        2.0  right_only
# 3   2.0      NaN        2.0  right_only

# 自定indicator column的名称，并打印出
res = pd.merge(df1, df2, on='col1', how='outer', indicator='indicator_column')
print(res)
#   col1 col_left  col_right indicator_column
# 0   0.0        a        NaN        left_only
# 1   1.0        b        2.0             both
# 2   2.0      NaN        2.0       right_only
# 3   2.0      NaN        2.0       right_only

10.4按照行索引合并

import pandas as pd

#定义资料集并打印出
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'])

print(left)
#     A   B
# K0  A0  B0
# K1  A1  B1
# K2  A2  B2

print(right)
#     C   D
# K0  C0  D0
# K2  C2  D2
# K3  C3  D3

#依据左右资料集的index进行合并，how='outer',并打印出
res = pd.merge(left, right, left_index=True, right_index=True, how='outer')
print(res)
#      A    B    C    D
# K0   A0   B0   C0   D0
# K1   A1   B1  NaN  NaN
# K2   A2   B2   C2   D2
# K3  NaN  NaN   C3   D3

#依据左右资料集的index进行合并，how='inner',并打印出
res = pd.merge(left, right, left_index=True, right_index=True, how='inner')
print(res)
#     A   B   C   D
# K0  A0  B0  C0  D0
# K2  A2  B2  C2  D2

10.5把相同索引的数据分开显示

import pandas as pd

#定义资料集
boys = pd.DataFrame({'k': ['K0', 'K1', 'K2'], 'age': [1, 2, 3]})
girls = pd.DataFrame({'k': ['K0', 'K0', 'K3'], 'age': [4, 5, 6]})

#使用suffixes解决overlapping的问题
res = pd.merge(boys, girls, on='k', suffixes=['_boy', '_girl'], how='outer')
print(res)
#    age_boy   k  age_girl
# 0        1  K0         4
# 1        1  K0         5

画图

11.1 引入库

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

11.2画线性图

# 随机生成1000个数据
data = pd.Series(np.random.randn(1000),index=np.arange(1000))
 
# 为了方便观看效果, 我们累加这个数据
data = data.cumsum()


# pandas 数据可以直接观看其可视化形式
data.plot()
#显示
plt.show()

11.3一张图画多个线性图

data = pd.DataFrame(
    np.random.randn(1000,4),#生成四组每组一千个数据
    index=np.arange(1000),#为每个数据分配索引
    columns=list("ABCD")#分配列数据
    )
data  = data.cumsum()
# pandas 数据可以直接观看其可视化形式
data.plot()
#显示
plt.show()

11.4画单张散点图

ax = data.plot.scatter(x='A',y='B',color='DarkBlue',label='Class1')#画散点图

11.5将之下这个 data 画在上一个 ax 上面

# 将之下这个 data 画在上一个 ax 上面
ab = data.plot.scatter(x='A',y='B',color='DarkBlue',label='Class1')
data.plot.scatter(x='A',y='C',color='LightGreen',label='Class2',ax=ab)
plt.show()