数据分析三剑客之Pandas(持续更新中...)

已于 2024-07-18 22:37:29 修改
阅读量1.2k 收藏 25
点赞数 20
分类专栏： 数据分析 文章标签： pandas python 数据分析
于 2024-07-13 23:17:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Magician_liu/article/details/140408470
版权

文章目录

零基础之pandas

一.pandas基础知识

1.pandas初认识

import pandas as ps
data={
    'name':['lcl','小明','小红'],
    'age':[10,20,30],
}
df=ps.DataFrame(data)
print(type(df))
print(df)

运行结果：

<class 'pandas.core.frame.DataFrame'>
  name  age
0  lcl   10
1   小明   20
2   小红   30
进程已结束，退出代码为 0

初步收获：

​ 我们发现dataframe可以把一个字典格式的数据转换成类似于excel表格的列表形式。

2.pandas数据结构之Series

#### 2.1series概念
  • Series是一种类似与一维数组的对象，由下面两个部分组成：
    • values：一组数据（ndarray类型）
    • index：相关的数据索引标签
  • pandas Series类似于表格中的一个列（column),类似于一维数组，可以保存任何数据类型。

​ Series由索引（index)和列组成，函数如下：

pandas.Series(data,index,dtype,name.copy)

参数说明:

data：⼀组数据(ndarray 类型)。

index：数据索引标签，如果不指定，默认从 0 开始。

dtype：数据类型，默认会⾃⼰判断。

name：设置名称。

copy：拷⻉数据，默认为 False。

2.1data可以是列表，也可以是字典。

​ 如果是列表，不指定index参数，默认index从0开始，指定index的话需要和列表中的数据个数一致

​ 如果是字典，不指定index，默认索引为字典的全部key，指定index的话可以选取部分字典数据

2.2创建⼀个简单的 Series 实例：
import pandas as pd
data1=[3,2,4]
data2=['a','b','c']
s1=pd.Series(data1)
s2=pd.Series(data2)
print(type(s1))
print(type(s2))
print(s1)
print(s2)

输出如下：

<class 'pandas.core.series.Series'>
<class 'pandas.core.series.Series'>

0    3
1    2
2    4
dtype: int64  #数字类型

#索引	数据
0    a
1    b
2    c
#数据类型
dtype: object #字符串类型，但在python中字符串为对象类型

从上图可知，如果没有指定索引，索引值就从0开始

我们可以根据索引值读取数据

print(s1[0])
2.3指定索引值
a=['小明','小红','小亮']
myvar=pd.Series(a,index=['x','y','z'])
print(myvar)

x    小明
y    小红
z    小亮
dtype: object

索引取值：

myvar[‘x’]:小明

2.4使⽤ key/value 对象，类似字典来创建 Series：
import pandas as pd
data = {1: "哈哈", 2: "呵呵", 3: "喜喜"}
myvar = pd.Series(data)
print(myvar)

out:

1    哈哈
2    呵呵
3    喜喜
dtype: object

从上可知，字典的 key 变成了索引值。

如果我们只需要字典中的⼀部分数据，只需要指定需要数据的索引即可，如下:

import pandas as pd
data = {1: "哈哈", 2: "呵呵", 3: "喜喜"}
myvar = pd.Series(data, index = [1, 3]) #可以index参数指定索引
print(myvar)

out:

1    哈哈
3    喜喜
dtype: object
2.5设置 Series 名称参数：
myvar = pd.Series(data, index = [1, 3],name='小明') #参数name设置series名称
print(myvar)

out:

1    哈哈
3    喜喜
Name: 小明, dtype: object #我们输出时多了name属性
2.6Series的索引和切片
dic = {
    '语文':100,
    '数学':99,
    '理综':250
}
s = Series(data=dic)
print(s[0])
print(s.语文)
print(s[0:2])

out:

100
100
语文    100
数学     99
dtype: int64

进程已结束，退出代码为 0
2.7 Series的常用属性
  • Series的常用属性
    • shape
    • size
    • index
    • values
dic = {
    '语文':100,
    '数学':99,
    '理综':250
}
s = Series(data=dic)
print(s)
print(s.shape)
print(s.size)
print(s.index) #返回索引
print(s.values) #返回值
print(s.dtype) #元素的类型

语文    100
数学     99
理综    250
dtype: int64
(3,)
3
Index(['语文', '数学', '理综'], dtype='object')
[100  99 250]
int64
2.8Series的常用方法
  • head(),tail()
  • unique()
s = Series(data=np.random.randint(60,100,size=(10,)))
s.unique() #去重
print(s) #[99, 88, 74, 72, 80, 63, 85, 70, 76] 
				10个却只有9个,去重了！
  • isnull(),notnull()
s.isnull() #用于判断每一个元素是否为空，为空返回True，否则返回False
输出如下:
0    False
1    False
2    False
3    False
4    False
5    False
6    False
7    False
8    False
9    False
dtype: bool
s.notnull() 与isnull相反
输出如下:
0    True
1    True
2    True
3    True
4    True
5    True
6    True
7    True
8    True
9    True
dtype: bool
  • add() sub() mul() div()
2.9 Series的算术运算
  • 法则：索引一致的元素进行算数运算否则补空
s1 = Series(data=[1,2,3],index=['a','b','c'])
s2 = Series(data=[1,2,3],index=['a','d','c'])
s = s1 + s2
print(s)
print(s.isnull())

out

a    2.0
b    NaN
c    6.0
d    NaN
dtype: float64
a    False
b     True
c    False
d     True
dtype: bool

3 Pandas 数据结构 之DataFrame

3.1DataFrame初认识

​ DataFrame 是⼀个表格型的数据结构，它含有⼀组有序的列，每列可以是不同的值类型（数值、字符串、布尔型值）。

  • DataFrame是一个【表格型】的数据结构。DataFrame由按一定顺序排列的多列数据组成。设计初衷是将Series的使用场景从一维拓展到多维。DataFrame既有行索引，也有列索引。
    • 行索引：index
    • 列索引：columns
    • 值：values

​ DataFrame 既有⾏索引也有列索引，它可以被看做由 Series组成的字典（共同⽤⼀个索引）。
在这里插入图片描述
在这里插入图片描述

3.2DataFrame 构造⽅法
pandas.DataFrame( data, index, columns, dtype,copy)

参数说明：

data：⼀组数据(ndarray、series, map, lists, dict 等类

型)。

index：索引值，或者可以称为⾏标签。

columns：列标签，默认为 RangeIndex (0, 1, 2, …, n) 。

dtype：数据类型。

copy：拷⻉数据，默认为 False。

3.3使用列表创建实例

Pandas DataFrame 是⼀个⼆维的数组结构，类似⼆维数组。

实例 - 使⽤列表创建

import pandas as pd
data=[['小明',10,200],['小红',12,300],['小亮',100,300]]
df=pd.DataFrame(data,columns=['name','age','account'],dtype=float)
print(df)

类似于一个二维数组，创建时columns参数就是设置列索引，dtype就是设置数据类型,index和series一样设置行索引

out:

name    age  account
0   小明   10.0    200.0
1   小红   12.0    300.0
2   小亮  100.0    300.0
3.4使⽤ ndarrays 创建

