使用Python中的类初始化对数据表中的条目进行累积样式计算

我试图使用Python确定数据表中Z的最佳值。当Y值的差值大于10时，出现Z的最佳值。在我的代码中，我将每个条目的元素分配到一个类中。因此，为了确定最佳值，我需要访问先前计算的Y值，并从新值中减去它。这对我来说似乎很麻烦，所以如果你知道更好的方法，我可以执行这些类型的计算，请让我知道。我的示例数据表是：

X       Y       Z

1       5       10
2       3       20
3       4       30
4       6       40
5       12      50
6       12      60
7       34      70
8       5       80

到目前为止，我的代码是：

class values:                                      
    def __init__(self, X, Y, Z): 

        self.X = X
        self.Y = Y
        self.Z = Z  

        #Diff = Y2 - Y1

        #if Diff > 10:
            #optimum = Z
        #else:
            #pass

        #optimum 

valueLst = []

f = open('sample.txt','r')


for i in f:
    X = i.split('\t')[0]
    Y = i.split('\t')[1]
    Z = i.split('\t')[2]

    x = values(X,Y,Z)

valueLst.append(x)

下表显示了我希望实现的操作示例。Y值的差值在第三列中计算，当差值为22时，我想返回Z值，即Z值为70

1       2               10
2       3       1       20
3       4       1       30
4       6       2       40
5       12      6       50
6       12      0       60
7       34      22      70
8       35      1       80

---

任何帮助都将不胜感激

A

类

在这方面似乎有些过分。为什么不列出

（x，y，z）

元组

valueLst = []
for i in f:
    valueLst.append(tuple(i.split('\t')))

然后，您可以确定

y

值之间的差异，并从对应于最大delta-

y

的三元组中获取最后一项

z

：

yDiffs = [0] + list(valueLst[i][1] - valueLst[i-1][1]
                    for i in range(1, len(valueLst)))
bestZVal = valueLst[yDiffs.index(max(yDiffs))][2]

---

首先，可以将列放入列表数据结构中：

f = open('sample.txt','r')

x, y, z = [], [], []
for i in f:
    ix, iy, iz = map(int, i.split('\t')) # the map function changes each number
                                         # to an integer from a string
    y.append(iy)
    z.append(iz)

当您拥有数据结构时，您可以将它们一起使用以获得所需的其他数据结构

然后，您可以从第二个y开始获得每个差异：

differences  = [y[i] - y[i+1] for i in range(1,len(y))]

您想要的是z与最大差值的索引相同，因此：

maxIndex = y.index(max(differences))
answer = z[maxIndex]

---

给定包含此内容的文件：

1       5       10
2       3       20
3       4       30
4       6       40
5       12      50
6       12      60
7       34      70
8       5       80

您可以读取该文件并将其转换为元组列表，如下所示：

data=[]
with open('value_list.txt') as f:
    for line in f:
        x,y,z=map(int,line.split())
        data.append((x,y,z))

print(data)        

印刷品：

[(1, 5, 10), (2, 3, 20), (3, 4, 30), (4, 6, 40), (5, 12, 50), (6, 12, 60), (7, 34, 70), (8, 5, 80)]

然后，您可以使用该数据通过列表来查找满足条件的元组。在这种情况下

y-之前的y>10

：

tgt=10     
print([data[i][2]  for i in range(1,len(data)) if data[i][1]-data[i-1][1]>tgt])
[70]

---

跳过元组x、y和z的构建

diffs = [curr-prev for curr, prev in izip(islice(y, 1, None), islice(y, len(y)-1))]
max_diff = max(diffs)
Z = y[diffs.index(max_diff)+1]

---

他们不是在寻找

x

和

y

之间的区别，而是在这

y

和前一行的

y

之间。如果您确实必须有一个用于存储XYZ元组的类，请使用

Value=collections.namedtuple（'Value'，x y z'）

，但是我认为在这里使用

namedtuple

而不是

tuple

并没有什么好处；这里的nameduple增加了不必要的参考开销。很抱歉回复得太晚，但非常感谢。我正在使用的表要大得多（大约1000行，共6列），您认为这是处理这样的大型数据集的最有效的方法吗？1000*6在总体方案中并不多，我希望这个过程花费很少的时间来找到合适的

z

，而不是

差异=[y[I]-y[i+1]对于范围（1，len（y））]内的i

，使用中的

itertools成对

配方。此代码变为

差异=[a-b为a，b为成对（y）]

（或使用

imap（operator.subtract，pairwise（y））

）当您需要元素和索引时，使用enumerate；使用range迭代列表是非常不符合Python的