Python数据分析与程序设计(三)：Pandas库基础

前言

欢迎回到“Python数据分析与程序设计”系列博客。在上一篇文章中，我们探讨了NumPy库的实践应用，掌握了数据分析的基础技能;

在本篇博客中，我们将把目光转向另一个Python数据分析的核心库——Pandas。Pandas库提供了丰富的数据结构和函数，专门用于处理表格数据和时间序列。它使得数据的导入、清洗、探索、分析和导出变得前所未有的简单。

本文将介绍Pandas的基本数据结构，包括Series和DataFrame，以及如何使用Pandas进行数据的读取、筛选、排序和聚合。我们还会探讨如何使用Pandas进行数据清洗，包括处理缺失值、重复值和异常值。此外，我们还将学习如何使用Pandas进行数据的合并和连接，以及如何创建和使用数据透视表来进行复杂的数据汇总。

一、简介

在Python中，pandas是基于NumPy数组构建的，使数据预处理、清洗、分析工作变得更快更简单。

pandas是专门为处理表格和混杂数据设计的，而numpy更适合处理统一的数值数组数据。

使用 Pandas，我们可以完成数据处理和分析的五个典型步骤——加载、准备、操作、建模和分析。

二、相关数据结构

Pandas 主要处理以下两种数据结构 −

Series

DataFrame

# Panel   自 pandas 0.24.0 版本以来，它已被标记为过时（deprecated）

三种数据结构比较与联系

名称                维数                  介绍

Series                1             一维标记的同构数组，大小不可变。

Data Frames      2           具有潜在异构类型的通用 2D 标记、大小可变的表格结构 列。

Panel                  3           通用 3D 标记、大小可变的数组。

高维数据结构是其低维数据结构的容器。 比如DataFrame是Series的容器，Panel是DataFrame的容器。

构建和处理二维或更多维数组是一项繁琐的任务，用户在编写函数时需要考虑数据集的方向。 但是使用 Pandas 数据结构，减少了用户的脑力劳动。

相关性质

大小可变性

所有 Pandas 数据结构的值都是可变的（可以更改），除了 Series 之外，所有数据结构的大小都是可变的。 系列是大小不可变的。

系列(Series)的性质

系列是具有同质数据的一维数组结构。 例如，以下系列是整数 10、23、56、……的集合

要点：

• 同质数据
• 大小不可变  大小在创建后不能再更改。一旦创建了一个固定大小的数据结构，就无法在后续的操作中添加或删除元素来改变其大小。
• 可变数据的值

DataFrame的性质

DataFrame 是一个包含异构数据的二维数组

Name    Age Gender  Rating

Steve   32  Male    3.45

Lia     28  Female  4.6

Vin     45  Male    3.9

Katie   38  Female  2.78

数据以行和列的形式表示。 每列代表一个属性，每一行代表一个人。

要点：

• 异构数据
• 大小可变
• 数据可变

面板(Panel)的性质 了解即可

Panel 是一种具有异构数据的三维数据结构。 很难用图形表示面板。 但是面板可以说明为 DataFrame 的容器。

要点：

• 异构数据
• 大小可变
• 数据可变

三、Series 

一维标记数组，能够保存任何类型的数据（整数、字符串、浮点数、python 对象等）。 轴标签统称为索引。

1.创建series对象

# pandas.Series( data, index, dtype, copy)
# data为数据 index为索引 dtype 为数据类型
def series_test():
    s = pd.Series() # 创建一个空系列 => Series([], dtype: float64)
    print(s)
    data = np.array(['a','b','c','d'])
    print(data)
    s = pd.Series(data,index=[100,101,102,103]) # 标签 数据值 数据值类型
    print(s)

#  dict创建Series对象 : key值为标签 value为数据值
# 您可以把 dict 作为输入数据。如果没有传入索引时会按照字典的键来构造索引；反之，当传递了索引时需要将索引标签与字典中的值一一对应。
def series_test_01():
    data = {'a' : 0., 'b' : 1., 'c' : 2.}
    s = pd.Series(data)
    print(s)
    data = {'a' : 0., 'b' : 1., 'c' : 2.}
    s = pd.Series(data,index=['b','c','d','a'])
    print(s) # 当传递的索引值无法找到与其对应的值时，使用 NaN（非数字）填充。

