Python表结构对象

在Python中Dataframe对象就是我们熟知的表结构对象，它具备构成表的基本元素：字段和记录。

本文主要介绍了Dataframe表及其Series字段的定义、常用属性和常用方法。

1、Dataframe表的创建

Dataframe表通过pd.Dataframe()方法创建。

pd.DataFrame(data, index, columns)

• data作为值，可以是二维数组、多维列表、多维元组、字典（键值必须是可迭代对象）
• index作为行索引
• columns作为列索引
• dtype用于设置数据类型

# 全部行输出
from IPython.core.interactiveshell import InteractiveShell

InteractiveShell.ast_node_interactivity = "all"

# 导入包
import numpy as np
import pandas as pd

# 使用二维数组创建Dataframe表
arr = np.zeros((3, 3))
tb_arr = pd.DataFrame(data=arr, columns=['a', 'b', 'c'])
print(tb_arr)

     a    b    c
0  0.0  0.0  0.0
1  0.0  0.0  0.0
2  0.0  0.0  0.0

# 使用二维列表创建Dataframe表
li = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
tb_li = pd.DataFrame(data=li, columns=['a', 'b', 'c'])
print(tb_li)

   a  b  c
0  1  2  3
1  4  5  6
2  7  8  9

# 使用二维元组创建Dataframe表
tup = ((1, 2, 3), (4, 5, 6), (7, 8, 9))
tb_tup = pd.DataFrame(data=tup, columns=['a', 'b', 'c'], dtype=int)
print(tb_tup)
print(tb_tup.dtypes)

   a  b  c
0  1  2  3
1  4  5  6
2  7  8  9
a    int32
b    int32
c    int32
dtype: object

# 使用字典创建Dataframe表
dic = {'a': (1, 2, 3), 'b': (4, 5, 6), 'c': (7, 8, 9)}
tb_dic = pd.DataFrame(data=dic, index=['index1', 'index2', 'index3'], dtype=str)
print(tb_dic)
print(tb_dic.dtypes)

        a  b  c
index1  1  4  7
index2  2  5  8
index3  3  6  9
a    object
b    object
c    object
dtype: object

为什么三维数组不能生成Dataframe，但三维列表却可以？

三维列表（即列表的列表的列表）在Python中可以被视为一种嵌套的数据结构，其中每个内部列表都可以被看作是一个独立的序列（即一维数组）。
当你将三维列表转换为pandas DataFrame时，实际上你是在将这些内部列表（即二维列表）作为DataFrame的行或列来处理。

pandas的DataFrame构造函数可以接受一个嵌套的列表（或类似的可迭代对象），并尝试将这些内部列表转换为DataFrame的列。

值得注意的是，三维列表和三维数组在结构上有所不同。三维数组（如NumPy数组）是连续的内存块，其中的元素按照固定的步长排列，
而三维列表则是由嵌套的Python列表组成，每个内部列表都是独立的对象，可能存储在内存的不同位置。由于这种结构上的差异，
它们与pandas DataFrame的交互方式也会有所不同。NumPy数组提供了更高效的数值计算功能，而列表则提供了更灵活的数据结构。

2、Dataframe表的字段：Series对象

Dataframe表的字段是Python中的Series对象

Series是一种类似于一维数组的对象，是由一组数据(各种NumPy数据类型)以及一组与之相关的数据标签(即索引)组成。仅由一组数据也可产生简单的Series对象。
Series是Pandas包提供的一种Key-value型数据结构,其中Key为用户定义的显示index,每个显式index对应一个value值.

它与Python列表的区别在于,Series的每个元素都带有两种index

• 显示index : 由用户指定
• 隐式index : 由系统自动分配(Series对象中每个元素的下标,类似Python”列表”的下标)

Series的访问既可以通过显示index,也可以通过隐式index,

在数据分析和数据科学项目中,一般用显式索引(index),而不是隐式下标,原因在于:当数据量很大时,很难准确定义其下标

2.1、Series对象的创建

Series对象通过pd.Series()创建

pd.Series(data, index, dtype, name)

• data可以是ndarray对象，列表，元组，字典等，其中字典的键直接作为显示索引
• index用于设置显示索引
• dtype用于设置数据类型
• name用于设置Series的名称

