机器学习入门——Pandas的基本用法

Pandas

Pandas基本介绍

• 创建Series

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

  相当于numpy中的一维数组，数据类型默认为float64

• 创建DataFrame

  dates = pd.date_range("20220101", periods = 6)
  A = np.arange(24).reshape(6,4)
  df1 = pd.DataFrame(A, index = dates, columns=['a','b','c','d'])
  df2 = pd.DataFrame({'A':1.,'B':'foo','E': pd.Categorical(["test", "train", "test", "train"])})
  
  

  1. df1生成DataFrame时，三个参数分别代表数据内容，行名称，列名称
  2. 当没有显式声明行列名称时，默认为从0开始的下标
  3. df2中是使用字典生成，其中，字典的键名代表列的名称，值代表该列的值，需要注意的是，使用该方法是必须传入一个可迭代的对象，或者直接指定index

• DataFrame的属性

  df2 = pd.DataFrame({'A':1.,'B':'foo'}, index=[0])
  df2.dtypes # 输出每列的数据类型
  df2.index # 输出行的index名称
  df2.columns # 输出列的index名称
  df2.values # 以行为单位打印数据内容
  df2.describe() # 运算数值类型的一些方差、平均值、数量等
  df2.T # 转置
  df.sort_index(axis=0,ascending=False) # 根据索引排序
  df.sort_values(by='a',ascending=False) # 根据某一列的值进行排序
  

  在排序中，如果axis=0，表示按照行索引进行排序，axis=1，表示按照列索引进行排序，ascending属性控制升序或者降序，默认为True（升序）

选择数据

• 选择DF中的某一列值

  # 使用列索引名
  df['a']
  df.a
  

• 使用切片获取行的数据

  df[0:3]
  df['20220101':'20220104']
  

  方式1：切片两边是左开右闭的

  方式2：切片是完全闭合的

• Select by label：loc

  df.loc['20220101']
  df.loc[:,'a':'b']
  df.loc[['20220101','20220104'],['a','c']]
  

  方式1：只能使用行标签的值来获取一行的数据

  方式2：获取列的数据

  方式3：可以同时指定行或者列需要选取的数据范围

• Select by position：iloc

  df.iloc[3,1]
  df.iloc[3:5,1:3]
  df.iloc[[2,3,5],1:3]
  

  使用序号进行切片时，是左开右闭的

• Boolean indexing

  df[df.a>8] # 符合条件的行的所有列数据
  df[df.a>8]['a'] # 符合条件的行的某一列数据
  

赋值操作

# 通过标签或索引进行定位修改
df.iloc[2,2]=111
df.loc['20220101','d'] = 100

# 修改某一列中满足条件的行
df.b[df.a > 3] = 90

df['f'] = np.nan

# 此种方式，需要将新传入的series的index与dataframe已有的index对齐
df['e'] = pd.Series([1,2,3,4,5,6],index=pd.date_range('20220101',periods=6))

本质上来说，赋值操作很简单，重点还是选择你需要修改的数据

处理NAN

df.dropna(axis=1, how='any')

df.fillna(value=0)

df.isnull() # 输出boolean矩阵，判断是否有缺失

print(np.any(df.isnull())) # 当结果为true时，表示df.isnull()的结果中包含至少一个true，表示有缺失值

dropna( )：

1. axis = 0，丢弃行；axis=1 丢弃列
2. how = any，只要出现一个就丢弃；how=all，全部都是才丢弃

csv导入导出

data = pd.read_csv('Student.csv') # 导入数据
data.to_pickle('student.pickle') #导出数据

合并Concat

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'])

res = pd.concat([df1,df2,df3], axis=0, ignore_index=True)

1. axis指定合并的方向，通过shape来记忆，比如两个shape(3,4)在axis=0合并时，结果是shape（6,4）
2. ignore_index=True,忽略原来的索引，默认情况下时false，会导致合并后的行索引重复

# join,['inner','outer']
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])
print(df1)
print(df2)

