Почему функция возвращает none python

Функции

Мы зачастую хотим делить нашу программу на составные блоки, это могут быть модули/пакеты модулей , классы для написания программ в парадигме ООП . Одним из составных блоков нашей программы может быть функция.

Если говорить просто, то функция – это средство, позволяющее группировать наборы инструкций так, что в программе они могут запускаться неоднократно. Функции могут вычислять некоторый результат и позволять указывать вход- ные параметры, отличающиеся по своим значениям от вызова к вызову. Воз- можность оформления операций в виде функций – это очень удобный инстру- мент, который мы можем использовать в самых разных ситуациях.

Для объявления функций используется инструкция def . Пример простой функции с именем foo , которая ничего не делает

Функции получают аргументы. Аргументы мы перечисляем в круглых скобочках.

Вызов функций#

Для вызова функции(т.е перехода к исполнению ее инструкций) используется оператор вызова функции:

Возврат значения из функции / оператор return #

Наши функции делают какую-то работу, мы это работу хотим из функции получить, для того чтобы вернуть значение из функции используется оператор return

Если мы явно ничего из функции не возвращали — из функции вернется None

Помимо этого инструкция return прекращает дальнейшее исполнение функции и мы можем исползовать return без указания возвращаемого значения:

Аргументы функции#

• Позиционные аргументы — аргументы передаваемые при вызове по их порядку в объявлении функции
• Именованные аргументы — аргументы передаваемые по их имени, указанному при объвлении функции

Аргументы со значением по умолчанию (Опициональные)#

Если вы объявили функцию с 2 аргументами и не указали значения по умолчанию — эти аргументы будут обязательными при вызове функции, для объявления функции с опциональными аргументами используется следующий синтаксис:

В примере мы создали функцию foo , которая получает один аргумент, но он не является обязательным, потому что для него указано значение по умолчанию("default value")

❗️Обратите внимание#

Значения по умолчанию инициализируются во время инициализации функции, в других языках, которые я знаю значение по умолчанию инициализируется при каждом вызове функции, это может приводить к неблагоприятным сайд-эффектам.
Для большей ясности я продемонстрирую вам пример:

Живой примерчик:#

Сворачивание аргументов#

Нам было бы не удобно если функции могли получать только ограниченное кол-во аргументов, поэтому мы можем делать сворачивание аргументов. Для начала рассмотрим пример функции sum которая получает только 2 аргумента и возвращает их сумму:

Но что делать если мы хотим вызывать функцию с несколькими аргументами?

В таком случае давайте сделаем так, чтобы все позиционные аргументы собирались в какую-то одну переменную-аргумент , назовем ее args . Для сворачивания аргуметов используется символ *

Вполне естественно для понимания, что переменная args внутри функции будет типа tuple . Примерно такое же вы можете делать и для именованных аргументов

Для того чтобы свернуть все оставшиеся именованные аргументы используется синтаксис с двумя звездочками ** . А тип переменной kwargs будет dict .

Только позиционные и только именованные аргументы#

⚠️Важно заметить#

Только позиционные аргументы появились в Python 3.8

Только именованные#

Для того чтобы сделать аргументы только именованными нам надо просто воспользоваться сворачиванием позиционных аргументов через * или *args . Все перечисленные аргументы полсле сворачивания будут передаваться только по имени.

Только позиционные#

Для того чтобы сделать аргументы только позиционными они отделяются символом / . (Как показано в примере выше)

Что делает def ?#

Давайте теперь рассмотрим что делает оператор def , и для того чтобы меньше самому писать я обращусь к Лутцу.

def – это исполняемый программный код. Функции в языке Python создаются с помощью новой инструкции def . В отличие от функций в компилирующих языках программирования, таких как C , def относится к классу исполняемых инструкций – функция не существует, пока интерпретатор не доберется до инструкции def и не выполнит ее. Фактически вполне допу- стимо (а иногда даже полезно) вкладывать инструкции def внутрь инструкций if , циклов while и даже в другие инструкции def . В случае наиболее типичного использования инструкции def вставляются в файлы модулей и генерируют функции при выполнении во время первой операции импор- тирования.

def создает объект и присваивает ему имя. Когда интерпретатор Python встречает и выполняет инструкцию def , он создает новый объект-функцию и связывает его с именем функции. Как и в любой другой операции при- сваивания, имя становится ссылкой на объект-функцию. В имени функции нет ничего необычного – как будет показано далее, объект-функция может быть связан с несколькими именами, может сохраняться в списке и так да- лее. Кроме того, к функциям можно прикреплять различные атрибуты, определяемые пользователем, для сохранения каких-либо данных.

