我知道如何遍历字符串中的所有字符，但是我正在寻找一种更优雅的方法。

解决方案

使用正则表达式，看看是否匹配！

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

正则表达式只需很少的代码即可解决问题：

import re

...

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

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

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

我们始终可以使用列表推导并全部检查结果，这比使用正则表达式要少一些资源：all([c in string.letters + string.digits + [" _"，"-"] for mystring中的c])

有多种方法可以实现此目标，有些方法比其他方法更清晰。对于我的每个示例，" True"表示传递的字符串有效，" False"表示包含无效字符。

首先，有一个幼稚的方法：

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)

我们也可以对"设置"对象进行一些棘手的操作。看一下这个示例，该示例从原始字符串中删除了所有允许的字符，从而为我们提供了一个包含以下内容的集合：a)没有任何内容，或者b)字符串中令人反感的字符：

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

作为使用正则表达式的替代方法，我们可以在Sets中完成：

from sets import Set

allowed_chars = Set('0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-')

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

如果不是破折号和下划线，最简单的解决方案是

my_little_string.isalnum()

(《 Python库参考》的3.6.1节)

[编辑]还有一个尚未提及的解决方案，在大多数情况下，它似乎胜过其他解决方案。

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

在大多数情况下，转换方法似乎是最好的，对于长有效字符串来说尤其如此，但是在test_long_invalid中，正则表达式会击败它(大概是因为正则表达式可以立即纾困，但是转换始终必须扫描整个字符串)。设置方法通常是最糟糕的，仅在空字符串情况下才击败正则表达式。

如果使用all(x in allowed_set中的x for s中的x in)效果好，则可以尽早解决，但如果必须迭代每个字符，则效果会很差。 isSubSet和set差异是可比较的，并且无论数据如何，其始终与字符串的长度成比例。

匹配所有有效字符和搜索无效字符的regex方法之间存在相似的区别。当检查一个较长但完全有效的字符串时，匹配的性能要好一些，但在字符串末尾的无效字符时，匹配的性能会更好。