Pandas中Concat与Append_Python数据分析与可视化

在Numpy中,我们介绍过可以用np.concatenatenp.stacknp.vstacknp.hstack实现合并功能。Pandas中有一个pd.concat()函数与concatenate语法类似,但是配置参数更多,功能也更强大。

主要参数:
在这里插入图片描述


pd.concat()可以简单地合并一维的SeriesDataFrame对象。

# Series合并
ser1 = pd.Series(['A', 'B', 'C'], index=[1, 2, 3])
ser2 = pd.Series(['D', 'E', 'F'], index=[4, 5, 6])
pd.concat([ser1,ser2])
Out:
 1 A 
 2 B 
 3 C 
 4 D 
 5 E 
 6 F 
 dtype: object
 
# DataFrame合并,将concat的axis参数设置为1即可横向合并
df1 = pd.DataFrame([["A1","B1"],["A2","B2"]],index=[1,2],columns=["A","B"])
df2 = pd.DataFrame([["A3","B3"],["A4","B4"]],index=[3,4],columns=["A","B"])
pd.concat([df1,df2])
Out:
    A  B
 1 A1 B1 
 2 A2 B2 
 3 A3 B3 
 4 A4 B4

合并时索引的处理

np.concatenate与pd.concat最主要的差异之一就是Pandas在合并时会保留索引,即使索引是重复的!

df3 = pd.DataFrame([["A1","B1"],["A2","B2"]],index=[1,2],columns=["A","B"])
df4 = pd.DataFrame([["A1","B1"],["A2","B2"]],index=[1,2],columns=["A","B"])
pd.concat([df3,df4])
Out:
    A  B
 1 A1 B1 
 2 A2 B2 
 1 A3 B3 
 2 A4 B4

  1. 如果你想要检测pd.concat()合并的结果中是否出现了重复的索引,可以设置verify_integrity参数。将参数设置为True,合并时若有索引重复就会触发异常。
try: 
 pd.concat([df3, df4], verify_integrity=True) 
except ValueError as e: 
 print("ValueError:", e)
Out:
ValueError: Indexes have overlapping values: [0, 1]

  1. 有时索引无关紧要,那么合并时就可以忽略它们,可以通过设置 ignore_index参数为True来实现。
pd.concat([df3,df4],ignore_index=True)
Out:
   A B 
0 A0 B0 
1 A1 B1 
2 A2 B2 
3 A3 B3

  1. 另一种处理索引重复的方法是通过keys参数为数据源设置多级索引标签,这样结果数据就会带上多级索引。
pd.concat([df3, df4], keys=['x', 'y'])
Out:
     A B 
x 0 A0 B0 
  1 A1 B1 
y 0 A2 B2 
  1 A3 B3

join和join_axes参数

前面介绍的简单示例都有一个共同特点,那就是合并的DataFrame都是同样的列名。而在实际工作中,需要合并的数据往往带有不同的列名,而 pd.concat提供了一些参数来解决这类合并问题。

df5 = pd.DataFrame([["A1","B1","C1"],["A2","B2","C2"]],index=[1,2],columns=["A","B","C"])
df6 = pd.DataFrame([["B3","C3","D3"],["B4","C4","D4"]],index=[3,4],columns=["B","C","D"])
pd.concat([df5,df6])
Out:
    A  B  C  D
 1 A1  B1 C1 NaN
 2 A2  B2 C2 NaN
 3 NaN B3 C3 D3
 4 NaN B4 C4 D4

可以看到,结果中出现了缺失值,如果不想出现缺失值,可以使用join和join_axes参数。

pd.concat([df5,df6],join="inner") # 合并取交集
Out:
    B C 
 1 B1 C1 
 2 B2 C2 
 3 B3 C3 
 4 B4 C4
# join_axes的参数需为一个列表索引对象
pd.concat([df5,df6],join_axes=[pd.Index(["B","C"])])
Out:
    B C 
 1 B1 C1 
 2 B2 C2 
 3 B3 C3 
 4 B4 C4

