¿Cómo verificar si el tipo de una variable es una cadena?

¿Hay alguna manera de verificar si el tipo de una variable en python es un string, como:

isinstance(x,int);

para valores enteros?

En Python 2.x, harías

isinstance(s, basestring)

basestringes la superclase abstracta de stry unicode. Se puede usar para probar si un objeto es una instancia de stro unicode.

En Python 3.x, la prueba correcta es

isinstance(s, str)

La bytesclase no se considera un tipo de cadena en Python 3.

Sé que este es un tema antiguo, pero al ser el primero que se muestra en Google y dado que no encuentro ninguna de las respuestas satisfactorias, lo dejaré aquí para referencia futura:

six es una biblioteca de compatibilidad de Python 2 y 3 que ya cubre este problema. Entonces puedes hacer algo como esto:

import six

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

Al inspeccionar el código, esto es lo que encuentra:

import sys

PY3 = sys.version_info[0] == 3

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

En Python 3.xo Python 2.7.6

if type(x) == str:

tu puedes hacer:

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

o:

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

¡espero que esto ayude!

El módulo de tipo también existe si está comprobando más que ints y cadenas. http://docs.python.org/library/types.html

Editar basado en una mejor respuesta a continuación. Baja unas 3 respuestas y descubre la frescura de la cadena base.

Respuesta anterior: tenga cuidado con las cadenas Unicode, que puede obtener desde varios lugares, incluidas todas las llamadas COM en Windows.

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

como basestringno está definido en Python3, este pequeño truco podría ayudar a que el código sea compatible:

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

después de eso, puede ejecutar la siguiente prueba en Python2 y Python3

isinstance(myvar, basestring)

Python 2/3 incluyendo unicode

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

También quiero notar que si desea verificar si el tipo de una variable es un tipo específico, puede comparar el tipo de la variable con el tipo de un objeto conocido.

Para la cadena puedes usar esto

type(s) == type('')

Muchas buenas sugerencias proporcionadas por otros aquí, pero no veo un buen resumen multiplataforma. Lo siguiente debería ser un buen complemento para cualquier programa de 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)

En esta función, usamos isinstance(object, classinfo)para ver si nuestra entrada es a stren Python 3 o a basestringen Python 2.

Forma alternativa para Python 2, sin usar la cadena base:

isinstance(s, (str, unicode))

Pero aún así no funcionará en Python 3 ya unicodeque no está definido (en Python 3).

Entonces,

Tiene muchas opciones para verificar si su variable es cadena o no:

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

Este pedido es para un propósito.

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

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

devuelve True

type(a) in [str, unicode]

devuelve True

Aquí está mi respuesta para admitir Python 2 y Python 3 junto con estos requisitos:

• Escrito en código Py3 con un mínimo código de compatibilidad Py2.
• Elimine el código de compatibilidad Py2 más tarde sin interrupción. Es decir, solo para eliminar, no modificar el código Py3.
• Evite el uso de sixmódulos compatibles o similares, ya que tienden a ocultar lo que se intenta lograr.
• A prueba de futuro para un potencial 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)

Si no desea depender de bibliotecas externas, esto funciona tanto para Python 2.7+ como para 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");

Simplemente puede usar la función isinstance para asegurarse de que los datos de entrada tengan formato de cadena o unicode . Los siguientes ejemplos lo ayudarán a comprender fácilmente.

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

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

Así es como lo hago:

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

He visto:

hasattr(s, 'endswith') 

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