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