标签: nested-loops

我想要两个嵌套的 for 循环

async.each(ListA,
function(itemA,callback1){
        //process itemA
        async.each(itemA.Children,
        function(itemAChild,callback1){
              //process itemAChild  
              callback1();
               }),
    function(err){
    console.log("InnerLoopFinished")
    }   

callback();
}),function(err){
console.log("OuterLoopFinished")
}
console.log("Process Finished")

现在我希望根据 List Size 和

流程完成

Bt 我得到的是 Process Finished at First 以及 InnerLoop 和 Outerloop 消息，具体取决于循环大小..

我在两个循环中处理数据，所以当控制去打印“最终过程”消息时，我希望我的所有数据都填充到一个对象之前，并将其作为响应发送，这在此处没有实现

我认为我不清楚工作 async.each 的想法..有人可以帮助我实现所需的输出

我创建list1了包含来自特定列的唯一值，方法是附加标识为它唯一的值，以便执行某种“如果”。

下面是我正在努力解决的场景，内部循环，遍历 csv 行只执行一次。是否有一些特殊的特性使得在嵌套循环的内循环中迭代 csv 文件中的行有问题？

.csv 内容：

Field1
row1
row2
row3

代码：

datafile = open(r"my_file.csv", "r")
myreader = csv.reader(datafile, delimiter=",")

list1 = ["A", "B", "C"]

for x in list1[:]:
    print(x)
        for y in myreader:
               print(y)

预期结果：

A
row1
row2
row3
B
row1
row2
row3
C
row1
row2
row3

实际结果：

A
row1
row2
row3<
B
C

似乎只有内循环的初始迭代在工作。

如果我用另一个列表替换 csv 它工作正常：

datafile = open(r"my_file.csv", "r")
myreader = csv.reader(datafile, delimiter=",")

list1 = ["A", "B", "C"]
list2 = ["row1", "row2", "row2"] …

我是 python 的初学者，并尝试通过谷歌搜索找到解决方案。但是，我找不到任何我想要的解决方案。

我试图用 python 做的是对数据进行预处理，查找关键字并从大型 csv 文件中获取包含关键字的所有行。

不知何故，嵌套循环经历了just once，然后它就没有经历过second loop。

下面显示的代码是我的代码的一部分，它从文件中查找关键字csv并写入文本文件。

def main():
   #Calling file (Directory should be changed)
   data_file = 'dataset.json'
   #Loading data.json file
   with open(data_file, 'r') as fp:
       data = json.load(fp)

       #Make the list for keys    
       key_list = list(data.keys())
       #print(key_list)
   preprocess_txt = open("test_11.txt", "w+", -1, "utf-8")
   support_fact = 0

   for i, k in enumerate(key_list):
       count = 1
       #read csv, and split on "," the line  
       with open("my_csvfile.csv", 'r', encoding = 'utf-8') …

我必须使用物理公式来实现一些模拟。在一个公式中，有许多变量。我想用 100 个样本改变这些变量。对于每个样本，我必须使用所有组合进行计算。简化的 for 循环更好地解释了我想要做什么：

set.seed(3)
a = rnorm(100)
b = rnorm(100)
c = rnorm(100)
d = rnorm(100)
f = rnorm(100)

for (a in 1:length(a)) {
        
        for (b in 1:length(b)) {
                
                for (c in 1:length(c)) {
                        
                        for (d in 1:length(d)) {
                                
                                for (f in 1:length(f)) {
                                        
                                        value = a + b / c * d - f # for illustrative purposes only
                                        # .... 
                                        # ... then I append the value to a vector etc.
                                        
                                }
                                
                        }
                        
                }
                
        }
        
} …

我有一个嵌套循环，它将组装参数的所有变体。参数越多，嵌套就越大。

for param1 in [1,2,3]:
    for param2 in [5,10,15]:
        for param3 in [10,11,12]:
            for param4 in [35,36,37]:
                for param5 in [2,4,6]:
                    params  = {
                        'param1': param1,
                        'param2': param2,
                        'param3': param3,
                        'param4': param4,
                        'param5': param5,
                    }
                    run_test(params)

为了使代码更具可读性，希望将所有变体放入一个 dict 中，然后创建上面的循环。但如何实现这一目标？

configuration  = {
    'param1': [1,2,3],
    'param2': [5,10,15],
    'param3': [10,11,12],
    'param4': [35,36,37],
    'param5': [2,4,6],
}

所需的输出是一个字典列表

