assistant: ```python
def sieve_of_eratosthenes(n):
  numbers = list(range(2, n + 1))  # generate a list from 2 to n
  primes = []                      # initiate a currently empty list of prime numbers
  while numbers:                   # as long as there are numbers in the first list
    prime = numbers.pop(0)         # take the currently first number in the list
    primes.append(prime)           # add it to the list of primes
    numbers = [num for num in numbers if num % prime != 0]  # from the list of numbers, remove those divisible by that prime
  return primes  # once the initial list of numbers is exhausted, return the list of all found primes
```

- The code first generates all the natural numbers from 2 to n, as well as an empty list for storing found primes.
Note: `range()` in python does not include the top value. For instance, `range(3)` would generate the numbers "0, 1, 2" and `range(2,3)` would only generate the number 2.
To properly find all primes occurring in the positive numbers up to and including n, it is therefore necessary to add 1 to the top argument. This is why the code reads `range(2, n + 1)` rather than `range(2, n)`.

- As 2 is the smallest prime number, the first number in the list of `numbers` is already prime, so the sieve of Eratosthenes takes out that number using `numbers.pop(0)` (the list `numbers`now goes from 3 to n) and puts it into the list of primes.
Note: The argument in `pop()` specifies which element of a list is taken out. By default, `pop()` takes out the final element of the list. `pop(0)` makes sure the first element is taken instead.

- The code then uses a list comprehension to filter the list of numbers against that first prime number. This can be a bit complex to read, but is compact notation:
`num for num in numbers if num % prime != 0` is roughly equivalent to (but more efficient than):

```python
new_numbers = []                # construct a new list of numbers
for num in numbers:             # for each number in numbers,
    if num % prime != 0:        # if the prime does NOT divide that number,
        new_numbers.append(num) # add the number to the list of new numbers
numbers = new_numbers           # then use the new list in place of the old list
```
`%` here denotes the modulo function which returns the rest of a division. For instance, 7/3 = 2 with 1 rest, so 7 % 3 would be 1.
If the outcome is 0 (for instance 6/3 = 2 with 0 rest, so 6 % 3 is 0), it means the right argument cleanly divides the left argument.
Since in the above code, the right argument here would initially be 2, this list comprehension filters out all numbers divisible by 2 such as 4, 6, 8, ...
The list `numbers` now contains no more numbers divisible by 2, and the first number in the list must be the next prime number. In this case, that would be 3.

- From here, the loop is finished and the code returns to the initial line of the loop: `while numbers:`

- If the list `numbers` is now exhausted, the loop is escaped and the list of found primes is found. Otherwise, the loop starts over with the now filtered and necessarily smaller list `numbers`.

The while loop is guaranteed to escape eventually, as the list `numbers` is finite, and at the very least one element is removed from that list every step using `pop()`, and so for positive integers as input `n`, it will correctly find all prime numbers up to the specified size, stored in a list sorted from the smallest (2) to the largest prime in the given range..
For integers smaller than 2, it will just return the empty list `[]`.
Note: for non-integer values, `sieve_of_eratosthenes` will throw a TypeError as `range(2, n + 1)` expects `n` to be an integer.