# Python | Accessing nth element from tuples in list

While working with tuples, we store different data as different tuple elements. Sometimes, there is a need to print a specific information from the tuple. For instance, a piece of code would want just names to be printed of all the student data. Lets discuss certain ways how one can achieve solutions to this problem.

Method #1 : Using list comprehension List comprehension is the simplest way in which this problem can be solved. We can just iterate over only the specific index value in all the index and store it in a list and print it after that.

## Python3

 `# Python3 code to demonstrate ` `# get nth tuple element from list` `# using list comprehension `   `# initializing list of tuples` `test_list ``=` `[(``1``, ``'Rash'``, ``21``), (``2``, ``'Varsha'``, ``20``), (``3``, ``'Kil'``, ``19``)]`   `# printing original list ` `print` `("The original ``list` `is` `: " ``+` `str``(test_list))`   `# using list comprehension to get names` `res ``=` `[lis[``1``] ``for` `lis ``in` `test_list]` `    `  `# printing result` `print` `("``List` `with only nth ``tuple` `element (i.e names) : " ``+` `str``(res))`

Output :

```The original list is : [(1, 'Rash', 21), (2, 'Varsha', 20), (3, 'Kil', 19)]
List with only nth tuple element (i.e names) : ['Rash', 'Varsha', 'Kil']```

Time complexity: O(n), where n is the number of tuples in the input list.
Auxiliary space: O(n), where n is the number of tuples in the input list.

Method #2 : Using map() + itemgetter() map() coupled with itemgetter() can perform this task in more simpler way. map() maps all the element we access using itemgetter() and returns the result.

## Python3

 `# Python3 code to demonstrate ` `# get nth tuple element from list` `# using map() + itemgetter()` `from` `operator ``import` `itemgetter`   `# initializing list of tuples` `test_list ``=` `[(``1``, ``'Rash'``, ``21``), (``2``, ``'Varsha'``, ``20``), (``3``, ``'Kil'``, ``19``)]`   `# printing original list ` `print` `("The original ``list` `is` `: " ``+` `str``(test_list))`   `# using map() + itemgetter() to get names` `res ``=` `list``(``map``(itemgetter(``1``), test_list))` `    `  `# printing result` `print` `("``List` `with only nth ``tuple` `element (i.e names) : " ``+` `str``(res))`

Output :

```The original list is : [(1, 'Rash', 21), (2, 'Varsha', 20), (3, 'Kil', 19)]
List with only nth tuple element (i.e names) : ['Rash', 'Varsha', 'Kil']```

Method #3 : Using zip() The most conventional and pythonic way to perform this particular task is using this function. This collects all the nth tuple elements into a single container and returns the result. This only works for Python 2.

## Python

 `# Python code to demonstrate ` `# get nth tuple element from list` `# using zip()`   `# initializing list of tuples` `test_list ``=` `[(``1``, ``'Rash'``, ``21``), (``2``, ``'Varsha'``, ``20``), (``3``, ``'Kil'``, ``19``)]`   `# printing original list ` `print` `("The original ``list` `is` `: " ``+` `str``(test_list))`   `# using zip() to get names` `res ``=` `list``(``zip``(``*``test_list)[``1``])` `    `  `# printing result` `print` `("``List` `with only nth ``tuple` `element (i.e names) : " ``+` `str``(res))`

Output :

```The original list is : [(1, 'Rash', 21), (2, 'Varsha', 20), (3, 'Kil', 19)]
List with only nth tuple element (i.e names) : ['Rash', 'Varsha', 'Kil']```

Method #4 : Using map() + lambda

To access the nth element of each tuple in a list using a lambda function, you can define a lambda function that returns the nth element of each tuple, and then use the map function to apply this lambda function to each tuple in the list.

Here is an example of how you can do this:

## Python3

 `# initializing list of tuples` `test_list ``=` `[(``1``, ``'Rash'``, ``21``), (``2``, ``'Varsha'``, ``20``), (``3``, ``'Kil'``, ``19``)]`   `# printing original list` `print``(``"The original list is:"``, test_list)`   `# using the map function and a lambda function to access the nth element of each tuple` `n ``=` `1`  `# specify the index of the element to access` `res ``=` `list``(``map``(``lambda` `x: x[n], test_list))`   `# printing result` `print``(``"List with only nth tuple element:"``, res)` `#This code is contributed by Edula Vinay Kumar Reddy`

Output

```The original list is: [(1, 'Rash', 21), (2, 'Varsha', 20), (3, 'Kil', 19)]
List with only nth tuple element: ['Rash', 'Varsha', 'Kil']```

Time complexity: O(n), since it involves a single pass through the list. It uses the map function and a lambda function to access the nth element of each tuple, but does not require any additional modules.
Auxiliary space: O(n), since it requires the creation of a new list to store the result.

Method #5: Using a for loop

Step-by-step approach:

• Initialize an empty list to store the nth element of each tuple.
• Loop through each tuple in the given list.
• Append the nth element of the current tuple to the empty list.
• Return the resulting list.

Below is the implementation of the above approach:

## Python3

 `# initializing list of tuples` `test_list ``=` `[(``1``, ``'Rash'``, ``21``), (``2``, ``'Varsha'``, ``20``), (``3``, ``'Kil'``, ``19``)]`   `# printing original list` `print``(``"The original list is:"``, test_list)`   `# using a for loop to access the nth element of each tuple` `n ``=` `1`  `# specify the index of the element to access` `res ``=` `[]` `for` `tup ``in` `test_list:` `    ``res.append(tup[n])`   `# printing result` `print``(``"List with only nth tuple element:"``, res)`

Output

```The original list is: [(1, 'Rash', 21), (2, 'Varsha', 20), (3, 'Kil', 19)]
List with only nth tuple element: ['Rash', 'Varsha', 'Kil']```

Time complexity: O(n), where n is the number of tuples in the list.
Auxiliary space: O(n), where n is the number of tuples in the list.

Method 6: Using reduce()

1. Import the reduce() function from the functools module: from functools import reduce
2. Initialize a list of tuples: test_list = [(1, ‘Rash’, 21), (2, ‘Varsha’, 20), (3, ‘Kil’, 19)]
3. Print the original list: print(“The original list is : ” + str(test_list))
4. Choose which nth tuple element you want to extract and assign it to the variable n: n = 1
5. Use the reduce() function to extract the nth tuple element from each tuple in the list: res = reduce(lambda acc, tup: acc + [tup[n]], test_list, [])
6. Print the result: print(“List with only nth tuple element (i.e names) : ” + str(res))

## Python3

 `# Python3 code to demonstrate` `# get nth tuple element from list` `# using reduce()`   `from` `functools ``import` `reduce`   `# initializing list of tuples` `test_list ``=` `[(``1``, ``'Rash'``, ``21``), (``2``, ``'Varsha'``, ``20``), (``3``, ``'Kil'``, ``19``)]`   `# printing original list` `print``(``"The original list is : "` `+` `str``(test_list))`   `# using reduce() to get nth tuple element` `n ``=` `1`  `# replace n with the index of the tuple element you want` `res ``=` `reduce``(``lambda` `acc, tup: acc ``+` `[tup[n]], test_list, [])`   `# printing result` `print``(``"List with only nth tuple element (i.e names) : "` `+` `str``(res))`

Output

```The original list is : [(1, 'Rash', 21), (2, 'Varsha', 20), (3, 'Kil', 19)]
List with only nth tuple element (i.e names) : ['Rash', 'Varsha', 'Kil']```

Time complexity:The time complexity of Method #7 is O(n), where n is the length of the input list test_list.
The auxiliary space complexity of Method #7 is O(n), where n is the length of the input list test_list.

Method #7 : Using numpy.array(), and then fancy indexing to get the nth column

We will use numpy.array() function and fancy indexing to get the nth tuple element. We will convert the list of tuples to a 2D numpy array using numpy.array(), and then we will use fancy indexing to get the nth column (which represents the nth tuple element) from the array. Finally, we will convert the resulting 1D numpy array to a list.

1. Import numpy module.
2. Initialize the list of tuples.
3. Convert the list of tuples to a 2D numpy array using numpy.array() function.
4. Extract the nth column (which represents the nth tuple element) from the array using fancy indexing.
5. Convert the resulting 1D numpy array to a list.
6. Print the original list and the list with only the nth tuple element.

## Python3

 `# import numpy module` `import` `numpy as np`   `# initialize list of tuples` `test_list ``=` `[(``1``, ``'Rash'``, ``21``), (``2``, ``'Varsha'``, ``20``), (``3``, ``'Kil'``, ``19``)]`   `# print original list` `print``(``"The original list is : "` `+` `str``(test_list))`   `# convert list of tuples to a 2D numpy array` `arr ``=` `np.array(test_list)`   `# specify the index of the element to access` `n ``=` `1`   `# extract the nth column from the` `# array using fancy indexing` `res_arr ``=` `arr[:, n]`   `# convert the resulting 1D numpy ` `# array to a list` `res ``=` `res_arr.tolist()`   `# print list with only the nth tuple element` `print``(``"List with only nth tuple element (i.e names) : "` `+` `str``(res))`

Output:

```The original list is : [(1, 'Rash', 21), (2, 'Varsha', 20), (3, 'Kil', 19)]
List with only nth tuple element (i.e names) : ['Rash', 'Varsha', 'Kil']
```

Time complexity: O(n), where n is the number of tuples in the input list. The numpy.array() function has a time complexity of O(n), where n is the number of elements in the input list. Fancy indexing also has a time complexity of O(n), where n is the number of elements in the array. Converting the resulting 1D numpy array to a list has a time complexity of O(n) as well.

Space complexity: O(n), where n is the number of tuples in the input list. The numpy.array() function creates a 2D numpy array of size n x 3, where n is the number of tuples in the input list. The resulting 1D numpy array also has a size of n. Converting the resulting 1D numpy array to a list also creates a list of size n. Therefore, the total space complexity is O(n + n + n), which simplifies to O(n).

Whether you're preparing for your first job interview or aiming to upskill in this ever-evolving tech landscape, GeeksforGeeks Courses are your key to success. We provide top-quality content at affordable prices, all geared towards accelerating your growth in a time-bound manner. Join the millions we've already empowered, and we're here to do the same for you. Don't miss out - check it out now!