​ ndarray ( N 维数组）是⼀个快速且灵活的数据集容器

​ 实例 - 使⽤ ndarrays 创建

import pandas as pd
import numpy as np
df = pd.DataFrame(data=np.random.randint(60,100,size=(8,4)),columns=['a','b','c','d'])
print(df)

out

    a   b   c   d
0  67  69  81  93
1  88  82  76  69
2  75  62  83  84
3  68  88  67  80
4  80  90  65  79
5  64  69  82  62
6  67  67  71  87
7  72  64  67  96

进程已结束，退出代码为 0

​

3.5使用字典套列表的方式创建(常用）
import pandas as pd
# data=[['小明',10,200],['小红',12,300],['小亮',100,300]]
# df=pd.DataFrame(data,columns=['name','age','account'],dtype=float)
data={'name':['小明','小红','小亮'],'age':[10,12,100],'account':[200,300,300]}
df=pd.DataFrame(data)
print(df)

out:

name  age  account
0   小明   10      200
1   小红   12      300
2   小亮  100      300

​ 从以上输出结果可以知道， DataFrame 数据类似⼀个表格，

包含 rows（⾏）和 columns（列）：

在这里插入图片描述

还可以使⽤字典（key/value），其中字典的 key 为列名:

3.6实例 - 使⽤字典创建
data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10,'c': 20}]
df = pd.DataFrame(data)
print(df)

out:

   a   b     c
0  1   2   NaN
1  5  10  20.0

没有对应的部分数据为NaN。

3.7DataFrame索引操作
  • 对行进行索引
  • 对列进行索引
  • 对元素进行索引
3.7.1对行索引
  • iloc:
    • 通过隐式索引取行
  • loc:
    • 通过显式索引取行