# 表字段对象类型
print(type(tb_dic['a']))

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

# 使用列表创建Series对象
ser = pd.Series(data=[80, 90, 70], index=['语文', '数学', '英语'], name='分数', dtype='int64')
print(ser)

语文    80
数学    90
英语    70
Name: 分数, dtype: int64

# 使用字典创建Series对象
dic = {'a': 123, 'b': 456, 'c': '789'}
ser_dic = pd.Series(dic, name="用字典创建")  # 把字典的键作为显示索引
print(ser_dic)

a    123
b    456
c    789
Name: 用字典创建, dtype: object

2.2、Series对象的常用属性

• ser.name：字段名
• ser.dtype：字段类型
• ser.size：字段大小
• ser.index：字段索引
• ser.values：字段值
• ser.is_unique：字段值是否唯一

ser = pd.Series(data=[80, 90, 70], index=['语文', '数学', '英语'], name='分数', dtype='int64')
print(ser.name)
print(ser.dtype)
print(ser.size)
print(ser.index)
print(ser.values)
print(ser.is_unique)

分数
int64
3
Index(['语文', '数学', '英语'], dtype='object')
[80 90 70]
True

2.3、Series对象的常用方法

• 数据的增删改查
• 数据清洗：排序、筛选、去重、替换、缺失值处理
• 数据统计：计数和非重复计数、平均值、分位数、最大和最小值、标准差
• 数据重塑：列表展开（一行转多行）
• 自定义方法

2.31、数据的增删改查

• ser.drop()：默认axis=0，删除行
• ser.astype()：更改数据类型
• ser.loc[]：按标签查询，可新增行（列）赋值
• ser.iloc[]：按位置查询，不可新增行（列）赋值
• ser.head(n)：返回前n行，默认n=5
• ser.tail(n)：返回后n行，默认n=5

# 增加数据
ser = pd.Series(data=[80, 90, 70], index=['语文', '数学', '英语'], name='分数', dtype='int64')
ser.loc['地理'] = 55  # 显示索引赋值
print(ser)

语文    80
数学    90
英语    70
地理    55
Name: 分数, dtype: int64

【注意】
.iloc只能选取数据表里实际存在的行和列，不能选取不存在的行和列进行赋值。
如果你想要添加新的行或列，可能需要使用其他方法，如.loc。与.iloc不同，.loc可以选取不存在的行和列，赋值后就可以添加新行或者列。
因此，在使用.iloc进行赋值时，请确保你正在对已经存在的行和列进行操作。如果你需要添加新的行或列，可能需要先使用其他方法创建这些行或列，然后再使用.iloc进行赋值。

# 删除数据
ser = ser.drop('地理')
print(ser)

语文    80
数学    90
英语    70
Name: 分数, dtype: int64

# 更改数据
ser.loc['语文'] = 70
print(ser)
# 更改字段类型
ser = ser.astype('int32')
print(ser.dtypes)

语文    70
数学    90
英语    70
Name: 分数, dtype: int64
int32

# 查询数据：切片
print(ser.iloc[0:2])  # 隐式索引
print(ser.iloc[2])  # 隐式索引

print(ser.loc['语文':'英语'])  # 显示索引
print(ser.loc['语文'])  # 显示索引

语文    70
数学    90
Name: 分数, dtype: int32
70
语文    70
数学    90
英语    70
Name: 分数, dtype: int32
70

# 返回前2行
print(ser.head(2))
# 返回后2行
print(ser.tail(2))

语文    70
数学    90
Name: 分数, dtype: int32
数学    90
英语    70
Name: 分数, dtype: int32

2.32、数据清洗

1）排序

• ser.sort_index(ascending, inplace)
• ser.sort_values(ascending, inplace)

ascending默认为True, 即升序排列
inplace默认为False，即不替换原始数据

2）筛选

• ser.loc[条件表达式]

3）去重

• ser.unique()
• ser.nunique() 返回不重复元素的个数
• ser.drop_duplicates()

4）替换

• ser.replace()

5）缺失值处理

• ser.isna()
• ser.fill()
• ser.dropna()

