В Python, как проверить, содержит ли строка только определенные символы?

Ответ 1

Финал (?) edit

Ответ, завернутый в функцию, с аннотированным интерактивным сеансом:

>>> import re
>>> def special_match(strg, search=re.compile(r'[^a-z0-9.]').search):
...     return not bool(search(strg))
...
>>> special_match("")
True
>>> special_match("az09.")
True
>>> special_match("az09.\n")
False
# The above test case is to catch out any attempt to use re.match()
# with a `$` instead of `\Z` -- see point (6) below.
>>> special_match("az09.#")
False
>>> special_match("az09.X")
False
>>>

Примечание. Существует сравнение с использованием re.match() далее в этом ответе. Дальнейшие тайминги показывают, что match() будет выигрывать с гораздо более длинными строками; match(), кажется, имеет намного большие накладные расходы, чем search(), когда окончательный ответ True; это вызывает недоумение (возможно, это стоимость возврата объекта MatchObject вместо None) и может потребовать дальнейшего рыться.

==== Earlier text ====

В принятом ответе [ранее] можно использовать несколько улучшений:

(1) Презентация дает представление о результате интерактивного сеанса Python:

reg=re.compile('^[a-z0-9\.]+$')
>>>reg.match('jsdlfjdsf12324..3432jsdflsdf')
True

но match() не возвращает True

(2) Для использования с match() ^ в начале шаблона является избыточным и выглядит немного медленнее, чем тот же шаблон без ^

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

(4) Обратная косая черта перед точкой/периодом избыточна

(5) Медленнее кода OP!

prompt>rem OP version -- NOTE: OP used raw string!

prompt>\python26\python -mtimeit -s"t='jsdlfjdsf12324..3432jsdflsdf';import
re;reg=re.compile(r'[^a-z0-9\.]')" "not bool(reg.search(t))"
1000000 loops, best of 3: 1.43 usec per loop

prompt>rem OP version w/o backslash

prompt>\python26\python -mtimeit -s"t='jsdlfjdsf12324..3432jsdflsdf';import
re;reg=re.compile(r'[^a-z0-9.]')" "not bool(reg.search(t))"
1000000 loops, best of 3: 1.44 usec per loop

prompt>rem cleaned-up version of accepted answer

prompt>\python26\python -mtimeit -s"t='jsdlfjdsf12324..3432jsdflsdf';import
re;reg=re.compile(r'[a-z0-9.]+\Z')" "bool(reg.match(t))"
100000 loops, best of 3: 2.07 usec per loop

prompt>rem accepted answer

prompt>\python26\python -mtimeit -s"t='jsdlfjdsf12324..3432jsdflsdf';import
re;reg=re.compile('^[a-z0-9\.]+$')" "bool(reg.match(t))"
100000 loops, best of 3: 2.08 usec per loop

(6) Может привести к неправильному ответу!

>>> import re
>>> bool(re.compile('^[a-z0-9\.]+$').match('1234\n'))
True # uh-oh
>>> bool(re.compile('^[a-z0-9\.]+\Z').match('1234\n'))
False

Ответ 2

Вот простая, чистая реализация Python. Он должен использоваться, когда производительность не является критичной (для будущих гуглеров).

import string
allowed = set(string.ascii_lowercase + string.digits + '.')

def check(test_str):
    set(test_str) <= allowed

Что касается производительности, то итерация, вероятно, будет самым быстрым методом. Регексы должны проходить через конечный автомат, а установленное решение равенства должно построить временный набор. Однако разница вряд ли имеет значение. Если производительность этой функции очень важна, напишите ее как модуль расширения C с оператором switch (который будет скомпилирован в таблицу перехода).

Здесь реализация C, которая использует операторы if из-за ограничений пространства. Если вам абсолютно необходим крошечный бит дополнительной скорости, выпишите коммутационный футляр. В моих тестах он работает очень хорошо (2 секунды против 9 секунд в тестах против регулярного выражения).

#define PY_SSIZE_T_CLEAN
#include <Python.h>

