Wie führe ich einen Zeichenfolgenvergleich ohne Berücksichtigung der Groß- und Kleinschreibung durch?

Wie kann ich in Python einen Vergleich von Zeichenfolgen ohne Berücksichtigung der Groß- und Kleinschreibung durchführen?

Ich möchte den Vergleich einer regulären Zeichenfolge mit einer Repository-Zeichenfolge auf sehr einfache und pythonische Weise zusammenfassen. Ich möchte auch die Möglichkeit haben, Werte in einem Diktat nachzuschlagen, das von Zeichenfolgen mit regulären Python-Zeichenfolgen gehasht wird.

Angenommen, ASCII-Zeichenfolgen:

string1 = 'Hello'
string2 = 'hello'

if string1.lower() == string2.lower():
    print("The strings are the same (case insensitive)")
else:
    print("The strings are NOT the same (case insensitive)")

Der Vergleich von Zeichenfolgen auf eine Weise, bei der die Groß- und Kleinschreibung nicht berücksichtigt wird, scheint trivial zu sein, ist es aber nicht. Ich werde Python 3 verwenden, da Python 2 hier unterentwickelt ist.

Das erste, was zu beachten ist, ist, dass das Entfernen von Groß- und Kleinschreibung in Unicode nicht trivial ist. Es gibt Text, für den text.lower() != text.upper().lower()wie "ß":

"ß".lower()
#>>> 'ß'

"ß".upper().lower()
#>>> 'ss'

Aber lassen Sie uns sagen , Sie zu caselessly vergleichen wollte "BUSSE"und "Buße". Heck, Sie möchten wahrscheinlich auch vergleichen "BUSSE"und "BUẞE"gleich - das ist die neuere Kapitalform. Der empfohlene Weg ist casefold:

str. casefold ()

Geben Sie eine casefolded Kopie der Zeichenfolge zurück. Casefolded Strings können für das Matching ohne Gehäuse verwendet werden.

Casefolding ähnelt dem Lowercasing, ist jedoch aggressiver, da alle Case-Unterscheidungen in einer Zeichenfolge entfernt werden sollen. [...]

Nicht nur verwenden lower. Wenn casefoldnicht verfügbar, .upper().lower()hilft das Tun (aber nur etwas).

Dann sollten Sie Akzente berücksichtigen. Wenn Ihr Font-Renderer gut ist, denken Sie wahrscheinlich "ê" == "ê"- aber nicht:

"ê" == "ê"
#>>> False

Dies liegt daran, dass der Akzent auf letzterem ein kombinierender Charakter ist.

import unicodedata

[unicodedata.name(char) for char in "ê"]
#>>> ['LATIN SMALL LETTER E WITH CIRCUMFLEX']

[unicodedata.name(char) for char in "ê"]
#>>> ['LATIN SMALL LETTER E', 'COMBINING CIRCUMFLEX ACCENT']

Der einfachste Weg, damit umzugehen, ist unicodedata.normalize. Sie möchten wahrscheinlich die NFKD- Normalisierung verwenden , können jedoch die Dokumentation überprüfen. Dann tut man es

unicodedata.normalize("NFKD", "ê") == unicodedata.normalize("NFKD", "ê")
#>>> True

Zum Schluss wird dies hier in Funktionen ausgedrückt:

import unicodedata

def normalize_caseless(text):
    return unicodedata.normalize("NFKD", text.casefold())

def caseless_equal(left, right):
    return normalize_caseless(left) == normalize_caseless(right)

Rufen Sie mit Python 2 .lower()jede Zeichenfolge oder jedes Unicode-Objekt auf ...

string1.lower() == string2.lower()

... wird die meiste Zeit funktionieren, funktioniert aber in den von @tchrist beschriebenen Situationen nicht .

Angenommen, wir haben eine Datei unicode.txtmit den beiden Zeichenfolgen Σίσυφοςund ΣΊΣΥΦΟΣ. Mit Python 2:

>>> utf8_bytes = open("unicode.txt", 'r').read()
>>> print repr(utf8_bytes)
'\xce\xa3\xce\xaf\xcf\x83\xcf\x85\xcf\x86\xce\xbf\xcf\x82\n\xce\xa3\xce\x8a\xce\xa3\xce\xa5\xce\xa6\xce\x9f\xce\xa3\n'
>>> u = utf8_bytes.decode('utf8')
>>> print u
Σίσυφος
ΣΊΣΥΦΟΣ

>>> first, second = u.splitlines()
>>> print first.lower()
σίσυφος
>>> print second.lower()
σίσυφοσ
>>> first.lower() == second.lower()
False
>>> first.upper() == second.upper()
True

Das Σ-Zeichen hat zwei Kleinbuchstaben, ς und σ, und .lower() hilft nicht, sie ohne Berücksichtigung der Groß- und Kleinschreibung zu vergleichen.

Ab Python 3 werden jedoch alle drei Formulare in ς aufgelöst, und das Aufrufen von lower () für beide Zeichenfolgen funktioniert ordnungsgemäß:

>>> s = open('unicode.txt', encoding='utf8').read()
>>> print(s)
Σίσυφος
ΣΊΣΥΦΟΣ

>>> first, second = s.splitlines()
>>> print(first.lower())
σίσυφος
>>> print(second.lower())
σίσυφος
>>> first.lower() == second.lower()
True
>>> first.upper() == second.upper()
True

Wenn Sie sich also für Randfälle wie die drei griechischen Sigmen interessieren, verwenden Sie Python 3.

(Als Referenz werden Python 2.7.3 und Python 3.3.0b1 in den obigen Interpreter-Ausdrucken gezeigt.)

