Comment savoir si un objet Python est une chaîne de caractères?

Comment puis-je vérifier si un objet Python est une chaîne de caractères (réguliers ou Unicode)?

Ce que Jason se référant à l'est du duck-typing (si il charlatans comme un canard, c'est probablement un canard). En Python, vous avez souvent "laissez vos code du travail" sur n'importe quelle chaîne, comme objet, sans vérifier si c'est une chaîne ou une chaîne de sous-classe. Pour plus d'info, voir: docs.python.org/glossary.html#term-duck-typing
C'est ce que j'aime à propos de la SORTE. J'ai l'habitude de poser une question, il ne répond pas, les gens me disent que je ne devrais pas faire ça de toute façon et pourquoi, et je grandir en tant que programmeur. =)
+1: tout Simplement parce que la réponse est rarement nécessaire, ne signifie pas que la question n'est pas valide. Même si je pense que c'est génial d'avoir une attention ici, je ne pense pas qu'il mérite de la rétrogradation de la question.
C'est peut-être le plus de l'usage légitime de la vérification du type en Python. Les chaînes sont itératif, afin de les distinguer des listes de toute autre manière est une mauvaise idée.
Il y a certainement des cas où il est nécessaire de distinguer les chaînes à partir d'autres iterables. Par exemple, voir le code source pour PrettyPrinter dans le pprint module.
“Si ça ressemble à un canard et les charlatans comme un canard, il doit etre un canard.”
Je pense que le duck-typing est destinée à travailler avec le polymorphisme. Certaines personnes ont une réaction réflexe à l'encontre de TOUTES python vérification de type. Ben du lien n'a pas vraiment parler contre des choses où les types ont fondamentalement différents comportements. Mon interprétation est que le duck-typing est destinée à faire confiance à la Principe de Substitution de Liskov
Les chaînes ne sont pas seulement iterables, ils sont iterables de chaînes de caractères. Les distinguant des autres iterables de chaîne sans "triche" est presque impossible. Mais ensuite, il y a stringlike et la triche code des pauses.
Depuis beaucoup de nouvelles personnes vont probablement lu cela: d'abord, assurez-vous que vous n'avez vraiment vérifier. Ma réponse pourrait donner quelques idées sur la façon d'éviter la case.
Voir aussi stackoverflow.com/questions/4843173/...

InformationsquelleAutor Matt S. | 2009-08-19

297

Python 2

Utilisation isinstance(obj, basestring) pour un objet à tester obj.

Docs.

InformationsquelleAutor John Fouhy
169

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 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 si o est une instance de str ou d'une sous-classe de str:
```
isinstance(o, str)
```
Ci-dessus fonctionnent aussi pour des chaînes Unicode si vous remplacez str avec unicode.

Cependant, vous ne pouvez pas besoin de faire de type explicite tout de vérification. "Duck typing" peut s'adapter à vos besoins. Voir http://docs.python.org/glossary.html#term-duck-typing.

Voir aussi Quelle est la manière canonique pour vérifier le type en python?
- variable locale 'str' référencé avant affectation
- python3 vs python2. Vous avez besoin de vérifier pour basestring dans py2.
InformationsquelleAutor Matt S.
152

Python 3

En Python 3.x basestring n'est plus disponible, comme str est le seul type de chaîne (avec la sémantique de Python 2.x unicode).

Afin de le vérifier en Python 3.x est juste:
```
isinstance(obj_to_test, str)
```
Ce qui suit le correctif de l'officiel 2to3 outil de conversion: la conversion de basestring à str.
- Ne fonctionne pas pour moi pour une chaîne unicode
- Vous êtes sûr que vous avez été à l'aide de Python 3.x? Ce n' repr() de votre chaîne de retour?
- Ah...non, à l'aide de 2,7
InformationsquelleAutor sevenforce
91

Python 2 et 3

(croix-compatible)

Si vous voulez vérifier avec aucun égard pour la version de Python (2.x vs 3.x), utilisez six (PyPI) et de ses string_types attribut:
```
import six

if isinstance(obj, six.string_types):
    print('obj is a string!')
```
Dans six (un très léger-poids à fichier unique module), c'est tout simplement de faire cette:
```
import sys
PY3 = sys.version_info[0] == 3

if PY3:
    string_types = str
else:
    string_types = basestring
```
- Alternativement, vous pouvez utiliser future (PyPI) à même de conserver le nom: from past.builtins import basestring
- BTW le Feuille de Triche est une excellente ressource pour la version de Python de compatibilité.
- Pourquoi ne pas tout importations? Essayez d'abord de basestring et ensuite retomber à str. E. g. def is_string(obj): try: return isinstance(obj, basestring) # python 2 except NameError: return isinstance(obj, str) # python 3
InformationsquelleAutor Nick T
17

J'ai trouvé cette sna plus pythonic:
```
if type(aObject) is str:
    #do your stuff here
    pass
```
depuis les objets de type sont singleton, est peut être utilisé pour faire la comparaison de l'objet pour le str type
- Ce n'est pas le général a recommandé au moyen d'essais de type, en raison de l'héritage: 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 d'autres, la non-str cas.
InformationsquelleAutor Zhou Jingyuan
12