对行索引之loc(显式索引）有行显式索引，必须得使用显式行索引名称

Pandas 可以使⽤loc属性返回指定⾏的数据，如果没有设置索引，第⼀⾏索引为0，第⼆⾏索引为1

当然也可以loc[行索引，列索引]精准索引确认某数据

  • 因为没有设置行索引，因此此时可以用loc[隐式索引]来取，设置了就不能了，得用iloc来取
取单行
data={
    "calories": [420, 380, 390],
    "duration": [50, 40, 45]
}
df = pd.DataFrame(data)
# 返回第⼀⾏
print(df.loc[0])
# 返回第⼆⾏
print(df.loc[1])
print(type(df.loc[2]))

out

calories    420
duration     50
Name: 0, dtype: int64
calories    380
duration     40
Name: 1, dtype: int64
<class 'pandas.core.series.Series'>

Pandas 可以使⽤loc属性返回指定索引对应到某⼀⾏：

因此我先把dataframe每一行都认为是series对象，列索引为每个series对象的索引！！！！！

注意：返回结果其实就是⼀个 Pandas Series 数据。

取多行

也可以取多⾏数据，使⽤[[ ... ]]格式，...为各⾏的索引，以逗号隔开：

如下：

data={
    "calories": [420, 380, 390],
    "duration": [50, 40, 45]
}
df = pd.DataFrame(data)
print(df)
print(type(df.loc[[1,2]]))
print(df.loc[[1,2]])

out:

   calories  duration
0       420        50
1       380        40
2       390        45
<class 'pandas.core.frame.DataFrame'>
   calories  duration
1       380        40
2       390        45

注意：返回结果其实就是⼀个 Pandas DataFrame 数据。

我们可以指定索引值，如下实例：

data={
    "calories": [420, 380, 390],
    "duration": [50, 40, 45]
}
df = pd.DataFrame(data,index=['d1', 'd2', 'd3'])
print(df)
print(type(df.loc[['d1','d2']]))
print(df.loc[['d1','d2']])

out: index参数就是设置行索引！！！！设置之后就是显式索引了

    calories  duration
d1       420        50
d2       380        40
d3       390        45
<class 'pandas.core.frame.DataFrame'>
    calories  duration
d1       420        50
d2       380        40
loc小结:

​ Pandas 可以使⽤loc属性返回指定索引对应到某⼀⾏

​ 如果指定某一行，即df.loc[索引名],返回的是Series对象

​ 如果指定多行,即df.loc[[索引名1,索引名2,...]],返回的仍然是Dateframe对象

对行索引之iloc(隐式索引）有行显式索引，但想用隐式索引，可以用iloc
  • 用法与loc类似，一个是用显示索引，一个是用隐式索引。
3.7.2 对列索引
df = DataFrame(data=np.random.randint(60,100,size=(8,4)),columns=['a','b','c','d'])
取单列
df['a'] #取单列，如果df有显示的索引，通过索引机制去行或者列的时候只可以使用显示索引
取多列
df[['a','c']] #取多列
3.7.3对元素进行索引 loc[显式行索引,显式列索引] iloc[隐式行索引,隐式列索引]
df = DataFrame(data=np.random.randint(60,100,size=(8,4)),columns=['a','b','c','d'])
取单个元素
df.iloc[0,2]  #隐式索引
df.loc[0,'a'] #显示索引，因为有列索引，必须用列名称
取多个元素
df.iloc[[1,3,5],2]
3.8DataFrame的属性
  • values、columns、index、shape
from pandas import DataFrame
dic = {
    'name':['magician','xiaoming','xiaohong'],
    'salary':[1000,2000,3000]
}
df = DataFrame(data=dic,index=['a','b','c'])
print(df)
print(df.values)  ----------------类型为<class 'numpy.ndarray'>
print(df.columns)
print(df.index)
print(df.shape)

out:

       name  salary
a  magician    1000
b  xiaoming    2000
c  xiaohong    3000
[['magician' 1000]
 ['xiaoming' 2000]
 ['xiaohong' 3000]]   #类型为<class 'numpy.ndarray'>
Index(['name', 'salary'], dtype='object')
Index(['a', 'b', 'c'], dtype='object')
(3, 2)

进程已结束，退出代码为 0
3.9DataFrame的切片操作
  • 对行进行切片
  • 对列进行切片
对行进行切片
df[0:2]
  • 注意：当直接中括号索引时,即df[index]是取列的，但变为df[？：？]切片操作后就变成取行了，是行切片！
对列进行切片
df.iloc[:,0:2]
3.10df索引和切片操作总结
  • 索引：
    • df[col]:取列
    • df.loc[index]:取行
    • df.iloc[index,col]:取元素
  • 切片：
    • df[index1:index3]:切行
    • df.iloc[:,col1:col3]:切列
  • DataFrame的运算
    • 同Series
3.11df设置某列为行索引之set_index(列索引)
#将time列作为源数据的行索引
df.set_index('time',inplace=True)
3.12DataFrame的级联与合并操作
3.12.1 级联操作(类似于表的无脑拼接)
pd.concat()

  • pandas使用pd.concat函数，与np.concatenate函数类似，只是多了一些参数：

    • objs
    • axis=0
    • keys
    • join=‘outer’ / ‘inner’:表示的是级联的方式，outer会将所有的项进行级联（忽略匹配和不匹配），而inner只会将匹配的项级联到一起，不匹配的不级联
    • ignore_index=False

  • (1)匹配级联(行列索引都一致的级联叫做匹配级联)

df1 = pd.DataFrame(data=np.random.randint(0,100,size=(5,3)),columns=['A','B','C'])
df2 = pd.DataFrame(data=np.random.randint(0,100,size=(5,3)),columns=['A','D','C'])
print(pd.concat((df1,df1),axis=1)) #行列索引都一致的级联叫做匹配级联
输出如下:
    A   B   C   A   B   C
0   0  17  42   0  17  42
1  68  39  98  68  39  98
2  42   6  52  42   6  52
3   2  21  46   2  21  46
4  54  92  89  54  92  89

进程已结束，退出代码为 0
  • (2)不匹配级联
    • 不匹配指的是级联的维度的索引不一致。例如纵向级联时列索引不一致，横向级联时行索引不一致
    • 有2种连接方式：
      • 外连接：补NaN（默认模式）
      • 内连接：只连接匹配的项
    • 如果想要保留数据的完整性必须使用outer（外连接）
import pandas as pd
import numpy as np
df1 = pd.DataFrame(data=np.random.randint(0,100,size=(5,3)),columns=['A','B','C'])
df2 = pd.DataFrame(data=np.random.randint(0,100,size=(5,3)),columns=['A','D','C'])
print(pd.concat((df1,df2),axis=0)) #默认outer
print(pd.concat((df1,df2),axis=0,join='inner')) #inner直把可以级联的级联不能级联不处理

out:

    A     B   C     D
0  51  99.0  81   NaN
1  12   2.0  70   NaN
2  95  17.0  86   NaN
3  69   2.0  89   NaN
4  62  98.0   7   NaN
0   4   NaN  85  75.0
1  55   NaN   3  69.0
2  65   NaN  86  30.0
3   3   NaN  38   2.0
4  19   NaN  97  68.0
    A   C
0  51  81
1  12  70
2  95  86
3  69  89
4  62   7
0   4  85
1  55   3
2  65  86
3   3  38
4  19  97

进程已结束，退出代码为 0
append函数（不常用，了解，要被淘汰，可用pd.concat((df1,df2),axis=0)替代）
df1 = pd.DataFrame(data=np.random.randint(0,100,size=(5,3)),columns=['A','B','C'])
df2 = pd.DataFrame(data=np.random.randint(0,100,size=(5,3)),columns=['A','D','C'])
print(df1.append(df2))
print(df1.append(df1))

out (我们发现它是纵向外连接，可用pd.concat((df1,df2),axis=0)替代

    A     B   C     D
0  69  28.0  82   NaN
1  50  12.0  65   NaN
2   6  62.0  34   NaN
3   1  88.0  75   NaN
4  50  44.0  43   NaN
0  94   NaN  29  81.0
1  37   NaN  80  51.0
2  71   NaN   7  63.0
3  43   NaN  99  33.0
4  82   NaN  61  43.0
    A   B   C
0  69  28  82
1  50  12  65
2   6  62  34
3   1  88  75
4  50  44  43
0  69  28  82
1  50  12  65
2   6  62  34
3   1  88  75
4  50  44  43

进程已结束，退出代码为 0
3.12.2 合并操作(类似于数据库根据数据内容连接)

  • merge与concat的区别在于，merge需要依据某一共同列来进行合并

  • 使用pd.merge()合并时，会自动根据两者相同column名称的那一列，作为key来进行合并。

  • 注意每一列元素的顺序不要求一致

一对一合并
  • 示例
from pandas import DataFrame
import pandas as pd
df1 = DataFrame({'employee':['Bob','Jake','Lisa'],
                'group':['Accounting','Engineering','Engineering'],
                })
df2 = DataFrame({'employee':['Lisa','Bob','Jake'],
                'hire_date':[2010,2008,2012],
                })
print(df1)
print(df2)
print('合并后----------------------------------')
print(pd.merge(df1,df2,on='employee'))

out:

  employee        group
0      Bob   Accounting
1     Jake  Engineering
2     Lisa  Engineering
  employee  hire_date
0     Lisa       2004
1      Bob       2008
2     Jake       2012
合并后----------------------------------
  employee        group  hire_date
0      Bob   Accounting       2008
1     Jake  Engineering       2012
2     Lisa  Engineering       2004

进程已结束，退出代码为 0
一对多合并
df1 = DataFrame({
    'employee':['Lisa','Jake'],
    'group':['Accounting','Engineering'],
    'hire_date':[2004,2016]})
df2 = DataFrame({'group':['Accounting','Engineering','Engineering'],
                       'supervisor':['Carly','Guido','Steve']
                })
print(df1)
print(df2)
print('合并后----------------------------------')
print(pd.merge(df1,df2)) #on如果不写，默认情况下使用两表中公有的列作为合并条件

out

  employee        group  hire_date
0     Lisa   Accounting       2004
1     Jake  Engineering       2016
         group supervisor
0   Accounting      Carly
1  Engineering      Guido
2  Engineering      Steve
合并后----------------------------------
  employee        group  hire_date supervisor
0     Lisa   Accounting       2004      Carly
1     Jake  Engineering       2016      Guido
2     Jake  Engineering       2016      Steve

进程已结束，退出代码为 0
多对多合并
df1 = DataFrame({'employee':['Bob','Jake','Lisa'],
                 'group':['Accounting','Engineering','Engineering']})
df2 = DataFrame({'group':['Engineering','Engineering','HR'],
                'supervisor':['Carly','Guido','Steve']
                })
print(df1)
print(df2)
print('合并后----------------------------------')
print(pd.merge(df1,df2,how='right')) #右外连接
print(pd.merge(df1,df2,how='left'))  #左外连接

out (注意观察空值的位置)

  employee        group
0      Bob   Accounting
1     Jake  Engineering
2     Lisa  Engineering
         group supervisor
0  Engineering      Carly
1  Engineering      Guido
2           HR      Steve
合并后----------------------------------
  employee        group supervisor
0     Jake  Engineering      Carly
1     Lisa  Engineering      Carly
2     Jake  Engineering      Guido
3     Lisa  Engineering      Guido
4      NaN           HR      Steve
  employee        group supervisor
0      Bob   Accounting        NaN
1     Jake  Engineering      Carly
2     Jake  Engineering      Guido
3     Lisa  Engineering      Carly
4     Lisa  Engineering      Guido

进程已结束，退出代码为 0
当两张表没有可进行连接的列时，可使用left_on和right_on手动指定merge中左右两边的哪一列作为连接的列
df1 = DataFrame({'employee':['Bobs','Linda','Bill'],
                'group':['Accounting','Product','Marketing'],
               'hire_date':[1998,2017,2018]})
df2 = DataFrame({'name':['Lisa','Bobs','Bill'],
                'hire_dates':[1998,2016,2007]})
print(df1)
print(df2)
print('合并后----------------------------------')
print(pd.merge(df1,df2,left_on='employee',right_on='name')) #由输出结果判断这里默认how为inner

out

  employee       group  hire_date
0     Bobs  Accounting       1998
1    Linda     Product       2017
2     Bill   Marketing       2018
   name  hire_dates
0  Lisa        1998
1  Bobs        2016
2  Bill        2007
合并后----------------------------------
  employee       group  hire_date  name  hire_dates
0     Bobs  Accounting       1998  Bobs        2016
1     Bill   Marketing       2018  Bill        2007

进程已结束，退出代码为 0

二.pandas CSV文件

Pandas 可以很⽅便的处理 CSV ⽂件本⽂以 nba.csv为例

1.CSV文件概述

​ CSV（Comma-Separated Values，逗号分隔值，有时也称为字符分隔值，因为分隔字符也可以不是逗号），其⽂件以纯⽂本形式存储表格数据（数字和⽂本）。

​ CSV 是⼀种通⽤的、相对简单的⽂件格式，被⽤户、商业和科学⼴泛应⽤。

2.pandas之写csv文件 ：to_csv()

​ 我们可以使⽤to_csv()⽅法将 DataFrame 存储为 csv ⽂件：

import pandas as pd
# 三个字段 name, site, age
name = ["小明", "小红", "小亮", "小林"]
site = ["www.xiaoming.com", "www.xiaohong.com","www.xiaoliang.com", "www.xiaolin.org"]
age = [90, 40, 80, 98]
# 字典
dict = {'name': name, 'site': site, 'age': age}
#生成了dataframe对象
df = pd.DataFrame(dict)
print(df)
df.to_csv('./info.csv')

out:

  name               site  age
0   小明   www.xiaoming.com   90
1   小红   www.xiaohong.com   40
2   小亮  www.xiaoliang.com   80
3   小林    www.xiaolin.org   98

上方是df对象，写入csv后打开csv如下：

在这里插入图片描述

注意：在写⼊csv⽂件会默认将索引写⼊如果不需要索引则需添加参数进⾏处理

​ df.to_csv('site.csv', index=False)

3.pandas之读csv文件 ： ps:pd.read_csv(‘nba.csv’)其返回dataframe对象

​ to_string()⽤于返回 DataFrame 类型的数据，如果不使⽤该函数，则输出结果为数据的前⾯ 5 ⾏和末尾 5 ⾏，中间部分以...代替。

例如：

import pandas as pd
data=pd.read_csv('./info.csv')
print(type(data))
print(data)

out:

<class 'pandas.core.frame.DataFrame'>
   Unnamed: 0 name               site  age
0           0   小明   www.xiaoming.com   90
1           1   小红   www.xiaohong.com   40
2           2   小亮  www.xiaoliang.com   80
3           3   小林    www.xiaolin.org   98

注意：

​ 它把我存入csv的索引也当成了数据读了进来，并自动又创建了索引。

4.数据处理

​ to_string()⽤于返回 DataFrame 类型的数据，如果不使⽤该函数，则输出结果为数据的前⾯ 5 ⾏和末尾 5 ⾏，中间部分以...代替。

​ 即dataframe类型数据过多时中间会用…替代，而转换为str类型就会全部显示

data=pd.read_csv('./info.csv')
print(type(data)) #<class 'pandas.core.frame.DataFrame'>
print(type(data.to_string())) #<class 'str'>
4.1head()

​ head( n)⽅法⽤于读取前⾯的 n ⾏，如果不填参数 n ，默认返回 5 ⾏。

import pandas as pd
data=pd.read_csv('./info.csv')
print(type(data))
print(data.head())
print(data.head(10))

out:

<class 'pandas.core.frame.DataFrame'>
   Unnamed: 0 name               site  age
0           0   小明   www.xiaoming.com   90
1           1   小红   www.xiaohong.com   40
2           2   小亮  www.xiaoliang.com   80
3           3   小林    www.xiaolin.org   98
4           3   小林    www.xiaolin.org   98
   Unnamed: 0 name               site  age
0           0   小明   www.xiaoming.com   90
1           1   小红   www.xiaohong.com   40
2           2   小亮  www.xiaoliang.com   80
3           3   小林    www.xiaolin.org   98
4           3   小林    www.xiaolin.org   98
5           3   小林    www.xiaolin.org   98
6           3   小林    www.xiaolin.org   98
7           3   小林    www.xiaolin.org   98
8           3   小林    www.xiaolin.org   98
9           3   小林    www.xiaolin.org   98
4.2tail()

​ tail( n )⽅法⽤于读取尾部的 n ⾏，如果不填参数 n ，默认返回 5 ⾏，空⾏各个字段的值返回NaN。

实例 :

import pandas as pd
data=pd.read_csv('./info.csv')
print(type(data))
print(data.tail())
print(data.tail(10))

out:

<class 'pandas.core.frame.DataFrame'>
    Unnamed: 0 name             site  age
11           3   小林  www.xiaolin.org   98
12           3   小林  www.xiaolin.org   98
13           3   小林  www.xiaolin.org   98
14           3   小林  www.xiaolin.org   98
15           3   小林  www.xiaolin.org   98
    Unnamed: 0 name             site  age
6            3   小林  www.xiaolin.org   98
7            3   小林  www.xiaolin.org   98
8            3   小林  www.xiaolin.org   98
9            3   小林  www.xiaolin.org   98
10           3   小林  www.xiaolin.org   98
11           3   小林  www.xiaolin.org   98
12           3   小林  www.xiaolin.org   98
13           3   小林  www.xiaolin.org   98
14           3   小林  www.xiaolin.org   98
15           3   小林  www.xiaolin.org   98
4.3info()

​ info() ⽅法返回表格的⼀些基本信息

import pandas as pd
data=pd.read_csv('./info.csv')
print(data.info())

out:

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 16 entries, 0 to 15   ps：行数，索引从0-15
Data columns (total 4 columns):  ps:列数，4列
 #   Column      Non-Null Count  Dtype   ps：各列的数据类型
---  ------      --------------  ----- 
 0   Unnamed: 0  16 non-null     int64 
 1   name        16 non-null     object
 2   site        16 non-null     object
 3   age         16 non-null     int64 
dtypes: int64(2), object(2)
memory usage: 640.0+ bytes
None

non-null 为⾮空数据，我们可以看到上⾯的信息中，得知哪一列空值最多

三.pandas Excel文件

​ Pandas提供了⾮常强⼤的功能操作Excel,是数据分析领域处理Excel⽂档的重要⼯具

1.1读取excel (与csv类似)

pd.read_excel()

1.2 写入Excel （与csv类似)

df.to_excel()

读写excel时有很多参数：

​ index 是否写⼊索引默认为True

​ header 是否写⼊表头默认True

​ sheet_name 写⼊哪个sheet⻚默认sheet1

​ startrow 写⼊Excel数据开始⾏默认0⾏

​ startcol 写⼊Excel数据开始列默认0列

1.3实例时参数header的区别

import pandas as pd
data_header_None=pd.read_excel('./excel.xlsx',sheet_name='pandas',header=None)
print('header=None时：')
print(data_header_None)
data_header_true=pd.read_excel('./excel.xlsx',sheet_name='pandas')
print('header=True时：')
print(data_header_true)

out

header=None时：
        0     1     2     3   4       5
0    销售年份  销售地区  销售人员    品名  数量   销售金额￥
1   43896    北京    苏珊  液晶电视   1  215000
2   44237    北京    李兵   微波炉   5  114400
3   43896    北京    苏珊   按摩椅  13  147000
4   44237    北京    赵琦   按摩椅  20   54400
5   44237    北京    白丁   微波炉  24   22400
6   43896    北京    白丁   微波炉  27   34500
7   44237    北京    白丁   按摩椅  28   36000
8   44237    北京    李兵   跑步机  30  132000
9   43896    北京    苏珊   显示器  33  265000
10  43896    北京    白丁  液晶电视  34   13500
11  44237    北京    赵琦   显示器  40   32500
12  44237    北京    赵琦  液晶电视  41   78000
13  43896    北京    白丁  液晶电视  43  170000
14  44237    北京    白丁   按摩椅  45   16000
15  43896    北京    苏珊  液晶电视  47    5000
16  43896    北京    苏珊   显示器  49  114000
17  44237    北京    李兵   跑步机  52   66000
18  44237    北京    赵琦   显示器  52  270000
19  43896    北京    苏珊  液晶电视  53  235000
20  44237    北京    赵琦  液晶电视  54   60000
21  44237    北京    李兵   跑步机  60   15400
22  44237    北京    赵琦   微波炉  65    2500
23  44237    北京    赵琦   按摩椅  68  115500
24  43896    北京    白丁   微波炉  69   12000
25  43896    北京    苏珊   显示器  76   49500
26  44237    北京    赵琦   显示器  77  205000
27  43896    北京    苏珊   显示器  98   73500
header=True时：
     销售年份 销售地区 销售人员    品名  数量   销售金额￥
0   43896   北京   苏珊  液晶电视   1  215000
1   44237   北京   李兵   微波炉   5  114400
2   43896   北京   苏珊   按摩椅  13  147000
3   44237   北京   赵琦   按摩椅  20   54400
4   44237   北京   白丁   微波炉  24   22400
5   43896   北京   白丁   微波炉  27   34500
6   44237   北京   白丁   按摩椅  28   36000
7   44237   北京   李兵   跑步机  30  132000
8   43896   北京   苏珊   显示器  33  265000
9   43896   北京   白丁  液晶电视  34   13500
10  44237   北京   赵琦   显示器  40   32500
11  44237   北京   赵琦  液晶电视  41   78000
12  43896   北京   白丁  液晶电视  43  170000
13  44237   北京   白丁   按摩椅  45   16000
14  43896   北京   苏珊  液晶电视  47    5000
15  43896   北京   苏珊   显示器  49  114000
16  44237   北京   李兵   跑步机  52   66000
17  44237   北京   赵琦   显示器  52  270000
18  43896   北京   苏珊  液晶电视  53  235000
19  44237   北京   赵琦  液晶电视  54   60000
20  44237   北京   李兵   跑步机  60   15400
21  44237   北京   赵琦   微波炉  65    2500
22  44237   北京   赵琦   按摩椅  68  115500
23  43896   北京   白丁   微波炉  69   12000
24  43896   北京   苏珊   显示器  76   49500
25  44237   北京   赵琦   显示器  77  205000
26  43896   北京   苏珊   显示器  98   73500

excel表格如下：

在这里插入图片描述

注意（默认把第一行作为表头读入，即列索引）

​ 当前在读取Excel以后会默认把第⼀⾏作为表头，这样在写⼊的时候会⾃带格式，为了防⽌这个问题出现，所以需要再读取和写⼊的时候给定参数

​ 当前上⾯处理csv的所有⽅法在这⾥可以同样去使⽤，这⾥就不在过多赘述咯~

四.pandas数据清洗

数据清洗是对⼀些没有⽤的数据进⾏处理的过程。

​ 很多数据集存在数据缺失、数据格式错误、错误数据或重复数据的情况，如果要对使数据分析更加准确，就需要对这些没有⽤的数据进⾏处理。

​ 因此我们将利⽤ Pandas包来进⾏数据清洗。

1.清洗空值

  • 处理丢失数据
    • 有两种丢失数据：
      None
      np.nan(NaN)
  • 两种丢失数据的区别
    • type(None):NoneType
    • type(NaN):float
  • 为什么在数据分析中需要用到的是浮点类型的空而不是对象类型？
    • 数据分析中会常常使用某些形式的运算来处理原始数据，如果原数数据中的空值为NAN的形式，则不会干扰或者中断运算。
    • NAN可以参与运算的
    • None是不可以参与运算
  • pandas处理空值操作
    • isnull
    • notnull
    • any
    • all
    • dropna
    • fillna
1.1isnull的使用（查找空值)
  • isnull函数常常和any搭配使用，而notnull函数和all搭配使用。
  • df.isnull().any(axis=1) #any会作用isnull返回结果的每一行
    • 不选中某列，而是对整个表，any:只要某行有空值就会返回true，axis=1代表行
  • df.notnull().all(axis=1)
    • 也是对整个表，all：只要某行全不为空，则返回true，而有空值，则返回False.
  • 以上都是返回一个bool类型的Series对象
    csv文件内容如下：

在这里插入图片描述

#isnull的使用
import pandas as pd
df=pd.read_csv('info.csv')
#打印所有列
print(df)
#打印NUM_BEDROOMS
print(df['NUM_BEDROOMS'])
print(type(df['NUM_BEDROOMS']))

out:

           PID  ST_NUM     ST_NAME OWN_OCCUPIED NUM_BEDROOMS NUM_BATH SQ_FT
0  100001000.0   104.0      PUTNAM            Y            3        1  1000
1  100002000.0   197.0   LEXINGTOM            N            3      1.5    --
2  100003000.0     NaN   LEXINGTON            N          NaN        1   850
3  100004000.0   201.0    BERKELEY           12            1      NaN   700
4          NaN   203.0    BERKELEY            Y            3        2  1600
5  100006000.0   207.0    BERKELEY            Y          NaN        1   800
6  100007000.0     NaN  WASHINGTON          NaN            2   HURLEY   950
7  100008000.0   213.0     TREMONT            Y            1        1   NaN
8  100009000.0   215.0     TREMONT            Y           na        2  1800
0      3
1      3
2    NaN
3      1
4      3
5    NaN
6      2
7      1
8     na
Name: NUM_BEDROOMS, dtype: object
<class 'pandas.core.series.Series'>

我们发现原本csv文件中的值n/a,NA读入时转换成了NAN，即为NULL类型，比如我们用isnull验证一下：

print(df['NUM_BEDROOMS'].isnull())
print(type(df['NUM_BEDROOMS'].isnull()))
#哪些行中有空值
#any(axis=1)检测哪些行中存有空值
df.isnull().any(axis=1) #any会作用isnull返回结果的每一行
	不选中某列，而是对整个表，any:只要某行有空值就会返回true，axis=1代表行
#true对应的行就是存有缺失数据的行

out:

0    False
1    False
2     True
3    False
4    False
5     True
6    False
7    False
8    False
Name: NUM_BEDROOMS, dtype: bool
<class 'pandas.core.series.Series'>

我们发现数据na没有被转换成NAN，从而isnull之后为False，因此我们需要在实例化时添加参数，使其将对应的数据转换成NAN。

如下:

​

import pandas as pd
miss_values=['na','--','n/a']
df=pd.read_csv('info.csv',na_values=miss_values)
#打印NUM_BEDROOMS
print(df['NUM_BEDROOMS'].isnull())

out:

0    False
1    False
2     True
3    False
4    False
5     True
6    False
7    False
8     True
Name: NUM_BEDROOMS, dtype: bool

​ 索引为8的数据变为了true。

​ 代表成功将不需要的数据变为NAN，即为空，为之后清洗做准备

isnull（）小结：

​ 读取的数据中有无效的数据，在我们将其转为dataframe对象时，应添加na_values参数将无用的目标数据转换为NAN，其为空后即可方便对其删除

1.2dropna()的使用 (删除空值)
  • 如果用1.1所对应得方法，我们可以这样删除空值，但比较麻烦!
#将布尔值作为源数据的行索引
df.loc[df.notnull().all(axis=1)]
#获取空对应的行数据
df.loc[df.isnull().any(axis=1)]
#获取空对应行数据的行索引
indexs = df.loc[df.isnull().any(axis=1)].index
df.drop(labels=indexs,axis=0)
  • 如果我们要删除包含空字段的⾏，可以使⽤更简便的方法:dropna()函数

语法格式如下：

DataFrame.dropna(axis=0, how='any',thresh=None, subset=None, inplace=False)

参数说明：

axis：默认为0，表示逢空值剔除整⾏，如果设置参数axis ＝1表示逢空值去掉整列。

how：默认为any如果⼀⾏（或⼀列）⾥任何⼀个数据有出现 NA 就去掉整⾏，如果设置how='all'⼀⾏（或列）都是 NA 才去掉这整⾏。

thresh：设置需要多少⾮空值的数据才可以保留下来的。

subset：设置想要检查的列。如果是多个列，可以使⽤列名的 list 作为参数。

inplace：如果设置 True，将计算得到的值直接覆盖之前的值并返回 None，修改的是源数据。

接下来的实例演示了删除包含空数据的⾏。

#dropna的使用
import pandas as pd
df=pd.read_csv('info.csv')
new_df=df.dropna()
print(df)
print(new_df)

out:

           PID  ST_NUM     ST_NAME OWN_OCCUPIED NUM_BEDROOMS NUM_BATH SQ_FT
0  100001000.0   104.0      PUTNAM            Y            3        1  1000
1  100002000.0   197.0   LEXINGTOM            N            3      1.5    --
2  100003000.0     NaN   LEXINGTON            N          NaN        1   850
3  100004000.0   201.0    BERKELEY           12            1      NaN   700
4          NaN   203.0    BERKELEY            Y            3        2  1600
5  100006000.0   207.0    BERKELEY            Y          NaN        1   800
6  100007000.0     NaN  WASHINGTON          NaN            2   HURLEY   950
7  100008000.0   213.0     TREMONT            Y            1        1   NaN
8  100009000.0   215.0     TREMONT            Y           na        2  1800
           PID  ST_NUM    ST_NAME OWN_OCCUPIED NUM_BEDROOMS NUM_BATH SQ_FT
0  100001000.0   104.0     PUTNAM            Y            3        1  1000
1  100002000.0   197.0  LEXINGTOM            N            3      1.5    --
8  100009000.0   215.0    TREMONT            Y           na        2  1800

​ new_df所有包含空值的行都被删除了！！！！！！！！！！！！！！！！

1.2.1inplace参数(决定是否在源数据上修改)

默认情况下，dropna不会在源df上修改，而是复制产生了一个新的new_df

要想在源数据上修改，我们需要添加参数,示例如下：

new_df=df.dropna(inplace=True)
print(df)
print(new_df)

out:

           PID  ST_NUM    ST_NAME OWN_OCCUPIED NUM_BEDROOMS NUM_BATH SQ_FT
0  100001000.0   104.0     PUTNAM            Y            3        1  1000
1  100002000.0   197.0  LEXINGTOM            N            3      1.5    --
8  100009000.0   215.0    TREMONT            Y           na        2  1800
None

new_df为空，而原来的df发生改变了！！！

1.2.2 subset参数（指定根据某些列上是否有空值来删除）
import pandas as pd
df=pd.read_csv('info.csv')
new_df=df.dropna(subset=['NUM_BEDROOMS'])  #某列
#new_df=df.dropna(subset=['NUM_BEDROOMS','ST_NUM'])  #多列
print(df)
print(new_df)

out:

          PID  ST_NUM     ST_NAME OWN_OCCUPIED NUM_BEDROOMS NUM_BATH SQ_FT
0  100001000.0   104.0      PUTNAM            Y            3        1  1000
1  100002000.0   197.0   LEXINGTOM            N            3      1.5    --
2  100003000.0     NaN   LEXINGTON            N          NaN        1   850
3  100004000.0   201.0    BERKELEY           12            1      NaN   700
4          NaN   203.0    BERKELEY            Y            3        2  1600
5  100006000.0   207.0    BERKELEY            Y          NaN        1   800
6  100007000.0     NaN  WASHINGTON          NaN            2   HURLEY   950
7  100008000.0   213.0     TREMONT            Y            1        1   NaN
8  100009000.0   215.0     TREMONT            Y           na        2  1800
           PID  ST_NUM     ST_NAME OWN_OCCUPIED NUM_BEDROOMS NUM_BATH SQ_FT
0  100001000.0   104.0      PUTNAM            Y            3        1  1000
1  100002000.0   197.0   LEXINGTOM            N            3      1.5    --
3  100004000.0   201.0    BERKELEY           12            1      NaN   700
4          NaN   203.0    BERKELEY            Y            3        2  1600
6  100007000.0     NaN  WASHINGTON          NaN            2   HURLEY   950
7  100008000.0   213.0     TREMONT            Y            1        1   NaN
8  100009000.0   215.0     TREMONT            Y           na        2  1800
1.3fillna()的使用 （替换空值)

