Из 3 петель 3: Мастер — класс «три из трех»

Это не так уж и сложно, правда?

Давайте рассмотрим другой пример цикла for, в котором вы используете две переменные для определения вашего потока управления:

  языков = ['R', 'Python', 'Scala', 'Java', 'Julia']

для индекса в диапазоне (len (languages)):
   print ('Текущий язык:', языки [индекс])
  

  Текущий язык: R
Текущий язык: Python
Текущий язык: Scala
Текущий язык: Java
Текущий язык: Юлия
  

Как видите, цикл начинается с ключевого слова for .Затем вы используете переменные index и языков , в ключевом слове и функцию range () для создания последовательности чисел. Кроме того, вы видите, что в этом случае вы также используете функцию len () , поскольку список языков не является числовым. Фрагмент кода, который вы хотите выполнять повторно, - это оператор печати, а именно: print ('Current language:', languages ​​[index]) .

В приведенном выше цикле вы хотите выразить, что для каждого индекса в диапазоне len (languages) вы хотите распечатать язык программирования для науки о данных.Теперь len (languages) равно 5, поэтому оператор также можно переписать как:

  для индекса в диапазоне (5):
    print ('Текущий язык:', языки [индекс])
  

  Текущий язык: R
Текущий язык: Python
Текущий язык: Scala
Текущий язык: Java
Текущий язык: Юлия
  

И это снова дает тот же результат!

While против циклов For в Python

Давайте еще раз вернемся к самому первому примеру цикла while, чтобы определить, в чем именно теперь заключаются различия между циклами while и for.Вы уже читали выше, что разница заключается в условии, которое задействовано или не задействовано, но как это отражается в коде и как вы можете переключаться между ними?

  # Принять ввод пользователя
число = 2

а число <5:
    print («Спасибо»)
    # Увеличиваем число на 1
    число = число + 1
  

  Спасибо
Спасибо
Спасибо
  

Вы можете использовать цикл for для более контролируемой печати заявления «Спасибо»:

  # Распечатать "Спасибо" 3 раза
для числа в диапазоне (3):
    print («Спасибо»)
  

  Спасибо
Спасибо
Спасибо
  

Видите, как легко было преобразовать цикл while в эквивалент цикла for?

Как это работает, спросите вы? Ну это просто.

В цикле for целое число, упомянутое внутри функции диапазона, представляет собой диапазон или количество раз, которое элементу управления необходимо выполнить в цикле и выполнить код в предложении цикла for.

Обратите внимание на , что счетчик функции range () начинается с 0, а не с 1. Это означает, что в приведенном выше примере счет должен быть как 0,1,2, а не 1,2,3. Так работает подсчет чисел в памяти компьютера. Итак, при разработке цикла for всегда имейте в виду, что вы должны учитывать количество диапазонов от 0, а не от 1.

Совет : это то же самое, например, для списков в Python. Если вы хотите узнать больше о списках Python, ознакомьтесь с руководством DataCamp 18 самых распространенных вопросов о списках Python.

Есть еще одно интересное различие между циклом for и циклом while. Цикл for быстрее, чем цикл while. Чтобы понять это, вам нужно изучить приведенный ниже пример.

  импортное время

# Пример цикла for
def for_loop ():
    для числа в диапазоне (10000):
        # Выполнить приведенный ниже код 10000 раз
        сумма = 3 + 4
        #print (сумма)

timeit.timeit (for_loop)
  

  267.08047288
  
  импорт timeit

# Пример цикла while
def while_loop ():
    я = 0
    пока я <10000:
        сумма = 3 + 4
        #print (сумма)
        я + = 1

