Pandas快速入门---------常用方法函数总结。

文章目录

• ​​一、数据文件的读取和查看​​
• ​​二、Pandas里的数据结构​​
• ​​三、查询数据的方法​​
• ​​四、新增、修改、删除数据方法​​
• ​​五、统计类函数​​
• ​​六、排序​​
• ​​七、字符串的处理​​
• ​​八、merge函数、Conat函数​​

• ​​merge​​
• ​​concat​​

• ​​九、groupby 分组​​

pandas官方文档：

​​https://pandas.pydata.org/pandas-docs/stable/reference​​

panda和numpy有很多相通的地方，可以看一下我前一阵整理的numpy笔记。

• ​​numpy常用方法总结​​
• ​​numpy练习题+解析​​

一、数据文件的读取和查看

读取CSV文件：

CSV文件里的数据 都是用逗号分割每个值。

res = pd.read_csv(path,sep='!',header=None,names=['a','b','c'])

其中:

• path是文件路径
• sep告诉系统你的数据文件以什么为分隔符
• header表明你所用的文件是否有抬头字段
• names是如果没有抬头字段，你要添加什么字段名

比如现有数据文件:

1!2!3

运行上面的代码后:

0  1  2  3
最左边的0表示索引值，可以看到按照！分割开了，并且加入abc的字段名(列名)。

该函数也可以用于读取 txt文件和tsv(用tab分割的数据)文件。

读Excel文件:

res = pd.read_excel(path)

读Mysql数据库文件：

conn = pymysql.connect(host ='127,0,0,1',
                       user = 'root',
                       password = 123,
                       database='test',
                       charst='utf8'
                       )
res = pd.read_sql("select * from student",con=conn)

俩参数第一个是sql语句，第二个数据库连接、

查看前几行的数据：

可以在括号里面写int数字，写几就是显示前几行，默认前五行。

print(res.head())

查看数据的形状(几行几列):

print(res.shape)

查看列名:
或者说查看字段名

print(res.columns)

查看每列(字段)的数据类型:

print(res.dtypes)

二、Pandas里的数据结构

就跟Numpy里的.ndarray类型一样，Pandas里也有专属的数据类型。
一个是Series 另一个是DataFrame。

Series

表示二维数组中的以为数组，可以理解为一行或者一列。

下面这张图是一张表格，就是一个二维数组，整体为DataFrame，其中的一行或者一列就是 Series。

创建Series的三种方法

方法一：

a = pd.Series([1,2,3])
print(a)
输出:
0    1
1    2
2    3
dtype:

左边是从0开始的索引，右边是对应的值，这个索引是可以改变的。

指定索引:

a = pd.Series([1,2,3],index = (['a','b','c']))
print(a)
输出:
a    1
b    2
c    3
dtype:

方法二：
使用python字典来创建Series。
key变成索引，val变成值。

a = {"a":1,"b":2,"c":3}
s = pd.Series(a)
print(s)
输出：
a    1
b    2
c    3
dtype:

Series的查询方式和python里的字典是一样的。

DataFrame
代表整个表格，相当于二维数组。
DataFrame的创建方式也可以直接用python的字典。key为字段名(列名)。

a = {'a':[1,2,3,4,5,6],
     'b':[7,8,9,10,11,12],
     'c':[13,14,15,16,17,18]}
res = pd.DataFrame(a)
print(res)
输出：
   a   b   c
0  1   7  13
1  2   8  14
2  3   9  15
3  4  10  16
4  5  11  17
5  6  12  18

或者使用numpy和pandas组合:

res= pd.DataFrame(np.arange(12).reshape(3,4),columns=['a','b','c','d'])
print(res)
输出:
   a  b   c   d
0  0  1   2   3
1  4  5   6   7
2  8  9  10  11

不过在使用DataFrame的时候几乎不会这样创建，一般都是从数据文件中创建DataFrame。

三、查询数据的方法

