
Portuguese: 
Eu disse que não precisamos de novas construções, mas agora vou introduzir uma nova.
Ela irá tornar o código que precisamos escrever para uma máquina de busca mais conveniente.
Ela será útil para muitos e muitos procedimentos que vamos querer escrever.
A construção que vamos introduzir é chamada loop.
Ela é uma maneira de fazer coisas repetidamente.
O tipo de loop que vamos introduzir é chamado while loop.
A sintaxe de um while loop é:
temos a palavra chave while, seguida de uma expressão condicional,
seguida de : e dentro temos um bloco --
um bloco é uma sequência de comandos.
Isso é bastante semelhante ao comando if.
Então, para lembrar, aqui está como é um comando if:
temos if, seguido de uma condição, seguida de :
e então um bloco, identado, que é uma sequência de comandos,
que são executados sempre que a condição avalia para o valor True.
Com if, o bloco é excutado o ou 1 vez, dependendo de se a condição é True.

Spanish: 
Dije que no necesitábamos nuevas estructuras, Pero vamos a ver una
Y eso va hacer que escribir el código que necesitamos para nuestro motor de búsqueda sea mucho más conveniente
Esto va a ser muy util para muchos procedimientos que vamos a escribir
Y la estructura que vamos a presentar es llamada un bucle
Es una forma de hacer las cosas una y otra vez
El tipo de bucle que vamos a presentar primero es llamado bucle while
La sintaxis para el bucle while es esta
Tenemos la palabra clave while, seguida por una expresion de prueba
Seguida por dos puntos, y dentro tenemos el bloque
Y el bloque es una secuencia de instrucciones
Esto es similar a la sentencia if
A modo de recordatorio, aquí tenemos la estructura de la sentencia if
Teníamos un if seguido por una expresión de prueba, seguida de dos puntos
y luego un bloque indentado, que es una lista de sentencias
Que se ejecutan siempre que la expresion de prueba es evaluada como verdadero
con if el bloque se ejecuta uno o más veces, dependiendo si la expresión de prueba es verdadera

Russian: 
Я говорил, что мы можем обойтись и без новых конструкций, но нам предстоит
познакомиться еще с одной, которая значительно облегчит написание поисковой системы.
Она очень пригодится и для множества процедур, которые нам предстоит написать,
и эта конструкция называется циклом.
Циклы позволяют повторять одни и те же действия снова и снова.
Первый цикл, с которым мы познакомимся, называется while-циклом.
Синтаксис while-цикла таков:
сначала идет ключевое слово while, за которым следует ,
затем двоеточие, и вложенный ,
который представляет собой последовательность инструкций.
Это очень похоже на инструкцию if.
Давайте вспомним, как выглядит инструкция if:
ключевое слово if, за которым следуют , двоеточие
и вложенный , представляющий собой список инструкций,
которые выполняются всякий раз, когда проверяемое выражение равно True.
В случае с if  выполняется ноль или один раз, в зависимости от того, истинно ли .

Italian: 
Ho detto che non necessitiamo di nessun nuovo costrutto, ma ne introdurremo uno
e ci renderà molto più conveniente scrivere il codice per il nostro motore di ricerca.
Sarà molto utile anche per moltissime altre procedure che dovremo scrivere
e il costrutto è chiamato ciclo [loop]
E' un modo per ripetere le cose
Il tipo di ciclo che introduciamo per primo è detto "ciclo while" [mentre]
La sintassi per il ciclo while è questa:
abbiamo la parola chiave "while", seguita da una espressione di test
seguita da due punti, e poi abbiamo un blocco [block]
e il blocco è una sequenza di istruzioni.
E' molto simile all'istruzione "if"
così come promemoria, qui è come appare l'istruzione "if"
abbiamo "if" seguito da una espressione di test, seguida da due punti
e un blocco indentato, che è una lista di istruzioni
che va in esecuzione tutte le volte che l'espressione di test risulta "True"
Con "if", il blocco viene eseguito zero o una volta, dipende se la espressione di test è vera.

English: 
I said we didn't need any new constructs, but we are gonna introduce one
and that's gonna make writing the code we need for a search engine much more convenient
It's also gonna be very useful for lots and lots of procedures that we wanna write
and the construct we are gonna introduce is called a loop
It's a way to do things over and over again
The kind of loop that we are gonna introduce first is called the while loop
The syntax for the while loop is this
We have the key word "while", followed by a test expression
followed by a colon, and then inside we have a "block"
and the "block" is a sequence of instructions
This is very similar to the "if" statement
So as a reminder, here's what the "if" statement look like
we had an "if" followed by a test expression, followed by a colon
and then an indented "block", which is a list of statements
that executes whenever the test expression evaluates to a "True" value
With "if", the block executes either zero or one times, depending on whether the test expression is "True"

Arabic: 
لقد قلت أننا لا نحتاج إلى أي تركيبات جديدة، ولكننا سنقوم بتقديم واحدة
وهذا سيجعل عملية كتابة الكود الذي نحتاجه لمحرك البحث أكثر ملاءمة
كما أنها ستكون مفيدة جدًا للكثير والكثير من الإجراءات التي نريد كتابتها
أما التركيبة التي نحن بصدد تقديمها فتسمى loop التكرار الحلقي
وهي وسيلة للقيام بالأشياء مرارًا وتكرارًا
نوع التكرار الحلقي الذي سنقوم بتقديمه أولاً يسمى التكرار الحلقي while
يكون بناء الجملة في التكرار الحلقي loop كما يلي
الكلمة الأساسية "while"، يليها تعبير الاختبار &lt;test expression>
"ثم النقطتين، ومن ثم في الداخل لدينا "block
و"block" هو تسلسل من التعليمات
"هذا مشابه جدًا لعبارة "if
"وكتذكير، إليكم شكل عبارة "if
لدينا "if" يليها تعبير الاختبار&lt;test expression>، ثم النقطتين
ثم "block" المطلوبة وهي قائمة من العبارات
"التي يتم تنفيذها عندما يتم تقييم تعبير الاختبار إلى القيمة "True
"مع عبارة "if"، تنفذ block السابقة إما صفر أو مرة واحدة، وهذا يتوقف على ما إذا كان تعبير الاختبار "True