Что мы можем понять из этих двух пунктов? А то, что когда вы используете инструкцию def вы просто создаете объект, у которого есть имя и магический метод __call__ . По этим причинам следующий код будет работать:

Почему из функции возвращается None

Изучаю Python3. Реализовал рекурсивный алгоритм Евклида для поиска наибольшего общего делителя. Никак не пойму, почему функция возвращает None . Что самое интересное — строка print(b) выводит правильный результат и далее функция завершается, но результат None

Любая функция в Python возвращает значение. Если вы не используете инструкцию return явно, то функция возвращает None .

В вашем случае ветки условия elif a > b и else не возвращают ничего. Отсюда и берется None .

А вот и пример правильного, работоспособного кода (без лишнего вызова print ):

Добавьте return в elif a > b: и else:

Дизайн сайта / логотип © 2023 Stack Exchange Inc; пользовательские материалы лицензированы в соответствии с CC BY-SA . rev 2023.9.6.43612

Нажимая «Принять все файлы cookie» вы соглашаетесь, что Stack Exchange может хранить файлы cookie на вашем устройстве и раскрывать информацию в соответствии с нашей Политикой в отношении файлов cookie.

Почему функция выводит none в Python?

Достаточно часто возникают вопросы: "почему моя функция ничего не возвращает?!", "почему из функции возвращается None?", "не могу понять откуда появляется None. ".

Для начала необходимо понимать и помнить, что любая функция в Python всегда что-то возвращает и если не используется оператор return для возврата значения (такие случаи бывают, но об этом позднее), то функция возвращает объект None . В случае если return используется, но после него ничего не указывается явно, то по умолчанию считается, что там стоит объект None .

Порой бывает, что по ошибке указывается возврат вместе с функцией print() . Для информации функция print() в Python выводит переданные аргументы на стандартное устройство вывода (экран), но при этом не возвращает значений, т.е. можно считать, что возвращает None .

Если дальше по коду проводятся манипуляции с переменной b, например сложение, то возникнет ошибка TypeError :

Возможен вариант, когда функция и не должна ничего возвращать, она производит какие-либо действия с объектами в глобальной зоне видимости и на этом ее функционал заканчивается. В таком случае return может и не использоваться, но необходимо помнить, что в этом случае функция возвращает None .

В примере выше использовался метод работы со списками extend() и необходимо понимать, что метод изменяет объект, к которому применен, а не возвращает результат изменения объекта.

Функции¶

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

• структурировать код и улучшить читаемость;
• переиспользовать код;
• уменьшать количество мест, в которых можно ошибиться, при копировании и вставке кода.

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

В Python функции можно разделить на три типа:

• встроенные (список built-in функций);
• именованные (определенные пользователем при помощи def );
• анонимные ( lambda -функции).

Все функции являются объектами типа function .

Мы уже использовали встроенные функции, например:

• print() – вывод данных на экран;
• str() – создание объектов строкового типа;
• type() – определение типа объекта.

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

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

Очевидно, стандартные функции дают лишь базовый инструментарий. Реализовать более сложную логику можно самостоятельно.

Пример¶

Представим, что необходимо находить количество корней квадратного уравнения — это легко можно реализовать на Python!

Именованные функции¶

Определение¶

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

В Python существует особый синтаксис определения именованных функций:

в начале — ключевое слово def ;

существуют правила и рекомендации по именованию функций:

правила:

• название не может начинаться с числа;
• можно использовать нижнее подчеркивание _ , цифры и буквы;

рекомендации:

• snake_case : в названии только буквы нижнего регистра, слова разделяются _ ;
• название функции должно быть уникальным;

круглые скобки и, опционально, параметры внутри (о них ниже);

Код в Python организован в блоки и именно отступы дают понять, где у блоков начало и конец. Блоки могут быть вложенными. Все тело функции должно располагаться минимум в одном отступе от начала строк.

Напишем простейшую функцию, которая будет печатать две фразы:

Вызов¶

После определения функции появляется возможность к ней обращаться (вызывать). Делается это просто: указывается имя функции, круглые скобки и, опционально, аргументы в них.

Возвращаемое значение¶

Все функции в Python имеют одно и только одно возвращаемое значение. Если в теле функции отсутствует ключевое слово return , возвращаемое значение всегда будет None .

Возможно ли вернуть несколько значений?

Это возможно, если упаковать несколько значений в одно значение-контейнер. В Python контейнеры могут быть следующих типов:

