`` python
def sieve_of_eratosthenes（n）：
  数字=リスト（範囲（2、n + 1））＃2からnまでリストを生成します
  プライム= []＃現在空のプライムナンバーリストを開始する
  数値：＃最初のリストに数字がある限り
    prime = numbers.pop（0）＃リストの現在の最初の番号を取得します
    Primes.Append（Prime）＃プライムのリストに追加
    数字= [数字のnum num num num％prime！= 0]＃数字のリストから、そのプライムで分割可能なものを削除します
  返品プライム＃数字の最初のリストが使い果たされたら、見つかったすべてのプライムのリストを返します
`` `

 - コードは、最初に2からnのすべての自然数を生成し、発見されたプライムを保存するための空のリストを生成します。
注： `range（）` Pythonには最高値が含まれていません。たとえば、 `範囲（3）`は数字 "0、1、2"を生成し、 `範囲（2,3）`は数値2のみを生成します。
したがって、Nを含むすべてのプライムが正の数で発生していることを適切に見つけるには、最上位の引数に1を追加する必要があります。これが、コードが「範囲（2、n + 1）」ではなく「2、n） `ではなく「範囲（2、n + 1）」を読み取る理由です。

 -  2が最小のプライム番号であるため、「数字」のリストの最初の数字はすでにプライムであるため、eratosthenesのふるいは `numbers.pop（0）`を使用してその数字を取り出します3からn）、そしてそれを素数のリストに入れます。
注： `pop（）`の引数は、リストのどの要素が削除されるかを指定します。デフォルトでは、 `pop（）`はリストの最終要素を取り出します。`pop（0）`最初の要素が代わりに撮影されることを確認します。

 - 次に、コードはリストの理解を使用して、その最初の素数に対して数字のリストをフィルタリングします。これは少し複雑になる可能性がありますが、コンパクトな表記です。
num num num on num in num num％prime！= 0`はほぼ同等です（ただし、より効率的です）：

`` python
new_numbers = []＃数字の新しいリストを作成する
数字のnumについて：＃数字の数ごとに、
    num％prime！= 0の場合：＃プライムがその数を除算しない場合、
        new_numbers.append（num）＃新しい数字のリストに番号を追加する
数字= new_Numbers＃次に、古いリストの代わりに新しいリストを使用します
`` `
`％`ここでは、部門の残りの部分を返すmodulo関数を示します。たとえば、7/3 = 2が1つの休息であるため、7％3は1になります。
結果が0の場合（たとえば6/3 = 2が0であるため、6％3は0です）、右の引数が左引数をきれいに分割することを意味します。
上記のコードでは、ここでの正しい引数は最初に2になるため、このリスト理解は、4、6、8、...などのすべての数値を2で割り切れる可能性のあるすべての数値をフィルタリングします。
リスト「番号」には2で割り切れる数字が含まれていないようになり、リストの最初の数字は次のプライム番号でなければなりません。この場合、それは3です。

 - ここからループが終了し、コードがループの初期行に戻ります： `while numbers：`

 - リスト「数字」が使い果たされるようになった場合、ループが逃げ、発見されたプライムのリストが見つかります。それ以外の場合、ループは、現在フィルター処理された、必然的に小さいリスト「番号」から始まります。

whileループは最終的に逃げることが保証されます。リスト「数字」は有限であり、少なくとも1つの要素が `pop（）`を使用してそのリストから削除されます。指定されたサイズまでのすべての素数を正しく見つけます。これは、最小（2）から与えられた範囲で最大のプライムにソートされたリストに保存されます。
2より小さい整数の場合、空のリスト `[]`を返すだけです。
注：非整数の値の場合、「sieve_of_eratosthenes」は `範囲（2、n + 1）としてtypeRrorをスローします。
```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.