Python 使用列表理解；“合并”；列表中的列表

所以我在一个列表中有一个列表：

woot = [['abc','efg', '4.3', '5.7', '80085'],['aba','bab', '1.0', '9.0', '3.0'], ... , ... ]

每个嵌套列表都是相同的：前两个元素是由字母组成的字符串，其余的是由数字组成的字符串

我试图将所有字符串编号转换为浮点数，并将每个嵌套列表的字符串编号合并到其自己的列表中（最终为双嵌套列表），因此最终结果如下所示：

final = [['abc','efg', [ 4.3, 5.7, 80085]], ['aba','bab', [ 1.0, 9.0, 3.0]] , ... , ... ]

因此，我的方法是使用列表理解将字符串数字转换为浮点数，然后将这些数字和字母字符串拆分成单独的列表并合并它们

bloop = [[float(x) for x in y[2:]] for y in woot]

bleep = [[x for x in y[:2]] for y in woot]

因此，我最终得出以下结论：

bloop = [[ 4.3, 5.7, 8005.0],[ 1.0, 9.0, 3.0], ... , ... ]
bleep = [['abc','efg'],['aba','bab'], ... , ... ]

这里是我崩溃的地方，我似乎无法集中精力“合并”这些列表

final = []
for i in bleep:
    final.append(i)
for i in bloop:
    final.append(i)

不幸的是，这只是将列表放在一起：

[['abc','efg'],['aba','bab'],[ 4.3, 5.7, 8005.0],[ 1.0, 9.0, 3.0]]

那么：

final = [x[:2] + [[float(f) for f in x[2:]]] for x in woot]

简化您的逻辑：

final = []
for l in woot:
    adjusted = l[:2]
    adjusted.append( [float(x) for x in l[2:]] )
    final.append(adjusted)

---

调试的难度是编写代码的两倍。 因此，如果您尽可能巧妙地编写代码，那么 定义，没有足够的智能来调试它

   — Brian W. Kernighan and P. J. Plauger in The Elements of Programming Style.

参考：

---

以下是生成所需输出的列表理解：

>>> [t[:2] + [[float(f) for f in t[2:]]] for t in woot]
[['abc', 'efg', [4.3, 5.7, 80085.0]], ['aba', 'bab', [1.0, 9.0, 3.0]]]

---

下面的想法使用列表理解和切片语法将每个子列表拆分为一个包含sub-0、sub-1的列表，然后是索引2..n中的项目列表。这是使用

列表

类型的

+

运算符完成的

为了简洁起见，我使用了

map

而不是内部理解，但是如果在y[2:]中对ysub使用

[float（ysub））则没有功能上的区别

woot = [['abc','efg', '4.3', '5.7', '80085'],['aba','bab', '1.0', '9.0', '3.0']]
print [y[:2] + [map(float, y[2:])] for y in woot]
[['abc', 'efg', [4.3, 5.7, 80085.0]], ['aba', 'bab', [1.0, 9.0, 3.0]]]

这似乎有效：

final = [l[0:2]+[list(map(float,l[2:]))] for l in woot]

但也许我作弊是因为我用你的bleep和bloop使用
map
…

bloop = [[ 4.3, 5.7, 8005.0],[ 1.0, 9.0, 3.0]]
bleep = [['abc','efg'],['aba','bab']]
final =[]
for i in range(len(bleep)):
    final.append(bleep[i]+[bloop[i]])
print final

这里有很多很好的答案，我只是想指出扩展语法通常更好。此外，尽量避免嵌套列表理解。为嵌套的每一层编写一个函数，并在每一层中放入一个列表，这几乎总是更清楚的。因此，我会：

def process_list(l) :
    #processes the sub list
    new_list = l[:2]
    new_list.extend([float(x) for x in l[2:])
    return new_list

result = [process_list(l) for l in original_list]

这正是你要求它做的…旁注：
[[x代表x在y中[:2]]代表y在低音中]
相当于
[y[:2]代表y在低音中]
另一旁注：尽量不要滥用列表理解。在大多数情况下，它可以为您节省几个字符，但也可能会使您的代码变得不可读且速度较慢。您是否建议我坚持编写循环或使用其他函数？我试图练习一些操作嵌套循环的思维障碍，而不用使用图书馆里的神奇工具，尽管现在我开始疯狂地理解列表，因为它似乎很容易失去我的思路。我接受你的观点，但列表理解并不太“聪明”。它们是蟒蛇的肉和3种蔬菜。在这种情况下，生成所需输出的列表理解是微不足道的。您能详细说明一下您所说的不太“聪明”是什么意思吗？@user155876：这是对回答“尽可能聪明地编写代码”中的引用。我的观点是，列表理解是Python语言的一个基本特性，它们并不一定聪明。当然，写一个难以理解的列表理解很容易，但是，在这个特定的例子中，所需的列表理解一点也不复杂。我引用了这段话，因为最初的问题是使用两个列表理解来创建两个列表，然后再尝试将它们合并在一起。列表理解本身并不成问题，只要它们简单明了。事实上，我对德尔根最初的答案投了更高的票，因为这看起来很好，很简单，也很容易理解。（当时我在回答中保留了一个简单的列表！）我最讨厌的是变量
l
。它看起来太像
1
。（我曾经发现一个程序包含
l
、
l1
、
l12
和
ll2
，最后一个是bug！）撇开它不谈，我更喜欢列表理解，尽管总体上我喜欢列表理解，提供有关此代码为什么和/或如何回答此问题的附加上下文可以提高其长期价值。使用
list（map（））
与使用列表理解没有什么区别。当然，他问我如何处理列表理解，而我没有完全使用列表理解。我知道这不是“作弊”，这只是另一种方式。