timeit.timeit (while_loop)
  
  884.17965908
  

 В приведенном выше фрагменте кода у вас есть два цикла с примерно 10000 итерациями. Оба выглядят одинаково на первый взгляд, пока вы не заглянете за кулисы и не поймете, как работают эти две петли.Подсказка: функция  timeit ()  подскажет, в чем может быть разница! 
  Помните : весь код Python компилируется компилятором C, а это означает, что код, который вы видите выше, сначала разбивается на байтовые коды, а затем обрабатывается базовым компилятором C. 
 Когда начинается выполнение цикла for в приведенном выше примере, интерпретатор Python обращается к базовому компилятору C, а затем создает объект списка размером 10000. Затем он вызывает итератор, чтобы коснуться индекса каждого из 10000 элементов. в списке.
 С другой стороны, выполнение цикла while не создает никаких объектов списка. Фактически, базовый компилятор C вызывает логический оператор сравнения для условия  i <10000  9999 раз. 
 Вы уже можете себе представить, что перебор уже созданного объекта списка с 10000 элементами проще для компилятора, чем повторное выполнение логической операции 9999 раз, время выполнения цикла for лучше, чем у цикла while. Это четко отражается во времени выполнения: время завершения цикла for намного меньше, чем время, необходимое для завершения цикла while.

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6IiMgU2V0IGBmaWJfbm9gIHRvIDU1LCB0aGUgbnVtYmVyIHVudGlsIHdoZXJlIHlvdSB3YW50IHRvIHByaW50XG5maWJfbm8gPSA1NVxuXG4jIFNldCBgZmlyc3Rfbm9gIHRvIDBcbmZpcnN0X25vID0gMFxuXG4jIFNldCBgc2Vjb25kX25vYCB0byAxXG5zZWNvbmRfbm8gPSAxXG5cbiMgU2V0IHRoZSBjb3VudGVyIGBjb3VudGAgdG8gMCBcbmNvdW50ID0gMFxuXG4jIHdoaWxlIGxvb3AgdG8gcHJpbnQgdGhlIGZpYm9uYWNjaSBzZXJpZXMgdW50aWwgdGhlIGBmaWJfbm9gXG53aGlsZSBmaXJzdF9ubyA8PSBmaWJfbm86XG4gICAgICAgIyBQcmludCBgZmlyc3Rfbm9gXG4gICAgICAgcHJpbnQoZmlyc3Rfbm8pXG4gICAgICAgXG4gICAgICAgIyBGaWJvbm5hY2NpIG51bWJlclxuICAgICAgIG50aCA9IGZpcnN0X25vICsgX19fX19fX19fX1xuICAgICAgIFxuICAgICAgICMgdXBkYXRlIHZhbHVlcyBvZiBgZmlyc3Rfbm9gIGFuZCBgc2Vjb25kX25vYFxuICAgICAgIGZpcnN0X25vID0gX19fX19fX19fX19fXG4gICAgICAgc2Vjb25kX25vID0gX19fXG4gICAgICAgXG4gICAgICAgIyBTZXQgY291bnRlciBgY291bnRgICsxXG4gICAgICAgX19fX19fX19fXyIsInNvbHV0aW9uIjoiIyBTZXQgYGZpYl9ub2AgdG8gNTUsIHRoZSBudW1iZXIgdW50aWwgd2hlcmUgeW91IHdhbnQgdG8gcHJpbnRcbmZpYl9ubyA9IDU1XG5cbiMgU2V0IGBmaXJzdF9ub2AgdG8gMFxuZmlyc3Rf bm8gPSAwXG5cbiMgU2V0IGBzZWNvbmRfbm9gIHRvIDFcbnNlY29uZF9ubyA9IDFcblxuIyBTZXQgdGhlIGNvdW50ZXIgYGNvdW50YCB0byAwIFxuY291bnQgPSAwXG5cbiMgd2hpbGUgbG9vcCB0byBwcmludCB0aGUgZmlib25hY2NpIHNlcmllcyB1bnRpbCB0aGUgYGZpYl9ub2BcbndoaWxlIGZpcnN0X25vIDw9IGZpYl9ubzpcbiAgICAgICAjIFByaW50IGBmaXJzdF9ub2BcbiAgICAgICBwcmludChmaXJzdF9ubylcbiAgICAgICBcbiAgICAgICAjIEZpYm9ubmFjY2kgbnVtYmVyXG4gICAgICAgbnRoID0gZmlyc3Rfbm8gKyBzZWNvbmRfbm9cbiAgICBcbiAgICAgICAjIHVwZGF0ZSB2YWx1ZXMgb2YgYGZpcnN0X25vYCBhbmQgYHNlY29uZF9ub2BcbiAgICAgICBmaXJzdF9ubyA9IHNlY29uZF9ub1xuICAgICAgIHNlY29uZF9ubyA9IG50aFxuICAgICAgIFxuICAgICAgICMgU2V0IGNvdW50ZXIgYGNvdW50YCArMVxuICAgICAgIGNvdW50ICs9IDEiLCJzY3QiOiJFeCgpLmNoZWNrX29iamVjdChcImZpYl9ub1wiLCAwKS5oYXNfZXF1YWxfdmFsdWUoaW5jb3JyZWN0X21zZz1cIkRpZCB5b3UgY29ycmVjdGx5IGRlZmluZSBgZmliX25vYD9cIilcbkV4KCkuaGFzX2VxdWFsX2FzdChcIllvdSBkb24ndCBuZWVkIHRvIGNoYW5nZSB0aGUgdmFsdWUgb2YgYGZpcnN0X25vYCFcIiwgY29kZT1cImZpcnN0X25vID0gMFwiLCBleGFjdD1GYWxzZSlcbkV4KCkuaGFzX2VxdWFsX2FzdChcIllvdSBkb24ndCBuZWVkIHRvIGNoYW5n ZSB0aGUgdmFsdWUgb2YgYHNlY29uZF9ub2AhXCIsIGNvZGU9XCJzZWNvbmRfbm8gPSAxXCIsIGV4YWN0PUZhbHNlKVxuRXgoKS5oYXNfZXF1YWxfYXN0KFwiWW91IGRvbid0IG5lZWQgdG8gY2hhbmdlIHRoZSB2YWx1ZSBvZiBgY291bnRgIVwiLCBjb2RlPVwiY291bnQgPSAwXCIsIGV4YWN0PUZhbHNlKVxuXG5FeCgpLmNoZWNrX3doaWxlKDApLmNoZWNrX3Rlc3QoKS5oYXNfZXF1YWxfYXN0KClcbkV4KCkuY2hlY2tfd2hpbGUoMCkuY2hlY2tfYm9keSgpLmNoZWNrX2Z1bmN0aW9uKFwicHJpbnRcIiwgMClcbkV4KCkuY2hlY2tfd2hpbGUoMCkuY2hlY2tfYm9keSgpLmhhc19lcXVhbF9hc3QoXCJJdCBsb29rcyBsaWtlIHRoZSBjb250ZW50cyBvZiBgbnRoYCBhcmVuJ3QgY29ycmVjdC5cIixcbiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY29kZT1cIm50aCA9IGZpcnN0X25vICsgc2Vjb25kX25vXCIsXG4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGV4YWN0PUZhbHNlKVxuRXgoKS5jaGVja193aGlsZSgwKS5jaGVja19ib2R5KCkuaGFzX2VxdWFsX2FzdChcIkl0IGxvb2tzIGxpa2UgdGhlIGNvbnRlbnRzIG9mIGBmaXJzdF9ub2AgYXJlbid0IGNvcnJlY3QuXCIsXG4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvZGU9XCJmaXJzdF9ubyA9IHNlY29uZF9ub1wiLFxuICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBleGFjdD1GYWxzZSlcbkV4KCkuY2hlY2tfd2hpbGUoMCkuY2hlY2tfYm9keSgpLmhhc19lcXVhbF9hc3QoXCJJdCBsb29rcyBsaWtlIHRoZSBjb250ZW50cyBvZiBgc2Vjb25kX25vYCBhcmVuJ3QgY29ycmVjdC5cIixcbiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY29kZT1cInNlY29uZF9ubyA9IG50aFwiLFxuICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBleGFjdD1GYWxzZSlcbkV4KCkuY2hlY2tfd2hpbGUoMCkuY2hlY2tfYm9keSgpLmhhc19lcXVhbF9hc3QoXCJJdCBsb29rcyBsaWtlIHRoZSB2YWx1ZSBvZiBgY291bnRgIGlzbid0IGNvcnJlY3QuXCIsXG4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvZGU9XCJjb3VudCArPSAxXCIsXG4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGV4YWN0PUZhbHNlKSJ9
 
 Теперь попробуйте цикл for! Обратите внимание, что вы хотите указать диапазон от 0 до 11, поскольку вы хотите отображать только числа в последовательности до 55, что является 11-м номером в последовательности.

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6IiMgSW5pdGlhbGl6ZSBgZmlyc3Rfbm9gIHRvIGAwYFxuZmlyc3Rfbm8gPSAwXG5cbiMgSW5pdGlhbGl6ZSBgc2Vjb25kX25vYCB0byBgMWBcbnNlY29uZF9ubyA9IDFcblxuIyBJbml0aWFsaXplIGBudW1iZXJzYFxubnVtYmVycyA9IF9fX19fX19fX19fXG5cbiMgRmluZCBhbmQgZGlzcGxheSBGaWJvbmFjY2kgc2VyaWVzXG5mb3IgbnVtIGluIF9fX19fX186XG4gICAgICAgICAgIGlmKG51bSA8PSAxKTpcbiAgICAgICAgICAgIyBVcGRhdGUgb25seSBgbnRoYFxuICAgICAgICAgICAgICAgICAgICAgIG50aCA9IF9fX1xuICAgICAgICAgICBlbHNlOlxuICAgICAgICAgICAjIFVwZGF0ZSB0aGUgdmFsdWVzIGBudGhgLCBgZmlyc3Rfbm9gIGFuZCBgc2Vjb25kX25vYFxuICAgICAgICAgICAgICAgICAgICAgIG50aCA9IGZpcnN0X25vICsgc2Vjb25kX25vXG4gICAgICAgICAgICAgICAgICAgICAgZmlyc3Rfbm8gPSBzZWNvbmRfbm9cbiAgICAgICAgICAgICAgICAgICAgICBzZWNvbmRfbm8gPSBfX19fX19fX19fXG4gICAgICAgICAgICAgICAgICAgICAgXG4gICAgICAgICAgICMgUHJpbnQgYG50aGBcbiAgICAgICAgICAgcHJpbnQobnRoKSIsInNvbHV0aW9uIjoiIyBJbml0aWFsaXplIGBmaXJzdF9ub2AgdG8gYDBgXG5maXJzdF9ubyA9IDBcblxuIyBJbml0aWFsaXplIGBzZWNvbmRfbm9gIHRvIGAxYFxuc2Vjb25kX25vID0gMVxuICAgICAgICAgICBcbiMgSW5p dGlhbGl6ZSBgbnVtYmVyc2Bcbm51bWJlcnMgPSByYW5nZSgwLDExKVxuXG4jIEZpbmQgYW5kIGRpc3BsYXkgRmlib25hY2NpIHNlcmllc1xuZm9yIG51bSBpbiBudW1iZXJzOlxuICAgICAgICAgICBpZihudW0gPD0gMSk6XG4gICAgICAgICAgICMgVXBkYXRlIG9ubHkgYG50aGBcbiAgICAgICAgICAgICAgICAgICAgICBudGggPSBudW1cbiAgICAgICAgICAgZWxzZTpcbiAgICAgICAgICAgIyBVcGRhdGUgdGhlIHZhbHVlcyBgbnRoYCwgYGZpcnN0X25vYCBhbmQgYHNlY29uZF9ub2BcbiAgICAgICAgICAgICAgICAgICAgICBudGggPSBmaXJzdF9ubyArIHNlY29uZF9ub1xuICAgICAgICAgICAgICAgICAgICAgIGZpcnN0X25vID0gc2Vjb25kX25vXG4gICAgICAgICAgICAgICAgICAgICAgc2Vjb25kX25vID0gbnRoXG5cbiAgICAgICAgICAgIyBQcmludCBgbnRoYFxuICAgICAgICAgICBwcmludChudGgpIiwic2N0IjoiRXgoKS5oYXNfZXF1YWxfYXN0KFwiWW91IGRvbid0IG5lZWQgdG8gY2hhbmdlIHRoZSB2YWx1ZSBvZiBgZmlyc3Rfbm9gIVwiLCBjb2RlPVwiZmlyc3Rfbm8gPSAwXCIsIGV4YWN0PUZhbHNlKVxuRXgoKS5oYXNfZXF1YWxfYXN0KFwiWW91IGRvbid0IG5lZWQgdG8gY2hhbmdlIHRoZSB2YWx1ZSBvZiBgc2Vjb25kX25vYCFcIiwgY29kZT1cInNlY29uZF9ubyA9IDFcIiwgZXhhY3Q9RmFsc2UpXG5FeCgpLmNoZWNrX29iamVjdChcIm51bWJlcnNcIilcblxuRXgoKS5jaGVja19mb3JfbG9vcCgwKS5j aGVja19pdGVyKCkuaGFzX2VxdWFsX2FzdCgpXG5cbkV4KCkuY2hlY2tfZm9yX2xvb3AoMCkuY2hlY2tfYm9keSgpLmNoZWNrX2lmX2Vsc2UoMCkuY2hlY2tfdGVzdCgpLmhhc19lcXVhbF9hc3QoXCJEaWQgeW91IGNvcnJlY3RseSBjaGVjayB0aGF0IHRoZSBudW1iZXIgaXMgc21hbGxlciBvciBlcXVhbCB0aGFuIDE / XCIsIGNvZGU9XCJudW0gPD0gMVwiLCBleGFjdD1GYWxzZSlcbkV4KCkuY2hlY2tfZm9yX2xvb3AoMCkuY2hlY2tfYm9keSgpLmNoZWNrX2lmX2Vsc2UoMCkuY2hlY2tfYm9keSgpLmhhc19lcXVhbF9hc3QoXCJJdCBsb29rcyBsaWtlIHRoZSBjb250ZW50cyBvZiBgbnRoYCBhcmVuJ3QgY29ycmVjdC5cIiwgY29kZT1cIm50aCA9IG51bVwiLCBleGFjdD1GYWxzZSlcblxuRXgoKS5jaGVja19mb3JfbG9vcCgwKS5jaGVja19ib2R5KCkuY2hlY2tfaWZfZWxzZSgwKS5jaGVja19vcmVsc2UoKS5oYXNfZXF1YWxfYXN0KFwiSXQgbG9va3MgbGlrZSB0aGUgY29udGVudHMgb2YgYG50aGAgYXJlbid0IGNvcnJlY3QuXCIsY29kZT1cIm50aCA9IGZpcnN0X25vICsgc2Vjb25kX25vXCIsIGV4YWN0PUZhbHNlKVxuRXgoKS5jaGVja19mb3JfbG9vcCgwKS5jaGVja19ib2R5KCkuY2hlY2tfaWZfZWxzZSgwKS5jaGVja19vcmVsc2UoKS5oYXNfZXF1YWxfYXN0KFwiSXQgbG9va3MgbGlrZSB0aGUgY29udGVudHMgb2YgYGZpcnN0X25vYCBhcmVuJ3QgY29ycmVjdC5cIixjb2RlPVwiZmlyc3Rfbm8gPSBzZWNvbmRfbm9c IiwgZXhhY3Q9RmFsc2UpXG5FeCgpLmNoZWNrX2Zvcl9sb29wKDApLmNoZWNrX2JvZHkoKS5jaGVja19pZl9lbHNlKDApLmNoZWNrX29yZWxzZSgpLmhhc19lcXVhbF9hc3QoXCJJdCBsb29rcyBsaWtlIHRoZSBjb250ZW50cyBvZiBgc2Vjb25kX25vYCBhcmVuJ3QgY29ycmVjdC5cIixjb2RlPVwic2Vjb25kX25vID0gbnRoXCIsIGV4YWN0PUZhbHNlKVxuXG5FeCgpLmNoZWNrX2Zvcl9sb29wKDApLmNoZWNrX2JvZHkoKS50ZXN0X2Z1bmN0aW9uKFwicHJpbnRcIiwgZG9fZXZhbD1GYWxzZSwgY29weT1GYWxzZSkifQ ==
 
 Вложенные циклы 
 Как вы можете заметить в приведенном выше примере, внутри цикла while есть условие if-else, которое позволяет вам вводить дополнительные условия в ваш код.
 Держись! 
 Это не единственный способ настроить цикл. Вы также можете включить еще несколько циклов while внутри существующего кода, и это называется вложенным циклом. Вы можете изменить приведенный выше пример, чтобы включить еще один цикл while, как показано ниже: 
  # Принять ввод пользователя
число = 2

# условие цикла while
а число <5:
    # условие вложенного цикла while
    а число% 2 == 0:
        print ("Число" + str (число) + "четно")
  
 В приведенном выше примере есть еще один цикл while, который «вложен» во внешний цикл, этот внутренний цикл выполняет еще одну проверку, чтобы увидеть, является ли число % (mod) 2   0 .
 Другими словами, он проверяет, четное ли число, а затем печатает оператор «Число четное». 
 Но есть одна загвоздка: если вы присмотритесь, вы увидите, что, как и в предыдущем коде, на этот раз отсутствует инструкция  number = number + 1 . Поскольку вы нигде не увеличиваете номер переменной, значение переменной остается неизменным каждый раз, и код входит в бесконечный цикл. Это означает, что как только он входит в цикл, он никогда не выходит и печатает оператор бесконечное количество раз, потому что для переменной  number  всегда будет установлено значение 2.Это число, конечно, меньше 5 и четное число. 
 Давайте теперь посмотрим, как будет выглядеть вложенный цикл for: 
  # Распечатайте следующую инструкцию 3 раза
для числа в диапазоне (3):
    Распечатать("-------------------------------------------")
    print ("Я - итерация внешнего цикла" + str (number))
    # Внутренний цикл
    для другого_числа в диапазоне (5):
        Распечатать("****************************")
        print ("Я - итерация внутреннего цикла" + str (another_number))
  
  -------------------------------------------