• список (например, [1, 2, 3] )
• кортеж ( (1, 2, 3) )
• словарь ( <"key_one": 1, "key_two": 2, "key_three": 3>)
• объект класса (см. раздел объекты и классы)

Таким образом, возвращается одно значение, а содержать в себе оно может несколько других.

Возвращение значения означает, что его можно использовать вне функции, например, присвоить полученное значение переменной. Давайте посмотрим, что возвращает print_theme() и add_two() :

Как видите, несмотря на отсутствие return в коде функции, она действительно возвращает None .

Теперь посмотрим на add_two() , где возвращаемое значение задано нами:

Множественные return -ы¶

В теле функции можно указать return несколько раз. Выражения в Python вычисляются по очереди, и возвращаемое значение функции определяется первым вычисленным выражением, содержащем return (а если return отсутствует в теле функции, возвращается None ).

Покажем это на примере функции, умножающей нечетные числа на 2 и делящей четные числа пополам.

Выражение в строке 3 будет выполнено в случае, если выполняется условие из строки 2. При этом происходит выход из функции, и следующие выражения в ее теле уже не исполнятся при этом вызове. Поэтому нет необходимости писать else :

Функция change_num_2 эквивалентна change_num , но содержит лишний уровень вложенности. Знание о том, что после первого return происходит выход из функции, позволяет избежать лишней вложенности.

Пространства имен и области видимости¶

Чуть выше была определена add_two() , внутри которой инициализировалась переменная result . Значение этой переменной нельзя получить, обратившись к ней вне функции.

Потому что функции обладают своим пространством имен: переменные, которые определены внутри, не видны извне. Однако, функция может получать доступ к переменным, которые определены снаружи. Давайте опишем чуть более формально.

В Python объектам можно давать имя и обращаться к ним по нему. Эти имена организованы в пространства имен или namespace. Инициализация переменной добавляет в namespace название объекта. Namespace — набор имен определенных на текущий момент объектов. Представьте себе dict , где ключом является строка, а значением — ссылка на объект. Область видимости определяет, переменные из каких пространств имен сейчас доступны. Разберем, как и где Python ищет объекты, к которым обращаются (этот процесс называется name resolution).

Namespace и области видимости можно разделить на несколько типов:

• локальные (Local) — локальные переменные функции, данная область существует до тех пор, пока функция не завершит работу после вызова;
• локальные пространства могут быть вложены друг в друга, в таком случае область уровня \(N\) (Enclosing) содержит «более глубокую» \(N + 1\) . Поиск имени, вызванного на уровне \(N\) , начинается с локального namespace этого уровня и продвигается «наружу», то есть на уровни выше;
• глобальные (Global) — все объекты, определенные на уровне скрипта;
• встроенные (Built-in) — namespace содержит все встроенные объекты (функции, исключения и т. д.), поиск в нем осуществляется последним.

Если имя не было найдено даже на уровне Built-in, будет выброшено исключение NameError .

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

Замыкания¶

Замыкание (Closure) — это функция, объявленная в теле внешней функции, и использующая значения из области видимости внешней функции.

Замыкания удобно использовать для динамического создания функций.

Каррирование¶

Каррирование (Currying) — это превращение функции от нескольких аргументов в последовательность функций от одного аргумента.

В Python реализован менее строгий аналог каррирования. С помощью функции partial можно получить функцию от меньшего числа аргументов, но не обязательно одного. Рассмотрим пример.

Первым аргументом в partial передается функция. А далее через запятую можно передать от \(0\) до \(N\) аргументов, которые требуется зафиксировать, где \(N\) — это число аргументов исходной функции. Возвращаемое значение partial — это функция от \(N — x\) аргументов, где \(x\) — это число аргументов, переданных в partial (и таким образом зафиксированных). Передавать в partial только функцию и \(0\) аргументов можно, но не имеет смысла (получится функция от \(N\) аргументов, которая и была изначально). Если же зафиксировать все \(N\) аргументов, то на выходе получится функция от нуля аргументов (если это была чистая функция, результат будет эквивалентен константе).

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

Легко увидеть аналогию с примером замыкания, и действительно, в некоторых случаях использование partial дает тот же результат, но проще и потому предпочтительнее.

Чистые функции¶

Чистой функцией (pure function) называют функцию, одновременно обладающую следующими свойствами:

• является детерминированной;
• не имеет побочных эффектов.

Детерминированность означает, что возвращаемое значение всегда одинаково для одних и тех же значений аргументов.

