Как убедиться, что строка содержит только буквы, цифры, подчеркивания и дефисы?

Я знаю, как это сделать, если перебираю все символы в строке, но я ищу более элегантный метод.

Регулярное выражение поможет с минимальным количеством кода:

import re

...

if re.match("^[A-Za-z0-9_-]*$", my_little_string):
    # do something here

[Edit] Есть еще одно решение, которое еще не упоминалось, и в большинстве случаев оно, кажется, превосходит другие, приведенные до сих пор.

Используйте string.translate, чтобы заменить все допустимые символы в строке, и посмотрите, остались ли у нас недопустимые. Это довольно быстро, так как для выполнения работы используется базовая функция C с очень небольшим байт-кодом Python.

Очевидно, что производительность - это еще не все - выбор наиболее удобочитаемых решений, вероятно, является лучшим подходом, когда не в критическом для производительности кодовом пути, а просто для того, чтобы увидеть, как решения складываются, вот сравнение производительности всех методов, предложенных на данный момент. check_trans - это тот, который использует метод string.translate.

Код теста:

import string, re, timeit

pat = re.compile('[\w-]*$')
pat_inv = re.compile ('[^\w-]')
allowed_chars=string.ascii_letters + string.digits + '_-'
allowed_set = set(allowed_chars)
trans_table = string.maketrans('','')

def check_set_diff(s):
    return not set(s) - allowed_set

def check_set_all(s):
    return all(x in allowed_set for x in s)

def check_set_subset(s):
    return set(s).issubset(allowed_set)

def check_re_match(s):
    return pat.match(s)

def check_re_inverse(s): # Search for non-matching character.
    return not pat_inv.search(s)

def check_trans(s):
    return not s.translate(trans_table,allowed_chars)

test_long_almost_valid='a_very_long_string_that_is_mostly_valid_except_for_last_char'*99 + '!'
test_long_valid='a_very_long_string_that_is_completely_valid_' * 99
test_short_valid='short_valid_string'
test_short_invalid='/$%$%&'
test_long_invalid='/$%$%&' * 99
test_empty=''

def main():
    funcs = sorted(f for f in globals() if f.startswith('check_'))
    tests = sorted(f for f in globals() if f.startswith('test_'))
    for test in tests:
        print "Test %-15s (length = %d):" % (test, len(globals()[test]))
        for func in funcs:
            print "  %-20s : %.3f" % (func, 
                   timeit.Timer('%s(%s)' % (func, test), 'from __main__ import pat,allowed_set,%s' % ','.join(funcs+tests)).timeit(10000))
        print

if __name__=='__main__': main()

Результаты в моей системе:

Test test_empty      (length = 0):
  check_re_inverse     : 0.042
  check_re_match       : 0.030
  check_set_all        : 0.027
  check_set_diff       : 0.029
  check_set_subset     : 0.029
  check_trans          : 0.014

Test test_long_almost_valid (length = 5941):
  check_re_inverse     : 2.690
  check_re_match       : 3.037
  check_set_all        : 18.860
  check_set_diff       : 2.905
  check_set_subset     : 2.903
  check_trans          : 0.182

Test test_long_invalid (length = 594):
  check_re_inverse     : 0.017
  check_re_match       : 0.015
  check_set_all        : 0.044
  check_set_diff       : 0.311
  check_set_subset     : 0.308
  check_trans          : 0.034

Test test_long_valid (length = 4356):
  check_re_inverse     : 1.890
  check_re_match       : 1.010
  check_set_all        : 14.411
  check_set_diff       : 2.101
  check_set_subset     : 2.333
  check_trans          : 0.140

Test test_short_invalid (length = 6):
  check_re_inverse     : 0.017
  check_re_match       : 0.019
  check_set_all        : 0.044
  check_set_diff       : 0.032
  check_set_subset     : 0.037
  check_trans          : 0.015

Test test_short_valid (length = 18):
  check_re_inverse     : 0.125
  check_re_match       : 0.066
  check_set_all        : 0.104
  check_set_diff       : 0.051
  check_set_subset     : 0.046
  check_trans          : 0.017

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

Использование all (x в разрешенном_наборе вместо x в s) хорошо работает, если он выйдет из строя раньше, но может быть плохим, если ему придется перебирать каждый символ. isSubSet и разница наборов сопоставимы и неизменно пропорциональны длине строки независимо от данных.