Я итерация внешнего цикла 0
****************************
Я итерация внутреннего цикла 0
****************************
Я итерация внутреннего цикла 1
****************************
Я внутренний цикл итерация 2
****************************
Я итерация внутреннего цикла 3
****************************
Я итерация 4 внутреннего цикла
-------------------------------------------
Я итерация внешнего цикла 1
****************************
Я итерация внутреннего цикла 0
****************************
Я итерация внутреннего цикла 1
****************************
Я внутренний цикл итерация 2
****************************
Я итерация внутреннего цикла 3
****************************
Я итерация внутреннего цикла 4
-------------------------------------------
Я итерация внешнего цикла 2
****************************
Я итерация внутреннего цикла 0
****************************
Я итерация внутреннего цикла 1
****************************
Я внутренний цикл итерация 2
****************************
Я итерация внутреннего цикла 3
****************************
Я итерация внутреннего цикла 4
  
 Приведенный выше код представляет собой модифицированную версию первого примера цикла for.Обратите внимание, как второй цикл for используется внутри внешнего цикла. 
 Выполните код. 
 Вы обнаружите, что элемент управления входит в первый цикл for, а значение переменной  номер  инициализируется как 0. Первый оператор печати печатается, а затем элемент управления входит во второй цикл for, где значение переменной  Другой_номер  инициализируется как  0 . Первый оператор печати во втором цикле for печатается один раз. 
 Теперь управление снова возвращается во внутренний цикл for, и значение  another_number  снова инициализируется следующим целым числом с последующей печатью оператора внутри функции  print () .
 Вышеупомянутый процесс продолжается до тех пор, пока элемент управления не перейдет через конец функции  range () , которая в данном случае равна 5, а затем управление вернется к самому внешнему циклу, инициализирует переменную  номер  следующим целым числом. , печатает оператор внутри функции  print () , обращается к внутреннему циклу и затем повторяет все вышеперечисленные шаги до тех пор, пока не будет пройдена функция  range () . 
 Это путешествие элемента управления из внешнего цикла, прохождение внутреннего цикла и затем обратно во внешний цикл for продолжается до тех пор, пока элемент управления не покроет весь диапазон, что в вашем случае составляет 3 раза.
 Теперь, когда вы прочитали некоторые объяснения вложенных циклов, пришло время самому начать! Напишите программу Python для построения следующего шаблона, используя вложенный цикл for:
 

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6IiMgSW5pdGlhbGl6ZSB0aGUgZmlyc3QgZml2ZSByb3dzXG5uID0gX1xuXG4jIFN0YXJ0IHRoZSBsb29wIHRvIHByaW50IHRoZSBmaXJzdCBmaXZlIHJvd3NcbmZvciBpIGluIHJhbmdlKF8pOlxuICAgIGZvciBqIGluIHJhbmdlKGkpOlxuICAgICAgICBwcmludCgnKiAnLCBlbmQ9XCJcIilcbiAgICBwcmludCgnJylcblxuIyBTdGFydCB0aGUgbG9vcCB0byBwcmludCB0aGUgcmVtYWluaW5nIHJvd3MgaW4gZGVjcmVhc2luZyBvcmRlciBvZiBzdGFyc1xuZm9yIGkgaW4gcmFuZ2UobiwwLC0xKTpcbiAgICBmb3IgaiBpbiByYW5nZShfKTpcbiAgICAgICAgcHJpbnQoJyogJywgZW5kPVwiXCIpXG4gICAgcHJpbnQoJycpIiwic29sdXRpb24iOiIjIEluaXRpYWxpemUgdGhlIGZpcnN0IGZpdmUgcm93c1xubiA9IDVcblxuIyBTdGFydCB0aGUgbG9vcCB0byBwcmludCB0aGUgZmlyc3QgZml2ZSByb3dzXG5mb3IgaSBpbiByYW5nZShuKTpcbiAgICBmb3IgaiBpbiByYW5nZShpKTpcbiAgICAgICAgcHJpbnQoJyogJywgZW5kPVwiXCIpXG4gICAgcHJpbnQoJycpXG5cbiMgU3RhcnQgdGhlIGxvb3AgdG8gcHJpbnQgdGhlIHJlbWFpbmluZyByb3dzIGluIGRlY3JlYXNpbmcgb3JkZXIgb2Ygc3RhcnNcbmZvciBpIGluIHJhbmdlKG4sMCwtMSk6XG4gICAgZm9yIGogaW4gcmFuZ2UoaSk6XG4gICAgICAgIHByaW50KCcqICcsIGVuZD1cIlwiKVxuICAgIHByaW50KCcnKSIsInNj dCI6IkV4KCkuaGFzX2VxdWFsX2FzdChcIkluaXRpYWxpemUgdGhlIHZhbHVlIG9mIGBuYCBhdCA1IVwiLCBjb2RlPVwibiA9IDVcIiwgZXhhY3Q9RmFsc2UpXG5cbkV4KCkuY2hlY2tfZm9yX2xvb3AoMCkuY2hlY2tfaXRlcigpLmhhc19lcXVhbF9hc3QoXCJyYW5nZShuKVwiKVxuRXgoKS5jaGVja19mb3JfbG9vcCgwKS5jaGVja19ib2R5KCkuY2hlY2tfZm9yX2xvb3AoMCkuY2hlY2tfaXRlcigpLmhhc19lcXVhbF9hc3QoXCJyYW5nZShpKVwiKVxuRXgoKS5jaGVja19mb3JfbG9vcCgwKS5jaGVja19ib2R5KCkuY2hlY2tfZm9yX2xvb3AoMCkuY2hlY2tfaXRlcigpLmhhc19lcXVhbF9hc3QoXCJwcmludCAoJyogJywgZW5kPVxcXCJcXFwiKVwiKVxuRXgoKS5jaGVja19mb3JfbG9vcCgwKS5jaGVja19ib2R5KCkudGVzdF9mdW5jdGlvbihcInByaW50XCIsIDEpXG5cbkV4KCkuY2hlY2tfZm9yX2xvb3AoMSkuY2hlY2tfaXRlcigpLmhhc19lcXVhbF9hc3QoXCJyYW5nZShuLDAsLTEpXCIpXG5FeCgpLmNoZWNrX2Zvcl9sb29wKDEpLmNoZWNrX2JvZHkoKS5jaGVja19mb3JfbG9vcCgwKS5jaGVja19pdGVyKCkuaGFzX2VxdWFsX2FzdChcInJhbmdlKGkpXCIpXG5FeCgpLmNoZWNrX2Zvcl9sb29wKDEpLmNoZWNrX2JvZHkoKS5jaGVja19mb3JfbG9vcCgwKS5jaGVja19pdGVyKCkuaGFzX2VxdWFsX2FzdChcInByaW50ICgnKiAnLCBlbmQ9XFxcIlxcXCIpXCIpXG5FeCgpLmNoZWNrX2Zvcl9sb29wKDEpLmNoZWNrX2JvZHko KS50ZXN0X2Z1bmN0aW9uKFwicHJpbnRcIiwgMSkifQ ==
 
 
 break  и  continue  Ключевые слова: Создание бесконечных циклов 
 Вы можете использовать  break  и  continue  в любом цикле, который вы создаете.Эти ключевые слова не ограничиваются нарушением преднамеренных бесконечных циклов, но их следует использовать осторожно. Оба ключевых слова усложняют другим - включая вас через пару месяцев, когда вы оглянетесь на свой код - понимание потока управления в цикле и того, где заканчивается условие. Кроме того, вам не нужно , чтобы использовать ключевые слова  break  и  continue : как вы видели до сих пор, вы прекрасно справлялись и без них! 

 Однако в некоторых случаях может быть более понятным написать преднамеренные бесконечные циклы, чем традиционные циклы for и while, которые вы видели до сих пор.Конечно, в таких случаях использование этих ключевых слов приветствуется! 
 Разрыв и продолжение цикла while в Python 
 К счастью, есть способ выйти из ситуации бесконечного цикла, описанной выше, и он использует ключевое слово  break . 
  # Принять ввод пользователя
число = 2

# Условие цикла while
а число <5:
    # условие вложенного цикла while
    а число% 2 == 0:
        print ("Число" + str (число) + "четно")
        перерыв

    число + = 1
  
 Когда вы запускаете приведенный выше код, он больше не входит в бесконечный цикл.
 "Что это за колдовство!" Вы кричите. - Я говорю расслабься, это не колдовство. 
 Что происходит, так это то, что когда элемент управления встречает ключевое слово  break , он понимает, что должен выйти из цикла (в данном случае из внутреннего цикла), и выполняет следующую строку кода. Поэтому он прерывается из внутреннего цикла while и переходит к внешнему циклу и продолжает делать свои обычные дела, пока условие во внешнем цикле while не будет выполнено. 
 Следует учитывать тот факт, что строка кода должна существовать после ключевого слова  break , иначе она не будет иметь никакого эффекта.Попробуйте удалить строку кода после ключевого слова  break  в приведенном выше примере, а затем выполните код. 
 Что если вы введете ключевое слово  continue  после оператора  break ? Вы можете следовать приведенному ниже коду: 
  # Принять ввод пользователя
число = 2

а число <5:
    а число% 2 == 0:
        print ("Число" + str (число) + "четно")
        перерыв

    Продолжить

    число + = 1
  
 Приведенный выше код представляет собой слегка измененную версию примера ключевого слова  break .
 Когда вы запустите приведенный выше код, вы снова столкнетесь с бесконечным циклом. Прежде чем вы в отчаянии начнете дергать за волосы, присмотритесь к ним повнимательнее. Вы заметите, что после перерыва есть ключевое слово  continue . Ключевое слово  continue  делает то, что оно передает управление обратно в самый внешний цикл даже до того, как переменная  номер  увеличивается, и из-за этого код переходит в бесконечный цикл. 
 Прерывание и продолжение циклов 
 Что делать, если вы не хотите выполнять внутренний цикл for в приведенном выше примере для всего диапазона? Вы можете использовать оператор  break  аналогично тому, как вы это делали в случае цикла while.
  # Распечатайте следующую инструкцию 3 раза
для числа в диапазоне (3):
    Распечатать("-------------------------------------------")
    print ("Я - итерация внешнего цикла" + str (number))
    для другого_числа в диапазоне (3):
        Распечатать("****************************")
        print ("Я - итерация внутреннего цикла" + str (another_number))
        перерыв
  
 В приведенном выше примере ключевое слово  break  после внутреннего цикла инструктирует элемент управления выйти из внутреннего цикла, после чего элемент управления возвращается во внешний цикл.
 Запустите приведенный ниже пример кода: 
  # Распечатайте следующую инструкцию 3 раза
для числа в диапазоне (3):
    Распечатать("-------------------------------------------")
    print ("Я - итерация внешнего цикла" + str (number))
    Продолжить
    для другого_числа в диапазоне (3):
        Распечатать("****************************")
        print ("Я - итерация внутреннего цикла" + str (another_number))
        перерыв
  
 В приведенном выше коде выполняется только самый внешний цикл, а элемент управления даже не касается внутреннего цикла.
 "Почему?" ты спрашиваешь. 
 Внимательно посмотрите на код. Ключевое слово  continue  находится сразу после второго оператора печати во внешнем цикле. Что он делает, так это то, что он инструктирует элемент управления вернуться к внешнему циклу for и начать заново, и поэтому элемент управления никогда не касается внутреннего цикла. 
 В отличие от цикла while, вам не нужен фрагмент кода после ключевого слова  break  в цикле for. Только цикл прерывания будет нормально работать внутри цикла for.
 
 диапазон ()  по сравнению с  xrange ()  
 Эти две функции похожи друг на друга, но если вы используете Python 3, вам будет доступна только функция  range () . В Python 3.x функция  xrange ()  переименована в  range () . Это означает, что если вы попытаетесь использовать функцию  xrange ()  с Python 3, вы получите  NameError: name 'xrange' is not defined  error. 
 Чтобы понять, чем эти две функции похожи, рассмотрим следующий пример: 
  # Распечатайте следующую инструкцию 3 раза
