Pandas基础入门（Python三大库系列之pandas篇）

python三大库之—pandas（一）

文章目录

python三大库之—pandas（一）

一、概述

二，安装

三，内置数据结构

四，Series

4.1创建 Series 对象的方式

4.1.1创建 Series 空对象

4.1.2ndarray(多维数组) 创建 Series 对象

4.1.3 字典创建 Series 对象

4.2访问 Series 数据

4.3 Series遍历

4.4 Series 常用方法

五，DataFrame

5.1 创建 DataFrame 对象

5.1.1 创建 DataFrame 空对象

5.1.2 列表嵌套字典创建 DataFrame 对象

5.1.3 字典嵌套列表创建 DataFrame 对象

5.1.4 Series 创建 DataFrame 对象

5.2 列索引操作

5.2.1选取数据

5.2.2 添加数据

5.2.3修改数据

5.2.4删除数据

5.3行索引操作

5.3.1 loc 选取数据

5.3.2 iloc 选取数据

5.3.3 切片多行选取

5.3.4添加数据行

5.3.5 删除数据行

---

一、概述

Pandas 是一个开源的第三方 Python 库，从 Numpy 和 Matplotlib 的基础上构建而来

Pandas 是 Python 语言的一个扩展程序库，用于数据分析

Pandas 一个强大的分析结构化数据的工具集，基础是 Numpy（提供高性能的矩阵运算）

Pandas 可以从各种文件格式比如 CSV、JSON、SQL、Microsoft Excel 导入数据

Pandas 可以对各种数据进行运算操作，比如归并、再成形、选择，还有数据清洗和数据加工特征

Pandas 广泛应用在学术、金融、统计学等各个数据分析领域

Pandas 的出现使得 Python 做数据分析的能力得到了大幅度提升，它主要实现了数据分析的五个重要环节：加载数据、整理数据、操作数据、构建数据模型、分析数据

二，安装

pip install pandas

使用清华园镜像

pip install pandas -i https://pypi.tuna.tsinghua.edu.cn/simple/

三，内置数据结构

Pandas 在 ndarray 数组（NumPy 中的数组）的基础上构建出了两种不同的数据结构，分别是 Series（一维数据结构）、DataFrame（二维数据结构）：

Series 是带标签的一维数组，这里的标签可以理解为索引，但这个索引并不局限于整数，它也可以是字符类型，比如 a、b、c 等

DataFrame 是一种表格型数据结构，它既有行标签，又有列标签

数据结构	维度	说明
Series	1	该结构能够存储各种数据类型，比如字符数、整数、浮点数、Python 对象等，Series 用 name 和 index 属性来描述数据值。Series 是一维数据结构，因此其维数不可以改变
DataFrame	2	DataFrame 是一种二维表格型数据的结构，既有行索引，也有列索引。行索引是 index，列索引是 columns。 在创建该结构时，可以指定相应的索引值

从图中可见，

整个表是一个DataFrame，

一行或者一列为一个Series，

如果没有行标签的话，使用默认行标签0，1，2，3

列的Series的标签是DataFrame的行标签，行的Series标签是DataFrame的列标签

图中0，1，2为默行标签，小明，小王，小李为列标签

四，Series

Pandas Series 类似表格中等一个列（column），类似于一维数组，可以保存任何数据类型 Series 由索引（index）和列组成，函数：

函数名	参数
pandas.Series(data,index,dtype)	data：一组数据（ndarray 类型） index：索引标签 dtype：数据类型 copy：表示对 data 进行拷贝，默认为 False

#创建Series对象
def one():
    series_one = pd.Series([1,2,3],index=['a','b','c'],dtype='int64')
    print(series_one)
one()

a    1
b    2
c    3
dtype: int64

a，b，c是行索引

1，2，3是数据

dtype是数据类型

4.1创建 Series 对象的方式

4.1.1创建 Series 空对象

#创建Series空对象
def two():
    series_two = pd.Series()
    print(series_two)
two()

Series([], dtype: object)

4.1.2ndarray(多维数组) 创建 Series 对象

#列表创建
s= pd.Series(np.array([1,2,3,4]),dtype='float64')
print(s)

0    1.0
1    2.0
2    3.0
3    4.0
dtype: float64

4.1.3 字典创建 Series 对象

#字典创建，字典中的key是索引，value是值
dic = {'a':1,'b':2,'c':3,'d':4}
s= pd.Series(dic)
print(s)

a    1
b    2
c    3
d    4
dtype: int64

4.2访问 Series 数据