我们也可以fillna()⽅法来替换⼀些空字段：

​ 例如使⽤ 12345 替换空字段：

#fillna的使用
import pandas as pd
df=pd.read_csv('info.csv')
new_df=df.fillna(123456)
print(df)
print(new_df)

out:

           PID  ST_NUM     ST_NAME OWN_OCCUPIED NUM_BEDROOMS NUM_BATH SQ_FT
0  100001000.0   104.0      PUTNAM            Y            3        1  1000
1  100002000.0   197.0   LEXINGTOM            N            3      1.5    --
2  100003000.0     NaN   LEXINGTON            N          NaN        1   850
3  100004000.0   201.0    BERKELEY           12            1      NaN   700
4          NaN   203.0    BERKELEY            Y            3        2  1600
5  100006000.0   207.0    BERKELEY            Y          NaN        1   800
6  100007000.0     NaN  WASHINGTON          NaN            2   HURLEY   950
7  100008000.0   213.0     TREMONT            Y            1        1   NaN
8  100009000.0   215.0     TREMONT            Y           na        2  1800
           PID    ST_NUM     ST_NAME OWN_OCCUPIED NUM_BEDROOMS NUM_BATH   SQ_FT
0  100001000.0     104.0      PUTNAM            Y            3        1    1000
1  100002000.0     197.0   LEXINGTOM            N            3      1.5      --
2  100003000.0  123456.0   LEXINGTON            N       123456        1     850
3  100004000.0     201.0    BERKELEY           12            1   123456     700
4     123456.0     203.0    BERKELEY            Y            3        2    1600
5  100006000.0     207.0    BERKELEY            Y       123456        1     800
6  100007000.0  123456.0  WASHINGTON       123456            2   HURLEY     950
7  100008000.0     213.0     TREMONT            Y            1        1  123456
8  100009000.0     215.0     TREMONT            Y           na        2    1800