假设已有数据:

   a  b   c
0  1  7  13
1  2  8  14
2  3  9  15
3  4  a  16

查询某一行

print(res.loc[1])
输出：
a     2
b     8
c    14

loc[索引值]
因为他输出的一行数据，所以类型是series。

使用索引或切片

loc也可以使用切片操作，比如loc[1:3]。此时显然要返回两行，因为两行就是二维数组了，所以类型就变成DataFrame.

但是和切片有一点区别就是 python的切片是 左闭区间右开区间，而pandas里loc的切片是左闭右闭。

loc里的方式和numpy里的一样，也可以这样使用:loc[行，列]
如：

print(res.loc[0,'b'])  # 表示取  第0行 字段 ‘b’列的值
print(res.loc[:,'a'])  # 表示取   第 ‘a’ 列的所有值
print(res.loc[1,:])       # 表示取   第 1 行所有的值
print(res.loc[1,'a':'b'])  # 表示取 第1行的 a-b列的值，包含a和b。
输出:
7

0    1
1    2
2    3
3    4
Name: a, dtype: int64

a     2
b     8
c    14
Name: 1, dtype: object

a    2
b    8
Name: 1, dtype: object

使用判别表达式：

print(res.loc[res['a']>2,:])  # 查询a这一列中所有大于2的数据(所有列中)
print(res.loc[res['a']>2,:'a']) # 查询a这一列中所有大于2的数据 (仅在a列中)

输出：
   a  b   c
2  3  9  15
3  4  1  16
   a
2  3
3  4

这里其实和numpy一样，内部都是False和True。

这里面也可以使用匿名函数lamdba。

四、新增、修改、删除数据方法

假设已有数据:

  a = {'a':[1,2,3,4],
 'b':[7,8,9,1],
 'c':[13,14,15,16]}

res = pd.DataFrame(a)
输出：
     a  b   c
  0  1  7  13
  1  2  8  14
  2  3  9  15
  3  4  a  16

直接赋值、修改法：

res.loc[0,'a'] = 'x' # 修改第0行 第‘a’列数据 为‘x’。
print(res)
res.loc[:,'bb'] = res['b'] * 2  # 新增了‘bb’列，值为‘b'列的两倍。
print(res)

输出：
   a  b   c
0  x  7  13
1  2  8  14
2  3  9  15
3  4  1  16

   a  b   c  bb
0  1  7  13  14
1  2  8  14  16
2  3  9  15  18
3  4  1  16   2

从这个例子里也可以看出来loc的好处是，有这个数据就用，没有这个数据就新建。

使用apply函数

# 定义一个函数
def fun(s):
    return s['b']
res.loc[:,'新增列和b相同'] = res.apply(fun,axis=1)
print(res)
输出：
   a  b   c  新增列和b相同
0  1  7  13        7
1  2  8  14        8
2  3  9  15        9
3  4  1  16        1

这里可以写匿名函数。注意这里的传值，apply函数参数第一个是函数，第二个是轴的反向。axis=1是行方向，就是新增的列的每一行上操作。
且这里函数的传参s传入的是整个表格。

apply还有map函数和applymap函数。

• map：只用于Series，实现对每个值的映射。
• apply：用于Series 对每个值处理，用于DataFrame对每个轴也就是Series处理。
• applymap：只用于DataFrame，对每个元素逐一处理。

assign方法
该方法和apply一样，但是apply每次只增加一列，这个函数可以一次增加多个列。

ss = res.assign(
    新增列和b相同 = lambda x:x['b'],
    新增列和c相同 = lambda x:x['c']
)
print(ss)
输出：
   a  b   c  新增列和b相同  新增列和c相同
0  1  7  13        7       13
1  2  8  14        8       14
2  3  9  15        9       15
3  4  1  16        1       16

assign方法会返回一个新的对象，不会对原来的数据产生影响，这点和apply不同。

按条件赋值、修改

