Wie kann ich überprüfen, ob ein Python-Objekt eine Zeichenfolge ist (entweder regulär oder Unicode)?

Python 2

Verwenden Sie isinstance(obj, basestring)für ein zu testendes Objekt obj.

Docs .

Python 2

So überprüfen Sie, ob ein Objekt oein Zeichenfolgentyp einer Unterklasse eines Zeichenfolgentyps ist:

isinstance(o, basestring)

weil beide strund unicodeUnterklassen von sind basestring.

So überprüfen Sie, ob der Typ ogenau ist str:

type(o) is str

So überprüfen Sie, ob oes sich um eine Instanz stroder eine Unterklasse von str:

isinstance(o, str)

Die oben auch Arbeit für Unicode - Strings , wenn Sie ersetzen strmit unicode.

Möglicherweise müssen Sie jedoch überhaupt keine explizite Typprüfung durchführen. "Duck Typing" kann Ihren Bedürfnissen entsprechen. Siehe http://docs.python.org/glossary.html#term-duck-typing .

Siehe auch Wie kann kanonisch nach Python gesucht werden?

Python 3

In Python 3.x basestringist nicht mehr verfügbar, ebenso strwie der einzige Zeichenfolgentyp (mit der Semantik von Python 2.x unicode).

Die Prüfung in Python 3.x lautet also nur:

isinstance(obj_to_test, str)

Dies folgt dem Fix des offiziellen 2to3Konvertierungstools: Konvertieren basestringin str.

Python 2 und 3

(kreuzkompatibel)

Wenn Sie ohne Berücksichtigung der Python-Version (2.x vs 3.x) prüfen möchten, verwenden Sie six( PyPI ) und sein string_typesAttribut:

import six

if isinstance(obj, six.string_types):
    print('obj is a string!')

Innerhalb six(eines sehr leichten Einzeldateimoduls) geschieht dies einfach wie folgt :

import sys
PY3 = sys.version_info[0] == 3

if PY3:
    string_types = str
else:
    string_types = basestring

Ich fand das und mehr pythonic:

if type(aObject) is str:
    #do your stuff here
    pass

da Objekte vom Typ Singleton sind, wird verwendet werden , die zu vergleichen , um das Objekt zu dem str Typen zu tun

Wenn Sie sich von expliziten Typprüfungen fernhalten möchten (und es gibt gute Gründe, sich davon fernzuhalten), ist der wahrscheinlich sicherste Teil des zu überprüfenden Zeichenfolgenprotokolls:

str(maybe_string) == maybe_string

Es wird nicht durch eine Iteration oder einen Iterator iteriert, es wird keine Liste von Zeichenfolgen als Zeichenfolge bezeichnet und es erkennt eine Zeichenfolge wie eine Zeichenfolge korrekt .

Natürlich gibt es Nachteile. Zum Beispiel str(maybe_string)kann eine schwere Berechnung sein. Wie so oft ist die Antwort, dass es darauf ankommt .

BEARBEITEN : Wie @Tcll in den Kommentaren hervorhebt , fragt die Frage tatsächlich nach einer Möglichkeit, sowohl Unicode-Zeichenfolgen als auch Bytestrings zu erkennen. In Python 2 Falseschlägt diese Antwort mit Ausnahme von Unicode-Zeichenfolgen fehl, die Nicht-ASCII-Zeichen enthalten, und in Python 3 wird sie für alle Bytestrings zurückgegeben.

Um zu überprüfen, ob Ihre Variable etwas ist, können Sie folgendermaßen vorgehen:

s='Hello World'
if isinstance(s,str):
#do something here,

Die Ausgabe von isistance gibt Ihnen einen booleschen True- oder False-Wert, damit Sie ihn entsprechend anpassen können. Sie können das erwartete Akronym Ihres Werts überprüfen, indem Sie zunächst Folgendes verwenden: type (s) Dies gibt Ihnen den Typ 'str' zurück, damit Sie es in der isistance-Funktion verwenden können.

Ich könnte damit im Enten-Schreibstil umgehen, wie andere erwähnen. Woher weiß ich, dass eine Zeichenfolge wirklich eine Zeichenfolge ist? Nun, offensichtlich durch Konvertieren in einen String!

def myfunc(word):
    word = unicode(word)
    ...

Wenn das Argument bereits ein String- oder Unicode-Typ ist, behält real_word seinen Wert unverändert bei. Wenn das übergebene Objekt eine __unicode__Methode implementiert , wird diese verwendet, um die Unicode-Darstellung abzurufen. Wenn das übergebene Objekt nicht als Zeichenfolge verwendet werden kann, unicodelöst das integrierte Objekt eine Ausnahme aus.

isinstance(your_object, basestring)

wird wahr sein, wenn Ihr Objekt tatsächlich ein Zeichenfolgentyp ist. 'str' ist ein reserviertes Wort.

Ich entschuldige mich, die richtige Antwort ist, "basestring" anstelle von "str" ​​zu verwenden, um auch Unicode-Strings einzuschließen - wie oben von einem der anderen Responder erwähnt.

Heute Abend bin ich in eine Situation geraten, in der ich dachte, ich müsste mich gegen den strTyp erkundigen, aber es stellte sich heraus, dass ich es nicht tat.

Mein Ansatz zur Lösung des Problems wird wahrscheinlich in vielen Situationen funktionieren. Daher biete ich ihn unten an, falls andere, die diese Frage lesen, interessiert sind (nur 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

Einige 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

Verwenden Sie einfach den folgenden Code (wir nehmen an, dass das erwähnte Objekt obj ist) -

if type(obj) == str:
    print('It is a string')
else:
    print('It is not a string.')

Sie können es testen, indem Sie es mit einer leeren Zeichenfolge verketten:

def is_string(s):
  try:
    s += ''
  except:
    return False
  return True

Bearbeiten :

Korrektur meiner Antwort nach Kommentaren, die darauf hinweisen, dass dies bei Listen fehlschlägt

def is_string(s):
  return isinstance(s, basestring)

Für einen netten Ententypisierungsansatz für String-Likes, der den Vorteil hat, sowohl mit Python 2.x als auch mit 3.x zu arbeiten:

def is_string(obj):
    try:
        obj + ''
        return True
    except TypeError:
        return False

Wisefish war eng mit der Ententypisierung verbunden, bevor er zum isinstanceAnsatz überging , außer dass dies +=für Listen eine andere Bedeutung hat als dies der +Fall ist.

if type(varA) == str or type(varB) == str:
    print 'string involved'

from EDX - Online-Kurs MITx: 6.00.1x Einführung in die Informatik und Programmierung mit Python