[{"data":1,"prerenderedAt":3055},["ShallowReactive",2],{"navigation":3,"\u002Fblog\u002Fpython\u002Fst9":386,"\u002Fblog\u002Fpython\u002Fst9-surround":3050},[4],{"title":5,"path":6,"stem":7,"children":8,"page":114},"Blog","\u002Fblog","blog",[9,115,184,329],{"title":10,"path":11,"stem":12,"children":13,"page":114},"Ege","\u002Fblog\u002Fege","blog\u002Fege",[14,18,22,26,30,34,38,42,46,50,54,58,62,66,70,74,78,82,86,90,94,98,102,106,110],{"title":15,"path":16,"stem":17},"ЕГЭ Задание 1","\u002Fblog\u002Fege\u002Ftask1","blog\u002Fege\u002Ftask1",{"title":19,"path":20,"stem":21},"ЕГЭ Задание 10","\u002Fblog\u002Fege\u002Ftask10","blog\u002Fege\u002Ftask10",{"title":23,"path":24,"stem":25},"ЕГЭ Задание 11","\u002Fblog\u002Fege\u002Ftask11","blog\u002Fege\u002Ftask11",{"title":27,"path":28,"stem":29},"ЕГЭ Задание 12","\u002Fblog\u002Fege\u002Ftask12","blog\u002Fege\u002Ftask12",{"title":31,"path":32,"stem":33},"ЕГЭ Задание 13","\u002Fblog\u002Fege\u002Ftask13","blog\u002Fege\u002Ftask13",{"title":35,"path":36,"stem":37},"ЕГЭ Задание 14","\u002Fblog\u002Fege\u002Ftask14","blog\u002Fege\u002Ftask14",{"title":39,"path":40,"stem":41},"ЕГЭ Задание 15","\u002Fblog\u002Fege\u002Ftask15","blog\u002Fege\u002Ftask15",{"title":43,"path":44,"stem":45},"ЕГЭ Задание 16","\u002Fblog\u002Fege\u002Ftask16","blog\u002Fege\u002Ftask16",{"title":47,"path":48,"stem":49},"ЕГЭ Задание 17","\u002Fblog\u002Fege\u002Ftask17","blog\u002Fege\u002Ftask17",{"title":51,"path":52,"stem":53},"ЕГЭ Задание 18","\u002Fblog\u002Fege\u002Ftask18","blog\u002Fege\u002Ftask18",{"title":55,"path":56,"stem":57},"ЕГЭ Задание 19, 20, 21","\u002Fblog\u002Fege\u002Ftask19_20_21","blog\u002Fege\u002Ftask19_20_21",{"title":59,"path":60,"stem":61},"ЕГЭ Задание 2","\u002Fblog\u002Fege\u002Ftask2","blog\u002Fege\u002Ftask2",{"title":63,"path":64,"stem":65},"ЕГЭ Задание 22","\u002Fblog\u002Fege\u002Ftask22","blog\u002Fege\u002Ftask22",{"title":67,"path":68,"stem":69},"ЕГЭ Задание 23","\u002Fblog\u002Fege\u002Ftask23","blog\u002Fege\u002Ftask23",{"title":71,"path":72,"stem":73},"ЕГЭ Задание 24","\u002Fblog\u002Fege\u002Ftask24","blog\u002Fege\u002Ftask24",{"title":75,"path":76,"stem":77},"ЕГЭ Задание 25","\u002Fblog\u002Fege\u002Ftask25","blog\u002Fege\u002Ftask25",{"title":79,"path":80,"stem":81},"ЕГЭ Задание 26","\u002Fblog\u002Fege\u002Ftask26","blog\u002Fege\u002Ftask26",{"title":83,"path":84,"stem":85},"ЕГЭ Задание 27","\u002Fblog\u002Fege\u002Ftask27","blog\u002Fege\u002Ftask27",{"title":87,"path":88,"stem":89},"ЕГЭ Задание 3","\u002Fblog\u002Fege\u002Ftask3","blog\u002Fege\u002Ftask3",{"title":91,"path":92,"stem":93},"ЕГЭ Задание 4","\u002Fblog\u002Fege\u002Ftask4","blog\u002Fege\u002Ftask4",{"title":95,"path":96,"stem":97},"ЕГЭ Задание 5","\u002Fblog\u002Fege\u002Ftask5","blog\u002Fege\u002Ftask5",{"title":99,"path":100,"stem":101},"ЕГЭ Задание 6","\u002Fblog\u002Fege\u002Ftask6","blog\u002Fege\u002Ftask6",{"title":103,"path":104,"stem":105},"ЕГЭ Задание 7","\u002Fblog\u002Fege\u002Ftask7","blog\u002Fege\u002Ftask7",{"title":107,"path":108,"stem":109},"ЕГЭ Задание 8","\u002Fblog\u002Fege\u002Ftask8","blog\u002Fege\u002Ftask8",{"title":111,"path":112,"stem":113},"ЕГЭ Задание 9","\u002Fblog\u002Fege\u002Ftask9","blog\u002Fege\u002Ftask9",false,{"title":116,"path":117,"stem":118,"children":119,"page":114},"Oge","\u002Fblog\u002Foge","blog\u002Foge",[120,124,128,132,136,140,144,148,152,156,160,164,168,172,176,180],{"title":121,"path":122,"stem":123},"ОГЭ Задание 1","\u002Fblog\u002Foge\u002Ftask1","blog\u002Foge\u002Ftask1",{"title":125,"path":126,"stem":127},"ОГЭ Задание 10","\u002Fblog\u002Foge\u002Ftask10","blog\u002Foge\u002Ftask10",{"title":129,"path":130,"stem":131},"ОГЭ Задание 11","\u002Fblog\u002Foge\u002Ftask11","blog\u002Foge\u002Ftask11",{"title":133,"path":134,"stem":135},"ОГЭ Задание 12","\u002Fblog\u002Foge\u002Ftask12","blog\u002Foge\u002Ftask12",{"title":137,"path":138,"stem":139},"ОГЭ Задание 13","\u002Fblog\u002Foge\u002Ftask13","blog\u002Foge\u002Ftask13",{"title":141,"path":142,"stem":143},"ОГЭ Задание 14","\u002Fblog\u002Foge\u002Ftask14","blog\u002Foge\u002Ftask14",{"title":145,"path":146,"stem":147},"ОГЭ Задание 15","\u002Fblog\u002Foge\u002Ftask15","blog\u002Foge\u002Ftask15",{"title":149,"path":150,"stem":151},"ОГЭ Задание 16","\u002Fblog\u002Foge\u002Ftask16","blog\u002Foge\u002Ftask16",{"title":153,"path":154,"stem":155},"ОГЭ Задание 2","\u002Fblog\u002Foge\u002Ftask2","blog\u002Foge\u002Ftask2",{"title":157,"path":158,"stem":159},"ОГЭ Задание 3","\u002Fblog\u002Foge\u002Ftask3","blog\u002Foge\u002Ftask3",{"title":161,"path":162,"stem":163},"ОГЭ Задание 4","\u002Fblog\u002Foge\u002Ftask4","blog\u002Foge\u002Ftask4",{"title":165,"path":166,"stem":167},"ОГЭ Задание 5","\u002Fblog\u002Foge\u002Ftask5","blog\u002Foge\u002Ftask5",{"title":169,"path":170,"stem":171},"ОГЭ Задание 6","\u002Fblog\u002Foge\u002Ftask6","blog\u002Foge\u002Ftask6",{"title":173,"path":174,"stem":175},"ОГЭ Задание 7","\u002Fblog\u002Foge\u002Ftask7","blog\u002Foge\u002Ftask7",{"title":177,"path":178,"stem":179},"ОГЭ Задание 8","\u002Fblog\u002Foge\u002Ftask8","blog\u002Foge\u002Ftask8",{"title":181,"path":182,"stem":183},"ОГЭ Задание 9","\u002Fblog\u002Foge\u002Ftask9","blog\u002Foge\u002Ftask9",{"title":185,"path":186,"stem":187,"children":188,"page":114},"Python","\u002Fblog\u002Fpython","blog\u002Fpython",[189,193,197,201,205,209,213,217,221,225,229,233,237,241,245,249,253,257,261,265,269,273,277,281,285,289,293,297,301,305,309,313,317,321,325],{"title":190,"path":191,"stem":192},"Знакомство с синтаксисом","\u002Fblog\u002Fpython\u002Fst1","blog\u002Fpython\u002Fst1",{"title":194,"path":195,"stem":196},"Отладка","\u002Fblog\u002Fpython\u002Fst10","blog\u002Fpython\u002Fst10",{"title":198,"path":199,"stem":200},"Модули и пакеты","\u002Fblog\u002Fpython\u002Fst11","blog\u002Fpython\u002Fst11",{"title":202,"path":203,"stem":204},"Кортежи","\u002Fblog\u002Fpython\u002Fst12","blog\u002Fpython\u002Fst12",{"title":206,"path":207,"stem":208},"Знакомство со списками","\u002Fblog\u002Fpython\u002Fst13","blog\u002Fpython\u002Fst13",{"title":210,"path":211,"stem":212},"Списки и циклы","\u002Fblog\u002Fpython\u002Fst14","blog\u002Fpython\u002Fst14",{"title":214,"path":215,"stem":216},"Использование списков ч.1","\u002Fblog\u002Fpython\u002Fst15","blog\u002Fpython\u002Fst15",{"title":218,"path":219,"stem":220},"Использование списков ч.2","\u002Fblog\u002Fpython\u002Fst16","blog\u002Fpython\u002Fst16",{"title":222,"path":223,"stem":224},"Использование списков ч.3","\u002Fblog\u002Fpython\u002Fst17","blog\u002Fpython\u002Fst17",{"title":226,"path":227,"stem":228},"Словари","\u002Fblog\u002Fpython\u002Fst18","blog\u002Fpython\u002Fst18",{"title":230,"path":231,"stem":232},"Множества","\u002Fblog\u002Fpython\u002Fst19","blog\u002Fpython\u002Fst19",{"title":234,"path":235,"stem":236},"Переменные","\u002Fblog\u002Fpython\u002Fst2","blog\u002Fpython\u002Fst2",{"title":238,"path":239,"stem":240},"Хеш-таблицы","\u002Fblog\u002Fpython\u002Fst20","blog\u002Fpython\u002Fst20",{"title":242,"path":243,"stem":244},"Решето Эратосфена","\u002Fblog\u002Fpython\u002Fst21","blog\u002Fpython\u002Fst21",{"title":246,"path":247,"stem":248},"Длинная арифметика","\u002Fblog\u002Fpython\u002Fst22","blog\u002Fpython\u002Fst22",{"title":250,"path":251,"stem":252},"Декораторы функций","\u002Fblog\u002Fpython\u002Fst23","blog\u002Fpython\u002Fst23",{"title":254,"path":255,"stem":256},"Знакомство с алгоритмами","\u002Fblog\u002Fpython\u002Fst24","blog\u002Fpython\u002Fst24",{"title":258,"path":259,"stem":260},"Бинарный поиск – примеры задач","\u002Fblog\u002Fpython\u002Fst25","blog\u002Fpython\u002Fst25",{"title":262,"path":263,"stem":264},"Сортировка выбором","\u002Fblog\u002Fpython\u002Fst26","blog\u002Fpython\u002Fst26",{"title":266,"path":267,"stem":268},"Рекурсия и стек","\u002Fblog\u002Fpython\u002Fst27","blog\u002Fpython\u002Fst27",{"title":270,"path":271,"stem":272},"Быстрая сортировка","\u002Fblog\u002Fpython\u002Fst28","blog\u002Fpython\u002Fst28",{"title":274,"path":275,"stem":276},"Поиск в ширину","\u002Fblog\u002Fpython\u002Fst29","blog\u002Fpython\u002Fst29",{"title":278,"path":279,"stem":280},"Работа со строками","\u002Fblog\u002Fpython\u002Fst3","blog\u002Fpython\u002Fst3",{"title":282,"path":283,"stem":284},"Поиск в глубину","\u002Fblog\u002Fpython\u002Fst30","blog\u002Fpython\u002Fst30",{"title":286,"path":287,"stem":288},"Сбалансированные деревья","\u002Fblog\u002Fpython\u002Fst31","blog\u002Fpython\u002Fst31",{"title":290,"path":291,"stem":292},"Алгоритм Дейкстры","\u002Fblog\u002Fpython\u002Fst32","blog\u002Fpython\u002Fst32",{"title":294,"path":295,"stem":296},"Жадные алгоритмы","\u002Fblog\u002Fpython\u002Fst33","blog\u002Fpython\u002Fst33",{"title":298,"path":299,"stem":300},"Динамическое программирование","\u002Fblog\u002Fpython\u002Fst34","blog\u002Fpython\u002Fst34",{"title":302,"path":303,"stem":304},"Алгоритм k ближайших соседей","\u002Fblog\u002Fpython\u002Fst35","blog\u002Fpython\u002Fst35",{"title":306,"path":307,"stem":308},"Типы данных","\u002Fblog\u002Fpython\u002Fst4","blog\u002Fpython\u002Fst4",{"title":310,"path":311,"stem":312},"О функциях","\u002Fblog\u002Fpython\u002Fst5","blog\u002Fpython\u002Fst5",{"title":314,"path":315,"stem":316},"Свойства и методы","\u002Fblog\u002Fpython\u002Fst6","blog\u002Fpython\u002Fst6",{"title":318,"path":319,"stem":320},"Определение функций","\u002Fblog\u002Fpython\u002Fst7","blog\u002Fpython\u002Fst7",{"title":322,"path":323,"stem":324},"Логика","\u002Fblog\u002Fpython\u002Fst8","blog\u002Fpython\u002Fst8",{"title":326,"path":327,"stem":328},"Циклы","\u002Fblog\u002Fpython\u002Fst9","blog\u002Fpython\u002Fst9",{"title":330,"path":331,"stem":332,"children":333,"page":114},"Toi","\u002Fblog\u002Ftoi","blog\u002Ftoi",[334,338,342,346,350,354,358,362,366,370,374,378,382],{"title":335,"path":336,"stem":337},"Информация и информационные процессы","\u002Fblog\u002Ftoi\u002Fst1","blog\u002Ftoi\u002Fst1",{"title":339,"path":340,"stem":341},"Электронные таблицы","\u002Fblog\u002Ftoi\u002Fst10","blog\u002Ftoi\u002Fst10",{"title":343,"path":344,"stem":345},"Система, её свойства и компоненты. Моделирование","\u002Fblog\u002Ftoi\u002Fst11","blog\u002Ftoi\u002Fst11",{"title":347,"path":348,"stem":349},"Представление информации в компьютере","\u002Fblog\u002Ftoi\u002Fst12","blog\u002Ftoi\u002Fst12",{"title":351,"path":352,"stem":353},"Средства информационно-коммуникационных технологий. Файловая система","\u002Fblog\u002Ftoi\u002Fst13","blog\u002Ftoi\u002Fst13",{"title":355,"path":356,"stem":357},"Комбинаторика","\u002Fblog\u002Ftoi\u002Fst2","blog\u002Ftoi\u002Fst2",{"title":359,"path":360,"stem":361},"Адресация в интернете","\u002Fblog\u002Ftoi\u002Fst3","blog\u002Ftoi\u002Fst3",{"title":363,"path":364,"stem":365},"Измерение количества информации","\u002Fblog\u002Ftoi\u002Fst4","blog\u002Ftoi\u002Fst4",{"title":367,"path":368,"stem":369},"Системы счисления","\u002Fblog\u002Ftoi\u002Fst5","blog\u002Ftoi\u002Fst5",{"title":371,"path":372,"stem":373},"Диаграммы Эйлера — Венна","\u002Fblog\u002Ftoi\u002Fst6","blog\u002Ftoi\u002Fst6",{"title":375,"path":376,"stem":377},"Условие Фано","\u002Fblog\u002Ftoi\u002Fst7","blog\u002Ftoi\u002Fst7",{"title":379,"path":380,"stem":381},"Теория графов","\u002Fblog\u002Ftoi\u002Fst8","blog\u002Ftoi\u002Fst8",{"title":383,"path":384,"stem":385},"Алгебра логики","\u002Fblog\u002Ftoi\u002Fst9","blog\u002Ftoi\u002Fst9",{"id":387,"title":326,"author":388,"body":393,"date":3042,"description":3043,"extension":3044,"image":3045,"meta":3046,"minRead":3047,"navigation":506,"num":528,"path":327,"seo":3048,"stem":328,"__hash__":3049},"python\u002Fblog\u002Fpython\u002Fst9.md",{"name":389,"avatar":390},"Штана Альберт Игоревич",{"src":391,"alt":392},"me.jpg","@ashtana",{"type":394,"value":395,"toc":3014},"minimark",[396,401,405,410,418,531,534,564,567,687,695,700,713,719,877,881,884,941,944,964,967,971,987,1009,1013,1016,1020,1023,1026,1113,1116,1230,1233,1318,1321,1325,1328,1350,1353,1449,1452,1517,1521,1524,1528,1531,1636,1647,1651,1654,1657,1665,1817,1820,1864,1867,1871,1874,1919,1922,2023,2026,2030,2037,2040,2051,2058,2061,2115,2122,2136,2139,2143,2146,2155,2158,2335,2338,2344,2347,2413,2416,2469,2472,2479,2482,2485,2496,2499,2546,2549,2602,2605,2608,2662,2666,2669,2727,2730,2834,2837,2993,2996,3007,3010],[397,398,400],"h2",{"id":399},"циклические-конструкции","Циклические конструкции",[402,403,404],"p",{},"Программы, которые мы пишем, со временем становятся сложнее и объемнее.\nОни еще далеки от реальных программ, хотя уже заставляют напрячься.\nВ этой статье рассматриваются одни из самых сложных базовых тем в программировании — циклы.",[406,407,409],"h4",{"id":408},"зачем-нужны-циклы","Зачем нужны циклы",[402,411,412,413,417],{},"Прикладные программы помогают управлять сотрудниками, финансами и могут развлекать.\nНесмотря на различия, они выполняют заложенные в них алгоритмы, которые похожи.\nАлгоритм — это последовательность действий, которая приводит к ожидаемому результату.\nПредставим, что у нас есть книга, и мы хотим найти в ней конкретную фразу.\nСаму фразу мы помним, но не знаем, на какой она странице.\nНам придется последовательно просматривать страницы до тех пор, пока не найдем нужную.\nАлгоритм включает логические проверки и перебор страниц.\nКоличество страниц, которое придется посмотреть, заранее неизвестно.\nНо сам процесс просмотра повторяется одинаковым образом.\nЧтобы выполнять повторяющиеся действия, нужны циклы.\nКаждый повтор называется ",[414,415,416],"strong",{},"итерацией",".\nНапишем функцию с простым циклом, который будет n раз выводить на экран строку 'Python':",[419,420,425],"pre",{"className":421,"code":422,"language":423,"meta":424,"style":424},"language-python shiki shiki-themes github-light","def print_python(n):\n    counter = 0\n    while counter \u003C n:\n        print('Python')\n        counter += 1\n\nprint_hello(2)\n# => Python\n# => Python\n","python","",[426,427,428,445,458,473,489,501,508,519,526],"code",{"__ignoreMap":424},[429,430,433,437,441],"span",{"class":431,"line":432},"line",1,[429,434,436],{"class":435},"sD7c4","def",[429,438,440],{"class":439},"s7eDp"," print_python",[429,442,444],{"class":443},"sgsFI","(n):\n",[429,446,448,451,454],{"class":431,"line":447},2,[429,449,450],{"class":443},"    counter ",[429,452,453],{"class":435},"=",[429,455,457],{"class":456},"sYu0t"," 0\n",[429,459,461,464,467,470],{"class":431,"line":460},3,[429,462,463],{"class":435},"    while",[429,465,466],{"class":443}," counter ",[429,468,469],{"class":435},"\u003C",[429,471,472],{"class":443}," n:\n",[429,474,476,479,482,486],{"class":431,"line":475},4,[429,477,478],{"class":456},"        print",[429,480,481],{"class":443},"(",[429,483,485],{"class":484},"sYBdl","'Python'",[429,487,488],{"class":443},")\n",[429,490,492,495,498],{"class":431,"line":491},5,[429,493,494],{"class":443},"        counter ",[429,496,497],{"class":435},"+=",[429,499,500],{"class":456}," 1\n",[429,502,504],{"class":431,"line":503},6,[429,505,507],{"emptyLinePlaceholder":506},true,"\n",[429,509,511,514,517],{"class":431,"line":510},7,[429,512,513],{"class":443},"print_hello(",[429,515,516],{"class":456},"2",[429,518,488],{"class":443},[429,520,522],{"class":431,"line":521},8,[429,523,525],{"class":524},"sAwPA","# => Python\n",[429,527,529],{"class":431,"line":528},9,[429,530,525],{"class":524},[402,532,533],{},"Теперь проанализируем пример функции с циклом, который выводит на экран числа от одного до числа-аргумента:",[419,535,537],{"className":421,"code":536,"language":423,"meta":424,"style":424},"print_numbers(3)\n# => 1\n# => 2\n# => 3\n",[426,538,539,549,554,559],{"__ignoreMap":424},[429,540,541,544,547],{"class":431,"line":432},[429,542,543],{"class":443},"print_numbers(",[429,545,546],{"class":456},"3",[429,548,488],{"class":443},[429,550,551],{"class":431,"line":447},[429,552,553],{"class":524},"# => 1\n",[429,555,556],{"class":431,"line":460},[429,557,558],{"class":524},"# => 2\n",[429,560,561],{"class":431,"line":475},[429,562,563],{"class":524},"# => 3\n",[402,565,566],{},"Эту функцию невозможно реализовать с помощью уже изученных средств, так как количество выводов на экран заранее неизвестно.\nА с циклами проблем не будет:",[419,568,570],{"className":421,"code":569,"language":423,"meta":424,"style":424},"def print_numbers(last_number):\n    # i — сокращение от index (порядковый номер)\n    # используется по общему соглашению во множестве языков\n    # как счетчик цикла\n    i = 1\n    while i \u003C= last_number:\n        print(i)\n        i = i + 1\n    print('finished!')\n\nprint_numbers(3)\n# => 1\n# => 2\n# => 3\n# => finished!\n",[426,571,572,582,587,592,597,606,619,626,640,652,657,666,671,676,681],{"__ignoreMap":424},[429,573,574,576,579],{"class":431,"line":432},[429,575,436],{"class":435},[429,577,578],{"class":439}," print_numbers",[429,580,581],{"class":443},"(last_number):\n",[429,583,584],{"class":431,"line":447},[429,585,586],{"class":524},"    # i — сокращение от index (порядковый номер)\n",[429,588,589],{"class":431,"line":460},[429,590,591],{"class":524},"    # используется по общему соглашению во множестве языков\n",[429,593,594],{"class":431,"line":475},[429,595,596],{"class":524},"    # как счетчик цикла\n",[429,598,599,602,604],{"class":431,"line":491},[429,600,601],{"class":443},"    i ",[429,603,453],{"class":435},[429,605,500],{"class":456},[429,607,608,610,613,616],{"class":431,"line":503},[429,609,463],{"class":435},[429,611,612],{"class":443}," i ",[429,614,615],{"class":435},"\u003C=",[429,617,618],{"class":443}," last_number:\n",[429,620,621,623],{"class":431,"line":510},[429,622,478],{"class":456},[429,624,625],{"class":443},"(i)\n",[429,627,628,631,633,635,638],{"class":431,"line":521},[429,629,630],{"class":443},"        i ",[429,632,453],{"class":435},[429,634,612],{"class":443},[429,636,637],{"class":435},"+",[429,639,500],{"class":456},[429,641,642,645,647,650],{"class":431,"line":528},[429,643,644],{"class":456},"    print",[429,646,481],{"class":443},[429,648,649],{"class":484},"'finished!'",[429,651,488],{"class":443},[429,653,655],{"class":431,"line":654},10,[429,656,507],{"emptyLinePlaceholder":506},[429,658,660,662,664],{"class":431,"line":659},11,[429,661,543],{"class":443},[429,663,546],{"class":456},[429,665,488],{"class":443},[429,667,669],{"class":431,"line":668},12,[429,670,553],{"class":524},[429,672,674],{"class":431,"line":673},13,[429,675,558],{"class":524},[429,677,679],{"class":431,"line":678},14,[429,680,563],{"class":524},[429,682,684],{"class":431,"line":683},15,[429,685,686],{"class":524},"# => finished!\n",[688,689,691,692],"h3",{"id":690},"цикл-while","Цикл ",[426,693,694],{},"while",[402,696,691,697,699],{},[426,698,694],{}," состоит из трех элементов:",[701,702,703,707,710],"ul",{},[704,705,706],"li",{},"Ключевое слово while",[704,708,709],{},"Предикат — условие, которое указывается после while и вычисляется на каждой итерации",[704,711,712],{},"Блок кода — тело цикла",[402,714,715,716,718],{},"Каждое выполнение тела цикла называется ",[414,717,416],{},".\nВ примере выше print_numbers(3) вызвал три итерации, на каждой из которых была выведена на экран переменная i.\nКонструкция читается так: «делать то, что указано в теле цикла, пока истинно условие i \u003C= last_number».\nРазберем работу этого кода для вызова print_numbers(3):",[419,720,722],{"className":421,"code":721,"language":423,"meta":424,"style":424},"# Инициализируется i\ni = 1\n\n# Предикат возвращает true, поэтому выполняется тело цикла\nwhile 1 \u003C= 3\n# print(1)\n# i = 1 + 1\n\n# Закончилось тело цикла, поэтому происходит возврат в начало\nwhile 2 \u003C= 3\n# print(2)\n# i = 2 + 1\n\n# Закончилось тело цикла, поэтому происходит возврат в начало\nwhile 3 \u003C= 3\n# print(3)\n# i = 3 + 1\n\n# Предикат возвращает false, поэтому выполнение переходит за цикл\nwhile 4 \u003C= 3\n\n# print('finished!')\n# На этом этапе i равен 4, но он нам уже не нужен\n# Функция завершается\n",[426,723,724,729,738,742,747,760,765,770,774,779,790,795,800,804,808,819,825,831,836,842,854,859,865,871],{"__ignoreMap":424},[429,725,726],{"class":431,"line":432},[429,727,728],{"class":524},"# Инициализируется i\n",[429,730,731,734,736],{"class":431,"line":447},[429,732,733],{"class":443},"i ",[429,735,453],{"class":435},[429,737,500],{"class":456},[429,739,740],{"class":431,"line":460},[429,741,507],{"emptyLinePlaceholder":506},[429,743,744],{"class":431,"line":475},[429,745,746],{"class":524},"# Предикат возвращает true, поэтому выполняется тело цикла\n",[429,748,749,751,754,757],{"class":431,"line":491},[429,750,694],{"class":435},[429,752,753],{"class":456}," 1",[429,755,756],{"class":435}," \u003C=",[429,758,759],{"class":456}," 3\n",[429,761,762],{"class":431,"line":503},[429,763,764],{"class":524},"# print(1)\n",[429,766,767],{"class":431,"line":510},[429,768,769],{"class":524},"# i = 1 + 1\n",[429,771,772],{"class":431,"line":521},[429,773,507],{"emptyLinePlaceholder":506},[429,775,776],{"class":431,"line":528},[429,777,778],{"class":524},"# Закончилось тело цикла, поэтому происходит возврат в начало\n",[429,780,781,783,786,788],{"class":431,"line":654},[429,782,694],{"class":435},[429,784,785],{"class":456}," 2",[429,787,756],{"class":435},[429,789,759],{"class":456},[429,791,792],{"class":431,"line":659},[429,793,794],{"class":524},"# print(2)\n",[429,796,797],{"class":431,"line":668},[429,798,799],{"class":524},"# i = 2 + 1\n",[429,801,802],{"class":431,"line":673},[429,803,507],{"emptyLinePlaceholder":506},[429,805,806],{"class":431,"line":678},[429,807,778],{"class":524},[429,809,810,812,815,817],{"class":431,"line":683},[429,811,694],{"class":435},[429,813,814],{"class":456}," 3",[429,816,756],{"class":435},[429,818,759],{"class":456},[429,820,822],{"class":431,"line":821},16,[429,823,824],{"class":524},"# print(3)\n",[429,826,828],{"class":431,"line":827},17,[429,829,830],{"class":524},"# i = 3 + 1\n",[429,832,834],{"class":431,"line":833},18,[429,835,507],{"emptyLinePlaceholder":506},[429,837,839],{"class":431,"line":838},19,[429,840,841],{"class":524},"# Предикат возвращает false, поэтому выполнение переходит за цикл\n",[429,843,845,847,850,852],{"class":431,"line":844},20,[429,846,694],{"class":435},[429,848,849],{"class":456}," 4",[429,851,756],{"class":435},[429,853,759],{"class":456},[429,855,857],{"class":431,"line":856},21,[429,858,507],{"emptyLinePlaceholder":506},[429,860,862],{"class":431,"line":861},22,[429,863,864],{"class":524},"# print('finished!')\n",[429,866,868],{"class":431,"line":867},23,[429,869,870],{"class":524},"# На этом этапе i равен 4, но он нам уже не нужен\n",[429,872,874],{"class":431,"line":873},24,[429,875,876],{"class":524},"# Функция завершается\n",[406,878,880],{"id":879},"завершение-цикла","Завершение цикла",[402,882,883],{},"Процесс, который порождает цикл, должен остановиться. За это отвечает программист.\nОбычно задача сводится к введению переменной — счетчика цикла.\nСначала он инициализируется — ему задается начальное значение.\nВ нашем примере это строчка i = 1. Затем в условии цикла проверяется, не достиг ли счетчик своего предельного значения.\nПредельное значение в примере определяется аргументом функции.\nЕсли условие цикла ложно, то тело не выполняется и интерпретатор двигается дальше — работает с инструкциями после цикла.\nЕсли условие цикла истинно, то выполняется тело, в котором находится элемент остановки — изменение значения счетчика.\nОбычно его делают в конце тела, и это изменение — место, где нельзя обойтись без переменной.\nВ примере выше за изменение отвечает строчка i = i + 1. На этом моменте новички много ошибаются.\nНапример, можно забыть увеличить значение счетчика или неправильно проверить его в предикате.\nЭто приведет к зацикливанию — цикл будет работать бесконечно, и программа никогда не остановится.\nВ таком случае ее нужно завершить принудительно.",[419,885,887],{"className":421,"code":886,"language":423,"meta":424,"style":424},"def print_numbers(last_number):\n    i = 1\n    # Этот цикл никогда не остановится\n    # и будет печатать всегда одно значение\n    while i \u003C= last_number:\n        print(i)\n    print('finished!')\n",[426,888,889,897,905,910,915,925,931],{"__ignoreMap":424},[429,890,891,893,895],{"class":431,"line":432},[429,892,436],{"class":435},[429,894,578],{"class":439},[429,896,581],{"class":443},[429,898,899,901,903],{"class":431,"line":447},[429,900,601],{"class":443},[429,902,453],{"class":435},[429,904,500],{"class":456},[429,906,907],{"class":431,"line":460},[429,908,909],{"class":524},"    # Этот цикл никогда не остановится\n",[429,911,912],{"class":431,"line":475},[429,913,914],{"class":524},"    # и будет печатать всегда одно значение\n",[429,916,917,919,921,923],{"class":431,"line":491},[429,918,463],{"class":435},[429,920,612],{"class":443},[429,922,615],{"class":435},[429,924,618],{"class":443},[429,926,927,929],{"class":431,"line":503},[429,928,478],{"class":456},[429,930,625],{"class":443},[429,932,933,935,937,939],{"class":431,"line":510},[429,934,644],{"class":456},[429,936,481],{"class":443},[429,938,649],{"class":484},[429,940,488],{"class":443},[402,942,943],{},"В некоторых случаях бесконечные циклы полезны.\nНе будем пока рассматривать такие ситуации, но код в таких циклах начинается так:",[419,945,947],{"className":421,"code":946,"language":423,"meta":424,"style":424},"while True:\n    # Что-то делаем\n",[426,948,949,959],{"__ignoreMap":424},[429,950,951,953,956],{"class":431,"line":432},[429,952,694],{"class":435},[429,954,955],{"class":456}," True",[429,957,958],{"class":443},":\n",[429,960,961],{"class":431,"line":447},[429,962,963],{"class":524},"    # Что-то делаем\n",[402,965,966],{},"Без циклов невозможно обойтись, когда алгоритм решения задачи требует повторения каких-то действий и количество этих операций заранее неизвестно.",[406,968,970],{"id":969},"синтаксический-сахар","Синтаксический сахар",[402,972,973,974,977,978,981,982,986],{},"Конструкции типа ",[426,975,976],{},"x = x + 1"," часто используются в Python, поэтому создатели языка добавили сокращенный вариант: ",[426,979,980],{},"x += 1",".\nОни отличаются только способом записи. Интерпретатор превратит сокращенную конструкцию в развернутую.\nТакие сокращения называют ",[983,984,985],"em",{},"синтаксическим сахаром",", потому что они делают процесс написания кода немного проще и приятнее.\nСуществуют сокращенные формы для всех арифметических операций и для конкатенации строк:",[701,988,989,994,999,1004],{},[704,990,991],{},[426,992,993],{},"x = x + 1 → x += 1",[704,995,996],{},[426,997,998],{},"x = x - 1 → x -= 1",[704,1000,1001],{},[426,1002,1003],{},"x = x * 2 → x *= 2",[704,1005,1006],{},[426,1007,1008],{},"x = x \u002F 1 → x \u002F= 1",[688,1010,1012],{"id":1011},"агрегация-данных","Агрегация данных",[402,1014,1015],{},"Отдельный класс задач, который не обходится без циклов, называется агрегированием данных.\nК таким задачам относятся: поиск максимального или минимального значения, суммы, среднего арифметического.\nВ этом случае результат зависит от всего набора данных.\nЧтобы рассчитать сумму, нужно сложить все числа, а чтобы вычислить максимальное, нужно их сравнить.\nС такими задачами хорошо знакомы бухгалтеры и маркетологи. Они работают с таблицами Microsoft Excel или Google Sheets.\nРазберем, как агрегация применяется к числам и строкам.",[406,1017,1019],{"id":1018},"числа","Числа",[402,1021,1022],{},"Допустим, нам нужно найти суммы набора чисел.\nРеализуем функцию, которая складывает числа в указанном диапазоне, включая границы.\nДиапазон — ряд чисел от конкретного начала до определенного конца.\nНапример, диапазон [1, 10] включает целые числа от одного до десяти.",[402,1024,1025],{},"Пример:",[419,1027,1029],{"className":421,"code":1028,"language":423,"meta":424,"style":424},"sum_numbers_from_range(5, 7)  # 5 + 6 + 7 = 18\nsum_numbers_from_range(1, 2)  # 1 + 2 = 3\n\n# [1, 1] — диапазон с одинаковым началом и концом — тоже диапазон\n# Он включает одно число — саму границу диапазона\nsum_numbers_from_range(1, 1)      # 1\nsum_numbers_from_range(100, 100)  # 100\n",[426,1030,1031,1051,1067,1071,1076,1081,1097],{"__ignoreMap":424},[429,1032,1033,1036,1039,1042,1045,1048],{"class":431,"line":432},[429,1034,1035],{"class":443},"sum_numbers_from_range(",[429,1037,1038],{"class":456},"5",[429,1040,1041],{"class":443},", ",[429,1043,1044],{"class":456},"7",[429,1046,1047],{"class":443},")  ",[429,1049,1050],{"class":524},"# 5 + 6 + 7 = 18\n",[429,1052,1053,1055,1058,1060,1062,1064],{"class":431,"line":447},[429,1054,1035],{"class":443},[429,1056,1057],{"class":456},"1",[429,1059,1041],{"class":443},[429,1061,516],{"class":456},[429,1063,1047],{"class":443},[429,1065,1066],{"class":524},"# 1 + 2 = 3\n",[429,1068,1069],{"class":431,"line":460},[429,1070,507],{"emptyLinePlaceholder":506},[429,1072,1073],{"class":431,"line":475},[429,1074,1075],{"class":524},"# [1, 1] — диапазон с одинаковым началом и концом — тоже диапазон\n",[429,1077,1078],{"class":431,"line":491},[429,1079,1080],{"class":524},"# Он включает одно число — саму границу диапазона\n",[429,1082,1083,1085,1087,1089,1091,1094],{"class":431,"line":503},[429,1084,1035],{"class":443},[429,1086,1057],{"class":456},[429,1088,1041],{"class":443},[429,1090,1057],{"class":456},[429,1092,1093],{"class":443},")      ",[429,1095,1096],{"class":524},"# 1\n",[429,1098,1099,1101,1104,1106,1108,1110],{"class":431,"line":510},[429,1100,1035],{"class":443},[429,1102,1103],{"class":456},"100",[429,1105,1041],{"class":443},[429,1107,1103],{"class":456},[429,1109,1047],{"class":443},[429,1111,1112],{"class":524},"# 100\n",[402,1114,1115],{},"Чтобы реализовать такой код, понадобится цикл, так как сложение чисел — это итеративный процесс, то есть повторяется для каждого числа.\nКоличество итераций зависит от размера диапазона.\nПосмотрите код ниже:",[419,1117,1119],{"className":421,"code":1118,"language":423,"meta":424,"style":424},"def sum_numbers_from_range(start, finish):\n    # Технически можно менять start\n    # Но входные аргументы нужно оставлять в исходном значении\n    # Это сделает код проще для анализа\n    i = start\n    sum = 0  # Инициализация суммы\n    while i \u003C= finish:  # Двигаемся до конца диапазона\n        sum = sum + i   # Считаем сумму для каждого числа\n        i = i + 1       # Переходим к следующему числу в диапазоне\n    # Возвращаем получившийся результат\n    return sum\n",[426,1120,1121,1131,1136,1141,1146,1155,1169,1183,1202,1217,1222],{"__ignoreMap":424},[429,1122,1123,1125,1128],{"class":431,"line":432},[429,1124,436],{"class":435},[429,1126,1127],{"class":439}," sum_numbers_from_range",[429,1129,1130],{"class":443},"(start, finish):\n",[429,1132,1133],{"class":431,"line":447},[429,1134,1135],{"class":524},"    # Технически можно менять start\n",[429,1137,1138],{"class":431,"line":460},[429,1139,1140],{"class":524},"    # Но входные аргументы нужно оставлять в исходном значении\n",[429,1142,1143],{"class":431,"line":475},[429,1144,1145],{"class":524},"    # Это сделает код проще для анализа\n",[429,1147,1148,1150,1152],{"class":431,"line":491},[429,1149,601],{"class":443},[429,1151,453],{"class":435},[429,1153,1154],{"class":443}," start\n",[429,1156,1157,1160,1163,1166],{"class":431,"line":503},[429,1158,1159],{"class":456},"    sum",[429,1161,1162],{"class":435}," =",[429,1164,1165],{"class":456}," 0",[429,1167,1168],{"class":524},"  # Инициализация суммы\n",[429,1170,1171,1173,1175,1177,1180],{"class":431,"line":510},[429,1172,463],{"class":435},[429,1174,612],{"class":443},[429,1176,615],{"class":435},[429,1178,1179],{"class":443}," finish:  ",[429,1181,1182],{"class":524},"# Двигаемся до конца диапазона\n",[429,1184,1185,1188,1190,1193,1196,1199],{"class":431,"line":521},[429,1186,1187],{"class":456},"        sum",[429,1189,1162],{"class":435},[429,1191,1192],{"class":456}," sum",[429,1194,1195],{"class":435}," +",[429,1197,1198],{"class":443}," i   ",[429,1200,1201],{"class":524},"# Считаем сумму для каждого числа\n",[429,1203,1204,1206,1208,1210,1212,1214],{"class":431,"line":528},[429,1205,630],{"class":443},[429,1207,453],{"class":435},[429,1209,612],{"class":443},[429,1211,637],{"class":435},[429,1213,753],{"class":456},[429,1215,1216],{"class":524},"       # Переходим к следующему числу в диапазоне\n",[429,1218,1219],{"class":431,"line":654},[429,1220,1221],{"class":524},"    # Возвращаем получившийся результат\n",[429,1223,1224,1227],{"class":431,"line":659},[429,1225,1226],{"class":435},"    return",[429,1228,1229],{"class":456}," sum\n",[402,1231,1232],{},"Структура цикла здесь стандартная: есть счетчик, который инициализируется начальным значением диапазона, цикл с условием остановки при достижении конца диапазона и изменении значения счетчика в конце тела цикла.\nКоличество итераций в таком цикле равно finish - start + 1. Для диапазона [5, 7] — это 7 - 5 + 1, то есть три итерации.\nГлавное отличие от обычной обработки — логика вычисления результата.\nВ задачах на агрегацию всегда есть переменная, которая хранит внутри себя результат работы цикла. В коде выше это sum.\nОна изменяется на каждой итерации цикла — прибавляется следующее число в диапазоне: sum = sum + i.\nЭтот процесс выглядит так:",[419,1234,1236],{"className":421,"code":1235,"language":423,"meta":424,"style":424},"# Для вызова sum_numbers_from_range(2, 5)\nsum = 0\nsum = sum + 2  # 2\nsum = sum + 3  # 5\nsum = sum + 4  # 9\nsum = sum + 5  # 14\n# 14 – результат сложения чисел в диапазоне [2, 5]\n",[426,1237,1238,1243,1252,1267,1282,1297,1313],{"__ignoreMap":424},[429,1239,1240],{"class":431,"line":432},[429,1241,1242],{"class":524},"# Для вызова sum_numbers_from_range(2, 5)\n",[429,1244,1245,1248,1250],{"class":431,"line":447},[429,1246,1247],{"class":456},"sum",[429,1249,1162],{"class":435},[429,1251,457],{"class":456},[429,1253,1254,1256,1258,1260,1262,1264],{"class":431,"line":460},[429,1255,1247],{"class":456},[429,1257,1162],{"class":435},[429,1259,1192],{"class":456},[429,1261,1195],{"class":435},[429,1263,785],{"class":456},[429,1265,1266],{"class":524},"  # 2\n",[429,1268,1269,1271,1273,1275,1277,1279],{"class":431,"line":475},[429,1270,1247],{"class":456},[429,1272,1162],{"class":435},[429,1274,1192],{"class":456},[429,1276,1195],{"class":435},[429,1278,814],{"class":456},[429,1280,1281],{"class":524},"  # 5\n",[429,1283,1284,1286,1288,1290,1292,1294],{"class":431,"line":491},[429,1285,1247],{"class":456},[429,1287,1162],{"class":435},[429,1289,1192],{"class":456},[429,1291,1195],{"class":435},[429,1293,849],{"class":456},[429,1295,1296],{"class":524},"  # 9\n",[429,1298,1299,1301,1303,1305,1307,1310],{"class":431,"line":503},[429,1300,1247],{"class":456},[429,1302,1162],{"class":435},[429,1304,1192],{"class":456},[429,1306,1195],{"class":435},[429,1308,1309],{"class":456}," 5",[429,1311,1312],{"class":524},"  # 14\n",[429,1314,1315],{"class":431,"line":510},[429,1316,1317],{"class":524},"# 14 – результат сложения чисел в диапазоне [2, 5]\n",[402,1319,1320],{},"У переменной sum есть начальное значение — с него начинается любая повторяющаяся операция. В примере выше — это 0.\nВ математике есть понятие нейтральный элемент, и у каждой операции он свой.\nОперация с этим элементом не изменяет то значение, над которым работает.\nНапример, при сложении любое число плюс ноль дает само число. При вычитании — то же самое.\nУ конкатенации тоже есть нейтральный элемент — это пустая строка: '' + 'one' будет 'one'.\nДалее разберем, как агрегация применяется к строкам.",[406,1322,1324],{"id":1323},"строки","Строки",[402,1326,1327],{},"Агрегация строк — это такие задачи, в которых заранее неизвестно, что содержат строки и какой у них размер.\nПредставьте функцию, которая умеет умножать строку — повторяет ее указанное количество раз:",[419,1329,1331],{"className":421,"code":1330,"language":423,"meta":424,"style":424},"repeat('python', 3)  # 'pythonpythonpython'\n",[426,1332,1333],{"__ignoreMap":424},[429,1334,1335,1338,1341,1343,1345,1347],{"class":431,"line":432},[429,1336,1337],{"class":443},"repeat(",[429,1339,1340],{"class":484},"'python'",[429,1342,1041],{"class":443},[429,1344,546],{"class":456},[429,1346,1047],{"class":443},[429,1348,1349],{"class":524},"# 'pythonpythonpython'\n",[402,1351,1352],{},"Принцип работы этой функции — в цикле происходит «наращивание» строки указанное количество раз:",[419,1354,1356],{"className":421,"code":1355,"language":423,"meta":424,"style":424},"def repeat(text, times):\n    # Нейтральный элемент для строк — пустая строка\n    result = ''\n    i = 1\n\n    while i \u003C= times:\n        # Каждый раз добавляем строку к результату\n        result = result + text\n        i = i + 1\n\n    return result\n",[426,1357,1358,1368,1373,1383,1391,1395,1406,1411,1426,1438,1442],{"__ignoreMap":424},[429,1359,1360,1362,1365],{"class":431,"line":432},[429,1361,436],{"class":435},[429,1363,1364],{"class":439}," repeat",[429,1366,1367],{"class":443},"(text, times):\n",[429,1369,1370],{"class":431,"line":447},[429,1371,1372],{"class":524},"    # Нейтральный элемент для строк — пустая строка\n",[429,1374,1375,1378,1380],{"class":431,"line":460},[429,1376,1377],{"class":443},"    result ",[429,1379,453],{"class":435},[429,1381,1382],{"class":484}," ''\n",[429,1384,1385,1387,1389],{"class":431,"line":475},[429,1386,601],{"class":443},[429,1388,453],{"class":435},[429,1390,500],{"class":456},[429,1392,1393],{"class":431,"line":491},[429,1394,507],{"emptyLinePlaceholder":506},[429,1396,1397,1399,1401,1403],{"class":431,"line":503},[429,1398,463],{"class":435},[429,1400,612],{"class":443},[429,1402,615],{"class":435},[429,1404,1405],{"class":443}," times:\n",[429,1407,1408],{"class":431,"line":510},[429,1409,1410],{"class":524},"        # Каждый раз добавляем строку к результату\n",[429,1412,1413,1416,1418,1421,1423],{"class":431,"line":521},[429,1414,1415],{"class":443},"        result ",[429,1417,453],{"class":435},[429,1419,1420],{"class":443}," result ",[429,1422,637],{"class":435},[429,1424,1425],{"class":443}," text\n",[429,1427,1428,1430,1432,1434,1436],{"class":431,"line":528},[429,1429,630],{"class":443},[429,1431,453],{"class":435},[429,1433,612],{"class":443},[429,1435,637],{"class":435},[429,1437,500],{"class":456},[429,1439,1440],{"class":431,"line":654},[429,1441,507],{"emptyLinePlaceholder":506},[429,1443,1444,1446],{"class":431,"line":659},[429,1445,1226],{"class":435},[429,1447,1448],{"class":443}," result\n",[402,1450,1451],{},"Распишем выполнение этого кода по шагам:",[419,1453,1455],{"className":421,"code":1454,"language":423,"meta":424,"style":424},"# Для вызова repeat('python', 3)\nresult = ''\nresult = result + 'python'  # python\nresult = result + 'python'  # pythonpython\nresult = result + 'python'  # pythonpythonpython\n",[426,1456,1457,1462,1471,1487,1502],{"__ignoreMap":424},[429,1458,1459],{"class":431,"line":432},[429,1460,1461],{"class":524},"# Для вызова repeat('python', 3)\n",[429,1463,1464,1467,1469],{"class":431,"line":447},[429,1465,1466],{"class":443},"result ",[429,1468,453],{"class":435},[429,1470,1382],{"class":484},[429,1472,1473,1475,1477,1479,1481,1484],{"class":431,"line":460},[429,1474,1466],{"class":443},[429,1476,453],{"class":435},[429,1478,1420],{"class":443},[429,1480,637],{"class":435},[429,1482,1483],{"class":484}," 'python'",[429,1485,1486],{"class":524},"  # python\n",[429,1488,1489,1491,1493,1495,1497,1499],{"class":431,"line":475},[429,1490,1466],{"class":443},[429,1492,453],{"class":435},[429,1494,1420],{"class":443},[429,1496,637],{"class":435},[429,1498,1483],{"class":484},[429,1500,1501],{"class":524},"  # pythonpython\n",[429,1503,1504,1506,1508,1510,1512,1514],{"class":431,"line":491},[429,1505,1466],{"class":443},[429,1507,453],{"class":435},[429,1509,1420],{"class":443},[429,1511,637],{"class":435},[429,1513,1483],{"class":484},[429,1515,1516],{"class":524},"  # pythonpythonpython\n",[688,1518,1520],{"id":1519},"обход-строк","Обход строк",[402,1522,1523],{},"С помощью циклов не только обрабатывают числа, но работают и со строками.\nНапример, можно получить конкретный символ по его индексу, а также формировать строки в циклах.",[406,1525,1527],{"id":1526},"получить-символ-по-индексу","Получить символ по индексу",[402,1529,1530],{},"Ниже пример кода, который печатает каждую букву каждого слова на отдельной строке:",[419,1532,1534],{"className":421,"code":1533,"language":423,"meta":424,"style":424},"def print_name_by_symbol(name):\n    i = 0\n    # Такая проверка будет выполняться до конца строки,\n    # включая последний символ. Его индекс len(name) - 1.\n    while i \u003C len(name):\n        # Обращаемся к символу по индексу\n        print(name[i])\n        i += 1\n\nname = 'Alex'\nprint_name_by_symbol(name)\n# => 'A'\n# => 'l'\n# => 'e'\n# => 'x'\n",[426,1535,1536,1546,1554,1559,1564,1577,1582,1589,1597,1601,1611,1616,1621,1626,1631],{"__ignoreMap":424},[429,1537,1538,1540,1543],{"class":431,"line":432},[429,1539,436],{"class":435},[429,1541,1542],{"class":439}," print_name_by_symbol",[429,1544,1545],{"class":443},"(name):\n",[429,1547,1548,1550,1552],{"class":431,"line":447},[429,1549,601],{"class":443},[429,1551,453],{"class":435},[429,1553,457],{"class":456},[429,1555,1556],{"class":431,"line":460},[429,1557,1558],{"class":524},"    # Такая проверка будет выполняться до конца строки,\n",[429,1560,1561],{"class":431,"line":475},[429,1562,1563],{"class":524},"    # включая последний символ. Его индекс len(name) - 1.\n",[429,1565,1566,1568,1570,1572,1575],{"class":431,"line":491},[429,1567,463],{"class":435},[429,1569,612],{"class":443},[429,1571,469],{"class":435},[429,1573,1574],{"class":456}," len",[429,1576,1545],{"class":443},[429,1578,1579],{"class":431,"line":503},[429,1580,1581],{"class":524},"        # Обращаемся к символу по индексу\n",[429,1583,1584,1586],{"class":431,"line":510},[429,1585,478],{"class":456},[429,1587,1588],{"class":443},"(name[i])\n",[429,1590,1591,1593,1595],{"class":431,"line":521},[429,1592,630],{"class":443},[429,1594,497],{"class":435},[429,1596,500],{"class":456},[429,1598,1599],{"class":431,"line":528},[429,1600,507],{"emptyLinePlaceholder":506},[429,1602,1603,1606,1608],{"class":431,"line":654},[429,1604,1605],{"class":443},"name ",[429,1607,453],{"class":435},[429,1609,1610],{"class":484}," 'Alex'\n",[429,1612,1613],{"class":431,"line":659},[429,1614,1615],{"class":443},"print_name_by_symbol(name)\n",[429,1617,1618],{"class":431,"line":668},[429,1619,1620],{"class":524},"# => 'A'\n",[429,1622,1623],{"class":431,"line":673},[429,1624,1625],{"class":524},"# => 'l'\n",[429,1627,1628],{"class":431,"line":678},[429,1629,1630],{"class":524},"# => 'e'\n",[429,1632,1633],{"class":431,"line":683},[429,1634,1635],{"class":524},"# => 'x'\n",[402,1637,1638,1639,1642,1643,1646],{},"Главное в этом коде — поставить правильное условие в while.\nЭто можно сделать двумя способами: ",[426,1640,1641],{},"i \u003C len(name)"," или ",[426,1644,1645],{},"i \u003C= len(name) - 1"," — они приведут к одному результату.",[406,1648,1650],{"id":1649},"как-формировать-строки-в-циклах","Как формировать строки в циклах",[402,1652,1653],{},"Еще циклы можно использовать, чтобы формировать строки. Подобная задача часто встречается в веб-программировании.\nОна сводится к обычной агрегации, когда применяется интерполяция или конкатенация.\nПереворот строки — алгоритмическая задача, которую задают на собеседованиях.\nПравильный способ перевернуть строку — использовать функцию из стандартной библиотеки. Но важно знать, как ее реализовать.",[402,1655,1656],{},"Один из алгоритмов выглядит так:",[701,1658,1659,1662],{},[704,1660,1661],{},"Строим новую строку;",[704,1663,1664],{},"Перебираем символы исходной строки в обратном порядке.",[419,1666,1668],{"className":421,"code":1667,"language":423,"meta":424,"style":424},"def reverse_string(string):\n    index = len(string) - 1\n    reversed_string = ''\n\n    while index >= 0:\n        current_char = string[index]\n        reversed_string = reversed_string + current_char\n        # То же самое через интерполяцию\n        # reversed_string = f'{reversed_string}{current_char}'\n        index = index - 1\n\n    return reversed_string\n\nreverse_string('Game Of Thrones')  # 'senorhT fO emaG'\n# Проверка нейтрального элемента\nreverse_string('')  # ''\n",[426,1669,1670,1680,1697,1706,1710,1724,1734,1749,1754,1759,1772,1776,1783,1787,1800,1805],{"__ignoreMap":424},[429,1671,1672,1674,1677],{"class":431,"line":432},[429,1673,436],{"class":435},[429,1675,1676],{"class":439}," reverse_string",[429,1678,1679],{"class":443},"(string):\n",[429,1681,1682,1685,1687,1689,1692,1695],{"class":431,"line":447},[429,1683,1684],{"class":443},"    index ",[429,1686,453],{"class":435},[429,1688,1574],{"class":456},[429,1690,1691],{"class":443},"(string) ",[429,1693,1694],{"class":435},"-",[429,1696,500],{"class":456},[429,1698,1699,1702,1704],{"class":431,"line":460},[429,1700,1701],{"class":443},"    reversed_string ",[429,1703,453],{"class":435},[429,1705,1382],{"class":484},[429,1707,1708],{"class":431,"line":475},[429,1709,507],{"emptyLinePlaceholder":506},[429,1711,1712,1714,1717,1720,1722],{"class":431,"line":491},[429,1713,463],{"class":435},[429,1715,1716],{"class":443}," index ",[429,1718,1719],{"class":435},">=",[429,1721,1165],{"class":456},[429,1723,958],{"class":443},[429,1725,1726,1729,1731],{"class":431,"line":503},[429,1727,1728],{"class":443},"        current_char ",[429,1730,453],{"class":435},[429,1732,1733],{"class":443}," string[index]\n",[429,1735,1736,1739,1741,1744,1746],{"class":431,"line":510},[429,1737,1738],{"class":443},"        reversed_string ",[429,1740,453],{"class":435},[429,1742,1743],{"class":443}," reversed_string ",[429,1745,637],{"class":435},[429,1747,1748],{"class":443}," current_char\n",[429,1750,1751],{"class":431,"line":521},[429,1752,1753],{"class":524},"        # То же самое через интерполяцию\n",[429,1755,1756],{"class":431,"line":528},[429,1757,1758],{"class":524},"        # reversed_string = f'{reversed_string}{current_char}'\n",[429,1760,1761,1764,1766,1768,1770],{"class":431,"line":654},[429,1762,1763],{"class":443},"        index ",[429,1765,453],{"class":435},[429,1767,1716],{"class":443},[429,1769,1694],{"class":435},[429,1771,500],{"class":456},[429,1773,1774],{"class":431,"line":659},[429,1775,507],{"emptyLinePlaceholder":506},[429,1777,1778,1780],{"class":431,"line":668},[429,1779,1226],{"class":435},[429,1781,1782],{"class":443}," reversed_string\n",[429,1784,1785],{"class":431,"line":673},[429,1786,507],{"emptyLinePlaceholder":506},[429,1788,1789,1792,1795,1797],{"class":431,"line":678},[429,1790,1791],{"class":443},"reverse_string(",[429,1793,1794],{"class":484},"'Game Of Thrones'",[429,1796,1047],{"class":443},[429,1798,1799],{"class":524},"# 'senorhT fO emaG'\n",[429,1801,1802],{"class":431,"line":683},[429,1803,1804],{"class":524},"# Проверка нейтрального элемента\n",[429,1806,1807,1809,1812,1814],{"class":431,"line":821},[429,1808,1791],{"class":443},[429,1810,1811],{"class":484},"''",[429,1813,1047],{"class":443},[429,1815,1816],{"class":524},"# ''\n",[402,1818,1819],{},"Разберем функцию построчно:",[701,1821,1822,1828,1834,1840,1846,1852,1858],{},[704,1823,1824,1827],{},[426,1825,1826],{},"index = len(string) - 1"," — записываем в новую переменную индекс последнего символа строки (индексы начинаются с нуля);",[704,1829,1830,1833],{},[426,1831,1832],{},"reversed_string = ''"," — инициализируем строку, куда будем записывать результат;",[704,1835,1836,1839],{},[426,1837,1838],{},"while index >= 0:"," — условие: повторяем тело цикла, пока текущий индекс не дошел до 0 — до первого символа;",[704,1841,1842,1845],{},[426,1843,1844],{},"current_char = string[index]"," — берем из строки символ по текущему индексу;",[704,1847,1848,1851],{},[426,1849,1850],{},"reversed_string = reversed_string + current_char"," — записываем в строку-результат новое значение: текущая строка-результат + новый символ;",[704,1853,1854,1857],{},[426,1855,1856],{},"index = index - 1"," — обновляем счетчик;",[704,1859,1860,1863],{},[426,1861,1862],{},"return reversed_string"," — когда цикл завершился, возвращаем строку-результат.",[402,1865,1866],{},"Советуем скопировать эту функцию и поэкспериментировать с ней.\nРаботая со строками, программисты часто допускают ошибку — выходят за границы строки.\nЕсли неправильно подобрать начальное значение счетчика или допустить ошибку в предикате цикла, функция может обращаться к несуществующему символу.\nОсобенно часто забывают, что индекс последнего элемента всегда меньше на единицу размера строки.\nВ строках начальный индекс равен 0, значит, индекс последнего элемента — len(str) - 1.",[688,1868,1870],{"id":1869},"условия-внутри-цикла","Условия внутри цикла",[402,1872,1873],{},"В теле цикла, как и в теле функции, можно выполнять инструкции.\nПоэтому внутри цикла можно использовать все изученное ранее, например — условные конструкции.\nПредставьте функцию, которая считает, сколько раз входит буква в предложение. Пример ее работы:",[419,1875,1877],{"className":421,"code":1876,"language":423,"meta":424,"style":424},"count_chars('Fear cuts deeper than swords.', 'e')  # 4\n# Если вы ничего не нашли, то результат — 0 совпадений\ncount_chars('Sansa', 'y')  # 0\n",[426,1878,1879,1897,1902],{"__ignoreMap":424},[429,1880,1881,1884,1887,1889,1892,1894],{"class":431,"line":432},[429,1882,1883],{"class":443},"count_chars(",[429,1885,1886],{"class":484},"'Fear cuts deeper than swords.'",[429,1888,1041],{"class":443},[429,1890,1891],{"class":484},"'e'",[429,1893,1047],{"class":443},[429,1895,1896],{"class":524},"# 4\n",[429,1898,1899],{"class":431,"line":447},[429,1900,1901],{"class":524},"# Если вы ничего не нашли, то результат — 0 совпадений\n",[429,1903,1904,1906,1909,1911,1914,1916],{"class":431,"line":460},[429,1905,1883],{"class":443},[429,1907,1908],{"class":484},"'Sansa'",[429,1910,1041],{"class":443},[429,1912,1913],{"class":484},"'y'",[429,1915,1047],{"class":443},[429,1917,1918],{"class":524},"# 0\n",[402,1920,1921],{},"Перед тем как посмотреть содержимое функции, подумайте: Является ли эта операция агрегацией? Какой будет проверка на вхождение символа?",[419,1923,1925],{"className":421,"code":1924,"language":423,"meta":424,"style":424},"def count_chars(string, char):\n    index = 0\n    count = 0\n    while index \u003C len(string):\n        if string[index] == char:\n            # Считаем только подходящие символы\n            count = count + 1\n        # Счетчик увеличивается в любом случае\n        index = index + 1\n    return count\n",[426,1926,1927,1937,1945,1954,1966,1980,1985,1999,2004,2016],{"__ignoreMap":424},[429,1928,1929,1931,1934],{"class":431,"line":432},[429,1930,436],{"class":435},[429,1932,1933],{"class":439}," count_chars",[429,1935,1936],{"class":443},"(string, char):\n",[429,1938,1939,1941,1943],{"class":431,"line":447},[429,1940,1684],{"class":443},[429,1942,453],{"class":435},[429,1944,457],{"class":456},[429,1946,1947,1950,1952],{"class":431,"line":460},[429,1948,1949],{"class":443},"    count ",[429,1951,453],{"class":435},[429,1953,457],{"class":456},[429,1955,1956,1958,1960,1962,1964],{"class":431,"line":475},[429,1957,463],{"class":435},[429,1959,1716],{"class":443},[429,1961,469],{"class":435},[429,1963,1574],{"class":456},[429,1965,1679],{"class":443},[429,1967,1968,1971,1974,1977],{"class":431,"line":491},[429,1969,1970],{"class":435},"        if",[429,1972,1973],{"class":443}," string[index] ",[429,1975,1976],{"class":435},"==",[429,1978,1979],{"class":443}," char:\n",[429,1981,1982],{"class":431,"line":503},[429,1983,1984],{"class":524},"            # Считаем только подходящие символы\n",[429,1986,1987,1990,1992,1995,1997],{"class":431,"line":510},[429,1988,1989],{"class":443},"            count ",[429,1991,453],{"class":435},[429,1993,1994],{"class":443}," count ",[429,1996,637],{"class":435},[429,1998,500],{"class":456},[429,2000,2001],{"class":431,"line":521},[429,2002,2003],{"class":524},"        # Счетчик увеличивается в любом случае\n",[429,2005,2006,2008,2010,2012,2014],{"class":431,"line":528},[429,2007,1763],{"class":443},[429,2009,453],{"class":435},[429,2011,1716],{"class":443},[429,2013,637],{"class":435},[429,2015,500],{"class":456},[429,2017,2018,2020],{"class":431,"line":654},[429,2019,1226],{"class":435},[429,2021,2022],{"class":443}," count\n",[402,2024,2025],{},"Это агрегирующая задача.\nНесмотря на то, что функция считает не все символы, чтобы подсчитать сумму, приходится анализировать каждый символ.\nКлючевое отличие этого цикла от рассмотренных — внутри тела есть условие.\nПеременная count увеличивается только в том случае, когда рассматриваемый символ совпадает с ожидаемым.\nВ остальном — это типичная агрегатная функция, которая возвращает количество нужных символов.",[406,2027,2029],{"id":2028},"пограничные-случаи","Пограничные случаи",[402,2031,2032,2033,2036],{},"Функция my_substr(), которую вы реализовали ранее, содержит много ошибок.\nОна прошла проверку, так как в ней не было ",[983,2034,2035],{},"пограничных случаев",".\nФункция работала с нормальными аргументами.",[402,2038,2039],{},"А теперь представим, что ей передали такие варианты длины:",[701,2041,2042,2045,2048],{},[704,2043,2044],{},"0;",[704,2046,2047],{},"Отрицательное число;",[704,2049,2050],{},"Число, которое превышает реальный размер строки;",[402,2052,2053,2054,2057],{},"Функция my_substr() не рассчитана на такие варианты.\nКод будет запускаться в разных ситуациях, с разными комбинациями условий и данных.\nНельзя быть уверенным, что аргументы всегда будут корректными, поэтому нужно учитывать все случаи.\n",[983,2055,2056],{},"Ошибки в пограничных случаях — частая причина логических ошибок в программах.","\nПрограммисты всегда забывают что-нибудь учесть.\nТакие ошибки часто проявляются не сразу и могут долго не приводить к видимым проблемам.\nПрограмма продолжает работать, но в какой-то момент обнаруживается, что в результатах есть ошибки.\nЧасто причина в динамической типизации Python.\nВы научитесь справляться с такими ошибками с опытом.",[402,2059,2060],{},"Представим расширенную функцию my_substr().\nОна принимает три аргумента: строку, индекс и длину извлекаемой подстроки.\nФункция возвращает подстроку указанной длины, начиная с указанного индекса.\nПримеры вызова:",[419,2062,2064],{"className":421,"code":2063,"language":423,"meta":424,"style":424},"string = 'If I look back I am lost'\nprint(my_substr(string, 0, 1))  # => 'I'\nprint(my_substr(string, 3, 6))  # => 'I look'\n",[426,2065,2066,2076,2097],{"__ignoreMap":424},[429,2067,2068,2071,2073],{"class":431,"line":432},[429,2069,2070],{"class":443},"string ",[429,2072,453],{"class":435},[429,2074,2075],{"class":484}," 'If I look back I am lost'\n",[429,2077,2078,2081,2084,2087,2089,2091,2094],{"class":431,"line":447},[429,2079,2080],{"class":456},"print",[429,2082,2083],{"class":443},"(my_substr(string, ",[429,2085,2086],{"class":456},"0",[429,2088,1041],{"class":443},[429,2090,1057],{"class":456},[429,2092,2093],{"class":443},"))  ",[429,2095,2096],{"class":524},"# => 'I'\n",[429,2098,2099,2101,2103,2105,2107,2110,2112],{"class":431,"line":460},[429,2100,2080],{"class":456},[429,2102,2083],{"class":443},[429,2104,546],{"class":456},[429,2106,1041],{"class":443},[429,2108,2109],{"class":456},"6",[429,2111,2093],{"class":443},[429,2113,2114],{"class":524},"# => 'I look'\n",[402,2116,2117,2118,2121],{},"Какие ",[983,2119,2120],{},"пограничные случаи"," стоит учитывать:",[701,2123,2124,2127,2130,2133],{},[704,2125,2126],{},"Отрицательная длина извлекаемой подстроки;",[704,2128,2129],{},"Отрицательный заданный индекс;",[704,2131,2132],{},"Заданный индекс выходит за границу всей строки;",[704,2134,2135],{},"Длина подстроки в сумме с заданным индексом выходит за границу всей строки.",[402,2137,2138],{},"Когда функция реализуется, каждый пограничный случай будет отдельным блоком кода. Скорее всего, он будет реализовываться с помощью if.\nЧтобы написать функцию my_substr() и защититься от этих случаев, стоит реализовать отдельную функцию, которая будет проверять аргументы на корректность.",[406,2140,2142],{"id":2141},"возврат-из-циклов","Возврат из циклов",[402,2144,2145],{},"Работа с циклами обычно сводится к двум сценариям:",[2147,2148,2149,2152],"ol",{},[704,2150,2151],{},"Агрегация. Накопление результата во время итераций и работа с ним после завершения цикла. Переворот строки относится к такому варианту",[704,2153,2154],{},"Выполнение цикла до достижения необходимого результата и выход. Например, задача поиска простых чисел — которые делятся без остатка только на себя и на единицу.",[402,2156,2157],{},"Рассмотрим алгоритм проверки простоты числа.\nБудем делить искомое число x на все числа из диапазона от двух до x - 1 и смотреть остаток.\nЕсли в этом диапазоне не найден делитель, который делит число x без остатка, значит, перед нами простое число.\nВ этом случае достаточно проверять числа не до x - 1, а до половины числа.\nНапример, 11 не делится на 2, 3, 4, 5. Но и дальше не будет делиться на числа больше своей половины.\nЗначит, можно оптимизировать алгоритм и проверять деление только до x \u002F 2:",[419,2159,2161],{"className":421,"code":2160,"language":423,"meta":424,"style":424},"def is_prime(number):\n    if number \u003C 2:\n        return False\n\n    divider = 2\n\n    while divider \u003C= number \u002F 2:\n        if number % divider == 0:\n            return False\n\n        divider += 1\n\n    return True\n\nprint(is_prime(1))  # => False\nprint(is_prime(2))  # => True\nprint(is_prime(3))  # => True\nprint(is_prime(4))  # => False\n",[426,2162,2163,2173,2187,2195,2199,2209,2213,2231,2248,2255,2259,2268,2272,2279,2283,2297,2310,2322],{"__ignoreMap":424},[429,2164,2165,2167,2170],{"class":431,"line":432},[429,2166,436],{"class":435},[429,2168,2169],{"class":439}," is_prime",[429,2171,2172],{"class":443},"(number):\n",[429,2174,2175,2178,2181,2183,2185],{"class":431,"line":447},[429,2176,2177],{"class":435},"    if",[429,2179,2180],{"class":443}," number ",[429,2182,469],{"class":435},[429,2184,785],{"class":456},[429,2186,958],{"class":443},[429,2188,2189,2192],{"class":431,"line":460},[429,2190,2191],{"class":435},"        return",[429,2193,2194],{"class":456}," False\n",[429,2196,2197],{"class":431,"line":475},[429,2198,507],{"emptyLinePlaceholder":506},[429,2200,2201,2204,2206],{"class":431,"line":491},[429,2202,2203],{"class":443},"    divider ",[429,2205,453],{"class":435},[429,2207,2208],{"class":456}," 2\n",[429,2210,2211],{"class":431,"line":503},[429,2212,507],{"emptyLinePlaceholder":506},[429,2214,2215,2217,2220,2222,2224,2227,2229],{"class":431,"line":510},[429,2216,463],{"class":435},[429,2218,2219],{"class":443}," divider ",[429,2221,615],{"class":435},[429,2223,2180],{"class":443},[429,2225,2226],{"class":435},"\u002F",[429,2228,785],{"class":456},[429,2230,958],{"class":443},[429,2232,2233,2235,2237,2240,2242,2244,2246],{"class":431,"line":521},[429,2234,1970],{"class":435},[429,2236,2180],{"class":443},[429,2238,2239],{"class":435},"%",[429,2241,2219],{"class":443},[429,2243,1976],{"class":435},[429,2245,1165],{"class":456},[429,2247,958],{"class":443},[429,2249,2250,2253],{"class":431,"line":528},[429,2251,2252],{"class":435},"            return",[429,2254,2194],{"class":456},[429,2256,2257],{"class":431,"line":654},[429,2258,507],{"emptyLinePlaceholder":506},[429,2260,2261,2264,2266],{"class":431,"line":659},[429,2262,2263],{"class":443},"        divider ",[429,2265,497],{"class":435},[429,2267,500],{"class":456},[429,2269,2270],{"class":431,"line":668},[429,2271,507],{"emptyLinePlaceholder":506},[429,2273,2274,2276],{"class":431,"line":673},[429,2275,1226],{"class":435},[429,2277,2278],{"class":456}," True\n",[429,2280,2281],{"class":431,"line":678},[429,2282,507],{"emptyLinePlaceholder":506},[429,2284,2285,2287,2290,2292,2294],{"class":431,"line":683},[429,2286,2080],{"class":456},[429,2288,2289],{"class":443},"(is_prime(",[429,2291,1057],{"class":456},[429,2293,2093],{"class":443},[429,2295,2296],{"class":524},"# => False\n",[429,2298,2299,2301,2303,2305,2307],{"class":431,"line":821},[429,2300,2080],{"class":456},[429,2302,2289],{"class":443},[429,2304,516],{"class":456},[429,2306,2093],{"class":443},[429,2308,2309],{"class":524},"# => True\n",[429,2311,2312,2314,2316,2318,2320],{"class":431,"line":827},[429,2313,2080],{"class":456},[429,2315,2289],{"class":443},[429,2317,546],{"class":456},[429,2319,2093],{"class":443},[429,2321,2309],{"class":524},[429,2323,2324,2326,2328,2331,2333],{"class":431,"line":833},[429,2325,2080],{"class":456},[429,2327,2289],{"class":443},[429,2329,2330],{"class":456},"4",[429,2332,2093],{"class":443},[429,2334,2296],{"class":524},[402,2336,2337],{},"Если быть честными, то для решения задачи хватит проверки чисел до значения квадратного корня number, но в нашем случае важно сосредоточиться на понимании работы с условиями внутри цикла.\nПредставим, что по алгоритму последовательного деления на числа до x \u002F 2 нашлось одно, которое делит без остатка.\nЗначит, переданный аргумент — не простое число, и дальнейшие вычисления не имеют смысла. В этом месте стоит возврат False.\nЕсли цикл отработал целиком, а число, которое делит без остатка, не нашлось, значит, число — простое.",[688,2339,691,2341],{"id":2340},"цикл-for",[426,2342,2343],{},"for",[402,2345,2346],{},"Цикл while идеален для ситуаций, когда количество итераций неизвестно заранее — например, при поиске простого числа.\nКогда количество итераций известно, предпочтительнее использовать цикл for.\nПредставьте, что у нас есть ряд чисел от 0 до 9. Мы хотим сложить эти числа. Мы могли бы сделать это так:",[419,2348,2350],{"className":421,"code":2349,"language":423,"meta":424,"style":424},"sum = 0\ni = 0\nwhile i \u003C 10:\n    sum += i\n    i += 1\nprint(sum) # => 45\n",[426,2351,2352,2360,2368,2381,2391,2399],{"__ignoreMap":424},[429,2353,2354,2356,2358],{"class":431,"line":432},[429,2355,1247],{"class":456},[429,2357,1162],{"class":435},[429,2359,457],{"class":456},[429,2361,2362,2364,2366],{"class":431,"line":447},[429,2363,733],{"class":443},[429,2365,453],{"class":435},[429,2367,457],{"class":456},[429,2369,2370,2372,2374,2376,2379],{"class":431,"line":460},[429,2371,694],{"class":435},[429,2373,612],{"class":443},[429,2375,469],{"class":435},[429,2377,2378],{"class":456}," 10",[429,2380,958],{"class":443},[429,2382,2383,2385,2388],{"class":431,"line":475},[429,2384,1159],{"class":456},[429,2386,2387],{"class":435}," +=",[429,2389,2390],{"class":443}," i\n",[429,2392,2393,2395,2397],{"class":431,"line":491},[429,2394,601],{"class":443},[429,2396,497],{"class":435},[429,2398,500],{"class":456},[429,2400,2401,2403,2405,2407,2410],{"class":431,"line":503},[429,2402,2080],{"class":456},[429,2404,481],{"class":443},[429,2406,1247],{"class":456},[429,2408,2409],{"class":443},") ",[429,2411,2412],{"class":524},"# => 45\n",[402,2414,2415],{},"Сначала мы устанавливаем начальную сумму 0.\nДалее запускается цикл, в котором переменная i начинает принимать значения начиная с 0 и доходя до 10.\nНа каждом шаге мы прибавляем значение i к нашей сумме и увеличиваем i на 1.\nКак только i становится равным 10, цикл заканчивается и программа выдаёт нам сумму всех чисел от 0 до 9 равную 45.\nТакой код мы можем переписать на цикл for:",[419,2417,2419],{"className":421,"code":2418,"language":423,"meta":424,"style":424},"sum = 0\nfor i in range(10):\n    sum += i\nprint(sum) # => 45\n",[426,2420,2421,2429,2449,2457],{"__ignoreMap":424},[429,2422,2423,2425,2427],{"class":431,"line":432},[429,2424,1247],{"class":456},[429,2426,1162],{"class":435},[429,2428,457],{"class":456},[429,2430,2431,2433,2435,2438,2441,2443,2446],{"class":431,"line":447},[429,2432,2343],{"class":435},[429,2434,612],{"class":443},[429,2436,2437],{"class":435},"in",[429,2439,2440],{"class":456}," range",[429,2442,481],{"class":443},[429,2444,2445],{"class":456},"10",[429,2447,2448],{"class":443},"):\n",[429,2450,2451,2453,2455],{"class":431,"line":460},[429,2452,1159],{"class":456},[429,2454,2387],{"class":435},[429,2456,2390],{"class":443},[429,2458,2459,2461,2463,2465,2467],{"class":431,"line":475},[429,2460,2080],{"class":456},[429,2462,481],{"class":443},[429,2464,1247],{"class":456},[429,2466,2409],{"class":443},[429,2468,2412],{"class":524},[402,2470,2471],{},"Первый пример использует while, который продолжает работать пока i \u003C 10.\nВторой использует for и выполняет итерацию от 0 до 9 с помощью функции range().\nОба выполняют одно и то же: складывают числа от 0 до 9 в переменную sum, но используют разные способы выполнения итераций.",[406,2473,2475,2476],{"id":2474},"функция-range","Функция ",[426,2477,2478],{},"range",[402,2480,2481],{},"Функция range в Python является встроенной функцией, которая создает последовательность чисел внутри определенного диапазона.\nПодобные функции, которые создают, еще говорят \"генерируют\"(называют генераторными функциями), можно использовать в цикле for для контроля количества итераций.",[402,2483,2484],{},"У range есть несколько вариантов использования:",[701,2486,2487,2490,2493],{},[704,2488,2489],{},"range(stop) создает последовательность от 0 до stop - 1;",[704,2491,2492],{},"range(start, stop) создает последовательность от start до stop - 1;",[704,2494,2495],{},"range(start, stop, step) создает последовательность из чисел от start до stop - 1, с шагом step.",[402,2497,2498],{},"Пример с одним конечным значением мы рассмотрели выше. Рассмотрим другой - распечатаем на экран числа от 1 до 3:",[419,2500,2502],{"className":421,"code":2501,"language":423,"meta":424,"style":424},"for i in range(1, 4):\n    print(i)\n\n# => 1\n# => 2\n# => 3\n",[426,2503,2504,2524,2530,2534,2538,2542],{"__ignoreMap":424},[429,2505,2506,2508,2510,2512,2514,2516,2518,2520,2522],{"class":431,"line":432},[429,2507,2343],{"class":435},[429,2509,612],{"class":443},[429,2511,2437],{"class":435},[429,2513,2440],{"class":456},[429,2515,481],{"class":443},[429,2517,1057],{"class":456},[429,2519,1041],{"class":443},[429,2521,2330],{"class":456},[429,2523,2448],{"class":443},[429,2525,2526,2528],{"class":431,"line":447},[429,2527,644],{"class":456},[429,2529,625],{"class":443},[429,2531,2532],{"class":431,"line":460},[429,2533,507],{"emptyLinePlaceholder":506},[429,2535,2536],{"class":431,"line":475},[429,2537,553],{"class":524},[429,2539,2540],{"class":431,"line":491},[429,2541,558],{"class":524},[429,2543,2544],{"class":431,"line":503},[429,2545,563],{"class":524},[402,2547,2548],{},"Теперь попробуем вывести числа в обратном порядке:",[419,2550,2552],{"className":421,"code":2551,"language":423,"meta":424,"style":424},"for i in range(3, 0, -1):\n    print(i)\n\n# => 3\n# => 2\n# => 1\n",[426,2553,2554,2580,2586,2590,2594,2598],{"__ignoreMap":424},[429,2555,2556,2558,2560,2562,2564,2566,2568,2570,2572,2574,2576,2578],{"class":431,"line":432},[429,2557,2343],{"class":435},[429,2559,612],{"class":443},[429,2561,2437],{"class":435},[429,2563,2440],{"class":456},[429,2565,481],{"class":443},[429,2567,546],{"class":456},[429,2569,1041],{"class":443},[429,2571,2086],{"class":456},[429,2573,1041],{"class":443},[429,2575,1694],{"class":435},[429,2577,1057],{"class":456},[429,2579,2448],{"class":443},[429,2581,2582,2584],{"class":431,"line":447},[429,2583,644],{"class":456},[429,2585,625],{"class":443},[429,2587,2588],{"class":431,"line":460},[429,2589,507],{"emptyLinePlaceholder":506},[429,2591,2592],{"class":431,"line":475},[429,2593,563],{"class":524},[429,2595,2596],{"class":431,"line":491},[429,2597,558],{"class":524},[429,2599,2600],{"class":431,"line":503},[429,2601,553],{"class":524},[402,2603,2604],{},"На примерах выше мы видим, что итерация завершается до конечного значения.",[402,2606,2607],{},"Если нужно просто повторить действие несколько раз, и переменная не нужна, то её можно опустить. Для этого имя переменной заменяют на символ _:",[419,2609,2611],{"className":421,"code":2610,"language":423,"meta":424,"style":424},"for _ in range(1, 4):\n    print('Python!')\n\n# => Python!\n# => Python!\n# => Python!\n",[426,2612,2613,2634,2645,2649,2654,2658],{"__ignoreMap":424},[429,2614,2615,2617,2620,2622,2624,2626,2628,2630,2632],{"class":431,"line":432},[429,2616,2343],{"class":435},[429,2618,2619],{"class":443}," _ ",[429,2621,2437],{"class":435},[429,2623,2440],{"class":456},[429,2625,481],{"class":443},[429,2627,1057],{"class":456},[429,2629,1041],{"class":443},[429,2631,2330],{"class":456},[429,2633,2448],{"class":443},[429,2635,2636,2638,2640,2643],{"class":431,"line":447},[429,2637,644],{"class":456},[429,2639,481],{"class":443},[429,2641,2642],{"class":484},"'Python!'",[429,2644,488],{"class":443},[429,2646,2647],{"class":431,"line":460},[429,2648,507],{"emptyLinePlaceholder":506},[429,2650,2651],{"class":431,"line":475},[429,2652,2653],{"class":524},"# => Python!\n",[429,2655,2656],{"class":431,"line":491},[429,2657,2653],{"class":524},[429,2659,2660],{"class":431,"line":503},[429,2661,2653],{"class":524},[406,2663,2665],{"id":2664},"цикл-for-и-строки","Цикл for и строки",[402,2667,2668],{},"Например, если мы хотим перебрать символы в строке, то компьютер сам может понять, когда строка заканчивается.\nДля таких ситуаций в Python ввели цикл for.\nОн сам знает, когда нужно остановиться, так как работает только с коллекциями — наборами элементов, которые нужно перебрать.\nСтрока — это коллекция, так как состоит из набора символов.\nПример:",[419,2670,2672],{"className":421,"code":2671,"language":423,"meta":424,"style":424},"text = 'code'\nfor symbol in text:\n    print(symbol)\n\n# => c\n# => o\n# => d\n# => e\n",[426,2673,2674,2684,2696,2703,2707,2712,2717,2722],{"__ignoreMap":424},[429,2675,2676,2679,2681],{"class":431,"line":432},[429,2677,2678],{"class":443},"text ",[429,2680,453],{"class":435},[429,2682,2683],{"class":484}," 'code'\n",[429,2685,2686,2688,2691,2693],{"class":431,"line":447},[429,2687,2343],{"class":435},[429,2689,2690],{"class":443}," symbol ",[429,2692,2437],{"class":435},[429,2694,2695],{"class":443}," text:\n",[429,2697,2698,2700],{"class":431,"line":460},[429,2699,644],{"class":456},[429,2701,2702],{"class":443},"(symbol)\n",[429,2704,2705],{"class":431,"line":475},[429,2706,507],{"emptyLinePlaceholder":506},[429,2708,2709],{"class":431,"line":491},[429,2710,2711],{"class":524},"# => c\n",[429,2713,2714],{"class":431,"line":503},[429,2715,2716],{"class":524},"# => o\n",[429,2718,2719],{"class":431,"line":510},[429,2720,2721],{"class":524},"# => d\n",[429,2723,2724],{"class":431,"line":521},[429,2725,2726],{"class":524},"# => e\n",[402,2728,2729],{},"В коде выше for проходит по каждому символу в строке, записывает его в переменную symbol и вызывает внутренний блок кода, где эта переменная используется.\nИмя этой переменной может быть любым. Общая структура цикла for выглядит так: for \u003Cпеременная> in \u003Cколлекция>.\nПосмотрим, как реализовать функцию переворота строки через цикл for:",[419,2731,2733],{"className":421,"code":2732,"language":423,"meta":424,"style":424},"def reverse_string(text):\n    # Начальное значение\n    result = ''\n    # char - переменная, в которую записывается текущий символ\n    for char in text:\n        # Соединяем в обратном порядке\n        result = char + result\n    # Цикл заканчивается, когда пройдена вся строка\n    return result\n\n\nresult = reverse_string('go!')\nprint(result) # => !og\n",[426,2734,2735,2744,2749,2757,2762,2774,2779,2791,2796,2802,2806,2810,2824],{"__ignoreMap":424},[429,2736,2737,2739,2741],{"class":431,"line":432},[429,2738,436],{"class":435},[429,2740,1676],{"class":439},[429,2742,2743],{"class":443},"(text):\n",[429,2745,2746],{"class":431,"line":447},[429,2747,2748],{"class":524},"    # Начальное значение\n",[429,2750,2751,2753,2755],{"class":431,"line":460},[429,2752,1377],{"class":443},[429,2754,453],{"class":435},[429,2756,1382],{"class":484},[429,2758,2759],{"class":431,"line":475},[429,2760,2761],{"class":524},"    # char - переменная, в которую записывается текущий символ\n",[429,2763,2764,2767,2770,2772],{"class":431,"line":491},[429,2765,2766],{"class":435},"    for",[429,2768,2769],{"class":443}," char ",[429,2771,2437],{"class":435},[429,2773,2695],{"class":443},[429,2775,2776],{"class":431,"line":503},[429,2777,2778],{"class":524},"        # Соединяем в обратном порядке\n",[429,2780,2781,2783,2785,2787,2789],{"class":431,"line":510},[429,2782,1415],{"class":443},[429,2784,453],{"class":435},[429,2786,2769],{"class":443},[429,2788,637],{"class":435},[429,2790,1448],{"class":443},[429,2792,2793],{"class":431,"line":521},[429,2794,2795],{"class":524},"    # Цикл заканчивается, когда пройдена вся строка\n",[429,2797,2798,2800],{"class":431,"line":528},[429,2799,1226],{"class":435},[429,2801,1448],{"class":443},[429,2803,2804],{"class":431,"line":654},[429,2805,507],{"emptyLinePlaceholder":506},[429,2807,2808],{"class":431,"line":659},[429,2809,507],{"emptyLinePlaceholder":506},[429,2811,2812,2814,2816,2819,2822],{"class":431,"line":668},[429,2813,1466],{"class":443},[429,2815,453],{"class":435},[429,2817,2818],{"class":443}," reverse_string(",[429,2820,2821],{"class":484},"'go!'",[429,2823,488],{"class":443},[429,2825,2826,2828,2831],{"class":431,"line":673},[429,2827,2080],{"class":456},[429,2829,2830],{"class":443},"(result) ",[429,2832,2833],{"class":524},"# => !og\n",[402,2835,2836],{},"Теперь посчитаем количество упоминаний символа в строке без учета регистра:",[419,2838,2840],{"className":421,"code":2839,"language":423,"meta":424,"style":424},"# text - произвольный текст\n# char - символ, который нужно учитывать\ndef chars_count(text, char):\n    # Так как ищем сумму, то начальное значение — 0\n    result = 0\n    for current_char in text:\n        # Приводим все к нижнему регистру,\n        # чтобы не зависеть от текущего регистра\n        if current_char.lower() == char.lower():\n            result += 1\n    return result\n\n\nchars_count('python!', 'o')  # 1\nchars_count('pYthon!', 'y')  # 1\nchars_count('pYthon!', 'Y')  # 1\nchars_count('python!', 'a')  # 0\n",[426,2841,2842,2847,2852,2862,2867,2875,2886,2891,2896,2908,2917,2923,2927,2931,2948,2963,2978],{"__ignoreMap":424},[429,2843,2844],{"class":431,"line":432},[429,2845,2846],{"class":524},"# text - произвольный текст\n",[429,2848,2849],{"class":431,"line":447},[429,2850,2851],{"class":524},"# char - символ, который нужно учитывать\n",[429,2853,2854,2856,2859],{"class":431,"line":460},[429,2855,436],{"class":435},[429,2857,2858],{"class":439}," chars_count",[429,2860,2861],{"class":443},"(text, char):\n",[429,2863,2864],{"class":431,"line":475},[429,2865,2866],{"class":524},"    # Так как ищем сумму, то начальное значение — 0\n",[429,2868,2869,2871,2873],{"class":431,"line":491},[429,2870,1377],{"class":443},[429,2872,453],{"class":435},[429,2874,457],{"class":456},[429,2876,2877,2879,2882,2884],{"class":431,"line":503},[429,2878,2766],{"class":435},[429,2880,2881],{"class":443}," current_char ",[429,2883,2437],{"class":435},[429,2885,2695],{"class":443},[429,2887,2888],{"class":431,"line":510},[429,2889,2890],{"class":524},"        # Приводим все к нижнему регистру,\n",[429,2892,2893],{"class":431,"line":521},[429,2894,2895],{"class":524},"        # чтобы не зависеть от текущего регистра\n",[429,2897,2898,2900,2903,2905],{"class":431,"line":528},[429,2899,1970],{"class":435},[429,2901,2902],{"class":443}," current_char.lower() ",[429,2904,1976],{"class":435},[429,2906,2907],{"class":443}," char.lower():\n",[429,2909,2910,2913,2915],{"class":431,"line":654},[429,2911,2912],{"class":443},"            result ",[429,2914,497],{"class":435},[429,2916,500],{"class":456},[429,2918,2919,2921],{"class":431,"line":659},[429,2920,1226],{"class":435},[429,2922,1448],{"class":443},[429,2924,2925],{"class":431,"line":668},[429,2926,507],{"emptyLinePlaceholder":506},[429,2928,2929],{"class":431,"line":673},[429,2930,507],{"emptyLinePlaceholder":506},[429,2932,2933,2936,2939,2941,2944,2946],{"class":431,"line":678},[429,2934,2935],{"class":443},"chars_count(",[429,2937,2938],{"class":484},"'python!'",[429,2940,1041],{"class":443},[429,2942,2943],{"class":484},"'o'",[429,2945,1047],{"class":443},[429,2947,1096],{"class":524},[429,2949,2950,2952,2955,2957,2959,2961],{"class":431,"line":683},[429,2951,2935],{"class":443},[429,2953,2954],{"class":484},"'pYthon!'",[429,2956,1041],{"class":443},[429,2958,1913],{"class":484},[429,2960,1047],{"class":443},[429,2962,1096],{"class":524},[429,2964,2965,2967,2969,2971,2974,2976],{"class":431,"line":821},[429,2966,2935],{"class":443},[429,2968,2954],{"class":484},[429,2970,1041],{"class":443},[429,2972,2973],{"class":484},"'Y'",[429,2975,1047],{"class":443},[429,2977,1096],{"class":524},[429,2979,2980,2982,2984,2986,2989,2991],{"class":431,"line":827},[429,2981,2935],{"class":443},[429,2983,2938],{"class":484},[429,2985,1041],{"class":443},[429,2987,2988],{"class":484},"'a'",[429,2990,1047],{"class":443},[429,2992,1918],{"class":524},[402,2994,2995],{},"Главное преимущество for в том, что он короче и проще, когда известно сколько итераций будет.\nЕщё он понятнее и легче читается, например со строками.\nВ Python он ещё и управляет итерациями сам, что делает его удобнее в некоторых случаях.",[402,2997,2998,2999,3002,3003,3006],{},"Попробуйте сами запустить код в окне ниже с интерпретатором Python и повторите примеры из статьи чтобы самим увидеть и понять как всё это работает.\nДля этого в ячейке с кодом нажмите клавиши на клавиатуре ",[414,3000,3001],{},"Shift+Enter"," или запустите код через ",[414,3004,3005],{},"кнопку Run"," по значку ▶.",[3008,3009],"jypiter",{},[3011,3012,3013],"style",{},"html pre.shiki code .sD7c4, html code.shiki .sD7c4{--shiki-default:#D73A49}html pre.shiki code .s7eDp, html code.shiki .s7eDp{--shiki-default:#6F42C1}html pre.shiki code .sgsFI, html code.shiki .sgsFI{--shiki-default:#24292E}html pre.shiki code .sYu0t, html code.shiki .sYu0t{--shiki-default:#005CC5}html pre.shiki code .sYBdl, html code.shiki .sYBdl{--shiki-default:#032F62}html pre.shiki code .sAwPA, html code.shiki .sAwPA{--shiki-default:#6A737D}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}",{"title":424,"searchDepth":447,"depth":491,"links":3015},[3016],{"id":399,"depth":447,"text":400,"children":3017},[3018,3019,3024,3028,3032,3036],{"id":408,"depth":475,"text":409},{"id":690,"depth":460,"text":3020,"children":3021},"Цикл while",[3022,3023],{"id":879,"depth":475,"text":880},{"id":969,"depth":475,"text":970},{"id":1011,"depth":460,"text":1012,"children":3025},[3026,3027],{"id":1018,"depth":475,"text":1019},{"id":1323,"depth":475,"text":1324},{"id":1519,"depth":460,"text":1520,"children":3029},[3030,3031],{"id":1526,"depth":475,"text":1527},{"id":1649,"depth":475,"text":1650},{"id":1869,"depth":460,"text":1870,"children":3033},[3034,3035],{"id":2028,"depth":475,"text":2029},{"id":2141,"depth":475,"text":2142},{"id":2340,"depth":460,"text":3037,"children":3038},"Цикл for",[3039,3041],{"id":2474,"depth":475,"text":3040},"Функция range",{"id":2664,"depth":475,"text":2665},"2025-02-17","Создание циклов. Условия внутри тела цикла. Обход строк","md","images\u002Fblog\u002Fpython\u002Fst9\u002Fimg.png",{},32,{"title":326,"description":3043},"YHZIPaRjrxqh6QpofVgGBGXu8OOTklvouSRmkglfW4o",[3051,3053],{"title":322,"path":323,"stem":324,"description":3052,"children":-1},"Логические операции. Условные конструкции",{"title":194,"path":195,"stem":196,"description":3054,"children":-1},"Поиск ошибок в коде. Типы ошибок. Способы отладки",1780737508609]