Solving problem is about exposing yourself to as many situations as possible like Why does “return list.sort()” return None, not the list? and practice these strategies over and over. With time, it becomes second nature and a natural way you approach any problems in general. Big or small, always start with a plan, use other strategies mentioned here till you are confident and ready to code the solution.

In this post, my aim is to share an overview the topic about Why does “return list.sort()” return None, not the list?, which can be followed any time. Take easy to follow this discuss.

I’ve been able to verify that the `findUniqueWords`

does result in a sorted `list`

. However, it does not return the list. Why?

```
def findUniqueWords(theList):
newList = []
words = []
# Read a line at a time
for item in theList:
# Remove any punctuation from the line
cleaned = cleanUp(item)
# Split the line into separate words
words = cleaned.split()
# Evaluate each word
for word in words:
# Count each unique word
if word not in newList:
newList.append(word)
answer = newList.sort()
return answer
```

##
Answer #1:

`list.sort`

sorts the list in place, i.e. it doesn’t return a new list. Just write

```
newList.sort()
return newList
```

##
Answer #2:

The problem is here:

```
answer = newList.sort()
```

`sort`

does not return the sorted list; rather, it sorts the list in place.

Use:

```
answer = sorted(newList)
```

##
Answer #3:

Here is an email from Guido van Rossum in Python’s dev list explaining why he choose not to return `self`

on operations that affects the object and don’t return a new one.

This comes from a coding style (popular in various other languages, I

believe especially Lisp revels in it) where a series of side effects

on a single object can be chained like this:`x.compress().chop(y).sort(z)`

which would be the same as

`x.compress() x.chop(y) x.sort(z)`

I find the chaining form a threat to readability; it requires that the

reader must be intimately familiar with each of the methods. The

second form makes it clear that each of these calls acts on the same

object, and so even if you don’t know the class and its methods very

well, you can understand that the second and third call are applied to

x (and that all calls are made for their side-effects), and not to

something else.I’d like to reserve chaining for operations that return new values,

like string processing operations:

`y = x.rstrip("n").split(":").lower()`

##
Answer #4:

Python has two kinds of sorts: a sort *method* (or “member function”) and a sort *function*. The sort method operates on the contents of the object named — think of it as *an action that the object is taking to re-order itself*. The sort function is an *operation over the data represented by an object* and returns a new object with the same contents in a sorted order.

Given a list of integers named `l`

the list itself will be reordered if we call `l.sort()`

:

```
>>> l = [1, 5, 2341, 467, 213, 123]
>>> l.sort()
>>> l
[1, 5, 123, 213, 467, 2341]
```

This method has no return value. But what if we try to assign the result of `l.sort()`

?

```
>>> l = [1, 5, 2341, 467, 213, 123]
>>> r = l.sort()
>>> print(r)
None
```

`r`

now equals actually nothing. This is one of those weird, somewhat annoying details that a programmer is likely to forget about after a period of absence from Python (which is why I am writing this, so *I* don’t forget again).

The function `sorted()`

, on the other hand, will not do anything to the contents of `l`

, but will return a new, sorted list with the same contents as `l`

:

```
>>> l = [1, 5, 2341, 467, 213, 123]
>>> r = sorted(l)
>>> l
[1, 5, 2341, 467, 213, 123]
>>> r
[1, 5, 123, 213, 467, 2341]
```

Be aware that the returned value is *not* a deep copy, so be cautious about side-effecty operations over elements contained within the list as usual:

```
>>> spam = [8, 2, 4, 7]
>>> eggs = [3, 1, 4, 5]
>>> l = [spam, eggs]
>>> r = sorted(l)
>>> l
[[8, 2, 4, 7], [3, 1, 4, 5]]
>>> r
[[3, 1, 4, 5], [8, 2, 4, 7]]
>>> spam.sort()
>>> eggs.sort()
>>> l
[[2, 4, 7, 8], [1, 3, 4, 5]]
>>> r
[[1, 3, 4, 5], [2, 4, 7, 8]]
```

##
Answer #5:

Python habitually returns `None`

from functions and methods that mutate the data, such as `list.sort`

, `list.append`

, and `random.shuffle`

, with the idea being that it hints to the fact that it was mutating.

If you want to take an iterable and return a new, sorted list of its items, use the `sorted`

builtin function.

##
Answer #6:

To understand why it does not return the list:

sort() doesn’t return any value while the sort() *method* just sorts the elements of a given list in a specific order – *ascending* or *descending* without returning any value.

So problem is with `answer = newList.sort()`

where answer is none.

Instead you can just do `return newList.sort()`

.

The syntax of the sort() method is:

```
list.sort(key=..., reverse=...)
```

Alternatively, you can also use Python’s in-built function sorted() for the same purpose.

```
sorted(list, key=..., reverse=...)
```

Note: The simplest difference between sort() and sorted() is: sort() doesn’t return any value while, sorted() returns an iterable list.

So in your case `answer = sorted(newList)`

.

##
Answer #7:

you can use sorted() method if you want it to return the sorted list.

It’s more convenient.

```
l1 = []
n = int(input())
for i in range(n):
user = int(input())
l1.append(user)
sorted(l1,reverse=True)
```

list.sort() method modifies the list in-place and returns None.

if you still want to use sort you can do this.

```
l1 = []
n = int(input())
for i in range(n):
user = int(input())
l1.append(user)
l1.sort(reverse=True)
print(l1)
```