res['我是新列'] = '' # 创建一个空的新列
res.loc[res['a']>2,'我是新列'] = '你大' # ’a‘列大于2的行，在新列中复制 ’你大‘
print(res)
输出:
   a  b   c 我是新列
0  1  7  13     
1  2  8  14     
2  3  9  15   你大
3  4  1  16

删除某一行或列
使用drop()函数，删除后返回一个新的对象，对原来的数据不做修改。

原有数据:
   a  b   c
0  1  7  13
1  2  8  14
2  3  9  15
3  4  1  16

s = res.drop('a',axis=1)

删除后输出:
   b   c
0  7  13
1  8  14
2  9  15
3  1  16

五、统计类函数

现有数据:

   a  b   c
0  1  7  13
1  2  8  14
2  3  9  15
3  4  1  16
存放在res中。

各种数据汇总统计

describe() 函数，统计输出每列的计数，平均值最大最小值，各类别所占百分比等。

res.describe()
输出：
              a         b          c
count  4.000000  4.000000   4.000000
mean   2.500000  6.250000  14.500000
std    1.290994  3.593976   1.290994
min    1.000000  1.000000  13.000000
25%    1.750000  5.500000  13.750000
50%    2.500000  7.500000  14.500000
75%    3.250000  8.250000  15.250000
max    4.000000  9.000000  16.000000

也可以直接操作某个字段，比如​​res.['字段名'].max​​

unique函数

去重函数，可以看到某个字段下所有类型的值，一般使用在非数字字符上。比如:​​res['字段名'].unique()​​

value_counts

按值记数函数，查看某个字段下面的各个类型所有的个数，比如​​res['字段名'].value_counts()​​

相关系数和协方差

• 协方差:衡量同向反向的程度，如果协方差为正，则说明x,y同向变化，协方差越大说明同向程度越高；若协方差为负，说明x，y反向运动，协方差越小说明反向程度越高。
• 相关系数：衡量相似程度，当他们相关系数为1时，说明两个变量变化的正向相似度最大，当相关系数为-1时，说明两个变量变化的反向相似度最大。

res.cov()  # 协方差矩阵
res.corr() # 相关系数矩阵
res["A"].corr(res["B"]) # 查看A和B的相关系数
res["A"].corr(res["B"]-res["C"]) # 查看A和b-c的差的相关系数

六、排序

Series的排序

​​pd.Series.sort_values(ascending=True,inplace=False)​​

• ascending 参数：默认为True 升序，为False降序
• inplace参数 ：是否修改原数据
• 
  

DataFrame的排序

​​pd.DataFrame.sort_values(by,ascending=True,inplace=False)​​

• by 参数：指定列名(axis=0或’index’)或索引值(axis=1或’columns’)

可以合并指定某些字段升序某些字段降序:​​res.sort_values(by=['a','b'],ascending=[True,False])​​ （数据在res里，字段a升序，字段b降序）

七、字符串的处理

• 先获取Series的str属性，然后再使用str的函数
• 数字列上不能用
• DataFrame上没有str属性处理和方法，也就是说从DataFrame上取出来某一行或者某一列再用str方法
• Series.str并不是原生的python的str方法，而是有自己的一套，只不过和python的比较相似。
• Series.str 默认开启正则表达式模式，可以用正则。

比如:​​print(res['a'].str.replace('1','2')​​

将a列中的字符‘1’替换成‘2’，如果a列中有数字，则即使没有操作该数字字符，输出的时候也会变成Nan。

其他的和python基本一样，并且支持链式操作。

链式操作示例
使用链式操作的时候，应该是这样的: ​​​res['a'].str.replace.str.slice()​​ 不能忽略每一个函数前面的str。

正则操作示例
​​​res['c'].str.replce("[ABC]"," ")​​ 将字段c中的A或B或C字符替换成空值。

八、merge函数、Conat函数

merge

merge是个用于合并的函数，和mysql里的join左右连接相似。

函数格式：
​​​pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None,left_index=False, right_index=False, sort=True,suffixes=('_x', '_y'), copy=True)​​