In Abschnitt 3.13 des Unicode-Standards werden Algorithmen für das Caseless Matching definiert.

X.casefold() == Y.casefold() implementiert in Python 3 das "Standard-Caseless-Matching" (D144).

Beim Fallfalten bleibt die Normalisierung von Zeichenfolgen nicht in allen Fällen erhalten, und daher muss die Normalisierung durchgeführt werden ( 'å'vs. 'å'). D145 führt "Canonical Caseless Matching" ein:

import unicodedata

def NFD(text):
    return unicodedata.normalize('NFD', text)

def canonical_caseless(text):
    return NFD(NFD(text).casefold())

NFD() wird zweimal für sehr seltene Randfälle mit U + 0345-Zeichen aufgerufen.

Beispiel:

>>> 'å'.casefold() == 'å'.casefold()
False
>>> canonical_caseless('å') == canonical_caseless('å')
True

Es gibt auch Kompatibilitäts-Caseless-Matching (D146) für Fälle wie '㎒'(U + 3392) und "Identifier Caseless Matching", um das Caseless-Matching von Identifikatoren zu vereinfachen und zu optimieren .

Ich habe diese Lösung hier mit Regex gesehen .

import re
if re.search('mandy', 'Mandy Pande', re.IGNORECASE):
# is True

Es funktioniert gut mit Akzenten

In [42]: if re.search("ê","ê", re.IGNORECASE):
....:        print(1)
....:
1

Bei Unicode-Zeichen, bei denen die Groß- und Kleinschreibung nicht berücksichtigt wird, funktioniert dies jedoch nicht. Vielen Dank an @Rhymoid, dass Sie darauf hingewiesen haben, dass nach meinem Verständnis das genaue Symbol erforderlich ist, damit der Fall wahr ist. Die Ausgabe ist wie folgt:

In [36]: "ß".lower()
Out[36]: 'ß'
In [37]: "ß".upper()
Out[37]: 'SS'
In [38]: "ß".upper().lower()
Out[38]: 'ss'
In [39]: if re.search("ß","ßß", re.IGNORECASE):
....:        print(1)
....:
1
In [40]: if re.search("SS","ßß", re.IGNORECASE):
....:        print(1)
....:
In [41]: if re.search("ß","SS", re.IGNORECASE):
....:        print(1)
....:

Der übliche Ansatz besteht darin, die Zeichenfolgen für die Suche und Vergleiche in Groß- oder Kleinbuchstaben zu schreiben. Zum Beispiel:

>>> "hello".upper() == "HELLO".upper()
True
>>> 

Wie wäre es zuerst mit der Konvertierung in Kleinbuchstaben? Sie können verwenden string.lower().

def insenStringCompare(s1, s2):
    """ Method that takes two strings and returns True or False, based
        on if they are equal, regardless of case."""
    try:
        return s1.lower() == s2.lower()
    except AttributeError:
        print "Please only pass strings into this method."
        print "You passed a %s and %s" % (s1.__class__, s2.__class__)

Alles, was Sie tun müssen, ist, die beiden Zeichenfolgen in Kleinbuchstaben umzuwandeln (alle Buchstaben werden zu Kleinbuchstaben) und sie dann zu vergleichen (vorausgesetzt, die Zeichenfolgen sind ASCII-Zeichenfolgen).

Zum Beispiel:

string1 = "Hello World"
string2 = "hello WorlD"

if string1.lower() == string2.lower():
    print("The two strings are the same.")
else:
    print("The two strings are not the same.")

Dies ist eine weitere Regex, die ich in der letzten Woche lieben / hassen gelernt habe, also normalerweise als (in diesem Fall ja) etwas importieren, das widerspiegelt, wie ich mich fühle! mache eine normale Funktion .... frage nach Eingabe, dann benutze .... etwas = re.compile (r'foo * | spam * ', yes.I) ...... re.I (yes.I unten) ist dasselbe wie IGNORECASE, aber Sie können nicht so viele Fehler machen, wenn Sie es schreiben!

Sie durchsuchen Ihre Nachricht dann mit regulären Ausdrücken, aber ehrlich gesagt sollten dies einige Seiten sein, aber der Punkt ist, dass Foo oder Spam zusammengeleitet werden und Groß- und Kleinschreibung ignoriert wird. Wenn dann einer von beiden gefunden wird, zeigt lost_n_found einen von ihnen an. Wenn beides nicht der Fall ist, ist lost_n_found gleich None. Wenn es nicht gleich none ist, geben Sie den user_input in Kleinbuchstaben mit "return lost_n_found.lower ()" zurück.

Auf diese Weise können Sie alles, was zwischen Groß- und Kleinschreibung unterscheidet, viel einfacher abgleichen. Schließlich steht (NCS) für "niemand kümmert sich ernsthaft ...!" oder nicht zwischen Groß- und Kleinschreibung unterscheiden .... je nachdem

Wenn jemand irgendwelche Fragen hat, melde dich bei mir.

    import re as yes

    def bar_or_spam():

        message = raw_input("\nEnter FoO for BaR or SpaM for EgGs (NCS): ") 

        message_in_coconut = yes.compile(r'foo*|spam*',  yes.I)

        lost_n_found = message_in_coconut.search(message).group()

        if lost_n_found != None:
            return lost_n_found.lower()
        else:
            print ("Make tea not love")
            return

    whatz_for_breakfast = bar_or_spam()

    if whatz_for_breakfast == foo:
        print ("BaR")

    elif whatz_for_breakfast == spam:
        print ("EgGs")