# 在这个示例中，参数5被用作pd.Series构造函数的第一个参数，这个参数被用来创建一个Series对象，并且被称为标量值。标量值表示Series对象中的所有元素都将被设置为这个标量值。
# 标量创建Series对象
# 如果 data 是标量值，则必须提供索引，示例如下：
def series_test_02():
    s = pd.Series(5, index=[0, 1, 3, 2]) # index只是索引 并不在乎1234这种数理顺序
    print(s)

2.访问series数据

一种是位置索引访问；另一种是索引标签访问

def index_test():
    s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])
    # print(s[0])  # 位置下标
    ### 在最新的Pandas版本中，当使用整数作为Series的索引时，Pandas会默认将整数作为标签而不是位置。这意味着，如果你使用整数作为索引来访问Series中的值，Pandas会将这个整数视为标签而不是位置。这与DataFrame的行为一致，DataFrame也默认将整数作为行标签。
    print(s.iloc[0]) # 如果你想要通过位置访问Series中的值，你可以使用ser.iloc[pos]来实现。
    print(s['a']) # 标签下标
    print(s.iloc[:3]) # 位置索引加入切片操作

    print(s[['a','b','c']]) # 使用索引标签访问多个元素值 多索引用列表存储再当成参数传入
    # 使用了 index 中不包含的标签，则会触发异常

3.series 常用属性

• axes    以列表的形式返回所有行索引标签。
• dtype   返回数据值的数据类型。
• empty   返回bool值 用于判断数据对象是否为空。
• ndim    返回输入数据的维数。
• size    返回输入数据的元素数量。
• values  以 ndarray 的形式返回 Series 对象。
• index   返回一个RangeIndex对象，用来描述索引的取值范围。

def series_attribute_test():
    s = pd.Series(np.random.randn(5))
    print(s)
    print ("The axes are:")
    print(s.axes)
    print ("The dtype is:")
    print(s.dtype)
    print("是否为空对象?")
    print (s.empty)
    print('维数？') 
    print (s.ndim) # 查看序列的维数。根据定义，Series 是一维数据结构，因此它始终返回 1
    print('series的长度大小')
    print(s.size)
    print("输出series中数据")
    print(s.values) # 以数组的形式返回 Series 对象中的数据。
    print(f'values返回的数据类型为:{type(s.values)}')
    print('索引的取值范围')
    # 显示索引
    s1=pd.Series([1,2,5,8],index=['a','b','c','d'])
    print(f'显示索引{s1.index}')
    # 隐式索引
    s2=pd.Series([1,2,5,8])
    print(f'隐式索引{s2.index}')

about.系列的加法

# 空值和任何值计算结果扔为空值 
# 系列的加法 按对应索引进行相加
def series_add_test():
    s1 = pd.Series(np.random.randn(3),index=['a','b','c'])
    s2 = pd.Series(np.random.randn(3),index=['b','c','d'])
    print(s1)
    print(s2)
    print(s1+s2)

4.series 常用方法

1) head()&tail()查看数据

如果想要查看 Series 的某一部分数据，可以使用 head() 或者 tail() 方法。

其中 head() 返回前 n 行数据，默认显示前 5 行数据。

tail() 返回的是后 n 行数据，默认为后 5 行。

2) isnull()&nonull()检测缺失值

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

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

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

其实不难理解，在实际的数据分析任物中，数据的收集往往要经历一个繁琐的过程。在这个过程中难免会因为一些不可抗力，或者人为因素导致数据丢失的现象。这时，我们可以使用相应的方法对缺失值进行处理，比如均值插值、数据补齐等方法。上述两个方法就是帮助我们检测是否存在缺失值。

def series_method_test():
    s=pd.Series([1,2,5,None]) # 关于如何表示空值
    print(s.head(2))
    print(s.tail(2))
    print(pd.isnull(s))  #是空值返回True
    print(type(pd.isnull(s))) # 也是一个系列
    print(pd.notnull(s)) #空值返回False

3）再次提醒 系列具有大小不可变性 所有不存在往一个系列中增加元素的方法

四、DataFrame

DataFrame 一个表格型的数据结构，既有行标签（index），又有列标签（columns）

它也被称异构数据表，所谓异构，指的是表格中每列的数据类型可以不同，比如可以是字符串、整型或者浮点型等。