inplace参数与dropna同理

我们也可以指定某⼀个列来替换数据：

使⽤ 12345 替换 PID 为空数据：

  • 即选中某列进行fillna():df['PID'].fillna(123456,inplace=True)
import pandas as pd
df=pd.read_csv('info.csv')
new_df=df['PID'].fillna(123456,inplace=True)
print(df)
print(new_df)

out:

          PID  ST_NUM     ST_NAME OWN_OCCUPIED NUM_BEDROOMS NUM_BATH SQ_FT
0  100001000.0   104.0      PUTNAM            Y            3        1  1000
1  100002000.0   197.0   LEXINGTOM            N            3      1.5    --
2  100003000.0     NaN   LEXINGTON            N          NaN        1   850
3  100004000.0   201.0    BERKELEY           12            1      NaN   700
4     123456.0   203.0    BERKELEY            Y            3        2  1600
5  100006000.0   207.0    BERKELEY            Y          NaN        1   800
6  100007000.0     NaN  WASHINGTON          NaN            2   HURLEY   950
7  100008000.0   213.0     TREMONT            Y            1        1   NaN
8  100009000.0   215.0     TREMONT            Y           na        2  1800
None

要对某列进行替换，我们只要选中某列再fillna()即可

替换空单元格的常⽤⽅法是计算列的均值、中位数值或众数。