Japanese: 
新たな構造体は必要ないと言いましたが
1つご紹介します
検索エンジンに必要なコードを書くのに
非常に便利なものです
また書く必要のある非常に多くの関数にも
とても役立ちます
これから挿入する構造体はループと呼ばれるもので
何度も物事を繰り返す方法です
まず初めに挿入するループは
whileループと呼ばれるものです
whileループの構文はこうです
キーワードwhileがあります　続いて条件式
さらに続くコロンがあります
そしてその中にループブロックがあります
ブロックは一連の命令になります
これはif文と非常に似ています
ちなみにif文はこんな感じになっています
ifがあってそれに続いて評価式
さらに続いてコロンがあります
そしてインデントされたブロックがあります
これは評価式がTrueに評価する時
常に実行する文のリストです
if文は評価式がTrueかどうかに応じて
ブロックをゼロまたは1回実行します

Chinese: 
我说过我们不需要新的建构了 但是我还是会再介绍一个
那会让我们为建立搜索引擎编写代码方便得多
它在很多过程中都会很有用
这一新建构叫做 loop（循环）
这是一种不断重复做事情的方式
我们要介绍的第一种循环叫做 while 循环
其结构如下
先是关键词 "while" 然后是一个测试表达式
再是一个冒号 里面是一个 "block"（程序块）
该程序块是一系列的指令
这和 if 语句非常相似
下面我们来回顾一下 if 语句
先是一个 "if" 然后是一个测试表达式 再是一个冒号
接着是一个缩进的程序块 也就是一系列的语句
当测试表达式的值为 "True" 该程序块执行
在 if 语句中 根据测试表达式是否为真 该程序块执行0或1次

Chinese: 
我曾說過我們不需要新的建構，但是我還要再介紹一個
當我們建立搜尋引擎時，它會使得寫程式變得非常方便
它在很多、很多程序中都很有用
我們要介紹的建構 (construct) 稱為循環 (loop)
這是一種不斷重複做事的方法
我們要介紹的第一種循環稱為 while loop
while loop 的語法如下
先是關鍵字 while ，
然後是測試運算式 (test expression)
再跟著冒號，裡面是程式塊 (block)
程式塊 (block) 是一系列的指令 (instructions)
這與 if 陳述非常類似
我們來回顧一下 if 陳述
先是一個 if，然後是測試運算式，再跟著冒號
接著是縮格的程式塊 (block)，是一系列的陳述
當測試運算式的值為 True ，就會執行程式塊
在 if 陳述，根據測試運算式的值是否為 True，
程式塊會執行 0 次或 1 次

Chinese: 
我说过我们不需要新的建构了 但是我还是会再介绍一个
那会让我们为建立搜索引擎编写代码方便得多
它在很多过程中都会很有用
这一新建构叫做loop（循环）
这是一种不断重复做事情的方式
我们要介绍的第一种循环叫做while循环
其结构如下
先是关键词“while” 然后是一个测试表达式
再是一个冒号 里面是一个“block”（程序块）
该程序块是一系列的指令
这和if语句非常相似
下面我们来回顾一下“if”语句
先是一个“if” 然后是一个测试表达式 再是一个冒号
接着是一个缩进的程序块 也就是一系列的语句
当测试表达式的值为“True”（真） 该程序块执行
在“if”语句中 根据测试表达式是否为真 该程序块执行0或1次

Japanese: 
whileではブロックを何回でも実行できます
条件式がTrueの限り継続します
つまりif文では評価式がTrueの場合
ブロックに行ってブロックを実行し
そのあと継続します
評価式がFalseの場合は次の式にすぐ取り掛かります
whileでも条件式がTrueの場合はブロックに進みます
しかし今回はブロックのあとにある
次の文に進むのではなく
戻ってもう一度条件式を試します
それがTrueの場合ブロックに戻ります
常に条件式に戻って
それがTrueの時はもう一度ブロックを実行して
条件式に戻ります
再びTrueの場合もう一度ブロックを行って
条件式に戻ります
そして条件式がTrueである限り
必要なだけ何度も続けることができます
ブロックを実行し続け何度も条件式を評価し続けます
ある時点で条件式がFalseになるでしょう
条件式がFalseになったら次の命令に進みます

Portuguese: 
Com while, o bloco pode ser executado quelquer número de vezes,
ele é executado enquanto a expressão condicional é True.
Com o comando if, se a condição for True,
vamos para o bloco, executamos o bloco, e então continuamos;
se a condição for False, vamos diretamente para o próximo comando.
Com um while, também começamos verificando a expressão condicional:
se ela for True, vamos para o bloco,
mas, agora, ao invés de ir para o próximo comando, depois do bloco, voltamos
e testamos a condição novamente. Se ela for True, vamos de novo para o bloco,
sempre voltamos a testar a condição.
Se ela for True, executamos o bloco de novo e voltamos a testar a condição,
se ela for True de novo, executamos o bloco de novo, e voltamos a testar a condição,
e continuamos fazendo isso tantas vezes quantas necessário -- desde que a condição seja True,
continuamos a executar o bloco e a testar a condição novamente.
Em algum momento, talvez a condição seja False --
uma vez que a condição seja False, nós vamos para o próximo comando.

Russian: 
В случае с while  может выполняться произвольное число раз;
его выполнение будет повторяться пока  равно True.
Если проверяемое выражение инструкции if равно True,
мы переходим к блоку, выполняем его и идем дальше.
если проверяемое выражение равно False, мы сразу переходим к следующей инструкции.
В случае с while мы тоже сначала вычисляем проверяемое выражение.
Если оно истинно, мы переходим к вложенному блоку,
но вместо того, чтобы перейти к следующей инструкции после выполнения блока,
мы снова вычисляем проверяемое выражение, и если оно истинно, мы возвращаемся к блоку.
Каждый раз мы возвращаемся к тестовому выражению.
Если оно равно True, мы снова выполняем блок и снова вычисляем его значение.
Если оно снова истинно, мы опять выполняем блок и вычисляем проверочное выражение,
и мы можем повторять этот процесс столько раз, сколько нужно – пока проверяемое выражение равно True,
мы повторяем выполнение блока и вычисляем проверяемое выражение.
В какой-то момент проверяемое выражение возможно станет равным False.
Как только оно станет ложным, мы перейдем к следующей инструкции.

Chinese: 
在while循环中 该程序块可以执行任意次数
只要测试表达式为真 程序就不断运行
在“if”语句中 如果测试表达式为真
我们就执行该程序块 然后继续
如果测试表达式为假 我们就直接跳到下一表达式
在while循环中 我们也是先检查测试表达式
如果为真 我们就运行该程序块
但是之后我们会回到前面 而不是跳到下一个语句
我们再次检查测试表达式 如果为真 我们运行程序块
我们总是回到测试表达式
如果为真 我们就再次运行程序块 然后回到测试表达式
如果还为真 就再次运行程序块 然后再回到测试表达式
只要测试表达式为真 重复多少次都行
我们会不断地运行该程序块 不断地再次检查测试表达式
到某个时候 测试表达式可能为假
一旦测试表达式为假 我们就执行下一个指令

