isinstance(n, int)

Если вам нужно знать, действительно ли это действительно тип int, а не подкласс int (как правило, этого делать не нужно):

type(n) is int

это:

return int(n) == n

не такая уж хорошая идея, поскольку сравнения перекрестных типов могут быть правдой, особенно int(3.0)==3.0

Да, как сказал Эван, не проверяйте типаж. Просто попробуйте использовать значение:

def myintfunction(value):
   """ Please pass an integer """
   return 2 + value

Здесь нет проверки типов. Это намного лучше! Посмотрим, что будет, когда я попробую:

>>> myintfunction(5)
7

Это работает, потому что это целое число. Хм. Давайте попробуем текст.

>>> myintfunction('text')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in myintfunction
TypeError: unsupported operand type(s) for +: 'int' and 'str'

Он показывает ошибку TypeError, что он должен делать в любом случае. Если вызывающий хочет это поймать, это возможно.

Что бы вы сделали, если бы проверили тип? Показывать ошибку верно? Таким образом, вам не нужно выполнять проверку типов, потому что ошибка уже появляется автоматически.

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

Поплавки:

>>> print myintfunction(2.2)
4.2

Комплексные числа:

>>> print myintfunction(5j)
(2+5j)

Десятичные дроби:

>>> import decimal
>>> myintfunction(decimal.Decimal('15'))
Decimal("17")

Даже совершенно произвольные объекты, умеющие складывать числа!

>>> class MyAdderClass(object):
...     def __radd__(self, value):
...             print 'got some value: ', value
...             return 25
... 
>>> m = MyAdderClass()
>>> print myintfunction(m)
got some value:  2
25

Таким образом, вы явно ничего не получите от проверки типов. И много потеряешь.

ОБНОВИТЬ:

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

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

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

def myintfunction(value):
   """ Please pass an integer """
   return upstreamfunction(int(value))

Вы по-прежнему не проверяете типы, поэтому вы получаете максимальную пользу от отказа от проверки типов.

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

assert isinstance(...)
assert type() is xxxx

Таким образом, мы можем отключить asserts и удалить эту <sarcasm> функцию </sarcasm> из программы, вызвав ее как

python -OO program.py

Python теперь поддерживает постепенный ввод через модуль ввода и mypy . Модуль typing является частью stdlib начиная с Python 3.5 и может быть загружен из PyPi, если вам нужны резервные копии для Python 2 или предыдущей версии Python 3. Вы можете установить mypy, запустив pip install mypy из командной строки.

Короче говоря, если вы хотите убедиться, что какая-то функция принимает int, float и возвращает строку, вы должны аннотировать свою функцию следующим образом:

def foo(param1: int, param2: float) -> str:
    return "testing {0} {1}".format(param1, param2)

Если ваш файл был назван test.py, вы можете проверить тип после установки mypy, запустив mypy test.py из командной строки.

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

def foo(param1, param2):
    # type: (int, float) -> str
    return "testing {0} {1}".format(param1, param2)

Вы используете ту же команду mypy test.py для файлов Python 3 и mypy --py2 test.py для файлов Python 2.

Аннотации типов полностью игнорируются интерпретатором Python во время выполнения, поэтому накладные расходы минимальны или вообще отсутствуют - обычный рабочий процесс заключается в работе над кодом и периодическом запуске mypy для выявления ошибок и ошибок. Некоторые IDE, такие как PyCharm, понимают подсказки типов и могут предупреждать вас о проблемах и несоответствиях типов в вашем коде во время непосредственного редактирования.

Если по какой-то причине вам нужно, чтобы типы проверялись во время выполнения (возможно, вам нужно проверить большой ввод?), Вы должны следовать советам, указанным в других ответах, например используйте isinstance, issubclass и т.п. Есть также некоторые библиотеки, такие как enforce, которые пытаются выполнить проверку типов (с учетом аннотаций вашего типа) во время выполнения, хотя я не уверен, насколько они готовы к производству на момент написания.

Дополнительную информацию и подробности см. На веб-сайте mypy, mypy FAQ и PEP 484.

if type(n) is int

Это проверяет, является ли n Python int и только int. Он не принимает подклассы int.

Однако проверка типов не соответствует «пути Python». Вам лучше использовать n как int, и если он вызывает исключение, поймайте его и действуйте в соответствии с ним.

Не набирайте чек. Вся суть утиного набора текста в том, что вам не нужно этого делать. Например, что, если бы кто-то сделал что-то вроде этого:

class MyInt(int):
    # ... extra stuff ...

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

Из интерактивной командной строки вы можете запустить такую ​​инструкцию:

int('sometext')

Это вызовет ошибку - ipython сообщает мне:

<type 'exceptions.ValueError'>: invalid literal for int() with base 10: 'sometext'

Теперь вы можете написать такой код:

try:
   int(myvar) + 50
except ValueError:
   print "Not a number"

Его можно настроить для выполнения любых необходимых операций И ​​для обнаружения любых ожидаемых ошибок. Он выглядит немного запутанным, но соответствует синтаксису и идиомам Python и дает очень читаемый код (как только вы привыкнете говорить на Python).

Я бы хотел что-то вроде:

def check_and_convert(x):
    x = int(x)
    assert 0 <= x <= 255, "must be between 0 and 255 (inclusive)"
    return x

class IPv4(object):
    """IPv4 CIDR prefixes is A.B.C.D/E where A-D are 
       integers in the range 0-255, and E is an int 
       in the range 0-32."""

    def __init__(self, a, b, c, d, e=0):
        self.a = check_and_convert(a)
        self.b = check_and_convert(a)
        self.c = check_and_convert(a)
        self.d = check_and_convert(a)
        assert 0 <= x <= 32, "must be between 0 and 32 (inclusive)"
        self.e = int(e)

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

как насчет:

def ip(string):
    subs = string.split('.')
    if len(subs) != 4:
        raise ValueError("incorrect input")
    out = tuple(int(v) for v in subs if 0 <= int(v) <= 255)
    if len(out) != 4:
        raise ValueError("incorrect input")
    return out

конечно, есть стандартная функция isinstance (3, int) ...

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

assert(type(X) == int(0))

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