Si l'on veut rester à l'écart de type explicite-de la vérification (et il y en sont de bonnes raisons de rester loin de lui), probablement la partie la plus sûre de la chaîne protocole à vérifier est:
```
str(maybe_string) == maybe_string
```
De ne pas faire une itération sur un objet iterable ou itérateur, il ne fera pas appel à une liste de chaînes de caractères une chaîne de caractères et il détecte correctement une stringlike comme une chaîne de caractères.

Bien sûr, il ya des inconvénients. Par exemple, str(maybe_string) peut être lourd de calcul. Comme souvent, la réponse est ça dépend.

InformationsquelleAutor clacke
11

Afin de vérifier si votre variable est quelque chose que vous pourrait 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 valeur, de sorte que vous pouvez ajuster en conséquence.
Vous pouvez vérifier les attendus de l'acronyme de votre valeur en utilisant en premier lieu:
type(s)
Cela vous permettra de revenir de type 'str' de sorte que vous pouvez l'utiliser dans le isistance fonction.

InformationsquelleAutor Abraam Georgiadis
5

Je pourrais gérer cela à la duck-typing style, comme d'autres parlent. Comment puis-je savoir une chaîne de caractères est vraiment une chaîne de caractères? bon, évidemment, par conversion une chaîne!
```
def myfunc(word):
    word = unicode(word)
    ...
```
Si l'argument est déjà une chaîne de caractères unicode ou type, real_word tiendra sa valeur non modifiée. Si l'objet passé implémente un __unicode__ méthode, qui est utilisée pour obtenir sa représentation unicode. Si l'objet passé ne peut pas être utilisé comme une chaîne de caractères, la unicode builtin soulève une exception.

InformationsquelleAutor SingleNegationElimination
3
```
isinstance(your_object, basestring)
```
sera Vrai si votre objet est en effet une chaîne de type. 'str' est mot réservé.

mes excuses,
la bonne réponse est à l'aide de 'basestring' au lieu de 'str' afin de il pour inclure des chaînes unicode ainsi - comme cela a été indiqué ci-dessus par l'un des autres intervenants.
- Ne fonctionne pas pour l'unicode des objets, qui ont été explicitement demandé dans la question.
InformationsquelleAutor beepbeep
1

Vous pouvez le tester par la concaténation d'une chaîne vide:
```
def is_string(s):
  try:
    s += ''
  except:
    return False
  return True
```
Modifier:

Corriger ma réponse après les commentaires soulignant que cela échoue avec des listes
```
def is_string(s):
  return isinstance(s, basestring)
```
- Ne pas travailler avec des listes: >>> s = [1]; s += "
- Vous avez raison, merci de remarquer. J'ai donné une réponse alternative.
InformationsquelleAutor wisefish

Ce soir, j'ai couru dans une situation dans laquelle je pensée j'allais avoir à vérifier à l' str type, mais il s'est avéré que je n'ai pas.

Mon approche pour résoudre le problème va probablement travailler dans de nombreuses situations, donc je vous le propose ci-dessous dans le cas des autres la lecture de cette question sont intéressés (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

InformationsquelleAutor Rick Teachey

-3

Pour un gentil canard-typage approche de chaîne-aime qui a le bonus de travailler avec Python 2.x et 3.x:
```
def is_string(obj):
    try:
        obj + ''
        return True
    except TypeError:
        return False
```
wisefish était proche avec le duck-typing avant il est passé à la isinstance approche, sauf que += a une signification différente pour les listes de + n'.
- Eh bien, vous avez deux downvotes et pas celui fourni un commentaire. Je n'ai pas downvoted mais je n'aime pas votre solution car: * Trop verbeux. Vous ne devriez pas besoin de définir une fonction pour faire cela. * Cher. D'intercepter les exceptions n'est pas bon pour la performance. * Les risques d'erreurs. Un autre objet peut mettre en œuvre ajouter, voir une chaîne de caractères, et de soulever un autre type d'exception, qui n'est pas TypeError.
- Ici aussi, vous êtes employant le duck-typing approche, qui est belle, mais à la fin avec lancer et attraper une exception juste pour trouver quelque chose, ce qui n'est pas beau.
- Cela peut être légitimement le seul moyen infaillible pour distinguer entre une chaîne et quelques autres itératif de la chaîne. On pourrait regarder pour les attributs tels que isalpha, mais qui sait quelles méthodes seraient en sécurité à chercher?
- Je réalisé que le __str__ méthode plus d'égalité peut réellement être infaillible de l'un. Mais même cela n'est pas sans mises en garde.
- les exceptions sont bon marché en Python. Si vous pensez que l'erreur de 1% du temps, try peut être plus rapide. Si vous vous attendez à 99% du temps, peut-être pas. La différence de performances est minime, il est préférable d'être idiomatiques, à moins que vous le profil de votre code et de l'identifier comme étant effectivement lent.
InformationsquelleAutor Alphadelta14
-4
```
if type(varA) == str or type(varB) == str:
    print 'string involved'
```
de
EDX - cours en ligne
MITx: 6.00.1 x Introduction à l'Informatique et à la Programmation avec Python
- C'est probablement la pire façon possible de vérifier. Non seulement est-il exclure de l'unicode des objets, même exclut des sous-classes de str!
InformationsquelleAutor William Clay

Vous devez vous connecter pour publier un commentaire.

Python 2

Python 3

Python 2 et 3

(croix-compatible)