Игнорировать регистр в строках Python

В ответ на ваше разъяснение ...

Вы можете использовать ctypes для выполнения функции c "strcasecmp". Ctypes включен в Python 2.5. Он предоставляет возможность обращаться к dll и разделяемым библиотекам, таким как libc. Вот краткий пример (Python в Linux; см. Ссылку для справки по Win32):

from ctypes import *
libc = CDLL("libc.so.6")  // see link above for Win32 help
libc.strcasecmp("THIS", "this") // returns 0
libc.strcasecmp("THIS", "THAT") // returns 8

также может потребоваться ссылка на документацию по strcasecmp

Не совсем уверен, что это быстрее или медленнее (не тестировал), но это способ использовать функцию C для сравнения строк без учета регистра.

~~~~~~~~~~~~~~

Код ActiveState - рецепт 194371: строки без учета регистра - это рецепт создание строкового класса без учета регистра. Это может быть немного излишне kill для чего-то быстрого, но может предоставить вам общий способ обработки нечувствительных к регистру строк, если вы планируете часто их использовать.

Вот тест, показывающий, что при использовании str.lower быстрее, чем предложенный метод принятого ответа (libc.strcasecmp):

#!/usr/bin/env python2.7
import random
import timeit

from ctypes import *
libc = CDLL('libc.dylib') # change to 'libc.so.6' on linux

with open('/usr/share/dict/words', 'r') as wordlist:
    words = wordlist.read().splitlines()
random.shuffle(words)
print '%i words in list' % len(words)

setup = 'from __main__ import words, libc; gc.enable()'
stmts = [
    ('simple sort', 'sorted(words)'),
    ('sort with key=str.lower', 'sorted(words, key=str.lower)'),
    ('sort with cmp=libc.strcasecmp', 'sorted(words, cmp=libc.strcasecmp)'),
]

for (comment, stmt) in stmts:
    t = timeit.Timer(stmt=stmt, setup=setup)
    print '%s: %.2f msec/pass' % (comment, (1000*t.timeit(10)/10))

типичное время на моей машине:

235886 words in list
simple sort: 483.59 msec/pass
sort with key=str.lower: 1064.70 msec/pass
sort with cmp=libc.strcasecmp: 5487.86 msec/pass

Итак, версия с str.lower не только самая быстрая, но также самая портативная и питоническая из всех предлагаемых здесь решений. Я не анализировал использование памяти, но в оригинальном плакате все еще не было веских причин для беспокойства. Кроме того, кто сказал, что вызов модуля libc не дублирует никаких строк?

NB: строковый метод lower() также имеет то преимущество, что он зависит от локали. Что-то, что вы, вероятно, не поймете при написании собственного «оптимизированного» решения. Тем не менее, из-за ошибок и отсутствующих функций в Python такое сравнение может дать неверные результаты в контексте Unicode.

Ваш вопрос подразумевает, что вам не нужен Unicode. Попробуйте следующий фрагмент кода; если это сработает для вас, все готово:

Python 2.5.2 (r252:60911, Aug 22 2008, 02:34:17)
[GCC 4.3.1] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import locale
>>> locale.setlocale(locale.LC_COLLATE, "en_US")
'en_US'
>>> sorted("ABCabc", key=locale.strxfrm)
['a', 'A', 'b', 'B', 'c', 'C']
>>> sorted("ABCabc", cmp=locale.strcoll)
['a', 'A', 'b', 'B', 'c', 'C']

Уточнение: если это не очевидно на первый взгляд, locale.strcoll кажется вам нужной функцией, избегая "повторяющихся" строк str.lower или locale.strxfrm.

Используете ли вы это сравнение в очень часто выполняемом пути высокопроизводительного приложения? Или вы запускаете это на строках размером в мегабайты? Если нет, то вам не стоит беспокоиться о производительности и просто использовать метод .lower ().

Следующий код демонстрирует, что выполнение сравнения без учета регистра путем вызова .lower () для двух строк, каждая из которых имеет размер почти мегабайт, занимает около 0,009 секунды на моем настольном компьютере с частотой 1,8 ГГц:

from timeit import Timer

s1 = "1234567890" * 100000 + "a"
s2 = "1234567890" * 100000 + "B"

code = "s1.lower() < s2.lower()"
time = Timer(code, "from __main__ import s1, s2").timeit(1000)
print time / 1000   # 0.00920499992371 on my machine

Если это действительно чрезвычайно важный и критичный к производительности раздел кода, я рекомендую написать функцию на C и вызывать ее из кода Python, поскольку это позволит вам выполнять действительно эффективный поиск без учета регистра. Подробную информацию о написании модулей расширения C можно найти здесь: https://docs.python.org/exnding/exnding.html

Я не могу найти другой встроенный способ сравнения без учета регистра: рецепт поваренной книги python использует lower ().

Однако вы должны быть осторожны при использовании нижнего значения для сравнения из-за проблемы турецкого языка I. К сожалению, Python не очень хорошо справляется с турецкими языками. ı преобразуется в I, но не преобразуется в ı. İ преобразуется в i, но i не преобразуется в İ.

Нет встроенного эквивалента той функции, которую вы хотите.

Вы можете написать свою собственную функцию, которая будет преобразовывать в .lower () каждый символ за раз, чтобы избежать дублирования обеих строк, но я уверен, что это будет очень интенсивно и крайне неэффективно.

Если вы не работаете с очень длинными строками (настолько длинными, что при дублировании могут возникнуть проблемы с памятью), я бы сделал это простым и использовал

str1.lower() == str2.lower()

Ты будешь в порядке

В этом вопросе задаются 2 очень разные вещи:

1. Как проще всего сравнивать строки в Python без учета регистра?
2. Думаю, я ищу эквивалент функции stricmp () в C.

Поскольку на № 1 уже дан очень хороший ответ (например: str1.lower () ‹str2.lower ()), я отвечу на № 2.

def strincmp(str1, str2, numchars=None):
    result = 0
    len1 = len(str1)
    len2 = len(str2)
    if numchars is not None:
        minlen = min(len1,len2,numchars)
    else:
        minlen = min(len1,len2)
    #end if
    orda = ord('a')
    ordz = ord('z')

    i = 0
    while i < minlen and 0 == result:
        ord1 = ord(str1[i])
        ord2 = ord(str2[i])
        if ord1 >= orda and ord1 <= ordz:
            ord1 = ord1-32
        #end if
        if ord2 >= orda and ord2 <= ordz:
            ord2 = ord2-32
        #end if
        result = cmp(ord1, ord2)
        i += 1
    #end while

    if 0 == result and minlen != numchars:
        if len1 < len2:
            result = -1
        elif len2 < len1:
            result = 1
        #end if
    #end if

    return result
#end def

Используйте эту функцию только тогда, когда это имеет смысл, поскольку во многих случаях метод строчных букв будет лучше.

Я работаю только со строками ascii, я не уверен, как это будет вести себя с юникодом.

Когда что-то плохо поддерживается в стандартной библиотеке, я всегда ищу пакет PyPI. С виртуализацией и повсеместным распространением современных дистрибутивов Linux я больше не избегаю расширений Python. PyICU, похоже, отвечает всем требованиям: https://stackoverflow.com/a/1098160/3461

Теперь есть вариант - чистый питон. Это хорошо протестировано: https://github.com/jtauber/pyuca

Старый ответ:

Мне нравится решение с регулярными выражениями. Вот функцию, которую вы можете скопировать и вставить в любую функцию благодаря поддержке блочной структуры Python.

def equals_ignore_case(str1, str2):
    import re
    return re.match(re.escape(str1) + r'\Z', str2, re.I) is not None

Поскольку вместо поиска я использовал совпадение, мне не нужно было добавлять курсор (^) к регулярному выражению.

Примечание. Это проверяет только равенство, что иногда бывает необходимо. Я бы также не стал говорить, что мне это нравится.

Вот как вы это сделаете с re:

import re
p = re.compile('^hello$', re.I)
p.match('Hello')
p.match('hello')
p.match('HELLO')

Рекомендуемая идиома для сортировки списков значений с использованием дорогостоящих в вычислении ключей - это так называемый «декорированный шаблон». Он состоит просто в построении списка кортежей (ключей, значений) из исходного списка и сортировке этого списка. Затем просто удалить ключи и получить список отсортированных значений:

>>> original_list = ['a', 'b', 'A', 'B']
>>> decorated = [(s.lower(), s) for s in original_list]
>>> decorated.sort()
>>> sorted_list = [s[1] for s in decorated]
>>> sorted_list
['A', 'a', 'B', 'b']

Или, если вам нравятся однострочные:

>>> sorted_list = [s[1] for s in sorted((s.lower(), s) for s in original_list)]
>>> sorted_list
['A', 'a', 'B', 'b']

Если вы действительно беспокоитесь о стоимости вызова lower (), вы можете просто хранить кортежи (пониженная строка, исходная строка) везде. Кортежи - это самый дешевый вид контейнеров в Python, они также являются хешируемыми, поэтому их можно использовать в качестве ключей словаря, членов набора и т. Д.

Я почти уверен, что вам нужно либо использовать .lower (), либо регулярное выражение. Мне неизвестна встроенная функция сравнения строк без учета регистра.

Для случайных или даже повторяющихся сравнений несколько дополнительных строковых объектов не должны иметь значения, если это не произойдет во внутреннем цикле вашего основного кода или у вас недостаточно данных, чтобы действительно заметить влияние на производительность. Посмотрите, если вы это сделаете: делать что-то «глупым» способом будет гораздо менее глупо, если вы также будете делать это меньше.

Если вы серьезно хотите продолжать сравнивать много-много текста без учета регистра, вы можете каким-то образом держать под рукой строчные версии строк, чтобы избежать завершения и повторного создания, или нормализовать весь набор данных в нижнем регистре. Конечно, это зависит от размера набора данных. Если имеется относительно немного иголок и большой стог сена, замена иголок скомпилированными объектами регулярного выражения является одним из решений. Если Трудно сказать, не увидев конкретного примера.

Вы можете перевести каждую строку в нижний регистр один раз - лениво, только когда вам это нужно, или как предварительный переход к сортировке, если вы знаете, что будете сортировать всю коллекцию строк. Есть несколько способов привязать этот ключ сравнения к фактическим сортируемым данным, но эти методы следует рассматривать в отдельном выпуске.

Обратите внимание, что этот метод можно использовать не только для решения проблем с верхним / нижним регистром, но и для других типов сортировки, таких как сортировка по локали или сортировка заголовков «в библиотечном стиле», которая игнорирует ведущие статьи и иным образом нормализует данные перед их сортировкой.

Просто используйте метод str().lower(), если не важна высокая производительность - в этом случае напишите этот метод сортировки как расширение C.

"Как написать расширение Python" кажется неплохим вступлением. .

Что еще более интересно, В этом руководстве сравнивается использование библиотеки ctypes и написание внешнего модуля C. (ctype значительно медленнее, чем расширение C).

Вы можете создать подкласс str и создать свой собственный строковый класс без учета регистра, но ИМХО, это было бы крайне неразумно и создаст гораздо больше проблем, чем оно того стоит.