Italian: 
Con "while", il blocco più essere eseguito qualsiasi numero di volte
Dura finchè l'espressione di test è il valore "True"
Come l'istruzione "if", se l'espressione test è vera
entriamo nel blocco, eseguiamo il blocco e proseguiamo
se l'espressione di test è "False", andiamo all'istruzione successiva
Con "while", cominciamo ancora verificando l'epressione di test
se è "True", entriamo nel blocco
ma ora, invece di andare all'istruzione successiva, dopo il blocco, torniamo indietro
e proviamo l'espressione di test nuovamente. Se è "True", torniamo nel blocco
e torniamo sempre all'espressione di test
se è vera, entriamo nel blocco di nuovo, e torniamo all'espressione di test
se è vera ancora, entriamo ancora nel blocco, e torniamo all'espressione di test
e possiamo continuare quante è necessario finchè l'espressione di test è "True".
Continuiamo ad eseguire il blocco e continuiamo a testare l'espressione di test ancora
A qualche punto, probabilmente l'espressione di test diventa "False"
Una volta che è "False", andiamo all'istruzione successiva

Spanish: 
Con While el bloque puede ejecutarse cualquier número de veces
Continúa ejecutándose mientras la expresión de prueba sea verdadera
Entonces con la sentencia if, si la expresión de prueba es verdadera
entramos en el bloque, ejecutamos el bloque y luego continuamos
si la expresión de prueba fue falsa vamos directamente a la siguiente expresión.
Con un while, tambien verificamos la expresion de prueba
Si es verdadera, entramos al bloque
Pero ahora en lugar de ir a la siguiente sentencia, después del bloque, regresamos
probamos la expresión de prueba nuevamente, si es verdad volvemos al bloque
Siempre regresamos a la expresión de prueba
Si es verdad ejecutamos el bloque y volvemos a la expresión de prueba
Nuevamente, si es verdad, ejecutamos el bloque y regresamos a la expresion de prueba
Y podemos regresar tantas veces como que queramos; mientras la expresión de prueba sea verdad
Seguiremos ejecutando el bloque e intentando el test de prueba,
En algún punto, quizás la expresión de prueba es falsa
Una vez que la expresión de prueba es falsa pasamos a la siguiente instrucción.

Chinese: 
在 while 循环中 该程序块可以执行任意次数
只要测试表达式为真 程序就不断运行
在 if 语句中 如果测试表达式为真
我们就执行该程序块 然后继续
如果测试表达式为假 我们就直接跳到下一表达式
在 while 循环中 我们也是先检查测试表达式
如果为真 我们就运行该程序块
但是之后我们会回到前面 而不是跳到下一个语句
我们再次检查测试表达式 如果为真 我们运行程序块
我们总是回到测试表达式
如果为真 我们就再次运行程序块 然后回到测试表达式
如果还为真 就再次运行程序块 然后再回到测试表达式
只要测试表达式为真 重复多少次都行
我们会不断地运行该程序块 不断地再次检查测试表达式
到某个时候 测试表达式可能为假
一旦测试表达式为假 我们就执行下一个指令

English: 
With "while", the block can execute any number of times
It keeps going as long as the test expression is "True"
So with the "if " statement, if the test expression is "True"
we go to the block, run the block and then continue
if the test expression was "False", we go right to the next expression
With a "while", we also start by checking the test expression
if it's "True", we go to the block
But now, instead of going to the next statement, after the block, we go back
we try the test expression again, if it's "True", we go back to the block
we always go back to the test expression
if it's "True", we do the block again, we go back to the test expression
If it's "True" again, we do the block again, we go back to the test expression
and we can keep going around as many times as we need as long as the test expression is "True"
we'll keep executing the block and keep trying the test expression again
At some point, maybe the test expression is "False"
Once the test expression is "False", we go to the next instruction

Chinese: 
使用 while ，程式塊可以執行任意的次數
只要測試運算式是 True，程式塊就會繼續執行
在if 陳述，如果測試運算式是 True
我們就進入程式塊，執行它，然後繼續下去
如果測試運算式是 False，我們直接跳到下一個運算式
使用 while，一開始也是檢查測試運算式
如果是 True ，我們進入程式塊
但是在執行程式塊之後，我們會回到前面，
而不是跳到下一個陳述
我們再次檢查測試運算式，
如果是 True，我們再次執行程式塊
我們總是回到測試運算式
如果是 True，我們就再次執行程式塊，
然後回到測試運算式
如果還是 True，我們就再次執行程式塊，
然後回到測試運算式
只要測試運算式是 True，
我們會繼續下去重複，多少次都可以
我們會不斷地執行程式塊，不斷地檢查測試運算式
到某個時候，測試運算式可能是 False
一旦測試運算式是 False，我們就執行下一個指令

Arabic: 
بالعبارة "while" يمكن أن تنفذ block أي عدد من المرات
"فهي لا تكف عن المتابعة طالما أن تعبير الاختبار "True
"لذا مع عبارة "if"، إذا كان تعبير الاختبار "True
ننتقل إلى block، ونقوم بتشغيل block ومن ثم الاستمرار
" إذا كان التعبير الاختبار
،"مع "while"، نبدأ أيضًا بالتحقق من تعبير الاختبار ما إذا كان "True
،ننتقل إلى block
،ولكن الآن، بدلاً من الذهاب إلى العبارة التالية، بعد block، نعود مرة أخرى
ونجرب تعبير الاختبار مرة أخرى، إذا كان "True"، نعود إلى block
إننا دائمًا نعود إلى تعبير الاختبار
،إذا كان "True"، ننفذ block مرة أخرى، ونعود إلى تعبير الاختبار
إذا كان "True" مرة أخرى، ننفذ block مرة أخرى، ونعود إلى تعبير الاختبار
"ويمكننا المتابعة عدة مرات كما نريد طالما أن تعبير الاختبار "True
سنستمر في تنفيذ block ونستمر في تجربة تعبير الاختبار مرة أخرى
" في بعض النقاط، قد يكون تعبير الاختبار
" بمجرد معرفة أن تعبير الاختبار

