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

res就保存了文件的内容

其中:

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

比如现有数据文件:

1!2!3

运行上面的代码后:

   a  b  c
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。
Pandas快速入门---------常用方法函数总结。_第1张图片

创建Series的三种方法

方法一:

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

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

指定索引:

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

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

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

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  Hilen       sub6   Mike

在指定多个键进行合并的时候,只有相同的才能合并,在上面的例子里,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 就是以左边的数据为准,右边也有的话就补充,左边没有 ,右边有的数据就扔掉,其他的同理。

Pandas快速入门---------常用方法函数总结。_第2张图片

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    dog

对于俩个格式不相同的数据,对于缺少的直接变成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    a  three

进行分组:

# 分组运算
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: float64

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

你可能感兴趣的:(个人笔记,交流学习,python)