#访问Sieries元素
s=pd.Series([1,2,3,4,5,6])
print(s[3])
print (s[2:5])
s=pd.Series([1,2,3,4,5,6],index=['a','b','c','d','e','f'])
print(s)
print(s['f'])
print(s['a':'d'])

4
2    3
3    4
4    5
dtype: int64
a    1
b    2
c    3
d    4
e    5
f    6
dtype: int64
6
a    1
b    2
c    3
d    4
dtype: int64

4.3 Series遍历

使用index()方法遍历

#使用index()方法遍历
s= pd.Series([1,2,3,4],index=['a','b','c','d'])
#index获取标签
for i in s.index:
    print(i,s[i])

a 1
b 2
c 3
d 4

使用items()方法

#使用items()方法
s= pd.Series([1,2,3,4],index=['a','b','c','d'])
for i,j in s.items():
    print(i,j)

a 1
b 2
c 3
d 4

使用values()方法

#使用values()方法
s=pd.Series([1,2,3,4],index=['a','b','c','d'])
for i in s.values:
    print(i)

1
2
3
4

4.4 Series 常用方法

isnull() 和 notnull() 用于检测 Series、DataFrame 中的缺失值。所谓缺失值，顾名思义就是值不存在、丢失、缺少

isnull()：如果为值不存在或者缺失，则返回 True

notnull()：如果值不存在或者缺失，则返回 False

def eight():
    result = pd.Series(['a','b','c','d','e','f',None])
    print("isnull()如果为值不存在或者缺失，则返回 True：")
    print(result.isnull())
    print("notnull()如果值不存在或者缺失，则返回 False：")
    print(result.notnull())
    #过滤掉缺失值
    print(result[result.notnull()])
eight()

isnull()如果为值不存在或者缺失，则返回 True：
0    False
1    False
2    False
3    False
4    False
5    False
6     True
dtype: bool
notnull()如果值不存在或者缺失，则返回 False：
0     True
1     True
2     True
3     True
4     True
5     True
6    False
dtype: bool
0    a
1    b
2    c
3    d
4    e
5    f
dtype: object

五，DataFrame

DataFrame 一个表格型的数据结构，既有行标签（index），又有列标签（columns），它也被称异构数据表，所谓异构，指的是表格中每列的数据类型可以不同，比如可以是字符串、整型或者浮点型等。

DataFrame 的每一行或列数据都可以看成一个 Series 结构，只不过，DataFrame 为这些行中每个数据值增加了一个列或行标签

同 Series 一样，DataFrame 自带行标签索引，默认为“隐式索引”即从 0 开始依次递增，行标签与 DataFrame 中的数据项一一对应当然你也可以用“显式索引”的方式来设置行标签

DataFrame 构造方法：

函数名	参数
pd.DataFrame( data, index, columns, dtype, copy)	data：一组数据 index：行标签 columns：列标签 dtype：数据类型 copy：默认为 False，表示复制数据 data

5.1 创建 DataFrame 对象

创建 DataFrame 对象的方式：

列表

字典

Series

Numpy ndarrays

另一个 DataFrame

5.1.1 创建 DataFrame 空对象

#dataframe
s=pd.DataFrame({})
print(s)

Empty DataFrame
Columns: []
Index: []

5.1.2 列表嵌套字典创建 DataFrame 对象

#列表嵌套字典创建dataframe
#如果字典中有不同的键值对，则创建并集
s=pd.DataFrame([{'name':'a','age':1},{'name':'b','age':2},{'name':'c','age':3}])
print(s)

  name  age
0    a    1
1    b    2
2    c    3

5.1.3 字典嵌套列表创建 DataFrame 对象

#字典嵌套列表创建dataframe
s=pd.DataFrame({'name':['a','b','c','d'],'age':[1,2,3,4]})
print(s)

  name  age
0    a    1
1    b    2
2    c    3
3    d    4

5.1.4 Series 创建 DataFrame 对象

#series嵌套dataframe
def nine():
    s={
        'name':pd.Series([1,2,3,4,5,6],index=['a','b','c','d','e','f']),                                                                                                                                                                                                                                                                                                          
        'age':pd.Series([1,2,3,4],index=['a','b','c','d'])
        }
    a=pd.DataFrame(s)
    print(a)
nine()

   name  age
a     1  1.0
b     2  2.0
c     3  3.0
d     4  4.0
e     5  NaN
f     6  NaN

5.2 列索引操作

5.2.1选取数据

