如何在 Python 中初始化和填充列表列表？

Question

我正在尝试将单词对象（由扫描的单词、其按字母顺序排列的版本及其长度组成）按长度排序到列表中。因此，我初始化了一个长度为 0 的列表，并在浏览输入文件时对其进行了扩展。我想在列表中创建一个列表，以便我的结果 [5] 包含长度为 5 的列表。我该怎么做？

我首先将我的列表初始化如下：

results = []

然后我逐行扫描输入文件，创建临时对象，并希望将它们放入相应的列表中：

try:    #check if there exists an array for that length
    results[lineLength]
except IndexError:  #if it doesn't, create it up to that length
    # Grow the list so that the new highest index is len(word)
    difference = len(results) - lineLength
    results.extend([] for _ in range(difference))
finally:
    results[lineLength].append(tempWordObject)  

我觉得以下至少一项需要修改

(1) 我初始化结果列表的方式 (2) 我将对象附加到列表的方式 (3) 我扩展列表的方式（虽然我认为那部分是对的）

我正在使用 Python 3.4。

编辑：

from sys import argv
main, filename = argv
file = open(filename)
for line in file:           #go through the file
    if line == '\n':        #if the line is empty (aka end of file), exit loop
        break
    lineLength = (len(line)-1)  #get the line length 
    line= line.strip('\r\n')

    if lineLength > maxL:       #keeps track of length of longest word encountered
        maxL = lineLength

    #note: I've written a mergesort algorithm in a separate area in the code and it works 
    tempAZ = mergesort(line)    #mergesort the word into alphabetical order
    tempAZ = ''.join(tempAZ)    #merges the chars back together to form a string

    tempWordObject = word(line,tempAZ,lineLength) #creates a new word object

    try:    #check if there exists an array for that length
        results[lineLength]
    except IndexError:  #if it doesn't, create it up to that length
        # Grow the list so that the new highest index is len(word)
        difference = len(results) - lineLength
        results.extend([] for _ in range(difference))
        print("lineLength: ", lineLength, "    difference:", difference)
    finally:
        results[lineLength].append(tempWordObject)    

编辑：

这是我的单词类：

class word(object): #object class

    def __init__(self, originalWord=None, azWord=None, wLength=None):
        self.originalWord = originalWord
        self.azWord = azWord
        self.wLength = wLength

编辑：

这里是对我想要实现的目标的说明：当我遍历一个（长度未知的）单词列表（长度也未知）时，我正在创建包含单词的单词对象，它按字母顺序排列版本及其长度（例如 dog、dgo、3）。当我浏览该列表时，我希望所有对象都进入另一个列表 (results[]) 中的列表，该列表由单词的长度索引。如果 results[] 不包含这样的索引（例如 3），我想扩展 results[] 并在 results[3] 中启动一个列表，其中包含单词 object（dog、dgo、3）。最后，results[] 应该包含按长度索引的单词列表。

Answer 1

你可以有一本字典，而不是一个列表：

d = {}

这里的键是长度，值是单词列表：

if linelength not in d:
    d[linelength] = []
d[linelength].append(tempWordObject)

您可以使用d = collections.defaultdict(list) 进一步简化。

Answer 2

你的差异是负面的。你需要反过来减去。您还需要添加一个额外的索引，因为索引从 0 开始

difference = lineLength - len(results) + 1

事实证明，为此使用defaultdict 通常更容易

例如：

from collections import defaultdict
D = defaultdict(list)
for tempWordObject in the_file:
    D[len(tempWordObject)].append(tempWordObject)

Answer 3

关于您的问题的三个注意事项。

1. 嵌套列表初始化

   您在问题标题中提到了它，尽管您最终可能不需要它。一种简单的方法是使用两个嵌套的list comprehensions：

   import pprint
   
   m, n = 3, 4  # 2D: 3 rows, 4 columns
   lol = [[(j, i) for i in range(n)] for j in range(m)]
   
   pprint.pprint(lol)
   # [[(0, 0), (0, 1), (0, 2), (0, 3)],
   #  [(1, 0), (1, 1), (1, 2), (1, 3)],
   #  [(2, 0), (2, 1), (2, 2), (2, 3)]]
   

2. 使用一些默认的数据结构

   正如其他人指出的那样，您可以使用字典。特别是，collections.defaultdict 将为您提供按需初始化：

   import collections
   
   dd = collections.defaultdict(list)
   
   for value in range(10):
       dd[value % 3].append(value)
   
   pprint.pprint(dd)
   # defaultdict(<type 'list'>, {0: [0, 3, 6, 9], 1: [1, 4, 7], 2: [2, 5, 8]})
   

3. 比较自定义对象

   内置的sorted 函数采用关键字参数key，可用于比较自定义对象，这些对象本身不提供排序钩子：

   import operator
   
   class Thing:
       def __init__(self, word):
           self.word = word
           self.length = len(word)
   
       def __repr__(self):
           return '<Word %s>' % self.word
   
   things = [Thing('the'), Thing('me'), Thing('them'), Thing('anybody')]
   print(sorted(things, key=lambda obj: obj.length))
   # [<Word me>, <Word the>, <Word them>, <Word anybody>] 
   

Answer 4

如果您打算使用列表（这可能不是最佳选择），我认为从一开始就创建尽可能大的列表会更容易、更清晰。也就是说，如果最长的单词是 5 个字符，那么你首先创建这个列表：

output = [None, [], [], [], [], []]

这样做的好处是您不必担心在执行过程中发现异常，但它确实要求您在开始之前了解所有单词。由于您创建了一个对象类来存储所有这些，我假设您实际上存储了所有这些，所以这应该不是问题。

您总是需要在开头使用None，以便索引匹配。一旦你有了这个，你就可以遍历你的单词列表，然后像你已经做的那样简单地将它附加到适当的列表中。

for word in wordlist:
    output[len(word)].append(word)

---

因此，特别是对您而言，我要做的不是存储tempWordObject，而是在您处理文件时列出这些对象的列表(wordObjList)。完成文件后，关闭句柄，然后继续进行其余的处理。

生成模板列表：

output = [None]
for i in range(maxLen):
    output.append([])

从word 对象列表中填写列表

for wordObj in wordObjList:
    output[wordObj.wLength].append(wordObj.originalWord)

---

其他一些注意事项：

• 您无需处理文件末尾的问题。当Python在for循环中到达文件末尾时，会自动停止迭代

• 始终确保关闭文件。您可以使用with 构造来执行此操作（with open("file.txt", 'r') as f: for line in f:）

Answer 5

您拒绝接受建议将您的对象存储在字典中的答案。但是，您真正的问题是您想将包含扫描图像的 600 万个单词放入内存中。使用索引（或某种简单的引用）并将它们跟踪到您的结构中，然后根据它们查找您的数据。使用迭代器检索您需要的信息。