Pandas使⽤mean()、median()和mode()⽅法计算列的均值（所有值加起来的平均值）、中位数值（排序后排在中间的数）和众数（出现频率最⾼的数）。

1.3.1使⽤mean()、median()和mode()⽅法计算列的均值并替换空单元格：
#mean()，median() mode()的使用
import pandas as pd
df=pd.read_csv('info.csv')
print('原数据如下：')
print(df)
#---------------------------------------------------
mean=df['PID'].mean()  #求平均值
print('PID列的平均数为：',mean)
df['PID'].fillna(mean,inplace=True)  #替换该列空值为平均值
#---------------------------------------------------
median=df['ST_NUM'].median() #求该列中位数
print('ST_NUM列的中位数为：',median)
df['ST_NUM'].fillna(median,inplace=True) #替换该列空值为中位数
#------------------------------------------------------
mode=df['NUM_BATH'].mode()  #求该列众数
print('NUM列的众数为：',mode)
df['NUM_BATH'].fillna(mode,inplace=True) #替换该列空值为众数
#--------------------------------------------------------------
print('替换后的数据如下:')
print(df)

out:

原数据如下：
           PID  ST_NUM     ST_NAME OWN_OCCUPIED NUM_BEDROOMS NUM_BATH SQ_FT
0  100001000.0   104.0      PUTNAM            Y            3        1  1000
1  100002000.0   197.0   LEXINGTOM            N            3      1.5    --
2  100003000.0     NaN   LEXINGTON            N          NaN        1   850
3  100004000.0   201.0    BERKELEY           12            1      NaN   700
4          NaN   203.0    BERKELEY            Y            3        2  1600
5  100006000.0   207.0    BERKELEY            Y          NaN        1   800
6  100007000.0     NaN  WASHINGTON          NaN            2   HURLEY   950
7  100008000.0   213.0     TREMONT            Y            1        1   NaN
8  100009000.0   215.0     TREMONT            Y           na        2  1800
PID列的平均数为： 100005000.0
ST_NUM列的中位数为： 203.0
NUM列的众数为： 0    1
Name: NUM_BATH, dtype: object
替换后的数据如下:
           PID  ST_NUM     ST_NAME OWN_OCCUPIED NUM_BEDROOMS NUM_BATH SQ_FT
