零、导入pandas包
import pandas as pd
一、创建DF
DataFrame()
df = pd.DataFrame()
没有指定数据与结构
df = pd.DataFrame(columns=['A','B','C'],index=[0,1,2])
创建只有结构的空dataframe
List -> DataFrame
df2 = pd.DataFrame(data=['Apple','banna','cherry','dates','eggfruit'])
Dict -> DataFrame
product_dict = {'pencial':['black','red','yellow'],'ruler':['long','short']}
df3 = pd.DataFrame(product_dict)
这里需要注意的一个点是：每列数据的个数应保持一致。否则会报错：
ValueError: All arrays must be of the same length
CSV -> DataFrame
df = pd.read_csv('test.csv')
从test.csv中读取数据
import pandas as pd
df = pd.read_csv('test.csv', dtype=object)
如果需要保留字符串格式
Excel -> DataFrame
df = pd,read_excel('data.xlsl)
几个重要的参数
read_excel(
path,
sheet = NULL,
range = NULL,
col_names = TRUE,
col_types = NULL,
na = "",
trim_ws = TRUE,
skip = 0,
n_max = Inf,
guess_max = min(1000, n_max),
progress = readxl_progress(),
name_repair = "unique"
)
sheet 用于指定excel簿中的具体sheet
range 数据读取的范围，形如：“B3:D87”， “Budget!B2:G14”
col_names 如果是TRUE则读取第一行作为列名，否则用默认值命名或者接受一个字符串向量作为列名
na 用于指定缺失值的字符
Json -> DataFrame
从Json文件中读取数据
with open("data.json",'r') as f:
data = json.loads(f.read())
print(pd.DataFrame(data).to_string())
从json文件中读取数据
df = pd.read_json("data.json")
print(df.to_string())
使用read_json方法也可以从json文件中读取数据
DataFrame -> DataFrame
df2 = df
创建了一个对原先df的引用，也就是说，df2与df指向的是同一个内存， df2修改，对df也有效，也就是浅复制
df2 = df.copy()
创建了一个新的DataFrame, 也就是说，df2 与df指向的不是同一个内存， df2修改， 不影响df，也就是深复制
既然我们都重新定义一个df了，我个人推荐使用copy()这样能够避免原先的数据被更改
二、查看数据信息
df.shape
print(df.shape)
查看行与列维度，结果为
(rows,columns)
df.describe()
使用 .describe() 方法计算了列的描述统计信息，describe() 方法会计算每列数据的一些统计指标，包括计数、均值、标准差、最小值、四分位数和最大值。
以下是一个示例代码：
import pandas as pd
# 假设 sales 是一个 DataFrame，包含了 'recency'、'frequency' 和 'monetary' 列
sales = pd.DataFrame({'recency': [5, 10, 15, 20, 25],
'frequency': [2, 4, 6, 8, 10],
'monetary': [100, 200, 300, 400, 500]})
# 使用 describe() 方法计算描述统计信息，然后选择四分位数的范围
des = sales[['recency', 'frequency', 'monetary']].describe().loc['25%':'75%']
# 打印结果
print(des)
在上述示例代码中，我创建了一个示例的 DataFrame sales，其中包含了 ‘recency’、‘frequency’ 和 ‘monetary’ 三个列的数据。然后，使用 .describe() 方法计算了这些列的描述统计信息。接下来，通过使用 .loc['25%':'75%'] 选取了四分位数的范围。
以下是示例代码的输出结果：
recency frequency monetary
25% 10.0 4.0 200.0
50% 15.0 6.0 300.0
75% 20.0 8.0 400.0
这些结果显示了 recency、frequency 和 monetary 三列数据的四分位数范围（即第一四分位数、中位数和第三四分位数）。
df.columns
print(df.columns)
返回DataFrame中列变量的标签
len(df.columns)
计算有多少个列
df.info()
print(df.info())
查看数据的缺失情况和数据类型
三、条件查询
df.head()
df.head()
默认查看前5条数据
df.head(6)
查看前6条数据
df.tail()
print(df.tail())
默认查看最后5条数据
print(df.tail(100)
查看后100条数据
df.iloc[,]
print(df.iloc[9,:])
查看第10行数据，
print(df.iloc[9])
查看所有列时，可以省略,:
print(df.iloc[9:21,-1])
查看第10行到20行 的最后一列变量数据
df.loc[,]
print(df.loc[df.Language=='Python',])
查询对应language为python的数据
print(df.loc[df.Language=='Python','Achievement'])
查询对应language为python的数据对应的achievement值
print(df.loc[(df.Graduate_year==2020)&(df.Language=="Java")])
多条件查询，使用()括起不同的条件，然后根据条件的或以及与的逻辑，使用&【以及】|【或】
print(df.loc[df.Language.isin(['CPP','C'])])
使用isin进行多条件查询
df[]
print(df[df.Language=='Python'])
df.iloc[,]、df.loc[,], df[]的区别
在Pandas中，loc[]、iloc[]和[]都是用于对DataFrame或Series进行数据访问和切片的方法。
-
[]用于基本的索引和切片操作。你可以使用列名直接访问DataFrame中的列，例如df['column_name']，也可以使用布尔条件来筛选数据，例如df[df['column_name'] > 0]。 -
loc[]是基于标签的索引方法。它用于根据行标签或列标签进行数据访问和切片。例如，df.loc[row_labels, column_labels]可以用于选择特定行和列的数据，其中row_labels和column_labels可以是单个标签、标签列表或布尔条件。 -
iloc[]是基于位置的索引方法。它用于根据行索引和列索引的位置进行数据访问和切片。例如，df.iloc[row_indices, column_indices]可以用于选择特定行和列的数据，其中row_indices和column_indices可以是单个索引、索引列表或切片。
总结：
[]适用于基本的索引和切片操作。loc[]适用于基于标签的索引和切片操作。iloc[]适用于基于位置的索引和切片操作。
df.query(‘’)
filtered_df = df.query("column1>0 and column2=='value'")
筛选出 column1 大于0且 column2 等于 'value' 的数据行。
【query 与 where的相似】
查询的字符串表达式与SQL中的WHERE逻辑相似。Pandas的df.query()方法使用类似SQL的语法来执行筛选操作，可以通过在字符串表达式中使用逻辑运算符（如and、or、not）和比较运算符（如==、!=、<、>、<=、>=）来构建复杂的筛选条件。
【query 与 where 的差异】
另外，一些特定的SQL语法和函数在Pandas的查询表达式中可能不可用。
最后，where中相同是用=，而query中是使用==
print(df.query('Num_of_exercise==500')[['Level','Achievement_value']])
效果等价于
print(df.loc[df.Num_of_exericse==500,['Level','Achievement_value']])
df.isin()
print(df[df.Language.isin(['CPP','C'])])
对一个变量Language进行多条件查询
df.isnull()、df.isna()
isnull() 效果与isna()效果是一样的
print(df.isnull())
print(df.isna())
判断dataframe中的数据是否存在缺失值
df[df.Language.isnull()].Language = 'Python'
填补缺失值
df.notnull(), df.notna()
notnull() 与notna()效果也是等价的
print(df[df.notnull()])
返回不为null的数据
print(df[df.notna()])
df.duplicated()
print(df.duplicated())
返回关于数据是否重复的布尔变量
print(df.duplicated(subset='Language'))
返回关于列变量Language数据是否重复的布尔变量
print(df.duplicated(keep='first'))
first 标记第一个出现的值为Fasle, 后续出现的为True, 默认
print(df.duplicated(keep='last'))
last 标记最后一个出现的值为False，之前出现的为True
print(df.duplicated(keep=Fasle))
False 默认，述性分析
四、描述性分析
unique()
print(df.column_name.unique()
查看该变量的取值情况
value_counts()
查看对应列不同类别的频数
print(df.language.value_counts())
参数：
normalize = True：返回的对象将包含各个值的相对频率（默认False）ascending = True：升序（默认False）dropna = False：对无效值进行计数（默认True）
max()
print(df.column_name.max())
返回对应变量的最大值
print(df.max())
返回所有数值型变量的最大值
min()
print(df.column_name.min())
返回对应变量的最小值
mean()
print(df.column_name.mean()
返回对应变量的均值
median()
print(df.column_name.median()
返回对应变量的中位数
quantile()
print(df.column_name.quantile(q=0.25))
返回变量的25分位数
print(df[["column_name1", "column_name2"]].quantile(q=0.75))
返回多个变量的75分位数
qcut()
qcut() 是 Pandas 中的一个函数，用于根据数据的分位数将数据分成指定数量的相等大小的区间。它可以帮助您对数据进行分组或离散化操作。
以下是 qcut() 函数的基本语法：
pandas.qcut(x, q, labels=None, retbins=False, precision=3, duplicates='raise')
参数说明：
x：要进行分组的数据，可以是一个 Series 或数组。q：要分成的区间的个数，或者一个列表/数组，指定特定的分位数。labels：要为结果分组命名的标签，可以是一个列表或数组，长度与分组数量匹配。retbins：是否返回区间边界值，可以通过将其设置为True来获取区间边界值。precision：指定返回的区间边界值的小数位数。duplicates：指定如何处理相同的分位数情况。可选值包括 ‘raise’（抛出异常，默认）、‘drop’（忽略）和 ‘raise’（保留）。
下面是一个示例代码，展示了如何使用 qcut() 函数将数据分成四个等分的区间：
import pandas as pd
# 创建一个示例数据集
data = pd.DataFrame({'A': range(1, 11)})
# 使用 qcut() 分组
data['Group'] = pd.qcut(data['A'], q=4)
# 打印结果
print(data)
在上述代码中，我创建了一个示例的 DataFrame data，其中包含了一个列 ‘A’，并填充了从 1 到 10 的整数。然后，使用 qcut() 函数将 ‘A’ 列的数据分成四个等分的区间，并将结果存储在一个新的列 ‘Group’ 中。
以上示例代码将生成如下的分组结果：
A Group
0 1 (0.999, 3.25]
1 2 (0.999, 3.25]
2 3 (0.999, 3.25]
3 4 (3.25, 5.5]
4 5 (3.25, 5.5]
5 6 (5.5, 7.75]
6 7 (5.5, 7.75]
7 8 (7.75, 10.0]
8 9 (7.75, 10.0]
9 10 (7.75, 10.0]
可以看到，数据根据分位数被划分为四个相等大小的区间，并且每个区间用相应的标签表示。
sales['R_Quartile'] = pd.qcut(df.recency, 4, ['4','3','2','1']).astype('int')
将df.recency四等份，然后赋值为对应的标签，最后将标签转换为整数类型
rank()
count()
import pandas as pd
data = {
'Nowcoder_ID': [1, 2, 3, 4, 5, 6],
'Level': ['Beginner', 'Intermediate', 'Advanced', 'Beginner', 'Intermediate', 'Advanced'],
'Language': ['Python', 'Python', 'Python', 'Java', 'Java', 'Java']
}
# 使用 pd.DataFrame 创建示例 DataFrame
df = pd.DataFrame(data)
count = df.groupby(['Level', 'Language']).Nowcoder_ID.count()
print(count)
使用 groupby 方法按照 ‘Level’ 和 ‘Language’ 列进行分组，并使用 count 方法统计每个分组中 ‘Nowcoder_ID’ 列的数量。
注意，如果指定Nowcoder_ID，count()方法会对所有列都进行count
cumcount()
std()
print(df.column_name.std().round(2)
返回变量的标准差，并保留两位小数
var()
print(df.column_name.var().round(2)
返回变量的方差，并保留两位小数
.str.len()
print(df.column_name.str.len()
计算字符串变量的字符长度， 其中的str不可省去，在 Pandas 中，当你使用 .str 对象对字符串列进行操作时，它会将该列视为类型为 str 的 Pandas Series 对象，而不是普通的对象或整数。.str 提供了一些方便的字符串方法，例如 len() 用于计算字符串长度。
五、数据清洗
dropna()
pandas的dropna()函数的axis参数默认值为0。当axis=0时，表示沿着行方向进行操作，即删除包含缺失值的行。如果希望沿着列方向进行操作，即删除包含缺失值的列，可以将axis参数设置为1。以下是示例代码：
import pandas as pd
# 创建一个包含缺失值的DataFrame
df = pd.DataFrame({'A': [1, 2, None], 'B': [4, None, 6], 'C': [7, 8, 9]})
# 删除包含缺失值的行（默认axis=0）
df1 = df.dropna()
# 删除包含缺失值的列（axis=1）
df2 = df.dropna(axis=1)
删除所有存在缺失值的数据，默认按行，即axis=0
print(df.dropna(how='any')
删除所有存在缺失值得的列变量， 列中存在缺失值，该列直接去除掉
print(df.dropna(axis=1,how='any')
删除行数据，当其Languauge列中存在缺失值
print(df.dropna(axis=0,how='any', subset=['Language'])
筛选后的数据存为副本，默认为False，True表示直接在原数据上 保存
print(df.dropna(axis=0,how='any',inplace=True)
fillna()
fillna() 是 Pandas 中的一个函数，用于填充缺失值（NaN）。
它的语法是：fillna(value=None, method=None, axis=None, inplace=False, limit=None, downcast=None)
常用参数包括：
value：指定要用于填充的值。可以是标量（如 0、‘missing’），也可以是字典、Series 或 DataFrame。默认值为 None。method：指定填充缺失值的方法。常见的方法包括 ‘ffill’（用前一个非缺失值向前填充）、‘bfill’（用后一个非缺失值向后填充）以及 ‘nearest’（用最近的非缺失值填充）。默认值为 None。axis：指定填充的轴方向，可以是 0（行方向）或 1（列方向），或者用字符串 ‘index’（行方向）或 ‘columns’（列方向）。默认为 None，表示沿每个轴填充缺失值。inplace：指定是否在原地修改数据。默认为 False，表示返回填充后的副本。limit：指定连续填充的最大数量。例如，如果设置为 1，则仅填充连续出现的一个缺失值。默认为 None，表示填充所有缺失值。downcast：指定数据类型的下转换。常见的选项包括 ‘infer’（自动推断数据类型），‘integer’（整数类型），‘signed’（有符号整数类型）和 ‘float’（浮点数类型）。默认为 None，表示不进行数据类型下转换。下转换可以用于减少数据的内存占用，提高计算效率。在填充缺失值时，可以通过downcast参数将数据类型下转换为更合适的类型。
以下是几个示例用法：
import pandas as pd
import numpy as np
# 填充Series中的缺失值为0
series = pd.Series([1, np.nan, 3, 4, np.nan])
series_filled = series.fillna(0)
# 填充DataFrame中的缺失值为特定的值
df = pd.DataFrame({'A': [1, np.nan, 3], 'B': [4, np.nan, np.nan]})
df_filled = df.fillna(value={'A': 0, 'B': 'missing'})
# 使用前向填充方法填充缺失值
series_filled_ffill = series.fillna(method='ffill')
# 使用后向填充方法填充缺失值
series_filled_bfill = series.fillna(method='bfill')
# 在列方向上填充DataFrame中的缺失值
df_filled_columns = df.fillna(method='ffill', axis=1)
# 在原地修改DataFrame，填充缺失值为0
df.fillna(0, inplace=True)
# 使用fillna进行缺失值填充，并将数据类型下转换为整数类型
df_filled = df.fillna(0, downcast='integer')
replace()
要实现将男生用 1 替代，女生用 0 替代的操作，可以使用 Pandas 的 replace() 方法来完成。
import pandas as pd
# 创建一个包含性别信息的列的 DataFrame
df = pd.DataFrame({'sex': ['男', '女', '女', '男', '男', '女']})
# 使用 replace() 方法将 '男' 替换为 1，'女' 替换为 0
df['sex'] = df['sex'].replace({'男': 1, '女': 0})
# 查看替换后的 DataFrame
print(df)
在示例中，我们首先创建了一个包含性别信息的 DataFrame，然后使用 replace() 方法将 ‘男’ 替换为 1，‘女’ 替换为 0。替换后，原先的 ‘男’ 和 ‘女’ 被相应的数字替代，并得到了替换后的 DataFrame。
drop_duplicates()
print(df.drop_duplicates())
删除重复的数据，只保留第一个出现的数据
print(df.drop_duplicates(keep=False)
删除重复的数据
print(df.drop_duplicated(inplace=True))
删除重复的数据，保留第一个出现的数据，并保存
sort_values()
print(df.sort_values(['monetarty'], ignore_index=True).head(3))
如果您是想了解有关 sort_values() 函数的参数，sort_values() 是 Pandas 中用于对 DataFrame 或 Series 进行排序的函数。下面是 sort_values() 函数的常用参数：
by：指定用于排序的列或列的列表。默认为单个列名或索引。axis：指定按行还是按列排序。axis=0表示按行排序，axis=1表示按列排序。默认为axis=0。ascending：指定排序的顺序，即升序或降序。默认为True，表示升序排序。inplace：指定是否在原地修改数据，即是否就地进行排序。默认为False，表示返回排序后的副本。kind：指定排序算法的类型。常见的选项包括'quicksort'、'mergesort'和'heapsort'。默认为'quicksort'。na_position：指定缺失值的排序位置。'last'表示将缺失值放在末尾，'first'表示将缺失值放在开头。默认为'last'。
import pandas as pd
# 创建一个包含成绩信息的 DataFrame
df = pd.DataFrame({
'Name': ['Alice', 'Bob', 'Charlie'],
'Math': [80, 90, 75],
'English': [85, 70, 95]
})
# 按照 'Math' 列进行降序排序
df_sorted = df.sort_values(by='Math', ascending=False)
# 查看排序后的 DataFrame
print(df_sorted)
在示例中，我们使用 sort_values() 对成绩信息 DataFrame 按照 ‘Math’ 列进行降序排序。结果显示根据 ‘Math’ 列进行了排序的 DataFrame。
drop()
df.drop(['f','r'], axis=1, inplace=True)
去除多余的变量
reset_index()
df.reset_index(drop=False, inplace=True)
不丢弃原始索引，默认为False， 如果设置为True则丢弃索引，
df.reset_index(drop=True, inplace=True)
丢弃原始索引，并且在本地保存更改
六、分组聚合
groupby()
print(df.groupby('date')['question_id'].count()
对date进行分组，并使用count()方法统计不同组的数量
grouped = df.groupby('date')['question_id'].mean()
对date进行分组，并使用mean聚合函数统计
grouped = df.groupby(['result','date'])
根据date与result进行分组
agg()
聚合函数mean() ，sum()等是内置的聚合函数，可以直接应用与series 或dataframe，通常用于简单聚合计算
对于复杂的聚合计算使用agg()函数更为方便，agg()允许对多个列，进行多种聚合计算，这些聚合函数可以是内置的聚合函数，也可以是自定义的函数。
使用字典传参
grouped = df.groupby(by="Department', as_index=False
group_stats = grouoped.agg({'age':'mean','salary':'sum'})
对分组后的结果的age列变量使用计算其均值，对salary变量计算其总值
使用列表传参
agg_result = df.agg(['mean','sum'])
使用agg()函数对Salary列进行平均值和总合的聚合计算，不对具体的列进行聚合，而是对整个DataFrame计算聚合
agg({'age':'mean','salary':'sum'})适用于针对不同列应用不同聚合函数的情况，提供了更灵活的方式。['mean', 'sum']适用于对整个 DataFrame 或 Series 对象应用多个聚合函数的情况，比如计算数据的平均值和总和。
七、链接
merge
df3 = pd.merge(df1,df2, how='inner', on='user_id')
对数据df1 与df2根据user_id进行内连接
df3 = pd.merge(df1,df2，how='left', on=['user_id', 'date'])
对数据df1与df2根据user_id与date进行左连接
df3 = pd.merge(df1, df2, how='outer', on=['user_id', 'date'])
对数据df1与df2根据user_id与date进行外链接
concat
df3 = pd.concat([df1,df2], axis=0)
沿行垂直方向，合并df1和df2，concat函数的axis参数的默认值是0
df3 = pd.concat([df1,df2], axis=0, ignore_index=True)
忽略原始索引，并生成新的连续索引
八、格式设置
pd.set_option(option,value)
pd.set_option('display.max_columns', 10)
设置显示的最大列数
pd.set_option('display.max_rows',100)
设置显示的最大行数为100
pd.set_option('display.max_rows',None)
不限制显示的最大行数
pd.set_option('display.precision',2)
设置显示浮点数的精度
pd.set_index()
df.set_index('column_name')
df.to_string()
print(df.to_string())
将整个DataFrame以字符串的形式输出，包括所有的行和列数据。
df.to_frame()
print(df.column_name.to_frame.mode())
将以列表的形式输出结果
如果不添加to_frame()
print(df.column_name.mode()
返回的直接是一个数值，或者序列
pd.to_datetime()
df.First_time = pd.to_datetime(df.First_time,format='%Y-%m-%d')
将df.Frist_time转换为指定日期数据
df.First_time = pd.to_datetime(df.First_time)
与上述代码结果相同
df['date1'] = pd.to_datetime(df['date']).dt.date
取年月日
df['date1'] = pd.to_datetime(df['date']).dt.strftime('%Y-%m')
取年月
astype()
astype() 是 Pandas 中的一个函数，用于将 Series 或 DataFrame 中的数据类型转换为指定的数据类型。
它的语法是：astype(dtype, copy=True, errors='raise')
dtype: 指定要转换的目标数据类型，可以是字符串（如 ‘int’, ‘str’）或相应的数据类型对象（如 np.int32, np.float64）。copy：布尔值，指定是否返回数据的副本。默认为 False。errors：指定当无法进行数据类型转换时的处理方式。默认为 ‘raise’，表示遇到错误会抛出异常。其他可选值包括 ‘ignore’（忽略错误，原样返回）、‘coerce’（将无法转换的值替换为缺失值）。
以下是几个示例用法：
series.astype('int')
转换 Series 的数据类型为整数
df['column_name'].astype('float')
转换 DataFrame 中的某一列数据类型为浮点数
df.astype({'column1': 'int', 'column2': 'str'})
转换 DataFrame 的数据类型为字典中指定的数据类型
df.astype('int', copy=True)
转换 DataFrame 的所有列的数据类型为整数（返回副本)
df = df.astype(str)
转换 DataFrame 的所有列的数据类型为字符串（原地修改）
.str
print(df.column_name.str.len()
在 Pandas 中，当你使用 .str 对象对字符串列进行操作时，它会将该列视为类型为 str 的 Pandas Series 对象，而不是普通的对象或整数。.str 提供了一些方便的字符串方法，例如 len() 用于计算字符串长度。
print(df.column_name.str.resplcae('/','-'))
将/ 替换为-
.dt
在 Pandas 中，.dt 是一个用于访问日期时间相关的属性和方法的属性。它可以应用于 Pandas Series 或 DataFrame 的日期时间列，以提取有关日期或时间的信息或执行日期时间操作。
.dt 属性可以与许多常见的日期时间属性和方法一起使用，例如年份（.dt.year）、月份（.dt.month）、日期（.dt.day）、小时（.dt.hour）、分钟（.dt.minute）、秒（.dt.second）等。
下面是一个示例，演示了如何使用 .dt 属性来提取 DataFrame 中的日期时间信息：
import pandas as pd
# 创建一个示例 DataFrame
data = {'date': ['2023-09-30 15:00:00', '2023-10-01 10:30:00', '2023-10-02 18:45:00']}
df = pd.DataFrame(data)
# 将日期时间列转换为 datetime 类型
df['date'] = pd.to_datetime(df['date'])
# 提取日期时间信息
df['year'] = df['date'].dt.year
df['month'] = df['date'].dt.month
df['day'] = df['date'].dt.day
df['hour'] = df['date'].dt.hour
df['minute'] = df['date'].dt.minute
df['second'] = df['date'].dt.second
# 打印结果
print(df)
运行以上代码，会打印出包含提取的日期时间信息的 DataFrame。
.dt 属性还提供了其他一些有用的方法和属性，例如 .dt.weekday 可以返回周几的数字（0-6 对应周一至周日），.dt.date 可以返回日期部分，.dt.time 可以返回时间部分等。
九、时间函数
pd.to_datetime()
df.First_time = pd.to_datetime(df.First_time,format='%Y-%m-%d')
将df.Frist_time转换为指定日期数据
df.First_time = pd.to_datetime(df.First_time)
与上述代码结果相同
df['date1'] = pd.to_datetime(df['date']).dt.date
取年月日
df['date1'] = pd.to_datetime(df['date']).dt.strftime('%Y-%m')
取年月
.dt
在 Pandas 中，.dt 是一个用于访问日期时间相关的属性和方法的属性。它可以应用于 Pandas Series 或 DataFrame 的日期时间列，以提取有关日期或时间的信息或执行日期时间操作。
.dt 属性可以与许多常见的日期时间属性和方法一起使用，例如年份（.dt.year）、月份（.dt.month）、日期（.dt.day）、小时（.dt.hour）、分钟（.dt.minute）、秒（.dt.second）等。
下面是一个示例，演示了如何使用 .dt 属性来提取 DataFrame 中的日期时间信息：
import pandas as pd
# 创建一个示例 DataFrame
data = {'date': ['2023-09-30 15:00:00', '2023-10-01 10:30:00', '2023-10-02 18:45:00']}
df = pd.DataFrame(data)
# 将日期时间列转换为 datetime 类型
df['date'] = pd.to_datetime(df['date'])
# 提取日期时间信息
df['year'] = df['date'].dt.year
df['month'] = df['date'].dt.month
df['day'] = df['date'].dt.day
df['hour'] = df['date'].dt.hour
df['minute'] = df['date'].dt.minute
df['second'] = df['date'].dt.second
# 打印结果
print(df)
运行以上代码，会打印出包含提取的日期时间信息的 DataFrame。
.dt 属性还提供了其他一些有用的方法和属性，例如 .dt.weekday 可以返回周几的数字（0-6 对应周一至周日），.dt.date 可以返回日期部分，.dt.time 可以返回时间部分等。
pd.Timedelta()
pd.Timedelta:pd.Timedelta是一个构造函数，用于直接创建一个时间间隔对象。你可以使用pd.Timedelta创建一个指定时间间隔的对象，例如pd.Timedelta(days=3, hours=4)表示 3 天 4 小时的时间间隔。这个函数通常用于在代码中直接创建时间间隔对象。
df['date'] = df['date'] + pd.Timedelt(days=1)
将data 日期加上一天
df['new_date'] = pd.date - pd.Timedelta(weeks=2)
在日期上减去 两 周的时间间隔
timedelta1 = pd.Timedelta(days=1)
创建一个时间间隔为 1 天的 Timedelta 对象
timedelta2 = pd.Timedelta(hours=2)
创建一个时间间隔为 2 小时的 Timedelta 对象
timedelta3 = pd.Timedelta(minutes=30)
创建一个时间间隔为 30 分钟的 Timedelta 对象
pd.to_timedelta()
-
pd.Timedelta和pd.to_timedelta都是 Pandas 中用于处理时间间隔的函数，但它们在用法和功能上有一些区别。 -
pd.to_timedelta:pd.to_timedelta是一个函数，用于将传入的字符串或列表转换为时间间隔。它可以从不同的时间间隔表示形式中解析字符串，并返回对应的时间间隔对象。例如，你可以使用pd.to_timedelta('3 days 4 hours')来将字符串转换为一个表示 3 天 4 小时的时间间隔对象。这个函数通常用于从外部数据源（如 CSV 文件）中读取时间间隔数据，并将其转换为 Pandas 的时间间隔对象。其中的字符串比较灵活，即使不是复数的day也能够进行识别
td1 = pd.to_timedelta('3 days 4 hours')
td2 = pd.to_timedelta(df.groupby(['user_id']).date.rank(), unit='day')
根据user_id进行分组，并对date进行排序，将排序结果用to_tiemdelta进行转换为days实践格式
十、数据透视图
unstack()
在 Pandas 中，unstack 函数默认解除堆叠最内层的索引级别。如果没有指定 level 参数，它将默认使用最内层的索引级别。
import pandas as pd
data = {
'A': ['foo', 'foo', 'foo', 'bar', 'bar', 'bar'],
'B': ['one', 'one', 'two', 'two', 'one', 'one'],
'C': ['x', 'y', 'x', 'y', 'x', 'y'],
'D': [1, 2, 3, 4, 5, 6],
'E': [7, 8, 9, 10, 11, 12]
}
df = pd.DataFrame(data).set_index(['A', 'B', 'C'])
# 将最内层的索引级别解除堆叠，转换为列
result = df.unstack()
print(result)
我们设置了一个 DataFrame df，并使用 set_index 函数将列 “A”、“B” 和 “C” 设置为层次化索引。然后，我们调用 unstack 函数，将最内层的索引级别解除堆叠并转换为列。最后，打印转换后的结果。
执行以上代码，输出结果将是一个二维表格，其中最内层的索引级别（“C” 列）被解除堆叠，转换为了列。也就是最右边的列。
print(df.unstack(level=0))
当设置unstack的参数level为0时，将会把最外层的索引列解除堆叠，转换为列
import pandas as pd
df1 = pd.read_csv('items.csv')
df2 = pd.read_csv('signup.csv')
df3 = df1.merge(df2, how='left', on='item_id')
print(df3.groupby(['sex','department','item_name'])[['employee_id'].count().astype('int8'))
牛客上的题，做出关于sex和department关于不同item_name的参赛人数
pivot_table()
pivot_table() 是 Pandas 中的一个函数，用于根据一个或多个键对数据进行透视操作。
它的基本语法是：pivot_table(data, values=None, index=None, columns=None, aggfunc='mean', fill_value=None, margins=False, dropna=True)
下面解释一下常用的参数：
data：要进行透视操作的 DataFrame 对象。values：可选参数，用于指定透视表中的值列，可以是单个列名，或由多个列名组成的列表。index：可选参数，用于指定透视表中的行索引，可以是单个列名，或由多个列名组成的列表。columns：可选参数，用于指定透视表中的列索引，可以是单个列名，或由多个列名组成的列表。aggfunc：可选参数，用于指定在生成透视表时要应用的聚合函数，默认为 ‘mean’（计算平均值），也可以是其他多种内置聚合函数（如 ‘sum’、‘count’、‘min’、‘max’ 等），或用户自定义的聚合函数。fill_value：可选参数，用于指定用于填充缺失值的值。margins：可选参数，是否在透视表中包含汇总统计行和列。默认为 False。dropna：可选参数，是否在透视表中排除所有包含缺失值的行。默认为 True。
示例用法如下：
import pandas as pd
# 创建一个包含商品销售信息的 DataFrame
df = pd.DataFrame({
'Date': ['2019-01-01', '2019-01-02', '2019-01-01', '2019-01-02'],
'Product': ['A', 'A', 'B', 'B'],
'Category': ['Furniture', 'Electronics', 'Furniture', 'Electronics'],
'Sales': [100, 200, 150, 300]
})
# 使用 pivot_table 创建透视表
pivot_df = df.pivot_table(values='Sales', index=['Product', 'Category'], columns='Date', aggfunc='sum')
# 查看透视表
print(pivot_df)
在示例中，我们使用 pivot_table() 对销售信息 DataFrame 进行透视操作。设置 values='Sales' 表示以 ‘Sales’ 列为值列，index=['Product', 'Category'] 表示以 ‘Product’ 和 ‘Category’ 列为行索引，columns='Date' 表示以 ‘Date’ 列为列索引，aggfunc='sum' 表示计算每个单元格的和作为聚合函数。
1288
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