# 排序
print(ser.sort_index())
print(ser.sort_values(ascending=False))  # 按分数降序

数学    90
英语    70
语文    70
Name: 分数, dtype: int32
数学    90
语文    70
英语    70
Name: 分数, dtype: int32

# 去重
print(ser)
print(ser.unique())  ## 去重
print(ser.drop_duplicates())  ## 去重
print(ser.nunique())  ## 非重复计数

语文    70
数学    90
英语    70
Name: 分数, dtype: int32
[70 90]
语文    70
数学    90
Name: 分数, dtype: int32
2

注意：

• ser.unique() 返回所有唯一值的数组，不修改原始 Series。
• ser.drop_duplicates() 返回一个新的 Series，其中删除了重复的值，并可以选择是否修改原始 Series。（推荐使用）

# 替换
print(ser.replace(90,91))

语文    70
数学    91
英语    70
Name: 分数, dtype: int32

# 筛选
print((ser.loc[(ser > 60) & (ser < 90)]))  # 大于60分且小于90分的数据

语文    70
英语    70
Name: 分数, dtype: int32

# 缺失值处理
ser['历史'] = np.nan
print(ser)
print(ser.isna())  # 判断是否有缺失值

语文    70.0
数学    90.0
英语    70.0
历史     NaN
Name: 分数, dtype: float64
语文    False
数学    False
英语    False
历史     True
Name: 分数, dtype: bool

print(ser.fillna(0))  # 填充缺失值

语文    70.0
数学    90.0
英语    70.0
历史     0.0
Name: 分数, dtype: float64

print(ser.dropna())  # 删除缺失值

语文    70.0
数学    90.0
英语    70.0
Name: 分数, dtype: float64

2.33、数据统计

1）统计描述

• ser.describe()

2）计数和非重复计数

• ser.count()：计数
• ser.nunique()：非重复计数
• ser.value_counts()：分类计数

3）平均值

• ser.mean()

4）分位数

• ser.median()
• ser.quantile()

5）最大和最小值

• ser.max()

6）标准差

• ser.std()

# 定义分类型变量
ser = pd.Series(['A', 'A', 'B', 'C'])
print(ser)
# 基本信息概述
print(ser.info())

0    A
1    A
2    B
3    C
dtype: object
<class 'pandas.core.series.Series'>
RangeIndex: 4 entries, 0 to 3
Series name: None
Non-Null Count  Dtype 
--------------  ----- 
4 non-null      object
dtypes: object(1)
memory usage: 164.0+ bytes
None

# 统计描述
print(ser.describe())
# 计数
print(ser.count())
# 非重复计数
print(ser.nunique())
# 分类计数
print(ser.value_counts())

count     4
unique    3
top       A
freq      2
dtype: object
4
3
A    2
B    1
C    1
Name: count, dtype: int64

# 定义数值型变量
ser = pd.Series(range(5))
print(ser)
print(ser.describe())   # 统计描述

0    0
1    1
2    2
3    3
4    4
dtype: int64
count    5.000000
mean     2.000000
std      1.581139
min      0.000000
25%      1.000000
50%      2.000000
75%      3.000000
max      4.000000
dtype: float64

print(ser.mean())       # 平均数
print(ser.median())     # 中位数
print(ser.quantile(0.5))    # 分位数
print(ser.max())   # 最大值 
print(ser.min())    # 最小值
print(ser.std())  # 标准差

2.0
2.0
2.0
4
0
1.5811388300841898

2.34、数据重塑

• ser.explore()：可将字段中的列表元素展开为多行

ser = pd.Series([1, 2, 3, [4, 5, 6]])
print(ser)
# 列表元素展开
print(ser.explode())

0            1
1            2
2            3
3    [4, 5, 6]
dtype: object
0    1
1    2
2    3
3    4
3    5
3    6
dtype: object

2.35、自定义方法

• ser.map(lambda x: 函数表达式)
• ser.apply(lambda x: 函数表达式)

ser = pd.Series([1, 2, 3])
print(ser.map(lambda x: x + 1))
print(ser.apply(lambda x: x + 1))

0    2
1    3
2    4
dtype: int64
0    2
1    3
2    4
dtype: int64