Chinese: 
也就是说 while循环可能执行程序块0次
如果测试表达式在一开始就为假
可能执行1次 如果测试表达式第一次为真 但第二次为假
可能执行2次 3次 或任意次数 它可以永远运行下去
没有什么条件能保证测试表达式最终会为假
下面是while循环的一个例子
我们先引入变量i 赋值为0
然后使用while循环 测试表达式为 i小于10
只要该表达式为真 我们就执行程序块
程序块为 print（打印）i 然后让i加1
这就是程序块内的指令
一开始 i的值为0 i小于10
我们将进入循环
测试表达式为真 我们将执行程序块 打印i
我们看到0这个值被打印出来
下面我们进行赋值 这将改变i的值

Chinese: 
也就是說， while loop 可能執行程式塊
0 次，如果一開始測試運算式就是 False
1 次，如果測試運算式第一次是True ，第二次是 False
2次，3次，或任意次數，它可以永遠繼續下去
沒有什麼必要條件，保證測試運算式最後會是 False
下面是 while loop 的例子
我們先引入變數 i ，初始值為 0
然後使用 while ，測試運算式為 i < 10
也就是說，只要這個值是 True，我們就執行程式塊
程式塊會印出 i， 然後將 i 值加 1
這是程式塊做的事
一開始 i 的值為 0 ， i 小於10
表示我們會進入 loop
這表示測試運算式是 True，我們會進入程式塊，印出 i
我們看到印出了 0
然後我們做指定 (assignment)，這會改變 i 的值

Portuguese: 
Então, isso significa eu um while loop executa o bloco
0 vezes, se a expressão condicional for False na primeira vez,
1 vez, se ela for True na primeira vez, mas False depois disso,
2 vezes, 3 vezes... qualquer número de vezes -- pode até mesmo repetir indefinidamente.
Não existe nenhum requerimento que garanta que a condição eventualmente se torne False.
Aqui está um exemplo de um while loop.
Eu inicializei a variável i, com o valor 0.
Então, eu tenho um while, onde a condição é i<10.
Isso significa que, desde que isso avalie para True, nós avaliamos o bloco,
e o que o bloco faz é imprimir i, e depois somar 1 a i.
Então, aqui está o que acontece quando isso é executado.
Inicialmente, o valor é 0 -- isso é manor que 10,
o que significa que vamos entrar no loop.
Então, isso significa que a condição é True, e portanto entramos no bloco e imprimimos i --
vemos o valor 0 impresso.
E então fazemos a atribuição -- isso altera o valor de i,

English: 
So this means a while loop can execute the block
either zero times if the test expression was "False" at the beginning
one time if it was "True" the first time, but "False" after that
two times, three times...any number of times, it could keep going forever
There's no requirement that guarantees the test expression eventually becomes "False"
So here's an example of while loop.
We start by initializing variable i, and we'll give it a value, zero
then we have the "while", the test expression says i is less than ten
So that means as long as this evaluates to "True", we'll evaluate the block
and what the block does is print i and then add one to i
So here's what happens when this executes
So initially, the value of i is zero, i is less than ten
So that means we'll enter the loop
So that means the test expression is "True", so we'll enter the block, we'll print i
So we'll see the value zero printed
and then we'll do the assignment, so that will change the value of i

Chinese: 
也就是说 while 循环可能执行程序块0次
如果测试表达式在一开始就为假
可能执行1次 如果测试表达式第一次为真 但第二次为假
可能执行2次 3次 或任意次数 它可以永远运行下去
没有什么条件能保证测试表达式最终会为假
下面是 while 循环的一个例子
我们先引入变量i 赋值为0
然后使用 while 循环 测试表达式为 i小于10
只要该表达式为真 我们就执行程序块
程序块为 print i 然后让i加1
这就是程序块内的指令
一开始 i的值为0 i小于10
我们将进入循环
测试表达式为真 我们将执行程序块 打印i
我们看到0这个值被打印出来
下面我们进行赋值 这将改变i的值

Italian: 
Questo significa che possiamo eseguire il blocco
sia 0 volte, se l'espressione di test è falsa all'inizio
una volta se è "True" la prima volta ma poi "False"
due volte, tre volte, qualsiasi numero di volte, può continuare per sempre
Non c'è nessuna garanzia che il l'espressione di test diventi falsa
Questo è un esempio di ciclo while.
Cominciamo inizializzando la variabile "i", e le diamo il valore "0"
poi abbiamo "while", l'espressione di test dice "i è minore di 10"
Significa che finchè questa sarà valutata a "True", eseguiremo il blocco
e il blocco stampa il valore di "i" e poi gli aggiunge 1
Seguiamo quello che succede quando mandiamo in esecuzione
Inizialmente, il valore di i è zero, che è minore di uno
Significa che entriamo nel loop
L'espressione di test è vera, così entriamo nel blocco e stampiamo "i"
Vediamo il valore "0" stampato
e quando facciamo l'assegnamento, questo cambia il valore di "i"

Arabic: 
وهذا يعني أن التكرار الحلقي "while" لا يمكنه تنفيذ block
" إذا كان تعبير الاختبار
"أو يمكنه تنفيذها مرة واحدة إذا كان "True" في المرة الأولى، و
وتنفيذها مرتين أو ثلاث مرات...أو أي عدد من المرات، يمكن أن تستمر إلى الأبد
" ليس هناك شرط يضمن أن يصبح تعبير الاختبار في نهاية المطاف
.ولذا إليكم مثال حول التكرار الحلقي while
نبدأ بتهيئة المتغير i وسنعطيه القيمة صفرًا
بعد ذلك لدينا "while"، ويخبرنا تعبير الاختبار أن المتغير i أقل من 10
وهذا يعني ما دام هذا التقييم "True"، فسنقوم بتقييم block
وما تقوم به block هو طباعة i ثم إضافة 1 إليه
وإليكم ما يحدث عند تنفيذ ذلك
في البداية، تكون قيمة i صفرًا، وi أقل من 10
وهذا يعني أننا سندخل التكرار الحلقي
وهذا يعني أن تعبير الاختبار "True"، لذلك سندخل block، وسنقوم بطباعة i
لذلك سنرى القيمة صفرًا مطبوعة
وبعد ذلك سنقوم بهذا التخصيص، بحيث سيغير قيمة i