0_1.关于DataFrame的索引

同 Series 一样，DataFrame 自带行标签索引，默认为“隐式索引”即从 0 开始依次递增，行标签与 DataFrame 中的数据项一一对应。

当然你也可以用“显式索引”的方式来设置行标签。

0_2.DataFrame和Series

DataFrame 的每一行数据都可以看成一个 Series 结构，只不过，DataFrame 为这些行中每个数据值增加了一个列标签。因此 DataFrame 其实是从 Series 的基础上演变而来。在数据分析任务中 DataFrame 的应用非常广泛，因为它描述数据的更为清晰、直观。

1.创建DataFrame对象

pd.DataFrame( data, index, columns, dtype, copy)

• data    输入的数据，可以是 ndarray，series，list，dict，标量以及一个 DataFrame。
• index   行标签，如果没有传递 index 值，则默认行标签是 np.arange(n)，n 代表 data 的元素个数。
• columns 列标签，如果没有传递 columns 值，则默认列标签是 np.arange(n)。
• dtype   dtype表示每一列的数据类型。
• copy    默认为 False，表示复制数据 data。

def DataFrame_test():
    ## 1) 创建空的DataFrame对象
    print('test_01:')
    df = pd.DataFrame()
    print(df)

    ## 2) 列表创建DataFame对象 列表仅提供数据值 显式索引需要自定义 
    # 单一列表创建
    print('test_02:')
    data = [1,2,3,4,5]
    df = pd.DataFrame(data)
    print(df) # 行列均为隐式索引

    # 嵌套列表创建
    print('test_03:')
    data = [
        ['Alex',10],
        ['string',18],
        ['int',None]
    ]
    df = pd.DataFrame(data,index=['001','002','003'],columns=['name','age'])
    print(df)

    ## 3) 字典嵌套列表创建 键值提供列索引columns 自定义行索引index
    ## 这种方式无法更改列索引 会导致所有数据值为NaN
    # data 字典中，键对应的值的元素长度必须相同（也就是列表长度相同）
    print('test_04:')
    data = {'Name':['Tom', 'Jack', 'Steve', 'Ricky'],'Age':[28,34,29,42]}
    df = pd.DataFrame(data,index=['001','002','003','004'])
    print(df)

    ## 4) 列表嵌套字典创建DataFrame
    # 列表嵌套字典可以作为输入数据传递给 DataFrame 构造函数。默认情况下，字典的键被用作列名
    print('test_05:')
    data = [{'a':1,'b':2},{'a':3,'b':4,'c':5}]
    df = pd.DataFrame(data,index=['001','002'])
    print(df)

    # 定义行，列索引
    print('test_06:')
    data = [{'a':1,'b':2},{'a':3,'b':4,'c':5}]
    df1 = pd.DataFrame(data,index=['001','002'],columns=['a','b'])
    df2 = pd.DataFrame(data,index=['001','002'],columns=['a','b1'])
    print(df1)
    print(df2) # 注意：因为 b1 在字典键中不存在，所以对应值为 NaN。

    ## 5) Series创建DataFrame对象
    # 您也可以传递一个字典形式的 Series，从而创建一个 DataFrame 对象，其输出结果的行索引是所有 index 的合集
    # 同理 key值为列索引 values为其数据值 系列的行索引标签为DataFrame的行索引
    print('test_07:')
    data = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),\
   'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
    df = pd.DataFrame(data)
    print(df)

2.列索引操作DataFrame

可以使用列索引（columns）来完成数据的选取、添加和删除操作。