Аналогичная разница между методами регулярного выражения, сопоставляющими все допустимые символы, и поиском недопустимых символов. Сопоставление выполняется немного лучше при проверке длинной, но полностью допустимой строки, но хуже при проверке недопустимых символов в конце строки.

Есть множество способов достичь этой цели, некоторые из них более понятны, чем другие. Для каждого из моих примеров «Истина» означает, что переданная строка действительна, «Ложь» означает, что она содержит недопустимые символы.

Во-первых, наивный подход:

import string
allowed = string.letters + string.digits + '_' + '-'

def check_naive(mystring):
    return all(c in allowed for c in mystring)

Затем можно использовать регулярное выражение, это можно сделать с помощью re.match (). Обратите внимание, что «-» должен стоять в конце [], иначе он будет использоваться как разделитель «диапазона». Также обратите внимание на $, что означает «конец строки». В других ответах, упомянутых в этом вопросе, используется специальный класс символов '\ w', я всегда предпочитаю использовать явный диапазон классов символов с помощью [], потому что его легче понять, не просматривая краткое справочное руководство, и проще использовать специальные кейс.

import re
CHECK_RE = re.compile('[a-zA-Z0-9_-]+$')
def check_re(mystring):
    return CHECK_RE.match(mystring)

В другом решении отмечалось, что вы можете выполнять обратное сопоставление с регулярными выражениями, я включил это здесь сейчас. Обратите внимание, что [^ ...] инвертирует класс символов, потому что используется ^:

CHECK_INV_RE = re.compile('[^a-zA-Z0-9_-]')
def check_inv_re(mystring):
   return not CHECK_INV_RE.search(mystring)

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

def check_set(mystring):
    return not set(mystring) - set(allowed)

Если бы не дефисы и подчеркивания, самым простым решением было бы

my_little_string.isalnum()

(Раздел 3.6.1 Справочника по библиотеке Python)

В качестве альтернативы использованию регулярного выражения вы можете сделать это в наборах:

from sets import Set

allowed_chars = Set('0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-')

if Set(my_little_sting).issubset(allowed_chars):
    # your action
    print True

 pat = re.compile ('[^\w-]')

 def onlyallowed(s):
    return not pat.search (s)

Регулярное выражение может быть очень гибким.

import re;
re.fullmatch("^[\w-]+$", target_string) # fullmatch looks also workable for python 3.4

\w: Только [a-zA-Z0-9_]

Поэтому вам нужно добавить -char для выравнивания дефиса char.

+: Соответствует одному или нескольким повторениям предыдущего символа. Я думаю, вы не принимаете пустой ввод. Но если вы это сделаете, измените на *.

^: Соответствует началу строки.

$: Соответствует концу строки.

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

&&&PATTERN&&PATTERN

Ну, вы можете попросить помощи регулярного выражения, здесь здорово :)

код:

import re

string = 'adsfg34wrtwe4r2_()' #your string that needs to be matched.
regex = r'^[\w\d_()]*$' # you can also add a space in regex if u want to allow it in the string  
if re.match(regex,string):
    print 'yes'
else: 
    print 'false'

Выход:

yes  

Надеюсь это поможет :)

Вы всегда можете использовать понимание списка и проверить результаты со всеми, это будет немного менее ресурсоемко, чем использование регулярного выражения: all([c in string.letters + string.digits + ["_", "-"] for c in mystring])

Вот что-то, основанное на «наивном подходе» Джеруба (наивно его слова, а не мои!):

import string
ALLOWED = frozenset(string.ascii_letters + string.digits + '_' + '-')

def check(mystring):
    return all(c in ALLOWED for c in mystring)

Если бы это ALLOWEDбыла строка, я думаю, c in ALLOWEDчто потребовалось бы перебирать каждый символ в строке, пока он не нашел совпадение или не достиг конца. Что, по словам Джоэла Спольски, является чем-то вроде алгоритма Шлемиэля Художника .

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

ДЕЙСТВИТЕЛЬНО на моей машине регулярное выражение работает в несколько раз быстрее и так же просто (возможно, проще). Так что это, вероятно, лучший путь вперед.

используйте регулярное выражение и посмотрите, соответствует ли оно!

([a-z][A-Z][0-9]\_\-)*