Spanish: 
Entonces esto significa que un bucle while puede ejecutar el bloque
Cero veces si la expresión de prueba fue falsa al principio,
Una vez si fue verdadera la primera vez pero falsa después de eso,
Dos veces, tres veces, cualquier número de veces podría seguir ejecutándose para siempre,
No hay requerimiento que garantice que la expresión de prueba sea falsa finalmente.
Aquí tienen un ejemplo de bucle while
Empezamos inicializando la variable i, y le vamos a dar el valor de cero
Luego tenemos el while, la expresión de prueba dice si i es <10
Eso significa que mientras esto se evalúe verdadero, evaluaremos el bloque
y lo que el bloque hace es mostrar i y luego le suma 1
aquí està lo que pasa cuando esto se ejecuta.
Entonces, inicialmente el valor de i es cero, i es menor que diez
entonces eso significa que entraremos al bucle
eso significa que la expresión de prueba es verdadera, entonces entraremos al bloque e imprimiremos i,
veremos el valor de cero mostrado.
y luego haremos la asignaciòn, eso cambiará el valor de i,

Japanese: 
最初に条件式がFalseになった場合
whileはループブロックを実行できません
最初がTrueでそのあとFalseだった場合は
1回実行します
また1回、2回、3回と何回もブロックを実行し
延々と続けることも可能です
条件式が最終的にFalseになると
保証する条件はありません
ではwhileループの例を挙げます
変数iを設定することから開始し
ゼロの値を与えます
そしてwhileを置きます
条件式でiは10より少ないとします
つまりこれがTrueに評価する限り
ブロックを評価するということです
そしてブロックはiを出力してそのあと1をiに加えます
これを実行すると次のようなことが起きます
最初iの値はゼロでiは10より少ないです
つまりループに入るということです
条件式がTrueなので
ブロックに入ってiを出力するという意味です
すると出力された値ゼロを確認できます
そこでiの値を変更できるように代入を行います

Russian: 
И это значит, что while-цикл может выполнять свой блок
либо ноль раз, если проверяемое выражение с самого начала равно False,
либо один раз, если оно сначала равно True, а после выполния блока равно False,
либо два, либо три раза.. любое, и даже бесконечное количество раз.
Нет никакого ограничения, которое гарантировало бы, что проверяемое условие когда-нибудь станет ложным.
И вот пример while-цикла.
Сначала мы инициализируем переменную i и присваиваем ей нулевое значение,
затем идет while-цикл, в котором проверяется условие i < 10.
То есть пока это выражение равно True, мы выполняем код в блоке,
который выводит на экран значение i, и затем увеличивает его на 1.
И вот что происходит, если мы запускаем код.
Сначала значение i равно нулю и меньше 10.
Это значит, что мы входим в цикл,
то есть проверяемое выражение равно True, мы входим в блок и выводим i.
После этого мы видим на экране 0,
и выполняем присваивание, которое изменяет значение i.

Italian: 
Aggiungiamo uno a "i", così ora il valore di "i" è 1
Se fosse stata una "if", avremmo finito ora, ma siccome è un "while", proseguiamo
Torniamo indietro, testiamo di nuovo, se "i" è minore di 10
Ora il valore di "i" è uno, che è ancora minore di 10
così continuiamo, torniamo nel blocco di nuovo
stampiamo "i", questa volta vediamo il valore 1
La prossima istruzione incrementa il valore di "i" di uno
che rende "i" pari a 2
Ora "i" contiene il numero "2"
Siccome è un "while", continuiamo, torniamo all'espressione di test
"i" è minore di 10, ancora minore di 10, ora è 2, stamperemo 2
aggiungiamo 1 che rende "i" pari a 3
e proseguiamo qualche iterazione.

Spanish: 
sumamos uno a i, entonces eso va a hacer que el valor de i ahora haga referencia a uno.
Si hubiese sido un if, ya habríamos terminado, pero debido a que es un while, seguimos ejecutando
regresamos a la prueba nuevamente, si i es menor que diez
Ahora el valor de i es uno, lo cual también es menor que diez
entonces continuamos, vamos al bloque nuevamente
vamos a mostrar i, esta vez veremos el valor de uno.
Luego vamos a la siguiente expresión, incrementamos el valor de i en uno
eso va a hacer el valor de i dos
ahora i refiere al número dos
debido a que es un while, seguimos ejecutando, regresamos de nuevo a la expresión de prueba
i es menor que diez, todavía menor que diez, ahora es dos, vamos a mostrar dos
vamos a sumar uno y eso hará que el valor de i tres
y vamos a continuar

Arabic: 
نضيف 1 إلى i، بحيث ستعمل على جعل قيمة i الآن تشير إلى 1
إذا كانت عبارة "if"، فسنكون قد انتهينا الآن، ولكن لأنها "while"، فسنتابع
في حالة تطابقهما، مثلما فعلنا في الإصدار while، ينبغي لنا إرجاع النتيجة." ونكون قد انتهينا من التكرار الحلقي while
والآن قيمة i هي 1، حيث لا تزال أقل من 10
حسنًا سنتابع، انتقلوا إلى block مرة أخرى
سنقوم بطباعة i، وهذه المرة سنرى القيمة 1
ثم نذهب إلى العبارة التالية، ونضيف 1 إلى القيمة i
وهذا من شأنه جعل قيمة i تساوي 2
والآن تشير i إلى الرقم 2
نظرًا لأنها "while"، فعندما نستمر في المتابعة نعود إلى تعبير الاختبار
i أقل من 10، لا تزال أقل من 10، والآن تساوي 2، ونحن سنقوم بطباعة 2
سنقوم بإضافة 1 حيث سيجعل قيمة i تساوي 3
ونستمر بالمتابعة

Japanese: 
1をiに加えます
それによってiの値が1を参照するようになります
ifならここで終了ですが
これはwhileなので継続します
iが10より少ない場合は戻ってもう一度テストします
今iの値は1です　これも10より少ないです
そのため継続してまたブロックに戻ります
iを出力すると今度は値1を確認できます
そのあと次の文に移ります　iの値が1つ増えます
つまりiの値が2になります
現在iは値2を参照しています
これはwhileなので継続して条件式に戻ります
iはまだ10より少なく現在は2です　2を出力します
それに1を加えます　それによってiの値が3になります
続けましょう

English: 
We add one to i, so that's gonna be making the value of i now refers to one
So if it was an "if", we would be done now, but because it's a "while", we keep going
We go back, test again, if i is less than ten
Now the value of i is one, which also is less than ten
so we continue, go to the block again
we are gonna print i, this time we'll see the value one
Then we go to the next statement, increase the value of i by one
that's gonna make the value of i two
Now i refers to the number two
Because it's a "while", we keep going, we go back to the test expression
i is less than ten, still less than ten, now it's two, we are gonna print the two
we are gonna add one that it will make the value of i three
and we are gonna keep going