def DataFrame_columns_test():
    ## 1) 列索引选取数据列 df['column_name']
    print('test_01:')
    data = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
   'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
    df = pd.DataFrame(data)
    print(df['one'])
    
    ## 2) 列索引添加数据列
    # 使用 columns 列索引表标签可以实现添加新的数据列
    # 使用df['列']=值，插入新的数据列
    print('test_02:')
    df['three']=pd.Series([10,20,30],index=['a','b','c'])
    print('使用列索引创建新数据列:')
    print(df)
    # 将已经存在的数据列做相加运算
    df['four']=df['one']+df['three']
    print('已存在的数据列做算术运算：')
    print(df)
    ## 同时 我们初次使用了 DataFrame 的算术运算，这和 NumPy 非常相似。
    再次提醒 NaN和任意数值的加法 都是NaN

   

    ## 3) 使用 insert() 方法插入新的列
    print('test_03:')
    info=[['Jack',18],['Helen',19],['John',17]]
    df=pd.DataFrame(info,columns=['name','age'])
    print('添加前：')
    print(df)
    # 注意是column参数
    # 数值1代表插入到columns列表的索引位置
    df.insert(1,column='score',value=[91,90,75])
    print('添加后：')
    print(df)

    ## 4) 列索引删除数据列
    # 通过 del 和 pop() 都能够删除 DataFrame 中的数据列。
    d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
   'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd']),
   'three' : pd.Series([10,20,30], index=['a','b','c'])}
    df = pd.DataFrame(d)
    print ("Our dataframe is:")
    print(df)
    # 使用del删除
    del df['one']
    print(df)
    # 使用pop方法删除
    df.pop('two')
    print (df)


当你使用 del 语句删除 DataFrame 中的列时，这个操作是直接作用于原始 DataFrame 的。
这意味着，一旦你使用 del 删除了列，这个更改是不可逆的，原始 DataFrame 将会永久失去这些列。

另一方面，pop() 方法会删除指定的列，并将该列及其数据作为返回值。
使用 pop() 方法不会改变原始 DataFrame，除非你再次对返回的列进行操作。
如果你想要删除列并保留被删除的列的数据，pop() 是一个不错的选择。

3.行索引操作DataFrame

理解了上述的列索引操作后，行索引操作就变的简单。下面看一下，如何使用行索引来选取 DataFrame 中的数据。

def DataFrame_index_test():
    ## 1) 标签索引选取
    # 可以将行标签传递给 loc 函数，来选取数据。
    ## loc 允许接两个参数分别是行和列，参数之间需要使用“逗号”隔开，但该函数只能接收标签索引。
    print('test_01:')
    d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
   'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
    df = pd.DataFrame(d)
    print(df)
    print(df.loc['b'])
    print(df.loc['b','one'])

    ## 2) 整数索引选取
    # 通过将数据行所在的索引位置传递给 iloc 函数，也可以实现数据行选取。
    print('test_02:')
    print(df.iloc[2])
    # print(df.iloc[2][1]) # 已经过时的方法
    print(df.iloc[2,1]) # iloc 允许接受两个参数分别是行和列，参数之间使用“逗号”隔开，但该函数只能接收整数索引。

    ## 3) 切片操作多行选取 左闭右开
    # 您也可以使用切片的方式同时选取多行。示例如下：
    print('test_03:')
    print(df.iloc[2:4])

    ## 4) 添加数据行 append似乎有误
    # # 使用 append() 函数，可以将新的数据行添加到 DataFrame 中，该函数会在行末追加数据行。示例如下：
    # print('test_04:')
    # df1 = pd.DataFrame([[1, 2], [3, 4]], columns = ['a','b'])
    # df2 = pd.DataFrame([[5, 6], [7, 8]], columns = ['a','b'])
    # # 在行末追加新数据行 ### 但是 无法避免行索引标签发生重复
    # df1 = df1.append(df2,ignore_index=True)
    # print(df1)

    ## 5) 删除数据行 调用drop方法
    # 您可以使用行索引标签，从 DataFrame 中删除某一行数据。如果索引标签存在重复，那么它们将被一起删除。示例如下：
    print('test_04:')
    df = pd.DataFrame([[1, 2], [3, 4],[5, 6], [7, 8]], columns = ['a','b'])
    print(df)
    print('after drop:')
    df = df.drop(0)
    print(df)

4.DataFrame常用属性和方法

DataFrame 的属性和方法，与 Series 相差无几，如下所示：

名称         属性&方法描述

• T       行和列转置。
• axes    返回一个仅以行轴标签和列轴标签为成员的列表。
• dtypes  返回每列数据的数据类型。
• empty   DataFrame中没有数据或者任意坐标轴的长度为0，则返回True。
• ndim    轴的数量，也指数组的维数。
• shape   返回一个元组，表示了 DataFrame 维度。
• size    DataFrame中的元素数量。
• values  使用 numpy 数组表示 DataFrame 中的元素值。
• head()  返回前 n 行数据。
• tail()  返回后 n 行数据。
• shift() 将行或列移动指定的步幅长度