Отсутствие побочных эффектов означает, что вызов функции не изменит ничего за пределами своей локальной области видимости. Сохранение возвращаемого функцией значения в переменную происходит за рамками функции, поэтому не нарушает ее чистоты.

1. 4
2. 4
3. 6
4. 4

Функция fn1 не имеет побочных эффектов, но она не детерминирована потому что зависит от external_dict . Поэтому она не чистая.

Функция fn2 детерминирована, но она имеет побочный эффект — изменяет содержимое external_dict . Поэтому она не чистая.

Функция fn3 детерминирована и не имеет побочных эффектов, поэтому она чистая.

Функция print тоже была вызвана. Является ли она чистой? Вывод на печать — это побочный эффект, поэтому нет.

Вызов fn2 изменил содержимое external_dict , поэтому второй вызов fn1 дал результат, отличный от первого вызова.

Подумайте, какие значения будут напечатаны?

Ответ можно посмотреть нажав на + справа возле print

Чистые функции гораздо проще понять при чтении кода и гораздо проще отлаживать, поэтому по возможности стоит все функции делать чистыми.

Параметры¶

Наша функция add_two() или, например, type() ожидают, что на вход будут переданы какие-то аргументы для успешной работы, а вот print() можно вызвать и с ними, и с пустыми скобками. В начале лекции был представлен скелет функции, сейчас разберем, что же находится в скобках.

Для начала немного формализма:

• при определении функции в скобках пишутся параметры, которые функция может принять;
• при вызове функции в скобках указываются аргументы, которые задают значения параметров внутри функции.

То есть происходит отображение: аргументы, с которыми вызывается функция \(\Rightarrow\) значения параметров.

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

Позиционные параметры¶

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

Данный тип параметров характеризуется следующим:

• идут первыми после открытых скобок, все именованные строго после них;
• важен порядок: отображение аргументов в параметры будет последовательным;
• при вызове функции все аргументы, которые ожидает функция, должны быть переданы (иначе откуда Python возьмет значения? вот именно!)

Разберем пример, который суммирует два числа:

А что, если количество входных переменных очень большое или вы заранее не знаете, сколько аргументов будет передано при вызове? Например, вам нужно сложить не 2 числа, а 102? В Python есть специальный синтаксис со звездочками. После позиционных аргументов можно указать list , элементами которого станут неограниченное количество переданных позиционных аргументов.

Синтаксис: имя_функции([поз_0, . поз_N,] [*поз_список]): . ; [] в данном случае обозначают необязательность.

Лучше передавать все в списках или векторах (о которых будет позже)

Именованные параметры¶

Данные параметры имеют значения по умолчанию.

Синтаксис: имя_функции([поз_0, . поз_N,] [*поз_список], [им_0=значение_0, . им_K=значение_K], [**им_словарь]): .

• в определении идут строго после позиционных параметров;
• в определении дано значение по умолчанию через = после имени;
• при вызове необязательно указывать значения, тогда будет использовано значение по умолчанию.

Аналогично позиционным аргументам, если необходимо передать множество именованных параметров, используется синтаксис со звездочками, но в данном случае их две, а не одна. Если такой синтаксис использован, все переданные именованные аргументы, кроме определенных явно, попадут в dict , указанный после ** :

Что это за комментарий в тройных кавычках внутри функции?

Это один из общепринятых способов написания docstring — документации по функции.

Списки как значения по умолчанию¶

Рассмотрим следующую функцию:

Второй вызов функции привел к результату, отличающемуся от первого вызова. Почему так произошло? Значение ls по умолчанию мы объявили равным [1] . Оба вызова используют значение по умолчанию. Но при втором вызове в данном случае произошло обращение к тому же списку, который был создан в качестве значения по умолчанию при первом вызове. Как это можно проверить?

В Python определена встроенная функция id. Она возвращает целочисленный идентификатор объекта (уникальный и постоянный, пока объект существует). Используем ее, чтобы посмотреть идентификаторы списков.

Значения идентификаторов могут быть другие. Важно, что в первом, втором и четвертом вызове эти значения одинаковы и отличаются от третьего вызова, у которого значения списка по умолчанию не используется. Такое поведение сохраняется и для пустого списка как значения по умолчанию, и для непустого, как в примере выше.

Одним из решений может быть следующее:

Обратите внимание, что с set -ом ситуация другая.

Анонимные функции¶

Функции, определенные при помощи def , имеют название, по которому их можно вызвать, но также существуют и анонимные или неименованные функции. Такие функции могут быть определены при помощи оператора lambda . Он позволяет задать входные и выходные данные. Самостоятельно можете почитать документацию.