Chinese: 
让i加上1 所以现在i的值是1
如果这是一个“if” 到这里就结束了 但这是“while” 所以我们继续
我们回去 再次测试i是否小于10
现在i的值为1 还是小于10
所以我们继续 再次执行程序块
我们将打印i 这次我们将看到1这个值
下一个语句是让i的值增加1
这将让i的值变为2
所以现在i的值是2
因为这是一个while 我们继续 回到测试表达式
i仍然小于10 我们将打印2
再让i加1 让其值变为3
然后继续

Chinese: 
让i加上1 所以现在i的值是1
如果这是一个 "if" 到这里就结束了 但这是 "while" 所以我们继续
我们回去 再次测试i是否小于10
现在i的值为1 还是小于10
所以我们继续 再次执行程序块
我们将打印i 这次我们将看到1这个值
下一个语句是让i的值增加1
这将让i的值变为2
所以现在i的值是2
因为这是一个while 我们继续 回到测试表达式
i仍然小于10 我们将打印2
再让i加1 让其值变为3
然后继续

Chinese: 
讓 i 值加 1，所以現在 i 的值指向 1
如果這是 if ，到這裡就完成了，
但是，因為這是 while，所以我們繼續
我們回去，再做測試，是否 i < 10
現在 i 值是 1，還是小於10
所以我們繼續，再次執行程式塊
我們印出 i ，這次我們將看到 1
執行下一個陳述，讓 i 值增加 1
所以 i 值變為 2
現在 i 指向數字 2
因為這是 while，我們繼續，回到測試運算式
i 仍然小於 10，現在 i 是 2，我們將印出 2
再讓 i 值加1 ，變為 3
然後繼續

Portuguese: 
adicionamos 1 a i, e então a variável i agora referencia o valor 1.
Então, se isso fosse um if, teríamos terminado agora. Mas como é um while, continuamos:
voltamos, testamos de novo, se i < 10 --
agora o valor de i é 1, que também é menor que 10 --
então continuamos, vamos para o bloco de novo,
e vamos imprimir i, e desta vez vemos o valor 1.
Então vamos para o próximo comando: incrementamos i de 1 --
isso faz com que o valor de i seja 2.
Agora i referencia o número 2.
Como é um while, voltamos ao teste,
i < 10 -- ainda é menor que 10, agora é 2 -- vamos imprimir 2,
e vamos adicionar 1, o que faz com que o valor de i seja 3.
E continuamos fazendo isso.

Russian: 
Мы прибавляем 1 к i, и теперь i становится равным 1.
Если бы это была инструкция if, мы бы уже завершили ее выполнение, но так как мы имеем дело с while, то продолжаем.
Мы возвращаемся обратно, проверяем условие i < 10.
Теперь i равно 1 и по-прежнему меньше 10,
поэтому мы продолжаем, снова переходим к блоку,
выводим i и на этот раз видим единицу.
Затем мы переходим к следующей команде, увеличивая значение i на 1,
и теперь i равняется двум.
Теперь i хранит значение 2.
Поскольку это while-цикл, мы продолжаем его выполнение, возвращаясь к проверяемому условию,
i меньше.. по-прежнему меньше 10, и теперь оно равно 2, так что мы выводим двойку,
увеличиваем i на 1, после чего оно становится равным 3,
и продолжаем.

Chinese: 
再次測試， i 仍然小於 10，所以我們再次印出 i
我們將印出 9 這個值，然後將 9 加 1，得到 10
也就是 i 的新值
再次回來
現在檢查 i < 10，現在 i 值為 10
10 不小於10 ，所以測試運算式是 False，
while loop 結束了
我們將繼續執行這裡的陳述 (statement)，
在這個例子中，沒有任何陳述

Chinese: 
再次测试 i仍然小于10 所以我们将再次打印i
我们将打印9这个值 然后加1 9+1=10
也就是i现在的值
再回到上面
现在i的值为10
10不小于10 所以测试表达式为假 该while循环就结束了
我们将继续执行这里的语句 在这个例子中 这里没有别的语句

Italian: 
Test ancora, i è ancora minore di 10, così stamperemo i di nuovo
stampiamo il valore 9, poi aggiungiamo 1, otteniamo 10
Questo è il nuovo valore di i
e torniamo indietro
e ora testiamo i è minore di 10, e ora i ha il valore 10
10 non è minore di 10, così sarà "False" e abbiamo finito col ciclo while.
Continuiamo con qualsiasi istruzione qui, in questo caso non ne abbiamo nessuna

Chinese: 
再次测试 i仍然小于10 所以我们将再次打印i
我们将打印9这个值 然后加1 9+1=10
也就是i现在的值
再回到上面
现在i的值为10
10不小于10 所以测试表达式为假 该while循环就结束了
我们将继续执行这里的语句 在这个例子中 这里没有别的语句

Russian: 
..очередная проверка, i по-прежнему меньше 10, и поэтому мы снова выводим его на экран,
мы видим значение 9 и снова добавляем 1, складывая 1 и 9, получаем 10.
Это новое значение i,
и мы возвращаемся обратно,
снова проверяем условие i < 10, но теперь i равно 10.
10 не меньше 10, поэтому условие ложно, и мы выходим из while-цикла.
Мы переходим к выполнению следующих за ним инструкций, правда в данном случае их нет.

English: 
Test again, and i is still less than ten, so we are gonna print i again
we will print the value nine, then we add one, so that's gonna have one to nine, we'll get ten
So that's the new value of i
and we go back again
and now we do i is less than ten, and now i has the value ten
Ten is not less than ten, so that will be "False" and we are done with the while loop
We'll continue with whatever statements here, in this case, there is none

Portuguese: 
Testamos de novo, i é ainda menor que 10, então vamos imprimir i novamente,
vamos imprimir o valor 9, e então adicionar 1, e vamos obter 10 --
este é o valor de i.
E voltamos de novo,
e agora fazemos i < 10, e agora i tem o valor 10 --
10 não é menor que 10, e então isso é False, e terminamos o while loop.
Prosseguimos executando os comandos que apareçam aqui -- neste caso, nenhum.

Japanese: 
もう一度テストするとiはまだ10より少ないので
もう一度iを出力します
9の値を出力して1を加えます
つまり9に1増えて10になります
これがiの新しい値です
再び戻ります
iは10より少ないものでしたが
今iの値は10になりました
10は10より少なくないのでFalseになります
そしてwhileループを終了します
どんな文でも継続できます　この場合何もありません