append()方法

因为直接进行数组合并的需求非常普遍,所以SeriesDataFrame 对象都支持append方法,让你通过最少的代码实现合并功能。例如,df1.append(df2)效果与pd.concat([df1,df2])一样。
但是它和Python中的append不一样,每次使用Pandas中的append()都需要重新创建索引和数据缓存。

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
下面是一个使用Transformer模型预测并可视化时间序列数据的Python代码示例: ```python import torch import torch.nn as nn import torch.optim as optim import numpy as np import pandas as pd from sklearn.preprocessing import MinMaxScaler import matplotlib.pyplot as plt # 数据预处理 data = pd.read_csv('data.csv') scaler = MinMaxScaler(feature_range=(-1, 1)) data['scaled'] = scaler.fit_transform(data['value'].values.reshape(-1, 1)) training_data = data['scaled'].values # 定义超参数 input_size = 24 output_size = 12 num_epochs = 100 learning_rate = 0.0001 # 定义Transformer模型 class TransformerModel(nn.Module): def __init__(self, input_size, output_size): super(TransformerModel, self).__init__() self.transformer = nn.Transformer(d_model=input_size, nhead=2, num_encoder_layers=2, num_decoder_layers=2) self.fc = nn.Linear(input_size, output_size) def forward(self, input): input = input.unsqueeze(0) output = self.transformer(input, input) output = self.fc(output.squeeze(0)) return output # 训练模型 model = TransformerModel(input_size, output_size) criterion = nn.MSELoss() optimizer = optim.Adam(model.parameters(), lr=learning_rate) for epoch in range(num_epochs): for i in range(len(training_data) - input_size - output_size): input_seq = training_data[i:i+input_size] output_seq = training_data[i+input_size:i+input_size+output_size] input_tensor = torch.FloatTensor(input_seq).view(-1, 1, input_size) output_tensor = torch.FloatTensor(output_seq).view(-1, 1, output_size) optimizer.zero_grad() predicted_output = model(input_tensor) loss = criterion(predicted_output, output_tensor) loss.backward() optimizer.step() print('Epoch: {}, Loss: {:.5f}'.format(epoch+1, loss.item())) # 预测 model.eval() with torch.no_grad(): future = 12 input_seq = training_data[-input_size:] predicted_outputs = [] for i in range(future): input_tensor = torch.FloatTensor(input_seq).view(-1, 1, input_size) predicted_output = model(input_tensor) predicted_outputs.append(predicted_output.squeeze().item()) input_seq = np.append(input_seq[1:], predicted_output.squeeze().item()) # 可视化预测结果 predicted_outputs = scaler.inverse_transform(np.array(predicted_outputs).reshape(-1, 1)) data_pred = data.iloc[-12:].copy() data_pred['value'] = predicted_outputs data_pred['scaled'] = scaler.fit_transform(data_pred['value'].values.reshape(-1, 1)) # 将原始数据和预测数据合并 data_all = pd.concat([data, data_pred], ignore_index=True) data_all = data_all[['timestamp', 'value']] # 可视化所有数据 plt.figure(figsize=(10, 6)) plt.plot(data_all['timestamp'][0:len(data)], data_all['value'][0:len(data)], label='Original data') plt.plot(data_all['timestamp'][len(data):], data_all['value'][len(data):], label='Predicted data') plt.xlabel('Time') plt.ylabel('Value') plt.legend() plt.show() ``` 这个代码示例使用了PyTorch深度学习库的Transformer模型来预测时间序列数据,并将预测结果可视化出来。代码首先对原始数据进行了归一化处理,然后定义了一个Transformer模型类,其包含了一个Transformer层和一个全连接层。接着使用MSELoss作为损失函数,Adam优化器作为优化器来训练模型。在训练完成后,使用模型来预测未来12个时间步长的数据,并将预测结果和原始数据合并,最后将所有数据可视化出来。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

阿松爱睡觉

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值