dic = {'name':['a','b','c','d'],'age':[1,2,3,4],'money':[1,2,3,4]}
df = pd.DataFrame(dic)
print(df['money'])

#取多列返回DataFrame
print(df[['name', 'age']])
#不能直接对列做切片操作,可以通过loc或iloc实现
#print(df['one':'three'])

0    1
1    2
2    3
3    4
Name: money, dtype: int64
  name  age
0    a    1
1    b    2
2    c    3
3    d    4

5.2.2 添加数据

添加一列空列

# 添加一个空列
data = {'name' : pd.Series(data=[1, 2, 3], index=['a', 'b', 'c']),
'age': pd.Series(data=[1, 2,3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(data)
df['zzz'] = None
print(df)

   name  age   zzz
a   1.0    1  None
b   2.0    2  None
c   3.0    3  None
d   NaN    4  None

添加新列，直接赋值添加

# 添加一个空列
data = {'name' : pd.Series(data=[1, 2, 3], index=['a', 'b', 'c']),
'age': pd.Series(data=[1, 2,3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(data)
# df['zzz'] = None
# print(df)
df['zzz'] = [10,20,30,40]
print(df),

   name  age  zzz
a   1.0    1   10
b   2.0    2   20
c   3.0    3   30
d   NaN    4   40

通过assign方法添加新列

# 通过assign()方法添加列
data = {'name' : pd.Series(data=[1, 2, 3], index=['a', 'b', 'c']),
        'age': pd.Series(data=[1, 2,3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(data)
df1 = df.assign(new_column=pd.Series([1, 2, 3, 4], index=df.index)).assign(new_column1=pd.Series([1, 2, 3, 4], index=df.index))
print(df1)

  name  age  new_column  new_column1
a   1.0    1           1            1
b   2.0    2           2            2
c   3.0    3           3            3
d   NaN    4           4            4

在指定的位置插入新列
使用insert方法在指定位置插入新列，参数：

loc: 插入位置的列索引。

column: 新列的名称。

value: 要插入的 Series。

#insert()方法,在指定位置插入一列
data = {
    "A":[ 1,2,3,4],
    "B":[ 1,2,3,4],
    "C":[ 1,2,3,4],
    "D":[ 1,2,3,4],
}
df = pd.DataFrame(data)
print(df)
df.insert(0,'new_column',pd.Series([1,2,3,4],index=df.index))
print(df)

   new_column  A  B  C  D
0           1  1  1  1  1
1           2  2  2  2  2
2           3  3  3  3  3
3           4  4  4  4  4

5.2.3修改数据

修改列的值

#修改数据
data = {
    "A":[ 1,2,3,4],
    "B":[ 1,2,3,4],
    "C":[ 1,2,3,4],
    "D":[ 1,2,3,4],
}
df = pd.DataFrame(data)

# 修改指定行指定列的值
df['B']=[10,20,30,40]
print(df)
df['B']=df['A']+20#广播
print(df)

   A   B  C  D
0  1  10  1  1
1  2  20  2  2
2  3  30  3  3
3  4  40  4  4
   A   B  C  D
0  1  21  1  1
1  2  22  2  2
2  3  23  3  3
3  4  24  4  4

修改列名

#修改数据
data = {
    "A":[ 1,2,3,4],
    "B":[ 1,2,3,4],
    "C":[ 1,2,3,4],
    "D":[ 1,2,3,4],
}
df = pd.DataFrame(data)

# 修改指定行指定列的值
# df['B']=[10,20,30,40]
# print(df)
# df['B']=df['A']+20#广播
# print(df)

#修改列名
#1.columns属性
df.columns = ['a','b','c','d']
print(df)

  a  b  c  d
0  1  1  1  1
1  2  2  2  2
2  3  3  3  3
3  4  4  4  4

使用 rename 方法修改列名

data = {
    "A":[ 1,2,3,4],
    "B":[ 1,2,3,4],
    "C":[ 1,2,3,4],
    "D":[ 1,2,3,4],
}
df = pd.DataFrame(data)
#2.rename()方法
df.rename(columns={'a':'E','b':'F','c':'G','d':'H'},inplace=True)
print(df)

A  B  C  D
0  1  1  1  1
1  2  2  2  2
2  3  3  3  3
3  4  4  4  4

修改列的数据类型

#修改数据类型，astype()
data = {
    "A":[ 1,2,3,4],
    "B":[ 1,2,3,4],
}

df = pd.DataFrame(data)
df['A']=df['A'].astype('float64')
df['B']=df['B'].astype('float64')
print(df)
print(df.dtypes)

   A    B
0  1.0  1.0
1  2.0  2.0
2  3.0  3.0
3  4.0  4.0
A    float64
B    float64
dtype: object

5.2.4删除数据

通过drop方法删除 DataFrame 中的数据，默认情况下，drop() 不会修改原 DataFrame，而是返回一个新的 DataFrame
参数：

1. labels：
2. 类型：单个标签或列表。
3. 描述：要删除的行或列的标签。如果 axis=0，则 labels 表示行标签；如果 axis=1，则 labels 表示列标签。
4. axis：
5. 类型：整数或字符串，默认为 0。
6. 描述：指定删除的方向。axis=0 或 axis=‘index’ 表示删除行，axis=1 或 axis=‘columns’ 表示删除列。
7. index：
8. 类型：单个标签或列表，默认为 None。
9. 描述：要删除的行的标签。如果指定，则忽略 labels 参数。
10. columns：
11. 类型：单个标签或列表，默认为 None。
12. 描述：要删除的列的标签。如果指定，则忽略 labels 参数。
13. level：
14. 类型：整数或级别名称，默认为 None。
15. 描述：用于多级索引（MultiIndex），指定要删除的级别。
16. inplace：
17. 类型：布尔值，默认为 False。
18. 描述：如果为 True，则直接修改原 DataFrame，而不是返回一个新的 DataFrame。
19. errors：
20. 类型：字符串，默认为 ‘raise’。
21. 描述：指定如何处理不存在的标签。‘raise’ 表示抛出错误，‘ignore’ 表示忽略错误。

drop()
labels：
axis:轴方向
index:行
columns:列
inplace:是否修改原数据

data= {
    "A":[ 1,2,3,4],
    "B":[ 6,7,8,9],
}
data = pd.DataFrame(data)
print(data)

#使用drop删除行和列
df1 = data.drop(['A'],axis=1)
print(df1)
df2= data.drop(columns=['A'])
print(df2)

   A  B
0  1  6
1  2  7
2  3  8
3  4  9
   B
0  6
1  7
2  8
3  9
   B
0  6
1  7
2  8
3  9

5.3行索引操作

5.3.1 loc 选取数据

df.loc[] 只能使用标签索引，不能使用整数索引。当通过标签索引的切片方式来筛选数据时，它的取值前闭后闭，也就是只包括边界值标签（开始和结束）

loc方法返回的数据类型：

1.如果选择单行或单列，返回的数据类型为Series

2.选择多行或多列，返回的数据类型为DataFrame

3.选择单个元素(某行某列对应的值)，返回的数据类型为该元素的原始数据类型（如整数、浮点数等）。

DataFrame.loc[row_indexer, column_indexer]

data = {
    'A': [1, 2, 3, 4],
    'B': [5, 6, 7, 8],
    'C': [9, 10, 11, 12]
}
df = pd.DataFrame(data, index=['a', 'b', 'c', 'd'])

#基于标签获取数据
# 使用 loc 选择数据
print(df.loc['a'])  # 选择行标签为 'a' 的行
print(df.loc['a':'c'])  # 选择行标签从 'a' 到 'c' 的行
print(df.loc['a', 'B'])  # 选择行标签为 'a'，列标签为 'B' 的元素
print(df.loc[['a', 'c'], ['A', 'C']])  # 选择行标签为 'a' 和 'c'，列标签为 'A' 和 'C' 的数据

A    1
B    5
C    9
Name: a, dtype: int64
   A  B   C
a  1  5   9
b  2  6  10
c  3  7  11
5
   A   C
a  1   9
c  3  11

5.3.2 iloc 选取数据

​ iloc 方法用于基于位置（integer-location based）的索引，即通过行和列的整数位置来选择数据。

# iloc基于索引获取数据
data = {
    'A': [1, 2, 3, 4],
    'B': [5, 6, 7, 8],
    'C': [9, 10, 11, 12]
}
df = pd.DataFrame(data, index=['a', 'b', 'c', 'd'])
print(df)

print(df.iloc[0])## 选择第 0 行的数据
print(df.iloc[0:2]) # 选择第 0 到 1 行的数据
print(df.iloc[0, 1])# 选择第 0 行，第 1 列的元素
print(df.iloc[[0, 2], [0, 2]])  # 选择第 0 和 2 行，第 0 和 2 列的数据

 A  B   C
a  1  5   9
b  2  6  10
c  3  7  11
d  4  8  12
A    1
B    5
C    9
Name: a, dtype: int64
   A  B   C
a  1  5   9
b  2  6  10
5
   A   C
a  1   9
c  3  11

5.3.3 切片多行选取

通过切片的方式进行多行数据的选取

#切片多行选取
data = {
    'A': [1, 2, 3, 4],
    'B': [5, 6, 7, 8],
    'C': [9, 10, 11, 12]
}
df = pd.DataFrame(data)
print(df[0:3])

A  B   C
0  1  5   9
1  2  6  10
2  3  7  11

5.3.4添加数据行

loc方法添加新行

#
data = {
    'A': [1, 2, 3, 4],
    'B': [5, 6, 7, 8],
    'C': [9, 10, 11, 12]
}
df = pd.DataFrame(data,index=['a','b','c','d'])
df.loc['e']=[13,14,15]
print(df)

 A   B   C
a   1   5   9
b   2   6  10
c   3   7  11
d   4   8  12
e  13  14  15

concat拼接

pd.concat(objs, axis=0, join='outer', ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, sort=False, copy=True)

参数：

objs: 要连接的 DataFrame 或 Series 对象的列表或字典。

axis: 指定连接的轴，0 或 ‘index’ 表示按行连接，1 或 ‘columns’ 表示按列连接。

join: 指定连接方式，‘outer’ 表示并集（默认），‘inner’ 表示交集。

ignore_index: 如果为 True，则忽略原始索引并生成新的索引。

keys: 用于在连接结果中创建层次化索引。

levels: 指定层次化索引的级别。

names: 指定层次化索引的名称。

verify_integrity: 如果为 True，则在连接时检查是否有重复索引。

sort: 如果为 True，则在连接时对列进行排序。

copy: 如果为 True，则复制数据。

#concat()：连接多个 DataFrame
data1 = {
    'A': [1, 2, 3, 4],
    'B': [5, 6, 7, 8],
    'C': [9, 10, 11, 12]
}
data2 = {
    'A': [13, 14, 15, 16],
    'B': [17, 18, 19, 20],
    'C': [21, 22, 23, 24]
}

result = pd.concat([pd.DataFrame(data1), pd.DataFrame(data2)], )
print(result)

#按列拼接
result = pd.concat([pd.DataFrame(data1), pd.DataFrame(data2)], axis=1, )
print(result)

 A   B   C
0   1   5   9
1   2   6  10
2   3   7  11
3   4   8  12
0  13  17  21
1  14  18  22
2  15  19  23
3  16  20  24
   A  B   C   A   B   C
0  1  5   9  13  17  21
1  2  6  10  14  18  22
2  3  7  11  15  19  23
3  4  8  12  16  20  24

使用 ignore_index

df1 = pd.DataFrame({
    'A': [1, 2, 3],
    'B': [4, 5, 6]
})

df2 = pd.DataFrame({
    'A': [7, 8, 9],
    'B': [10, 11, 12]
})

# 按行连接 df1 和 df2，并忽略原始索引
result = pd.concat([df1, df2], axis=0, ignore_index=True)

print(result)

 A   B
0  1   4
1  2   5
2  3   6
3  7  10
4  8  11
5  9  12

使用 join=‘inner’，按行合并

# 使用join='inner',按行合并
df1 = pd.DataFrame({
    'A': [1, 2, 3],
    'B': [4, 5, 6]
})

df2 = pd.DataFrame({
    'A': [7, 8, 9],
    'B': [10, 11, 12]
})

# 按行连接 df1 和df2，并忽略原始索引
result = pd.concat([df1, df2], axis=0, join='inner')
print(result)
#按行连接 df1 和 df2，并忽略原始索引
result = pd.concat([df1, df2], axis=1, join='outer')
print(result)

  A   B
0  1   4
1  2   5
2  3   6
0  7  10
1  8  11
2  9  12
   A  B  A   B
0  1  4  7  10
1  2  5  8  11
2  3  6  9  12

5.3.5 删除数据行

您可以使用行索引标签，从 DataFrame 中删除某一行数据。如果索引标签存在重复，那么它们将被一起删除。使用的是 drop 函数

#删除数据行
data = {
    'A': [1, 2, 3, 4],
    'B': [5, 6, 7, 8],
    'C': [9, 10, 11, 12]
}
df = pd.DataFrame(data)
print(df)
df.drop(0,inplace=True)
print(df)

   A  B   C
0  1  5   9
1  2  6  10
2  3  7  11
3  4  8  12
   A  B   C
1  2  6  10
2  3  7  11
3  4  8  12

作者：暴龙胡乱写博客