Spanish: 
prueba de nuevo, e i todavía es menor que diez, entonces vamos a mostrar i de nuevo
mostraremos el valor de nuevo, luego sumaremos uno, eso es nueve mas uno, y obtendremos diez
entonces ese es el nuevo valor de i
y regresamos de nuevo
y ahora tenemos si i es menor que diez, y ahora i tiene el valor de diez
diez no es menor que diez, entonces eso será falso y hemos terminado el bucle while
continuaremos con cualquier expresión aquí, en este caso no hay ninguna

Arabic: 
نقوم بالاختبار مرة أخرى، i لا تزال أقل من 10، لذلك سنقوم بطباعة i مرة أخرى
سنقوم بطباعة القيمة 9، ثم نضيف 1، بحيث سيكون لدينا 1 إلى 9، سنحصل على 10
حسنًا هذه هي قيمة i الجديدة
ونعود مرة أخرى
والآن i&lt;10، أصبحت قيمة i تساوي 10
" 10ليست أقل من 10، وهكذا ستكون
سنقوم بالمتابعة مع أي عبارة أخرى هنا، وفي هذه الحالة لا يوجد

Chinese: 
我们一共执行了该循环10次
打印出了从0到9的所有整数
i的新值为10 如果接下去我们要使用i的值
这个值将是10
下面我们进行一个小测验 看看你们是否明白了while循环
问题是 运行该程序会得到什么结果
下面是这个程序的编码
首先将i赋值为0
然后是一个while循环
测试表达式为 i不等于10
然后是i=i+1
然后是print（打印）i
这和前面的例子很相似 但是在某些方面又有所不同
接下来就要看你们是否能思考出该程序的结果了
尽量自己思考得出答案
当然你们也可以在Python解释器里试着运行
选项为
产生一个错误

Chinese: 
我们一共执行了该循环10次
打印出了从0到9的所有整数
i的新值为10 如果接下去我们要使用i的值
这个值将是10
下面我们进行一个小测验 看看你们是否明白了while循环
问题是 运行该程序会得到什么结果
下面是这个程序的编码
首先将i赋值为0
然后是一个while循环
测试表达式为 i不等于10
然后是 i=i+1
然后是 print i
这和前面的例子很相似 但是在某些方面又有所不同
接下来就要看你们是否能思考出该程序的结果了
尽量自己思考得出答案
当然你们也可以在 Python 解释器里试着运行
选项为
产生一个错误

Portuguese: 
Então, terminamos o loop. O que fizemos foi executá-lo 10 vezes --
imprimimos os números de 0 a 9.
O novo valor de i será 10. Se fizermos qualquer coisa aqui, que use o valor de i,
veremos que o valor de i é 10.
Então, para ver se você entendeu while loops, aqui vai um teste.
A pergunta é: o que este programa faz?
Aqui está o programa:
Começamos atribuindo 0 a i,
temos então um while loop, onde o teste é i diferente de 10 --
então o teste é i != 10.
Então, temos i = i +1 -- estamos atribuindo a i o valor de i mais 1.
E então imprimimos i.
Isso é semelhante ao exemplo, mas um pouco diferente.
Então, cabe a você ver se consegue descobrir o que esse programa faz.
Tende descobrir por si próprio.
É claro que você pode também tentar executar isso no interpretador Python.
As opções são:
produz um erro;

Russian: 
И этот цикл – мы выполнили его десять раз,
выведя на экран числа от 0 до 9.
Новое значение i будет равно 10, и если после цикла мы выполним с ним какое-нибудь действие,
то увидим, что значение i равно 10.
И чтобы проверить, насколько хорошо вы понимаете while-циклы, мы зададим вам вопрос.
Вопрос таков: что делает данная программа?
Вот ее код:
сначала мы присваиваем i значение 0,
затем идет while-цикл c условием i != 10.
Оно истинно, когда i не равно 10.
Затем инструкцией i = i + 1 мы присваиваем i значение i + 1,
и затем выводим i на экран.
Это код похож на предыдущий пример, но кое-чем от него отличается.
Вам предстоит догадаться, что же делает эта программа.
Попробуйте сделать это самостоятельно.
Хотя вы также можете запустить этот код в интерпретаторе Python.
Возможные варианты:
программа выдает ошибку;

