Должен ли я всегда проверять типы параметров каждой функции?

Question

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

В частности, intTup должен:

• быть кортеж
• быть длиной 3
• содержат только INTS

Так что, как только функция выполняется, те свойства, проверены:

def myFunc(intTup) 
    if type(intTup) is not tuple: 
     print("intTup  = ", intTup) 
     print("type(intTup) = ", type(intTup)) 
     raise Exception('In parameter intTup : should be a tuple of float') 
    elif (len(h) != 3) : 
     print("intTup  = ", intTup) 
     print("len(intTup) = ", len(intTup)) 
     raise Exception('In parameter intTup : should contain three atoms') 
    elif [int]*len(intTup) == map(type,intTup): 
     print("intTup  = ", intTup) 
     print("type(intTup) = ", map(type,intTup)) 
     raise Exception('In parameter h : all atoms should be ints') 
    # Some actual code follow these tests 

Конечно, этот тип проверок часто встречается: в любой момент, когда функция допускает параметр кортежа типа, содержащий n значений типа t, должна выполняться аналогичная проверка. Следовательно, следует ли мне определить функцию checkTuple(tupleToTest, shouldBeLen, shouldBeType) для автоматизации этих проверок? Или я должен оставить, как это? Как вы продвигаетесь в своих сценариях?

Answer 1

№ В Python вы используете «тип утки»: если что-то идет, как утка, шарлатанцы, как утка, и плавает, как утка, это отождествляется с уткой.

Другими словами, с Python мы считаем, что это это то, что вы делаете, что определяет, что вы -.

Это означает, что вы должны полагаться на свойство объекта, а не на его тип. В вашем случае вы просто используете вход так, как предполагается, что используется «3-кортеж, содержащий int s», и обрабатывать исключения.

См. Также: isinstance considered harmful.

Answer 2

Какой смысл использовать язык без проверки статического типа, если вы собираетесь в любом случае реализовать проверку типа выполнения? Ответ на ваш вопрос таков: нет; вы не должны всегда проверять ограничения параметров. Если вы хотите иметь такой контроль, есть лучшие инструменты для работы. Бывают случаи, когда вы можете ввести проверку, например, при принятии ввода от пользователей или внешних процессов, но вы не хотите, чтобы всегда.

Answer 3

Возможно, вам стоит рассмотреть EAFP.

Проще просить прощения, кроме разрешения. Этот общий стиль кодирования Python предполагает наличие допустимых ключей или атрибутов и исключение исключений, если предположение оказывается ложным. Этот чистый и быстрый стиль характеризуется наличием множества попыток и исключений. Техника контрастирует со стилем LBYL, общим для многих других языков, таких как С.

docs

Try для обработки пользовательского ввода, и если он не по какой-либо причине, возбудит исключение. Это не так, как вы обычно это делаете на большинстве других языков, где основное внимание уделяется предотвращению ошибок, но для python обычно используется принцип EAFP.

Другими словами, не проверяйте.

Answer 4

Вы можете сделать декоратор, чтобы проверить, если

 def validate(func): 
     def f(*args, **kwargs): 
      if args[0] is not tuple or len(args[0])! =3: 
       raise Exception("invalid parameter") 
      return func(*args, **kwargs) 
     return f 

Answer 5

Если вы действительно (на самом деле?) Должен разорвать утиную типизацию, можно утверждать справедливость Params следующим образом:

def myFunc(intTup): 
    """intTup is a tuple of size 3""" 
    assert(isinstance(intTup, tuple)), "not a tuple" 
    assert(len(intTup) == 3), "not length 3" 

Легче Спросите прощения, кроме разрешения :)

Вы можете взглянуть на warnings module.