static PyObject *check(PyObject *self, PyObject *args)
{
        const char *s;
        Py_ssize_t count, ii;
        char c;
        if (0 == PyArg_ParseTuple (args, "s#", &s, &count)) {
                return NULL;
        }
        for (ii = 0; ii < count; ii++) {
                c = s[ii];
                if ((c < '0' && c != '.') || c > 'z') {
                        Py_RETURN_FALSE;
                }
                if (c > '9' && c < 'a') {
                        Py_RETURN_FALSE;
                }
        }

        Py_RETURN_TRUE;
}

PyDoc_STRVAR (DOC, "Fast stringcheck");
static PyMethodDef PROCEDURES[] = {
        {"check", (PyCFunction) (check), METH_VARARGS, NULL},
        {NULL, NULL}
};
PyMODINIT_FUNC
initstringcheck (void) {
        Py_InitModule3 ("stringcheck", PROCEDURES, DOC);
}

Включите его в свой setup.py:

from distutils.core import setup, Extension
ext_modules = [
    Extension ('stringcheck', ['stringcheck.c']),
],

Использовать как:

>>> from stringcheck import check
>>> check("abc")
True
>>> check("ABC")
False

Ответ 3

Упрощенный подход? Чуть больше Pythonic?

>>> ok = "0123456789abcdef"
>>> all(c in ok for c in "123456abc")
True
>>> all(c in ok for c in "hello world")
False

Это, конечно, не самый эффективный, но он уверен читаемый.

Ответ 4

EDIT: Изменено регулярное выражение, чтобы исключить A-Z

Регулярное выражение - это самое быстрое решение для чистого питона

reg=re.compile('^[a-z0-9\.]+$')
>>>reg.match('jsdlfjdsf12324..3432jsdflsdf')
True
>>> timeit.Timer("reg.match('jsdlfjdsf12324..3432jsdflsdf')", "import re; reg=re.compile('^[a-z0-9\.]+$')").timeit()
0.70509696006774902

По сравнению с другими решениями:

>>> timeit.Timer("set('jsdlfjdsf12324..3432jsdflsdf') <= allowed", "import string; allowed = set(string.ascii_lowercase + string.digits + '.')").timeit()
3.2119350433349609
>>> timeit.Timer("all(c in allowed for c in 'jsdlfjdsf12324..3432jsdflsdf')", "import string; allowed = set(string.ascii_lowercase + string.digits + '.')").timeit()
6.7066690921783447

Если вы хотите разрешить пустые строки, измените их на:

reg=re.compile('^[a-z0-9\.]*$')
>>>reg.match('')
False

По запросу я верну другую часть ответа. Но учтите, что нижеследующие принимают диапазон A-Z.

Вы можете использовать isalnum

test_str.replace('.', '').isalnum()

>>> 'test123.3'.replace('.', '').isalnum()
True
>>> 'test123-3'.replace('.', '').isalnum()
False

EDIT Использование isalnum намного эффективнее, чем установленное решение

>>> timeit.Timer("'jsdlfjdsf12324..3432jsdflsdf'.replace('.', '').isalnum()").timeit()
0.63245487213134766

EDIT2  Джон привел пример, где выше не работает. Я изменил решение, чтобы преодолеть этот частный случай, используя encode

test_str.replace('.', '').encode('ascii', 'replace').isalnum()

И это почти в 3 раза быстрее, чем установленное решение

timeit.Timer("u'ABC\u0131\u0661'.encode('ascii', 'replace').replace('.','').isalnum()", "import string; allowed = set(string.ascii_lowercase + string.digits + '.')").timeit()
1.5719811916351318

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

Ответ 5

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

Вот мои тестовые реализации:

import re

hex_digits = set("ABCDEF1234567890")
hex_match = re.compile(r'^[A-F0-9]+\Z')
hex_search = re.compile(r'[^A-F0-9]')

def test_set(input):
    return set(input) <= hex_digits

def test_not_any(input):
    return not any(c not in hex_digits for c in input)

def test_re_match1(input):
    return bool(re.compile(r'^[A-F0-9]+\Z').match(input))

