hajef -4 years ago 76

Python Question

I came across this question in a very specific context but I soon realized that it has a quite general relevance.

FYI: I'm getting data from a framework and at a point I have transformed it into a list of unordered pairs (could be list of lists or tupels of any size as well but atm. I have 100% pairs). In my case these pairs are representing relationships between data objects and I want to refine my data.

I have a list of unordered tupels and want a list of objects or in this case a dict of dicts. If the same letter indicates the same class and differing numbers indicate different instances I want to accomplish this transformation:

`[(a1, x1), (x2, a2), (y1, a2), (y1, a1)] -> {a1:{"y":y1,"x":x1},a2:{"y":y1,"x":x2}}`

Note that there can be many "a"s that are connected to the same "x" or "y" but every "a" has at most one "x" or "y" each and that I can't rely on neither the order of the tupels nor the order of the tupel's elements (because the framework does not make a difference between "a" and "x") and I obviously don't care about the order of elements in my dicts - I just need the proper relations. There are many other pairs I don't care about and they can contain "a" elements, "y" elements or "x" elements as well

So the main question is "How to iterate over nested data when there is no reliable order but a need of accessing and checking all elements of the lowest level?"

I tried it in several ways but they don't seem right. For simplicity I just check for A-X pairs here:

`def first_draft(list_of_pairs):`

result = {}

for pair in list_of_pairs:

if pair[0].__cls__ is A and pair[1].__class__ is X:

result[pair[0]] = {"X": pair[1]}

if pair[0].__cls__ is X and pair[1].__class__ is A:

result[pair[1]] = {"X": pair[0]}

return result

def second_draft(list_of_pairs):

result = {}

for pair in list_of_pairs:

for index, item in enumerate(pair):

if item.__cls__ is A:

other_index = (index + 1) % 2

if pair[other_index].__class__ is X:

result[item] = {"X":pair[other_index]}

return result

def third_draft(list_of_pairs):

result = {}

for pair in list_of_pairs:

for item in pair:

if item.__class__ is A:

for any_item in pair:

if any_item.__class__ is X:

result[item] = {"X":any_item}

return result

The third draft actually works for every size of sub lists and got rid of any non pythonic integer usage but iterating over the same list while iterating over itself? And quintuple nesting for just one line of code? That does not seem right to me and I learned "When there is a problem according to iteration in python and you don't know a good solution - there is a great solution in itertools!" - I just didn't find one.

Does someone now a buildin that can help me or simply a better way to implement my methods?

Recommended for you: Get network issues from **WhatsUp Gold**. **Not end users.**

Answer Source

Looks like Ned Batchelder (who said that every time one have a problem with iterables and don't think there is a nice solution in Python there is a solution in itertools) was right. I finally found a solution I overlooked last time: the permutations method

```
def final_draft(list_of_pairs):
result = {}
for pair in self.undirected_edges:
for permutation in permutations(pair):
if permutation[0].__class__ is A:
my_a = permutation[0]
if permutation[1].__class__ is X:
my_x = permutation[1]
if my_a not in result:
result[my_a] = {}
result[my_a]["key for X"] = my_x
return result
```

I still have quintuple nesting because I added a check if the key exists (so my original drafts would have sextuple nesting and two productive lines of code) but I got rid of the double iteration over the same iterable and have both minimal index usage and the possibility of working with triplets in the future.

One could avoid the assignments but I prefere "my_a" before permutation[0]

Recommended from our users: **Dynamic Network Monitoring from WhatsUp Gold from IPSwitch**. ** Free Download**

Latest added