pandas基础使用

pandas基础使用

基本介绍

• 类似于字典形式的numpy，可以给它的不同行和不同列进行重命名。

import numpy as np
import pandas as pd
# 创建一个序列
s = pd.Series([1,4,True,np.nan,55.0])

• 创建date format日期矩阵

import numpy as np
import pandas as pd
dates = pd.date_range('20241231',periods=6)

• 创建DataFrame数据结构（类似于二维表格或电子表格）

import numpy as np
import pandas as pd
df = pd.DataFrame(np.random.randn(6,4),index=dates,columns=['a','b','c','d'])

其中np.random.randn(6,4)表示随机产生一个六行四列的矩阵，其中的数值近似服从正态分布。如果不给定索引列以及行的索引名称，会默认生成有序序列。

import numpy as np
import pandas as pd
df1 = pd.DataFrame(np.arange(12).reshape(3,4))

除此之外，还有一种来生成DataFrame数据结构

import numpy as np
import pandas as pd 
df2 = pd.DataFrame({'A':1.,'B':pd.Timestamp('20241231'),'C':pd.Series(1,index=list(range(4)),dtype='float32'),'D':np.array([3]*4,dtype='int32'),'E':pd.Categorical(["test","train","test","train"]),"F":"foo"})
df2.dtypes
# 返回每一个元素的类型
df2.index
# 返回元素的每一行的索引
df2.columns
# 返回元素的每一列的标签
df2.values
# 返回元素的所有values
df2.describe()
# 描述数据的内容，比如方差、平均值等等。
df2.T
# 矩阵转置
df2.sort_index(axis=0,ascending=False)
# 对维度为列的行数据进行排序,并指定排序的格式：正序或倒序，除了对索引进行排序，也可对value值进行排序
df2.sort_values(by="E")

选择数据

列选择

1. 通过列名选择单个列：如果有一个DataFrame df，可以使用df[‘列名’]来选择一列，这会返回一个Series。

 import numpy as npimport pandas as pddates = pd.date_range('20241231',periods=6)df = pd.DataFrame(np.arange(24).reshape(6,4),index=dates,columns=["A","B","C","D"])print(df['A']) # 也可以通过print(df.A)是同样的效果

2. 选择多个列：使用df[[“列名1”,“列名3”]]的形式。会返回一个DataFrame。

 import numpy as npimport pandas as pddates = pd.date_range('20241231',periods=6)df = pd.DataFrame(np.arange(24).reshape(6,4),index=dates,columns=["A","B","C","D"])print(df[["A","C"]])

行选择

1. 基于行索引标签选择：可以用df.loc[行索引标签]来选择单行。如果要选择多行，格式为df.loc[行索引标签列表]。例如，df.loc[“20241231”:“20250102”]选择第一行到第三行或者df.loc[[“20241231”,“20250102”]]选择第一行和第三行的数据。

 import numpy as npimport pandas as pddates = pd.date_range('20241231',periods=6)df = pd.DataFrame(np.arange(24).reshape(6,4),index=dates,columns=["A","B","C","D"])print(df.loc["20241231":"20250102"])print(df.loc[["20241231","20250102"]]) #选择第一行和第三行的数据

2. 基于行索引位置选择：用df.iloc[行索引位置]选择单行，df.iloc[行索引位置列表]选择多行。比如df.iloc[3]表示选择第四行，df.iloc[[0,1,3]]表示选择第一行、第二行以及第四行，df.iloc[0:2]选择第一行到第三行

 import numpy as npimport pandas as pddates = pd.date_range('20241231',periods=6)df = pd.DataFrame(np.arange(24).reshape(6,4),index=dates,columns=["A","B","C","D"])# print(df.iloc[3])# print(df.iloc[[0,1,3]])print(df.iloc[0:3])

