# Python – Group first elements by second elements in Tuple list

Given List of tuples, group 1st elements on basis of 2nd elements.

```Input : test_list = [(6, 5), (2, 7), (2, 5), (8, 7), (3, 7)]
Output : {5: [6, 2], 7: [2, 8, 3]}
Explanation : 5 occurs along with 6 and 2 in tuple list, hence grouping. ```
```Input : test_list = [(6, 5), (2, 7), (2, 5), (8, 7)]
Output : {5: [6, 2], 7: [2, 8]}
Explanation : 5 occurs along with 6 and 2 in tuple list, hence grouping.```

Method #1 : Using loop + groupby() + sorted() + list comprehension + lambda

In this, the elements are sorted for grouping, function provided by lambda, then only first elements are extracted using list comprehension out of result. And final dictionary formation using loop.

## Python3

 `# Python3 code to demonstrate working of``# Group first elements by second elements in Tuple list``# Using loop + groupby() + sorted() + list comprehension + lambda``from` `itertools ``import` `groupby` `# initializing list``test_list ``=` `[(``6``, ``5``), (``2``, ``7``), (``2``, ``5``), (``8``, ``7``), (``9``, ``8``), (``3``, ``7``)]` `# printing original list``print``(``"The original list is : "` `+` `str``(test_list))` `res ``=` `dict``()` `# forming equal groups``for` `key, val ``in` `groupby(``sorted``(test_list, key``=``lambda` `ele: ele[``1``]), key``=``lambda` `ele: ele[``1``]):``    ``res[key] ``=` `[ele[``0``] ``for` `ele ``in` `val]` `# printing results``print``(``"Grouped Dictionary : "` `+` `str``(res))`

Output
```The original list is : [(6, 5), (2, 7), (2, 5), (8, 7), (9, 8), (3, 7)]
Grouped Dictionary : {5: [6, 2], 7: [2, 8, 3], 8: [9]}```

Time Complexity: O(n)
Auxiliary Space: O(n)

Method #2 : Using dictionary comprehension

This is method similar to above, just a one-liner shorthand handled using dictionary comprehension.

## Python3

 `# Python3 code to demonstrate working of``# Group first elements by second elements in Tuple list``# Using dictionary comprehension``from` `itertools ``import` `groupby` `# initializing list``test_list ``=` `[(``6``, ``5``), (``2``, ``7``), (``2``, ``5``), (``8``, ``7``), (``9``, ``8``), (``3``, ``7``)]` `# printing original list``print``(``"The original list is : "` `+` `str``(test_list))` `# shorthand to solve problem``res ``=` `{key: [v[``0``] ``for` `v ``in` `val] ``for` `key, val ``in` `groupby(``    ``sorted``(test_list, key``=``lambda` `ele: ele[``1``]), key``=``lambda` `ele: ele[``1``])}` `# printing results``print``(``"Grouped Dictionary : "` `+` `str``(res))`

Output
```The original list is : [(6, 5), (2, 7), (2, 5), (8, 7), (9, 8), (3, 7)]
Grouped Dictionary : {5: [6, 2], 7: [2, 8, 3], 8: [9]}```

Time Complexity: O(nlogn) for sorting the list, where n is the length of the input list.
Auxiliary Space: O(n) for storing the dictionary.

Method #3 : Using for loop , in and not in operators

## Python3

 `# Python3 code to demonstrate working of``# Group first elements by second elements in Tuple list` `# initializing list``test_list ``=` `[(``6``, ``5``), (``2``, ``7``), (``2``, ``5``), (``8``, ``7``), (``9``, ``8``), (``3``, ``7``)]` `# printing original list``print``(``"The original list is : "` `+` `str``(test_list))` `res ``=` `dict``()``x ``=` `[]``for` `i ``in` `test_list:``    ``if` `i[``1``] ``not` `in` `x:``        ``x.append(i[``1``])``for` `i ``in` `x:``    ``p ``=` `[]``    ``for` `j ``in` `test_list:``        ``if` `j[``1``] ``=``=` `i:``            ``p.append(j[``0``])``        ``res[i] ``=` `p` `# printing results``print``(``"Grouped Dictionary : "` `+` `str``(res))`

Output
```The original list is : [(6, 5), (2, 7), (2, 5), (8, 7), (9, 8), (3, 7)]
Grouped Dictionary : {5: [6, 2], 7: [2, 8, 3], 8: [9]}```

Time complexity: O(n^2)
Auxiliary space: O(n)

Method #4: Using defaultdict

Use the defaultdict from the collections module to group the first elements by the second elements in a tuple list.

Step-by-step approach:

• Import the defaultdict class from the collections module.
• Initialize a defaultdict with a list as the default value.
• Loop through each tuple in the input list, and append the first element of the tuple to the list associated with the second element of the tuple in the defaultdict.
• Return the resulting defaultdict as a regular dictionary.

Below is the implementation of the above approach:

## Python3

 `from` `collections ``import` `defaultdict` `# initializing list``test_list ``=` `[(``6``, ``5``), (``2``, ``7``), (``2``, ``5``), (``8``, ``7``), (``9``, ``8``), (``3``, ``7``)]` `# printing original list``print``(``"The original list is : "` `+` `str``(test_list))` `# using defaultdict to group first elements by second elements``res ``=` `defaultdict(``list``)``for` `key, val ``in` `test_list:``    ``res[val].append(key)` `# converting defaultdict to regular dictionary``res ``=` `dict``(res)` `# printing results``print``(``"Grouped Dictionary : "` `+` `str``(res))`

Output
```The original list is : [(6, 5), (2, 7), (2, 5), (8, 7), (9, 8), (3, 7)]
Grouped Dictionary : {5: [6, 2], 7: [2, 8, 3], 8: [9]}```

Time Complexity: O(n), where n is the length of the input list.
Auxiliary Space: O(n), to store the defaultdict.

Method #6: Using pandas

Use pandas to group the tuples by their second element and get the corresponding first elements as a list.

Step-by-step approach:

• Import the pandas library.
• Convert the list of tuples to a pandas DataFrame.
• Set the second element of each tuple as the index of the DataFrame.
• Group the DataFrame by the index and aggregate the first elements of each tuple into a list.
• Convert the resulting pandas Series back to a dictionary.
• Print the resulting grouped dictionary.

Below is the implementation of the above approach:

## Python3

 `import` `pandas as pd` `# initializing list``test_list ``=` `[(``6``, ``5``), (``2``, ``7``), (``2``, ``5``), (``8``, ``7``), (``9``, ``8``), (``3``, ``7``)]` `# convert to pandas DataFrame``df ``=` `pd.DataFrame(test_list, columns``=``[``'first'``, ``'second'``])` `# group by second element and aggregate the first elements``grouped ``=` `df.groupby(``'second'``)[``'first'``].agg(``list``)` `# convert pandas Series to dictionary``grouped_dict ``=` `grouped.to_dict()` `# print the resulting grouped dictionary``print``(``"Grouped Dictionary : "` `+` `str``(grouped_dict))`

Output:

`Grouped Dictionary : {5: [6, 2], 7: [2, 8, 3], 8: [9]}`

Time complexity: O(n log n), where n is the length of the input list.
Auxiliary space: O(n), where n is the length of the input list.

Previous
Next