 # pythonic way to take the only item from a list

• Last Update :
• Techknowledgy :

Get elements by indexuse the operator [] with the element’s indexuse the list’s method pop(index)use slicing lst[start:stop:step] to get several elements at onceuse the function itemgetter() from the operator module,Get elements by indexuse the operator [] with the element’s indexuse the list’s method pop(index)use slicing (lst[start:stop:step]) to get several elements at onceuse the function itemgetter() from the operator module,Get elements by conditionuse the filter() functionuse a list comprehension statement,The indices start at 0, therefore the third element’s index is 2. In Python it is also possible to count from back to front using negative indices.This is very handy, especially for retrieving the last or second last element.The index of a list’s last element is -1, the index of the second last is -2 and so on.

To access any item in a list use the brackets operator with the index of the item you want to retrieve. E.g. if we want to access the point (4, 5) from our list `ps` we write:

```# list of points from the 2 D space
ps = [(2, 4), (-1, 7), (4, 5), (3, -4), (-1, -5)]
point = ps```

If you want to access and remove an item from a list, call the pop() method with
the index of the element. If you don’t pass a value for the index, the pop() method
returns and removes the last element from the list.
This is how you get and remove the item (4, 5) using the pop() method:

```# list of points from the 2 D space
ps = [(2, 4), (-1, 7), (4, 5), (3, -4), (-1, -5)]

item = ps.pop(2)
print(ps)
#[(2, 4), (-1, 7), (3, -4), (-1, -5)]```

To get a continuous range of elements from a list, use slicing.
Slicing also uses the brackets operator with a start and end index.
As code it looks as follows:

```ps = [(2, 4), (-1, 7), (4, 5), (3, -4), (-1, -5)]
items = ps[2: 4]```

Using the filter() function we can get all elements with a distance greater than
6.0 from (0, 0) like this:

```def dist(x):
return (x ** 2 + x ** 2) ** 0.5

ps = [(2, 4), (-1, 7), (4, 5), (3, -4), (-1, -5)]
filtered = list(filter(lambda x: dist(x) > 6.0, ps))```

Another way to get all elements from a list which satisfy a certain condition is a
list comprehension. The algorithm behind the list comprehension is called Linear Search.
Linear Search iterates over the input once and appends all elements that satisfy the
condition to a new list.
In our example where we wanted to get all points from the list ps whose distance from
(0, 0) is larger than 6.0 we need the following code:

```def dist(x):
return (x ** 2 + x ** 2) ** 0.5

ps = [(2, 4), (-1, 7), (4, 5), (3, -4), (-1, -5)]
filtered = [p
for p in ps
if dist(p) > 6.0
]```

Suggestion : 2

#### Sequence unpacking:

```singleitem, = mylist
# Identical in behavior(byte code produced is the same),
# but arguably more readable since a lone trailing comma could be missed: [singleitem] = mylist```

#### Rampant insanity, unpack the input to the identity `lambda` function:

```# The only even semi - reasonable way to retrieve a single item and raise an exception on
# failure
for too many, not just too few, elements as an expression, rather than a
# statement, without resorting to defining / importing functions elsewhere to do the work
singleitem = (lambda x: x)( * mylist)```

#### Explicit use of iterator protocol:

`singleitem = next(iter(mylist))`

#### Negative index:

`singleitem = mylist[-1]`

#### Set via single iteration `for` (because the loop variable remains available with its last value when a loop terminates):

`for singleitem in mylist: break`

I will add that the `more_itertools` library has a tool that returns one item from an iterable.

```from more_itertools
import one

iterable = ["foo"]
one(iterable)
# "foo"```

In addition, `more_itertools.one` raises an error if the iterable is empty or has more than one item.

```iterable = []
one(iterable)
# ValueError: not enough values to unpack(expected 1, got 0)

iterable = ["foo", "bar"]
one(iterable)
# ValueError: too many values to unpack(expected 1)```

One way is to use `reduce` with `lambda x: x`.

```from functools import reduce

> reduce(lambda x: x, })
3

> reduce(lambda x: x, [1, 2, 3])
TypeError: <lambda>() takes 1 positional argument but 2 were given

> reduce(lambda x: x, [])
TypeError: reduce() of empty sequence with no initial value
```

Suggestion : 3

By the end, you'll know how to use remove() to remove an item from a list in Python.,And there you have it! You now know how to remove a list item in Python using the remove() method. You also saw some ways of removing all occurrences of an item in a list in Python.,The remove() method is one of the ways you can remove elements from a list in Python.,remove() removes only the first occurrence of an item How to remove all occurrences of an item

The general syntax of the `remove()` method looks like this:

`list_name.remove(value)`

`remove()` will search the list to find it and remove it.

```#original list
programming_languages = ["JavaScript", "Python", "Java", "C++"]

#print original list
print(programming_languages)

# remove the value 'JavaScript'
from the list
programming_languages.remove("JavaScript")

#print updated list
print(programming_languages)

#output

#['JavaScript', 'Python', 'Java', 'C++']
#['Python', 'Java', 'C++']```

If you specify a value that is not contained in the list, then you'll get an error – specifically the error will be a `ValueError`:

```programming_languages = ["JavaScript", "Python", "Java", "C++"]

#I want to remove the value 'React'
programming_languages.remove("React")

#print list
print(programming_languages)

#output

# line 5, in <module>
#programming_languages.remove("React")
#ValueError: list.remove(x): x not in list```

Another way to avoid this error is to create a condition that essentially says, "If this value is part of the list then delete it. If it doesn't exist, then show a message that says it is not contained in the list".

```programming_languages = ["JavaScript", "Python", "Java", "C++"]

if "React" in programming_languages:
programming_languages.remove("React")
else:
print("This value does not exist")

#output
#This value does not exist```

Let's look at the following example:

```programming_languages = ["JavaScript", "Python", "Java", "Python", "C++", "Python"]

programming_languages.remove("Python")

print(programming_languages)

#output
#['JavaScript', 'Java', 'Python', 'C++', 'Python']```

Suggestion : 4

Remote Work 2022 , Remote Work 2022

`list.remove(value)`

### Code to remove item from list by value:

```list1 = ["Hire", "Hire", "the", "top", 10, "python", "freelancers"]

list1.remove("Hire")
print(list1)

#Output - ['Hire', 'the', 'top', 10, 'python', 'freelancers']```

### Syntax of pop()

`list.pop(index)`

### Syntax of del:

`del object_name`

### Code to remove items using del

```list1 = ["Hire", "the", "top", 10, "python", "freelancers"]

del list1
print(list1)

#Output - "['the', 'top', 10, 'python', 'freelancers']"```

Suggestion : 5

Last Updated : 26 Jul, 2022

Examples:

```Input: 10 20 10 30 40 40
Output: 10 20 30 40```
```Input : 10 20 10 30 40 40
Output : 10 20 30 40 ```
```Input: 1 2 1 1 3 4 3 3 5
Output: 1 2 3 4 5```

Output:

```the unique values from 1 st list is
10 20 30 40
the unique values from 2n d list is
1 2 3 4 5```

Output:

```the unique values from 1 st list is
[10 20 30 40]

the unique values from 2n d list is
[1 2 3 4 5]```

```the unique values from 1 st list is
40 10 20 30
the unique values from 2n d list is
1 2 3 4 5```

```the unique values from 1 st list is
10 20 30 40

the unique values from 2n d list is
1 2 3 4 5```