3. 条件筛选：可以根据条件来选择行。例如，df[df[‘语文成绩’] > 80]会返回语文成绩大于80的所有行。还可以使用多个条件组合。

 import numpy as npimport pandas as pddates = pd.date_range('20241231',periods=6)df = pd.DataFrame(np.arange(24).reshape(6,4),index=dates,columns=["A","B","C","D"])print(df[df[["A","C"]] > 8])

设置值

1. 通过列名设置列的值

   • 整体替换列的值：比如把A列的全部值替换为0，可以这样做：df[‘A’] = 0

     import numpy as npimport pandas as pddates = pd.date_range('20241231',periods=6)df = pd.DataFrame(np.arange(24).reshape(6,4),index=dates,columns=["A","B","C","D"])df['A']=0print(df)
   

   • 基于条件设置列的值：可以根据一定的条件来设置列的值。例如，将A列中大于10的值设为-1,df[‘A’] [df[‘A’] > 10] = -1

    import numpy as npimport pandas as pddates = pd.date_range('20241231',periods=6)df = pd.DataFrame(np.arange(24).reshape(6,4),index=dates,columns=["A","B","C","D"])df['A'][df['A'] > 10] = -1print(df)
   

2. 通过行索引和列名设置单个或多个值

   • 使用loc索引器设置单个值：loc是基于标签的索引方式。例如，要将索引为"2024-12-31"这一行的B列设为100，可以使用df.loc[‘20241231’,‘B’]=100

    import numpy as npimport pandas as pddates = pd.date_range('20241231',periods=6)df = pd.DataFrame(np.arange(24).reshape(6,4),index=dates,columns=["A","B","C","D"])df.loc['20241231','B']=100print(df)
   

   • 使用loc索引器设置多个值（一个区域）：假设要将索引从"2025-01-01"到"2025-01-02"这两行的C列和D列的值设为新的值，可以这样做：df.loc[‘20250101’:‘20250102’,[“C”,“D”]] =5

    import numpy as npimport pandas as pddates = pd.date_range('20241231',periods=6)df = pd.DataFrame(np.arange(24).reshape(6,4),index=dates,columns=["A","B","C","D"])df.loc['20250101':'20250102',['C','D']] = 5print(df)
   

3. 使用iloc索引器设置值（基于位置）

   • 设置单个值：iloc是基于位置的索引方式。如果要将第一行的第一列元素的值设置为5，df.iloc[0,0]= 5

    import numpy as npimport pandas as pddates = pd.date_range('20241231',periods=6)df = pd.DataFrame(np.arange(24).reshape(6,4),index=dates,columns=["A","B","C","D"])df.iloc[0,0]= 5print(df)
   

   • 设置多个值（区域）：比如要将前三行的后两列的值设为30

    import numpy as npimport pandas as pddates = pd.date_range('20241231',periods=6)df = pd.DataFrame(np.arange(24).reshape(6,4),index=dates,columns=["A","B","C","D"])df.iloc[0:3,2:4] = 30print(df)
   

处理丢失数据

识别丢失数据

• isnull()和notnull()函数：isnull()用于返回一个布尔型的DataFrame或Series，其中缺失值对应的位置为True，非缺失值为False。而notnull()函数则相反。

import numpy as np
import pandas as pd
dates = pd.date_range('20241231',periods=6)
df = pd.DataFrame(np.arange(24).reshape(6,4),index=dates,columns=["A","B","C","D"])
df.iloc[0,1]=np.nan
df.iloc[2,3]=np.nan
df.isnull()
# 也可以用notnull()
df.notnull()

删除丢失数据

• dropna()方法：对于DataFrame，可以在axis参数设置0（按行删除）或1（按列删除）。例如：df.dropna(axis=0)会删除包含行缺失值的行。
• 还可以通过how参数控制删除的条件，how=‘any’（默认值）表示只要某行/列包含缺失值就删除，而how='all’表示只有当某行/某列全部是缺失值时才删除。

