Почему функции всегда должны возвращать один и тот же тип?
Когда вы объявляете ссылочную переменную (т. е. объект), вы действительно создаете указатель на объект. Рассмотрим следующий код, в котором вы объявляете переменную примитивного типа int:
int x;
x = 10;
В этом примере переменная x является int, и Java инициализирует ее для 0. Когда вы назначаете его 10 во второй строке, ваше значение 10 записывается в ячейку памяти, на которую указывает x.
Но когда вы пытаетесь объявить ссылочный тип, произойдет что-то другое. Возьмите следующий код:
Integer num;
num = new Integer(10);
Первая строка объявляет переменную с именем num, но она не содержит примитивного значения. Вместо этого он содержит указатель (потому что тип Integer является ссылочным типом). Поскольку вы еще не указали, что указать на Java, он устанавливает значение null, что означает «Я ничего не указываю».
Во второй строке ключевое слово new используется для создания экземпляра (или создания ) объекту типа Integer и переменной указателя num присваивается этот объект. Теперь вы можете ссылаться на объект, используя оператор разыменования . (точка).
Exception, о котором вы просили, возникает, когда вы объявляете переменную, но не создавали объект. Если вы попытаетесь разыменовать num. Перед созданием объекта вы получите NullPointerException. В самых тривиальных случаях компилятор поймает проблему и сообщит вам, что «num не может быть инициализирован», но иногда вы пишете код, который непосредственно не создает объект.
Например, вы можете имеют следующий метод:
public void doSomething(SomeObject obj) {
//do something to obj
}
В этом случае вы не создаете объект obj, скорее предполагая, что он был создан до вызова метода doSomething. К сожалению, этот метод можно вызвать следующим образом:
doSomething(null);
В этом случае obj имеет значение null. Если метод предназначен для того, чтобы что-то сделать для переданного объекта, целесообразно бросить NullPointerException, потому что это ошибка программиста, и программисту понадобится эта информация для целей отладки.
Альтернативно, там могут быть случаи, когда цель метода заключается не только в том, чтобы работать с переданным в объекте, и поэтому нулевой параметр может быть приемлемым. В этом случае вам нужно будет проверить нулевой параметр и вести себя по-другому. Вы также должны объяснить это в документации. Например, doSomething может быть записано как:
/**
* @param obj An optional foo for ____. May be null, in which case
* the result will be ____.
*/
public void doSomething(SomeObject obj) {
if(obj != null) {
//do something
} else {
//do something else
}
}
Наконец, Как определить исключение & amp; причина использования Трассировки стека
6 ответов
Почему функции должны возвращать значения согласованного типа? Чтобы соответствовать следующим двум правилам.
Правило 1 - функция имеет «тип» - входы отображаются на выходы. Он должен возвращать согласованный тип результата, иначе это не функция. Это беспорядок.
Математически мы говорим, что некоторая функция F является отображением домена D в диапазон R. F: D -> R . Домен и диапазон образуют «тип» функции. Типы ввода и тип результата так же важны для определения функции, как и имя или тело.
Правило 2 - когда у вас «проблема» или вы не можете вернуть правильный результат, вызовите исключение. .
def x(foo):
if 'bar' in foo:
return (foo, 'bar')
raise Exception( "oh, dear me." )
Вы можете нарушить вышеуказанные правила, но стоимость долговременной ремонтопригодности и понятности астрономическая.
«Разве не было бы дешевле памяти вернуть None?» Неправильный вопрос.
Дело в , а не в оптимизации памяти за счет ясного, читаемого, очевидного кода.
Не так ясно, что функция всегда должна возвращать объекты ограниченного типа или что возвращать None неправильно. Например, re.search может вернуть объект _sre.SRE_Match или объект NoneType :
import re
match=re.search('a','a')
type(match)
# <type '_sre.SRE_Match'>
match=re.search('a','b')
type(match)
# <type 'NoneType'>
Разработанный таким образом, вы можете проверить соответствие с идиомой
if match:
# do xyz
Если разработчики потребовали, чтобы re.search возвращал объект _sre.SRE_Match , затем
идиома должна быть изменена на
if match.group(1) is None:
# do xyz
. Требование, чтобы re.search всегда возвращал объект _sre.SRE_Match , не принесло бы большой пользы.
Так что я думаю, что от того, как вы создадите функцию, должно зависеть о ситуации и, в частности, о том, как вы планируете использовать функцию.
Также обратите внимание, что оба _sre.SRE_Match и NoneType являются экземплярами объекта, поэтому в широком смысле они однотипны. Так что правило «функции всегда должны возвращать только один тип» довольно бессмысленно.
Сказав это, есть прекрасная простота функций, которые возвращают объекты, которые все имеют одинаковые свойства. (Утиная типизация, а не статическая типизация - это способ Python!) Он может позволить вам объединять функции: foo (bar (baz))) и с уверенностью знать тип объекта, который вы получите на другом конце.
Это может помочь вам проверить правильность вашего кода. Требуя, чтобы функция возвращала только объекты определенного ограниченного типа, меньше случаев для проверки. "foo всегда возвращает целое число, так что пока целое число ожидается везде, где я использую foo, я золотой ..."
Лучшая практика в том, что Функция, которая должна возвращать, сильно различается от языка к языку и даже между разными проектами Python.
В целом для Python я согласен с предположением, что возвращать None - это плохо, если ваша функция обычно возвращает итерацию, потому что итерация без тестирования становится невозможной. В этом случае просто верните пустую итерацию,
Если x вызывается так, то
foo, bar = x(foo)
возврат None приведет к
TypeError: 'NoneType' object is not iterable
if 'bar' отсутствует в foo .
Пример
def x(foo):
if 'bar' in foo:
return (foo, 'bar')
return None
foo, bar = x(["foo", "bar", "baz"])
print foo, bar
foo, bar = x(["foo", "NOT THERE", "baz"])
print foo, bar
Это приводит к:
['foo', 'bar', 'baz'] bar
Traceback (most recent call last):
File "f.py", line 9, in <module>
foo, bar = x(["foo", "NOT THERE", "baz"])
TypeError: 'NoneType' object is not iterable
Я лично считаю, что для функции совершенно нормально возвращать кортеж или None. Однако функция должна возвращать не более двух разных типов, а второй должен быть None. Например, функция никогда не должна возвращать строку и список.
Преждевременная оптимизация - корень всех зол. Незначительный прирост эффективности может быть важен, но не раньше, чем вы докажете, что он вам нужен.
Независимо от вашего языка: функция определяется один раз, но имеет тенденцию использоваться в любом количестве мест. Наличие согласованного типа возвращаемого значения (не говоря уже о задокументированных предварительных и постусловиях) означает, что вам придется потратить больше усилий на определение функции, но вы значительно упростите использование функции. Угадайте, перевешивают ли единовременные затраты повторную экономию ...?