• left/right 两个不同的 DataFrame 对象。
• on 指定用于连接的键（即列标签的名字），该键必须同时存在于左右两个 DataFrame 中，如果没有指定，并且其他参数也未指定， 那么将会以两个 DataFrame 的列名交集做为连接键。
• left_on 指定左侧 DataFrame 中作连接键的列名。该参数在左、右列标签名不相同，但表达的含义相同时非常有用。
• right_on 指定左侧 DataFrame 中作连接键的列名。
• left_index 布尔参数，默认为 False。如果为 True 则使用左侧 DataFrame 的行索引作为连接键，若 DataFrame 具有多层
  索引(MultiIndex)，则层的数量必须与连接键的数量相等。
• right_index 布尔参数，默认为 False。如果为 True 则使用左侧 DataFrame 的行索引作为连接键。
• how 要执行的合并类型，从 {‘left’, ‘right’, ‘outer’, ‘inner’} 中取值，默认为“inner”内连接。
• sort 布尔值参数，默认为True，它会将合并后的数据进行排序；若设置为 False，则按照 how 给定的参数值进行排序。
• suffixes 字符串组成的元组。当左右 DataFrame 存在相同列名时，通过该参数可以在相同的列名后附加后缀名，默认为(‘_x’,‘_y’)。
• copy 默认为 True，表示对数据进行复制。

示例：

现有数据：
left：
   id    Name subject_id
0   1   Smith       sub1
1   2   Maiki       sub2
2   3  Hunter       sub4
3   4   Hilen       sub6
right：
   id     Name subject_id
0   1  William       sub2
1   2   Albert       sub4
2   3     Tony       sub3

进行合并：
#通过on参数指定合并的键
print(pd.merge(left,right,on='id'))

输出：
   id  Name_x subject_id_x   Name_y subject_id_y
0   1   Smith         sub1  William         sub2
1   2   Maiki         sub2   Albert         sub4
2   3  Hunter         sub4     Tony         sub3
3   4   Hilen         sub6    Allen         sub6


也可以指定多个合并的键:
print(pd.merge(left,right,on=['id','subject_id'])) # 指定id和 subject_id
输出:
   id Name_x subject_id Name_y
0   4

在指定多个键进行合并的时候，只有相同的才能合并，在上面的例子里，left和right两个表格中，subject_id 只有在第四行 id为4的时候subject_id的值是相同的，都为sub6，所以才能合并，输出了这一行，如果将第一行都改成sub2，则这一行也会输出。

总结一下merge实际上就是下面几点:

• 一对一的关系 ，比如(学号，姓名) merge(学号，年龄)，结果为 1 * 1
• 一对多的关系，左边唯一，右边不唯一。比如(学号，姓名) merge (学号,[数学分，语文分，英语分]),结果为 1 * N
• 多对多的关系，比如(学号，[语文分，数学分]) merge (学号，[篮球，排球]) 结果为 M * N

一对多关系演示:

现有数据:
left = pd.DataFrame({
     'id':[11,12,13,14],
     'Name': ['Smith', 'Maiki', 'Hunter', 'Hilen'],
     })
right = pd.DataFrame({
     'id':[11,11,11,12,12,13],
     'grad': ['语文88', '数学99', '英语77', '语文11','数学44','英语77'],
     })
输出:
   id    Name
0  11   Smith
1  12   Maiki
2  13  Hunter

3  14   Hilen    id  grad
0  11  语文88
1  11  数学99
2  11  英语77
3  12  语文11
4  12  数学44
5  13  英语77

合并：

print(pd.merge(left,right,on=['id'])) 
   id    Name  grad
