Comment puis-je vérifier si un objet Python est une chaîne (régulière ou Unicode)?
Comment puis-je vérifier si un objet Python est une chaîne (régulière ou Unicode)?
Réponses:
Pour vérifier si un objet o
est un type chaîne d'une sous-classe d'un type chaîne:
isinstance(o, basestring)
parce que les deux str
et unicode
sont des sous-classes de basestring
.
Pour vérifier si le type de o
est exactement str
:
type(o) is str
Pour vérifier s'il o
s'agit d'une instance str
ou d'une sous-classe de str
:
isinstance(o, str)
Les éléments ci-dessus fonctionnent également pour les chaînes Unicode si vous les remplacez str
par unicode
.
Cependant, vous n'aurez peut-être pas du tout besoin d'effectuer 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 Quelle est la manière canonique de vérifier le type en python?
basestring
dans py2.
En Python 3.x basestring
n'est plus disponible, tout comme str
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)
Cela suit le correctif de l' 2to3
outil de conversion officiel : conversion basestring
en str
.
Si vous souhaitez vérifier sans tenir compte de la version Python (2.x vs 3.x), utilisez six
( PyPI ) et son string_types
attribut:
import six
if isinstance(obj, six.string_types):
print('obj is a string!')
Dans six
(un module à fichier unique très léger), il fait simplement ceci :
import sys
PY3 = sys.version_info[0] == 3
if PY3:
string_types = str
else:
string_types = basestring
future
( PyPI ) pour conserver même le nom:from past.builtins import basestring
basestring
, puis retombez str
. Par exempledef is_string(obj): try: return isinstance(obj, basestring) # python 2 except NameError: return isinstance(obj, str) # python 3
J'ai trouvé cela et plus encore pythonic
:
if type(aObject) is str:
#do your stuff here
pass
puisque les objets type sont singleton, is peut être utilisé pour comparer l'objet au type str
isinstance(obj_to_test, str)
est évidemment destiné à tester pour le type, et il a l'avantage d'utiliser la même procédure que pour les autres cas, non str.
Si l'on veut éviter la vérification de type explicite (et il y a de bonnes raisons de s'en éloigner), la partie la plus sûre du protocole de chaîne à vérifier est probablement:
str(maybe_string) == maybe_string
Il ne sera pas par un itérer itérables ou iterator, il ne sera pas appeler une liste de chaînes comme une chaîne et il détecte correctement un type corde comme une 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 que cela dépend .
EDIT: Comme @Tcll le souligne dans les commentaires, la question demande en fait un moyen de détecter à la fois les chaînes unicode et les bytestrings. Sur Python 2, cette réponse échouera avec une exception pour les chaînes unicode qui contiennent des caractères non ASCII, et sur Python 3, elle retournera False
pour tous les bytestrings.
b = b'test'; r = str(b) == b
où b
contient les mêmes données que str(b)
mais (étant un objet octets) ne valide pas en tant que chaîne.
Afin de vérifier si votre variable est quelque chose, vous pouvez aller comme:
s='Hello World'
if isinstance(s,str):
#do something here,
La sortie de isistance vous donnera une valeur booléenne True ou False afin que vous puissiez l'ajuster en conséquence. Vous pouvez vérifier l'acronyme attendu de votre valeur en utilisant initialement: type (s) Cela vous renverra "str" afin que vous puissiez l'utiliser dans la fonction isistance.
Je pourrais traiter cela dans le style de frappe de canard, comme d'autres le mentionnent. Comment savoir qu'une chaîne est vraiment une chaîne? eh bien, évidemment en le convertissant 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 __unicode__
méthode, celle-ci est utilisée pour obtenir sa représentation unicode. Si l'objet transmis ne peut pas être utilisé en tant que chaîne, la fonction unicode
intégrée déclenche une exception.
isinstance(your_object, basestring)
sera True si votre objet est en effet de type chaîne. 'str' est un mot réservé.
mes excuses, la bonne réponse utilise «basestring» au lieu de «str» afin d'inclure également les chaînes unicode - comme cela a été noté ci-dessus par l'un des autres répondants.
Ce soir, je suis tombé sur une situation dans laquelle je pensais que j'allais devoir vérifier le str
type, mais il s'est avéré que non.
Mon approche pour résoudre le problème fonctionnera probablement dans de nombreuses situations, donc je l'offre ci-dessous au cas où d'autres personnes lisant cette question seraient intéressées (Python 3 uniquement).
# 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
C'est simple, utilisez le code suivant (nous supposons que l'objet mentionné est obj) -
if type(obj) == str:
print('It is a string')
else:
print('It is not a string.')
Vous pouvez le tester en concaténant avec une chaîne vide:
def is_string(s):
try:
s += ''
except:
return False
return True
Modifier :
Correction de ma réponse après des commentaires soulignant que cela échoue avec les listes
def is_string(s):
return isinstance(s, basestring)
Pour une belle approche de type canard pour les chaînes de caractères qui a l'avantage de travailler avec Python 2.x et 3.x:
def is_string(obj):
try:
obj + ''
return True
except TypeError:
return False
sagesse était proche du typage de canard avant de passer à l' isinstance
approche, sauf que cela +=
a une signification différente pour les listes +
.
isalpha
, mais qui sait quelles méthodes seraient sûres de rechercher?
try
peut être plus rapide. Si vous vous y attendez 99% du temps, peut-être pas. La différence de performances étant minime, il vaut mieux être idiomatique à moins de profiler votre code et de l'identifier comme étant réellement lent.
if type(varA) == str or type(varB) == str:
print 'string involved'
d'EDX - cours en ligne MITx: 6.00.1x Introduction à l'informatique et à la programmation à l'aide de Python
str
!