для числа в диапазоне (5,10,2):
    print ("Я число:" + str (число))
  
  Я номер: 5
Я номер: 7
Я номер: 9
  
 Запустив приведенный выше код, вы увидите, как значение переменной  number  пропускается с коэффициентом 2, и это из-за параметров в функции  range () .
 Первый параметр в этой функции - это параметр запуска. Это точка, с которой начинается отсчет контроля. Второй параметр - это параметр остановки, который является точкой, в которой элемент управления должен остановиться, а последний параметр - это функция шага, которая определяет коэффициент, на который элемент управления должен перейти во время счета. 
 Итак, в приведенном выше случае управление начинается с 5, затем проходит цикл до 9, добавляя 2 во время каждого счета. Это означает 5, 5 + 2 = 7, 7 + 2 = 9.
 Вы узнали, как функция  range ()  используется для определения количества циклов выполнения вашего кода. Теперь, в Python 2.x, вы также найдете другой способ сделать это - с помощью функции  xrange () . Запустите приведенный ниже код: 
  # Распечатайте следующую инструкцию 3 раза
для числа в xrange (10):
    print ("Я число:" + str (число))
  
  Я номер: 0
Я номер: 1
Я номер: 2
Я номер: 3
Я номер: 4
Я номер: 5
Я номер: 6
Я номер: 7
Я номер: 8
Я номер: 9
  
 Какую разницу вы заметили в выводе приведенного выше кода и выводе кода без функции  xrange () ? Нет разницы? 
 Верно.Вы не увидите никакой разницы в выводе кода. 
 Так зачем использовать функцию  xrange () ? Вы узнаете об этом немного позже в руководстве. Сначала запустите код ниже: 
  печать (xrange (10))
