Como posso verificar se um objeto Python é uma string (regular ou Unicode)?

Python 2

Use isinstance(obj, basestring)para um objeto a testar obj.

Docs .

Python 2

Para verificar se um objeto oé um tipo de string de uma subclasse de um tipo de string:

isinstance(o, basestring)

porque ambos stre unicodesão subclasses de basestring.

Para verificar se o tipo de oé exatamente str:

type(o) is str

Para verificar se oé uma instância strou qualquer subclasse de str:

isinstance(o, str)

O exemplo acima também funciona para cadeias de caracteres Unicode, se você substituir strpor unicode.

No entanto, talvez você não precise fazer nenhuma verificação explícita de tipo. A "digitação do pato" pode atender às suas necessidades. Veja http://docs.python.org/glossary.html#term-duck-typing .

Consulte também Qual é a maneira canônica de verificar o tipo em python?

Python 3

No Python 3.x, basestringnão está mais disponível, como stré o único tipo de string (com a semântica do Python 2.x unicode).

Portanto, a verificação no Python 3.x é apenas:

isinstance(obj_to_test, str)

Isso segue a correção da 2to3ferramenta de conversão oficial : converter basestringpara str.

Python 2 e 3

(compatível com outras versões)

Se você deseja verificar sem considerar a versão do Python (2.x vs 3.x), use six( PyPI ) e seu string_typesatributo:

import six

if isinstance(obj, six.string_types):
    print('obj is a string!')

Dentro six(um módulo de arquivo único muito leve), basta fazer o seguinte :

import sys
PY3 = sys.version_info[0] == 3

if PY3:
    string_types = str
else:
    string_types = basestring

Encontrei isso e mais pythonic:

if type(aObject) is str:
    #do your stuff here
    pass

desde que os objetos de tipo são Singleton, é pode ser usado para fazer a comparar o objeto para o tipo str

Se alguém quiser ficar longe explícita (e não de verificação de tipo são , provavelmente, a parte mais segura boas razões para ficar longe dele) do protocolo de string para verificação é:

str(maybe_string) == maybe_string

Ele não itera através de um iterável ou iterador, não chama uma lista de cadeias de caracteres como uma string e detecta corretamente uma string como uma string.

Claro que existem desvantagens. Por exemplo, str(maybe_string)pode ser um cálculo pesado. Como tantas vezes, a resposta é que depende .

EDIT: Como o @Tcll aponta nos comentários, a pergunta realmente pede uma maneira de detectar cadeias unicode e bytestrings. No Python 2, esta resposta falhará, com uma exceção para cadeias unicode que contêm caracteres não ASCII, e no Python 3 retornará Falsepara todas as cadeias de bytes.

Para verificar se sua variável é algo que você pode usar:

s='Hello World'
if isinstance(s,str):
#do something here,

A saída de isistance fornecerá um valor booleano True ou False, para que você possa ajustar adequadamente. Você pode verificar o acrônimo esperado do seu valor usando inicialmente: type (s) Isso retornará o tipo 'str' para que você possa usá-lo na função isistance.

Eu posso lidar com isso no estilo de digitação de pato, como outros mencionam. Como sei que uma string é realmente uma string? bem, obviamente, convertendo -o em uma string!

def myfunc(word):
    word = unicode(word)
    ...

Se o arg já for um tipo de cadeia ou unicode, real_word manterá seu valor não modificado. Se o objeto transmitido implementa um __unicode__método, isso é usado para obter sua representação unicode. Se o objeto passado não puder ser usado como uma sequência, o unicodebuiltin gerará uma exceção.

isinstance(your_object, basestring)

será True se o seu objeto for realmente um tipo de string. 'str' é uma palavra reservada.

minhas desculpas, a resposta correta é usar 'basestring' em vez de 'str' para incluir também strings unicode - como observado acima por um dos outros respondedores.

Naquela noite, me deparei com uma situação em que achava que precisaria checar o strtipo, mas acabou que não.

Minha abordagem para resolver o problema provavelmente funcionará em muitas situações, por isso ofereço-o abaixo caso outras pessoas que estejam lendo esta questão estejam interessadas (somente Python 3).

# NOTE: fields is an object that COULD be any number of things, including:
# - a single string-like object
# - a string-like object that needs to be converted to a sequence of 
# string-like objects at some separator, sep
# - a sequence of string-like objects
def getfields(*fields, sep=' ', validator=lambda f: True):
    '''Take a field sequence definition and yield from a validated
     field sequence. Accepts a string, a string with separators, 
     or a sequence of strings'''
    if fields:
        try:
            # single unpack in the case of a single argument
            fieldseq, = fields
            try:
                # convert to string sequence if string
                fieldseq = fieldseq.split(sep)
            except AttributeError:
                # not a string; assume other iterable
                pass
        except ValueError:
            # not a single argument and not a string
            fieldseq = fields
        invalid_fields = [field for field in fieldseq if not validator(field)]
        if invalid_fields:
            raise ValueError('One or more field names is invalid:\n'
                             '{!r}'.format(invalid_fields))
    else:
        raise ValueError('No fields were provided')
    try:
        yield from fieldseq
    except TypeError as e:
        raise ValueError('Single field argument must be a string'
                         'or an interable') from e

Alguns testes:

from . import getfields

def test_getfields_novalidation():
    result = ['a', 'b']
    assert list(getfields('a b')) == result
    assert list(getfields('a,b', sep=',')) == result
    assert list(getfields('a', 'b')) == result
    assert list(getfields(['a', 'b'])) == result

É simples, use o seguinte código (assumimos que o objeto mencionado seja obj) -

if type(obj) == str:
    print('It is a string')
else:
    print('It is not a string.')

Você pode testá-lo concatenando com uma sequência vazia:

def is_string(s):
  try:
    s += ''
  except:
    return False
  return True

Editar :

Corrigindo minha resposta após comentários apontando que isso falha nas listas

def is_string(s):
  return isinstance(s, basestring)

Para uma boa abordagem de digitação de pato para curtidas de string que tem o bônus de trabalhar com o Python 2.xe 3.x:

def is_string(obj):
    try:
        obj + ''
        return True
    except TypeError:
        return False

o wisefish estava próximo da digitação do pato antes de mudar para a isinstanceabordagem, exceto que ele +=tem um significado diferente para as listas +.

if type(varA) == str or type(varB) == str:
    print 'string involved'

from EDX - curso online MITx: 6.00.1x Introdução à ciência da computação e programação usando Python