import numpy as np
import pandas as pd
dates = pd.date_range('20241231',periods=6)
df = pd.DataFrame(np.arange(24).reshape(6,4),index=dates,columns=["A","B","C","D"])
df.iloc[0,1]=np.nan
df.iloc[2,3]=np.nan
df.dropna(axis=0,how='any')

填充丢失数据

• fillna()方法：可以用一个特定的值填充缺失值。例如，df.fillna(0)会将DataFrame中所有的缺失值都填充为0。
• 也可以使用字典来为不同的列制定不同的填充值。如df.fillna({‘B’:1,‘D’:2})会对第一列的缺失值填充为1，对第四列的缺失值填充为2。
• 还可以使用method参数进行向前填充(method=‘ffill’)或向后填充(method=‘bfill’)。向前填充使用缺失值前面的一个非缺失值来填充；向后填充则相反。例如，df.fillna(method=‘ffill’)会按照从前到后的顺序填充缺失值。

import numpy as np
import pandas as pd
dates = pd.date_range('20241231',periods=6)
df = pd.DataFrame(np.arange(24).reshape(6,4),index=dates,columns=["A","B","C","D"])
df.iloc[0,1]=np.nan
df.iloc[2,3]=np.nan
print(df.fillna(0)) # 将缺失值全部填充为0
print(df.fillna({"B":1,"D":2}))
print(df.fillna(method="ffill")) # 向前填充

导入导出数据

导入数据

• 从CSV文件导入：使用read_csv()函数。例如：df=pd.read_csv(‘data.csv’)可以将名为data.csv的文件读取到DataFrame中。可以通过参数来指定分隔符（sep参数，默认是逗号）、编码方式（encoding参数等）。如df=pd.raed_csv(‘data.csv’,sep=“;”,encoding=“utf-8”)用于读取以分号为分隔符、编码为utf-8的CSV文件。
• 从excel文件导入：使用read_excel()函数。如：df=pd.read_excel(“data.xlsx”)可以读取excel文件。可以通过sheet_name参数指定要读取的读取的工作表名称或索引，例如df=pd.read_excel(‘data.xlsx’,sheet_name=“Sheet1”)。

import numpy as np
import pandas as pd
data = pd.read_csv('data.csv')
# 读取excel数据
data = pd.read_excel('data.excel')

• 从SQL数据库导入：使用read_sql()函数，首先需要建立与数据库的连接。

import pandas as pd
from sqlalchemy import creat_engine
engine = create_engine("mysql+pymysql://user:password@localhost:3306/database_name")

导出数据

• 导出到CSV文件：使用to_csv()方法。例如，df.to_csv(‘new_data.csv’,index=False)可以将DataFrame中的数据保存为CSV文件。index = False参数表示不保存行索引。
• 导出到excel文件：使用to_excel()方法。如，df.to_excel(‘new_data.xlsx’,sheet_name=Sheet1,index=Fales)可以将数据保存到excel的指定工作表中，同样index=False表示不保存行索引。

import numpy as np
import pandas as pd
dates = pd.date_range('20241231',periods=6)
df = pd.DataFrame(np.arange(24).reshape(6,4),index=dates,columns=["A","B","C","D"])
df.to_excel("new_data.xlsx",sheet_name='sheet1',index=False)
df.to_csv("new_data.csv",index=False)

合并concat

在pandas中，concat函数主要用于沿着一条轴将多个对象（如DataFrame或Series）合并到一起。

合并相同类型的对象

• 对于DataFrame：假设我们有三个DataFrame，df1、df2以及df3，他们有相同的列名，可以使用concat函数将他们按行合并（默认是axis=0），结果会是一个包含df1、df2和df3所有行的新DataFrame，行索引会自动排列。

import pandas as pd
import numpy as np
df1 = pd.DataFrame(np.ones((3,4))*0,columns=["a","b","c","d"])
df2 = pd.DataFrame(np.ones((3,4))*1,columns=["a","b","c","d"])
df3 = pd.DataFrame(np.ones((3,4))*2,columns=["a","b","c","d"])
result = pd.concat([df1,df2,df3])
print(result)

