¿Cómo saber si un objeto Python es una cadena?

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

Python 2

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

Docs .

Para verificar si un objeto o es un tipo de cadena de una subclase de un tipo de cadena:

 isinstance(o, basestring) 

porque tanto str como unicode son subclases de basestring .

Para comprobar si el tipo de o es exactamente str :

 type(o) is str 

Para verificar si o es una instancia de str o cualquier subclase de str :

 isinstance(o, str) 

Lo anterior también funciona para cadenas Unicode si reemplaza str con unicode .

Sin embargo, es posible que no necesite realizar una comprobación explícita de tipos. “Escribir pato” puede adaptarse a sus necesidades. Consulte 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 basestring no está disponible la str , ya que str es el único tipo de cadena (con la semántica de unicode de Python 2.x).

Así que el cheque en Python 3.x es solo:

 isinstance(obj_to_test, str) 

Esto sigue la corrección de la herramienta de conversión oficial 2to3 : convertir basestring a str .

Python 2 y 3

(compatibilidad cruzada)

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

 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 

Para verificar si tu variable es algo que podrías hacer como:

 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 isistancia.

Si uno quiere mantenerse alejado de la comprobación explícita de tipos (y existen buenas razones para evitarlo), probablemente la parte más segura del protocolo de cadena es:

 str(maybe_string) == maybe_string 

No itera a través de un iterable o iterador, no llama a una lista de cadenas una cadena y detecta correctamente una cadena como una cadena.

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

Encontré esto y más pythonic :

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

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

Podría tratar esto en el estilo de escritura de pato, como mencionan otros. ¿Cómo sé que una cadena es realmente una cadena? Bueno, obviamente convirtiéndolo en una cadena!

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

Si el argumento ya es un tipo de cadena o Unicode, real_word mantendrá su valor sin modificar. Si el objeto pasado implementa un método __unicode__ , se usa para obtener su representación Unicode. Si el objeto pasado no se puede usar como una cadena, el builtin de unicode genera una excepción.

 isinstance(your_object, basestring) 

será verdadero si su objeto es de hecho un tipo de cadena. ‘str’ es una palabra reservada.

Mis disculpas, la respuesta correcta es usar ‘basestring’ en lugar de ‘str’ para incluir también cadenas Unicode, como se señaló anteriormente en uno de los otros respondedores.

Puedes probarlo concatenando con una cadena vacía:

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

Editar :

Corrigiendo mi respuesta después de comentarios señalando que esto falla con las listas.

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

Esta noche me encontré con una situación en la que pensé que iba a tener que comparar con el tipo de str , pero resultó que no lo hice.

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

Para un buen enfoque de escritura de pato para los me gusta de las cuerdas que tiene la ventaja de trabajar con Python 2.xy 3.x:

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

sabio estaba cerca con la tipificación de pato antes de cambiar al enfoque de isinstance , excepto que += tiene un significado diferente para las listas que + .

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

de EDX – curso en línea MITx: 6.00.1x Introducción a Informática y Progtwigción utilizando Python