печать (диапазон (10))
  
  xrange (10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  
 Вы можете видеть, что в выводе приведенного выше кода есть разница в выводе обоих операторов печати. В операторе печати, который содержит функцию  xrange () , вы получаете напечатанный объект функции  xrange () .Это отличается от оператора печати, который имеет функцию  range () : там вы получаете список целых чисел от 0 до 9. 
 В этом и заключается разница между функцией  range ()  и функцией  xrange () . 
 Когда вы определяете функцию  range () , список всего диапазона сохраняется в RAM и представляется вам. Однако, когда вы определяете функцию  xrange () , список не сохраняется в памяти.Вместо этого функция  xrange ()  генерирует целые числа во всем диапазоне, когда вам это нужно. Таким образом, функция  xrange ()  помогает в экономии памяти в системе с ограниченными ресурсами. 
 Оттачивайте свои навыки Python! 
 Поздравляю, вы дошли до конца этого урока. Теперь, когда вы узнали, как использовать циклы в Python, приступайте к практике. Чем больше вы тренируетесь, тем лучше! 
 Resistance Loops 3 Pack - Marika 
 Таблица размеров 
 Воспользуйтесь этой таблицей размеров, чтобы определить свой размер.Поскольку размеры и крой будут различаться у разных производителей, пожалуйста, используйте таблицы в качестве общего руководства для сравнения различных шкал размеров.

Если у вас есть конкретный вопрос о размерах или вам нужна дополнительная информация, свяжитесь с нами.

Указанные размеры являются американскими, если не указано иное. 



 Бюст 

Талия 

Бедро 



 X-Small (0-2) 
 32-33 
 24-26 
 34-36 


 Small (4-6) 
 34-35 
 26-28 
 36-38 


 Средний (8-10) 
 36-37 
 28-30 
 38-40 


 Большой (12-14) 
 38-39 
 30-32 
 40-42 


 Большой (16) 
 40 
 32 
 43 


 0X 
 44-46 
 35-37 
 46-48 


 1X 
 46-48 
 38-40 
 48-50 


 2X 
 48-50 
 41-43 
 50-52 


 3X 
 50-52 
 44-46 
 52-54 




 



  МАРИКА СПОРТ  
  БЮСТ  
  ТАЛИЯ  
  HIP  


 S 
 33-35 
 26–28 
 37-39 


 M 
 36-38 
 29-32 
 40-42 


 л 
 39-41 
 33-36 
 43-45 


 XL 
 42-44 
 37-40 
 46-48 






  БАЛАНС КОЛЛЕКЦИЯ ДЛЯ МУЖЧИН  
  СУНДУК  
  ТАЛИЯ  
  HIP  


 S 
 37-39 
 30-32 
 36-38 


 M 
 40-42 
 33-35 
 39-41 


 л 
 43-45 
 36-38 
 42-44 


 XL 
 46-48 
 39-41 
 45-47 



 Бюст 
 Для определения размера бюста измерьте размер груди по всей длине груди.
 Талия 
 Измерьте естественную талию (наименьшую часть талии), поместив один палец между телом и рулеткой. 
 Бедро 
 Измерьте всю длину бедра, следя за тем, чтобы лента оставалась ровной. 
 Длина платья 
 Встаньте, поставив пятки вместе, удерживая ленту прямо и перпендикулярно полу. Измерьте расстояние от верхней точки плеч до длины спины. 
 Внутренний шов 
 Найдите пару брюк, которые подходят вам, и измерьте расстояние от промежностного шва до отверстия внизу штанины.Округлите число до ближайшей 1/2 дюйма, чтобы получить длину внутреннего шва. 
 7.5 Петли | Введение в R 
 R очень хорошо справляется с повторяющимися задачами. Если мы хотим, чтобы набор операций повторялся несколько раз, мы используем так называемый цикл. Когда вы создаете цикл, R будет выполнять инструкции в цикле указанное количество раз или до тех пор, пока не будет выполнено указанное условие. В R есть три основных типа цикла: цикл  для , цикл , а также цикл  и цикл , повторяющийся, .
 Циклы являются одним из основных компонентов всех языков программирования, не только R, и могут быть мощным инструментом (хотя, по нашему мнению, они используются слишком часто при написании кода R). 
 Для петли 
 Наиболее часто используемая структура цикла, когда вы хотите повторить задачу определенное количество раз, - это цикл  для .

Самый простой пример цикла  для : 
  для (я в 1: 5) {
  печать (я)
}
## [1] 1
## [1] 2
## [1] 3
## [1] 4
## [1] 5  
 Но что на самом деле делает код? Это динамический бит кода, в котором индекс  i  итеративно заменяется каждым значением в векторе  1: 5 .Давайте разберемся. Поскольку первое значение в нашей последовательности ( 1: 5 ) -  1 , цикл начинается с замены  i  на  1  и выполняет все, что находится между  {} . Циклы обычно используют  и  в качестве счетчика, сокращение от итераций, но вы можете использовать все, что захотите, даже имя вашего питомца, это действительно не имеет значения (кроме случаев использования вложенных циклов, в этом случае счетчики должны называться разными такие вещи, как  SenorWhiskers  и  HerrFlufferkins .
 Итак, если бы мы выполняли первую итерацию цикла вручную 
 После завершения этой первой итерации цикл for  возвращает  в начало и заменяет  i  следующим значением в нашей последовательности  1: 5  (в данном случае  2 ): 
 Этот процесс затем повторяется до тех пор, пока цикл не достигнет последнего значения в последовательности ( 5  в этом примере), после чего он остановится. 
 Чтобы лучше понять, как работают петли  для , и познакомить вас с ценной функцией петель, мы изменим наш счетчик внутри цикла.Это можно использовать, например, если мы используем цикл для итерации по вектору, но хотим выбрать следующую строку (или любое другое значение). Чтобы продемонстрировать это, мы просто добавляем 1 к значению нашего индекса каждый раз, когда выполняем итерацию цикла. 
  для (я в 1: 5) {
  печать (я + 1)
}
## [1] 2
## [1] 3
## [1] 4
## [1] 5
## [1] 6  
 Как и в предыдущем цикле, первое значение в нашей последовательности - 1. Цикл начинается с замены  i  на  1 , но на этот раз мы указали, что значение  1  должно быть добавлено к  i  в выражении, которое дает значение  1 + 1 .
 Как и раньше, после завершения итерации цикл переходит к следующему значению в последовательности и заменяет  i  следующим значением (в данном случае  2 ), так что  i + 1  становится  2 + 1  . 
 И так далее. Думаем, вы поняли идею! По сути, это все, что делает цикл  для , и ничего более. 
 Хотя выше мы использовали простое добавление в теле цикла, вы также можете комбинировать циклы с функциями.
 Вернемся к нашему фрейму данных , город . Ранее в этой главе мы создали функцию для умножения двух столбцов и использовали ее для создания наших объектов  porto_aberdeen ,  aberdeen_nairobi  и  nairobi_genoa . Мы могли бы использовать для этого цикл. Напомним, как выглядят наши данные и код функции  multiple_columns () . 
  # Воссоздание нашего набора данных
город <- data.frame (
  porto = rnorm (100),
  aberdeen = rnorm (100),
  nairobi = c (rep (NA, 10), rnorm (90)),
  генуя = норм (100)
)

# Наша функция
multiply_columns <- function (x, y) {
  темп <- х * у
  если (любой (есть.na (temp))) {
    предупреждение ("Функция создала НП")
    возврат (темп)
  } еще {
    возврат (темп)
  }
}  
 Чтобы использовать список для итерации по этим столбцам, нам нужно сначала создать пустой список (помните списки?), Который мы называем  temp  (сокращенно от временного), который будет использоваться для хранения выходных данных цикла  для . 
  темп <- список ()
for (я в 1: (ncol (город) - 1)) {
  temp [[i]] <- multiply_columns (x = city [, i], y = city [, i + 1])
}
## Предупреждение в multiply_columns (x = city [, i], y = city [, i + 1]): функция имеет
## произведенных НП

## Предупреждение в multiply_columns (x = city [, i], y = city [, i + 1]): функция имеет
## произведено НА  
 Когда мы указываем наш цикл  для , обратите внимание, как мы вычитали 1 из  ncol (city) .Функция  ncol ()  возвращает количество столбцов в нашем фрейме данных  city , которое составляет  4 , поэтому наш цикл выполняется от  i = 1  до  i = 4 - 1 , что составляет  i = 3  . Мы вернемся к тому, почему нам нужно вычесть из этого числа 1, через минуту. 
 Итак, в первой итерации цикла  i  принимает значение  1 . Функция  multiply_columns ()  умножает столбцы  city [, 1]  ( porto ) и  city [, 1 + 1]  ( aberdeen ) и сохраняет их в формате  temp [[1]]  который является первым элементом списка  temp .
 Вторая итерация цикла  i  принимает значение  2 . Функция  multiply_columns ()  умножает столбцы  city [, 2]  ( aberdeen ) и  city [, 2 + 1]  ( nairobi ) и сохраняет их в формате  temp [[2]]  который является вторым элементом списка  temp . 
 Третья и последняя итерация цикла  i  принимает значение  3 . Функция  multiply_columns ()  умножает столбцы  city [, 3]  ( nairobi ) и  city [, 3 + 1]  ( genoa, ) и сохраняет их в формате  temp [[3]]  который является третьим элементом списка  temp .
 Итак, вы понимаете, почему мы использовали  ncol (city) - 1  при первой настройке нашего цикла? Поскольку у нас есть четыре столбца в нашем фрейме данных  city , если мы не использовали  ncol (city) - 1 , то в конечном итоге мы попытаемся добавить столбец 4  th  с несуществующим столбцом 5  th  . 
 Опять же, неплохо проверить, получаем ли мы что-то разумное из нашего цикла (запомните, проверьте, проверьте и еще раз проверьте!). Для этого мы можем использовать функцию  identify ()  для сравнения переменных, которые мы создали  вручную  с каждой итерацией цикла вручную.
  porto_aberdeen_func <- multiply_columns (город $ porto, город $ aberdeen)
я <- 1
идентичные (multiply_columns (city [, i], city [, i + 1]), porto_aberdeen_func)
## [1] ИСТИНА

aberdeen_nairobi_func <- multiply_columns (город $ абердин, город $ найроби)
## Предупреждение в multiply_columns (city $ aberdeen, city $ nairobi): функция имеет
## произведенных НП
я <- 2
идентичные (multiply_columns (city [, i], city [, i + 1]), aberdeen_nairobi_func)
## Предупреждение в multiply_columns (city [, i], city [, i + 1]): функция произвела
## НП
## [1] ИСТИНА  
 Если вы сможете следовать приведенным выше примерам, у вас будет хорошее время, чтобы начать писать свои собственные циклы for.Тем не менее, вам доступны и другие типы петель. 
 Цикл пока 
 Другой тип цикла, который вы можете использовать (хотя и реже), - это цикл  и . Цикл  и  используется, когда вы хотите продолжать цикл до тех пор, пока не будет выполнено определенное логическое условие (сравните это с циклом  для , который всегда будет повторять всю последовательность). 
 Базовая структура цикла while: 
  while (логическое_условие) {выражение}  
 Простой пример цикла while: 
  i <- 0
в то время как (я <= 4) {
  я <- я + 1
  печать (я)
}
## [1] 1
## [1] 2
## [1] 3
## [1] 4
## [1] 5  
 Здесь цикл будет продолжать передавать значения только в основную часть цикла (тело  выражения ), когда  i  меньше или равно 4 (задано с помощью оператора  <=  в этом примере).Как только  i  больше 4, цикл остановится. 
 Есть еще один, очень редко используемый тип шлейфа;  повторяют цикл . Цикл  repeat  не имеет условной проверки, поэтому может повторяться бесконечно (это означает, что в нем должен быть закодирован разрыв или «остановка здесь»). Стоит знать о его существовании, но пока мы не думаем, что вам нужно об этом беспокоиться;  для  и , в то время как петли  помогут вам справиться с подавляющим большинством ваших потребностей в петлях.
 Если не петли, то что? 
 Короче говоря, используйте семейство функций apply;  применить () ,  прилегать () ,  нанести () ,  sapply () ,  vapply ()  и  mapply () . Функции apply часто могут выполнять задачи большинства «самодельных» циклов, иногда быстрее (хотя для большинства людей это не проблема), но, что более важно, с гораздо меньшим риском ошибки. Стратегия, которая может быть полезна в уме: для каждого созданного вами цикла попробуйте переделать его с помощью функции apply (часто подойдет  lapply  или  sapply ).Если можете, используйте версию Apply. Нет ничего хуже, чем осознать, что произошла маленькая, крошечная, на первый взгляд бессмысленная ошибка в цикле, который через недели, месяцы или годы превратился в огромный беспорядок. Мы настоятельно рекомендуем по возможности использовать функции apply. 
 lapply 
 Ваша функция перехода к применению часто будет иметь вид  lapply () , по крайней мере, вначале. Способ, которым работает  lapply () , и причина, по которой он часто является хорошей альтернативой циклам for, заключается в том, что он просматривает каждый элемент в списке и выполняет задачу (т.е. запустить функцию). У него есть дополнительное преимущество, заключающееся в том, что он выводит результаты в виде списка - что-то, что в противном случае вам пришлось бы закодировать в цикл. 
  lapply ()  имеет следующую структуру: 
 Здесь  X  - вектор, с которым мы хотим сделать  что-то .  FUN  означает, насколько это весело (шучу!). Это также сокращение от «функция». 
 Начнем сначала с простой демонстрации. Давайте воспользуемся функцией  lapply ().  создадим последовательность от 1 до 5 и добавим 1 к каждому наблюдению (точно так же, как мы это делали, когда использовали цикл for): 
  lapply (0: 4, функция (a) {a + 1})
## [[1]]
## [1] 1
##
## [[2]]
## [1] 2
##
## [[3]]
## [1] 3
##
## [[4]]
## [1] 4
##
## [[5]]
## [1] 5  
 Обратите внимание, что нам нужно указать нашу последовательность как  0: 4 , чтобы получить результат  1, 2, 3, 4, 5 , поскольку мы добавляем  1  к каждому элементу последовательности.Посмотрите, что произойдет, если вы вместо этого воспользуетесь  1: 5 . 
 Аналогично, мы могли бы сначала определить функцию, а затем использовать ее в  lapply ()  
  add_fun <- функция (a) {a + 1}
лаппли (0: 4, add_fun)
## [[1]]
## [1] 1
##
## [[2]]
## [1] 2
##
## [[3]]
## [1] 3
##
## [[4]]
## [1] 4
##
## [[5]]
## [1] 5  
 Функция  sapply ()  делает то же самое, что и  lapply () , но вместо того, чтобы сохранять результаты в виде списка, она сохраняет их как вектор.
  sapply (0: 4, функция (a) {a + 1})
## [1] 1 2 3 4 5  
 Как видите, в обоих случаях мы получаем точно такие же результаты, как и при использовании цикла for. 
 Python "while" циклы (неопределенная итерация) - Real Python 
  Смотреть сейчас В этом руководстве есть связанный видеокурс, созданный командой Real Python. Посмотрите его вместе с письменным руководством, чтобы углубить свое понимание:  Mastering While Loops  

  Итерация  означает выполнение одного и того же блока кода снова и снова, возможно, много раз.Программная структура, реализующая итерацию, называется циклом  . 
 В программировании есть два типа итераций, неопределенные и определенные: 


 При  неопределенной итерации  количество выполнений цикла не указывается заранее. Скорее, назначенный блок выполняется повторно, пока выполняется какое-либо условие. 


 При  определенной итерации , количество раз, которое будет выполняться назначенный блок, указывается явно в момент начала цикла.


  В этом руководстве вы будете:  

 Узнайте о цикле  и , управляющей структуре Python, используемой для неопределенной итерации 
 Узнайте, как преждевременно выйти из цикла или итерации цикла 
 Исследуйте бесконечные циклы 

 Когда вы закончите, вы должны хорошо понимать, как использовать неопределенную итерацию в Python. 
   Пройдите викторину:  Проверьте свои знания с помощью нашей интерактивной викторины «Python во время цикла».По завершении вы получите оценку, чтобы вы могли отслеживать свой прогресс в обучении с течением времени: 

 Пройти тест »
 
 в то время как  петля 
 Давайте посмотрим, как операторы Python  и  используются для построения циклов. Мы начнем с простого и будем приукрашивать. 
 Формат элементарного цикла  и  показан ниже: 
 , а <выражение>:
    <заявление (я)>
  
  <оператор (ы)>  представляет блок, который должен быть повторно выполнен, часто называемый телом цикла.Это обозначается отступом, как в заявлении  if . 
  Помните:  Все управляющие структуры в Python используют отступ для определения блоков. См. Обсуждение операторов группировки в предыдущем учебном пособии. 
 Управляющее выражение    обычно включает одну или несколько переменных, которые инициализируются перед запуском цикла, а затем изменяются где-то в теле цикла. 
 Когда встречается цикл , а ,    сначала оценивается в логическом контексте.Если это правда, тело цикла выполняется. Затем снова проверяется   , и если все еще истинно, тело выполняется снова. Это продолжается до тех пор, пока    не станет ложным, после чего выполнение программы перейдет к первому оператору за пределами тела цикла. 
 Рассмотрим этот цикл: 
>>> 
  1 >>> п = 5
 2 >>> пока n> 0:
 3 ... п - = 1
 4 ... печать (n)
 5 ...
 64
 73
 82
 91
100
  
 Вот что происходит в этом примере: 


  n  - это изначально  5 .Выражение в заголовке оператора  while  в строке 2 имеет вид  n> 0 , что верно, поэтому тело цикла выполняется. Внутри тела цикла в строке 3 значение  n  уменьшается на  1  до  4  и затем печатается. 


 Когда тело цикла завершено, выполнение программы возвращается к началу цикла в строке 2, и выражение вычисляется снова. Это все еще верно, поэтому тело выполняется снова, и печатается  3 .


 Это продолжается до тех пор, пока номер  n  не станет  0 . В этот момент, когда выражение проверяется, оно ложно, и цикл завершается. Выполнение будет возобновлено с первого оператора, следующего за телом цикла, но в данном случае его нет. 


 Обратите внимание, что сначала проверяется управляющее выражение цикла  while , прежде чем что-либо произойдет. Если изначально задано false, тело цикла никогда не будет выполнено: 
>>> 
  >>> п = 0
>>> пока n> 0:
... n - = 1
... print (n)
...
  
 В приведенном выше примере при обнаружении цикла  n  равно  0 . Управляющее выражение  n> 0  уже ложно, поэтому тело цикла никогда не выполняется. 
 Вот еще один цикл  while , включающий список, а не сравнение чисел: 
>>> 
  >>> a = ['foo', 'bar', 'baz']
>>> а:
... печать (a.pop (-1))
...
баз
бар
фу
  
 Когда список оценивается в логическом контексте, он является истинным, если в нем есть элементы, и ложным, если он пуст.В этом примере  a  истинно, пока в нем есть элементы. Как только все элементы были удалены с помощью метода  .pop ()  и список пуст,  a  ложно, и цикл завершается. 
 Python 
 перерыв  и  продолжение  Заявления 
 В каждом из примеров, которые вы видели до сих пор, все тело цикла  и  выполняется на каждой итерации. Python предоставляет два ключевых слова, которые преждевременно завершают итерацию цикла: 


 Оператор Python   break   немедленно полностью завершает цикл.Выполнение программы переходит к первому оператору, следующему за телом цикла. 


 Оператор Python   continue   немедленно завершает текущую итерацию цикла. Выполнение переходит к началу цикла, и управляющее выражение повторно оценивается, чтобы определить, будет ли цикл выполняться снова или завершиться. 


 Различие между  break  и  continue  показано на следующей диаграмме: 
break and continue 
 Вот файл сценария под названием  break.py , который демонстрирует разрыв , оператор : 
  1н = 5
 2 при n> 0:
 3 п - = 1
 4, если n == 2:
 5 перерыв
 6 отпечатков (п)
 7print ('Цикл закончился.')
  
 Запуск  break.py  из интерпретатора командной строки дает следующий вывод: 
  C: \ Users \ john \ Documents> python break.py
4
3
Цикл закончился.
  
 Когда  n  становится  2 , выполняется оператор  break .Цикл полностью завершается, и выполнение программы переходит к оператору  print ()  в строке 7. 
 Следующий сценарий,  continue.py , идентичен, за исключением оператора  continue  вместо разрыва  : 
  1н = 5
 2 при n> 0:
 3 п - = 1
 4, если n == 2:
 5 продолжить
 6 отпечатков (п)
 7print ('Цикл закончился.')
  
 Результат  continue.py  выглядит так: 
  C: \ Users \ john \ Documents> python continue.ру
4
3
1
0
Цикл закончился.
  
 На этот раз, когда  n  равно  2 , оператор  continue  вызывает завершение этой итерации. Таким образом,  2  не печатается. Выполнение возвращается к началу цикла, условие переоценивается, и оно по-прежнему остается верным. Цикл возобновляется и завершается, когда  n  становится  0 , как и раньше. 
 
 еще  Пункт 
 Python допускает необязательное предложение  else  в конце цикла  while .Это уникальная особенность Python, которой нет в большинстве других языков программирования. Синтаксис показан ниже: 
 , а <выражение>:
    <заявление (я)>
еще:
    <дополнительные_условия>
  
   , указанное в предложении  else , будет выполнено, когда цикл  и  завершится. 
 Примерно сейчас вы можете подумать: «Чем это полезно?» Вы можете сделать то же самое, поместив эти операторы сразу после цикла  while , без  else : 
 , а <выражение>:
    <заявление (я)>
<дополнительные_условия>
  
 В чем разница? 
 В последнем случае, без предложения  else ,    будет выполняться после , а цикл  завершится, несмотря ни на что.
 Когда    помещены в предложение  else , они будут выполняться только в том случае, если цикл завершится «по исчерпанию», то есть, если цикл повторяется до тех пор, пока управляющее условие не станет ложным. Если цикл завершается оператором  break , предложение  else  выполняться не будет. 
 Рассмотрим следующий пример: 
>>> 
  >>> п = 5
>>> пока n> 0:
... п - = 1
... print (n)
... еще:
... print ('Цикл выполнен.')
...
4
3
2
1
0
Петля сделана.
  
 В этом случае цикл повторяется до тех пор, пока условие не будет исчерпано:  n  стало  0 , поэтому  n> 0  стало ложным. Поскольку цикл дожил, так сказать, свою естественную жизнь, условие  else  было выполнено. Теперь обратите внимание на разницу: 
>>> 
  >>> п = 5
>>> пока n> 0:
... п - = 1
... print (n)
... если n == 2:
...         перерыв
... еще:
... print ('Цикл выполнен.')
...
4
3
2
  
 Этот цикл прерывается преждевременно с помощью  break , поэтому предложение  else  не выполняется. 
 Может показаться, что значение слова  else  не совсем подходит для цикла  while , а также для оператора  if . Гвидо ван Россум, создатель Python, на самом деле сказал, что, если бы ему пришлось делать это снова, он бы оставил , а  цикла , еще предложение  вне языка.
 Одна из следующих интерпретаций может помочь сделать его более интуитивным: 


 Думайте о заголовке цикла ( при n> 0, ) как о заявлении  if  (, если n> 0, ), которое выполняется снова и снова, причем предложение  else , наконец, выполняется, когда условие становится ложный. 


 Подумайте о , иначе о , как о  без перерыва , в том смысле, что следующий за ним блок выполняется, если не было перерыва  .


 Если вы не находите какое-либо из этих толкований полезным, не стесняйтесь их игнорировать. 
 Когда может быть полезно предложение  else  в цикле  и ? Одна из распространенных ситуаций - это поиск в списке определенного элемента. Вы можете использовать  break  для выхода из цикла, если элемент найден, а предложение  else  может содержать код, который должен выполняться, если элемент не найден: 
>>> 
  >>> a = ['foo', 'bar', 'baz', 'qux']
>>> s = 'corge'

>>> я = 0
>>> пока я  

  Примечание:  Приведенный выше код полезен для иллюстрации концепции, но на самом деле вы вряд ли будете искать в списке таким образом. 
 Во-первых, списки обычно обрабатываются с определенной итерацией, а не с циклом  и . Определенная итерация рассматривается в следующем руководстве этой серии.
 Во-вторых, Python предоставляет встроенные способы поиска элемента в списке. Вы можете использовать  в операторе : 
>>> 
  >>> если в:
... print (s, 'найдено в списке.')
... еще:
... print (s, 'не найдено в списке.')
...
corge не найден в списке.
  
 Также подойдет метод  list.index () . Этот метод вызывает исключение  ValueError , если элемент не найден в списке, поэтому для его использования необходимо понимать обработку исключений.В Python вы используете оператор  try  для обработки исключения. Пример приведен ниже: 
>>> 
  >>> попробуйте:
... печать (a.index ('corge'))
... кроме ValueError:
... print (s, 'не найдено в списке.')
...
corge не найден в списке.
  
 Об обработке исключений вы узнаете позже в этой серии. 
 Предложение  else  с циклом  while  - это немного странность, которую не часто можно увидеть. Но не уклоняйтесь от этого, если вы обнаружите ситуацию, в которой, как вам кажется, это добавляет ясности в ваш код! 
 Бесконечные петли 
 Предположим, вы пишете цикл  и , который теоретически никогда не заканчивается.Звучит странно, правда? 
 Рассмотрим этот пример: 
>>> 
  >>> при этом True:
... печать ('фу')
...
фу
фу
фу
  .
  .
  .
фу
фу
фу
KeyboardInterrupt
Отслеживание (последний вызов последний):
  Файл "", строка 2, в 
    печать ('фу')
  
 Этот код был прерван  Ctrl  +  C , который генерирует прерывание с клавиатуры. В противном случае это продолжалось бы бесконечно. Многие выходные строки  foo  были удалены и заменены вертикальным многоточием в показанном выходе.
 Ясно, что  True  никогда не будет ложью, иначе у всех нас будут большие проблемы. Таким образом,  while True:  инициирует бесконечный цикл, который теоретически будет работать вечно. 
 Может быть, это не похоже на то, что вы хотели бы делать, но этот шаблон на самом деле довольно распространен. Например, вы можете написать код для службы, которая запускается и работает постоянно, принимая запросы на обслуживание. «Навсегда» в этом контексте означает, пока вы не выключите его или пока не наступит тепловая смерть вселенной, в зависимости от того, что наступит раньше.
 Проще говоря, помните, что цикл может быть разорван с помощью оператора  break . Может быть проще завершить цикл на основе условий, распознаваемых в теле цикла, а не на основе условия, оцененного наверху. 
 Вот еще один вариант цикла, показанный выше, который последовательно удаляет элементы из списка с помощью  .pop () , пока он не станет пустым: 
>>> 
  >>> a = ['foo', 'bar', 'baz']
>>> в то время как True:
... если не:
...         перерыв
... печать (a.pop (-1))
...
баз
бар
фу
  
 Когда  a  становится пустым,  не  становится истинным, и оператор  break  выходит из цикла. 
 Вы также можете указать несколько операторов  break  в цикле: 
  пока True:
    if : # Одно условие для завершения цикла
        перерыв
    ...
    if : # Другое условие завершения
        перерыв
    ...
    if : # Еще один
        перерыв
  
 В подобных случаях, когда есть несколько причин для завершения цикла, часто проще  прервать  из нескольких разных мест, а не пытаться указать все условия завершения в заголовке цикла.
 Бесконечные циклы могут быть очень полезны. Просто помните, что вы должны в какой-то момент разорвать цикл, чтобы он не стал бесконечным. 
 Вложенный 
, а  Петли 
 В общем, управляющие структуры Python могут быть вложены друг в друга. Например,  if / elif / else  условные операторы могут быть вложенными: 
  если возраст <18:
    если пол == 'M':
        печать ('сын')
    еще:
        print ('дочь')
elif age> = 18 и age <65:
    если пол == 'M':
        печать ('отец')
    еще:
        печать ('мать')
еще:
    если пол == 'M':
        print ('дедушка')
    еще:
        print ('бабушка')
  
 Аналогично, цикл  и  может содержаться в другом цикле  и , как показано здесь: 
>>> 
  >>> a = ['foo', 'bar']
>>> пока len (a):
... print (a.pop (0))
... b = ['baz', 'qux']
... пока len (b):
... печать ('>', b.pop (0))
...
фу
> баз
> qux
бар
> баз
> qux
  
  break  или  continue Оператор , обнаруженный во вложенных циклах, применяется к ближайшему охватывающему циклу: 
 , а :
    утверждение
    утверждение

    в то время как :
        утверждение
        утверждение
        break # Применяется к циклу while :

    break # Применяется к циклу while :
  
 Кроме того, циклы  и  могут быть вложены в , если / elif / else  операторы, и наоборот: 
  если <выражение>:
    утверждение
    в то время как :
        утверждение
        утверждение
еще:
    в то время как :
        утверждение
        утверждение
    утверждение
  
 , а <выражение>:
    если <выражение>:
        утверждение
    элиф <выражение>:
        утверждение
    еще:
        утверждение

    если <выражение>:
        утверждение
  
 Фактически, все управляющие структуры Python могут смешиваться друг с другом в любой степени, в которой вам нужно.Так и должно быть. Представьте, как было бы неприятно, если бы возникли неожиданные ограничения, такие как «Цикл , в то время как цикл  не может содержаться в операторе , если » или «Цикл , в то время как циклы  могут быть вложены друг в друга глубиной не более четырех». Вам будет очень сложно их все запомнить. 
 Кажущиеся произвольными числовые или логические ограничения считаются признаком плохой разработки языка программы. К счастью, вы не найдете многих в Python. 
 Однострочный 
, а  Петли 
 Как и в случае с оператором  if , цикл  while  может быть указан в одной строке.Если в блоке, составляющем тело цикла, несколько операторов, их можно разделить точкой с запятой (; ): 
>>> 
  >>> п = 5
>>> пока n> 0: n - = 1; печать (п)

4
3
2
1
0
  
 Это работает только с простыми операторами. Невозможно объединить два составных оператора в одну строку. Таким образом, вы можете указать цикл  и  в одной строке, как указано выше, и написать оператор  if  в одной строке: 
>>> 
  >>> если True: print ('foo')

фу
  
 Но вы не можете этого сделать: 
>>> 
  >>> при n> 0: n - = 1; если True: print ('foo')
SyntaxError: недопустимый синтаксис
  
 Помните, что PEP 8 не рекомендует использовать несколько операторов в одной строке.Так что вам, вероятно, в любом случае не следует делать это очень часто. 
 Заключение 
 В этом руководстве вы узнали о  неопределенной итерации  с использованием цикла Python  while . Теперь вы можете: 

 Построить базовый и сложный , а петли  
 Выполнение цикла прерывания с  break  и  continue  
 Используйте предложение  else  с циклом  while  
 Работа с бесконечными циклами 

 Теперь вы должны хорошо понимать, как многократно выполнять фрагмент кода.
   Пройдите викторину:  Проверьте свои знания с помощью нашей интерактивной викторины «Python во время цикла». По завершении вы получите оценку, чтобы вы могли отслеживать свой прогресс в обучении с течением времени: 

 Пройти тест »
 В следующем руководстве этой серии рассматривается  определенная итерация  с  для  циклов - повторяющееся выполнение, при котором количество повторений указывается явно. 
  Смотреть сейчас В этом руководстве есть связанный видеокурс, созданный командой Real Python.Посмотрите его вместе с письменным руководством, чтобы углубить свое понимание:  Mastering While Loops  

 Глава 5 | Python для всех 
 Распространенным шаблоном в операторах присваивания является оператор присваивания, который обновляет переменную, где новое значение переменной зависит от старого. 
  х = х + 1  
 Это означает «получить текущее значение  x , добавить 1, а затем обновить  x  с новым значением». 
 Если вы попытаетесь обновить несуществующую переменную, вы получите сообщение об ошибке, потому что Python оценивает правую сторону, прежде чем присвоить значение  x : 
  >>> х = х + 1
NameError: имя 'x' не определено  
 Прежде чем вы сможете обновить переменную, вы должны  инициализировать ее , обычно с простым присваиванием: 
  >>> х = 0
>>> х = х + 1  
 Обновление переменной путем добавления 1 называется приращением  ; вычитание 1 называется декрементом  .
 Компьютеры часто используются для автоматизации повторяющихся задач. Повторение идентичных или похожих задач без ошибок - это то, что компьютеры делают хорошо, а люди - плохо. Поскольку итерация очень распространена, Python предоставляет несколько языковых функций, облегчающих ее. 
 Одной из форм итераций в Python является оператор  while . Вот простая программа, которая ведет обратный отсчет от пяти, а затем говорит «Blastoff!». 
  п = 5
пока n> 0:
    печать (п)
    п = п - 1
print ('Взрыв!')  
 Вы можете почти прочитать заявления  и , как если бы они были на английском языке.Это означает: «Пока  n  больше 0, отобразите значение  n , а затем уменьшите значение  n  на 1. Когда вы дойдете до 0, выйдите из оператора , а  и отобразите слово  Blastoff. !  "
 Более формально, вот поток выполнения для оператора  и : 


 Оцените условие, выдав  True  или  False . 


 Если условие ложно, выйдите из оператора  while  и продолжите выполнение со следующего оператора.


 Если условие истинно, выполнить тело и затем вернуться к шагу 1. 


 Этот тип потока называется циклом  , потому что третий шаг возвращается к вершине. Мы вызываем каждый раз, когда выполняем тело цикла, итерацию  . Для вышеупомянутого цикла мы бы сказали: «У него было пять итераций», что означает, что тело цикла было выполнено пять раз. 
 Тело цикла должно изменить значение одной или нескольких переменных, чтобы в конечном итоге условие стало ложным и цикл завершился.Мы вызываем переменную, которая изменяется каждый раз при выполнении цикла, и контролируем, когда цикл завершается, итерационную переменную  . Если переменной итерации нет, цикл будет повторяться бесконечно, что приведет к бесконечному циклу  . 
 Бесконечный источник забавы для программистов - наблюдение, что указания для шампуня «вспенить, промыть, повторить» представляют собой бесконечный цикл, потому что не существует переменной  итерации , указывающей, сколько раз выполнить цикл.
 В случае обратного отсчета  , мы можем доказать, что цикл завершается, потому что мы знаем, что значение  n  конечно, и мы можем видеть, что значение  n  становится меньше каждый раз в цикле, так что в конечном итоге мы должны достичь 0. В других случаях цикл, очевидно, бесконечен, потому что он вообще не имеет переменной итерации. 
 Иногда вы не знаете, что пора заканчивать цикл, пока не пройдете половину тела. В этом случае вы можете специально написать бесконечный цикл, а затем использовать оператор  break  для выхода из цикла.
 Этот цикл, очевидно, является бесконечным циклом  , потому что логическое выражение в операторе , в то время как  - это просто логическая константа  Истина : 
  п = 10
в то время как True:
    печать (п, конец = '')
    п = п - 1
print ('Готово!')  
 Если вы сделаете ошибку и запустите этот код, вы быстро узнаете, как остановить неконтролируемый процесс Python в вашей системе, или найдете, где на вашем компьютере находится кнопка выключения питания. Эта программа будет работать вечно или до тех пор, пока ваша батарея не разрядится, потому что логическое выражение в верхней части цикла всегда истинно в силу того факта, что выражение является постоянным значением  True .
 Хотя это дисфункциональный бесконечный цикл, мы все еще можем использовать этот шаблон для построения полезных циклов, если мы аккуратно добавляем код в тело цикла, чтобы явно выйти из цикла с помощью  break , когда мы достигли условия выхода. 
 Например, предположим, что вы хотите принимать ввод от пользователя, пока он не наберет  выполнено . Вы могли написать: 
 Условие цикла -  True , которое всегда верно, поэтому цикл выполняется многократно, пока не встретится оператор break.
 Каждый раз он предлагает пользователю угловую скобку. Если пользователь набирает  done , оператор  break  выходит из цикла. В противном случае программа повторяет все, что вводит пользователь, и возвращается к началу цикла. Вот пример выполнения: 
 > привет
Привет
> готово
законченный
> сделано
Выполнено!  
 Этот способ записи циклов  и  является обычным, потому что вы можете проверить условие в любом месте цикла (а не только наверху), и вы можете выразить условие остановки утвердительно («остановить, когда это произойдет»), а не отрицательно («сохранить собираюсь, пока это не произойдет."). 
 Иногда вы находитесь в итерации цикла и хотите завершить текущую итерацию и немедленно перейти к следующей итерации. В этом случае вы можете использовать оператор  continue , чтобы перейти к следующей итерации, не завершая тело цикла для текущей итерации. 
 Вот пример цикла, который копирует свой ввод до тех пор, пока пользователь не наберет «готово», но обрабатывает строки, начинающиеся с символа решетки, как строки, которые не нужно печатать (что-то вроде комментариев Python).
 Вот пример выполнения этой новой программы с добавлением  continue . 
 > привет
Привет
> # не печатайте это
> распечатайте это!
распечатайте это!
> сделано
Выполнено!  
 Печатаются все строки, кроме той, которая начинается со знака решетки, потому что, когда выполняется  continue , он завершает текущую итерацию и переходит обратно к оператору , в то время как , чтобы начать следующую итерацию, таким образом пропуская печать   утверждение.
 Иногда нам нужно перебрать  набор  вещей, таких как список слов, строки в файле или список чисел. Когда у нас есть список вещей, которые нужно просмотреть, мы можем построить определенный цикл  , используя оператор  for . Мы называем оператор  while  неопределенным циклом  , потому что он просто зацикливается до тех пор, пока какое-либо условие не станет  False , тогда как цикл  for  проходит через известный набор элементов, поэтому он проходит столько итераций, сколько элементов в набор.

 Синтаксис цикла  для  аналогичен циклу , а  в том, что есть оператор  для  и тело цикла: 
  друзей = ['Джозеф', 'Гленн', 'Салли']
для друга в друзья:
    print ('С Новым годом:', друг)
print ('Готово!')  
 В терминах Python переменная  friends  представляет собой список из трех строк, а цикл  for  просматривает список и выполняет тело один раз для каждой из трех строк в списке, в результате чего получается следующий результат: 
  С Новым годом: Иосиф
С Новым годом: Гленн
С Новым годом: Салли
Выполнено!  
 Перевод этого цикла  для  на английский язык не так прямолинейен, как , а , но если вы думаете о друзьях как о  набора , он выглядит следующим образом: «Выполните операторы в теле цикла for один раз для каждого друг  в наборе  названы друзья.«
 Если посмотреть на цикл  для ,  для  и  в  являются зарезервированными ключевыми словами Python, а  friend  и  friends  - переменные. 
  другу в друзья:
    print ('Happy New Year:', друг)  
 В частности,  friend  - это итерационная переменная   для цикла for. Переменная  friend  изменяется для каждой итерации цикла и управляет, когда цикл  для  завершается.Итерационная переменная   последовательно проходит через три строки, хранящиеся в переменной  friends . 
 Часто мы используем  вместо  или , в то время как цикл  используется для просмотра списка элементов или содержимого файла, и мы ищем что-то вроде наибольшего или наименьшего значения данных, которые мы просматриваем. 
 Эти петли обычно составляют: 


 Инициализация одной или нескольких переменных перед запуском цикла 


 Выполнение некоторых вычислений для каждого элемента в теле цикла, возможно изменение переменных в теле цикла 


 Просмотр результирующих переменных после завершения цикла 


 Мы будем использовать список чисел, чтобы продемонстрировать концепции и построение этих шаблонов петель.
 Счетные и суммирующие петли 
 Например, чтобы подсчитать количество элементов в списке, мы должны написать следующий  для цикла : 
  количество = 0
для итервара в [3, 41, 12, 9, 74, 15]:
    count = count + 1
print ('Count:', count)  
 Мы устанавливаем переменную  count  в ноль перед запуском цикла, затем мы пишем  для цикла , чтобы просмотреть список чисел. Наша переменная  итерация  называется  itervar , и хотя мы не используем  itervar  в цикле, она управляет циклом и заставляет тело цикла выполняться один раз для каждого из значений в списке.
 В теле цикла мы добавляем 1 к текущему значению  count  для каждого значения в списке. Пока цикл выполняется, значение  count  - это количество значений, которые мы видели «до сих пор». 
 После завершения цикла значение  count  - это общее количество элементов. Общее количество «попадает нам на колени» в конце цикла. Мы строим цикл так, чтобы получить то, что мы хотим, когда цикл закончится. 
 Другой аналогичный цикл, вычисляющий сумму набора чисел, выглядит следующим образом: 
  всего = 0
для итервара в [3, 41, 12, 9, 74, 15]:
    итого = итого + итервар
print ('Всего:', всего)  
 В этом цикле мы с  по  используем итерационную переменную  .Вместо того, чтобы просто добавлять единицу к счетчику  , как в предыдущем цикле, мы добавляем фактическое число (3, 41, 12 и т. Д.) К промежуточной сумме во время каждой итерации цикла. Если вы думаете о переменной  total , она содержит «промежуточную сумму значений на данный момент». Итак, перед началом цикла  итоговое значение  равно нулю, потому что мы еще не видели никаких значений, во время цикла  итоговое значение  - это промежуточный итог, а в конце цикла  итоговое значение  - это общее количество всех значений в список.
 По мере выполнения цикла  total  накапливает сумму элементов; переменная, используемая таким образом, иногда называется аккумулятором  . 
 Ни цикл подсчета, ни цикл суммирования не особенно полезны на практике, потому что есть встроенные функции  len ()  и  sum () , которые вычисляют количество элементов в списке и общее количество элементов в списке. соответственно. 
 Максимальный и минимальный контуры 
 Чтобы найти наибольшее значение в списке или последовательности, мы строим следующий цикл: 
  наибольший = Нет
print ('До:', самый большой)
для итервара в [3, 41, 12, 9, 74, 15]:
    если наибольший - Нет или itervar> наибольший:
        наибольший = itervar
    print ('Цикл:', итервар, наибольший)
print ('Наибольший:', наибольший)  
 Когда программа выполняется, вывод будет следующим: 
  Раньше: Нет
Петля: 3 3
Петля: 41 41
Петля: 12 41
Петля: 9 41
Петля: 74 74
Петля: 15 74
Максимальный: 74  
 Переменная  наибольшее значение  лучше всего рассматривать как «наибольшее значение, которое мы видели до сих пор».Перед циклом мы установили  наибольшее  на константу  Нет .  Нет  - это специальное постоянное значение, которое мы можем сохранить в переменной, чтобы пометить переменную как «пустую». 
 Перед запуском цикла наибольшее значение, которое мы видели до сих пор, составляет  Нет , поскольку мы еще не видели никаких значений. Во время выполнения цикла, если  наибольшее значение  равно  Нет , тогда мы берем первое значение, которое мы видим, как наибольшее на данный момент. Вы можете видеть в первой итерации, когда значение  itervar  равно 3, поскольку  наибольшее  равно  Нет , мы сразу устанавливаем  наибольшее  равным 3.
 После первой итерации  наибольший  больше не  Нет , поэтому вторая часть составного логического выражения, которое проверяет  itervar> наибольшие  триггеры, только когда мы видим значение, которое больше, чем «наибольшее на данный момент». Когда мы видим новое «еще большее» значение, мы берем это новое значение за  наибольшее . Вы можете видеть в выводе программы, что  наибольших  прогрессируют от 3 до 41 до 74. 
 В конце цикла мы просканировали все значения, и переменная  наибольшее значение  теперь действительно содержит наибольшее значение в списке.
 Для вычисления наименьшего числа код очень похож с одним небольшим изменением: 
  наименьшее = Нет
print ('До:', наименьшее)
для итервара в [3, 41, 12, 9, 74, 15]:
    если наименьшее значение равно None или itervar <наименьшее:
        наименьший = itervar
    print ('Цикл:', itervar, наименьший)
print ('Самый маленький:', самый маленький)  
 Опять же,  наименьшее  - это "наименьшее на данный момент" до, во время и после выполнения цикла. Когда цикл завершен,  наименьших  содержат минимальное значение в списке.
 Опять же, как и при подсчете и суммировании, встроенные функции  max ()  и  min ()  делают написание этих точных циклов ненужным. 
 Ниже представлена ​​простая версия встроенной в Python функции  min () : 
  def min (значения):
    наименьший = Нет
    для значения в значениях:
        если наименьшее значение равно None или значение <наименьшее:
            наименьшее = значение
    возврат наименьшего  
 В функциональной версии наименьшего кода мы удалили все операторы  print , чтобы они были эквивалентны функции  min , которая уже встроена в Python.
 По мере того, как вы начинаете писать большие программы, вы можете тратить больше времени на отладку. Больше кода означает больше шансов на ошибку и больше мест, где ошибки могут спрятаться. 
 Один из способов сократить время отладки - «отладка пополам». Например, если в вашей программе 100 строк, и вы проверяете их по одной, это займет 100 шагов. 
 Вместо этого попробуйте разбить задачу пополам. Посмотрите в середине программы или рядом с ней, найдите промежуточное значение, которое вы можете проверить.Добавьте оператор  print  (или что-то еще, что имеет поддающийся проверке эффект) и запустите программу. 
 Если проверка средней точки неверна, проблема должна быть в первой половине программы. Если это правильно, проблема во втором тайме. 
 Каждый раз, когда вы выполняете такую ​​проверку, вы вдвое уменьшаете количество строк, которые нужно искать. После шести шагов (что намного меньше 100) вы получите одну или две строки кода, по крайней мере, теоретически. 
 На практике не всегда понятно, что такое «середина программы» и не всегда можно это проверить.Нет смысла считать линии и находить точную середину. Вместо этого подумайте о местах в программе, где могут быть ошибки, и о местах, где легко поставить проверку. Затем выберите место, где, по вашему мнению, шансы примерно такие же, как у ошибки до или после проверки. 

 аккумулятор 
 Переменная, используемая в цикле для суммирования или накопления результата.
 


 счетчик 
 Переменная, используемая в цикле для подсчета количества раз, когда что-то произошло.Мы инициализируем счетчик до нуля, а затем увеличиваем счетчик каждый раз, когда хотим что-то «подсчитать».
 


 декремент 
 Обновление, уменьшающее значение переменной.
 


 инициализировать 

 Присваивание, которое дает начальное значение переменной, которая будет обновлена. 

 шаг 
 Обновление, увеличивающее значение переменной (часто на единицу).
 


 бесконечный цикл 
 Цикл, в котором условие завершения никогда не выполняется или для которого нет условия завершения.


 итерация 
 Повторное выполнение набора операторов с использованием либо функции, которая вызывает сама себя, либо цикла.
 

 Упражнение 1: Напишите программу, которая многократно считывает числа, пока пользователь не введет «готово». После ввода «готово» распечатайте сумму, количество и среднее значение. Если пользователь вводит что-либо, кроме числа, обнаружьте свою ошибку, используя , попробуйте  и , кроме , распечатайте сообщение об ошибке и перейдите к следующему числу.
  Введите число: 4
Введите число: 5
Введите число: неверные данные
Некорректный ввод
Введите число: 7
Введите номер: готово
16 3 5,333333333333333  
 Упражнение 2: Напишите другую программу, которая запрашивает список чисел, как указано выше, и в конце выводит как максимум, так и минимум чисел вместо среднего. 
 Использование операторов Break, Continue и Pass 
 Введение 
 В Python 3 можно использовать два типа циклов.У вас есть циклы for и while. Вы можете использовать их для повторяющихся задач. В результате повторяющиеся задачи будут выполняться автоматически, что сделает процесс более эффективным. К сожалению, ваши петли могут столкнуться с некоторыми проблемами. Иногда ваша программа может столкнуться с проблемой, когда вам нужно пропустить часть цикла или полностью выйти из него. Или, может быть, вам нужно игнорировать внешний фактор, влияющий на программу. Если это то, что вы хотите добавить в свою программу, вам нужно использовать операторы  break ,  continue  и  pass .
 В этом руководстве мы обсудим, как можно использовать операторы break, continue и pass при работе с циклами в Python 3. 
 Как использовать оператор Break 
 Оператор  break  позволяет выйти из цикла при наличии внешнего воздействия. Вам нужно будет поместить этот оператор в код вашего оператора цикла. Обычно мы используем его с условным оператором  if . Чтобы помочь вам понять, давайте рассмотрим следующий цикл.Здесь мы используем оператор  break  в цикле  for : 

число = 0
для числа в диапазоне (10):

если число == 5:

перерыв # перерыв здесь
 print ('Число равно' + str (число))
print ('Вне цикла') 





 число = 0 

 для числа в диапазоне (10): 
 если число == 5: 
 break # break здесь 

 print ('Number is' + str (number)) 

 печать («Вне цикла») 




Как видите, мы инициализируем переменную  номер  на 0.Затем мы вставляем оператор  для , чтобы создать цикл. Условие состоит в том, что номер   меньше 10. После этого мы добавили оператор  if . В нем говорится, что если номер переменной   равен 5, то цикл будет прерван. Еще один фактор в коде цикла - это оператор  print () , который многократно выполняется с каждым циклом до тех пор, пока он не прервется. Наконец, последний оператор  print ()  позволяет нам получать предупреждения при выходе из цикла. 
 Добавление и запуск кода с этим оператором  break  даст вам следующий результат: 

 Это показывает, что как только переменная  номер  стала эквивалентной 5, цикл разорвался.Это означает, что программа сейчас вышла из цикла. 
 Как использовать оператор продолжения 
 С помощью оператора  continue  можно успешно пропустить только определенную часть цикла. Таким образом, когда ваша программа встречает триггер, она пропускает предустановленную часть цикла и продолжит выполнение оставшейся части сверху в новой итерации. Опять же, вам нужно будет использовать оператор  if . Давайте воспользуемся тем же примером, что и в предыдущем разделе. Здесь вместо оператора  break  мы применим оператор  continue : 

число = 0
для числа в диапазоне (10):

если число == 5:

continue # продолжить здесь

 print ('Число равно' + str (число))
print ('Вне цикла') 





 число = 0 

 для числа в диапазоне (10): 
 если число == 5: 
 продолжить # продолжить здесь 
 print ('Number is' + str (number)) 

 print («Вне цикла») 




Очевидная разница между выполнением операторов  break  и  continue  заключается в том, что с последним мы не выходим из цикла.Вместо этого код продолжается на следующей итерации, даже если номер переменной   эквивалентен 5. Результат будет выглядеть примерно так: 

 Как видите, в выходных данных не отображается значение  Число равно 5 . Цикл просто продолжается дальше. Он печатает контуры для чисел 6, 7, 8, 9 и 10 перед выходом из цикла. Это полезно, если вы хотите избежать использования условного кода. 
 Как использовать Заявление о прохождении 
 Оператор  pass  позволяет работать с внешним триггером, не прерывая цикл.Это означает, что независимо от внешнего фактора цикл продолжит печать строк, если не встретит другой оператор. Подобно двум другим операторам, мы добавим этот оператор в код цикла после условного оператора  if . Давайте применим это утверждение к нашему примеру: 

число = 0
для числа в диапазоне (10):

если число == 5:

пройти # пройти здесь
 print ('Число равно' + str (число))
print ('Вне цикла') 





 число = 0 

 для числа в диапазоне (10): 
 если число == 5: 
 пройти # пройти здесь 

 print ('Number is' + str (number)) 

 печать («Вне цикла») 




С помощью оператора  pass  мы говорим программе игнорировать тот факт, что номер переменной   равен 5.Запуск этого кода даст вам следующий результат: 

 Это показывает, что триггер не оказал никакого воздействия на петлю. Кажется, что условного оператора не было вообще. Таким образом, вы можете использовать оператор  pass  для создания минимальных классов или даже использовать его в качестве заполнителя для кодов, которые все еще находятся в разработке. 
 Наконец, вы можете взглянуть на другие наши руководства, которые помогут вам познакомиться с тем, что вы можете делать с Python: 
 Заключение 
 В этом руководстве мы помогли вам понять, что такое каждый из операторов  break, ,  continue,  и  pass,  и как они работают.Теперь вы знаете, как добавить их в блок кода операторов цикла в Python 3. Они помогут вам сделать циклы  для  и , а циклы  более эффективными в вашей программе. 
 Счастливых вычислений! 
 Об Акшай Нагпале 
 Аналитика больших данных и энтузиаст машинного обучения.