[{"data":1,"prerenderedAt":2634},["ShallowReactive",2],{"navigation":3,"\u002Fblog\u002Fpython\u002Fst7":386,"\u002Fblog\u002Fpython\u002Fst7-surround":2629},[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":318,"author":388,"body":393,"date":2621,"description":2622,"extension":2623,"image":2624,"meta":2625,"minRead":2626,"navigation":453,"num":492,"path":319,"seo":2627,"stem":320,"__hash__":2628},"python\u002Fblog\u002Fpython\u002Fst7.md",{"name":389,"avatar":390},"Штана Альберт Игоревич",{"src":391,"alt":392},"me.jpg","@ashtana",{"type":394,"value":395,"toc":2605},"minimark",[396,400,404,409,412,507,510,573,576,614,617,621,624,650,653,677,743,746,782,785,807,810,853,856,887,890,943,946,975,978,1020,1023,1076,1080,1083,1167,1170,1233,1236,1247,1250,1281,1284,1311,1314,1389,1392,1425,1428,1449,1452,1485,1488,1531,1534,1563,1567,1570,1661,1664,1716,1719,1762,1765,1906,1909,1914,1917,1944,1947,1965,1968,2003,2006,2010,2013,2017,2024,2031,2055,2062,2095,2098,2101,2105,2108,2111,2119,2122,2226,2229,2255,2258,2262,2267,2270,2298,2301,2304,2344,2347,2394,2397,2401,2416,2470,2473,2530,2533,2584,2587,2598,2601],[397,398,318],"h2",{"id":399},"определение-функций",[401,402,403],"p",{},"С помощью определения собственных функций писать и поддерживать программы проще.\nОни позволяют объединять составные операции в одну.",[405,406,408],"h3",{"id":407},"создание-функции","Создание функции",[401,410,411],{},"Допустим, мы хотим отправить письма на сайте — это достаточно сложный процесс, который включает взаимодействие с внешними системами.\nНо если определить функцию, вся сложность скроется за одной простой функцией. Представим такой код:",[413,414,419],"pre",{"className":415,"code":416,"language":417,"meta":418,"style":418},"language-python shiki shiki-themes github-light","# Место, откуда берется функция\nfrom emails import send\n\nemail = 'support@admin.ru'\ntitle = 'Помогите'\nbody = 'Я написал историю, как я могу получить скидку?'\n\n# Один вызов — много логики внутри\nsend(email, title, body)\n","python","",[420,421,422,431,448,455,468,479,490,495,501],"code",{"__ignoreMap":418},[423,424,427],"span",{"class":425,"line":426},"line",1,[423,428,430],{"class":429},"sAwPA","# Место, откуда берется функция\n",[423,432,434,438,442,445],{"class":425,"line":433},2,[423,435,437],{"class":436},"sD7c4","from",[423,439,441],{"class":440},"sgsFI"," emails ",[423,443,444],{"class":436},"import",[423,446,447],{"class":440}," send\n",[423,449,451],{"class":425,"line":450},3,[423,452,454],{"emptyLinePlaceholder":453},true,"\n",[423,456,458,461,464],{"class":425,"line":457},4,[423,459,460],{"class":440},"email ",[423,462,463],{"class":436},"=",[423,465,467],{"class":466},"sYBdl"," 'support@admin.ru'\n",[423,469,471,474,476],{"class":425,"line":470},5,[423,472,473],{"class":440},"title ",[423,475,463],{"class":436},[423,477,478],{"class":466}," 'Помогите'\n",[423,480,482,485,487],{"class":425,"line":481},6,[423,483,484],{"class":440},"body ",[423,486,463],{"class":436},[423,488,489],{"class":466}," 'Я написал историю, как я могу получить скидку?'\n",[423,491,493],{"class":425,"line":492},7,[423,494,454],{"emptyLinePlaceholder":453},[423,496,498],{"class":425,"line":497},8,[423,499,500],{"class":429},"# Один вызов — много логики внутри\n",[423,502,504],{"class":425,"line":503},9,[423,505,506],{"class":440},"send(email, title, body)\n",[401,508,509],{},"Внутри себя этот вызов выполняет много логики: соединяется с почтовым сервером, формирует правильный запрос на основе заголовка и тела сообщения, а затем все отправляет, не забыв закрыть соединение.\nСоздадим нашу первую функцию. Ее задача — вывести на экран приветствие: Hello, World!",[413,511,513],{"className":415,"code":512,"language":417,"meta":418,"style":418},"# Определение функции не вызывает и не выполняет код функции\ndef show_greeting():\n    # Внутри тела — отступ четыре пробела\n    text = 'Hello, World!'\n    print(text)\n\n# Вызов функции\nshow_greeting()  # => Hello, World!\n",[420,514,515,520,532,537,547,556,560,565],{"__ignoreMap":418},[423,516,517],{"class":425,"line":426},[423,518,519],{"class":429},"# Определение функции не вызывает и не выполняет код функции\n",[423,521,522,525,529],{"class":425,"line":433},[423,523,524],{"class":436},"def",[423,526,528],{"class":527},"s7eDp"," show_greeting",[423,530,531],{"class":440},"():\n",[423,533,534],{"class":425,"line":450},[423,535,536],{"class":429},"    # Внутри тела — отступ четыре пробела\n",[423,538,539,542,544],{"class":425,"line":457},[423,540,541],{"class":440},"    text ",[423,543,463],{"class":436},[423,545,546],{"class":466}," 'Hello, World!'\n",[423,548,549,553],{"class":425,"line":470},[423,550,552],{"class":551},"sYu0t","    print",[423,554,555],{"class":440},"(text)\n",[423,557,558],{"class":425,"line":481},[423,559,454],{"emptyLinePlaceholder":453},[423,561,562],{"class":425,"line":492},[423,563,564],{"class":429},"# Вызов функции\n",[423,566,567,570],{"class":425,"line":497},[423,568,569],{"class":440},"show_greeting()  ",[423,571,572],{"class":429},"# => Hello, World!\n",[401,574,575],{},"Важным моментом при определении функции является то, что внутри тела функции обязательно должен быть отступ в четыре пробела.\nВ отличие от обычных данных, функции выполняют действия.\nПоэтому их имена нужно указывать через глаголы: «построить что-то», «нарисовать что-то», «открыть что-то».\nОписание с отступом, которое находится ниже имени функции, называется телом функции.\nВнутри тела можно писать любой код. Это как небольшая самостоятельная программа — набор произвольных инструкций.\nТело выполняется в тот момент, когда запускается функция. При этом каждый вызов функции запускает тело независимо от других вызовов.\nТело функции может быть пустым, тогда внутри него используется ключевое слово pass(используется как \"заглушка\", чтобы интерпретатор Python не выдавал ошибку, позднее можно будет написать код):",[413,577,579],{"className":415,"code":578,"language":417,"meta":418,"style":418},"# Минимальное определение функции\n# Функция ничего не делает\ndef noop():\n    pass\n\nnoop()\n",[420,580,581,586,591,600,605,609],{"__ignoreMap":418},[423,582,583],{"class":425,"line":426},[423,584,585],{"class":429},"# Минимальное определение функции\n",[423,587,588],{"class":425,"line":433},[423,589,590],{"class":429},"# Функция ничего не делает\n",[423,592,593,595,598],{"class":425,"line":450},[423,594,524],{"class":436},[423,596,597],{"class":527}," noop",[423,599,531],{"class":440},[423,601,602],{"class":425,"line":457},[423,603,604],{"class":436},"    pass\n",[423,606,607],{"class":425,"line":470},[423,608,454],{"emptyLinePlaceholder":453},[423,610,611],{"class":425,"line":481},[423,612,613],{"class":440},"noop()\n",[401,615,616],{},"У понятия «создать функцию» много синонимов: «реализовать», «определить» и даже «заимплементить».\nОни часто встречаются на практике. Создавая свои функции, вы облегчите сложные операции и сделаете разработку проще.",[405,618,620],{"id":619},"возврат-значений","Возврат значений",[401,622,623],{},"Когда мы определяем функцию, она печатает на экране какие-то данные:",[413,625,627],{"className":415,"code":626,"language":417,"meta":418,"style":418},"def show_greeting():\n    print('Hello, World!')\n",[420,628,629,637],{"__ignoreMap":418},[423,630,631,633,635],{"class":425,"line":426},[423,632,524],{"class":436},[423,634,528],{"class":527},[423,636,531],{"class":440},[423,638,639,641,644,647],{"class":425,"line":433},[423,640,552],{"class":551},[423,642,643],{"class":440},"(",[423,645,646],{"class":466},"'Hello, World!'",[423,648,649],{"class":440},")\n",[401,651,652],{},"Пользы от таких функций немного, так как результатом нельзя воспользоваться внутри программы. Рассмотрим на примере.\nВозьмем задачу обработки электронной почты. Когда пользователь регистрируется на сайте, он может ввести email любым способом:",[654,655,656,669],"ul",{},[657,658,659,660,668],"li",{},"Добавить случайно пробелы в начале или в конце: ",[661,662,663],"em",{},[664,665,667],"a",{"href":666},"mailto:support@admin.ru","support@admin.ru","_",[657,670,671,672,676],{},"Использовать буквы в разных регистрах: ",[664,673,675],{"href":674},"mailto:SUPPORT@admin.ru","SUPPORT@admin.ru","\nЕсли мы сохраним его в таком виде в базе данных, то пользователь не войдет на сайт.\nЧтобы этого не произошло, email нужно подготовить к записи в базу: привести его к нижнему регистру и обрезать пробелы по краям строки.\nТакая задача решается в пару строчек:",[413,678,680],{"className":415,"code":679,"language":417,"meta":418,"style":418},"def save_email():\n    # Email приходит из формы\n    email = '  SuppORT@admin.ru'\n    # Обрезаем пробельные символы\n    trimmed_email = email.strip()\n    prepared_email = trimmed_email.lower()\n    print(prepared_email)\n    # Здесь будет запись в базу данных \n",[420,681,682,691,696,706,711,721,731,738],{"__ignoreMap":418},[423,683,684,686,689],{"class":425,"line":426},[423,685,524],{"class":436},[423,687,688],{"class":527}," save_email",[423,690,531],{"class":440},[423,692,693],{"class":425,"line":433},[423,694,695],{"class":429},"    # Email приходит из формы\n",[423,697,698,701,703],{"class":425,"line":450},[423,699,700],{"class":440},"    email ",[423,702,463],{"class":436},[423,704,705],{"class":466}," '  SuppORT@admin.ru'\n",[423,707,708],{"class":425,"line":457},[423,709,710],{"class":429},"    # Обрезаем пробельные символы\n",[423,712,713,716,718],{"class":425,"line":470},[423,714,715],{"class":440},"    trimmed_email ",[423,717,463],{"class":436},[423,719,720],{"class":440}," email.strip()\n",[423,722,723,726,728],{"class":425,"line":481},[423,724,725],{"class":440},"    prepared_email ",[423,727,463],{"class":436},[423,729,730],{"class":440}," trimmed_email.lower()\n",[423,732,733,735],{"class":425,"line":492},[423,734,552],{"class":551},[423,736,737],{"class":440},"(prepared_email)\n",[423,739,740],{"class":425,"line":497},[423,741,742],{"class":429},"    # Здесь будет запись в базу данных\n",[401,744,745],{},"Этот код стал возможен благодаря тому, что значение вернулось.\nМетоды strip() и lower() ничего не печатают на экране, они возвращают результат своей работы.\nПоэтому мы можем записать его в переменные.\nЕсли бы они печатали на экране, мы бы не могли присвоить результат переменной.\nНапример, так мы не можем сделать с функцией show_greeting():",[413,747,749],{"className":415,"code":748,"language":417,"meta":418,"style":418},"message = show_greeting()\n# в действительности функция print() возвращает None\n# None — специальный объект, используемый для представления отсутствия значения\nprint(message) # => None\n",[420,750,751,761,766,771],{"__ignoreMap":418},[423,752,753,756,758],{"class":425,"line":426},[423,754,755],{"class":440},"message ",[423,757,463],{"class":436},[423,759,760],{"class":440}," show_greeting()\n",[423,762,763],{"class":425,"line":433},[423,764,765],{"class":429},"# в действительности функция print() возвращает None\n",[423,767,768],{"class":425,"line":450},[423,769,770],{"class":429},"# None — специальный объект, используемый для представления отсутствия значения\n",[423,772,773,776,779],{"class":425,"line":457},[423,774,775],{"class":551},"print",[423,777,778],{"class":440},"(message) ",[423,780,781],{"class":429},"# => None\n",[401,783,784],{},"Теперь переименуем и изменим функцию show_greeting() так, чтобы она возвращала данные. Для этого выполним возврат вместо печати на экране:",[413,786,788],{"className":415,"code":787,"language":417,"meta":418,"style":418},"def greeting():\n    return 'Hello World!'\n",[420,789,790,799],{"__ignoreMap":418},[423,791,792,794,797],{"class":425,"line":426},[423,793,524],{"class":436},[423,795,796],{"class":527}," greeting",[423,798,531],{"class":440},[423,800,801,804],{"class":425,"line":433},[423,802,803],{"class":436},"    return",[423,805,806],{"class":466}," 'Hello World!'\n",[401,808,809],{},"return — это инструкция. Она берет записанное справа выражение и отдает его тому коду, который вызвал метод.\nЗдесь выполнение функции завершается.",[413,811,813],{"className":415,"code":812,"language":417,"meta":418,"style":418},"# Теперь мы можем использовать результат работы функции\nmessage = greeting()\nprint(message) # => Hello World!\n# И даже выполнить какие-то действия над результатом\nprint(message.upper()) # => HELLO WORLD!\n",[420,814,815,820,829,838,843],{"__ignoreMap":418},[423,816,817],{"class":425,"line":426},[423,818,819],{"class":429},"# Теперь мы можем использовать результат работы функции\n",[423,821,822,824,826],{"class":425,"line":433},[423,823,755],{"class":440},[423,825,463],{"class":436},[423,827,828],{"class":440}," greeting()\n",[423,830,831,833,835],{"class":425,"line":450},[423,832,775],{"class":551},[423,834,778],{"class":440},[423,836,837],{"class":429},"# => Hello World!\n",[423,839,840],{"class":425,"line":457},[423,841,842],{"class":429},"# И даже выполнить какие-то действия над результатом\n",[423,844,845,847,850],{"class":425,"line":470},[423,846,775],{"class":551},[423,848,849],{"class":440},"(message.upper()) ",[423,851,852],{"class":429},"# => HELLO WORLD!\n",[401,854,855],{},"Любой код после return не выполняется:",[413,857,859],{"className":415,"code":858,"language":417,"meta":418,"style":418},"def greeting_with_code_after_return():\n    return 'Hello World!'\n    print('Я никогда не выполнюсь')\n",[420,860,861,870,876],{"__ignoreMap":418},[423,862,863,865,868],{"class":425,"line":426},[423,864,524],{"class":436},[423,866,867],{"class":527}," greeting_with_code_after_return",[423,869,531],{"class":440},[423,871,872,874],{"class":425,"line":433},[423,873,803],{"class":436},[423,875,806],{"class":466},[423,877,878,880,882,885],{"class":425,"line":450},[423,879,552],{"class":551},[423,881,643],{"class":440},[423,883,884],{"class":466},"'Я никогда не выполнюсь'",[423,886,649],{"class":440},[401,888,889],{},"Даже если функция возвращает данные, это не ограничивает ее в том, что она печатает.\nКроме возврата данных мы можем и печатать:",[413,891,893],{"className":415,"code":892,"language":417,"meta":418,"style":418},"def greeting_with_return_and_printing():\n    print('Я появлюсь в консоли')\n    return 'Hello World!'\n\n\n# И напечатает текст на экране, и вернет значение\nmessage = greeting_with_return_and_printing()\n",[420,894,895,904,915,921,925,929,934],{"__ignoreMap":418},[423,896,897,899,902],{"class":425,"line":426},[423,898,524],{"class":436},[423,900,901],{"class":527}," greeting_with_return_and_printing",[423,903,531],{"class":440},[423,905,906,908,910,913],{"class":425,"line":433},[423,907,552],{"class":551},[423,909,643],{"class":440},[423,911,912],{"class":466},"'Я появлюсь в консоли'",[423,914,649],{"class":440},[423,916,917,919],{"class":425,"line":450},[423,918,803],{"class":436},[423,920,806],{"class":466},[423,922,923],{"class":425,"line":457},[423,924,454],{"emptyLinePlaceholder":453},[423,926,927],{"class":425,"line":470},[423,928,454],{"emptyLinePlaceholder":453},[423,930,931],{"class":425,"line":481},[423,932,933],{"class":429},"# И напечатает текст на экране, и вернет значение\n",[423,935,936,938,940],{"class":425,"line":492},[423,937,755],{"class":440},[423,939,463],{"class":436},[423,941,942],{"class":440}," greeting_with_return_and_printing()\n",[401,944,945],{},"Возвращать можно не только конкретное значение.\nТак как return работает с выражениями, то справа от него может быть что угодно.\nЗдесь нужно руководствоваться принципами читаемости кода:",[413,947,949],{"className":415,"code":948,"language":417,"meta":418,"style":418},"def greeting():\n    message = 'Hello World!'\n    return message\n",[420,950,951,959,968],{"__ignoreMap":418},[423,952,953,955,957],{"class":425,"line":426},[423,954,524],{"class":436},[423,956,796],{"class":527},[423,958,531],{"class":440},[423,960,961,964,966],{"class":425,"line":433},[423,962,963],{"class":440},"    message ",[423,965,463],{"class":436},[423,967,806],{"class":466},[423,969,970,972],{"class":425,"line":450},[423,971,803],{"class":436},[423,973,974],{"class":440}," message\n",[401,976,977],{},"Здесь мы не возвращаем переменную.\nВозвращается всегда значение, которое находится в этой переменной.\nНиже пример с вычислениями:",[413,979,981],{"className":415,"code":980,"language":417,"meta":418,"style":418},"def double_four():\n    # или return 4 + 4\n    result = 4 + 4\n    return result\n",[420,982,983,992,997,1013],{"__ignoreMap":418},[423,984,985,987,990],{"class":425,"line":426},[423,986,524],{"class":436},[423,988,989],{"class":527}," double_four",[423,991,531],{"class":440},[423,993,994],{"class":425,"line":433},[423,995,996],{"class":429},"    # или return 4 + 4\n",[423,998,999,1002,1004,1007,1010],{"class":425,"line":450},[423,1000,1001],{"class":440},"    result ",[423,1003,463],{"class":436},[423,1005,1006],{"class":551}," 4",[423,1008,1009],{"class":436}," +",[423,1011,1012],{"class":551}," 4\n",[423,1014,1015,1017],{"class":425,"line":457},[423,1016,803],{"class":436},[423,1018,1019],{"class":440}," result\n",[401,1021,1022],{},"Определить функцию мало. Еще важно, чтобы она была полезна, и результатом можно было воспользоваться.\nА теперь подумайте, что вернет вызов функции run(), определенной ниже:",[413,1024,1026],{"className":415,"code":1025,"language":417,"meta":418,"style":418},"# Определение\ndef run():\n    return 1\n    return 2\n\n\n# Что будет выведено на экран?\nprint(run())\n",[420,1027,1028,1033,1042,1049,1056,1060,1064,1069],{"__ignoreMap":418},[423,1029,1030],{"class":425,"line":426},[423,1031,1032],{"class":429},"# Определение\n",[423,1034,1035,1037,1040],{"class":425,"line":433},[423,1036,524],{"class":436},[423,1038,1039],{"class":527}," run",[423,1041,531],{"class":440},[423,1043,1044,1046],{"class":425,"line":450},[423,1045,803],{"class":436},[423,1047,1048],{"class":551}," 1\n",[423,1050,1051,1053],{"class":425,"line":457},[423,1052,803],{"class":436},[423,1054,1055],{"class":551}," 2\n",[423,1057,1058],{"class":425,"line":470},[423,1059,454],{"emptyLinePlaceholder":453},[423,1061,1062],{"class":425,"line":481},[423,1063,454],{"emptyLinePlaceholder":453},[423,1065,1066],{"class":425,"line":492},[423,1067,1068],{"class":429},"# Что будет выведено на экран?\n",[423,1070,1071,1073],{"class":425,"line":497},[423,1072,775],{"class":551},[423,1074,1075],{"class":440},"(run())\n",[405,1077,1079],{"id":1078},"параметры-функций","Параметры функций",[401,1081,1082],{},"Функции могут не только возвращать значения, но и принимать параметры.\nНапомним, что с параметрами функций мы уже сталкивались:",[413,1084,1086],{"className":415,"code":1085,"language":417,"meta":418,"style":418},"# Принимает на вход один параметр любого типа\nprint('я параметр')\n# Принимает на вход два строковых параметра\n# первый — что ищем, второй — на что меняем\n'google'.replace('go', 'mo')  # moogle\n# Принимает на вход два числовых параметра\n# первый — округляемое число, второй — число знаков после запятой, которые нужно оставить\nround(10.23456, 3)  # 10.235\n",[420,1087,1088,1093,1104,1109,1114,1137,1142,1147],{"__ignoreMap":418},[423,1089,1090],{"class":425,"line":426},[423,1091,1092],{"class":429},"# Принимает на вход один параметр любого типа\n",[423,1094,1095,1097,1099,1102],{"class":425,"line":433},[423,1096,775],{"class":551},[423,1098,643],{"class":440},[423,1100,1101],{"class":466},"'я параметр'",[423,1103,649],{"class":440},[423,1105,1106],{"class":425,"line":450},[423,1107,1108],{"class":429},"# Принимает на вход два строковых параметра\n",[423,1110,1111],{"class":425,"line":457},[423,1112,1113],{"class":429},"# первый — что ищем, второй — на что меняем\n",[423,1115,1116,1119,1122,1125,1128,1131,1134],{"class":425,"line":470},[423,1117,1118],{"class":466},"'google'",[423,1120,1121],{"class":440},".replace(",[423,1123,1124],{"class":466},"'go'",[423,1126,1127],{"class":440},", ",[423,1129,1130],{"class":466},"'mo'",[423,1132,1133],{"class":440},")  ",[423,1135,1136],{"class":429},"# moogle\n",[423,1138,1139],{"class":425,"line":481},[423,1140,1141],{"class":429},"# Принимает на вход два числовых параметра\n",[423,1143,1144],{"class":425,"line":492},[423,1145,1146],{"class":429},"# первый — округляемое число, второй — число знаков после запятой, которые нужно оставить\n",[423,1148,1149,1152,1154,1157,1159,1162,1164],{"class":425,"line":497},[423,1150,1151],{"class":551},"round",[423,1153,643],{"class":440},[423,1155,1156],{"class":551},"10.23456",[423,1158,1127],{"class":440},[423,1160,1161],{"class":551},"3",[423,1163,1133],{"class":440},[423,1165,1166],{"class":429},"# 10.235\n",[401,1168,1169],{},"А теперь представим, что нам нужно реализовать функцию get_last_char(), которая возвращает последний символ в строке, переданной ей на вход как параметр.\nВот как будет выглядеть использование этой функции:",[413,1171,1173],{"className":415,"code":1172,"language":417,"meta":418,"style":418},"# Передача параметров напрямую без переменных\nget_last_char(\"Python\")  # n\n# Передача параметров через переменные\nname1 = 'Python'\nget_last_char(name1)  # n\nname2 = 'Go'\nget_last_char(name2)  # o\n",[420,1174,1175,1180,1193,1198,1208,1215,1225],{"__ignoreMap":418},[423,1176,1177],{"class":425,"line":426},[423,1178,1179],{"class":429},"# Передача параметров напрямую без переменных\n",[423,1181,1182,1185,1188,1190],{"class":425,"line":433},[423,1183,1184],{"class":440},"get_last_char(",[423,1186,1187],{"class":466},"\"Python\"",[423,1189,1133],{"class":440},[423,1191,1192],{"class":429},"# n\n",[423,1194,1195],{"class":425,"line":450},[423,1196,1197],{"class":429},"# Передача параметров через переменные\n",[423,1199,1200,1203,1205],{"class":425,"line":457},[423,1201,1202],{"class":440},"name1 ",[423,1204,463],{"class":436},[423,1206,1207],{"class":466}," 'Python'\n",[423,1209,1210,1213],{"class":425,"line":470},[423,1211,1212],{"class":440},"get_last_char(name1)  ",[423,1214,1192],{"class":429},[423,1216,1217,1220,1222],{"class":425,"line":481},[423,1218,1219],{"class":440},"name2 ",[423,1221,463],{"class":436},[423,1223,1224],{"class":466}," 'Go'\n",[423,1226,1227,1230],{"class":425,"line":492},[423,1228,1229],{"class":440},"get_last_char(name2)  ",[423,1231,1232],{"class":429},"# o\n",[401,1234,1235],{},"Из этого примера можно сделать следующие выводы:",[654,1237,1238,1241,1244],{},[657,1239,1240],{},"Нужно определить функцию get_last_char()",[657,1242,1243],{},"Функция должна принимать на вход один параметр строкового типа",[657,1245,1246],{},"Функция должна возвращать значение строкового типа",[401,1248,1249],{},"Определяем функцию:",[413,1251,1253],{"className":415,"code":1252,"language":417,"meta":418,"style":418},"def get_last_char(text):\n    return text[-1]\n",[420,1254,1255,1265],{"__ignoreMap":418},[423,1256,1257,1259,1262],{"class":425,"line":426},[423,1258,524],{"class":436},[423,1260,1261],{"class":527}," get_last_char",[423,1263,1264],{"class":440},"(text):\n",[423,1266,1267,1269,1272,1275,1278],{"class":425,"line":433},[423,1268,803],{"class":436},[423,1270,1271],{"class":440}," text[",[423,1273,1274],{"class":436},"-",[423,1276,1277],{"class":551},"1",[423,1279,1280],{"class":440},"]\n",[401,1282,1283],{},"В скобках указывается имя переменной text, которая служит параметром. Имя параметра может быть любым.\nГлавное, чтобы оно отражало смысл значения, которое содержится внутри. Например:",[413,1285,1287],{"className":415,"code":1286,"language":417,"meta":418,"style":418},"def get_last_char(string):\n    return string[-1]\n",[420,1288,1289,1298],{"__ignoreMap":418},[423,1290,1291,1293,1295],{"class":425,"line":426},[423,1292,524],{"class":436},[423,1294,1261],{"class":527},[423,1296,1297],{"class":440},"(string):\n",[423,1299,1300,1302,1305,1307,1309],{"class":425,"line":433},[423,1301,803],{"class":436},[423,1303,1304],{"class":440}," string[",[423,1306,1274],{"class":436},[423,1308,1277],{"class":551},[423,1310,1280],{"class":440},[401,1312,1313],{},"Значение параметра будет зависеть от вызова этой функции:",[413,1315,1317],{"className":415,"code":1316,"language":417,"meta":418,"style":418},"# Внутри функции string будет равна 'python'\nget_last_char('python')  # n\n\n# Внутри функции string будет равна 'code'\nget_last_char('code')  # e\n\n# Внутри функции string будет равна 'Summer'\n# Имя переменной снаружи не связано с именем переменной в определении функции\ntext = 'Summer'\nget_last_char(text)  # r\n",[420,1318,1319,1324,1335,1339,1344,1356,1360,1365,1370,1380],{"__ignoreMap":418},[423,1320,1321],{"class":425,"line":426},[423,1322,1323],{"class":429},"# Внутри функции string будет равна 'python'\n",[423,1325,1326,1328,1331,1333],{"class":425,"line":433},[423,1327,1184],{"class":440},[423,1329,1330],{"class":466},"'python'",[423,1332,1133],{"class":440},[423,1334,1192],{"class":429},[423,1336,1337],{"class":425,"line":450},[423,1338,454],{"emptyLinePlaceholder":453},[423,1340,1341],{"class":425,"line":457},[423,1342,1343],{"class":429},"# Внутри функции string будет равна 'code'\n",[423,1345,1346,1348,1351,1353],{"class":425,"line":470},[423,1347,1184],{"class":440},[423,1349,1350],{"class":466},"'code'",[423,1352,1133],{"class":440},[423,1354,1355],{"class":429},"# e\n",[423,1357,1358],{"class":425,"line":481},[423,1359,454],{"emptyLinePlaceholder":453},[423,1361,1362],{"class":425,"line":492},[423,1363,1364],{"class":429},"# Внутри функции string будет равна 'Summer'\n",[423,1366,1367],{"class":425,"line":497},[423,1368,1369],{"class":429},"# Имя переменной снаружи не связано с именем переменной в определении функции\n",[423,1371,1372,1375,1377],{"class":425,"line":503},[423,1373,1374],{"class":440},"text ",[423,1376,463],{"class":436},[423,1378,1379],{"class":466}," 'Summer'\n",[423,1381,1383,1386],{"class":425,"line":1382},10,[423,1384,1385],{"class":440},"get_last_char(text)  ",[423,1387,1388],{"class":429},"# r\n",[401,1390,1391],{},"Параметр нужно обязательно указывать. Если вызвать функцию без него, то интерпретатор выдаст ошибку:",[413,1393,1395],{"className":415,"code":1394,"language":417,"meta":418,"style":418},"get_last_char()  # У такого кода нет смысла\n\nTypeError: get_last_char() missing 1 required positional argument: 'string'\n",[420,1396,1397,1405,1409],{"__ignoreMap":418},[423,1398,1399,1402],{"class":425,"line":426},[423,1400,1401],{"class":440},"get_last_char()  ",[423,1403,1404],{"class":429},"# У такого кода нет смысла\n",[423,1406,1407],{"class":425,"line":433},[423,1408,454],{"emptyLinePlaceholder":453},[423,1410,1411,1414,1417,1419,1422],{"class":425,"line":450},[423,1412,1413],{"class":551},"TypeError",[423,1415,1416],{"class":440},": get_last_char() missing ",[423,1418,1277],{"class":551},[423,1420,1421],{"class":440}," required positional argument: ",[423,1423,1424],{"class":466},"'string'\n",[401,1426,1427],{},"Многие функции работают одновременно с несколькими параметрами.\nНапример, чтобы округлить число, нужно указать не только само число, но и количество знаков после запятой:",[413,1429,1431],{"className":415,"code":1430,"language":417,"meta":418,"style":418},"round(10.23456, 3)  # 10.235\n",[420,1432,1433],{"__ignoreMap":418},[423,1434,1435,1437,1439,1441,1443,1445,1447],{"class":425,"line":426},[423,1436,1151],{"class":551},[423,1438,643],{"class":440},[423,1440,1156],{"class":551},[423,1442,1127],{"class":440},[423,1444,1161],{"class":551},[423,1446,1133],{"class":440},[423,1448,1166],{"class":429},[401,1450,1451],{},"То же самое относится и к методам. Они могут требовать на вход любое количество параметров, которое им нужно для работы:",[413,1453,1455],{"className":415,"code":1454,"language":417,"meta":418,"style":418},"# Первый параметр — что ищем\n# Второй параметр — на что меняем\n'google'.replace('go', 'do')  # doogle\n",[420,1456,1457,1462,1467],{"__ignoreMap":418},[423,1458,1459],{"class":425,"line":426},[423,1460,1461],{"class":429},"# Первый параметр — что ищем\n",[423,1463,1464],{"class":425,"line":433},[423,1465,1466],{"class":429},"# Второй параметр — на что меняем\n",[423,1468,1469,1471,1473,1475,1477,1480,1482],{"class":425,"line":450},[423,1470,1118],{"class":466},[423,1472,1121],{"class":440},[423,1474,1124],{"class":466},[423,1476,1127],{"class":440},[423,1478,1479],{"class":466},"'do'",[423,1481,1133],{"class":440},[423,1483,1484],{"class":429},"# doogle\n",[401,1486,1487],{},"Чтобы создать такие функции и методы, в определении нужно указать необходимое количество параметров через запятую.\nЕще им нужно дать понятные имена.\nНиже пример определения функции replace(), которая заменяет в слове одну часть строки на другую:",[413,1489,1491],{"className":415,"code":1490,"language":417,"meta":418,"style":418},"def replace(text, from_, to):\n    # Здесь тело функции\n\nreplace('google', 'go', 'do')  # doogle\n",[420,1492,1493,1503,1508,1512],{"__ignoreMap":418},[423,1494,1495,1497,1500],{"class":425,"line":426},[423,1496,524],{"class":436},[423,1498,1499],{"class":527}," replace",[423,1501,1502],{"class":440},"(text, from_, to):\n",[423,1504,1505],{"class":425,"line":433},[423,1506,1507],{"class":429},"    # Здесь тело функции\n",[423,1509,1510],{"class":425,"line":450},[423,1511,454],{"emptyLinePlaceholder":453},[423,1513,1514,1517,1519,1521,1523,1525,1527,1529],{"class":425,"line":457},[423,1515,1516],{"class":440},"replace(",[423,1518,1118],{"class":466},[423,1520,1127],{"class":440},[423,1522,1124],{"class":466},[423,1524,1127],{"class":440},[423,1526,1479],{"class":466},[423,1528,1133],{"class":440},[423,1530,1484],{"class":429},[401,1532,1533],{},"Когда параметров два и более, то практически для всех функций важен порядок передачи этих параметров.\nЕсли его поменять, то функция отработает по-другому:",[413,1535,1537],{"className":415,"code":1536,"language":417,"meta":418,"style":418},"# Ничего не заменилось, так как внутри google нет do\nreplace('google', 'do', 'go')  # google\n",[420,1538,1539,1544],{"__ignoreMap":418},[423,1540,1541],{"class":425,"line":426},[423,1542,1543],{"class":429},"# Ничего не заменилось, так как внутри google нет do\n",[423,1545,1546,1548,1550,1552,1554,1556,1558,1560],{"class":425,"line":433},[423,1547,1516],{"class":440},[423,1549,1118],{"class":466},[423,1551,1127],{"class":440},[423,1553,1479],{"class":466},[423,1555,1127],{"class":440},[423,1557,1124],{"class":466},[423,1559,1133],{"class":440},[423,1561,1562],{"class":429},"# google\n",[405,1564,1566],{"id":1565},"необязательные-параметры-функций","Необязательные параметры функций",[401,1568,1569],{},"В программировании у многих функций и методов есть параметры, которые редко меняются.\nВ таких случаях этим параметрам задают значения по умолчанию, которые можно поменять по необходимости.\nС помощью этого сокращается количество одинакового кода. Рассмотрим, как это выглядит на практике.\nРазберем пример:",[413,1571,1573],{"className":415,"code":1572,"language":417,"meta":418,"style":418},"# Функция возведения в степень\n# Второй параметр имеет значение по умолчанию два\ndef pow(x, base=2):\n    return x ** base\n\n# Три во второй степени (двойка задана по умолчанию)\npow(3)  # 3 * 3 = 9\n# Три в третьей степени\npow(3, 3)  # 3 * 3 * 3 = 27\n",[420,1574,1575,1580,1585,1603,1616,1620,1625,1639,1644],{"__ignoreMap":418},[423,1576,1577],{"class":425,"line":426},[423,1578,1579],{"class":429},"# Функция возведения в степень\n",[423,1581,1582],{"class":425,"line":433},[423,1583,1584],{"class":429},"# Второй параметр имеет значение по умолчанию два\n",[423,1586,1587,1589,1592,1595,1597,1600],{"class":425,"line":450},[423,1588,524],{"class":436},[423,1590,1591],{"class":551}," pow",[423,1593,1594],{"class":440},"(x, base",[423,1596,463],{"class":436},[423,1598,1599],{"class":551},"2",[423,1601,1602],{"class":440},"):\n",[423,1604,1605,1607,1610,1613],{"class":425,"line":457},[423,1606,803],{"class":436},[423,1608,1609],{"class":440}," x ",[423,1611,1612],{"class":436},"**",[423,1614,1615],{"class":440}," base\n",[423,1617,1618],{"class":425,"line":470},[423,1619,454],{"emptyLinePlaceholder":453},[423,1621,1622],{"class":425,"line":481},[423,1623,1624],{"class":429},"# Три во второй степени (двойка задана по умолчанию)\n",[423,1626,1627,1630,1632,1634,1636],{"class":425,"line":492},[423,1628,1629],{"class":551},"pow",[423,1631,643],{"class":440},[423,1633,1161],{"class":551},[423,1635,1133],{"class":440},[423,1637,1638],{"class":429},"# 3 * 3 = 9\n",[423,1640,1641],{"class":425,"line":497},[423,1642,1643],{"class":429},"# Три в третьей степени\n",[423,1645,1646,1648,1650,1652,1654,1656,1658],{"class":425,"line":503},[423,1647,1629],{"class":551},[423,1649,643],{"class":440},[423,1651,1161],{"class":551},[423,1653,1127],{"class":440},[423,1655,1161],{"class":551},[423,1657,1133],{"class":440},[423,1659,1660],{"class":429},"# 3 * 3 * 3 = 27\n",[401,1662,1663],{},"Значение по умолчанию выглядит как обычное присваивание в определении. Оно срабатывает только в том случае, если параметр не передали.\nПредставьте, что вы не привезли с собой в автосервис запчасти для вашего автомобиля.\nТогда автомеханик предложит вам поставить те, которые есть у него — в наличии, по умолчанию.\nЗначение по умолчанию может быть даже в том случае, когда параметр один:",[413,1665,1667],{"className":415,"code":1666,"language":417,"meta":418,"style":418},"def my_print(text='nothing'):\n    print(text)\n\nmy_print()  # => \"nothing\"\nmy_print(\"Python\")  # => \"Python\"\n",[420,1668,1669,1686,1692,1696,1704],{"__ignoreMap":418},[423,1670,1671,1673,1676,1679,1681,1684],{"class":425,"line":426},[423,1672,524],{"class":436},[423,1674,1675],{"class":527}," my_print",[423,1677,1678],{"class":440},"(text",[423,1680,463],{"class":436},[423,1682,1683],{"class":466},"'nothing'",[423,1685,1602],{"class":440},[423,1687,1688,1690],{"class":425,"line":433},[423,1689,552],{"class":551},[423,1691,555],{"class":440},[423,1693,1694],{"class":425,"line":450},[423,1695,454],{"emptyLinePlaceholder":453},[423,1697,1698,1701],{"class":425,"line":457},[423,1699,1700],{"class":440},"my_print()  ",[423,1702,1703],{"class":429},"# => \"nothing\"\n",[423,1705,1706,1709,1711,1713],{"class":425,"line":470},[423,1707,1708],{"class":440},"my_print(",[423,1710,1187],{"class":466},[423,1712,1133],{"class":440},[423,1714,1715],{"class":429},"# => \"Python\"\n",[401,1717,1718],{},"Параметров со значениями по умолчанию может быть любое количество:",[413,1720,1722],{"className":415,"code":1721,"language":417,"meta":418,"style":418},"def print_params(a=5, b=10, c=100):\n    ...\n",[420,1723,1724,1757],{"__ignoreMap":418},[423,1725,1726,1728,1731,1734,1736,1739,1742,1744,1747,1750,1752,1755],{"class":425,"line":426},[423,1727,524],{"class":436},[423,1729,1730],{"class":527}," print_params",[423,1732,1733],{"class":440},"(a",[423,1735,463],{"class":436},[423,1737,1738],{"class":551},"5",[423,1740,1741],{"class":440},", b",[423,1743,463],{"class":436},[423,1745,1746],{"class":551},"10",[423,1748,1749],{"class":440},", c",[423,1751,463],{"class":436},[423,1753,1754],{"class":551},"100",[423,1756,1602],{"class":440},[423,1758,1759],{"class":425,"line":433},[423,1760,1761],{"class":551},"    ...\n",[401,1763,1764],{},"У значений по умолчанию есть одно ограничение. Они должны идти в самом конце списка параметров.\nС точки зрения синтаксиса, невозможно создать функцию, у которой после необязательного параметра идет обязательный:",[413,1766,1768],{"className":415,"code":1767,"language":417,"meta":418,"style":418},"# Такой код завершится с ошибкой\ndef print_params(a=5, b=10, c=100, x):\n# И такой\ndef print_params(a=5, b=10, x, c=100):\n\n# Этот код сработает\ndef print_params(x, a=5, b=10, c=100):\n\n# Этот тоже сработает\ndef print_params(x, y, a=5, b=10, c=100):\n",[420,1769,1770,1775,1802,1807,1834,1838,1843,1870,1874,1879],{"__ignoreMap":418},[423,1771,1772],{"class":425,"line":426},[423,1773,1774],{"class":429},"# Такой код завершится с ошибкой\n",[423,1776,1777,1779,1781,1783,1785,1787,1789,1791,1793,1795,1797,1799],{"class":425,"line":433},[423,1778,524],{"class":436},[423,1780,1730],{"class":527},[423,1782,1733],{"class":440},[423,1784,463],{"class":436},[423,1786,1738],{"class":551},[423,1788,1741],{"class":440},[423,1790,463],{"class":436},[423,1792,1746],{"class":551},[423,1794,1749],{"class":440},[423,1796,463],{"class":436},[423,1798,1754],{"class":551},[423,1800,1801],{"class":440},", x):\n",[423,1803,1804],{"class":425,"line":450},[423,1805,1806],{"class":429},"# И такой\n",[423,1808,1809,1811,1813,1815,1817,1819,1821,1823,1825,1828,1830,1832],{"class":425,"line":457},[423,1810,524],{"class":436},[423,1812,1730],{"class":527},[423,1814,1733],{"class":440},[423,1816,463],{"class":436},[423,1818,1738],{"class":551},[423,1820,1741],{"class":440},[423,1822,463],{"class":436},[423,1824,1746],{"class":551},[423,1826,1827],{"class":440},", x, c",[423,1829,463],{"class":436},[423,1831,1754],{"class":551},[423,1833,1602],{"class":440},[423,1835,1836],{"class":425,"line":470},[423,1837,454],{"emptyLinePlaceholder":453},[423,1839,1840],{"class":425,"line":481},[423,1841,1842],{"class":429},"# Этот код сработает\n",[423,1844,1845,1847,1849,1852,1854,1856,1858,1860,1862,1864,1866,1868],{"class":425,"line":492},[423,1846,524],{"class":436},[423,1848,1730],{"class":527},[423,1850,1851],{"class":440},"(x, a",[423,1853,463],{"class":436},[423,1855,1738],{"class":551},[423,1857,1741],{"class":440},[423,1859,463],{"class":436},[423,1861,1746],{"class":551},[423,1863,1749],{"class":440},[423,1865,463],{"class":436},[423,1867,1754],{"class":551},[423,1869,1602],{"class":440},[423,1871,1872],{"class":425,"line":497},[423,1873,454],{"emptyLinePlaceholder":453},[423,1875,1876],{"class":425,"line":503},[423,1877,1878],{"class":429},"# Этот тоже сработает\n",[423,1880,1881,1883,1885,1888,1890,1892,1894,1896,1898,1900,1902,1904],{"class":425,"line":1382},[423,1882,524],{"class":436},[423,1884,1730],{"class":527},[423,1886,1887],{"class":440},"(x, y, a",[423,1889,463],{"class":436},[423,1891,1738],{"class":551},[423,1893,1741],{"class":440},[423,1895,463],{"class":436},[423,1897,1746],{"class":551},[423,1899,1749],{"class":440},[423,1901,463],{"class":436},[423,1903,1754],{"class":551},[423,1905,1602],{"class":440},[401,1907,1908],{},"Значения по умолчанию могут быть как у нескольких параметров, так и у одного.\nИ помните, что значения по умолчанию должны быть в самом конце списка параметров.\nЭти знания помогут сократить количество одинакового кода.",[1910,1911,1913],"h4",{"id":1912},"функции-с-переменным-числом-параметров","Функции с переменным числом параметров",[401,1915,1916],{},"У некоторых функций есть особенность — они принимают переменное число параметров.\nИ мы говорим не о значениях по умолчанию. Посмотрите на этот пример:",[413,1918,1920],{"className":415,"code":1919,"language":417,"meta":418,"style":418},"max(1, 10, 3)  # 10\n",[420,1921,1922],{"__ignoreMap":418},[423,1923,1924,1927,1929,1931,1933,1935,1937,1939,1941],{"class":425,"line":426},[423,1925,1926],{"class":551},"max",[423,1928,643],{"class":440},[423,1930,1277],{"class":551},[423,1932,1127],{"class":440},[423,1934,1746],{"class":551},[423,1936,1127],{"class":440},[423,1938,1161],{"class":551},[423,1940,1133],{"class":440},[423,1942,1943],{"class":429},"# 10\n",[401,1945,1946],{},"В примере выше функция max() находит максимальное значение среди переданных параметров.\nЧтобы узнать, сколько параметров можно передавать на вход, нужно изучить документацию этой функции.\nТам мы увидим такую конструкцию:",[413,1948,1950],{"className":415,"code":1949,"language":417,"meta":418,"style":418},"max(arg1, arg2, *args[, key])\n",[420,1951,1952],{"__ignoreMap":418},[423,1953,1954,1956,1959,1962],{"class":425,"line":426},[423,1955,1926],{"class":551},[423,1957,1958],{"class":440},"(arg1, arg2, ",[423,1960,1961],{"class":436},"*",[423,1963,1964],{"class":440},"args[, key])\n",[401,1966,1967],{},"Это значит, что max() принимает на вход два параметра и больше:",[413,1969,1971],{"className":415,"code":1970,"language":417,"meta":418,"style":418},"max(1, 3, 2, 4, 2)  # 4\n",[420,1972,1973],{"__ignoreMap":418},[423,1974,1975,1977,1979,1981,1983,1985,1987,1989,1991,1994,1996,1998,2000],{"class":425,"line":426},[423,1976,1926],{"class":551},[423,1978,643],{"class":440},[423,1980,1277],{"class":551},[423,1982,1127],{"class":440},[423,1984,1161],{"class":551},[423,1986,1127],{"class":440},[423,1988,1599],{"class":551},[423,1990,1127],{"class":440},[423,1992,1993],{"class":551},"4",[423,1995,1127],{"class":440},[423,1997,1599],{"class":551},[423,1999,1133],{"class":440},[423,2001,2002],{"class":429},"# 4\n",[401,2004,2005],{},"Если функция найдет несколько параметров с максимальным значением, значит, она вернет самый первый из них.",[405,2007,2009],{"id":2008},"именованные-аргументы","Именованные аргументы",[401,2011,2012],{},"Разберем, какие параметры существуют, чем они отличаются и в каких случаях их применять.",[1910,2014,2016],{"id":2015},"какие-параметры-существуют","Какие параметры существуют",[401,2018,2019,2023],{},[2020,2021,2022],"strong",{},"Аргументы"," — это данные, которые передаются в вызов функции. Они бывают двух типов:",[401,2025,2026,2027,2030],{},"Первый тип — ",[2020,2028,2029],{},"позиционные аргументы",". Они передаются в том же порядке, в котором определены параметры функции:",[413,2032,2034],{"className":415,"code":2033,"language":417,"meta":418,"style":418},"# (text, length)\ntruncate('My Text', 3)\n",[420,2035,2036,2041],{"__ignoreMap":418},[423,2037,2038],{"class":425,"line":426},[423,2039,2040],{"class":429},"# (text, length)\n",[423,2042,2043,2046,2049,2051,2053],{"class":425,"line":433},[423,2044,2045],{"class":440},"truncate(",[423,2047,2048],{"class":466},"'My Text'",[423,2050,1127],{"class":440},[423,2052,1161],{"class":551},[423,2054,649],{"class":440},[401,2056,2057,2058,2061],{},"Второй тип — ",[2020,2059,2060],{},"именованные аргументы",".\nОни передаются не просто как значения, а как пары «имя=значение».\nПоэтому их можно передавать в любом порядке:",[413,2063,2065],{"className":415,"code":2064,"language":417,"meta":418,"style":418},"# Аргументы переданы в другом порядке\ntruncate(length=3, text='My Text')\n",[420,2066,2067,2072],{"__ignoreMap":418},[423,2068,2069],{"class":425,"line":426},[423,2070,2071],{"class":429},"# Аргументы переданы в другом порядке\n",[423,2073,2074,2076,2080,2082,2084,2086,2089,2091,2093],{"class":425,"line":433},[423,2075,2045],{"class":440},[423,2077,2079],{"class":2078},"sqxcx","length",[423,2081,463],{"class":436},[423,2083,1161],{"class":551},[423,2085,1127],{"class":440},[423,2087,2088],{"class":2078},"text",[423,2090,463],{"class":436},[423,2092,2048],{"class":466},[423,2094,649],{"class":440},[401,2096,2097],{},"Если внимательно посмотреть на два примера выше, то можно понять, что это две одинаковые функции.",[401,2099,2100],{},"Теперь разберемся, в каких случаях нужно применять эти типы аргументов.",[1910,2102,2104],{"id":2103},"какие-параметры-использовать","Какие параметры использовать",[401,2106,2107],{},"Выбор типа параметра зависит от того, кто вызывает функцию.",[401,2109,2110],{},"Есть две причины использовать именованные аргументы:",[654,2112,2113,2116],{},[657,2114,2115],{},"Они повышают читаемость, так как сразу видно имена.",[657,2117,2118],{},"Можно не указывать все промежуточные параметры, которые нам сейчас не нужны.",[401,2120,2121],{},"Последнее полезно, если у функции много необязательных параметров. Посмотрим на примере:",[413,2123,2125],{"className":415,"code":2124,"language":417,"meta":418,"style":418},"def print_params(a=1, b=2, c=None, d=4):\n    print(a, b, c, d)\n\n# Нужно передать только d, но приходится передавать все\nprint_params(1, 2, None, 8)\n\n# Именованные аргументы позволяют передавать только d\n# Для остальных аргументов используются значения по умолчанию\nprint_params(d=8)\n",[420,2126,2127,2161,2168,2172,2177,2199,2203,2208,2213],{"__ignoreMap":418},[423,2128,2129,2131,2133,2135,2137,2139,2141,2143,2145,2147,2149,2152,2155,2157,2159],{"class":425,"line":426},[423,2130,524],{"class":436},[423,2132,1730],{"class":527},[423,2134,1733],{"class":440},[423,2136,463],{"class":436},[423,2138,1277],{"class":551},[423,2140,1741],{"class":440},[423,2142,463],{"class":436},[423,2144,1599],{"class":551},[423,2146,1749],{"class":440},[423,2148,463],{"class":436},[423,2150,2151],{"class":551},"None",[423,2153,2154],{"class":440},", d",[423,2156,463],{"class":436},[423,2158,1993],{"class":551},[423,2160,1602],{"class":440},[423,2162,2163,2165],{"class":425,"line":433},[423,2164,552],{"class":551},[423,2166,2167],{"class":440},"(a, b, c, d)\n",[423,2169,2170],{"class":425,"line":450},[423,2171,454],{"emptyLinePlaceholder":453},[423,2173,2174],{"class":425,"line":457},[423,2175,2176],{"class":429},"# Нужно передать только d, но приходится передавать все\n",[423,2178,2179,2182,2184,2186,2188,2190,2192,2194,2197],{"class":425,"line":470},[423,2180,2181],{"class":440},"print_params(",[423,2183,1277],{"class":551},[423,2185,1127],{"class":440},[423,2187,1599],{"class":551},[423,2189,1127],{"class":440},[423,2191,2151],{"class":551},[423,2193,1127],{"class":440},[423,2195,2196],{"class":551},"8",[423,2198,649],{"class":440},[423,2200,2201],{"class":425,"line":481},[423,2202,454],{"emptyLinePlaceholder":453},[423,2204,2205],{"class":425,"line":492},[423,2206,2207],{"class":429},"# Именованные аргументы позволяют передавать только d\n",[423,2209,2210],{"class":425,"line":497},[423,2211,2212],{"class":429},"# Для остальных аргументов используются значения по умолчанию\n",[423,2214,2215,2217,2220,2222,2224],{"class":425,"line":503},[423,2216,2181],{"class":440},[423,2218,2219],{"class":2078},"d",[423,2221,463],{"class":436},[423,2223,2196],{"class":551},[423,2225,649],{"class":440},[401,2227,2228],{},"Именованные аргументы можно передавать одновременно с позиционными. Тогда позиционные должны идти в самом начале:",[413,2230,2232],{"className":415,"code":2231,"language":417,"meta":418,"style":418},"# Передаем только a (позиционно) и d (как именованный)\nprint_params(3, d=3)\n",[420,2233,2234,2239],{"__ignoreMap":418},[423,2235,2236],{"class":425,"line":426},[423,2237,2238],{"class":429},"# Передаем только a (позиционно) и d (как именованный)\n",[423,2240,2241,2243,2245,2247,2249,2251,2253],{"class":425,"line":433},[423,2242,2181],{"class":440},[423,2244,1161],{"class":551},[423,2246,1127],{"class":440},[423,2248,2219],{"class":2078},[423,2250,463],{"class":436},[423,2252,1161],{"class":551},[423,2254,649],{"class":440},[401,2256,2257],{},"Итак, мы ограничились только базовыми знаниями, которые помогут вам читать примеры кода с именованными аргументами.\nВ дальнейшем необходимо изучить эту тему подробнее.",[405,2259,2261],{"id":2260},"аннотации-типов","Аннотации типов",[401,2263,2264,2266],{},[2020,2265,2261],{}," — это возможность указать типы параметров и возвращаемого значения у функции в Python.\nЭто не является обязательным требованием языка, но может помочь программистам в дальнейшей разработке, улучшить читаемость кода и повысить его надежность.",[401,2268,2269],{},"Давайте рассмотрим простой пример функции без аннотаций типов:",[413,2271,2273],{"className":415,"code":2272,"language":417,"meta":418,"style":418},"def concat(first, second):\n    return first + second\n",[420,2274,2275,2285],{"__ignoreMap":418},[423,2276,2277,2279,2282],{"class":425,"line":426},[423,2278,524],{"class":436},[423,2280,2281],{"class":527}," concat",[423,2283,2284],{"class":440},"(first, second):\n",[423,2286,2287,2289,2292,2295],{"class":425,"line":433},[423,2288,803],{"class":436},[423,2290,2291],{"class":440}," first ",[423,2293,2294],{"class":436},"+",[423,2296,2297],{"class":440}," second\n",[401,2299,2300],{},"Эта функция конкатенирует две строки в одну.\nПри этом с первого взгляда на код сложно понять, что происходит в нем: какие типы у аргументов, почему функция работает со строками, а не складывает, например, два числа.\nЕсли в дальнейшем использовать эту функцию в коде, то может возникнуть необходимость проверять типы аргументов перед передачей их в функцию, что увеличивает объем кода и затрудняет его понимание.",[401,2302,2303],{},"Теперь давайте добавим аннотации типов к функции:",[413,2305,2307],{"className":415,"code":2306,"language":417,"meta":418,"style":418},"def concat(first: str, second: str) -> str:\n    return first + second\n",[420,2308,2309,2334],{"__ignoreMap":418},[423,2310,2311,2313,2315,2318,2321,2324,2326,2329,2331],{"class":425,"line":426},[423,2312,524],{"class":436},[423,2314,2281],{"class":527},[423,2316,2317],{"class":440},"(first: ",[423,2319,2320],{"class":551},"str",[423,2322,2323],{"class":440},", second: ",[423,2325,2320],{"class":551},[423,2327,2328],{"class":440},") -> ",[423,2330,2320],{"class":551},[423,2332,2333],{"class":440},":\n",[423,2335,2336,2338,2340,2342],{"class":425,"line":433},[423,2337,803],{"class":436},[423,2339,2291],{"class":440},[423,2341,2294],{"class":436},[423,2343,2297],{"class":440},[401,2345,2346],{},"Здесь указали, что аргументы first и second должны быть строкового типа (str).\nС помощью стрелки -> указали тип возвращаемого значения функции, оно также будет строковым (-> str).\nКогда мы будем использовать эту функцию в коде, нам будет проще понять, какие типы аргументов можно передавать и какой тип возвращаемого значения ожидается.\nАннотации типов также могут быть использованы для определения типов переменных внутри функции. Например:",[413,2348,2350],{"className":415,"code":2349,"language":417,"meta":418,"style":418},"def double(n: int) -> int:\n    result: int = n * 2\n    return result\n",[420,2351,2352,2371,2388],{"__ignoreMap":418},[423,2353,2354,2356,2359,2362,2365,2367,2369],{"class":425,"line":426},[423,2355,524],{"class":436},[423,2357,2358],{"class":527}," double",[423,2360,2361],{"class":440},"(n: ",[423,2363,2364],{"class":551},"int",[423,2366,2328],{"class":440},[423,2368,2364],{"class":551},[423,2370,2333],{"class":440},[423,2372,2373,2376,2378,2381,2384,2386],{"class":425,"line":433},[423,2374,2375],{"class":440},"    result: ",[423,2377,2364],{"class":551},[423,2379,2380],{"class":436}," =",[423,2382,2383],{"class":440}," n ",[423,2385,1961],{"class":436},[423,2387,1055],{"class":551},[423,2389,2390,2392],{"class":425,"line":450},[423,2391,803],{"class":436},[423,2393,1019],{"class":440},[401,2395,2396],{},"В этом примере мы определили тип переменной result как int, используя аннотацию типа.\nАннотации типов — это нестрогая проверка типов в Python.\nИх использование не гарантирует, что функция будет вызвана с аргументами и возвращаемым значением указанных типов.\nPython остаётся динамически типизированным языком.\nВ нем аннотации типов не влияют на возможность передачи аргументов различных типов и возвращения значений других типов.\nТем не менее их использование упрощает чтение и понимание кода и помогает отслеживать ошибки.",[405,2398,2400],{"id":2399},"окружение","Окружение",[401,2402,2403,2404,2407,2408,2411,2412,2415],{},"Поработаем с функцией ",[2020,2405,2406],{},"generate()"," и переменными ",[2020,2409,2410],{},"result"," и ",[2020,2413,2414],{},"age",".\nТакже разберем, что такое локальная переменная и как она работает.\nВозьмем для примера следующий код:",[413,2417,2419],{"className":415,"code":2418,"language":417,"meta":418,"style":418},"age = 18\n\ndef generate():\n    return age + 3\n\nresult = generate()\n",[420,2420,2421,2431,2435,2444,2456,2460],{"__ignoreMap":418},[423,2422,2423,2426,2428],{"class":425,"line":426},[423,2424,2425],{"class":440},"age ",[423,2427,463],{"class":436},[423,2429,2430],{"class":551}," 18\n",[423,2432,2433],{"class":425,"line":433},[423,2434,454],{"emptyLinePlaceholder":453},[423,2436,2437,2439,2442],{"class":425,"line":450},[423,2438,524],{"class":436},[423,2440,2441],{"class":527}," generate",[423,2443,531],{"class":440},[423,2445,2446,2448,2451,2453],{"class":425,"line":457},[423,2447,803],{"class":436},[423,2449,2450],{"class":440}," age ",[423,2452,2294],{"class":436},[423,2454,2455],{"class":551}," 3\n",[423,2457,2458],{"class":425,"line":470},[423,2459,454],{"emptyLinePlaceholder":453},[423,2461,2462,2465,2467],{"class":425,"line":481},[423,2463,2464],{"class":440},"result ",[423,2466,463],{"class":436},[423,2468,2469],{"class":440}," generate()\n",[401,2471,2472],{},"Когда код выполнится, внутри переменной result окажется значение 21.\nХоть переменная age — это не аргумент функции generate(), ее все равно видно в теле функции.\nТак происходит, потому что переменную age определили ранее вызова функции, а интерпретатор Python читает файл сверху вниз.\nЭто правило относится и к другим переменным.\nРассмотрим другой пример:",[413,2474,2476],{"className":415,"code":2475,"language":417,"meta":418,"style":418},"age = 18\n\ndef generate():\n    age = 20\n    return age + 3\n\nresult = generate()\n",[420,2477,2478,2486,2490,2498,2508,2518,2522],{"__ignoreMap":418},[423,2479,2480,2482,2484],{"class":425,"line":426},[423,2481,2425],{"class":440},[423,2483,463],{"class":436},[423,2485,2430],{"class":551},[423,2487,2488],{"class":425,"line":433},[423,2489,454],{"emptyLinePlaceholder":453},[423,2491,2492,2494,2496],{"class":425,"line":450},[423,2493,524],{"class":436},[423,2495,2441],{"class":527},[423,2497,531],{"class":440},[423,2499,2500,2503,2505],{"class":425,"line":457},[423,2501,2502],{"class":440},"    age ",[423,2504,463],{"class":436},[423,2506,2507],{"class":551}," 20\n",[423,2509,2510,2512,2514,2516],{"class":425,"line":470},[423,2511,803],{"class":436},[423,2513,2450],{"class":440},[423,2515,2294],{"class":436},[423,2517,2455],{"class":551},[423,2519,2520],{"class":425,"line":481},[423,2521,454],{"emptyLinePlaceholder":453},[423,2523,2524,2526,2528],{"class":425,"line":492},[423,2525,2464],{"class":440},[423,2527,463],{"class":436},[423,2529,2469],{"class":440},[401,2531,2532],{},"В данном случае результатом будет число 23.\nВнешнее значение age = 18 не влияет на код функции, потому что в теле функции определили свою переменную age — локальную переменную.\nЕе не видно за пределами функции.\nИ последний пример:",[413,2534,2536],{"className":415,"code":2535,"language":417,"meta":418,"style":418},"age = 20\n\ndef generate():\n    age = 18\n\ngenerate()\nresult = age\n",[420,2537,2538,2546,2550,2558,2566,2570,2575],{"__ignoreMap":418},[423,2539,2540,2542,2544],{"class":425,"line":426},[423,2541,2425],{"class":440},[423,2543,463],{"class":436},[423,2545,2507],{"class":551},[423,2547,2548],{"class":425,"line":433},[423,2549,454],{"emptyLinePlaceholder":453},[423,2551,2552,2554,2556],{"class":425,"line":450},[423,2553,524],{"class":436},[423,2555,2441],{"class":527},[423,2557,531],{"class":440},[423,2559,2560,2562,2564],{"class":425,"line":457},[423,2561,2502],{"class":440},[423,2563,463],{"class":436},[423,2565,2430],{"class":551},[423,2567,2568],{"class":425,"line":470},[423,2569,454],{"emptyLinePlaceholder":453},[423,2571,2572],{"class":425,"line":481},[423,2573,2574],{"class":440},"generate()\n",[423,2576,2577,2579,2581],{"class":425,"line":492},[423,2578,2464],{"class":440},[423,2580,463],{"class":436},[423,2582,2583],{"class":440}," age\n",[401,2585,2586],{},"Результат будет 20.\nЛокальная переменная, которую создали внутри функции generate(), не влияет на внешнюю переменную age.\nПоэтому, когда функцию вызвали, значение внешней age не изменилось и осталось 5.",[401,2588,2589,2590,2593,2594,2597],{},"Попробуйте сами запустить код в окне ниже с интерпретатором Python и повторите примеры из статьи чтобы самим увидеть и понять как всё это работает.\nДля этого в ячейке с кодом нажмите клавиши на клавиатуре ",[2020,2591,2592],{},"Shift+Enter"," или запустите код через ",[2020,2595,2596],{},"кнопку Run"," по значку ▶.",[2599,2600],"jypiter",{},[2602,2603,2604],"style",{},"html pre.shiki code .sAwPA, html code.shiki .sAwPA{--shiki-default:#6A737D}html pre.shiki code .sD7c4, html code.shiki .sD7c4{--shiki-default:#D73A49}html pre.shiki code .sgsFI, html code.shiki .sgsFI{--shiki-default:#24292E}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}html pre.shiki code .sYu0t, html code.shiki .sYu0t{--shiki-default:#005CC5}html pre.shiki code .sqxcx, html code.shiki .sqxcx{--shiki-default:#E36209}",{"title":418,"searchDepth":433,"depth":470,"links":2606},[2607],{"id":399,"depth":433,"text":318,"children":2608},[2609,2610,2611,2612,2615,2619,2620],{"id":407,"depth":450,"text":408},{"id":619,"depth":450,"text":620},{"id":1078,"depth":450,"text":1079},{"id":1565,"depth":450,"text":1566,"children":2613},[2614],{"id":1912,"depth":457,"text":1913},{"id":2008,"depth":450,"text":2009,"children":2616},[2617,2618],{"id":2015,"depth":457,"text":2016},{"id":2103,"depth":457,"text":2104},{"id":2260,"depth":450,"text":2261},{"id":2399,"depth":450,"text":2400},"2025-02-06","Создание функций. Параметры функций. Аннотации типов. Окружение","md","images\u002Fblog\u002Fpython\u002Fst7\u002Fimg.png",{},25,{"title":318,"description":2622},"donh8PvdtKUeudERZdminqaBhYpqxRkRE8GKc_e8kPs",[2630,2632],{"title":314,"path":315,"stem":316,"description":2631,"children":-1},"Использование встроенных функций. Цепочки методов. Стандартная библиотека Python",{"title":322,"path":323,"stem":324,"description":2633,"children":-1},"Логические операции. Условные конструкции",1780737508005]