def dataframe_attribute_test():
    d = {'Name':pd.Series(['c语言中文网','编程帮',"百度",'360搜索','谷歌','微学苑','Bing搜索']),
   'years':pd.Series([5,6,15,28,3,19,23]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
    # 构建DataFrame
    df = pd.DataFrame(d)
    # 输出series
    print('输出 series 数据:')
    print(df)

    ## 1) T（Transpose）转置
    # 返回 DataFrame 的转置，也就是把行和列进行交换。
    print('test_01:')
    print('输出DataFrame的转置:')
    print(df.T)

    ## 2) axes
    # 返回一个行标签、列标签组成的列表。
    print('test_02:')
    print('输出行、列标签:')
    print(df.axes)

    ## 3) dtypes
    # 返回每一列的数据类型。
    print('test_03:')
    print('输出行、列标签')
    print(df.dtypes)

    ## 4) empty
    # 返回一个布尔值，判断输出的数据对象是否为空，若为 True 表示对象为空。
    print('test_04:')
    print('判断输入数据是否为空:')
    print(df.empty)

    ## 5) ndim
    # 返回数据对象的维数。DataFrame 是一个二维数据结构。

    ## 6) shape
    # 返回一个代表 DataFrame 维度的元组。返回值元组 (a,b)，其中 a 表示行数，b 表示列数。

    ## 7) size
    # 返回 DataFrame 中的元素数量。

    ## 8) values
    ## 以 ndarray 数组的形式返回 DataFrame 中的数据。
    #DataFrame的数据
    print(df.values)

    ## 9) head()&tail()查看数据
    # 如果想要查看 DataFrame 的一部分数据，可以使用 head() 或者 tail() 方法。其中 head() 返回前 n 行数据，默认显示前 5 行数据。
   

### 10) shift()移动行或列
# 如果您想要移动 DataFrame 中的某一行/列，可以使用 shift() 函数实现。它提供了一个periods参数，该参数表示在特定的轴上移动指定的步幅。

# shif() 函数的语法格式如下：DataFrame.shift(periods=1, freq=None, axis=0)
# 参数说明如下：

# 参数名称	             说明
# peroids	    类型为int，表示移动的幅度，可以是正数，也可以是负数，默认值为1。
# freq	        日期偏移量，默认值为None，适用于时间序。取值为符合时间规则的字符串。
# axis	        如果是 0 或者 “index” 表示上下移动，如果是 1 或者 “columns” 则会左右移动。
# fill_value	该参数用来填充缺失值。

def DataFrame_shift_test():
    info= pd.DataFrame({'a_data': [40, 28, 39, 32, 18], 
    'b_data': [20, 37, 41, 35, 45], 
    'c_data': [22, 17, 11, 25, 15]}) 
    # 移动幅度为3
    print(info)
    info.shift(periods=3) 
    print('after shift(periods=3):')
    print(info)
    # 注意：fill_value 参数不仅可以填充缺失值，还也可以对原数据进行替换。
    
### 11) 排序
# DataFrame.sort_values（by，axis=0，ascending=True），
# 参数：
# by为axis轴上的某个索引或索引列表。
# axis表示轴；对于2维表，有2个轴；默认轴axis=0，就是按某列排序；axis=1，就是按行排序；
# ascending表示升序还是降序，默认升序； false为降序 true为升序

# 关于索引列表 df = df.sort_values(['year','pop']) 为多列排序，year列的优先级高于pop列

5.读取文本文件

pandas提供了一些用于将表格型数据读取为DataFrame对象的函数，常用的包括：read_csv（）、read_table（）、to_csv（）等；

stock = pd.read_csv('csv_path') 
stock.head()

read_csv():
参数作用：read_csv()函数用于读取CSV文件并将其转换为DataFrame对象。它可以接受多种参数，如文件路径、分隔符、列名、行索引等，以便灵活地读取和处理数据。
返回值：返回一个DataFrame对象，其中包含了CSV文件的数据。
示例：
import pandas as pd
df = pd.read_csv('data.csv')

read_table():
参数作用：read_table()函数用于读取文本文件，并将其转换为DataFrame对象。与read_csv()函数类似，只是read_table()默认使用制表符（'\t'）作为分隔符。
返回值：返回一个DataFrame对象，其中包含了文本文件的数据。
示例：
import pandas as pd
df = pd.read_table('data.txt')

to_csv():
参数作用：to_csv()函数用于将DataFrame对象中的数据保存到CSV文件中。可以指定文件路径、数据分隔符、是否写入列名等参数。
返回值：将DataFrame对象的数据保存为CSV文件，并返回保存的文件路径。
示例：
import pandas as pd
df.to_csv('output.csv', index=False)
这些函数是Pandas库中用于读取和写入CSV文件的常用函数，可以帮助用户方便地进行数据处理和保存。

# 使用read_csv()读取CSV文件
df = pd.read_csv(
    filepath_or_buffer=filepath,
    sep=',',  # 指定字段分隔符为逗号
    header=0,  # 指定第一行为列名
    names=['Name', 'Age', 'Occupation'],  # 指定列名
    index_col='Name',  # 将Name列作为行索引
    skiprows=1,  # 跳过第一行（因为列名已经通过names参数指定）
    nrows=2,  # 只读取前两行数据
    encoding='utf-8',  # 指定文件编码格式
    dtype={'Name': str, 'Age': int, 'Occupation': str},  # 指定列的数据类型
    parse_dates=['Age']  # 将Age列解析为日期类型（这里假设Age是日期格式，实际情况可能不同）
)

filepath_or_buffer: CSV文件的路径，可以是文件路径字符串、URL或类文件对象。
sep: 指定CSV文件中字段之间的分隔符，默认为逗号(,)。
header: 指定用作列名的行号，默认为0，表示第一行。
names: 用于指定列名的列表。
index_col: 用作行索引的列的列号或列名。
skiprows: 指定要跳过的行数，可以是一个整数或列表。
nrows: 指定要读取的行数。
encoding: 指定文件编码格式，默认为'utf-8'。
dtype: 指定列的数据类型，可以是字典、序列、或Numpy数据类型。
parse_dates: 指定要解析为日期时间的列。

这些参数可以根据用户的需求灵活地使用，以确保正确地读取和处理CSV文件中的数据。

五、pandas数据分析

1.有关统计分析的DataFrame方法

stock.describe()是Pandas中DataFrame对象的一个方法，用于生成描述性统计信息。它会对DataFrame中的数值型列进行统计分析，包括计数、均值、标准差、最小值、25%分位数、中位数、75%分位数以及最大值等。这些统计信息能够帮助用户快速了解数据的分布和特征。
返回的各列描述性统计信息包括以下统计量：
count：非缺失值的数量
mean：平均值
std：标准差
min：最小值
25%、50%、75%：数据的分位数，分别对应25%、50%和75%的位置
max：最大值

计算各列数据之和 stock.sum()
统计各列非NaN的数量 stock.count()

.mean（）/.median（）：计算数据的算术平均值、算术中位数
.var（）/.std（）：计算数据的方差、标准差
.corr（）/.cov（）：计算相关系数矩阵、协方差矩阵，是通过参数对计算出来的。
.min（）/.max（）：计算数据的最小值、最大值
.diff（）：计算一阶差分，对时间序列很有效
.mode（）：计算众数，返回频数最高的那（几）个
.mean（）：计算均值
.quantile（）：计算分位数（0到1）

总结

本篇文章我们重点介绍了pandas库中最常用的两种数组结构，以及他们的属性方法；下一篇系列文章我们会将pandas库投入实践

拓展

1.关于成员检测

（1）保留字in

在Python中，in是一个用于成员检测的保留字。它可以用来检查一个元素是否存在于一个容器（如列表、元组、集合、字典等）中。当in操作符用于列表或元组时，它会检查指定的元素是否在列表或元组中；当用于字典时，in会检查指定的键名是否在字典中；当用于集合时，in会检查指定的元素是否在集合中。

# 保留字in操作：

# 示例：
# in操作符用于列表
my_list = [1, 2, 3, 4, 5]
print(3 in my_list)  # True
# in操作符用于字典
my_dict = {'a': 1, 'b': 2, 'c': 3}
print('b' in my_dict)  # True

（2）使用.get()方法

在Python中，字典对象有一个名为.get()的方法，用于获取指定键对应的值。与直接通过键访问字典元素的方式不同，使用.get()方法可以在键不存在时返回默认值（如果提供了默认值），避免出现KeyError异常。

# 示例：
my_dict = {'a': 1, 'b': 2, 'c': 3}
# 直接通过键访问字典元素
value = my_dict['b']
print(value)  # 2

# 使用.get()方法获取字典元素，避免KeyError
value = my_dict.get('d', 'Key not found')
print(value)  # 'Key not found'
# 通过使用.get()方法，可以更加安全地访问字典中的元素，避免由于键不存在而引发的KeyError异常。

（3）.Series对象支持保留字in操作和.get()方法

是的，Series对象支持保留字in操作和.get()方法。

# in操作：
# 可以使用in操作符来检查某个值是否在Series的索引中。

# 示例：
# 创建一个Series对象
s = pd.Series([1, 2, 3, 4], index=['A', 'B', 'C', 'D'])
# 使用in操作符检查索引是否存在
print('A' in s)  # True
print('E' in s)  # False

# .get()方法：
# Series对象也支持.get()方法，可以根据索引获取对应的值，如果索引不存在则返回指定的默认值。

# 示例：
# 创建一个Series对象
s = pd.Series([1, 2, 3, 4], index=['A', 'B', 'C', 'D'])
# 使用.get()方法获取值
print(s.get('B'))  # 2
print(s.get('E', 'Not found'))  # 'Not found'
# 因此，Series对象在操作上与字典类似，可以使用in操作符检查索引是否存在，也可以使用.get()方法获取索引对应的值，并可以指定默认值避免异常。

2.关于iloc和loc

还记得索引的两种方式吗？联系上英文全称更容易理解捏

在Python的pandas库中，iloc和loc是用于数据选择和索引的两种方法。它们的全称分别是：

iloc：整数位置选择器（Integer Location-based Indexing）
loc：标签选择器（Label-based Indexing）
这两种方法允许用户根据位置或标签来访问和操作DataFrame或Series中的数据。

iloc允许用户通过整数索引来选择数据，这意味着你可以使用行号或列号来获取数据。例如，df.iloc[0]将返回DataFrame df的第一行，而df.iloc[:, 1]将返回第二列的所有数据。

loc则允许用户通过标签来选择数据，这意味着你可以使用行标签或列标签来获取数据。例如，如果df有一个行标签为'row1'的行，你可以使用df.loc['row1']来获取这一行的数据。

这两种方法提供了灵活的数据访问方式，使得在处理大型数据集时能够更加高效和精确地进行数据操作。

3.ndarray与series

Series是Pandas库中的一种数据结构，类似于一维数组，与NumPy的ndarray也是一种类似的数据结构。以下是Series和ndarray的主要区别：

索引：


Series：每个Series对象都有一个索引，可以是默认的整数索引，也可以是自定义的标签索引。索引可以帮助用户标识数据点的含义。
ndarray：NumPy的ndarray没有内置的索引，只能通过整数位置来访问元素。

示例：
import pandas as pd
import numpy as np
创建一个Series对象
s = pd.Series([1, 2, 3, 4], index=['A', 'B', 'C', 'D'])
创建一个ndarray
arr = np.array([1, 2, 3, 4])
print(s)
Output:
A    1
B    2
C    3
D    4
dtype: int64
print(arr)
Output:
[1 2 3 4]

数据类型灵活性：


Series：在一个Series对象中，数据类型可以是任意的，可以是整数、浮点数、字符串等。
ndarray：NumPy的ndarray要求所有元素具有相同的数据类型。

示例：
Series中包含不同的数据类型
s = pd.Series([1, 'apple', 3.14])
ndarray要求所有元素具有相同的数据类型
arr = np.array([1, 2, 3.14])  # 会自动转换为浮点数类型
print(s)
Output:
0        1
1    apple
2     3.14
dtype: object
print(arr)
Output:
[1.   2.   3.14]

功能性：


Series：Pandas中的Series提供了丰富的数据操作和处理功能，如索引、数据对齐、缺失值处理等。
ndarray：NumPy的ndarray主要用于数值计算和数组操作，提供了各种数学函数和操作符。

总的来说，Series是在NumPy的ndarray基础上构建的，增加了索引、更灵活的数据类型和更丰富的功能，适用于数据分析和处理。而ndarray更适合用于数值计算和科学计算。

以上即是全部内容，如果对你有帮助，欢迎点赞收藏关注！