0  100001000.0   104.0      PUTNAM            Y            3        1  1000
1  100002000.0   197.0   LEXINGTOM            N            3      1.5    --
2  100003000.0   203.0   LEXINGTON            N          NaN        1   850
3  100004000.0   201.0    BERKELEY           12            1      NaN   700
4  100005000.0   203.0    BERKELEY            Y            3        2  1600
5  100006000.0   207.0    BERKELEY            Y          NaN        1   800
6  100007000.0   203.0  WASHINGTON          NaN            2   HURLEY   950
7  100008000.0   213.0     TREMONT            Y            1        1   NaN
8  100009000.0   215.0     TREMONT            Y           na        2  1800

进程已结束，退出代码为 0
1.3.2使⽤表格空值位置的前后左右进行替换空值(method参数设置）
  • 使用空的近邻值进行填充
  • method=ffill向前填充，bfill向后填充
    • df.fillna(axis=0,method='bfill')
    • 使用方法同上

2.清洗错误格式数据

​ 数据格式错误的单元格会使数据分析变得困难，甚⾄不可能。

​ 我们可以通过包含空单元格的⾏，或者将列中的所有单元格转换为相同格式的数据。

以下实例会格式化⽇期：

#清洗错误格式的数据
import pandas as pd
data={
    'name':['小红','小明','小亮'],
    'birthday':['2006/01/01','2003/06/01','20020612'],
}
df=pd.DataFrame(data)
print(df)
print('清洗后,将日期格式转换为正确的格式！')
df['birthday']=pd.to_datetime(df['birthday'])
print(df)

out:

  name    birthday
0   小红  2006/01/01
1   小明  2003/06/01
2   小亮    20020612
清洗后,将日期格式转换为正确的格式！
  name   birthday
0   小红 2006-01-01
1   小明 2003-06-01
2   小亮 2002-06-12

3.清洗错误数据(df.loc[2][‘age’]能查数据，但不能修改，修改要df.loc[2,'age']=18)

​ 数据错误也是很常⻅的情况，我们可以对错误的数据进⾏替换或移除。

以下实例会替换错误年龄的数据：

3.1替换已经确定位置的值
#清洗错误数据
import pandas as pd
data={
    'name':['小明','小红','小亮'],
    'age':[10,20,122],
}
df=pd.DataFrame(data)
print(df)
df.loc[2,'age']=18
#print(df.loc[2]['age'])
#df.loc[1]['age']=100  会报错
print(df)

out:

  name  age
0   小明   10
1   小红   20
2   小亮  122
  name  age
0   小明   10
1   小红   20
2   小亮   18

进程已结束，退出代码为 0
3.2也可以设置条件语句：将 age ⼤于 120 的设置为 120:
import pandas as pd
data={
    'name':['小明','小红','小亮'],
    'age':[10,20,122],
}
df=pd.DataFrame(data)
print(df)
for index in df.index:
    if df.loc[index,'age']>120:
        df.loc[index,'age']=120
print(df)

out:

  name  age
0   小明   10
1   小红   20
2   小亮  122
  name  age
0   小明   10
1   小红   20
2   小亮  120
3.3可以将错误数据的⾏删除：df.drop(index,…)

将 age ⼤于 120 的删除:

import pandas as pd
data={
    'name':['小明','小红','小亮'],
    'age':[10,20,122],
}
df=pd.DataFrame(data)
print(df)
for index in df.index:
    if df.loc[index,'age']>120:
        df.drop(index,inplace=True)
print(df)

out:

  name  age
0   小明   10
1   小红   20
2   小亮  122
  name  age
0   小明   10
1   小红   20

进程已结束，退出代码为 0

4.Pandas 清洗重复数据（所有列相同才为重复数据)

如果我们要清洗重复数据，可以使⽤duplicated()和drop_duplicates()⽅法。

如果对应的数据是重复的，duplicated()会返回 True，否则返回 False。

4.1duplicated() 默认keep参数为first，即保留重复数据的第一项，若要修改，将其改为last
#删除重复数据
import pandas as pd
data={
    'name':['小明','小红','magician','小明','magician'],
    'age':[10,20,122,10,20],
}
df=pd.DataFrame(data)
print(df)
print(df.duplicated())

out:

       name  age
0        小明   10
1        小红   20
2  magician  122
3        小明   10
4  magician   20
0    False
1    False
2    False
3     True
4    False
dtype: bool

我们发现要所有列全一样才为重复数据！

4.2drop_duplicates() 同理也有keep参数
import pandas as pd
data={
    'name':['小明','小红','magician','小明','magician'],
    'age':[10,20,122,10,20],
}
df=pd.DataFrame(data)
print(df)
df.drop_duplicates(inplace=True)
print(df)

out:

       name  age
0        小明   10
1        小红   20
2  magician  122
3        小明   10
4  magician   20
       name  age
0        小明   10
1        小红   20
2  magician  122
4  magician   20

​ 现在我假设有如下情景，只要name相同，我就要删除重复的后面的数据，只保留第一个name，是否可以如下操作？

import pandas as pd
data={
    'name':['小明','小红','magician','小明','magician'],
    'age':[10,20,122,10,20],
}
df=pd.DataFrame(data)
print(df)
print(df['name'].duplicated())
df['name'].drop_duplicates(inplace=True)
print(df)

out:

       name  age
0        小明   10
1        小红   20
2  magician  122
3        小明   10
4  magician   20
-----------------------
0    False
1    False
2    False
3     True
4     True
Name: name, dtype: bool
----------------------------
       name  age
0        小明   10
1        小红   20
2  magician  122
3        小明   10
4  magician   20

​ 删除失败！！！！！！！！！！！！！！

new_df=df['name'].drop_duplicates()
print(new_df)

out:

0          小明
1          小红
2    magician
Name: name, dtype: object

进程已结束，退出代码为 0

假想错误，经过百度查得：

​ 可以添加subset参数来选择某列来进行判断重复标准来进行删除