ser.map()和ser.apply()的区别

ser.map()
map() 方法用于将一个函数应用于Series中的每个元素。它主要用于将一组值映射到另一组值，通常用于分类变量的转换或简单的元素级操作。map() 方法通常接受一个字典或一个函数作为参数。

ser.apply()
apply() 方法也用于对Series中的每个元素应用一个函数，但它更加通用和灵活。apply() 方法可以接受任何可调用的对象（如函数、方法、Lambda表达式等），并且可以使用axis参数来指定操作是应用于Series的每个元素（axis=0，默认值）还是应用于整个Series（axis=1，这种情况对于Series并不常见，因为Series本身是一维的）。

区别总结

• 灵活性：apply() 方法更加灵活，可以接受任何可调用的对象，而 map() 通常只接受函数或字典。

• 性能：对于简单的映射操作，map() 通常比 apply() 更快，因为它针对这类操作进行了优化。然而，对于复杂的操作或需要更多控制的情况，apply() 提供了更大的灵活性。

• 用途：map() 更常用于简单的值映射，而 apply() 则更常用于更复杂的转换和计算。

3、Dataframe对象的常用属性

Dataframe的常用属性包括但不限于：

• values：返回Dataframe中的数值，即查看所有元素的值。
• dtypes：返回Dataframe中每一列元素的数据类型，用于查看所有元素的类型。
• index：返回Dataframe中的索引，即查看所有行名，同时也可以用于重命名行名。
• columns：返回Dataframe中的列索引，即查看所有列名，同样可以用于重命名列名。
• T：返回Dataframe的转置结果，即行列数据转换。
• shape：返回Dataframe的形状，即查看行数和列数，shape[0]表示行数，shape[1]表示列数。
• size：返回Dataframe中元素的个数。

这些属性在数据处理和分析过程中非常常用，可以帮助用户更好地理解和操作Dataframe数据。

# 全部行输出
from IPython.core.interactiveshell import InteractiveShell

InteractiveShell.ast_node_interactivity = "all"

# 导入包
import numpy as np
import pandas as pd

# 定义Dataframe表
li = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
tb = pd.DataFrame(data=li, columns=['a', 'b', 'c'])
print(tb)

   a  b  c
0  1  2  3
1  4  5  6
2  7  8  9

print(tb.values)  # 表数据
print(tb.dtypes)  # 各字段数据类型
print(tb.index)  # 表的行索引
print(tb.columns)  # 表的列索引（字段名）

[[1 2 3]
 [4 5 6]
 [7 8 9]]
a    int64
b    int64
c    int64
dtype: object
RangeIndex(start=0, stop=3, step=1)
Index(['a', 'b', 'c'], dtype='object')

print(tb.T)  # 转置
print(tb.shape)  # 表的形状（n,m)
print(tb.size)  # 表的大小（元素总个数 n*m）

   0  1  2
a  1  4  7
b  2  5  8
c  3  6  9
(3, 3)
9

4、Dataframe对象的常用方法

• 数据的增删改查
• 数据清洗：排序、筛选、去重、替换、缺失值处理
• 数据统计：计数和非重复计数、平均值、分位数、最大和最小值、标准差
• 数据重塑：列表展开（一行转多行）
• 自定义方法

4.1、数据的增删改查

• tb.insert()：新增指定位置的列数据
• tb.drop()：默认axis=0，删除行
• tb.astype()：更改数据类型
• tb.loc[]：按标签查询，可新增行（列）赋值
• tb.iloc[]：按位置查询，不可新增行（列）赋值
• tb.head(n)：返回前n行，默认n=5
• tb.tail(n)：返回后n行，默认n=5

# 定义Dataframe表
li = [[1, 2, 3], [4, 5, 6], [4, 5, 6]]
tb = pd.DataFrame(data=li, columns=['a', 'b', 'c'])
print(tb)

   a  b  c
0  1  2  3
1  4  5  6
2  4  5  6

# 新增行数据
tb.loc[3] = [0, 0, 0]
print(tb)
# 新增列数据
tb.loc[:, 'd'] = [11, 11, 11, 11]  # .loc赋值
tb.insert(2, 'new', [22, 22, 22, 22])  # 指定位置新增
print(tb)

   a  b  c
