Как проверить, является ли тип переменной строкой?

Есть ли способ проверить, является ли тип переменной в Python строковым. как:

isinstance(x,int);

для целочисленных значений?

Ответ 1

В Python 2.x вы бы сделали

isinstance(s, basestring)

basestring является абстрактным суперклассом str и unicode. Его можно использовать для проверки того, является ли объект экземпляром str или unicode.

В Python 3.x правильный тест

isinstance(s, str)

Класс bytes не считается строковым типом в Python 3.

Ответ 2

Я знаю, что это старая тема, но, будучи первыми, показанными в google, и, учитывая, что я не нахожу ни одного из ответов удовлетворительным, я оставлю это здесь для справки в будущем:

six - это библиотека совместимости Python 2 и 3, которая уже охватывает эту проблему. Затем вы можете сделать что-то вроде этого:

import six

if isinstance(value, six.string_types):
    pass # It a string !!

Проверяя код, это то, что вы найдете:

import sys

PY3 = sys.version_info[0] == 3

if PY3:
    string_types = str,
else:
    string_types = basestring,

Ответ 3

В Python 3.x или Python 2.7.6

if type(x) == str:

Ответ 4

Модуль типа также существует, если вы проверяете больше, чем ints и строки. http://docs.python.org/library/types.html

Ответ 5

вы можете сделать:

var = 1
if type(var) == int:
   print('your variable is an integer')

или

var2 = 'this is variable #2'
if type(var2) == str:
    print('your variable is a string')
else:
    print('your variable IS NOT a string')

надеюсь, что это поможет!

Ответ 6

Изменить на основе лучшего ответа ниже. Спуститесь примерно на 3 ответа и узнайте о прохладе basestring.

Старый ответ: Следите за строками unicode, которые вы можете получить из нескольких мест, включая все COM-вызовы в Windows.

if isinstance(target, str) or isinstance(target, unicode):

Ответ 7

поскольку basestring не определен в Python3, этот небольшой трюк может помочь сделать код совместимым:

try: # check whether python knows about 'basestring'
   basestring
except NameError: # no, it doesn't (it Python3); use 'str' instead
   basestring=str

после этого вы можете запустить следующий тест как на Python2, так и на Python3

isinstance(myvar, basestring)

Ответ 8

Python 2/3, включая Юникод

from __future__ import unicode_literals
from builtins import str  #  pip install future
isinstance('asdf', str)   #  True
isinstance(u'asdf', str)  #  True

http://python-future.org/overview.html

Ответ 9

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

def isstring(s):
    # if we use Python 3
    if (sys.version_info[0] >= 3):
        return isinstance(s, str)
    # we use Python 2
    return isinstance(s, basestring)

В этой функции мы используем isinstance(object, classinfo), чтобы увидеть, является ли наш вход str в Python 3 или basestring в Python 2.

Ответ 10

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

Для строки вы можете использовать этот

type(s) == type('')

Ответ 11

Итак,

У вас есть много вариантов проверки, является ли ваша переменная строкой или нет:

a = "my string"
type(a) == str # first 
a.__class__ == str # second
isinstance(a, str) # third
str(a) == a # forth
type(a) == type('') # fifth

Этот порядок предназначен для цели.

Ответ 12

Альтернативный способ для Python 2 без использования basestring:

isinstance(s, (str, unicode))

Но все еще не будет работать в Python 3, поскольку unicode не определен (в Python 3).

Ответ 13

a = '1000' # also tested for 'abc100', 'a100bc', '100abc'

isinstance(a, str) or isinstance(a, unicode)

возвращает True

type(a) in [str, unicode]

возвращает True

Ответ 14

Вот мой ответ для поддержки Python 2 и Python 3 вместе с этими требованиями:

Написано в коде Py3 с минимальным кодом совместимости Py2.
Удалить код совместимости Py2 позже без сбоев. То есть только для удаления, без изменения кода Py3.
Избегайте использования six или аналогичного модуля совместимости, поскольку они, как правило, скрывают, что пытается достичь.
Будущее для потенциального Py4.

import sys
PY2 = sys.version_info.major == 2

# Check if string (lenient for byte-strings on Py2):
isinstance('abc', basestring if PY2 else str)

# Check if strictly a string (unicode-string):
isinstance('abc', unicode if PY2 else str)

# Check if either string (unicode-string) or byte-string:
isinstance('abc', basestring if PY2 else (str, bytes))

# Check for byte-string (Py3 and Py2.7):
isinstance('abc', bytes)

Ответ 15

Чтобы проверить, является ли myvar строкой, также можно использовать это:

if type(myvar) == str

Ответ 16

Если вы не хотите зависеть от внешних lib, это работает как для Python 2.7+, так и для Python 3 (http://ideone.com/uB4Kdc):

# your code goes here
s = ["test"];
#s = "test";
isString = False;

if(isinstance(s, str)):
    isString = True;
try:
    if(isinstance(s, basestring)):
        isString = True;
except NameError:
    pass;

if(isString):
    print("String");
else:
    print("Not String");

Ответ 17

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

>>> isinstance('my string', str)
True
>>> isinstance(12, str)
False
>>> isinstance('my string', unicode)
False
>>> isinstance(u'my string',  unicode)
True

Ответ 18

Преобразование в строку и тестирование с помощью isdigit()

>>> not str('baba').isdigit()
True
>>> not str(123).isdigit()
False

Ответ 19

varA = "hey"
if type(varA) == str:
   print "it is a string"

Ответ 20

s = '123'
issubclass(s.__class__, str)

Ответ 21

Чтобы проверить, является ли myvar строкой, используйте это:

if type(myvar) == type('abc')

Ответ 22

Вот как я это делаю:

if type(x) == type(str()):

Ответ 23

Я видел:

hasattr(s, 'endswith')

Ответ 24

>>> thing = 'foo'
>>> type(thing).__name__ == 'str' or type(thing).__name__ == 'unicode'
True