В определении выражение — это возвращаемое значение анонимной функции, например:

В примере выше lambda -функции были только созданы в моменте, но не вызваны. Можно сказать, что мы их определили (как с def ), но не воспользовались и сразу потеряли к ним доступ.

Для удобства можно присвоить объект функции переменной, и по этому имени к ней обращаться:

В отличии от именованной, анонимная функция может иметь только одно выражение.

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

Здесь используется встроенная функция map . Она получает на вход функцию и список элементов, вызывает функцию для каждого элемента, результат такого вызова сохраняет в список и возвращает список результатов. В примере выше на вход подан список из трех элементов и анонимная функция, которая возводит аргумент в квадрат.

А вот пример с отложенными вычислениями:

В данном случае на первой строке вычисления уже определены, но еще не сделаны. И только на второй строке, где происходит вызов, вычисляется выражение из тела lambda -функции. Обратите внимание, что lambda -функция может вовсе не иметь аргументов, как и именованная.

Декораторы¶

Функции в Python являются объектами первого класса. Кроме прочего, это значит, что их можно передавать в другие функции в качестве аргументов, и отдавать в качестве возвращаемых значений. Благодаря этому возможно создавать декораторы. Декоратор — это функция, расширяющая возможности другой функции.

Пример¶

Выше была определена функция many_arg_sum() , давайте засекать, сколько она работает:

Отлично, но можно добавить так называемый : вместо присваивания значения над определением функции можно указать специальный символ @ , после которого указывается название декоратора:

Использование синтаксического сахара с @ и указанием имени декоратора над функцией аналогично вызову

Генераторы¶

Генераторы в Python — это особый класс функций с интересными возможностями. Они позволяют приостанавливать или продолжать работу. Обычные функции вычисляют значение и возвращают его, но генераторы возвращают итератор, который возвращает поток значений и по такому потоку можно проходить пошагово, получая доступ к одному значению с каждой из итераций.

Вот простейший пример функции-генератора:

Любая функция, содержащая ключевое слово yield , является функцией-генератором, это обнаруживается компилятором байт-кода Python, который в результате специально компилирует функцию. Когда вызывается функция-генератор, она не возвращает ни одного значения, вместо этого возвращается объект генератора, который поддерживает протокол итератора.

Инструкция yield ¶

Инструкция yield является частью генератора и заменяет ключевое слово return . Когда программа доходит до yield , то функция переходит в состояние ожидания и продолжает работу с того же места при повторном вызове.

Ниже представлены две функции (генерируют последовательность в обратном порядке), одна с оператором return , а другая функция-генератор с оператором yield . Принимают на вход некое значение n , в примере выше — 5 , и возвращают последовательность чисел от 4 до 0 .

Функция get_subsequence возвращает последовательность в виде списка. Такая функция хранит промежуточное состояние своей работы в виде списка. В примере выше такое состояние хранится в списке result , который и будет возвращён после окончания работы цикла while с помощью оператора return . Список будет возвращён в то место, откуда произошёл вызов функции, при этом важно понимать, что оператор return возвращает не только результат работы функции, но и управление ходом выполнения программы в то место, в котором был произведён вызов функции get_subsequence . При повторном вызове функции get_subsequence генерация чисел происходит заново.

Генератор generate_subsequence на первый взгляд делает тоже самое, генерирует последовательность чисел в обратном порядке, только он такую и происходит это благодаря оператору yield , который не возвращает контроль над ходом выполнения программы в то место, в котором был произведён вызов функции-генератора, а передаёт контроль на время. Для того, чтобы очередной сгенерированный функцией-генератором необходимо использовать встроенную функцию next , таким образом исполнение функции на время приостанавливается, до тех пор, пока снова не будет использована функция next . Локальная переменная внутри генератора неявным образом сохраняет своё состояние.

Eсли генератор вернёт все значения из сгенерированной последовательности и если будет выполнено ещё одно обращение к объекту генератора gen с помощью функции next — будет возвращено исключение StopIteration , как видно на 13-й строке примера выше. Генератор не смог вернуть ещё одно значение поскольку больше таких значений не осталось в сгенерированной последовательности.

Для того, чтобы получить все значения из функции-генератора можно воспользоваться циклом (для примера с помощью спискового включения (list comprehension)), например так:

Главное преимущество генераторов в том, что . По этой причине генераторы удобно использовать при обработке больших последовательностей данных.