¿Cómo puedo verificar si un objeto Python es una cadena (ya sea regular o Unicode)?

Python 2

Úselo isinstance(obj, basestring)para un objeto a prueba obj.

Doc .

Python 2

Para verificar si un objeto oes un tipo de cadena de una subclase de un tipo de cadena:

isinstance(o, basestring)

porque ambos stry unicodeson subclases de basestring.

Para verificar si el tipo de oes exactamente str:

type(o) is str

Para verificar si oes una instancia stro alguna subclase de str:

isinstance(o, str)

Lo anterior también funciona para cadenas Unicode si lo reemplaza strcon unicode.

Sin embargo, es posible que no necesite hacer una verificación de tipo explícita en absoluto. "Escribir pato" puede satisfacer sus necesidades. Ver http://docs.python.org/glossary.html#term-duck-typing .

Consulte también ¿Cuál es la forma canónica de verificar el tipo en Python?

Python 3

En Python 3.x basestringya no está disponible, al igual strque el único tipo de cadena (con la semántica de Python 2.x unicode).

Entonces, la comprobación en Python 3.x es solo:

isinstance(obj_to_test, str)

Esto sigue la solución de la 2to3herramienta de conversión oficial : la conversión basestringa str.

Python 2 y 3

(compatible con la cruz)

Si desea verificar sin tener en cuenta la versión de Python (2.x vs 3.x), use six( PyPI ) y su string_typesatributo:

import six

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

Dentro de six(un módulo de un solo archivo muy ligero), simplemente está haciendo esto :

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

if PY3:
    string_types = str
else:
    string_types = basestring

Encontré esto y más pythonic:

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

dado que los objetos de tipo son singleton, se puede usar para comparar el objeto con el tipo str

Si uno quiere mantenerse alejado de explícita el tipo de comprobación (y no son probablemente la parte buenas razones para permanecer lejos de ella), más segura del protocolo cadena a cheque es:

str(maybe_string) == maybe_string

No iterará a través de un iterador o iterador, no llamará a una lista de cadenas una cadena y detecta correctamente una cadena como una cadena.

Por supuesto que hay inconvenientes. Por ejemplo, str(maybe_string)puede ser un cálculo pesado. Como tantas veces, la respuesta es que depende .

EDITAR: como @Tcll señala en los comentarios, la pregunta realmente pide una forma de detectar tanto cadenas unicode como cadenas de bytes. En Python 2, esta respuesta fallará con una excepción para las cadenas unicode que contienen caracteres no ASCII, y en Python 3 devolverá Falsetodas las cadenas de bytes.

Para verificar si su variable es algo que podría usar:

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

La salida de isistance le dará un valor booleano verdadero o falso para que pueda ajustar en consecuencia. Puede verificar el acrónimo esperado de su valor usando inicialmente: tipo (s) Esto le devolverá el tipo 'str' para que pueda usarlo en la función de resistencia.

Podría lidiar con esto en el estilo de escritura de pato, como mencionan otros. ¿Cómo sé que una cadena es realmente una cadena? bueno, obviamente al convertirlo en una cadena!

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

Si el argumento ya es una cadena o un tipo unicode, real_word mantendrá su valor sin modificar. Si el objeto pasado implementa un __unicode__método, que se utiliza para obtener su representación unicode. Si el objeto pasado no se puede usar como una cadena, el valor unicodeincorporado genera una excepción.

isinstance(your_object, basestring)

será True si su objeto es realmente un tipo de cadena. 'str' es una palabra reservada.

Mis disculpas, la respuesta correcta es usar 'basetring' en lugar de 'str' para que también incluya cadenas unicode, como se señaló anteriormente por uno de los otros respondedores.

Esta tarde me encontré con una situación en la que pensé que iba a tener que verificar el strtipo, pero resultó que no.

Mi enfoque para resolver el problema probablemente funcionará en muchas situaciones, por lo que lo ofrezco a continuación en caso de que otras personas que lean esta pregunta estén interesadas (solo 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

Algunas pruebas:

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

Es simple, use el siguiente código (asumimos que el objeto mencionado es obj):

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

Puede probarlo concatenando con una cadena vacía:

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

Editar :

Corregir mi respuesta después de comentarios que señalan que esto falla con las listas

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

Para un buen enfoque de tipeo de pato para me gusta de cadenas que tiene la ventaja de trabajar con Python 2.xy 3.x:

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

wisefish estaba cerca del tipeo de patos antes de cambiar al isinstanceenfoque, excepto que +=tiene un significado diferente para las listas que el que +tiene.

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

de EDX - curso en línea MITx: 6.00.1x Introducción a la informática y programación usando Python