4.3根据指定列发生重复进行删除（subset参数的使用)
import pandas as pd
data={
    'name':['小明','小红','magician','小明','magician'],
    'age':[10,20,122,10,20],
}
df=pd.DataFrame(data)
print(df)
df.drop_duplicates(subset='name',inplace=True)
print(df)

out:

       name  age
0        小明   10
1        小红   20
2  magician  122
3        小明   10
4  magician   20
       name  age
0        小明   10
1        小红   20
2  magician  122

进程已结束，退出代码为 0

五 Pandas案例（以后补充，方便巩固理解）

1.python数据分析Pandas案例之股票分析

Magician_liu
关注
  • 20
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
pandas基础知识详解
bigfatbean
09-04 1307
pandas基础 首先导入库，别名 pandas有两种数据结构: Series 和 DataFrame 那么怎么生成一个序列？要生成一个序列，使用的是pd.Series。记得Series首字母大写，如果要生成缺失值，可以用np.nan生成NaN值 也可以生成一组日期数据，用的是pd.date_range()，periods表示要生成日期的个数 那么如何生成一个DataFram...
Numpy,pandas,Matplotlib三剑问鼎python数据分析
qq_44176343的博客
08-30 932
python之如此强大，是因为他的很多工具包，例如数据分析中就涉及三个主要的包，NumPy和pandas和Matplotlib库，其中NumPy和pandas主要就是处理一维以及二维数据，Matplotlib则是数据可视化的利器。 一 , NumPy库和数组 import numpy as np a = [1,2,3,4] #创建列表a b = np.array([1,2,3,4])#创建数组 print(a) print(b) print(type(a))#打印出数据类型 print(type(b))
数据分析三剑客之Numpy(持续更新中...)
Magician_liu的博客
07-16 848
数据分析三剑客之Numpy，优点在于数值的处理，其它类型的数据交给Pandas处理！
Python 数据分析三剑客之 Pandas（九）：时间序列
BOB'S BLOG
06-25 4581
CSDN 课程推荐：《迈向数据科学家：带你玩转Python数据分析》，讲师齐伟，苏州研途教育科技有限公司CTO，苏州大学应用统计专业硕士生指导委员会委员；已出版《跟老齐学Python：轻松入门》《跟老齐学Python：Django实战》、《跟老齐学Python：数据分析》和《Python大学实用教程》畅销图书。 Pandas 系列文章（正在更新中…）： Python 数据分析三剑客之...
python数据分析Pandas案例之股票分析
Magician_liu的博客
07-18 1091
个人笔记之股票分析案例用来巩固完善pandas知识点，查缺补漏，还介绍了均线和金叉死叉等股票概念知识，并锻炼了用python进行一定的数据处理和数据分析的能力。
数据分析之Pandas高级操作
Magician_liu的博客
07-27 638
进一步完善了Pandas的基础操作知识，认识到了Pandas对数据处理能力的强大之处！
Python数据分析三剑客：Pandas、Matplotlib与Seaborn
xx16755498979的博客
11-14 90
Python具有强大的数据分析和处理能力，使用Python做数据分析需掌握这三个Python包，掌握Python数据分析知识，可帮助我们更好地发现数据背后的规律和趋势，为业务决策提供支持。
Python数据分析之潘大师（Pandas）入门
别看我只是一只羊
02-14 1354
目录一、Numpy 介绍二、NumPy 的应用学习链接三、Numpy 中的 Ndarray对象1、ndarray 的内部结构2、创建ndarray对象：四、NumPy 数据类型**数据类型对象（dtype）**创建 dtype 对象        数据分析,作为大数据时下比较火的行业，想要转行从事相关工作的人很多很多，那么在工作...
Pandas是什么?丨Python数据分析基础(1)
阿星的Python技术分享博客
05-26 222
今天开始，阿星带大家学习Python数据分析，首先是Pandas基础部分🏆如果觉得博主的文章还不错，请点赞👍+收藏⭐️+留言📝支持一下哦🤞
Python数据分析实践：pandas读写文件new.pdf
06-14
读取.csv文件，可以使用`pandas.read_csv()`函数，例如： ```python df = pd.read_csv('file_path.csv') ``` 同样，写入.csv文件可以使用`DataFrame.to_csv()`方法，如下所示： ```python df.to_csv('output_file....
Python数据分析必备-Pandas库汉化手册.docx
10-30
Pandas是Python中用于数据分析的核心库，它提供了大量高效的数据结构，如DataFrame和Series，以及强大的数据操作和清洗功能。本手册旨在为中文用户详细解读Pandas库的各种对象、函数和方法，帮助用户更好地理解和...
Python数据分析三部曲Pandas篇.pdf
10-27
总之，Pandas库是Python数据分析的核心工具之一，它提供了丰富的数据操作和分析功能，包括数据的导入导出、清洗、转换、聚合等，极大地提高了数据科学家和分析师的工作效率。通过正确的安装和基本的操作，用户可以...
Python数据分析实践：pandas数据结构new.pdf
06-14
创建Series时，可以通过`pandas.Series(data, index)`指定数据和索引，还可以设置名称和数据类型。 2. **DataFrame**： - DataFrame是二维表格型数据结构，类似于电子表格或SQL表。它由多个Series组成，每个Series...
pandas超市数据分析.rar
07-09
在本项目"pandas超市数据分析.rar"中，我们将深入探讨如何使用Python的pandas库进行数据处理和分析，尤其适用于小型超市的数据集。这个实战项目旨在帮助你掌握pandas的关键功能，以便你能有效地理解并解释实际业务...
大模型微调工具-torchtune
weixin_40777649的博客
08-08 722
1.定义2.安装3. 案例。
jupyter下载
Einstein·Jun
08-06 672
Anaconda下载 参考链接：https://blog.csdn.net/qq_48372575/article/details/125630622 设置Jupyter Notebook的代码路径 在“此电脑”中搜索。删除最后一个""后面的的内容，包括“\”。 用记事本打开它。 按下ctrl+F就可以开始查找。查找内容如下： 找到之后，右键该文件，找到“发送到”，找到“桌面快捷方式”。然后就会发现桌面上已经建立好了！
Python 算法交易实验80 QTV200日常推进-目标估算
最新发布
yukai08008的博客
08-10 321
业务目标在先，月利3%是第一个目标。虽然日常有在常规推进，但目标是什么？现在做的是什么？与目标的关联是什么？业务上讲，如果月利能够达到3%(几何平均)，上下波动不超过1%，就算达标了(2%~4%)。考虑到金融领域有不可测风险，所以资金还会分摊到3个月。例如，假如总投资资金是30万，那么每个月的最大投资金额是10万。这样即使遇到大跳水，问题也不大。目标达到的话，10万本金每月的盈利是3000， 按复利计,24个月就会double，我觉得已经足够理想。假设投资90万，则可以按30万计算复利效果。
NVIDIA-CUDA
qq_41081716的博客
08-08 399
CUDA 是一种强大的并行计算平台，它极大地扩展了 GPU 的用途，使其不仅仅局限于图形处理。通过利用 CUDA，开发人员可以编写高效、高性能的并行应用程序，这些应用程序可以用于各种计算密集型任务。如果您正在从事高性能计算或需要加速计算任务的工作，CUDA 是一个非常有用的工具。
Pandas 0.23.3 更新亮点：数据分析工具包
Pandas是Python数据科学领域中不可或缺的一部分，它提供了一系列高效的数据结构，如DataFrame和Series，用于处理和分析数据。此工具包在不断进化以满足日益复杂的数据处理需求。通过版本更新，Pandas致力于提高数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值