[
    {
        'param1': param1,
        'param2': param2,
        'param3': param3,
        'param4': param4,
        'param5': param5,
    },
    { next dict …}
]

在笛卡尔乘积会工作，如果输入的是list of lists，但我有一个输入这是一个dict …

所以，我做了这个练习，我将收到一个整数列表，并且必须找出有多少个和对是 60 的倍数

例子：

输入：list01 = [10,90,50,40,30]

结果 = 2

解释：10+50、90+30

示例2：

输入：list02 = [60,60,60]

结果 = 3

解释：list02[0] + list02[1], list02[0] + list02[2], list02[1] + list02[2]

看起来很简单，所以这是我的代码：

def getPairCount(numbers):
    total = 0
    cont = 0
    for n in numbers:
        cont+=1
        for n2 in numbers[cont:]:
            if (n + n2) % 60 == 0:
                total += 1
    return total

它正在工作，但是，对于超过 100k+ 数字的大输入运行时间太长，并且我需要能够在 8 秒内运行，关于如何解决这个问题的任何提示？

与另一个我不知道的库一起使用或者能够在没有嵌套循环的情况下解决这个问题

SQL Server中有3个数据量很大的表，每个表包含大约100000行。有一个 SQL 从三个表中获取行。它的性能非常糟糕。

WITH t1 AS 
(
    SELECT 
        LeadId, dbo.get_item_id(Log) AS ItemId, DateCreated AS PriceDate
    FROM 
        (SELECT 
             t.ID, t.LeadID, t.Log, t.DateCreated, f.AskingPrice
         FROM 
             t
         JOIN 
             f ON f.PKID = t.LeadID
         WHERE 
             t.Log LIKE '%xxx%') temp
)
SELECT COUNT(1)
FROM t1
JOIN s ON s.ItemID = t1.ItemId

在检查其估计执行计划时，我发现它使用了大行的嵌套循环连接。抢劫看下面的截图。图像中的顶部部分返回 124277 行，底部部分执行了 124277 次！我想这就是它这么慢的原因。

我们知道嵌套循环在处理大数据时存在很大的性能问题。如何删除它，并使用散列连接或其他连接代替？

编辑：以下是相关功能。

CREATE FUNCTION [dbo].[get_item_Id](@message VARCHAR(200))
RETURNS VARCHAR(200) AS
BEGIN
    DECLARE @result VARCHAR(200),
            @index int

    --Sold in eBay (372827580038).
    SELECT @index = PatIndex('%([0-9]%)%', @message)
    IF(@index = …

我试图找出一种方法来动态重现下面的循环结构，具体取决于我拥有的“组”的数量。有任何想法吗？提前致谢！

for a in range(len(group1)):
  for b in range(len(group2)):
    for c in range(len(group3)):
      for d in range(len(group4)):
        for e in range(len(group5)):
          for f in range(len(group6)):
            createImage(a,b,c,d,e,f,counter)

foo使用函数参数作为循环变量

void foo(int i, int j) {
    for (; i < 5; ++i)
        for (; j < 5; ++j)
            std::cout << i << " " << j << std::endl;
}

和foo(0, 0)打印

0 0
0 1
0 2
0 3
0 4

我想知道为什么i总是0。

我有以下(简化)条件需要验证我正在编写的表单:

a> b

a> c

a> d

b> c

b> d

c> d

从图形上看,这可以看作:

用户可以自由输入a,b,c和d的值,这就是为什么需要对它们进行验证以确保它们遵守这些规则的原因.我遇到的问题是写一些清楚有效地评估每个陈述的东西.当然,最明显的方法是将每个语句分别作为if语句进行评估.不幸的是,这会占用很多代码行,而且我宁愿避免使用一堆if-blocks来完成同样的事情.我确实使用数组提出了以下嵌套的for循环解决方案.我构建了一个值数组,并将其循环两次(在类似Python的伪代码中演示):

A = [a, b, c, d]
for i in range(3):
    for j in range(i, 4):
        if i > j and A[i] >= A[j]:
            print("A[i] must be less than A[j]")
        else if i < j and A[i] <= A[j]:
            print("A[j] must be greater than A[i]")

我对这个解决方案的问题是难以阅读和理解 - 解决方案并不清楚.

我有这种唠叨的感觉,那里有一个更好,更清晰的答案,但我无法想到它对我的生活.这不是家庭作业或任何事情 - 我实际上正在研究一个项目,这个问题(或它的微妙变化)不止一次出现,所以我想制作一个清晰有效的可重用解决方案.任何输入将不胜感激.谢谢!