Arabic: 
حسنًا التكرار الحلقي الذي قمنا به، مررنا به عشر مرات
وقمنا بطباعة الأرقام من صفر إلى 9
قيمة i الجديدة ستكون 10، إذا قمنا بأي شيء هنا باستخدام قيمة i
فسنرى أن قيمة i تساوي 10
حسنًا لنرَ أنكم تفهمون الحلقات التكرارية while، فسيكون لدينا اختبار
حسنًا السؤال هو ماذا يفعل هذا البرنامج؟
هذا هو البرنامج
نبدأ بتخصيص صفر إلى i
لدينا التكرار الحلقي while حيث إن الاختبار لا يساوي 10
حسنًا فالاختبار هو أن i لا تساوي 10
حسنًا لدينا i=i+1، وسنقوم بتخصيص قيمة i+1 إلى i
ثم نقوم بطباعة i
هذا مشابه للمثال، ولكنه مختلف من أكثر من طريقة
الأمر متروك لكم لمعرفة ما إذا كان يمكنكم معرفة ما يفعله البرنامج
حاول أن تعرفوا ذلك بأنفسكم
(بالتأكيد يمكنكم محاولة تشغيل هذا في مُفسِّر (interpreter
الاختيارات هي
ينتج خطأ

Italian: 
Allora il ciclo che abbiamo fatto, ci siamo entrati 10 volte
e abbiamo stampato i valori da 0 a 9
Il nuovo valore di i sarà 10, se facessimo qualcosa che usi il valore di "i"
vedremmo che il valore di "i" è 10
Così vediamo se capisci i cicli while, faremo un quiz
La domanda è: cosa fa questo programma
Qui c'è il programma
Cominciamo assegnando 0 a i
Abbiamo un ciclo while, qui il test non è uguale a 10
così il test è "i non è uguale a 10"
Allora abbiamo i uguale a i più uno, così assegniamo a i il valore di i più uno
e stampiamo i
E' simile all'esempio, ma diverso in un po' di cose
E' a te vedere se puoi immaginare cosa fa il programma
Prova a pensarci da solo
Puoi certamente provare ad eseguire il programma nell'interprete Python
Le scelte sono:
produce un errore

Japanese: 
私たちはループを10回にわたって行い
ゼロから9までの数値を出力しました
iの新しい値は10です
ここでiの値を用いて何か行えば
iの値が10であることが確認できます
whileループが理解できているか確認するために
小テストを行います
問題はこのプログラムが行うことです
これがプログラムです
iにゼロを代入することから開始します
whileループがあります
テスト条件は10と等しくないことです
つまりテスト条件はiが10と等しくないことになります
i＝i＋1があります　ですからiにiの値＋1を代入します
そしてiを出力します
これは例と似ていますがいくつか違う点があります
プログラムが行うことを解明できるかはあなた次第です
自分で解き明かしてみてください
もちろんこれをPythonインタプリタで
実行することもできます
選択肢です
エラーを出す

Chinese: 
所以我們完成了 loop，我們執行了它 10 次
我們印出了從 0 到 9 的數字
i 的新值是 10 ，如果我們要使用 i 的值
i 值是 10
我們要進行測驗，看看你們是否明白了 while loops
問題是，這個程式在做什麼
程式在這裡
一開始將 i 指定為 0
然後有個 while loop，測試是否不等於 10
測試 i 不等於10
然後是 i=i+1，我們指定 i 的值為 i 加 1
然後印出 i
這和前面的例子很類似，但在某些方面又有所不同
接下來，就要看你們是否能了解程式在做什麼
盡量靠自己思考
當然你們也可以在 Python 解譯器裡執行看看
選項為
產生一個錯誤 (error)

English: 
So then the loopÃ¢Â€Â”Ã¢Â€Â”what we've done, we've gone through it ten times
we've printed the numbers from zero to nine
The new value of i will be ten, if we do anything here that uses the value of i
we'll see that the value of i is ten
So to see that you understand while loops, we'll have a quiz
So the question is what does this program do
Here's the program
We start by assigning zero to i
We have a while loop, where the test is not equal to ten
So the test is i is not equal to ten
Then we have i equals i plus one, so we are assigning to i the value of i plus one
and then we are printing i
So this is similar to the example, but different in a couple of ways
So it's up to you to see if you can figure out what the program does
Try to figure out yourself
You can certainly also try running this in the Python interpreter
The choices are
produce an error

Spanish: 
luego el bucle, lo que hemos hecho, hemos ido a traves de el diez veces
hemos mostrado los números de cero a nueve
El nuevo valor de i será diez, si hacemos algo aquí que use el valor de i
veremos que el valor de i es diez
Entonces, para ver si entendieron los bucles while, tendremos una prueba.
La pregunta es que hace este progama?
Aquí está el programa.
Empezamos asignando cero a i,
tenemos un bucle while, donde la prueba es i no es igual a 10
Entonces prueba es i no es igual a diez
luego tenemos i es igual a i mas uno, entonces estamos asignando a i el valor de i mas uno
y luego estamos mostrando i
Esto es similar al ejemplo, pero diferente en par de cosas
Entonces depende de ti ver si puedes determinar que hace el programa
trata de darte cuenta por tì mismo
Ciertmente también pueden probar ejecutando esto en el intéprete de pyhton
las opciones son:
produce un error

English: 
print out the numbers from zero to nine
print out the numbers from one to nine
print out the numbers from one to ten
or the final choice is it runs forever or at least until our machine runs out of power
So see if you can figure out what it does
You can definitely try running it
but try to figure out on your own before running it in the Python interpreter

Japanese: 
ゼロから9までの数値を出力する
1から9までの数値を出力する
1から10までの数値を出力する
延々と実行するもしくは
少なくとも機械のパワーがなくなるまで実行する
これを解明できたかどうか確認してみてください
もちろんこれを実行することはできますが
Pythonインタプリタで実行する前に
自分で解明してみてください

Chinese: 
打印出从0到9的所有整数
打印出从1到9的所有整数
打印出从1到10的所有整数
最后一项是 程序永远运行下去 或至少运行到机器没电为止
看你们能否自己想出答案
当然你们也可以试着运行这个程序
但是最好先自己想出答案 再在 Python 解释器中运行

Spanish: 
muestra los número de cero a nueve
muestra los números de uno hasta nueve
muestra los número de uno a diez
o la última opción es que se ejecuta para siempre o al menos hasta que nuestra máquina ya no pueda más.
Entonces si puedes determinar que hace
puedes probar ejecutarlo
pero trata de darte cuenta por ti mismo antes de ejecutarlo en el intèrprete de python

Chinese: 
打印出从0到9的所有整数
打印出从1到9的所有整数
打印出从1到10的所有整数
最后一项是 程序永远运行下去 或至少运行到机器没电为止
看你们能否自己想出答案
当然你们也可以试着运行这个程序
但是最好先自己想出答案 再在Python解释器中运行

Chinese: 
印出 0 到 9 的數字
印出 1 到 9 的數字
印出 1 到 10 的數字
最後的選項是程式永遠執行下去，
或是執行到機器沒電為止
看你們能否能想出答案
當然你們也可以試著執行它
但是最好自己先想答案，然後才在 Python 解譯器中執行

Portuguese: 
imprme os números de 0 a 9;
imprime os números de 1 a 9;
imprime os números de 1 a 10;
ou, última opção: executa para sempre, até que o computador fique sem bateria.
Então, veja se você pode descobrir o que isso faz.
Você pode certamente executá-lo,
mas tente descobrir por si próprio, antes de executar usando o interpretador Python.

Italian: 
stampa i numeri da 0 a 9
stampa i valori da 1 a 9
stampa i valori da 1 a 10
o la scelta finale è: continua per sempre almeno finchè la nostra macchina si spegnerà
Vedi se puoi pensare a cose fa
puoi davvero provare a eseguirlo

Arabic: 
طباعة الأرقام من 0 إلى 9
طباعة الأرقام من 1 إلى 9
طباعة الأرقام من 1 إلى 10
أو الخيار النهائي هو أن يعمل إلى الأبد أو على الأقل حتى تنفد الطاقة من الجهاز
حسنًا انظر ما إذا كان يمكنكم معرفة ما يفعله
يمكنكم بالتأكيد محاولة تشغيله
.(ولكن حاولوا أن تعرفوا بأنفسكم قبل تشغيله في مُفسِّر (interpreter

Russian: 
выводит числа от 0 до 9;
выводит числа от 1 до 9;
выводит числа от 1 до 10;
и наконец, выполняется бесконечно, или по крайней мере пока мы не отключим питание компьютера.
Попробуйте понять, что же делает этот код.
Вы конечно же можете запустить его,
но попробуйте все же получить ответ самостоятельно, прежде чем проверять его в интерпретаторе Python.

Italian: 
ma prova a scoprire da solo prima di eseguirlo nell'interprete Python
