Como faço uma comparação de cadeias sem distinção entre maiúsculas e minúsculas?

Como posso fazer comparação de strings sem distinção entre maiúsculas e minúsculas no Python?

Gostaria de encapsular a comparação de cadeias regulares a uma cadeia de repositórios usando de uma maneira muito simples e Python. Eu também gostaria de ter a capacidade de procurar valores em um dict hash por strings usando strings python regulares.

Assumindo cadeias ASCII:

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)")

Comparar strings de uma maneira que não diferencia maiúsculas de minúsculas parece trivial, mas não é. Eu vou usar o Python 3, pois o Python 2 é subdesenvolvido aqui.

A primeira coisa a observar é que as conversões de remoção de maiúsculas e minúsculas no Unicode não são triviais. Há texto para o qual text.lower() != text.upper().lower(), como "ß":

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

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

Mas digamos que você queria comparar "BUSSE"e "Buße". Caramba, você provavelmente também quer comparar "BUSSE"e "BUẞE"igualar - essa é a nova forma de capital. A maneira recomendada é usar casefold:

str. casefold ()

Retorne uma cópia dobrada em caixa da sequência. As cordas dobradas em caixa podem ser usadas para correspondência sem caixa.

A dobragem de caixa é semelhante à minúscula, mas é mais agressiva porque se destina a remover todas as distinções de maiúsculas e minúsculas em uma sequência. [...]

Não use apenas lower. Se casefoldnão estiver disponível, fazer .upper().lower()ajuda (mas apenas um pouco).

Então você deve considerar sotaques. Se o seu renderizador de fontes é bom, você provavelmente pensa "ê" == "ê"- mas não:

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

Isso ocorre porque o sotaque desse último é um personagem combinado.

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']

A maneira mais simples de lidar com isso é unicodedata.normalize. Você provavelmente deseja usar a normalização do NFKD , mas fique à vontade para verificar a documentação. Então se faz

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

Para finalizar, aqui isso é expresso em funções:

import unicodedata

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

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

Usando Python 2, chamando .lower()cada string ou objeto Unicode ...

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

... funcionará a maior parte do tempo, mas na verdade não funciona nas situações descritas por tchrist .

Suponha que temos um arquivo chamado unicode.txtcontendo as duas strings Σίσυφοςe ΣΊΣΥΦΟΣ. Com o 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

O caractere has possui duas formas minúsculas, ς e σ, e .lower()não ajudará a compará-las sem distinção entre maiúsculas e minúsculas.

No entanto, a partir do Python 3, todos os três formulários serão resolvidos como ς, e chamar lower () em ambas as strings funcionará corretamente:

>>> 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

Portanto, se você se importa com casos extremos como os três sigmas em grego, use Python 3.

(Para referência, Python 2.7.3 e Python 3.3.0b1 são mostrados nas impressões do interpretador acima.)

A Seção 3.13 do padrão Unicode define algoritmos para correspondência sem caixa.

X.casefold() == Y.casefold() no Python 3 implementa a "correspondência padrão sem caixa" (D144).

Casefolding não preserva a normalização de strings em todas as instâncias e, portanto, a normalização precisa ser feita ( 'å'vs. 'å'). O D145 apresenta a "correspondência canônica sem caixa":

import unicodedata

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

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

NFD() é chamado duas vezes para casos de borda muito pouco frequentes envolvendo o caractere U + 0345.

Exemplo:

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

Também há compatibilidade sem caixa de compatibilidade (D146) para casos como '㎒'(U + 3392) e "correspondência sem caixa de identificador" para simplificar e otimizar a correspondência sem caixa de identificadores .

Eu vi essa solução aqui usando regex .

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

Funciona bem com sotaques

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

No entanto, ele não funciona com caracteres unicode que não diferenciam maiúsculas de minúsculas. Obrigado @Rhymoid por apontar que, como eu entendi, ele precisa do símbolo exato, para que o caso seja verdadeiro. A saída é a seguinte:

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)
....:

A abordagem usual é colocar as cadeias em maiúsculas ou minúsculas para as pesquisas e comparações. Por exemplo:

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

Que tal converter primeiro para minúsculas? você pode usar 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__)

Tudo o que você precisa fazer é converter as duas strings em minúsculas (todas as letras se tornam minúsculas) e depois compará-las (assumindo que as strings sejam ASCII).

Por exemplo:

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.")

Este é outro regex que aprendi a amar / odiar na última semana, então geralmente importo como (neste caso, sim) algo que reflete como estou me sentindo! faça uma função normal .... solicite entrada e use .... algo = re.compile (r'foo * | spam * ', yes.I) ...... re.I (yes.I abaixo) é o mesmo que IGNORECASE, mas você não pode cometer tantos erros ao escrevê-lo!

Em seguida, você pesquisa sua mensagem usando regex, mas honestamente isso deve ter algumas páginas, mas o ponto é que foo ou spam são canalizados juntos e a caixa é ignorada. Então, se um deles for encontrado, lost_n_found exibirá um deles. se nenhum deles, lost_n_found for igual a None. Se não for igual a nenhum, retorne o user_input em letras minúsculas usando "return lost_n_found.lower ()"

Isso permite que você combine com mais facilidade qualquer coisa que diferencia maiúsculas de minúsculas. Por fim (NCS), significa "ninguém se importa seriamente ...!" ou não diferencia maiúsculas de minúsculas ...

se alguém tiver alguma dúvida me fale sobre isso ..

    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")