Comment vérifier si le type d'une variable est une chaîne?

Existe-t-il un moyen de vérifier si le type d'une variable en python est un string, comme:

isinstance(x,int);

pour les valeurs entières?

En Python 2.x, vous feriez

isinstance(s, basestring)

basestringest la superclasse abstraite de stret unicode. Il peut être utilisé pour tester si un objet est une instance de strou unicode.

Dans Python 3.x, le test correct est

isinstance(s, str)

La bytesclasse n'est pas considérée comme un type de chaîne en Python 3.

Je sais que c'est un vieux sujet, mais étant le premier affiché sur google et étant donné que je ne trouve aucune réponse satisfaisante, je vais laisser ceci ici pour référence future:

six est une bibliothèque de compatibilité Python 2 et 3 qui couvre déjà ce problème. Vous pouvez alors faire quelque chose comme ceci:

import six

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

En inspectant le code, voici ce que vous trouvez:

import sys

PY3 = sys.version_info[0] == 3

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

En Python 3.x ou Python 2.7.6

if type(x) == str:

tu peux faire:

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

ou:

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

J'espère que cela t'aides!

Le module de type existe également si vous vérifiez plus que des entiers et des chaînes. http://docs.python.org/library/types.html

Modifier en fonction d'une meilleure réponse ci-dessous. Descendez environ 3 réponses et découvrez la fraîcheur du basestring.

Ancienne réponse: faites attention aux chaînes unicode, que vous pouvez obtenir à plusieurs endroits, y compris tous les appels COM dans Windows.

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

comme basestringn'est pas défini en Python3, cette petite astuce pourrait aider à rendre le code compatible:

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

après cela, vous pouvez exécuter le test suivant sur Python2 et Python3

isinstance(myvar, basestring)

Python 2/3, y compris 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

Je veux également remarquer que si vous voulez vérifier si le type d'une variable est un type spécifique, vous pouvez comparer le type de la variable au type d'un objet connu.

Pour la chaîne, vous pouvez utiliser ceci

type(s) == type('')

Beaucoup de bonnes suggestions fournies par d'autres ici, mais je ne vois pas un bon résumé multiplateforme. Ce qui suit devrait être une bonne solution pour tout programme 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)

Dans cette fonction, nous utilisons isinstance(object, classinfo)pour voir si notre entrée est stren Python 3 ou basestringen Python 2.

Autre moyen pour Python 2, sans utiliser de chaîne de base:

isinstance(s, (str, unicode))

Mais ne fonctionnera toujours pas en Python 3 car il unicoden'est pas défini (en Python 3).

Donc,

Vous disposez de nombreuses options pour vérifier si votre variable est une chaîne ou non:

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

Cette commande a un but.

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

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

renvoie True

type(a) in [str, unicode]

renvoie True

Voici ma réponse pour prendre en charge Python 2 et Python 3 avec ces exigences:

• Écrit en code Py3 avec un code de compatibilité Py2 minimal.
• Supprimez le code de compatibilité Py2 plus tard sans interruption. C'est-à-dire ne viser que la suppression, pas de modification du code Py3.
• Évitez d'utiliser sixun module compat ou similaire car ils ont tendance à cacher ce qui tente d'être réalisé.
• A l'épreuve du temps pour un potentiel 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 vous ne voulez pas dépendre de bibliothèques externes, cela fonctionne à la fois pour Python 2.7+ et 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");

Vous pouvez simplement utiliser la fonction isinstance pour vous assurer que les données d'entrée sont au format chaîne ou unicode . Les exemples ci-dessous vous aideront à comprendre facilement.

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

Voici comment je le fais:

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

J'ai vu:

hasattr(s, 'endswith') 

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