def test_re_match2(input):
    return bool(hex_match.match(input))

def test_re_match3(input):
    return bool(re.match(r'^[A-F0-9]+\Z', input))

def test_re_search1(input):
    return not bool(re.compile(r'[^A-F0-9]').search(input))

def test_re_search2(input):
    return not bool(hex_search.search(input))

def test_re_search3(input):
    return not bool(re.match(r'[^A-F0-9]', input))

И тесты в Python 3.4.0 на Mac OS X:

import cProfile
import pstats
import random

# generate a list of 10000 random hex strings between 10 and 10009 characters long
# this takes a little time; be patient
tests = [ ''.join(random.choice("ABCDEF1234567890") for _ in range(l)) for l in range(10, 10010) ]

# set up profiling, then start collecting stats
test_pr = cProfile.Profile(timeunit=0.000001)
test_pr.enable()

# run the test functions against each item in tests. 
# this takes a little time; be patient
for t in tests:
    for tf in [test_set, test_not_any, 
               test_re_match1, test_re_match2, test_re_match3,
               test_re_search1, test_re_search2, test_re_search3]:
        _ = tf(t)

# stop collecting stats
test_pr.disable()

# we create our own pstats.Stats object to filter 
# out some stuff we don't care about seeing
test_stats = pstats.Stats(test_pr)

# normally, stats are printed with the format %8.3f, 
# but I want more significant digits
# so this monkey patch handles that
def _f8(x):
    return "%11.6f" % x

def _print_title(self):
    print('   ncalls     tottime     percall     cumtime     percall', end=' ', file=self.stream)
    print('filename:lineno(function)', file=self.stream)

pstats.f8 = _f8
pstats.Stats.print_title = _print_title

# sort by cumulative time (then secondary sort by name), ascending
# then print only our test implementation function calls:
test_stats.sort_stats('cumtime', 'name').reverse_order().print_stats("test_*")

который дал следующие результаты:

         50335004 function calls in 13.428 seconds

   Ordered by: cumulative time, function name
   List reduced from 20 to 8 due to restriction 

   ncalls     tottime     percall     cumtime     percall filename:lineno(function)
    10000    0.005233    0.000001    0.367360    0.000037 :1(test_re_match2)
    10000    0.006248    0.000001    0.378853    0.000038 :1(test_re_match3)
    10000    0.010710    0.000001    0.395770    0.000040 :1(test_re_match1)
    10000    0.004578    0.000000    0.467386    0.000047 :1(test_re_search2)
    10000    0.005994    0.000001    0.475329    0.000048 :1(test_re_search3)
    10000    0.008100    0.000001    0.482209    0.000048 :1(test_re_search1)
    10000    0.863139    0.000086    0.863139    0.000086 :1(test_set)
    10000    0.007414    0.000001    9.962580    0.000996 :1(test_not_any)

где:

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

Быстрее не беспокоиться о компиляции регулярного выражения, если бы вы каждый раз составляли его. Это примерно на 7,5% быстрее для компиляции один раз, чем каждый раз, но всего на 2,5% быстрее компилировать, чем компилировать.

test_set был в два раза медленнее, чем re_search, и трижды медленнее, чем re_match

test_not_any был на порядок ниже, чем test_set

TL; DR: используйте re.match или re.search

Ответ 6

Используйте Python Sets, когда вам нужно сравнить hm... наборы данных. Строки могут быть представлены в виде наборов символов довольно быстро. Здесь я проверяю, разрешена ли строка телефонного номера. Первая строка разрешена, вторая нет. Работает быстро и просто.

In [17]: timeit.Timer("allowed = set('0123456789+-() ');p = set('+7(898) 64-901-63 ');p.issubset(allowed)").timeit()

Out[17]: 0.8106249139964348

In [18]: timeit.Timer("allowed = set('0123456789+-() ');p = set('+7(950) 64-901-63 фыв');p.issubset(allowed)").timeit()

Out[18]: 0.9240323599951807

Никогда не используйте регулярные выражения, если вы можете избежать их.