[{"data":1,"prerenderedAt":4605},["ShallowReactive",2],{"navigation":3,"\u002Fblog\u002Fpython\u002Fst8":386,"\u002Fblog\u002Fpython\u002Fst8-surround":4600},[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":322,"author":388,"body":393,"date":4592,"description":4593,"extension":4594,"image":4595,"meta":4596,"minRead":4597,"navigation":567,"num":1102,"path":323,"seo":4598,"stem":324,"__hash__":4599},"python\u002Fblog\u002Fpython\u002Fst8.md",{"name":389,"avatar":390},"Штана Альберт Игоревич",{"src":391,"alt":392},"me.jpg","@ashtana",{"type":394,"value":395,"toc":4553},"minimark",[396,400,420,423,445,448,453,456,525,532,585,588,606,609,613,616,630,633,677,681,688,696,699,710,717,728,731,797,800,811,886,889,894,897,903,906,1004,1026,1051,1146,1149,1316,1319,1325,1382,1388,1435,1442,1456,1481,1484,1546,1556,1580,1583,1651,1658,1662,1665,1669,1672,1695,1698,1740,1743,1766,1769,1791,1794,1826,1828,1843,1849,1852,1860,1863,1924,1927,1972,1976,1979,1987,1990,2099,2102,2228,2231,2253,2257,2260,2288,2291,2318,2323,2364,2368,2371,2395,2398,2421,2424,2438,2441,2473,2477,2480,2487,2490,2587,2600,2607,2610,2724,2739,2819,2822,2829,2832,2983,2986,2994,2997,3137,3143,3154,3159,3163,3166,3209,3212,3246,3260,3335,3338,3342,3345,3412,3415,3521,3524,3620,3623,3627,3630,3636,3641,3712,3715,3792,3795,3807,3814,3863,3867,3870,3876,3988,3993,4053,4056,4060,4063,4228,4233,4236,4380,4384,4387,4532,4535,4546,4549],[397,398,322],"h2",{"id":399},"логика",[401,402,403,404,408,409,412,413,408,416,419],"p",{},"Кроме арифметических операций в математике есть операции сравнения, например, 6 > 2 или 5 \u003C 10. Они есть и в программировании.\nДопустим, когда мы заходим на сайт, введенные логин и пароль сравниваются с теми, какие есть в базе.\nЕсли они есть, нас пускают внутрь — аутентифицируют.\nЯзыки программирования адаптировали все математические операции сравнения в неизменном виде, кроме операторов равенства и неравенства.\nВ математике для этого используется обычное равно =, но в программировании такое встречается редко.\nВо многих языках символ ",[405,406,407],"strong",{},"="," ",[405,410,411],{},"используется, чтобы присвоить переменным значения",". Поэтому в Python ",[405,414,415],{},"сравнивают с помощью",[405,417,418],{},"==",".",[401,421,422],{},"Список операций сравнения:",[424,425,426,430,433,436,439,442],"ul",{},[427,428,429],"li",{},"\u003C — меньше",[427,431,432],{},"\u003C= — меньше или равно",[427,434,435],{},"> — больше",[427,437,438],{},">= — больше или равно",[427,440,441],{},"== — равно",[427,443,444],{},"!= — не равно",[401,446,447],{},"Эти операции применяются не только к числам.\nНапример, с помощью оператора равенства можно сравнить строки: password == text — это сравнение идентичности строк, которые записаны в разных переменных.",[449,450,452],"h4",{"id":451},"логический-тип","Логический тип",[401,454,455],{},"Логическая операция типа 6 > 3 или password == text — это выражение.\nЕго результат — специальное значение True («истина») или False («ложь»). Это тип данных — bool.",[457,458,463],"pre",{"className":459,"code":460,"language":461,"meta":462,"style":462},"language-python shiki shiki-themes github-light","result = 6 > 3\nprint(result)  # => True\nprint('two' != 'two')  # => False\n","python","",[464,465,466,488,501],"code",{"__ignoreMap":462},[467,468,471,475,478,482,485],"span",{"class":469,"line":470},"line",1,[467,472,474],{"class":473},"sgsFI","result ",[467,476,407],{"class":477},"sD7c4",[467,479,481],{"class":480},"sYu0t"," 6",[467,483,484],{"class":477}," >",[467,486,487],{"class":480}," 3\n",[467,489,491,494,497],{"class":469,"line":490},2,[467,492,493],{"class":480},"print",[467,495,496],{"class":473},"(result)  ",[467,498,500],{"class":499},"sAwPA","# => True\n",[467,502,504,506,509,513,516,519,522],{"class":469,"line":503},3,[467,505,493],{"class":480},[467,507,508],{"class":473},"(",[467,510,512],{"class":511},"sYBdl","'two'",[467,514,515],{"class":477}," !=",[467,517,518],{"class":511}," 'two'",[467,520,521],{"class":473},")  ",[467,523,524],{"class":499},"# => False\n",[401,526,527,528,531],{},"Наряду со строками (str) и целыми и рациональными числами, тип ",[405,529,530],{},"bool"," (булев) — это один из примитивных типов данных в Python.\nПопробуем написать простую функцию, которая принимает на вход возраст ребенка и определяет, младенец ли он. Младенцами считаются дети до года:",[457,533,535],{"className":459,"code":534,"language":461,"meta":462,"style":462},"def is_infant(age):\n    return age \u003C 1\n\nprint(is_infant(3))  # => False\n",[464,536,537,549,563,569],{"__ignoreMap":462},[467,538,539,542,546],{"class":469,"line":470},[467,540,541],{"class":477},"def",[467,543,545],{"class":544},"s7eDp"," is_infant",[467,547,548],{"class":473},"(age):\n",[467,550,551,554,557,560],{"class":469,"line":490},[467,552,553],{"class":477},"    return",[467,555,556],{"class":473}," age ",[467,558,559],{"class":477},"\u003C",[467,561,562],{"class":480}," 1\n",[467,564,565],{"class":469,"line":503},[467,566,568],{"emptyLinePlaceholder":567},true,"\n",[467,570,572,574,577,580,583],{"class":469,"line":571},4,[467,573,493],{"class":480},[467,575,576],{"class":473},"(is_infant(",[467,578,579],{"class":480},"3",[467,581,582],{"class":473},"))  ",[467,584,524],{"class":499},[401,586,587],{},"Любая операция — это выражение, поэтому единственной строчкой функции пишем: «Вернуть то значение, которое получится в результате сравнения age \u003C 1».\nВ зависимости от того, какой аргумент пришел, сравнение будет истинным (True) или ложным (False), а return вернет этот результат.\nА теперь проверим ребенка, которому полгода(напишем вызов той же функции только с другим значением):",[457,589,591],{"className":459,"code":590,"language":461,"meta":462,"style":462},"print(is_infant(0.5))  # => True\n",[464,592,593],{"__ignoreMap":462},[467,594,595,597,599,602,604],{"class":469,"line":470},[467,596,493],{"class":480},[467,598,576],{"class":473},[467,600,601],{"class":480},"0.5",[467,603,582],{"class":473},[467,605,500],{"class":499},[401,607,608],{},"Результат операции — True. Значит, ребенок в возрасте пол года — действительно младенец.",[449,610,612],{"id":611},"предикаты","Предикаты",[401,614,615],{},"Функция is_infant() — это функция-предикат или функция-вопрос. Предикат отвечает на вопрос «да» или «нет», возвращая значение типа bool.\nПредикаты во всех языках принято именовать особым образом для простоты анализа. В Python предикаты начинаются с префикса is или has, например:",[424,617,618,621,624,627],{},[427,619,620],{},"is_infant() — «младенец ли?»",[427,622,623],{},"has_children() — «есть ли дети?»",[427,625,626],{},"is_empty() — «пустой ли?»",[427,628,629],{},"has_errors() — «есть ли ошибки?»",[401,631,632],{},"Функция считается предикатом, если она возвращает булевы значения True или False.\nНапишем еще одну функцию-предикат. Она принимает строку и проверяет, является ли она словом 'Python':",[457,634,636],{"className":459,"code":635,"language":461,"meta":462,"style":462},"def is_python(string):\n    return string.is_capitalize() == 'Python'\n\nprint(is_python('C#'))\n",[464,637,638,648,660,664],{"__ignoreMap":462},[467,639,640,642,645],{"class":469,"line":470},[467,641,541],{"class":477},[467,643,644],{"class":544}," is_python",[467,646,647],{"class":473},"(string):\n",[467,649,650,652,655,657],{"class":469,"line":490},[467,651,553],{"class":477},[467,653,654],{"class":473}," string.is_capitalize() ",[467,656,418],{"class":477},[467,658,659],{"class":511}," 'Python'\n",[467,661,662],{"class":469,"line":503},[467,663,568],{"emptyLinePlaceholder":567},[467,665,666,668,671,674],{"class":469,"line":571},[467,667,493],{"class":480},[467,669,670],{"class":473},"(is_python(",[467,672,673],{"class":511},"'C#'",[467,675,676],{"class":473},"))\n",[449,678,680],{"id":679},"комбинирование-операций-и-функций","Комбинирование операций и функций",[401,682,683,687],{},[684,685,686],"em",{},"Логические операции"," — это выражения, значит, их можно комбинировать с другими выражениями.\nНапример, мы хотим проверить четность числа — кратность двум.\nВ программировании используют такой подход — проверяют остаток от деления на два:",[424,689,690,693],{},[427,691,692],{},"если остаток 0 — число четное",[427,694,695],{},"если остаток не 0 — число нечетное",[401,697,698],{},"Остаток от деления — простая, но важная концепция в арифметике, алгебре, в теории чисел и криптографии.\nНужно разделить число на несколько равных групп, и если в конце что-то останется — это остаток от деления.\nДелим конфеты поровну между людьми:",[424,700,701,704,707],{},[427,702,703],{},"7 конфет, 2 человека: 2 x 3 + остаток 1 — 7 не кратно 2",[427,705,706],{},"21 конфету, 3 человека: 3 x 7 + остаток 0 — 21 кратно 3",[427,708,709],{},"19 конфет, 5 человек: 5 x 3 + остаток 4 — 19 не кратно 5",[401,711,712,713,716],{},"Оператор ",[405,714,715],{},"%"," вычисляет остаток от деления:",[424,718,719,722,725],{},[427,720,721],{},"7 % 2 → 1",[427,723,724],{},"21 % 3 → 0",[427,726,727],{},"19 % 5 → 4",[401,729,730],{},"Скомбинируем в одном выражении логический оператор «проверка равенства» == и арифметический оператор % и напишем функцию проверки четности:",[457,732,734],{"className":459,"code":733,"language":461,"meta":462,"style":462},"def is_even(number):\n    return number % 2 == 0\n\nprint(is_even(8))  # => True\nprint(is_even(5))   # => False\n",[464,735,736,746,764,768,782],{"__ignoreMap":462},[467,737,738,740,743],{"class":469,"line":470},[467,739,541],{"class":477},[467,741,742],{"class":544}," is_even",[467,744,745],{"class":473},"(number):\n",[467,747,748,750,753,755,758,761],{"class":469,"line":490},[467,749,553],{"class":477},[467,751,752],{"class":473}," number ",[467,754,715],{"class":477},[467,756,757],{"class":480}," 2",[467,759,760],{"class":477}," ==",[467,762,763],{"class":480}," 0\n",[467,765,766],{"class":469,"line":503},[467,767,568],{"emptyLinePlaceholder":567},[467,769,770,772,775,778,780],{"class":469,"line":571},[467,771,493],{"class":480},[467,773,774],{"class":473},"(is_even(",[467,776,777],{"class":480},"8",[467,779,582],{"class":473},[467,781,500],{"class":499},[467,783,785,787,789,792,795],{"class":469,"line":784},5,[467,786,493],{"class":480},[467,788,774],{"class":473},[467,790,791],{"class":480},"5",[467,793,794],{"class":473},"))   ",[467,796,524],{"class":499},[401,798,799],{},"Приоритет арифметических операций выше логических.\nЗначит, сначала вычисляется арифметическое выражение number % 2, а затем результат сравнивается с нулем и возвращается результат проверки равенства.\nТеперь напишем функцию, которая принимает строку и проверяет, начинается ли эта строка с латинской буквы A.\nАлгоритм:",[424,801,802,805,808],{},[427,803,804],{},"Получить и записать в переменную первый символ из строки-аргумента;",[427,806,807],{},"Сравнить, равен ли символ латинской букве A;",[427,809,810],{},"Вернуть результат.",[457,812,814],{"className":459,"code":813,"language":461,"meta":462,"style":462},"def is_first_letter_an_a(string):\n    first_letter = string[0]\n    return first_letter == 'A'\n\nprint(is_first_letter_an_a('Orange'))  # => False\nprint(is_first_letter_an_a('Apple'))   # => True- \n",[464,815,816,825,841,853,857,871],{"__ignoreMap":462},[467,817,818,820,823],{"class":469,"line":470},[467,819,541],{"class":477},[467,821,822],{"class":544}," is_first_letter_an_a",[467,824,647],{"class":473},[467,826,827,830,832,835,838],{"class":469,"line":490},[467,828,829],{"class":473},"    first_letter ",[467,831,407],{"class":477},[467,833,834],{"class":473}," string[",[467,836,837],{"class":480},"0",[467,839,840],{"class":473},"]\n",[467,842,843,845,848,850],{"class":469,"line":503},[467,844,553],{"class":477},[467,846,847],{"class":473}," first_letter ",[467,849,418],{"class":477},[467,851,852],{"class":511}," 'A'\n",[467,854,855],{"class":469,"line":571},[467,856,568],{"emptyLinePlaceholder":567},[467,858,859,861,864,867,869],{"class":469,"line":784},[467,860,493],{"class":480},[467,862,863],{"class":473},"(is_first_letter_an_a(",[467,865,866],{"class":511},"'Orange'",[467,868,582],{"class":473},[467,870,524],{"class":499},[467,872,874,876,878,881,883],{"class":469,"line":873},6,[467,875,493],{"class":480},[467,877,863],{"class":473},[467,879,880],{"class":511},"'Apple'",[467,882,794],{"class":473},[467,884,885],{"class":499},"# => True-\n",[401,887,888],{},"Чтобы было понятно, что тут происходит, попробуйте проговорить происходящее аналогично тому, как мы расшифровывали процесс в примере с is_even().\nТеперь вы знаете, что операции сравнения применяются в программировании наравне с арифметическими.\nНо помните, что равенство обозначается ==.",[890,891,893],"h3",{"id":892},"логические-операторы","Логические операторы",[401,895,896],{},"Логические операторы нужны, чтобы составлять сложные логические условия.\nПредположим, что сайт при регистрации требует, чтобы пароль был длиннее восьми символов и короче двадцати.\nВ математике бы написали 8 \u003C x \u003C 20, но во многих языках программирования так сделать нельзя.\nПопробуем написать два отдельных логических выражения и соединим их специальным оператором «И»:",[898,899,900],"blockquote",{},[401,901,902],{},"Пароль длиннее 8 символов И пароль короче 20 символов",[401,904,905],{},"Напишем функцию, которая принимает пароль и говорит, соответствует ли он условиям (True) или не соответствует (False):",[457,907,909],{"className":459,"code":908,"language":461,"meta":462,"style":462},"def is_correct_password(password):\n    length = len(password)\n    return length > 8 and length \u003C 20\n\nprint(is_correct_password('qwerty'))                   # => False\nprint(is_correct_password('qwerty1234'))               # => True\nprint(is_correct_password('zxcvbnmasdfghjkqwertyui'))  # => False\n",[464,910,911,921,934,957,961,976,990],{"__ignoreMap":462},[467,912,913,915,918],{"class":469,"line":470},[467,914,541],{"class":477},[467,916,917],{"class":544}," is_correct_password",[467,919,920],{"class":473},"(password):\n",[467,922,923,926,928,931],{"class":469,"line":490},[467,924,925],{"class":473},"    length ",[467,927,407],{"class":477},[467,929,930],{"class":480}," len",[467,932,933],{"class":473},"(password)\n",[467,935,936,938,941,944,947,950,952,954],{"class":469,"line":503},[467,937,553],{"class":477},[467,939,940],{"class":473}," length ",[467,942,943],{"class":477},">",[467,945,946],{"class":480}," 8",[467,948,949],{"class":477}," and",[467,951,940],{"class":473},[467,953,559],{"class":477},[467,955,956],{"class":480}," 20\n",[467,958,959],{"class":469,"line":571},[467,960,568],{"emptyLinePlaceholder":567},[467,962,963,965,968,971,974],{"class":469,"line":784},[467,964,493],{"class":480},[467,966,967],{"class":473},"(is_correct_password(",[467,969,970],{"class":511},"'qwerty'",[467,972,973],{"class":473},"))                   ",[467,975,524],{"class":499},[467,977,978,980,982,985,988],{"class":469,"line":873},[467,979,493],{"class":480},[467,981,967],{"class":473},[467,983,984],{"class":511},"'qwerty1234'",[467,986,987],{"class":473},"))               ",[467,989,500],{"class":499},[467,991,993,995,997,1000,1002],{"class":469,"line":992},7,[467,994,493],{"class":480},[467,996,967],{"class":473},[467,998,999],{"class":511},"'zxcvbnmasdfghjkqwertyui'",[467,1001,582],{"class":473},[467,1003,524],{"class":499},[401,1005,1006,1009,1010,1013,1014,1017,1018,1021,1022,1025],{},[405,1007,1008],{},"and"," — означает «",[405,1011,1012],{},"И","». В математической логике это называют ",[684,1015,1016],{},"конъюнкцией",".\nВсе выражение считается истинным, если истинен каждый операнд — каждое из составных выражений.\nИными словами, and означает «и то, и другое». ",[684,1019,1020],{},"Приоритет этого оператора ниже, чем приоритет операторов сравнения",".\nПоэтому выражение ",[464,1023,1024],{},"length > 8 and length \u003C 20"," правильно отрабатывает без скобок.",[401,1027,1028,1029,1032,1033,1036,1037,1040,1041,1044,1045,1047,1048,1050],{},"Кроме and часто используется оператор ",[405,1030,1031],{},"or"," — «",[405,1034,1035],{},"ИЛИ","» (",[684,1038,1039],{},"дизъюнкция",").\nОн означает «или то, или другое, или оба». Выражение ",[464,1042,1043],{},"a or b"," считается истинным, если хотя бы один из операндов или одновременно все — истинные.\nВ другом случае выражение ложное. Операторы можно комбинировать в любом количестве и любой последовательности.\nЕсли в коде одновременно встречаются ",[464,1046,1008],{}," и ",[464,1049,1031],{},", то приоритет задают скобками.\nНиже пример расширенной функции, которая определяет корректность пароля:",[457,1052,1054],{"className":459,"code":1053,"language":461,"meta":462,"style":462},"import string\n\ndef has_special_chars(string):\n    # Проверяет, есть ли специальные символы в строке\n    # ...\n\ndef is_strong_password(password):\n    length = len(password)\n    # Скобки задают приоритет. Понятно, что к чему относится.\n    return (length > 8 and length \u003C 20) and has_special_chars(password)\n",[464,1055,1056,1064,1068,1077,1082,1087,1091,1100,1111,1117],{"__ignoreMap":462},[467,1057,1058,1061],{"class":469,"line":470},[467,1059,1060],{"class":477},"import",[467,1062,1063],{"class":473}," string\n",[467,1065,1066],{"class":469,"line":490},[467,1067,568],{"emptyLinePlaceholder":567},[467,1069,1070,1072,1075],{"class":469,"line":503},[467,1071,541],{"class":477},[467,1073,1074],{"class":544}," has_special_chars",[467,1076,647],{"class":473},[467,1078,1079],{"class":469,"line":571},[467,1080,1081],{"class":499},"    # Проверяет, есть ли специальные символы в строке\n",[467,1083,1084],{"class":469,"line":784},[467,1085,1086],{"class":499},"    # ...\n",[467,1088,1089],{"class":469,"line":873},[467,1090,568],{"emptyLinePlaceholder":567},[467,1092,1093,1095,1098],{"class":469,"line":992},[467,1094,541],{"class":477},[467,1096,1097],{"class":544}," is_strong_password",[467,1099,920],{"class":473},[467,1101,1103,1105,1107,1109],{"class":469,"line":1102},8,[467,1104,925],{"class":473},[467,1106,407],{"class":477},[467,1108,930],{"class":480},[467,1110,933],{"class":473},[467,1112,1114],{"class":469,"line":1113},9,[467,1115,1116],{"class":499},"    # Скобки задают приоритет. Понятно, что к чему относится.\n",[467,1118,1120,1122,1125,1127,1129,1131,1133,1135,1138,1141,1143],{"class":469,"line":1119},10,[467,1121,553],{"class":477},[467,1123,1124],{"class":473}," (length ",[467,1126,943],{"class":477},[467,1128,946],{"class":480},[467,1130,949],{"class":477},[467,1132,940],{"class":473},[467,1134,559],{"class":477},[467,1136,1137],{"class":480}," 20",[467,1139,1140],{"class":473},") ",[467,1142,1008],{"class":477},[467,1144,1145],{"class":473}," has_special_chars(password)\n",[401,1147,1148],{},"Теперь представим, что мы хотим купить квартиру, которая удовлетворяет таким условиям: площадь от 100 квадратных метров\nи больше на любой улице ИЛИ площадь от 80 квадратных метров и больше, но на центральной улице Main Street.\nНапишем функцию, которая проверит квартиру. Она принимает два аргумента: площадь — число и название улицы — строку:",[457,1150,1152],{"className":459,"code":1151,"language":461,"meta":462,"style":462},"def is_good_apartment(area, street):\n    return area >= 100 or (area >= 80 and street == 'Main Street')\n\nprint(is_good_apartment(91, 'Queens Street'))  # => False\nprint(is_good_apartment(78, 'Queens Street'))  # => False\nprint(is_good_apartment(70, 'Main Street'))    # => False\n\nprint(is_good_apartment(120, 'Queens Street'))  # => True\nprint(is_good_apartment(120, 'Main Street'))    # => True\nprint(is_good_apartment(80, 'Main Street'))     # => True\n",[464,1153,1154,1164,1201,1205,1225,1242,1261,1265,1282,1298],{"__ignoreMap":462},[467,1155,1156,1158,1161],{"class":469,"line":470},[467,1157,541],{"class":477},[467,1159,1160],{"class":544}," is_good_apartment",[467,1162,1163],{"class":473},"(area, street):\n",[467,1165,1166,1168,1171,1174,1177,1180,1183,1185,1188,1190,1193,1195,1198],{"class":469,"line":490},[467,1167,553],{"class":477},[467,1169,1170],{"class":473}," area ",[467,1172,1173],{"class":477},">=",[467,1175,1176],{"class":480}," 100",[467,1178,1179],{"class":477}," or",[467,1181,1182],{"class":473}," (area ",[467,1184,1173],{"class":477},[467,1186,1187],{"class":480}," 80",[467,1189,949],{"class":477},[467,1191,1192],{"class":473}," street ",[467,1194,418],{"class":477},[467,1196,1197],{"class":511}," 'Main Street'",[467,1199,1200],{"class":473},")\n",[467,1202,1203],{"class":469,"line":503},[467,1204,568],{"emptyLinePlaceholder":567},[467,1206,1207,1209,1212,1215,1218,1221,1223],{"class":469,"line":571},[467,1208,493],{"class":480},[467,1210,1211],{"class":473},"(is_good_apartment(",[467,1213,1214],{"class":480},"91",[467,1216,1217],{"class":473},", ",[467,1219,1220],{"class":511},"'Queens Street'",[467,1222,582],{"class":473},[467,1224,524],{"class":499},[467,1226,1227,1229,1231,1234,1236,1238,1240],{"class":469,"line":784},[467,1228,493],{"class":480},[467,1230,1211],{"class":473},[467,1232,1233],{"class":480},"78",[467,1235,1217],{"class":473},[467,1237,1220],{"class":511},[467,1239,582],{"class":473},[467,1241,524],{"class":499},[467,1243,1244,1246,1248,1251,1253,1256,1259],{"class":469,"line":873},[467,1245,493],{"class":480},[467,1247,1211],{"class":473},[467,1249,1250],{"class":480},"70",[467,1252,1217],{"class":473},[467,1254,1255],{"class":511},"'Main Street'",[467,1257,1258],{"class":473},"))    ",[467,1260,524],{"class":499},[467,1262,1263],{"class":469,"line":992},[467,1264,568],{"emptyLinePlaceholder":567},[467,1266,1267,1269,1271,1274,1276,1278,1280],{"class":469,"line":1102},[467,1268,493],{"class":480},[467,1270,1211],{"class":473},[467,1272,1273],{"class":480},"120",[467,1275,1217],{"class":473},[467,1277,1220],{"class":511},[467,1279,582],{"class":473},[467,1281,500],{"class":499},[467,1283,1284,1286,1288,1290,1292,1294,1296],{"class":469,"line":1113},[467,1285,493],{"class":480},[467,1287,1211],{"class":473},[467,1289,1273],{"class":480},[467,1291,1217],{"class":473},[467,1293,1255],{"class":511},[467,1295,1258],{"class":473},[467,1297,500],{"class":499},[467,1299,1300,1302,1304,1307,1309,1311,1314],{"class":469,"line":1119},[467,1301,493],{"class":480},[467,1303,1211],{"class":473},[467,1305,1306],{"class":480},"80",[467,1308,1217],{"class":473},[467,1310,1255],{"class":511},[467,1312,1313],{"class":473},"))     ",[467,1315,500],{"class":499},[401,1317,1318],{},"Раздел математики, в котором изучаются логические операторы, называется булевой алгеброй.\nНиже увидите таблицы истинности — по ним можно определить, каким будет результат, если применить оператор.",[449,1320,1322,1323],{"id":1321},"и-and","И ",[464,1324,1008],{},[1326,1327,1328,1344],"table",{},[1329,1330,1331],"thead",{},[1332,1333,1334,1338,1341],"tr",{},[1335,1336,1337],"th",{},"A",[1335,1339,1340],{},"B",[1335,1342,1343],{},"A and B",[1345,1346,1347,1357,1366,1374],"tbody",{},[1332,1348,1349,1353,1355],{},[1350,1351,1352],"td",{},"True",[1350,1354,1352],{},[1350,1356,1352],{},[1332,1358,1359,1361,1364],{},[1350,1360,1352],{},[1350,1362,1363],{},"False",[1350,1365,1363],{},[1332,1367,1368,1370,1372],{},[1350,1369,1363],{},[1350,1371,1352],{},[1350,1373,1363],{},[1332,1375,1376,1378,1380],{},[1350,1377,1363],{},[1350,1379,1363],{},[1350,1381,1363],{},[449,1383,1385,1386],{"id":1384},"или-or","ИЛИ ",[464,1387,1031],{},[1326,1389,1390,1401],{},[1329,1391,1392],{},[1332,1393,1394,1396,1398],{},[1335,1395,1337],{},[1335,1397,1340],{},[1335,1399,1400],{},"A or B",[1345,1402,1403,1411,1419,1427],{},[1332,1404,1405,1407,1409],{},[1350,1406,1352],{},[1350,1408,1352],{},[1350,1410,1352],{},[1332,1412,1413,1415,1417],{},[1350,1414,1352],{},[1350,1416,1363],{},[1350,1418,1352],{},[1332,1420,1421,1423,1425],{},[1350,1422,1363],{},[1350,1424,1352],{},[1350,1426,1352],{},[1332,1428,1429,1431,1433],{},[1350,1430,1363],{},[1350,1432,1363],{},[1350,1434,1363],{},[449,1436,1438,1439],{"id":1437},"отрицание-not","Отрицание ",[464,1440,1441],{},"not",[401,1443,1444,1445,1448,1449,1451,1452,1455],{},"Наряду с логическими операторами И и ИЛИ, часто используется операция «",[684,1446,1447],{},"инверсия","».\nОна меняет логическое значение на противоположное.\nВ программировании отрицанию соответствует унарный оператор ",[464,1450,1441],{}," или ",[464,1453,1454],{},"!"," знак:",[457,1457,1459],{"className":459,"code":1458,"language":461,"meta":462,"style":462},"not True   # False\nnot False  # True\n",[464,1460,1461,1471],{"__ignoreMap":462},[467,1462,1463,1465,1468],{"class":469,"line":470},[467,1464,1441],{"class":477},[467,1466,1467],{"class":480}," True",[467,1469,1470],{"class":499},"   # False\n",[467,1472,1473,1475,1478],{"class":469,"line":490},[467,1474,1441],{"class":477},[467,1476,1477],{"class":480}," False",[467,1479,1480],{"class":499},"  # True\n",[401,1482,1483],{},"Например, если есть функция, которая проверяет четность числа, то с помощью её отрицания можно выполнить проверку нечетности:",[457,1485,1487],{"className":459,"code":1486,"language":461,"meta":462,"style":462},"def is_even(number):\n    return number % 2 == 0\n\nprint(is_even(10))      # => True\nprint(not is_even(10))  # => False\n",[464,1488,1489,1497,1511,1515,1529],{"__ignoreMap":462},[467,1490,1491,1493,1495],{"class":469,"line":470},[467,1492,541],{"class":477},[467,1494,742],{"class":544},[467,1496,745],{"class":473},[467,1498,1499,1501,1503,1505,1507,1509],{"class":469,"line":490},[467,1500,553],{"class":477},[467,1502,752],{"class":473},[467,1504,715],{"class":477},[467,1506,757],{"class":480},[467,1508,760],{"class":477},[467,1510,763],{"class":480},[467,1512,1513],{"class":469,"line":503},[467,1514,568],{"emptyLinePlaceholder":567},[467,1516,1517,1519,1521,1524,1527],{"class":469,"line":571},[467,1518,493],{"class":480},[467,1520,774],{"class":473},[467,1522,1523],{"class":480},"10",[467,1525,1526],{"class":473},"))      ",[467,1528,500],{"class":499},[467,1530,1531,1533,1535,1537,1540,1542,1544],{"class":469,"line":784},[467,1532,493],{"class":480},[467,1534,508],{"class":473},[467,1536,1441],{"class":477},[467,1538,1539],{"class":473}," is_even(",[467,1541,1523],{"class":480},[467,1543,582],{"class":473},[467,1545,524],{"class":499},[401,1547,1548,1549,1551,1552,1555],{},"В примере выше мы добавили ",[464,1550,1441],{}," слева от вызова функции и получили обратное действие.\nОтрицание — инструмент, с помощью которого можно выражать задуманные правила в коде и не писать новые функции.\nЕсли написать ",[464,1553,1554],{},"not not is_even(10)",", то код сработает даже в таком случае:",[457,1557,1559],{"className":459,"code":1558,"language":461,"meta":462,"style":462},"print(not not is_even(10))  # => True\n",[464,1560,1561],{"__ignoreMap":462},[467,1562,1563,1565,1567,1569,1572,1574,1576,1578],{"class":469,"line":470},[467,1564,493],{"class":480},[467,1566,508],{"class":473},[467,1568,1441],{"class":477},[467,1570,1571],{"class":477}," not",[467,1573,1539],{"class":473},[467,1575,1523],{"class":480},[467,1577,582],{"class":473},[467,1579,500],{"class":499},[401,1581,1582],{},"В логике двойное отрицание — это отсутствие отрицания:",[457,1584,1586],{"className":459,"code":1585,"language":461,"meta":462,"style":462},"not not True   # True\nnot not False  # False\n\nprint(not not is_even(10))  # => True\nprint(not not is_even(11))  # => False\n",[464,1587,1588,1599,1610,1614,1632],{"__ignoreMap":462},[467,1589,1590,1592,1594,1596],{"class":469,"line":470},[467,1591,1441],{"class":477},[467,1593,1571],{"class":477},[467,1595,1467],{"class":480},[467,1597,1598],{"class":499},"   # True\n",[467,1600,1601,1603,1605,1607],{"class":469,"line":490},[467,1602,1441],{"class":477},[467,1604,1571],{"class":477},[467,1606,1477],{"class":480},[467,1608,1609],{"class":499},"  # False\n",[467,1611,1612],{"class":469,"line":503},[467,1613,568],{"emptyLinePlaceholder":567},[467,1615,1616,1618,1620,1622,1624,1626,1628,1630],{"class":469,"line":571},[467,1617,493],{"class":480},[467,1619,508],{"class":473},[467,1621,1441],{"class":477},[467,1623,1571],{"class":477},[467,1625,1539],{"class":473},[467,1627,1523],{"class":480},[467,1629,582],{"class":473},[467,1631,500],{"class":499},[467,1633,1634,1636,1638,1640,1642,1644,1647,1649],{"class":469,"line":784},[467,1635,493],{"class":480},[467,1637,508],{"class":473},[467,1639,1441],{"class":477},[467,1641,1571],{"class":477},[467,1643,1539],{"class":473},[467,1645,1646],{"class":480},"11",[467,1648,582],{"class":473},[467,1650,524],{"class":499},[401,1652,1653,1654],{},"Итак, с помощью логических операторов можно задавать составные условия из двух и более логических выражений.\nБолее, подробнее по алгебру логики можно почитать по ссылкам: ",[1655,1656,1657],"a",{"href":380},"Законы алгебры логики",[890,1659,1661],{"id":1660},"результаты-логических-операций","Результаты логических операций",[401,1663,1664],{},"Посмотрим на правила преобразования и составные выражения с двойным отрицанием.",[449,1666,1668],{"id":1667},"правила-преобразования","Правила преобразования",[401,1670,1671],{},"Посмотрите на пример:",[457,1673,1675],{"className":459,"code":1674,"language":461,"meta":462,"style":462},"print(0 or 1)  ## 1\n",[464,1676,1677],{"__ignoreMap":462},[467,1678,1679,1681,1683,1685,1687,1690,1692],{"class":469,"line":470},[467,1680,493],{"class":480},[467,1682,508],{"class":473},[467,1684,837],{"class":480},[467,1686,1179],{"class":477},[467,1688,1689],{"class":480}," 1",[467,1691,521],{"class":473},[467,1693,1694],{"class":499},"## 1\n",[401,1696,1697],{},"В данном случае число 0 эквивалентно False, а число 1 эквивалентно True.\nТаким образом, оператор ИЛИ вернет 1, так как это первый аргумент, который может быть преобразован в True.\nВозьмем пример посложнее:",[457,1699,1701],{"className":459,"code":1700,"language":461,"meta":462,"style":462},"print(0 or False or '' or [] or 42 or \"Hello\")  ## 42\n",[464,1702,1703],{"__ignoreMap":462},[467,1704,1705,1707,1709,1711,1713,1715,1717,1720,1722,1725,1727,1730,1732,1735,1737],{"class":469,"line":470},[467,1706,493],{"class":480},[467,1708,508],{"class":473},[467,1710,837],{"class":480},[467,1712,1179],{"class":477},[467,1714,1477],{"class":480},[467,1716,1179],{"class":477},[467,1718,1719],{"class":511}," ''",[467,1721,1179],{"class":477},[467,1723,1724],{"class":473}," [] ",[467,1726,1031],{"class":477},[467,1728,1729],{"class":480}," 42",[467,1731,1179],{"class":477},[467,1733,1734],{"class":511}," \"Hello\"",[467,1736,521],{"class":473},[467,1738,1739],{"class":499},"## 42\n",[401,1741,1742],{},"В данном случае:",[424,1744,1745,1748,1751,1754,1760,1763],{},[427,1746,1747],{},"Число 0 эквивалентно False",[427,1749,1750],{},"Значение False уже является False",[427,1752,1753],{},"Пустая строка ('') эквивалентна False",[427,1755,1756,1757,1759],{},"Пустой список ",[467,1758],{}," эквивалентен False",[427,1761,1762],{},"Число 42 эквивалентно True",[427,1764,1765],{},"Строка \"Hello\" также эквивалентна True",[401,1767,1768],{},"Оператор ИЛИ проверяет значения слева направо, и возвращает первый аргумент, который может быть преобразован в True.\nВ данном примере это число 42. Если ни одно значение не подходит, то вернется последнее значение в цепочке проверок.\nПример с оператором И:",[457,1770,1772],{"className":459,"code":1771,"language":461,"meta":462,"style":462},"print(0 and 1)  ## 0\n",[464,1773,1774],{"__ignoreMap":462},[467,1775,1776,1778,1780,1782,1784,1786,1788],{"class":469,"line":470},[467,1777,493],{"class":480},[467,1779,508],{"class":473},[467,1781,837],{"class":480},[467,1783,949],{"class":477},[467,1785,1689],{"class":480},[467,1787,521],{"class":473},[467,1789,1790],{"class":499},"## 0\n",[401,1792,1793],{},"Оператор И работает так, что его выполнение слева направо прерывается и возвращается результат первого аргумента, который можно преобразовать в False.\nЕсли такого аргумента нет, возвращается последний — правый.",[457,1795,1797],{"className":459,"code":1796,"language":461,"meta":462,"style":462},"print(42 and \"Hello\" and [] and 0)  ## []\n",[464,1798,1799],{"__ignoreMap":462},[467,1800,1801,1803,1805,1808,1810,1812,1814,1816,1818,1821,1823],{"class":469,"line":470},[467,1802,493],{"class":480},[467,1804,508],{"class":473},[467,1806,1807],{"class":480},"42",[467,1809,949],{"class":477},[467,1811,1734],{"class":511},[467,1813,949],{"class":477},[467,1815,1724],{"class":473},[467,1817,1008],{"class":477},[467,1819,1820],{"class":480}," 0",[467,1822,521],{"class":473},[467,1824,1825],{"class":499},"## []\n",[401,1827,1742],{},[424,1829,1830,1832,1835,1841],{},[427,1831,1762],{},[427,1833,1834],{},"Строка \"Hello\" эквивалентна True",[427,1836,1837,1838,1840],{},"Пустой список (",[467,1839],{},") эквивалентен False",[427,1842,1747],{},[401,1844,1845,1846,1848],{},"Оператор И будет проверять значения слева направо и возвращать первый аргумент, который может быть преобразован в False.\nВ данном примере это пустой список (",[467,1847],{},").",[401,1850,1851],{},"В Python есть два правила преобразования:",[424,1853,1854,1857],{},[427,1855,1856],{},"0, 0.0, '' и None приводятся к False. Эти значения называют falsy.",[427,1858,1859],{},"Все остальное приводится к True",[401,1861,1862],{},"Этими правилами пользуются в разработке, например, чтобы определить значение по умолчанию:",[457,1864,1866],{"className":459,"code":1865,"language":461,"meta":462,"style":462},"value = name or ''\n# Примеры\n234 or '' # 234\n'python' or '' # 'python'\nNone or '' # ''\n",[464,1867,1868,1883,1888,1900,1912],{"__ignoreMap":462},[467,1869,1870,1873,1875,1878,1880],{"class":469,"line":470},[467,1871,1872],{"class":473},"value ",[467,1874,407],{"class":477},[467,1876,1877],{"class":473}," name ",[467,1879,1031],{"class":477},[467,1881,1882],{"class":511}," ''\n",[467,1884,1885],{"class":469,"line":490},[467,1886,1887],{"class":499},"# Примеры\n",[467,1889,1890,1893,1895,1897],{"class":469,"line":503},[467,1891,1892],{"class":480},"234",[467,1894,1179],{"class":477},[467,1896,1719],{"class":511},[467,1898,1899],{"class":499}," # 234\n",[467,1901,1902,1905,1907,1909],{"class":469,"line":571},[467,1903,1904],{"class":511},"'python'",[467,1906,1179],{"class":477},[467,1908,1719],{"class":511},[467,1910,1911],{"class":499}," # 'python'\n",[467,1913,1914,1917,1919,1921],{"class":469,"line":784},[467,1915,1916],{"class":480},"None",[467,1918,1179],{"class":477},[467,1920,1719],{"class":511},[467,1922,1923],{"class":499}," # ''\n",[401,1925,1926],{},"Если name примет одно из falsy-значений, переменной value будет присвоена пустая строка.\nВ этом случае в последующем коде мы сможем работать с value как со строкой.\nНо здесь есть потенциальный баг.\nЕсли name содержит falsy значение, а переменной value можно присвоить значения типа 0, False, None, то код выше заработает неверно:",[457,1928,1930],{"className":459,"code":1929,"language":461,"meta":462,"style":462},"# Значение на самом деле есть,\n# но оно Falsy, поэтому не выбирается на условии OR\nFalse or '' # ''\n0 or '' # ''\nNone or '' # ''\n",[464,1931,1932,1937,1942,1952,1962],{"__ignoreMap":462},[467,1933,1934],{"class":469,"line":470},[467,1935,1936],{"class":499},"# Значение на самом деле есть,\n",[467,1938,1939],{"class":469,"line":490},[467,1940,1941],{"class":499},"# но оно Falsy, поэтому не выбирается на условии OR\n",[467,1943,1944,1946,1948,1950],{"class":469,"line":503},[467,1945,1363],{"class":480},[467,1947,1179],{"class":477},[467,1949,1719],{"class":511},[467,1951,1923],{"class":499},[467,1953,1954,1956,1958,1960],{"class":469,"line":571},[467,1955,837],{"class":480},[467,1957,1179],{"class":477},[467,1959,1719],{"class":511},[467,1961,1923],{"class":499},[467,1963,1964,1966,1968,1970],{"class":469,"line":784},[467,1965,1916],{"class":480},[467,1967,1179],{"class":477},[467,1969,1719],{"class":511},[467,1971,1923],{"class":499},[449,1973,1975],{"id":1974},"составные-выражения","Составные выражения",[401,1977,1978],{},"Если соединить логические выражения между собой, можно получить довольно интересные способы решения задач с кодом.\nДопустим, нам нужно реализовать код, в котором в переменную записывается:",[424,1980,1981,1984],{},[427,1982,1983],{},"Строка yes, если число четное",[427,1985,1986],{},"Строка no, если нечетное",[401,1988,1989],{},"Это можно сделать, если использовать знания, полученные выше:",[457,1991,1993],{"className":459,"code":1992,"language":461,"meta":462,"style":462},"# число четное\nresult = 10 % 2 == 0 and 'yes' or 'no' # 'yes'\n# или сразу печатаем на экране\nprint(10 % 2 == 0 and 'yes' or 'no') # => 'yes'\n# число нечетное\nprint(11 % 2 == 0 and 'yes' or 'no') # => 'no'\n",[464,1994,1995,2000,2031,2036,2065,2070],{"__ignoreMap":462},[467,1996,1997],{"class":469,"line":470},[467,1998,1999],{"class":499},"# число четное\n",[467,2001,2002,2004,2006,2009,2012,2014,2016,2018,2020,2023,2025,2028],{"class":469,"line":490},[467,2003,474],{"class":473},[467,2005,407],{"class":477},[467,2007,2008],{"class":480}," 10",[467,2010,2011],{"class":477}," %",[467,2013,757],{"class":480},[467,2015,760],{"class":477},[467,2017,1820],{"class":480},[467,2019,949],{"class":477},[467,2021,2022],{"class":511}," 'yes'",[467,2024,1179],{"class":477},[467,2026,2027],{"class":511}," 'no'",[467,2029,2030],{"class":499}," # 'yes'\n",[467,2032,2033],{"class":469,"line":503},[467,2034,2035],{"class":499},"# или сразу печатаем на экране\n",[467,2037,2038,2040,2042,2044,2046,2048,2050,2052,2054,2056,2058,2060,2062],{"class":469,"line":571},[467,2039,493],{"class":480},[467,2041,508],{"class":473},[467,2043,1523],{"class":480},[467,2045,2011],{"class":477},[467,2047,757],{"class":480},[467,2049,760],{"class":477},[467,2051,1820],{"class":480},[467,2053,949],{"class":477},[467,2055,2022],{"class":511},[467,2057,1179],{"class":477},[467,2059,2027],{"class":511},[467,2061,1140],{"class":473},[467,2063,2064],{"class":499},"# => 'yes'\n",[467,2066,2067],{"class":469,"line":784},[467,2068,2069],{"class":499},"# число нечетное\n",[467,2071,2072,2074,2076,2078,2080,2082,2084,2086,2088,2090,2092,2094,2096],{"class":469,"line":873},[467,2073,493],{"class":480},[467,2075,508],{"class":473},[467,2077,1646],{"class":480},[467,2079,2011],{"class":477},[467,2081,757],{"class":480},[467,2083,760],{"class":477},[467,2085,1820],{"class":480},[467,2087,949],{"class":477},[467,2089,2022],{"class":511},[467,2091,1179],{"class":477},[467,2093,2027],{"class":511},[467,2095,1140],{"class":473},[467,2097,2098],{"class":499},"# => 'no'\n",[401,2100,2101],{},"Эти выражения работают согласно порядку и приоритетам. Приоритет присваивания самый низкий, поэтому оно происходит в конце.\nПриоритет сравнения == выше, чем приоритет логических операторов and и or, поэтому сравнение происходит раньше.\nДальше код выполняется слева направо, так как приоритет and выше, чем приоритет or. Рассмотрим по шагам:",[457,2103,2105],{"className":459,"code":2104,"language":461,"meta":462,"style":462},"# Для четного\n# 1 шаг\n10 % 2 == 0 # True\n# 2 шаг\nTrue and 'yes' # Результат — 'yes'\n# 3 шаг\n'yes' or 'no' # Проверка на or выполняется, но правая часть не исполняется, так как сразу возвращается 'yes'\n\n# Для нечетного\n# 1 шаг\n11 % 2 == 0 # False\n# 2 шаг\nFalse and 'yes' # Результат — ложь, проверяем дальше\n# 3 шаг\nFalse or 'no' # Выбирается и возвращается 'no'\n",[464,2106,2107,2112,2117,2132,2137,2148,2153,2165,2169,2174,2178,2194,2199,2211,2216],{"__ignoreMap":462},[467,2108,2109],{"class":469,"line":470},[467,2110,2111],{"class":499},"# Для четного\n",[467,2113,2114],{"class":469,"line":490},[467,2115,2116],{"class":499},"# 1 шаг\n",[467,2118,2119,2121,2123,2125,2127,2129],{"class":469,"line":503},[467,2120,1523],{"class":480},[467,2122,2011],{"class":477},[467,2124,757],{"class":480},[467,2126,760],{"class":477},[467,2128,1820],{"class":480},[467,2130,2131],{"class":499}," # True\n",[467,2133,2134],{"class":469,"line":571},[467,2135,2136],{"class":499},"# 2 шаг\n",[467,2138,2139,2141,2143,2145],{"class":469,"line":784},[467,2140,1352],{"class":480},[467,2142,949],{"class":477},[467,2144,2022],{"class":511},[467,2146,2147],{"class":499}," # Результат — 'yes'\n",[467,2149,2150],{"class":469,"line":873},[467,2151,2152],{"class":499},"# 3 шаг\n",[467,2154,2155,2158,2160,2162],{"class":469,"line":992},[467,2156,2157],{"class":511},"'yes'",[467,2159,1179],{"class":477},[467,2161,2027],{"class":511},[467,2163,2164],{"class":499}," # Проверка на or выполняется, но правая часть не исполняется, так как сразу возвращается 'yes'\n",[467,2166,2167],{"class":469,"line":1102},[467,2168,568],{"emptyLinePlaceholder":567},[467,2170,2171],{"class":469,"line":1113},[467,2172,2173],{"class":499},"# Для нечетного\n",[467,2175,2176],{"class":469,"line":1119},[467,2177,2116],{"class":499},[467,2179,2181,2183,2185,2187,2189,2191],{"class":469,"line":2180},11,[467,2182,1646],{"class":480},[467,2184,2011],{"class":477},[467,2186,757],{"class":480},[467,2188,760],{"class":477},[467,2190,1820],{"class":480},[467,2192,2193],{"class":499}," # False\n",[467,2195,2197],{"class":469,"line":2196},12,[467,2198,2136],{"class":499},[467,2200,2202,2204,2206,2208],{"class":469,"line":2201},13,[467,2203,1363],{"class":480},[467,2205,949],{"class":477},[467,2207,2022],{"class":511},[467,2209,2210],{"class":499}," # Результат — ложь, проверяем дальше\n",[467,2212,2214],{"class":469,"line":2213},14,[467,2215,2152],{"class":499},[467,2217,2219,2221,2223,2225],{"class":469,"line":2218},15,[467,2220,1363],{"class":480},[467,2222,1179],{"class":477},[467,2224,2027],{"class":511},[467,2226,2227],{"class":499}," # Выбирается и возвращается 'no'\n",[401,2229,2230],{},"Такую же схему можно использовать с любым выражением в начале:",[457,2232,2234],{"className":459,"code":2233,"language":461,"meta":462,"style":462},"print(somefunc() and 'yes' or 'no')\n",[464,2235,2236],{"__ignoreMap":462},[467,2237,2238,2240,2243,2245,2247,2249,2251],{"class":469,"line":470},[467,2239,493],{"class":480},[467,2241,2242],{"class":473},"(somefunc() ",[467,2244,1008],{"class":477},[467,2246,2022],{"class":511},[467,2248,1179],{"class":477},[467,2250,2027],{"class":511},[467,2252,1200],{"class":473},[449,2254,2256],{"id":2255},"двойное-отрицание","Двойное отрицание",[401,2258,2259],{},"Вспомним, как выглядит операция отрицания:",[457,2261,2263],{"className":459,"code":2262,"language":461,"meta":462,"style":462},"answer = True\nprint(not answer)  # => False\n",[464,2264,2265,2275],{"__ignoreMap":462},[467,2266,2267,2270,2272],{"class":469,"line":470},[467,2268,2269],{"class":473},"answer ",[467,2271,407],{"class":477},[467,2273,2274],{"class":480}," True\n",[467,2276,2277,2279,2281,2283,2286],{"class":469,"line":490},[467,2278,493],{"class":480},[467,2280,508],{"class":473},[467,2282,1441],{"class":477},[467,2284,2285],{"class":473}," answer)  ",[467,2287,524],{"class":499},[401,2289,2290],{},"При двойном отрицании итоговое значение равно начальному:",[457,2292,2294],{"className":459,"code":2293,"language":461,"meta":462,"style":462},"answer = True\nprint(not not answer)  # => True\n",[464,2295,2296,2304],{"__ignoreMap":462},[467,2297,2298,2300,2302],{"class":469,"line":470},[467,2299,2269],{"class":473},[467,2301,407],{"class":477},[467,2303,2274],{"class":480},[467,2305,2306,2308,2310,2312,2314,2316],{"class":469,"line":490},[467,2307,493],{"class":480},[467,2309,508],{"class":473},[467,2311,1441],{"class":477},[467,2313,1571],{"class":477},[467,2315,2285],{"class":473},[467,2317,500],{"class":499},[401,2319,712,2320,2322],{},[464,2321,1441],{}," всегда возвращает булево значение, независимо от типа переданного аргумента, а не заменяет значение на противоположное.\nПоэтому двойное отрицание тоже вернет булево True\u002FFalse.",[457,2324,2326],{"className":459,"code":2325,"language":461,"meta":462,"style":462},"answer = 'python'\nprint(not answer) # => False\nprint(not not answer) # => True\n",[464,2327,2328,2337,2350],{"__ignoreMap":462},[467,2329,2330,2332,2334],{"class":469,"line":470},[467,2331,2269],{"class":473},[467,2333,407],{"class":477},[467,2335,2336],{"class":511}," 'python'\n",[467,2338,2339,2341,2343,2345,2348],{"class":469,"line":490},[467,2340,493],{"class":480},[467,2342,508],{"class":473},[467,2344,1441],{"class":477},[467,2346,2347],{"class":473}," answer) ",[467,2349,524],{"class":499},[467,2351,2352,2354,2356,2358,2360,2362],{"class":469,"line":503},[467,2353,493],{"class":480},[467,2355,508],{"class":473},[467,2357,1441],{"class":477},[467,2359,1571],{"class":477},[467,2361,2347],{"class":473},[467,2363,500],{"class":499},[449,2365,2367],{"id":2366},"ошибки-выбора","Ошибки выбора",[401,2369,2370],{},"Представьте, что нам нужно проверить, равно ли значение одному или другому.\nНапример, переменная value должна содержать одно из двух значений: first или second.\nНачинающие разработчики иногда записывают это выражение так:",[457,2372,2374],{"className":459,"code":2373,"language":461,"meta":462,"style":462},"value == ('first' or 'second')\n",[464,2375,2376],{"__ignoreMap":462},[467,2377,2378,2380,2382,2385,2388,2390,2393],{"class":469,"line":470},[467,2379,1872],{"class":473},[467,2381,418],{"class":477},[467,2383,2384],{"class":473}," (",[467,2386,2387],{"class":511},"'first'",[467,2389,1179],{"class":477},[467,2391,2392],{"class":511}," 'second'",[467,2394,1200],{"class":473},[401,2396,2397],{},"Однако такой код приведет к неверному результату.\nНеобходимо вспомнить приоритет выполнения операций.\nПервым делом вычисляется все, что указано в скобках — 'first' or 'second'.\nЕсли выполнить этот код, то вывод будет таким:",[457,2399,2401],{"className":459,"code":2400,"language":461,"meta":462,"style":462},">>> 'first' or 'second'\n'first'\n",[464,2402,2403,2416],{"__ignoreMap":462},[467,2404,2405,2408,2411,2413],{"class":469,"line":470},[467,2406,2407],{"class":477},">>>",[467,2409,2410],{"class":511}," 'first'",[467,2412,1179],{"class":477},[467,2414,2415],{"class":511}," 'second'\n",[467,2417,2418],{"class":469,"line":490},[467,2419,2420],{"class":511},"'first'\n",[401,2422,2423],{},"Теперь заменим исходное выражение на частично вычисленное:",[457,2425,2427],{"className":459,"code":2426,"language":461,"meta":462,"style":462},"value == 'first'\n",[464,2428,2429],{"__ignoreMap":462},[467,2430,2431,2433,2435],{"class":469,"line":470},[467,2432,1872],{"class":473},[467,2434,418],{"class":477},[467,2436,2437],{"class":511}," 'first'\n",[401,2439,2440],{},"Совсем не то, что мы ожидали. А теперь вернемся к началу и напишем проверку правильно:",[457,2442,2444],{"className":459,"code":2443,"language":461,"meta":462,"style":462},"# Скобки ставить не обязательно,\n# потому что приоритет == выше, чем приоритет or\nvalue == 'first' or value == 'second'\n",[464,2445,2446,2451,2456],{"__ignoreMap":462},[467,2447,2448],{"class":469,"line":470},[467,2449,2450],{"class":499},"# Скобки ставить не обязательно,\n",[467,2452,2453],{"class":469,"line":490},[467,2454,2455],{"class":499},"# потому что приоритет == выше, чем приоритет or\n",[467,2457,2458,2460,2462,2464,2466,2469,2471],{"class":469,"line":503},[467,2459,1872],{"class":473},[467,2461,418],{"class":477},[467,2463,2410],{"class":511},[467,2465,1179],{"class":477},[467,2467,2468],{"class":473}," value ",[467,2470,418],{"class":477},[467,2472,2415],{"class":511},[890,2474,2476],{"id":2475},"условные-конструкции","Условные конструкции",[401,2478,2479],{},"С помощью условных конструкций можно изменить поведение программы, которое будет зависеть от проверяемых условий.",[449,2481,2483,2484],{"id":2482},"если-if","Если ",[464,2485,2486],{},"if",[401,2488,2489],{},"Для примера рассмотрим функцию, которая определяет тип переданного предложения. Для начала она будет отличать повествовательные предложения от вопросительных:",[457,2491,2493],{"className":459,"code":2492,"language":461,"meta":462,"style":462},"def get_type_of_sentence(sentence):\n    last_char = sentence[-1]\n    if last_char == '?':\n        return 'question'\n    return 'normal'\n\nprint(get_type_of_sentence('Python'))   # => normal\nprint(get_type_of_sentence('Python?'))  # => question\n",[464,2494,2495,2505,2523,2539,2547,2554,2558,2573],{"__ignoreMap":462},[467,2496,2497,2499,2502],{"class":469,"line":470},[467,2498,541],{"class":477},[467,2500,2501],{"class":544}," get_type_of_sentence",[467,2503,2504],{"class":473},"(sentence):\n",[467,2506,2507,2510,2512,2515,2518,2521],{"class":469,"line":490},[467,2508,2509],{"class":473},"    last_char ",[467,2511,407],{"class":477},[467,2513,2514],{"class":473}," sentence[",[467,2516,2517],{"class":477},"-",[467,2519,2520],{"class":480},"1",[467,2522,840],{"class":473},[467,2524,2525,2528,2531,2533,2536],{"class":469,"line":503},[467,2526,2527],{"class":477},"    if",[467,2529,2530],{"class":473}," last_char ",[467,2532,418],{"class":477},[467,2534,2535],{"class":511}," '?'",[467,2537,2538],{"class":473},":\n",[467,2540,2541,2544],{"class":469,"line":571},[467,2542,2543],{"class":477},"        return",[467,2545,2546],{"class":511}," 'question'\n",[467,2548,2549,2551],{"class":469,"line":784},[467,2550,553],{"class":477},[467,2552,2553],{"class":511}," 'normal'\n",[467,2555,2556],{"class":469,"line":873},[467,2557,568],{"emptyLinePlaceholder":567},[467,2559,2560,2562,2565,2568,2570],{"class":469,"line":992},[467,2561,493],{"class":480},[467,2563,2564],{"class":473},"(get_type_of_sentence(",[467,2566,2567],{"class":511},"'Python'",[467,2569,794],{"class":473},[467,2571,2572],{"class":499},"# => normal\n",[467,2574,2575,2577,2579,2582,2584],{"class":469,"line":1102},[467,2576,493],{"class":480},[467,2578,2564],{"class":473},[467,2580,2581],{"class":511},"'Python?'",[467,2583,582],{"class":473},[467,2585,2586],{"class":499},"# => question\n",[401,2588,2589,2591,2592,2595,2596,2599],{},[405,2590,2486],{}," — конструкция языка, которая управляет порядком выполнения инструкций.\nПосле слова if ей передается выражение-предикат, и в конце ставится двоеточие.\nПосле этого идет блок кода. Он выполнится, если предикат — истина.\nЕсли предикат — ложь, то блок кода пропускается, и функция выполняется дальше.\nВ нашем случае следующая строчка кода — ",[464,2593,2594],{},"return 'normal'"," — заставит функцию вернуть строку и завершиться.\n",[464,2597,2598],{},"return"," может находиться в любом месте функции — даже внутри блока кода с условием.",[449,2601,2603,2604],{"id":2602},"иначе-else","Иначе ",[464,2605,2606],{},"else",[401,2608,2609],{},"Теперь изменим функцию из предыдущего примера так, чтобы она возвращала не просто тип предложения, а целую строку Sentence is normal или Sentence is question:",[457,2611,2613],{"className":459,"code":2612,"language":461,"meta":462,"style":462},"def get_type_of_sentence(sentence):\n    last_char = sentence[-1]\n\n    if last_char == '?':\n        sentence_type = 'question'\n    else:\n        sentence_type = 'normal'\n\n    return \"Sentence is \" + sentence_type\n\nprint(get_type_of_sentence('Python'))   # => 'Sentence is normal'\nprint(get_type_of_sentence('Python?'))  # => 'Sentence is question'\n",[464,2614,2615,2623,2637,2641,2653,2662,2669,2677,2681,2694,2698,2711],{"__ignoreMap":462},[467,2616,2617,2619,2621],{"class":469,"line":470},[467,2618,541],{"class":477},[467,2620,2501],{"class":544},[467,2622,2504],{"class":473},[467,2624,2625,2627,2629,2631,2633,2635],{"class":469,"line":490},[467,2626,2509],{"class":473},[467,2628,407],{"class":477},[467,2630,2514],{"class":473},[467,2632,2517],{"class":477},[467,2634,2520],{"class":480},[467,2636,840],{"class":473},[467,2638,2639],{"class":469,"line":503},[467,2640,568],{"emptyLinePlaceholder":567},[467,2642,2643,2645,2647,2649,2651],{"class":469,"line":571},[467,2644,2527],{"class":477},[467,2646,2530],{"class":473},[467,2648,418],{"class":477},[467,2650,2535],{"class":511},[467,2652,2538],{"class":473},[467,2654,2655,2658,2660],{"class":469,"line":784},[467,2656,2657],{"class":473},"        sentence_type ",[467,2659,407],{"class":477},[467,2661,2546],{"class":511},[467,2663,2664,2667],{"class":469,"line":873},[467,2665,2666],{"class":477},"    else",[467,2668,2538],{"class":473},[467,2670,2671,2673,2675],{"class":469,"line":992},[467,2672,2657],{"class":473},[467,2674,407],{"class":477},[467,2676,2553],{"class":511},[467,2678,2679],{"class":469,"line":1102},[467,2680,568],{"emptyLinePlaceholder":567},[467,2682,2683,2685,2688,2691],{"class":469,"line":1113},[467,2684,553],{"class":477},[467,2686,2687],{"class":511}," \"Sentence is \"",[467,2689,2690],{"class":477}," +",[467,2692,2693],{"class":473}," sentence_type\n",[467,2695,2696],{"class":469,"line":1119},[467,2697,568],{"emptyLinePlaceholder":567},[467,2699,2700,2702,2704,2706,2708],{"class":469,"line":2180},[467,2701,493],{"class":480},[467,2703,2564],{"class":473},[467,2705,2567],{"class":511},[467,2707,794],{"class":473},[467,2709,2710],{"class":499},"# => 'Sentence is normal'\n",[467,2712,2713,2715,2717,2719,2721],{"class":469,"line":2196},[467,2714,493],{"class":480},[467,2716,2564],{"class":473},[467,2718,2581],{"class":511},[467,2720,582],{"class":473},[467,2722,2723],{"class":499},"# => 'Sentence is question'\n",[401,2725,2726,2727,2729,2730,2732,2733,2735,2736,2738],{},"Мы добавили ",[464,2728,2606],{}," и новый блок. Он выполнится, если условие в ",[464,2731,2486],{}," — ложь. Еще в блок ",[464,2734,2606],{}," можно вкладывать другие условия ",[464,2737,2486],{},".\nElse переводится «иначе», «в ином случае».\nОформить конструкцию if-else можно двумя способами. С помощью отрицания можно изменить порядок блоков:",[457,2740,2742],{"className":459,"code":2741,"language":461,"meta":462,"style":462},"def get_type_of_sentence(sentence):\n    last_char = sentence[-1]\n\n    if last_char != '?':\n        sentence_type = 'normal'\n    else:\n        sentence_type = 'question'\n\n    return \"Sentence is \" + sentence_type\n",[464,2743,2744,2752,2766,2770,2783,2791,2797,2805,2809],{"__ignoreMap":462},[467,2745,2746,2748,2750],{"class":469,"line":470},[467,2747,541],{"class":477},[467,2749,2501],{"class":544},[467,2751,2504],{"class":473},[467,2753,2754,2756,2758,2760,2762,2764],{"class":469,"line":490},[467,2755,2509],{"class":473},[467,2757,407],{"class":477},[467,2759,2514],{"class":473},[467,2761,2517],{"class":477},[467,2763,2520],{"class":480},[467,2765,840],{"class":473},[467,2767,2768],{"class":469,"line":503},[467,2769,568],{"emptyLinePlaceholder":567},[467,2771,2772,2774,2776,2779,2781],{"class":469,"line":571},[467,2773,2527],{"class":477},[467,2775,2530],{"class":473},[467,2777,2778],{"class":477},"!=",[467,2780,2535],{"class":511},[467,2782,2538],{"class":473},[467,2784,2785,2787,2789],{"class":469,"line":784},[467,2786,2657],{"class":473},[467,2788,407],{"class":477},[467,2790,2553],{"class":511},[467,2792,2793,2795],{"class":469,"line":873},[467,2794,2666],{"class":477},[467,2796,2538],{"class":473},[467,2798,2799,2801,2803],{"class":469,"line":992},[467,2800,2657],{"class":473},[467,2802,407],{"class":477},[467,2804,2546],{"class":511},[467,2806,2807],{"class":469,"line":1102},[467,2808,568],{"emptyLinePlaceholder":567},[467,2810,2811,2813,2815,2817],{"class":469,"line":1113},[467,2812,553],{"class":477},[467,2814,2687],{"class":511},[467,2816,2690],{"class":477},[467,2818,2693],{"class":473},[401,2820,2821],{},"Чтобы конструкцию было легче оформлять, старайтесь выбирать проверку без отрицаний и подстраивайте содержимое блоков под нее.",[449,2823,2825,2826],{"id":2824},"конструкция-else-if-elif","Конструкция else + if = ",[464,2827,2828],{},"elif",[401,2830,2831],{},"Функция get_type_of_sentence() различает только вопросительные и повествовательные предложения. Добавим в нее поддержку восклицательных предложений:",[457,2833,2835],{"className":459,"code":2834,"language":461,"meta":462,"style":462},"def get_type_of_sentence(sentence):\n    last_char = sentence[-1]\n\n    if last_char == '?':\n        sentence_type = 'question'\n\n    if last_char == '!':\n        sentence_type = 'exclamation'\n    else:\n        sentence_type = 'normal'\n\n    return 'Sentence is ' + sentence_type\n\nprint(get_type_of_sentence('Who?'))  # => 'Sentence is normal'\nprint(get_type_of_sentence('No'))    # => 'Sentence is normal'\nprint(get_type_of_sentence('No!'))   # => 'Sentence is exclamation'\n",[464,2836,2837,2845,2859,2863,2875,2883,2887,2900,2909,2915,2923,2927,2938,2942,2955,2968],{"__ignoreMap":462},[467,2838,2839,2841,2843],{"class":469,"line":470},[467,2840,541],{"class":477},[467,2842,2501],{"class":544},[467,2844,2504],{"class":473},[467,2846,2847,2849,2851,2853,2855,2857],{"class":469,"line":490},[467,2848,2509],{"class":473},[467,2850,407],{"class":477},[467,2852,2514],{"class":473},[467,2854,2517],{"class":477},[467,2856,2520],{"class":480},[467,2858,840],{"class":473},[467,2860,2861],{"class":469,"line":503},[467,2862,568],{"emptyLinePlaceholder":567},[467,2864,2865,2867,2869,2871,2873],{"class":469,"line":571},[467,2866,2527],{"class":477},[467,2868,2530],{"class":473},[467,2870,418],{"class":477},[467,2872,2535],{"class":511},[467,2874,2538],{"class":473},[467,2876,2877,2879,2881],{"class":469,"line":784},[467,2878,2657],{"class":473},[467,2880,407],{"class":477},[467,2882,2546],{"class":511},[467,2884,2885],{"class":469,"line":873},[467,2886,568],{"emptyLinePlaceholder":567},[467,2888,2889,2891,2893,2895,2898],{"class":469,"line":992},[467,2890,2527],{"class":477},[467,2892,2530],{"class":473},[467,2894,418],{"class":477},[467,2896,2897],{"class":511}," '!'",[467,2899,2538],{"class":473},[467,2901,2902,2904,2906],{"class":469,"line":1102},[467,2903,2657],{"class":473},[467,2905,407],{"class":477},[467,2907,2908],{"class":511}," 'exclamation'\n",[467,2910,2911,2913],{"class":469,"line":1113},[467,2912,2666],{"class":477},[467,2914,2538],{"class":473},[467,2916,2917,2919,2921],{"class":469,"line":1119},[467,2918,2657],{"class":473},[467,2920,407],{"class":477},[467,2922,2553],{"class":511},[467,2924,2925],{"class":469,"line":2180},[467,2926,568],{"emptyLinePlaceholder":567},[467,2928,2929,2931,2934,2936],{"class":469,"line":2196},[467,2930,553],{"class":477},[467,2932,2933],{"class":511}," 'Sentence is '",[467,2935,2690],{"class":477},[467,2937,2693],{"class":473},[467,2939,2940],{"class":469,"line":2201},[467,2941,568],{"emptyLinePlaceholder":567},[467,2943,2944,2946,2948,2951,2953],{"class":469,"line":2213},[467,2945,493],{"class":480},[467,2947,2564],{"class":473},[467,2949,2950],{"class":511},"'Who?'",[467,2952,582],{"class":473},[467,2954,2710],{"class":499},[467,2956,2957,2959,2961,2964,2966],{"class":469,"line":2218},[467,2958,493],{"class":480},[467,2960,2564],{"class":473},[467,2962,2963],{"class":511},"'No'",[467,2965,1258],{"class":473},[467,2967,2710],{"class":499},[467,2969,2971,2973,2975,2978,2980],{"class":469,"line":2970},16,[467,2972,493],{"class":480},[467,2974,2564],{"class":473},[467,2976,2977],{"class":511},"'No!'",[467,2979,794],{"class":473},[467,2981,2982],{"class":499},"# => 'Sentence is exclamation'\n",[401,2984,2985],{},"Мы добавили проверку восклицательных предложений — exclamation.\nТехнически эта функция работает, но вопросительные предложения трактует неверно.\nЕще в ней есть проблемы с точки зрения семантики:",[424,2987,2988,2991],{},[427,2989,2990],{},"Наличие восклицательного знака проверяется в любом случае, даже если уже обнаружился вопросительный знак;",[427,2992,2993],{},"Ветка else описана для второго условия, но не для первого. Поэтому вопросительное предложение становится \"normal\";",[401,2995,2996],{},"Чтобы исправить ситуацию, воспользуемся еще одним элементом условной конструкции:",[457,2998,3000],{"className":459,"code":2999,"language":461,"meta":462,"style":462},"def get_type_of_sentence(sentence):\n    last_char = sentence[-1]\n\n    if last_char == '?':\n        sentence_type = 'question'\n    elif last_char == '!':\n        sentence_type = 'exclamation'\n    else:\n        sentence_type = 'normal'\n\n    return 'Sentence is ' + sentence_type\n\nprint(get_type_of_sentence('Who?'))  # => 'Sentence is question'\nprint(get_type_of_sentence('No'))    # => 'Sentence is normal'\nprint(get_type_of_sentence('No!'))   # => 'Sentence is exclamation'\n",[464,3001,3002,3010,3024,3028,3040,3048,3061,3069,3075,3083,3087,3097,3101,3113,3125],{"__ignoreMap":462},[467,3003,3004,3006,3008],{"class":469,"line":470},[467,3005,541],{"class":477},[467,3007,2501],{"class":544},[467,3009,2504],{"class":473},[467,3011,3012,3014,3016,3018,3020,3022],{"class":469,"line":490},[467,3013,2509],{"class":473},[467,3015,407],{"class":477},[467,3017,2514],{"class":473},[467,3019,2517],{"class":477},[467,3021,2520],{"class":480},[467,3023,840],{"class":473},[467,3025,3026],{"class":469,"line":503},[467,3027,568],{"emptyLinePlaceholder":567},[467,3029,3030,3032,3034,3036,3038],{"class":469,"line":571},[467,3031,2527],{"class":477},[467,3033,2530],{"class":473},[467,3035,418],{"class":477},[467,3037,2535],{"class":511},[467,3039,2538],{"class":473},[467,3041,3042,3044,3046],{"class":469,"line":784},[467,3043,2657],{"class":473},[467,3045,407],{"class":477},[467,3047,2546],{"class":511},[467,3049,3050,3053,3055,3057,3059],{"class":469,"line":873},[467,3051,3052],{"class":477},"    elif",[467,3054,2530],{"class":473},[467,3056,418],{"class":477},[467,3058,2897],{"class":511},[467,3060,2538],{"class":473},[467,3062,3063,3065,3067],{"class":469,"line":992},[467,3064,2657],{"class":473},[467,3066,407],{"class":477},[467,3068,2908],{"class":511},[467,3070,3071,3073],{"class":469,"line":1102},[467,3072,2666],{"class":477},[467,3074,2538],{"class":473},[467,3076,3077,3079,3081],{"class":469,"line":1113},[467,3078,2657],{"class":473},[467,3080,407],{"class":477},[467,3082,2553],{"class":511},[467,3084,3085],{"class":469,"line":1119},[467,3086,568],{"emptyLinePlaceholder":567},[467,3088,3089,3091,3093,3095],{"class":469,"line":2180},[467,3090,553],{"class":477},[467,3092,2933],{"class":511},[467,3094,2690],{"class":477},[467,3096,2693],{"class":473},[467,3098,3099],{"class":469,"line":2196},[467,3100,568],{"emptyLinePlaceholder":567},[467,3102,3103,3105,3107,3109,3111],{"class":469,"line":2201},[467,3104,493],{"class":480},[467,3106,2564],{"class":473},[467,3108,2950],{"class":511},[467,3110,582],{"class":473},[467,3112,2723],{"class":499},[467,3114,3115,3117,3119,3121,3123],{"class":469,"line":2213},[467,3116,493],{"class":480},[467,3118,2564],{"class":473},[467,3120,2963],{"class":511},[467,3122,1258],{"class":473},[467,3124,2710],{"class":499},[467,3126,3127,3129,3131,3133,3135],{"class":469,"line":2218},[467,3128,493],{"class":480},[467,3130,2564],{"class":473},[467,3132,2977],{"class":511},[467,3134,794],{"class":473},[467,3136,2982],{"class":499},[401,3138,3139,3140,3142],{},"Теперь все условия выстроились в единую конструкцию.\n",[464,3141,2828],{}," означает — «если не выполнено предыдущее условие, но выполнено текущее». Получается такая схема:",[424,3144,3145,3148,3151],{},[427,3146,3147],{},"Если последний символ — ?, то 'question'",[427,3149,3150],{},"Если последний символ — !, то 'exclamation'",[427,3152,3153],{},"Остальные варианты — 'normal'",[401,3155,3156,3157,419],{},"Выполнится только один из блоков кода, который относится ко всей конструкции ",[405,3158,2486],{},[449,3160,3162],{"id":3161},"тернарный-оператор","Тернарный оператор",[401,3164,3165],{},"Посмотрите на определение функции, которая возвращает модуль переданного числа:",[457,3167,3169],{"className":459,"code":3168,"language":461,"meta":462,"style":462},"def abs(number):\n    if number >= 0:\n        return number\n    return -number\n",[464,3170,3171,3180,3192,3199],{"__ignoreMap":462},[467,3172,3173,3175,3178],{"class":469,"line":470},[467,3174,541],{"class":477},[467,3176,3177],{"class":480}," abs",[467,3179,745],{"class":473},[467,3181,3182,3184,3186,3188,3190],{"class":469,"line":490},[467,3183,2527],{"class":477},[467,3185,752],{"class":473},[467,3187,1173],{"class":477},[467,3189,1820],{"class":480},[467,3191,2538],{"class":473},[467,3193,3194,3196],{"class":469,"line":503},[467,3195,2543],{"class":477},[467,3197,3198],{"class":473}," number\n",[467,3200,3201,3203,3206],{"class":469,"line":571},[467,3202,553],{"class":477},[467,3204,3205],{"class":477}," -",[467,3207,3208],{"class":473},"number\n",[401,3210,3211],{},"Но можно записать более лаконично.\nДля этого справа от return должно быть выражение, но if — это инструкция, а не выражение.\nВ Python есть конструкция, которая работает как if-else, но считается выражением.\nОна называется тернарный оператор — единственный оператор в Python, который требует три операнда:",[457,3213,3215],{"className":459,"code":3214,"language":461,"meta":462,"style":462},"def abs(number):\n    return number if number >= 0 else -number\n",[464,3216,3217,3225],{"__ignoreMap":462},[467,3218,3219,3221,3223],{"class":469,"line":470},[467,3220,541],{"class":477},[467,3222,3177],{"class":480},[467,3224,745],{"class":473},[467,3226,3227,3229,3231,3233,3235,3237,3239,3242,3244],{"class":469,"line":490},[467,3228,553],{"class":477},[467,3230,752],{"class":473},[467,3232,2486],{"class":477},[467,3234,752],{"class":473},[467,3236,1173],{"class":477},[467,3238,1820],{"class":480},[467,3240,3241],{"class":477}," else",[467,3243,3205],{"class":477},[467,3245,3208],{"class":473},[401,3247,3248,3249],{},"Общий паттерн выглядит так: ",[3250,3251,3252,3253],"expression",{"true":462}," if ",[3254,3255,3256,3257],"predicate",{}," else ",[3250,3258,3259],{"false":462},".\nДавайте перепишем начальный вариант get_type_of_sentence() аналогично.",[457,3261,3263],{"className":459,"code":3262,"language":461,"meta":462,"style":462},"def get_type_of_sentence(sentence):\n    last_char = sentence[-1]\n    return 'question' if last_char == '?' else 'normal'\n\nprint(get_type_of_sentence('Python'))   # => normal\nprint(get_type_of_sentence('Python?'))  # => question\n",[464,3264,3265,3273,3287,3307,3311,3323],{"__ignoreMap":462},[467,3266,3267,3269,3271],{"class":469,"line":470},[467,3268,541],{"class":477},[467,3270,2501],{"class":544},[467,3272,2504],{"class":473},[467,3274,3275,3277,3279,3281,3283,3285],{"class":469,"line":490},[467,3276,2509],{"class":473},[467,3278,407],{"class":477},[467,3280,2514],{"class":473},[467,3282,2517],{"class":477},[467,3284,2520],{"class":480},[467,3286,840],{"class":473},[467,3288,3289,3291,3294,3297,3299,3301,3303,3305],{"class":469,"line":503},[467,3290,553],{"class":477},[467,3292,3293],{"class":511}," 'question'",[467,3295,3296],{"class":477}," if",[467,3298,2530],{"class":473},[467,3300,418],{"class":477},[467,3302,2535],{"class":511},[467,3304,3241],{"class":477},[467,3306,2553],{"class":511},[467,3308,3309],{"class":469,"line":571},[467,3310,568],{"emptyLinePlaceholder":567},[467,3312,3313,3315,3317,3319,3321],{"class":469,"line":784},[467,3314,493],{"class":480},[467,3316,2564],{"class":473},[467,3318,2567],{"class":511},[467,3320,794],{"class":473},[467,3322,2572],{"class":499},[467,3324,3325,3327,3329,3331,3333],{"class":469,"line":873},[467,3326,493],{"class":480},[467,3328,2564],{"class":473},[467,3330,2581],{"class":511},[467,3332,582],{"class":473},[467,3334,2586],{"class":499},[401,3336,3337],{},"Тернарный оператор можно вкладывать в тернарный оператор. Но не нужно так делать, так как такой код тяжело читать и отлаживать.",[890,3339,3341],{"id":3340},"отступы-и-блоки","Отступы и блоки",[401,3343,3344],{},"В Python, в отличие от других языков, блоки кода принято выделять не скобками, а новой строкой с отступом.\nОтступы обычно состоят из 4 пробелов или одного символа табуляции, который нужно настроить в редакторе на использование пробелов.\nВсе строки в одном блоке должны иметь одинаковый отступ.\nУвеличение отступа означает начало нового блока, а уменьшение отступа означает конец блока.",[457,3346,3348],{"className":459,"code":3347,"language":461,"meta":462,"style":462},"if a == 42:\n    # отступ и начало блока if\n    # все строки кода с одним отступом выполняются в одном блоке\n    print('First')\n    print('Second')\n# конец отступа и выход из блока\nprint('Goodbye!')\n",[464,3349,3350,3363,3368,3373,3385,3396,3401],{"__ignoreMap":462},[467,3351,3352,3354,3357,3359,3361],{"class":469,"line":470},[467,3353,2486],{"class":477},[467,3355,3356],{"class":473}," a ",[467,3358,418],{"class":477},[467,3360,1729],{"class":480},[467,3362,2538],{"class":473},[467,3364,3365],{"class":469,"line":490},[467,3366,3367],{"class":499},"    # отступ и начало блока if\n",[467,3369,3370],{"class":469,"line":503},[467,3371,3372],{"class":499},"    # все строки кода с одним отступом выполняются в одном блоке\n",[467,3374,3375,3378,3380,3383],{"class":469,"line":571},[467,3376,3377],{"class":480},"    print",[467,3379,508],{"class":473},[467,3381,3382],{"class":511},"'First'",[467,3384,1200],{"class":473},[467,3386,3387,3389,3391,3394],{"class":469,"line":784},[467,3388,3377],{"class":480},[467,3390,508],{"class":473},[467,3392,3393],{"class":511},"'Second'",[467,3395,1200],{"class":473},[467,3397,3398],{"class":469,"line":873},[467,3399,3400],{"class":499},"# конец отступа и выход из блока\n",[467,3402,3403,3405,3407,3410],{"class":469,"line":992},[467,3404,493],{"class":480},[467,3406,508],{"class":473},[467,3408,3409],{"class":511},"'Goodbye!'",[467,3411,1200],{"class":473},[401,3413,3414],{},"На примере использования else видно, как важно не забывать отделять блоки.",[457,3416,3418],{"className":459,"code":3417,"language":461,"meta":462,"style":462},"# Неправильно\ndef check_number(number):\n    if number > 0:\n        print(\"Число положительное\")\n    if number > 10:\n        print(\"Число больше 10\")\n    else:\n        print(\"Число не положительное\")\n\ncheck_number(3)\n# => Число положительное\n# => Число не положительное\n",[464,3419,3420,3425,3434,3446,3458,3470,3481,3487,3498,3502,3511,3516],{"__ignoreMap":462},[467,3421,3422],{"class":469,"line":470},[467,3423,3424],{"class":499},"# Неправильно\n",[467,3426,3427,3429,3432],{"class":469,"line":490},[467,3428,541],{"class":477},[467,3430,3431],{"class":544}," check_number",[467,3433,745],{"class":473},[467,3435,3436,3438,3440,3442,3444],{"class":469,"line":503},[467,3437,2527],{"class":477},[467,3439,752],{"class":473},[467,3441,943],{"class":477},[467,3443,1820],{"class":480},[467,3445,2538],{"class":473},[467,3447,3448,3451,3453,3456],{"class":469,"line":571},[467,3449,3450],{"class":480},"        print",[467,3452,508],{"class":473},[467,3454,3455],{"class":511},"\"Число положительное\"",[467,3457,1200],{"class":473},[467,3459,3460,3462,3464,3466,3468],{"class":469,"line":784},[467,3461,2527],{"class":477},[467,3463,752],{"class":473},[467,3465,943],{"class":477},[467,3467,2008],{"class":480},[467,3469,2538],{"class":473},[467,3471,3472,3474,3476,3479],{"class":469,"line":873},[467,3473,3450],{"class":480},[467,3475,508],{"class":473},[467,3477,3478],{"class":511},"\"Число больше 10\"",[467,3480,1200],{"class":473},[467,3482,3483,3485],{"class":469,"line":992},[467,3484,2666],{"class":477},[467,3486,2538],{"class":473},[467,3488,3489,3491,3493,3496],{"class":469,"line":1102},[467,3490,3450],{"class":480},[467,3492,508],{"class":473},[467,3494,3495],{"class":511},"\"Число не положительное\"",[467,3497,1200],{"class":473},[467,3499,3500],{"class":469,"line":1113},[467,3501,568],{"emptyLinePlaceholder":567},[467,3503,3504,3507,3509],{"class":469,"line":1119},[467,3505,3506],{"class":473},"check_number(",[467,3508,579],{"class":480},[467,3510,1200],{"class":473},[467,3512,3513],{"class":469,"line":2180},[467,3514,3515],{"class":499},"# => Число положительное\n",[467,3517,3518],{"class":469,"line":2196},[467,3519,3520],{"class":499},"# => Число не положительное\n",[401,3522,3523],{},"В примере выше мы забыли \"вложить\" с помощью отступа второй if, потому else теперь относится к нему, а не первому if.",[457,3525,3527],{"className":459,"code":3526,"language":461,"meta":462,"style":462},"# Правильно\ndef check_number(number):\n    if number > 0:\n        print(\"Число положительное\")\n        if number > 10:\n            print(\"Число больше 10\")\n    else:\n        print(\"Число не положительное\")\n\ncheck_number(3)\n# => Число положительное\n",[464,3528,3529,3534,3542,3554,3564,3577,3588,3594,3604,3608,3616],{"__ignoreMap":462},[467,3530,3531],{"class":469,"line":470},[467,3532,3533],{"class":499},"# Правильно\n",[467,3535,3536,3538,3540],{"class":469,"line":490},[467,3537,541],{"class":477},[467,3539,3431],{"class":544},[467,3541,745],{"class":473},[467,3543,3544,3546,3548,3550,3552],{"class":469,"line":503},[467,3545,2527],{"class":477},[467,3547,752],{"class":473},[467,3549,943],{"class":477},[467,3551,1820],{"class":480},[467,3553,2538],{"class":473},[467,3555,3556,3558,3560,3562],{"class":469,"line":571},[467,3557,3450],{"class":480},[467,3559,508],{"class":473},[467,3561,3455],{"class":511},[467,3563,1200],{"class":473},[467,3565,3566,3569,3571,3573,3575],{"class":469,"line":784},[467,3567,3568],{"class":477},"        if",[467,3570,752],{"class":473},[467,3572,943],{"class":477},[467,3574,2008],{"class":480},[467,3576,2538],{"class":473},[467,3578,3579,3582,3584,3586],{"class":469,"line":873},[467,3580,3581],{"class":480},"            print",[467,3583,508],{"class":473},[467,3585,3478],{"class":511},[467,3587,1200],{"class":473},[467,3589,3590,3592],{"class":469,"line":992},[467,3591,2666],{"class":477},[467,3593,2538],{"class":473},[467,3595,3596,3598,3600,3602],{"class":469,"line":1102},[467,3597,3450],{"class":480},[467,3599,508],{"class":473},[467,3601,3495],{"class":511},[467,3603,1200],{"class":473},[467,3605,3606],{"class":469,"line":1113},[467,3607,568],{"emptyLinePlaceholder":567},[467,3609,3610,3612,3614],{"class":469,"line":1119},[467,3611,3506],{"class":473},[467,3613,579],{"class":480},[467,3615,1200],{"class":473},[467,3617,3618],{"class":469,"line":2180},[467,3619,3515],{"class":499},[401,3621,3622],{},"Теперь второй if вложен в первый, а else на одном уровне с первым и противопоставляется ему.",[890,3624,3626],{"id":3625},"оператор-match","Оператор match",[401,3628,3629],{},"Многие языки в дополнение к условной конструкции if включают в себя switch.\nС выходом версии Python 3.10 также был добавлен оператор с аналогичной функциональностью — match.",[449,3631,712,3633],{"id":3632},"оператор-match-1",[464,3634,3635],{},"match",[401,3637,712,3638,3640],{},[405,3639,3635],{}," — это специализированная версия if, которую создали для особых ситуаций.\nНапример, ее нужно использовать там, где есть цепочка if else с проверками на равенство:",[457,3642,3644],{"className":459,"code":3643,"language":461,"meta":462,"style":462},"if status == 'processing':\n    # Делаем раз\nelif status == 'paid':\n    # Делаем два\nelif status == 'new':\n    # Делаем три\nelse:\n    # Делаем четыре\n",[464,3645,3646,3660,3665,3678,3683,3696,3701,3707],{"__ignoreMap":462},[467,3647,3648,3650,3653,3655,3658],{"class":469,"line":470},[467,3649,2486],{"class":477},[467,3651,3652],{"class":473}," status ",[467,3654,418],{"class":477},[467,3656,3657],{"class":511}," 'processing'",[467,3659,2538],{"class":473},[467,3661,3662],{"class":469,"line":490},[467,3663,3664],{"class":499},"    # Делаем раз\n",[467,3666,3667,3669,3671,3673,3676],{"class":469,"line":503},[467,3668,2828],{"class":477},[467,3670,3652],{"class":473},[467,3672,418],{"class":477},[467,3674,3675],{"class":511}," 'paid'",[467,3677,2538],{"class":473},[467,3679,3680],{"class":469,"line":571},[467,3681,3682],{"class":499},"    # Делаем два\n",[467,3684,3685,3687,3689,3691,3694],{"class":469,"line":784},[467,3686,2828],{"class":477},[467,3688,3652],{"class":473},[467,3690,418],{"class":477},[467,3692,3693],{"class":511}," 'new'",[467,3695,2538],{"class":473},[467,3697,3698],{"class":469,"line":873},[467,3699,3700],{"class":499},"    # Делаем три\n",[467,3702,3703,3705],{"class":469,"line":992},[467,3704,2606],{"class":477},[467,3706,2538],{"class":473},[467,3708,3709],{"class":469,"line":1102},[467,3710,3711],{"class":499},"    # Делаем четыре\n",[401,3713,3714],{},"У этой составной проверки есть одна отличительная черта: каждая ветка здесь — это проверка значения переменной status.\nОператор match позволяет записать этот код короче и выразительнее:",[457,3716,3718],{"className":459,"code":3717,"language":461,"meta":462,"style":462},"match status:\n    case 'processing':  # status == 'processing'\n        # Делаем раз\n    case 'paid':  # status == 'paid'\n        # Делаем два\n    case 'new':  # status == 'new'\n        # Делаем три\n    case _:  # else\n        # Делаем четыре\n",[464,3719,3720,3727,3740,3745,3756,3761,3772,3777,3787],{"__ignoreMap":462},[467,3721,3722,3724],{"class":469,"line":470},[467,3723,3635],{"class":477},[467,3725,3726],{"class":473}," status:\n",[467,3728,3729,3732,3734,3737],{"class":469,"line":490},[467,3730,3731],{"class":477},"    case",[467,3733,3657],{"class":511},[467,3735,3736],{"class":473},":  ",[467,3738,3739],{"class":499},"# status == 'processing'\n",[467,3741,3742],{"class":469,"line":503},[467,3743,3744],{"class":499},"        # Делаем раз\n",[467,3746,3747,3749,3751,3753],{"class":469,"line":571},[467,3748,3731],{"class":477},[467,3750,3675],{"class":511},[467,3752,3736],{"class":473},[467,3754,3755],{"class":499},"# status == 'paid'\n",[467,3757,3758],{"class":469,"line":784},[467,3759,3760],{"class":499},"        # Делаем два\n",[467,3762,3763,3765,3767,3769],{"class":469,"line":873},[467,3764,3731],{"class":477},[467,3766,3693],{"class":511},[467,3768,3736],{"class":473},[467,3770,3771],{"class":499},"# status == 'new'\n",[467,3773,3774],{"class":469,"line":992},[467,3775,3776],{"class":499},"        # Делаем три\n",[467,3778,3779,3781,3784],{"class":469,"line":1102},[467,3780,3731],{"class":477},[467,3782,3783],{"class":473}," _:  ",[467,3785,3786],{"class":499},"# else\n",[467,3788,3789],{"class":469,"line":1113},[467,3790,3791],{"class":499},"        # Делаем четыре\n",[401,3793,3794],{},"С точки зрения количества элементов match — это сложная конструкция. Она состоит из таких элементов:",[424,3796,3797,3800],{},[427,3798,3799],{},"Внешнее описание, в которое входит ключевое слово match. Это переменная, по значениям которой match и будет выбирать поведение",[427,3801,3802,3803,3806],{},"Конструкции ",[405,3804,3805],{},"case",", внутри которых описывается поведение для разных значений рассматриваемой переменной.",[401,3808,3809,3810,3813],{},"Каждый case соответствует if в примере выше. При этом ",[405,3811,3812],{},"case _"," — это особая ситуация, которая соответствует ветке else в условных конструкциях.\nКак и else, указывать case _ необязательно. Внутри match допустим только тот синтаксис, который показан выше.\nДругими словами, там можно использовать case. А вот внутри каждого case ситуация другая.\nЗдесь можно выполнять любой произвольный код:",[457,3815,3817],{"className":459,"code":3816,"language":461,"meta":462,"style":462},"match count:\n    case 1:\n        # Делаем что-то полезное\n    case 2:\n        # Делаем что-то полезное\n    case _:\n        # Что-то делаем\n",[464,3818,3819,3826,3834,3839,3847,3851,3858],{"__ignoreMap":462},[467,3820,3821,3823],{"class":469,"line":470},[467,3822,3635],{"class":477},[467,3824,3825],{"class":473}," count:\n",[467,3827,3828,3830,3832],{"class":469,"line":490},[467,3829,3731],{"class":477},[467,3831,1689],{"class":480},[467,3833,2538],{"class":473},[467,3835,3836],{"class":469,"line":503},[467,3837,3838],{"class":499},"        # Делаем что-то полезное\n",[467,3840,3841,3843,3845],{"class":469,"line":571},[467,3842,3731],{"class":477},[467,3844,757],{"class":480},[467,3846,2538],{"class":473},[467,3848,3849],{"class":469,"line":784},[467,3850,3838],{"class":499},[467,3852,3853,3855],{"class":469,"line":873},[467,3854,3731],{"class":477},[467,3856,3857],{"class":473}," _:\n",[467,3859,3860],{"class":469,"line":992},[467,3861,3862],{"class":499},"        # Что-то делаем\n",[449,3864,3866],{"id":3865},"два-способа-вернуть-результат","Два способа вернуть результат",[401,3868,3869],{},"Иногда результат, полученный внутри case — это конец выполнения функции, которая содержит match.\nВ таком случае его нужно как-то вернуть наружу. Есть два способа для решения этой задачи:",[3871,3872,3873],"ol",{},[427,3874,3875],{},"Создать переменную перед match, заполнить ее в case и затем в конце вернуть значение этой переменной наружу:",[457,3877,3879],{"className":459,"code":3878,"language":461,"meta":462,"style":462},"def count_items(count):\n    # Объявляем переменную\n    result = ''\n\n    # Заполняем\n    match count:\n        case 1:\n            result = 'one'\n        case 2:\n            result = 'two'\n        case _:\n            result = None\n\n    # Возвращаем\n    return result \n",[464,3880,3881,3891,3896,3905,3909,3914,3921,3930,3940,3948,3957,3963,3972,3976,3981],{"__ignoreMap":462},[467,3882,3883,3885,3888],{"class":469,"line":470},[467,3884,541],{"class":477},[467,3886,3887],{"class":544}," count_items",[467,3889,3890],{"class":473},"(count):\n",[467,3892,3893],{"class":469,"line":490},[467,3894,3895],{"class":499},"    # Объявляем переменную\n",[467,3897,3898,3901,3903],{"class":469,"line":503},[467,3899,3900],{"class":473},"    result ",[467,3902,407],{"class":477},[467,3904,1882],{"class":511},[467,3906,3907],{"class":469,"line":571},[467,3908,568],{"emptyLinePlaceholder":567},[467,3910,3911],{"class":469,"line":784},[467,3912,3913],{"class":499},"    # Заполняем\n",[467,3915,3916,3919],{"class":469,"line":873},[467,3917,3918],{"class":477},"    match",[467,3920,3825],{"class":473},[467,3922,3923,3926,3928],{"class":469,"line":992},[467,3924,3925],{"class":477},"        case",[467,3927,1689],{"class":480},[467,3929,2538],{"class":473},[467,3931,3932,3935,3937],{"class":469,"line":1102},[467,3933,3934],{"class":473},"            result ",[467,3936,407],{"class":477},[467,3938,3939],{"class":511}," 'one'\n",[467,3941,3942,3944,3946],{"class":469,"line":1113},[467,3943,3925],{"class":477},[467,3945,757],{"class":480},[467,3947,2538],{"class":473},[467,3949,3950,3952,3954],{"class":469,"line":1119},[467,3951,3934],{"class":473},[467,3953,407],{"class":477},[467,3955,3956],{"class":511}," 'two'\n",[467,3958,3959,3961],{"class":469,"line":2180},[467,3960,3925],{"class":477},[467,3962,3857],{"class":473},[467,3964,3965,3967,3969],{"class":469,"line":2196},[467,3966,3934],{"class":473},[467,3968,407],{"class":477},[467,3970,3971],{"class":480}," None\n",[467,3973,3974],{"class":469,"line":2201},[467,3975,568],{"emptyLinePlaceholder":567},[467,3977,3978],{"class":469,"line":2213},[467,3979,3980],{"class":499},"    # Возвращаем\n",[467,3982,3983,3985],{"class":469,"line":2218},[467,3984,553],{"class":477},[467,3986,3987],{"class":473}," result\n",[3871,3989,3990],{"start":490},[427,3991,3992],{},"Вместо создания переменной при работе с case можно делать обычный возврат из функции:",[457,3994,3996],{"className":459,"code":3995,"language":461,"meta":462,"style":462},"def count_items(count):\n    match count:\n        case 1:\n            return 'one'\n        case 2:\n            return 'two'\n        case _:\n            return None \n",[464,3997,3998,4006,4012,4020,4027,4035,4041,4047],{"__ignoreMap":462},[467,3999,4000,4002,4004],{"class":469,"line":470},[467,4001,541],{"class":477},[467,4003,3887],{"class":544},[467,4005,3890],{"class":473},[467,4007,4008,4010],{"class":469,"line":490},[467,4009,3918],{"class":477},[467,4011,3825],{"class":473},[467,4013,4014,4016,4018],{"class":469,"line":503},[467,4015,3925],{"class":477},[467,4017,1689],{"class":480},[467,4019,2538],{"class":473},[467,4021,4022,4025],{"class":469,"line":571},[467,4023,4024],{"class":477},"            return",[467,4026,3939],{"class":511},[467,4028,4029,4031,4033],{"class":469,"line":784},[467,4030,3925],{"class":477},[467,4032,757],{"class":480},[467,4034,2538],{"class":473},[467,4036,4037,4039],{"class":469,"line":873},[467,4038,4024],{"class":477},[467,4040,3956],{"class":511},[467,4042,4043,4045],{"class":469,"line":992},[467,4044,3925],{"class":477},[467,4046,3857],{"class":473},[467,4048,4049,4051],{"class":469,"line":1102},[467,4050,4024],{"class":477},[467,4052,3971],{"class":480},[401,4054,4055],{},"Оператор match хоть и встречается в коде, но технически всегда можно обойтись без него.\nЕго главное достоинство в том, что он лучше выражает намерение программиста, когда нужно проверять конкретные значения переменной.\nХотя кода и стало физически чуть больше, читать его легче, в отличие от блоков elif.",[449,4057,4059],{"id":4058},"несколько-значений-в-case","Несколько значений в case",[401,4061,4062],{},"С помощью оператора | (или) можно объединять несколько значений в один case, чтобы выполнять одну и ту же операцию ветвления. Например:",[457,4064,4066],{"className":459,"code":4065,"language":461,"meta":462,"style":462},"def match_input(input):\n    match input:\n        case 'start' | 'begin':\n            print('Starting...')\n        case 'stop' | 'end':\n            print('Stopping...')\n        case 'pause':\n            print('Pausing...')\n        case _:\n            print('Invalid input')\n\nmatch_input('begin')  # => Starting...\nmatch_input('stop')  # => Stopping...\nmatch_input('pause')  # => Pausing...\nmatch_input('test')  # => Invalid input\n",[464,4067,4068,4078,4087,4102,4113,4127,4138,4147,4158,4164,4175,4179,4192,4204,4216],{"__ignoreMap":462},[467,4069,4070,4072,4075],{"class":469,"line":470},[467,4071,541],{"class":477},[467,4073,4074],{"class":544}," match_input",[467,4076,4077],{"class":473},"(input):\n",[467,4079,4080,4082,4085],{"class":469,"line":490},[467,4081,3918],{"class":477},[467,4083,4084],{"class":480}," input",[467,4086,2538],{"class":473},[467,4088,4089,4091,4094,4097,4100],{"class":469,"line":503},[467,4090,3925],{"class":477},[467,4092,4093],{"class":511}," 'start'",[467,4095,4096],{"class":477}," |",[467,4098,4099],{"class":511}," 'begin'",[467,4101,2538],{"class":473},[467,4103,4104,4106,4108,4111],{"class":469,"line":571},[467,4105,3581],{"class":480},[467,4107,508],{"class":473},[467,4109,4110],{"class":511},"'Starting...'",[467,4112,1200],{"class":473},[467,4114,4115,4117,4120,4122,4125],{"class":469,"line":784},[467,4116,3925],{"class":477},[467,4118,4119],{"class":511}," 'stop'",[467,4121,4096],{"class":477},[467,4123,4124],{"class":511}," 'end'",[467,4126,2538],{"class":473},[467,4128,4129,4131,4133,4136],{"class":469,"line":873},[467,4130,3581],{"class":480},[467,4132,508],{"class":473},[467,4134,4135],{"class":511},"'Stopping...'",[467,4137,1200],{"class":473},[467,4139,4140,4142,4145],{"class":469,"line":992},[467,4141,3925],{"class":477},[467,4143,4144],{"class":511}," 'pause'",[467,4146,2538],{"class":473},[467,4148,4149,4151,4153,4156],{"class":469,"line":1102},[467,4150,3581],{"class":480},[467,4152,508],{"class":473},[467,4154,4155],{"class":511},"'Pausing...'",[467,4157,1200],{"class":473},[467,4159,4160,4162],{"class":469,"line":1113},[467,4161,3925],{"class":477},[467,4163,3857],{"class":473},[467,4165,4166,4168,4170,4173],{"class":469,"line":1119},[467,4167,3581],{"class":480},[467,4169,508],{"class":473},[467,4171,4172],{"class":511},"'Invalid input'",[467,4174,1200],{"class":473},[467,4176,4177],{"class":469,"line":2180},[467,4178,568],{"emptyLinePlaceholder":567},[467,4180,4181,4184,4187,4189],{"class":469,"line":2196},[467,4182,4183],{"class":473},"match_input(",[467,4185,4186],{"class":511},"'begin'",[467,4188,521],{"class":473},[467,4190,4191],{"class":499},"# => Starting...\n",[467,4193,4194,4196,4199,4201],{"class":469,"line":2201},[467,4195,4183],{"class":473},[467,4197,4198],{"class":511},"'stop'",[467,4200,521],{"class":473},[467,4202,4203],{"class":499},"# => Stopping...\n",[467,4205,4206,4208,4211,4213],{"class":469,"line":2213},[467,4207,4183],{"class":473},[467,4209,4210],{"class":511},"'pause'",[467,4212,521],{"class":473},[467,4214,4215],{"class":499},"# => Pausing...\n",[467,4217,4218,4220,4223,4225],{"class":469,"line":2218},[467,4219,4183],{"class":473},[467,4221,4222],{"class":511},"'test'",[467,4224,521],{"class":473},[467,4226,4227],{"class":499},"# => Invalid input\n",[4229,4230,4232],"h5",{"id":4231},"проверка-типов","Проверка типов",[401,4234,4235],{},"В операторе case можно использовать функции приведения типов, например, str(), int(). Это нужно, чтобы проверять тип переменной после match:",[457,4237,4239],{"className":459,"code":4238,"language":461,"meta":462,"style":462},"def get_type(val):\n    match val:\n        case str(val):\n            print(f'It is a string: {val}')\n        case int(val):\n            print(f'It is an integer: {val}')\n        case _:\n            print(\"I don't know this type\")\n\nget_type('hello')  # => It is a string: hello\nget_type(123)  # => It is an integer: 123\nget_type(None)  # => I don't know this type\n",[464,4240,4241,4251,4258,4267,4293,4302,4323,4329,4340,4344,4357,4369],{"__ignoreMap":462},[467,4242,4243,4245,4248],{"class":469,"line":470},[467,4244,541],{"class":477},[467,4246,4247],{"class":544}," get_type",[467,4249,4250],{"class":473},"(val):\n",[467,4252,4253,4255],{"class":469,"line":490},[467,4254,3918],{"class":477},[467,4256,4257],{"class":473}," val:\n",[467,4259,4260,4262,4265],{"class":469,"line":503},[467,4261,3925],{"class":477},[467,4263,4264],{"class":480}," str",[467,4266,4250],{"class":473},[467,4268,4269,4271,4273,4276,4279,4282,4285,4288,4291],{"class":469,"line":571},[467,4270,3581],{"class":480},[467,4272,508],{"class":473},[467,4274,4275],{"class":477},"f",[467,4277,4278],{"class":511},"'It is a string: ",[467,4280,4281],{"class":480},"{",[467,4283,4284],{"class":473},"val",[467,4286,4287],{"class":480},"}",[467,4289,4290],{"class":511},"'",[467,4292,1200],{"class":473},[467,4294,4295,4297,4300],{"class":469,"line":784},[467,4296,3925],{"class":477},[467,4298,4299],{"class":480}," int",[467,4301,4250],{"class":473},[467,4303,4304,4306,4308,4310,4313,4315,4317,4319,4321],{"class":469,"line":873},[467,4305,3581],{"class":480},[467,4307,508],{"class":473},[467,4309,4275],{"class":477},[467,4311,4312],{"class":511},"'It is an integer: ",[467,4314,4281],{"class":480},[467,4316,4284],{"class":473},[467,4318,4287],{"class":480},[467,4320,4290],{"class":511},[467,4322,1200],{"class":473},[467,4324,4325,4327],{"class":469,"line":992},[467,4326,3925],{"class":477},[467,4328,3857],{"class":473},[467,4330,4331,4333,4335,4338],{"class":469,"line":1102},[467,4332,3581],{"class":480},[467,4334,508],{"class":473},[467,4336,4337],{"class":511},"\"I don't know this type\"",[467,4339,1200],{"class":473},[467,4341,4342],{"class":469,"line":1113},[467,4343,568],{"emptyLinePlaceholder":567},[467,4345,4346,4349,4352,4354],{"class":469,"line":1119},[467,4347,4348],{"class":473},"get_type(",[467,4350,4351],{"class":511},"'hello'",[467,4353,521],{"class":473},[467,4355,4356],{"class":499},"# => It is a string: hello\n",[467,4358,4359,4361,4364,4366],{"class":469,"line":2180},[467,4360,4348],{"class":473},[467,4362,4363],{"class":480},"123",[467,4365,521],{"class":473},[467,4367,4368],{"class":499},"# => It is an integer: 123\n",[467,4370,4371,4373,4375,4377],{"class":469,"line":2196},[467,4372,4348],{"class":473},[467,4374,1916],{"class":480},[467,4376,521],{"class":473},[467,4378,4379],{"class":499},"# => I don't know this type\n",[4229,4381,4383],{"id":4382},"определение-переменной-в-case","Определение переменной в case",[401,4385,4386],{},"Если определить переменную после case, то ей будет присвоено значение, которое связано с соответствием с match:",[457,4388,4390],{"className":459,"code":4389,"language":461,"meta":462,"style":462},"def match_input(input):\n    match input:\n        case 'start':\n            message = 'Starting...'\n        case 'stop':\n            message = 'Stopping...'\n        case 'pause':\n            message = 'Pausing...'\n        case _:\n            message = 'Invalid input'\n\n    print(message)\n\nmatch_input('start')  # => Starting...\nmatch_input('stop')  # => Stopping...\nmatch_input('pause')  # => Pausing...\nmatch_input('test')  # => Invalid input\n",[464,4391,4392,4400,4408,4416,4426,4434,4443,4451,4460,4466,4475,4479,4486,4490,4501,4511,4521],{"__ignoreMap":462},[467,4393,4394,4396,4398],{"class":469,"line":470},[467,4395,541],{"class":477},[467,4397,4074],{"class":544},[467,4399,4077],{"class":473},[467,4401,4402,4404,4406],{"class":469,"line":490},[467,4403,3918],{"class":477},[467,4405,4084],{"class":480},[467,4407,2538],{"class":473},[467,4409,4410,4412,4414],{"class":469,"line":503},[467,4411,3925],{"class":477},[467,4413,4093],{"class":511},[467,4415,2538],{"class":473},[467,4417,4418,4421,4423],{"class":469,"line":571},[467,4419,4420],{"class":473},"            message ",[467,4422,407],{"class":477},[467,4424,4425],{"class":511}," 'Starting...'\n",[467,4427,4428,4430,4432],{"class":469,"line":784},[467,4429,3925],{"class":477},[467,4431,4119],{"class":511},[467,4433,2538],{"class":473},[467,4435,4436,4438,4440],{"class":469,"line":873},[467,4437,4420],{"class":473},[467,4439,407],{"class":477},[467,4441,4442],{"class":511}," 'Stopping...'\n",[467,4444,4445,4447,4449],{"class":469,"line":992},[467,4446,3925],{"class":477},[467,4448,4144],{"class":511},[467,4450,2538],{"class":473},[467,4452,4453,4455,4457],{"class":469,"line":1102},[467,4454,4420],{"class":473},[467,4456,407],{"class":477},[467,4458,4459],{"class":511}," 'Pausing...'\n",[467,4461,4462,4464],{"class":469,"line":1113},[467,4463,3925],{"class":477},[467,4465,3857],{"class":473},[467,4467,4468,4470,4472],{"class":469,"line":1119},[467,4469,4420],{"class":473},[467,4471,407],{"class":477},[467,4473,4474],{"class":511}," 'Invalid input'\n",[467,4476,4477],{"class":469,"line":2180},[467,4478,568],{"emptyLinePlaceholder":567},[467,4480,4481,4483],{"class":469,"line":2196},[467,4482,3377],{"class":480},[467,4484,4485],{"class":473},"(message)\n",[467,4487,4488],{"class":469,"line":2201},[467,4489,568],{"emptyLinePlaceholder":567},[467,4491,4492,4494,4497,4499],{"class":469,"line":2213},[467,4493,4183],{"class":473},[467,4495,4496],{"class":511},"'start'",[467,4498,521],{"class":473},[467,4500,4191],{"class":499},[467,4502,4503,4505,4507,4509],{"class":469,"line":2218},[467,4504,4183],{"class":473},[467,4506,4198],{"class":511},[467,4508,521],{"class":473},[467,4510,4203],{"class":499},[467,4512,4513,4515,4517,4519],{"class":469,"line":2970},[467,4514,4183],{"class":473},[467,4516,4210],{"class":511},[467,4518,521],{"class":473},[467,4520,4215],{"class":499},[467,4522,4524,4526,4528,4530],{"class":469,"line":4523},17,[467,4525,4183],{"class":473},[467,4527,4222],{"class":511},[467,4529,521],{"class":473},[467,4531,4227],{"class":499},[401,4533,4534],{},"Здесь обязательно нужно задать \"дефолтный\" случай — _.\nТак как если ни один case не соответствует входному значению, переменная message не будет определена.\nЭто вызовет ошибку NameError.",[401,4536,4537,4538,4541,4542,4545],{},"Попробуйте сами запустить код в окне ниже с интерпретатором Python и повторите примеры из статьи чтобы самим увидеть и понять как всё это работает.\nДля этого в ячейке с кодом нажмите клавиши на клавиатуре ",[405,4539,4540],{},"Shift+Enter"," или запустите код через ",[405,4543,4544],{},"кнопку Run"," по значку ▶.",[4547,4548],"jypiter",{},[4550,4551,4552],"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 .sYu0t, html code.shiki .sYu0t{--shiki-default:#005CC5}html pre.shiki code .sAwPA, html code.shiki .sAwPA{--shiki-default:#6A737D}html pre.shiki code .sYBdl, html code.shiki .sYBdl{--shiki-default:#032F62}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":462,"searchDepth":490,"depth":784,"links":4554},[4555],{"id":399,"depth":490,"text":322,"children":4556},[4557,4558,4559,4560,4568,4574,4583,4584],{"id":451,"depth":571,"text":452},{"id":611,"depth":571,"text":612},{"id":679,"depth":571,"text":680},{"id":892,"depth":503,"text":893,"children":4561},[4562,4564,4566],{"id":1321,"depth":571,"text":4563},"И and",{"id":1384,"depth":571,"text":4565},"ИЛИ or",{"id":1437,"depth":571,"text":4567},"Отрицание not",{"id":1660,"depth":503,"text":1661,"children":4569},[4570,4571,4572,4573],{"id":1667,"depth":571,"text":1668},{"id":1974,"depth":571,"text":1975},{"id":2255,"depth":571,"text":2256},{"id":2366,"depth":571,"text":2367},{"id":2475,"depth":503,"text":2476,"children":4575},[4576,4578,4580,4582],{"id":2482,"depth":571,"text":4577},"Если if",{"id":2602,"depth":571,"text":4579},"Иначе else",{"id":2824,"depth":571,"text":4581},"Конструкция else + if = elif",{"id":3161,"depth":571,"text":3162},{"id":3340,"depth":503,"text":3341},{"id":3625,"depth":503,"text":3626,"children":4585},[4586,4587,4588],{"id":3632,"depth":571,"text":3626},{"id":3865,"depth":571,"text":3866},{"id":4058,"depth":571,"text":4059,"children":4589},[4590,4591],{"id":4231,"depth":784,"text":4232},{"id":4382,"depth":784,"text":4383},"2025-02-13","Логические операции. Условные конструкции","md","images\u002Fblog\u002Fpython\u002Fst8\u002Fimg.png",{},40,{"title":322,"description":4593},"0b4VIHtrZsEAOMLEHdj8L4RpF0CZ1KDCvcc0KuHYLHg",[4601,4603],{"title":318,"path":319,"stem":320,"description":4602,"children":-1},"Создание функций. Параметры функций. Аннотации типов. Окружение",{"title":326,"path":327,"stem":328,"description":4604,"children":-1},"Создание циклов. Условия внутри тела цикла. Обход строк",1780737508263]