Comment savoir si un objet Python est une chaîne?
Comment puis-je vérifier si un objet Python est une chaîne (standard ou Unicode)?
Pour vérifier si un objet o est un type de chaîne d'une sous-classe d'un type de chaîne:
isinstance(o, basestring)
parce que str et unicode sont tous deux des sous-classes de basestring.
Pour vérifier si le type de o est exactement str:
type(o) is str
Pour vérifier si o est une instance de str ou une sous-classe de str:
isinstance(o, str)
Ce qui précède fonctionne également pour les chaînes Unicode si vous remplacez str par unicode.
Cependant, il se peut que vous n’ayez pas besoin de faire une vérification de type explicite. "Duck Typing" peut répondre à vos besoins. Voir http://docs.python.org/glossary.html#term-duck-typing .
Voir aussi Quel est le moyen canonique de vérifier le type en python?
Python 3
Dans Python 3.x basestring n'est plus disponible, car str est le seul type de chaîne (avec la sémantique de Python 2.x unicode).
Donc, la vérification dans Python 3.x est juste:
isinstance(obj_to_test, str)
Ceci suit le correctif de l'outil de conversion officiel 2to3: convertir basestring en str.
Python 2 et 3
(compatibilité croisée)
Si vous voulez vérifier sans égard pour Python version (2.x vs 3.x), utilisez six ( PyPI ) et son attribut string_types:
import six
if isinstance(obj, six.string_types):
print('obj is a string!')
Dans six (un module très léger à fichier unique), vous ne faites que this :
import sys
PY3 = sys.version_info[0] == 3
if PY3:
string_types = str
else:
string_types = basestring
J'ai trouvé ceci et plus Pythonic:
if type(aObject) is str:
#do your stuff here
pass
comme les objets type sont singleton, is peut être utilisé pour comparer l'objet au type str
Si on veut rester à l'écart de la vérification de type explicite (et qu'il y ait = = = = = = = = = = de bonnes raisons de le rester), la partie la plus sûre du protocole de chaîne à vérifier est:
str(maybe_string) == maybe_string
Il ne parcourra pas un itératif ou un itérateur, n'appellera pas une chaîne de chaînes de listes de chaînes et détectera correctement un stringlike en tant que chaîne.
Bien sûr, il y a des inconvénients. Par exemple, str(maybe_string) peut être un calcul lourd. Comme souvent, la réponse est cela dépend .
Afin de vérifier si votre variable est quelque chose, vous pouvez aller comme ceci:
s='Hello World'
if isinstance(s,str):
#do something here,
La sortie de isistance vous donnera une valeur booléenne Vrai ou Faux afin que vous puissiez ajuster en conséquence. Vous pouvez vérifier l'acronyme attendu de votre valeur en utilisant initialement: type (s) Ceci vous retournera en tapant 'str' afin que vous puissiez l'utiliser dans la fonction isistance.
Je pourrais traiter de cela dans le style de frappe de canard, comme d'autres le mentionnent. Comment puis-je savoir qu'une chaîne est vraiment une chaîne? bien, évidemment par conversion en chaîne!
def myfunc(Word):
Word = unicode(Word)
...
Si l'argument est déjà une chaîne ou un type unicode, real_Word conservera sa valeur non modifiée. Si l'objet passé implémente une méthode __unicode__, il est utilisé pour obtenir sa représentation unicode. Si l'objet transmis ne peut pas être utilisé en tant que chaîne, la fonction intégrée unicode déclenche une exception.
isinstance(your_object, basestring)
sera True si votre objet est bien un type de chaîne. 'str' est réservé Word.
toutes mes excuses, la bonne réponse consiste à utiliser "basestring" au lieu de "str" afin d'inclure également les chaînes unicode - comme indiqué ci-dessus par l'un des autres répondants.
Vous pouvez le tester en concaténant une chaîne vide:
def is_string(s):
try:
s += ''
except:
return False
return True
Edit:
Corriger ma réponse après des commentaires soulignant que cela échoue avec les listes
def is_string(s):
return isinstance(s, basestring)
Ce soir, je suis tombé sur une situation dans laquelle je pensais j'allais devoir vérifier le type str, mais il s'est avéré que je ne l'ai pas fait.
Mon approche de la résolution du problème fonctionnera probablement dans de nombreuses situations. Je la propose donc ci-dessous au cas où d'autres lecteurs de cette question seraient intéressés (uniquement 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
Quelques tests:
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