Question

我理解列表推导的重要性，但是不理解它们的内部工作，因此无法用更简单的术语来理解它们，比如我想要循环。例如，我怎么能将其更改为for循环：

// utility function for making a "key" object
function makeKey(obj) {
    return {
        ns: '', //AEROSPIKE_NAMESPACE
        set: 'products', //AEROSPIKE_SET
        key: 'pd.v1.c' + options.city_id + '.' + obj.toString()
    }
}

// promisified version of batchGet()
function batchGetAsync(obj) {
    var defer = sails.Q.defer();
    batchGet(obj, function(err, results) {
        if(err.code === status.AEROSPIKE_OK) {
            defer.resolve(results);
        } else {
            defer.reject(err);
        }
    });
    return defer.promise; 
}

var status = require('aerospike').status;

// Main routine
exports.productDetailsQuery = function(options) {
    return batchGetAsync(options.results.map(makeKey)).then(results) {
        var promises = results.filter(function(res) {
            if (res.status === status.AEROSPIKE_OK) {
                return true;
            } else if(status.AEROSPIKE_ERR_RECORD_NOT_FOUND) {
                console.log("NOT_FOUND - ", res.keys);
            } else {
                console.log("ERR - %d - ", res.status, res.keys);
            }
            return false;
        }).map(function(parent) {
            var entry = { 'primary_prod': parent },
                children = parent['children'];
            if(children) {
                return batchGetAsync(children.map(makeKey)).then(function(childData) {
                    entry.variants = childData;
                    return entry;
                });
            } else {
                return entry;
            }
        });
        return sails.Q.all(promises);
    });
}

在这个例子中，我有一个列表列表，为了我的目的，一个名为 outer_list 的矩阵，它是一个列表列表。索引值是外部迭代所在的列号，从0到某个数字n。上面的列表推导会返回矩阵中的 index '列，并将其作为列表分配给 li 。如何创建以这种方式创建列表的for循环？

Answer 1

这只是表达list的缩短方式。

li = [row[index] for row in outer_list]

相当于：

li = []
for row in outer_list:
    li.append(row[index])

一旦习惯了语法，它就会成为创建list s（和其他迭代）的一种整洁方式。

Answer 2

问题：

如何将其更改为for循环？

li = [row[index] for row in outer_list]

答案：

li = []
for row in outer_list:
   li.append(row[index])

Answer 3

假设外部迭代是针对索引的，那么这段代码可以有效地重写为：

for row in outer_list:
    li.append(row[index])

在这里，您将在outer_list内的列表中进行迭代。因此，第一次迭代会将outer_list中的第一个列表添加到li，然后添加第二个列表，依此类推。

Answer 4

您的问题似乎暗示此代码段已经在for循环中，如下所示：

$ ./splitit
Whole string: <<(I) 44like22 .cookies. ,This, /is\ ?tricky?>>
Fragment[ 0] = (
Fragment[ 1] = I
Fragment[ 2] = )
Fragment[ 3] = 44
Fragment[ 4] = like
Fragment[ 5] = 22
Fragment[ 6] = .
Fragment[ 7] = cookies
Fragment[ 8] = .
Fragment[ 9] = ,
Fragment[10] = This
Fragment[11] = ,
Fragment[12] = /
Fragment[13] = is
Fragment[14] = \
Fragment[15] = ?
Fragment[16] = tricky
Fragment[17] = ?
Californian(*) Avocados--a joyous fruit--are "wonderful!" to eat.
Whole string: <<Californian(*) Avocados--a joyous fruit--are "wonderful!" to eat.
>>
Fragment[ 0] = Californian
Fragment[ 1] = (*)
Fragment[ 2] = Avocados
Fragment[ 3] = --
Fragment[ 4] = a
Fragment[ 5] = joyous
Fragment[ 6] = fruit
Fragment[ 7] = --
Fragment[ 8] = are
Fragment[ 9] = "
Fragment[10] = wonderful
Fragment[11] = !"
Fragment[12] = to
Fragment[13] = eat
Fragment[14] = .
$

将输出：

outer_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

for index in xrange(3):
    li = [row[index] for row in outer_list]
    print li

您可以通过在内部循环中嵌套内部循环来将其转换为仅使用传统的[1, 4, 7] [2, 5, 8] [3, 6, 9]循环：

for

如果您将此嵌套列表视为矩阵，那么您所描述的内容主要是对矩阵进行转置。你也可以通过列表推导完全做到这一点：

outer_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

for index in xrange(3):
    li = []                    # initial empty list
    for row in outer_list:     # our inner loop
        li.append(row[index])  # Build the list "li" iteratively
    print li

产生：

outer_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

transpose = [[row[i] for row in outer_list] for i in range(len(outer_list[0]))]

print transpose

如官方Python教程here所示。

我已经通过完整性包含了嵌套列表理解示例，但是明智地包含了一个词：使用嵌套列表推导通常使代码不易理解，而不是更多。只是因为你的意思并不代表你应该这样做。

将列表推导转换为Python中的循环

4 个答案:

问题：

答案：