• 对于Series：假设我们有两个series，s1和s2，可以类似的合并，使用concat合并，这样就会得到一个新的series，包含s1和s2中的所有元素。

import numpy as np
import pandas as pd
s1 = pd.Series([1,2])
s2 = pd.Series([2,3])
result = pd.concat([s1,s2])
print(result)

合并时指定轴

• 除了按行合并，还可以按列合并（axis=1）。比如，还是上述df1、df2和df3，合并后会得到一个新的DataFrame。

import pandas as pd
import numpy as np
df1 = pd.DataFrame(np.ones((3,4))*0,columns=["a","b","c","d"])
df2 = pd.DataFrame(np.ones((3,4))*1,columns=["a","b","c","d"])
df3 = pd.DataFrame(np.ones((3,4))*2,columns=["a","b","c","d"])
result = pd.concat([df1,df2,df3],axis=1)
print(result)

处理索引重复的情况

• 当合并的DataFrame或Series有相同的索引时，concat函数有不同的处理方式。假设df1与df2有相同的索引，如果直接合并（axis=0）会得到一个包含所有行的DataFrame，索引会有重复。可以通过ignore_index=True参数来重新生成索引，避免索引重复问题，这样得到的DataFrame的索引会是从0开始的连续整数。

import pandas as pd
df1 = pd.DataFrame({"A":[1,2]},index=[0,1])
df2 = pd.DataFrame({"B":[3,4]},index=[0,1])
result = pd.concat([df1,df2],ignore_index=True)
print(result)

join功能的inner及outer

• inner：在DataFrame的join方法中，默认是左连接。如果想要实现类似内连接的功能，它会根据索引来匹配两个DataFrame中相同的索引值，返回这些匹配索引对应的行组合。

import pandas as pd
import numpy as np
df1 = pd.DataFrame(np.ones((3,4))*0,columns=["a","b","c","d"],index=[1,2,3])
df2 = pd.DataFrame(np.ones((3,4))*1,columns=["b","c","d","e"],index=[2,3,4])
res = pd.concat([df1,df2],join="inner")
print(res)

• outer：在DataFrame的join中，会基于索引进行外连接。这意味着返回的两个DataFrame索引的并集对应的行组合，对于没有匹配上的索引行，对应列会填充NaN。

import pandas as pd
import numpy as np
df1 = pd.DataFrame(np.ones((3,4))*0,columns=["a","b","c","d"],index=[1,2,3])
df2 = pd.DataFrame(np.ones((3,4))*1,columns=["b","c","d","e"],index=[2,3,4])
res = pd.concat([df1,df2],join="outer")
print(res)

合并merge

• merge是pandas中用于将两个DataFrame对象根据一个或多个键（可以是列名或索引）合并的函数。

合并参数

参数	介绍
how	连接方式（左连接left，右连接right，内连接inner，外连接outer）默认内连接
on	用来做连接键的列名（两表必须相同）
left_on	左表用来做连接键的列名
right_on	右表用来做连接键的列名
left_index	True表示左表索引列作为连接键
right_index	True表示右表索引键作为连接键
suffix	给两个表加上后缀进行区分

• 基于单个相同列名合并

import numpy as np
import pandas as pd
df1 = pd.DataFrame({'student_id':[1,2,3],'name':["alex","bob","charlie"]})
df2 = pd.DataFrame({'student_id':[2,3,4],'grade':[80,85,90]})
merge_df = pd.merge(df1,df2,on="student_id")
print(merge_id)

• 基于多个相同列名合并（on参数传入列表）