0  1  2  3
1  4  5  6
2  4  5  6
3  0  0  0
   a  b  new  c   d
0  1  2   22  3  11
1  4  5   22  6  11
2  4  5   22  6  11
3  0  0   22  0  11

【注意】
.iloc只能选取数据表里实际存在的行和列，不能选取不存在的行和列进行赋值。
如果你想要添加新的行或列，可能需要使用其他方法，如.loc。与.iloc不同，.loc可以选取不存在的行和列，赋值后就可以添加新行或者列。
因此，在使用.iloc进行赋值时，请确保你正在对已经存在的行和列进行操作。如果你需要添加新的行或列，可能需要先使用其他方法创建这些行或列，然后再使用.iloc进行赋值。

# 删除行数据
tb = tb.drop(index=[3])
print(tb)
# 删除列数据
tb = tb.drop(columns=['new'])
print(tb)

   a  b  new  c   d
0  1  2   22  3  11
1  4  5   22  6  11
2  4  5   22  6  11
   a  b  c   d
0  1  2  3  11
1  4  5  6  11
2  4  5  6  11

# 更改数据
tb.loc[0, 'a'] = 70
print(tb)
# 更改字段类型
tb = tb.astype('int32')
print(tb.dtypes)

    a  b  c   d
0  70  2  3  11
1   4  5  6  11
2   4  5  6  11
a    int32
b    int32
c    int32
d    int32
dtype: object

# 查询数据：切片
print(tb.iloc[0:2, 0:2])  # 隐式索引，不含尾部索引
print(tb.iloc[1, 1])  # 隐式索引

print(tb.loc[0:2, 'a':'c'])  # 显示索引，包含尾部索引
print(tb.loc[0, 'a'])  # 显示索引

    a  b
0  70  2
1   4  5
5
    a  b  c
0  70  2  3
1   4  5  6
2   4  5  6
70

# 返回前2行
print(tb.head(2))
# 返回后2行
print(tb.tail(2))

    a  b  c   d
0  70  2  3  11
1   4  5  6  11
   a  b  c   d
1  4  5  6  11
2  4  5  6  11

4.2、数据清洗

1）排序

• tb.sort_index(ascending, inplace)
• tb.sort_values(ascending, inplace)

ascending默认为True, 即升序排列
inplace默认为False，即不替换原始数据

2）筛选

• tb.loc[条件表达式]

3）去重

• tb.drop_duplicates()
• tb.nunique()

4）替换

• tb.replace()

5）缺失值处理

• tb.isna()
• tb.fillna()
• tb.dropna()

注意：Dataframe没有.unique()

# 排序
print(tb.sort_index())

print(tb.sort_values(by='a', ascending=False))  # 按分数降序

    a  b  c   d
0  70  2  3  11
1   4  5  6  11
2   4  5  6  11
    a  b  c   d
0  70  2  3  11
1   4  5  6  11
2   4  5  6  11

# 去重（删除重复行）
print(tb.drop_duplicates())
print(tb.nunique())   ## 非重复计数

    a  b  c   d
0  70  2  3  11
1   4  5  6  11
a    2
b    2
c    2
d    1
dtype: int64

# 替换
print(tb.replace(11, 12))

    a  b  c   d
0  70  2  3  12
1   4  5  6  12
2   4  5  6  12

# 筛选
print((tb.loc[(tb.a < 60) & (tb.b <= 5)]))

   a  b  c   d
1  4  5  6  11
2  4  5  6  11

# 缺失值处理
tb.iloc[1, 1] = np.nan
print(tb)
print(tb.isna())  # 判断是否有缺失值

    a    b  c   d
0  70  2.0  3  11
1   4  NaN  6  11
2   4  5.0  6  11
       a      b      c      d
0  False  False  False  False
1  False   True  False  False
2  False  False  False  False

print(tb.fillna(0))  # 填充缺失值

    a    b  c   d
0  70  2.0  3  11
1   4  0.0  6  11
2   4  5.0  6  11

print(tb.dropna())  # 删除缺失值

    a    b  c   d
0  70  2.0  3  11
2   4  5.0  6  11

