有没有更好的方法来遍历python中的嵌套循环

Question

I have some code that is running through nested loops. I am guessing that there is a more "pythonic" way of doing this. Any suggestions?

The basic section of code looks like this:

   for e in range(len(listOfTuples)):

        for item in self.items:
            if item.getName() == listOfTuples[e][0]:
                <do stuff>
            if item.getName() == listOfTyples[e][1]:
                <do other stuff>
                continue

        if <both above if statements got answers>:
            <do yet more stuff>

Is there a better way to write these nested loops?

Answer 1

You can use a generator function. At least it hides the "ugliness" of a nested for loop to you.

def combine_items_and_tuples(items, listOfTuples):
   for e in range(len(listOfTuples)):
        for item in items:
            yield e, item

simply call it with:

for e, item in combine_items_and_tuples(self.items, listOfTuples):
      if item.getName() == listOfTuples[e][0]:
                <do stuff>
      if item.getName() == listOfTyples[e][1]:
                <do other stuff>
                continue

      if <both above if statements got answers>:
            <do yet more stuff>

As already mentioned in the comments, you can also iterate of the listOfTuples directly, since it is iterable (have a look in the python glossary ):

for tuple in listOfTuples:

Answer 2

Iterate directly over the listOfTuples and unpack the values we care about

for a, b, *_ in listOfTuples:

    a_check, b_check = False, False

    for item in self.items:
        if item.name == a:
            #do stuff
            a_check = True         
        if item.name == b:
            #do stuff
            b_check = True

    if a_check and b_check:
        #do more stuff

The *_ captures stuff past the first two elements of the tuples in listOfTuples (Assuming all we want is the first two elements).

Notice I use item.name instead of item.getName . Python generally doesn't care about getters and setters because there's no real concept of a private variable.