Python 自动转换为新数据-熊猫

我是python的新手，我在StackOverflow中搜索我的案例，但找不到技术上的答案。我有很多的B排

我的问题是这样的，我有一个

数据帧

：

df
BS          N
BS1 - BS5   1
BS2 - BS7   2
BS1 - BS9   2
BS9 - BS1   1

我想自动生成新数据。我的预期结果如下：

New_BS  BS1 - BS5   BS2 - BS7   BS1 - BS9   BS9 - BS1   Total
BS1-2       1                       2                     3
BS2-3       1           2           2                     5
BS3-4       1           2           2                     5
BS4-5       1           2           2                     5
BS5-6                   2           2                     4
BS6-7                   2           2                     4
BS7-8                               2                     2
BS8-9                               2                     2
BS9-8                                            1        1
BS8-7                                            1        1
BS7-6                                            1        1
BS6-5                                            1        1
BS5-4                                            1        1
BS4-3                                            1        1
BS3-2                                            1        1
BS2-1                                            1        1

---

提前感谢您帮助我

好吧-这是一个彻底的黑客-但很有趣

import pandas as pd
import numpy as np

df = df_flat = pd.DataFrame({"BS": ['BS1 - BS5', 'BS2 - BS7', 'BS1 - BS9', 'BS9 - BS1'],
                   "N" : [1, 2, 2, 1]})

df = df.pivot(columns='BS',
              values='N')

df_flat = df_flat.pivot_table(
              columns='BS',
              values='N')

for column_name, column in zip(list(df), df):
    if int(column[2:3]) < int(column[8:9]):
        for stop in range(int(column[2:3]), int(column[8:9])):
            index = "BS" + str(stop) + "-" + str(stop + 1)
            if index not in list(df.index.values):
                df.loc[index] = np.nan
            df.loc[index, column] = df_flat.loc['N', column]
    else:
        for stop in range(int(column[2:3]), int(column[8:9]), -1):
            index = "BS" + str(stop) + "-" + str(stop - 1)
            if index not in list(df.index.values):
                df.loc[index] = np.nan
            df.loc[index, column] = df_flat.loc['N', column]

df['Total'] = df.sum(axis=1)

df = df.iloc[len(list(df_flat)):]

print(df.fillna(''))

有大约1000种方法可以改进这一点-但这是一个好的开始

---

请注意，切片是对数据集的一个非常重要的约束--您必须真正地重新编写它以使其具有动态性

我一点也不清楚你是怎么弄到这些争吵的。

BS7-8

和

BS7-5

的区别是什么？例如，关于从一个公共汽车站到另一个公共汽车站（BS）有多少人的数据。。。BS7-8是指从7号到8号公共汽车站。BS7-5表示从BS7转到BS5的人。

BS

中的数据总是相同的格式吗？车站总是从1点到9点吗？这可能是不可能的，如果不知道如何反复通过公交车站。例如，当

BS1-BS9

按顺序运行时，您如何知道从

BS9-BS1

运行涉及

BS9->BS7->BS5->BS4

。在这种情况下，我想知道从BS1移动到BS9的人是否经过每一站的巴士。那么从BS9到BS1的人呢？这似乎不符合同样的模式。很好的方式，，，提前谢谢你。。如果我的数据

BS N1 N2 N3

，你将不得不基于上述代码为每个级别添加另一个迭代-但是可能有更好的方法来实现更好的定义的工作区。非常感谢你的想法，，，，对我来说有很大的洞察力

$ python bus.py
BS    BS1 - BS5 BS1 - BS9 BS2 - BS7 BS9 - BS1  Total
BS1-2         1         2                        3.0
BS2-3         1         2         2              5.0
BS3-4         1         2         2              5.0
BS4-5         1         2         2              5.0
BS5-6                   2         2              4.0
BS6-7                   2         2              4.0
BS7-8                   2                        2.0
BS8-9                   2                        2.0
BS9-8                                       1    1.0
BS8-7                                       1    1.0
BS7-6                                       1    1.0
BS6-5                                       1    1.0
BS5-4                                       1    1.0
BS4-3                                       1    1.0
BS3-2                                       1    1.0
BS2-1                                       1    1.0