Come verificare se il tipo di una variabile è stringa?

C'è un modo per verificare se il tipo di una variabile in Python è un string, come:

isinstance(x,int);

per valori interi?

In Python 2.x, lo faresti

isinstance(s, basestring)

basestringè la superclasse astratta di stre unicode. Può essere utilizzato per verificare se un oggetto è un'istanza di stro unicode.

In Python 3.x, il test corretto è

isinstance(s, str)

La bytesclasse non è considerata un tipo di stringa in Python 3.

So che questo è un vecchio argomento, ma essendo il primo mostrato su Google e dato che non trovo nessuna delle risposte soddisfacenti, lo lascerò qui per riferimento futuro:

six è una libreria di compatibilità Python 2 e 3 che già tratta questo problema. È quindi possibile fare qualcosa del genere:

import six

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

Ispezionando il codice, ecco cosa trovi:

import sys

PY3 = sys.version_info[0] == 3

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

In Python 3.xo Python 2.7.6

if type(x) == str:

tu puoi fare:

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')

spero che sia di aiuto!

Il modulo del tipo esiste anche se stai controllando più di ints e stringhe. http://docs.python.org/library/types.html

Modifica in base alla risposta migliore di seguito. Scorri verso il basso circa 3 risposte e scopri la bellezza del basestring.

Vecchia risposta: fai attenzione alle stringhe unicode, che puoi ottenere da diverse posizioni, comprese tutte le chiamate COM in Windows.

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

poiché basestringnon è definito in Python3, questo piccolo trucco potrebbe aiutare a rendere compatibile il codice:

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

successivamente è possibile eseguire il seguente test su Python2 e Python3

isinstance(myvar, basestring)

Python 2/3 incluso 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

Inoltre voglio notare che se si desidera verificare se il tipo di una variabile è un tipo specifico, è possibile confrontare il tipo di variabile con il tipo di un oggetto noto.

Per la stringa puoi usare questo

type(s) == type('')

Molti buoni suggerimenti forniti da altri qui, ma non vedo un buon riepilogo multipiattaforma. Quanto segue dovrebbe essere una buona risposta per qualsiasi programma 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)

In questa funzione, usiamo isinstance(object, classinfo)per vedere se il nostro input è strin in Python 3 o basestringin in Python 2.

Modo alternativo per Python 2, senza usare il basestring:

isinstance(s, (str, unicode))

Ma non funzionerà ancora in Python 3 poiché unicodenon è definito (in Python 3).

Così,

Hai molte opzioni per verificare se la tua variabile è stringa 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

Questo ordine è a scopo.

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

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

restituisce True

type(a) in [str, unicode]

restituisce True

Ecco la mia risposta per supportare sia Python 2 che Python 3 insieme a questi requisiti:

• Scritto in codice Py3 con codice Py2 minimo compatibile.
• Rimuovere il codice compatibile Py2 in un secondo momento senza interruzioni. Vale a dire solo per la cancellazione, nessuna modifica al codice Py3.
• Evita di utilizzare sixun modulo compatibile simile poiché tende a nascondere ciò che sta cercando di ottenere.
• A prova di futuro per un potenziale 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)

Se non si desidera dipendere da librerie esterne, questo funziona sia per Python 2.7+ che per 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");

È possibile semplicemente utilizzare la funzione isinstance per assicurarsi che i dati di input siano in formato stringa o unicode . Gli esempi seguenti ti aiuteranno a capire facilmente.

>>> 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)

Ecco come lo faccio:

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

Ho visto:

hasattr(s, 'endswith') 

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