0  11   Smith  语文88
1  11   Smith  数学99
2  11   Smith  英语77
3  12   Maiki  语文11
4  12   Maiki  数学44
5  13  Hunter  英语77

可以看到一对多合并的过程，以右边为准，左边复制了好几条name。

多对多关系演示:

现有数据:

left = pd.DataFrame({
     'id':[11,11,12,12,12],
     'Name': ['篮球', '羽毛球', '乒乓球', '排球','水球'],
     })
right = pd.DataFrame({
     'id':[11,11,11,12,12,13],
     'grad': ['语文88', '数学99', '英语77', '语文11','数学44','英语77'],
     })
 id Name
0  11   篮球
1  11  羽毛球
2  12  乒乓球
3  12   排球
4  12   水球    id  grad
0  11  语文88
1  11  数学99
2  11  英语77
3  12  语文11
4  12  数学44
5  13  英语77

多对多合并:
print(pd.merge(left,right,on=['id']))

输出:
    id Name  grad
0   11   篮球  语文88
1   11   篮球  数学99
2   11   篮球  英语77
3   11  羽毛球  语文88
4   11  羽毛球  数学99
5   11  羽毛球  英语77
6   12  乒乓球  语文11
7   12  乒乓球  数学44
8   12   排球  语文11
9   12   排球  数学44
10  12   水球  语文11
11  12   水球  数学44

关于 inner join、right join 、left join 、full outer
看下面的图就懂了，left join 就是以左边的数据为准，右边也有的话就补充，左边没有 ，右边有的数据就扔掉，其他的同理。

concat

连接函数
concat语法: ​​​pd.concat(objs,axis=0,join='outer',join_axes=None,ignore_index=False)​​

• objs 一个序列或者是Series、DataFrame对象。
• axis 表示在哪个轴方向上（行或者列）进行连接操作，默认 axis=0 表示行方向。
• j oin 指定连接方式，取值为{“inner”,“outer”}，默认为 outer 表示取并集，inner代表取交集。
• ignore_index 布尔值参数，默认为 False，如果为 True，表示不在连接的轴上使用索引。
  join_axes 表示索引对象的列表。

这个比较简单直接看示例、

现有数据:
df1 = pd.DataFrame([['a', 1], ['b', 2]],
                   columns=['letter', 'number'])

df3 = pd.DataFrame([['c', 3, 'cat'], ['d', 4, 'dog']],
                   columns=['letter', 'number', 'animal'])
输出:
  letter  number
0      a       1
1      b       2
  letter  number animal
0      c       3    cat
1      d       4    dog
进行纵向合并：
print(pd.concat([df1, df3],  axis=1，sort=False)) # axis=1指纵向合并

输出：
  letter  number animal
0      a       1    NaN
1      b       2    NaN
0      c       3    cat
1      d       4

对于俩个格式不相同的数据，对于缺少的直接变成NaN，如果想只留下共有的，则加入参数 join=‘inner’。

九、groupby 分组

pandas里的分组和mysql里的分组相似，就用一个实例来看一下。

现有数据:
      data1     data2 key1   key2
0  0.974685 -0.672494    a    one
1 -0.214324  0.758372    b    one
2  1.508838  0.392787    a    two
3  0.522911  0.630814    b  three
4  1.347359 -0.177858    a    two
5 -0.264616  1.017155    b    two
6 -0.624708  0.450885    a    one
7 -1.019229 -1.143825

进行分组:

# 分组运算
grouped1 = df_obj.groupby('key1') # 按照key1进行分组
print(grouped1.mean()) # 对分组后的每个组求平均

grouped2 = df_obj['data1'].groupby(df_obj['key1']) # dataframe的 data1 列根据 key1 进行分组
print(grouped2.mean()) 

输出:
         data1     data2
key1                    
a     0.437389 -0.230101
b     0.014657  0.802114
key1
a    0.437389
b    0.014657
Name: data1, dtype:

对于分组同样也支持遍历 使用不同函数等操作。