2

我有一个包含卡车配置的长文本文件。在每一行中，卡车的一些属性被列为字符串。每个属性在字符串中都有自己的固定宽度空间，例如：

2 chracters = number of axles
2 characters = weight of the first axle
2 characters = weight of the second axle
...
2 characters = weight of the last axle
2 characters = length of the first axle spacing (spacing means distance between axles)
2 characters = length of the second axle spacing
...
2 characters = length of the last axle spacing

举个例子：

031028331004

指：

number of axles = 3
first axle weight = 10
second axle weight = 28
third axle weight = 33
first spacing = 10
second spacing = 4

现在，您对我的文件结构有所了解，这是我的问题：我想将这些卡车分组到单独的列表中，并根据轴距命名列表。假设我正在使用布尔类型的方法，如果间距小于 6，则布尔值为 1，如果大于 6，则布尔值为 0。为了澄清，三轴卡车的可能结果变为：

00 #Both spacings > 6
10 #First spacing < 6, second > 6
01 #First spacing > 6, second < 6
11 #Both spacings < 6

现在，正如您所见，对于 3 轴卡车来说，结果并不多。但是，如果我有一辆 12 轴卡车，“可能”组合的数量就会变得混乱。问题是，实际上您不会在 12 轴卡车中看到所有“可能”的轴距组合。有某些组合（我不知道是哪些，但弄清楚是我的目标）的数量远少于“可能的”组合数量。

如果仅存在这样的组合，我希望代码创建列表并用定义我上面提到的属性的字符串填充它们。我想也许我应该创建带有变量名的列表，例如：

truck_0300[]
truck_0301[]
truck_0310[]
truck_0311[]

在飞行中。但是，根据我在 SF 和其他来源中阅读的内容，强烈建议不要这样做。您将如何使用字典概念来做到这一点？我知道字典就像二维数组，有一个键（在我的情况下，键可能是 truck_0300、truck_0301 等）和值对（在我的情况下，值可能是包含实际字符串的列表属于相应的卡车类型），但是我不知道如何创建该字典，并用变量键和值填充它。

欢迎任何见解！非常感谢！

4

3 回答 3

5

您绝对正确，尝试在范围内创建“动态变量”几乎总是一个坏主意。字典通常是随着时间的推移建立对象集合并引用它们的答案......

我不完全理解您的应用程序和格式，但通常定义和使用您的字典看起来像这样：

trucks = {}
trucks['0300'] = ['a']
trucks['0300'].append('c')
trucks['0300'].extend(['c','d'])

aTruck = trucks['0300']

现在因为每一个都应该是你的字符串列表，你可能只想使用一个 defaultdict，并告诉它使用一个列表作为不存在键的默认值：

from collections import defaultdict

trucks = defaultdict(list)
trucks['0300']
# []

请注意，即使它是一个不包含任何条目的全新字典，“truck_0300”键仍会返回一个新列表。这意味着您不必检查密钥。只需附加：

trucks = defaultdict(list)
trucks['0300'].append('a')

Adefaultdict可能是您想要的，因为您根本不必预先定义键。当您准备好时，它就在那里。

获取最大值的键

根据您的评论，这是一个如何获取具有字典最大值的键的示例。这很容易，因为您只需使用max并定义它应该如何确定用于比较的密钥：

d = {'a':10, 'b':5, 'c':50}
print max(d.iteritems(), key=lambda (k,v): v)
# ('c', 50)
d['c'] = 1
print max(d.iteritems(), key=lambda (k,v): v)
# ('a', 10)

您所要做的就是定义如何生成比较键。在这种情况下，我只是告诉它以值作为键。对于像这样非常简单的关键函数，您只是告诉它从对象中提取索引或属性，您可以通过使用operator模块来提高效率，以便关键函数在 C 中而不是在 python 中作为 lambda：

from operator import itemgetter
...
print max(d.iteritems(), key=itemgetter(1))
#('c', 50)

itemgetter创建一个新的可调用对象，它将从循环传入的元组中提取第二项。

现在假设每个值实际上是一个列表（类似于您的结构）。我们将使它成为一个数字列表，并且您想要找到具有最大总数的列表的键：

d = {'a': range(1,5), 'b': range(2,4), 'c': range(5,7)}
print max(d.iteritems(), key=lambda (k,v): sum(v))
# ('c', [5, 6])
于 2012-11-29T00:10:34.517 回答
1

如果密钥的数量超过 10,000，那么这种方法是不可行的。否则定义一个字典 d = {} 并在你的行上循环：

key = line[:4]
if not key in d.keys():
    d[key] = []
d[key] += [somevalue]

我希望这有帮助。

于 2012-11-29T00:13:21.870 回答
0

这是从字符串到输出的完整解决方案：

from collections import namedtuple, defaultdict

# lightweight class
Truck = namedtuple('Truck', 'weights spacings')

def parse_truck(s):
    # convert to array of numbers
    numbers = [int(''.join(t)) for t in zip(s[::2], s[1::2])]

    # check length
    n = numbers[0]
    assert n * 2 == len(numbers)
    numbers = numbers[1:]

    return Truck(numbers[:n], numbers[n:])

trucks = [
    parse_truck("031028331004"),
    ...
]

# dictionary where every key contains a list by default
trucks_by_spacing = defaultdict(list)

for truck in trucks:
    # (True, False) instead of '10'
    key = tuple(space > 6 for space in truck.spacings)
    trucks_by_spacing[key].append(truck)

print trucks_by_spacing

print trucks_by_spacing[True, False]
于 2012-11-29T00:19:58.893 回答