import numpy as np
import pandas as pd
df1 = pd.DataFrame({'customer_id':[101,102,103],'product_id':[201,202,203],'purchase_date':["2024-01-01","2024-02-01","2024-03-01"]})
df2 = pd.DataFrame({"customer_id":[102,103,104],"product_id":[202,203,204],'price':[10.0,12.0,15.0]})
merge_id = pd.merge(df1,df2,on=["customer_id","product_id"])
print(merge_id)

• 基于不同列名合并（使用left_on和right_on）

import numpy as np
import pandas as pd
df1 = pd.DataFrame({"id_left":[501,502,503],'name':["alex"."bob","ella"]})
df2 = pd.DataFrame({"id_right":[502,503,504],"department":["hr","it","finance"]})
merge_df = pd.merge(df1,df2,left_on="id_left",right_on="id_right")
print(merge_df)

how参数

在pandas的merge函数中，how用于指定合并的方式，这决定了如何处理两个数据框中键（用于合并的列）的匹配关系。

1. inner（内连接，默认值）

只保留两个DataFrame中键值完全匹配的行。就像是求两个集合的交集，只有在左右两个DataFrame中，合并键相同的的行才会被保留下来，其余行都被丢弃。

2. outer（外连接）

保留两个DataFrame的所有行，对于键不匹配的部分用NaN填充。如同求两个集合的并集，会把左右两gDataFrame中的所有行都包含进来。

3. left

以左边的DataFrame为基础，保留左边的DataFrame的所有行，右边DataFrame中只有与左边的DataFrame键匹配的行才会被合并进来，不匹配的部分用NaN填充。

4. right

跟左连接相反，以右边的dataFrame为基础，保留右边的DataFrame的所有行，左边的DataFrame中只有与右边的DataFrame键匹配的行才会被合并进来，不匹配的部分用于NaN填充。

import pandas as pd
df1 = pd.DataFrame({"key":["A","B","C","D"],"value1":[1,2,3,4]})
df2 = pd.DataFrame({"key":["B","D","E","F"],"value2":[5,6,7,8]})
# 内连接(how="inner")
inner_merge = pd.merge(df1,df2,on="key",how="inner")
print("内连接结果:")
print(inner_merge)
# 外连接(how="outer")
outer_merge = pd.merge(df1,df2,on="key",how="outer")
print("外连接结果:")
print(outer_merge)
# 左连接(how="left")
print(left_merge)
# 右连接(how="right")
right_merge = pd.merge(df1,df2,on="key",how="right")
print("右连接结果:")
print(right_merge)

suffix

在pandas中，suffix主要用于在合并(merge)数据时给列明添加后缀。当使用merge函数将两个DataFrame合并在一起，如果两个DataFrame存在相同列名，就会出现列名冲突的情况。suffixes参数可以接受一个包含两个字符串的元组，用来给合并后的DataFrame中的重叠列名添加后缀，以区分来自不同DataFrame的列。

import pandas as pd
df1 = pd.DataFrame({"key":["a","b","c"],"value":[1,2,3]})
df2 = pd.DataFrame({"key":["a","b","d"],"value":[4,5,6]})
merge_df = pd.merge(df1,df2,on="key",suffixes=("_left","_right"))
print(merge_df)

plot画图

对于Series：

• 如果有一个Series对象，例如：s = pd.Series([1,2,3,4])，直接调用s.plot()就可以绘制简单的线图。还可以通过传递参数给plot()方法来改变图形类型。例如：s.plot(kind=“bar”)表示绘制柱状图。

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
data = pd.Series(np.random.randn(1000),index=np.arange(1000))
data = data.cumsum
data.plot()
plt.show()

对于DataFrame

• 当有一个DataFrame对象时，每一列的数据可以被视为一个Series。默认情况下，df.plot()会绘制每一列数据的线图，其中x轴是索引，y轴是每列的数据。同样可以通过kind参数指定图形类型。

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
data = pd.DataFrame(np.random.randn(1000,4),index=np.arange(1000),columns=list("ABCD"))
data = data.cumsum()
data.plot()
plt.show()