4.3、数据统计

1）统计描述

• tb.describe()

2）计数和非重复计数

• tb.count()：计数
• tb.nunique()：非重复计数
• tb.value_counts()：分类计数

3）平均值

• ser.mean()

4）分位数

• ser.median()
• ser.quantile()

5）最大和最小值

• tb.max()
• tb.min()
• tb.cummax()
• tb.cummin()

6）标准差

• ser.std()

7）求和

• ser.sum()
• tb.cumsum()

# 基本信息概述
print(tb.info())

<class 'pandas.core.frame.DataFrame'>
Index: 3 entries, 0 to 2
Data columns (total 4 columns):
 #   Column  Non-Null Count  Dtype  
---  ------  --------------  -----  
 0   a       3 non-null      int32  
 1   b       2 non-null      float64
 2   c       3 non-null      int32  
 3   d       3 non-null      int32  
dtypes: float64(1), int32(3)
memory usage: 192.0 bytes
None

# 统计描述
print(tb.describe())

               a        b         c     d
count   3.000000  2.00000  3.000000   3.0
mean   26.000000  3.50000  5.000000  11.0
std    38.105118  2.12132  1.732051   0.0
min     4.000000  2.00000  3.000000  11.0
25%     4.000000  2.75000  4.500000  11.0
50%     4.000000  3.50000  6.000000  11.0
75%    37.000000  4.25000  6.000000  11.0
max    70.000000  5.00000  6.000000  11.0

# 计数
print(tb.count())  # axis默认为0
print(tb.count(axis=1))  # 对行计数
print(tb.nunique())  # 非重复计数
# 分类计数
print(tb.value_counts())

a    3
b    2
c    3
d    3
dtype: int64
0    4
1    3
2    4
dtype: int64
a    2
b    2
c    2
d    1
dtype: int64
a   b    c  d 
4   5.0  6  11    1
70  2.0  3  11    1
Name: count, dtype: int64

# 平均数
print(tb.mean())
# 中位数
print(tb.median())
# 分位数
print(tb.quantile(0.5))

a    26.0
b     3.5
c     5.0
d    11.0
dtype: float64
a     4.0
b     3.5
c     6.0
d    11.0
dtype: float64
a     4.0
b     3.5
c     6.0
d    11.0
Name: 0.5, dtype: float64

# 最大值
print(tb.max())
# 最小值
print(tb.min())
# 标准差
print(tb.std())

a    70.0
b     5.0
c     6.0
d    11.0
dtype: float64
a     4.0
b     2.0
c     3.0
d    11.0
dtype: float64
a    38.105118
b     2.121320
c     1.732051
d     0.000000
dtype: float64

print(tb)
print(tb.sum())  # 求和
print(tb.cumsum())  # 累计求和

    a    b  c   d
0  70  2.0  3  11
1   4  NaN  6  11
2   4  5.0  6  11
a    78.0
b     7.0
c    15.0
d    33.0
dtype: float64
    a    b   c   d
0  70  2.0   3  11
1  74  NaN   9  22
2  78  7.0  15  33

4.4、数据重塑

• tb.explore()：可将字段中的列表元素展开为多行

注意：Dataframe没有.map()

tb.loc[:, 'new'] = [1, 2, [0, 0, 0]]
print(tb)
# 列表元素展开
print(tb.explode(column=['new']).reset_index(drop=True))
tb = tb.drop(columns=['new'])

    a    b  c   d        new
0  70  2.0  3  11          1
1   4  NaN  6  11          2
2   4  5.0  6  11  [0, 0, 0]
    a    b  c   d new
0  70  2.0  3  11   1
1   4  NaN  6  11   2
2   4  5.0  6  11   0
3   4  5.0  6  11   0
4   4  5.0  6  11   0

4.5、自定义方法

• tb.apply(lambda x: 函数表达式)

print(tb.apply(lambda x: sum(x)))  # axis默认为0，对列处理
print(tb.apply(lambda x: sum(x), axis=1))  # 对行求和

a    78.0
b     NaN
c    15.0
d    33.0
dtype: float64
0    86.0
1     NaN
2    26.0
dtype: float64

打赏