res = pd.concat([df1,df2], join='inner',ignore_index=True)
print(res)

1. 要合并的两个df，列和index不完全相同，如果直接合并会将某一个df中不相同的部分填充nan
2. join=‘outer’会将不同部分填充nan，join=’inner‘,只对两者相同的部分进行填充

# 在一个df后添加另一个完整的df
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'])

res = df1.append(df2,ignore_index=True)

# 也可以只添加一行，即添加一个Series
df1 = pd.DataFrame(np.ones((3,4))*0, columns=['a','b','c','d'])
s1 = pd.Series([1,2,3,4],index=['a','b','c','d'])

res = df1.append(s1, ignore_index=True)

合并Merge

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']})

res = pd.merge(left, right, on='key')

此处在merge函数中的on属性，表示在某一列上合并，这一列必须是共有的列,且列上的值需要相同

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']})

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

# outer
  key1 key2    A    B    C    D
0   K0   K0   A0   B0   C0   D0
1   K0   K1   A1   B1  NaN  NaN
2   K1   K0   A2   B2   C1   D1
3   K1   K0   A2   B2   C2   D2
4   K2   K1   A3   B3  NaN  NaN
5   K2   K0  NaN  NaN   C3   D3

# left
  key1 key2   A   B    C    D
0   K0   K0  A0  B0   C0   D0
1   K0   K1  A1  B1  NaN  NaN
2   K1   K0  A2  B2   C1   D1
3   K1   K0  A2  B2   C2   D2
4   K2   K1  A3  B3  NaN  NaN

# right
  key1 key2    A    B   C   D
0   K0   K0   A0   B0  C0  D0
1   K1   K0   A2   B2  C1  D1
2   K1   K0   A2   B2  C2  D2
3   K2   K0  NaN  NaN  C3  D3

只能合并共有列中值完全相同的部分,也就是how='inner’即默认的方法

1. how=[‘inner’,‘outer’,‘left’,‘right’]

   inner：只合并key完全相同的部分

   outer ：全部进行合并，没有的数据填充nan

   left：基于第一个df的key进行合并

   right：基于第二个df的key进行合并

# data
df1 = pd.DataFrame({'col1':[0,1], 'col_left':['a','b']})
df2 = pd.DataFrame({'col1':[1,2,2],'col_right':[2,2,2]})

res = pd.merge(df1, df2, on='col1', how='outer', indicator=True)

1. indicator参数：可以显示合并后的df的数据来源分布，默认情况下indicator=False

2. 也可以对indicator参数赋一个字符串，标明这一来源列的名称

# merged by 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'])
print(left)
print(right)
# left_index and right_index
res = pd.merge(left, right, left_index=True, right_index=True, how='outer')
res = pd.merge(left, right, left_index=True, right_index=True, how='inner')

# handle overlapping
boys = pd.DataFrame({'k': ['K0', 'K1', 'K2'], 'age': [1, 2, 3]})
girls = pd.DataFrame({'k': ['K0', 'K0', 'K3'], 'age': [4, 5, 6]})
res = pd.merge(boys, girls, on='k', suffixes=['_boy', '_girl'], how='inner')

# res
    k  age_boy  age_girl
0  K0        1         4
1  K0        1         5

suffixes参数指明了对合并的merge中同名列的处理

plot数据可视化

Series

# Series
data = pd.Series(np.random.randn(1000), index=np.arange(1000))
data = data.cumsum() # 输出1000个数据的逐次累加和
data.plot()

DataFrame

# DataFrame
data = pd.DataFrame(np.random.randn(1000, 4), index=np.arange(1000), columns=list("ABCD"))
data = data.cumsum()
# plot methods:
# 'bar', 'hist', 'box', 'kde', 'area', scatter', hexbin', 'pie'
ax = data.plot.scatter(x='A', y='B', color='DarkBlue', label="Class 1")
data.plot.scatter(x='A', y='C', color='LightGreen', label='Class 2', ax=ax)

plt.show()