首页 / 知识

关于python：如何验证字符串仅包含字母，数字，下划线和破折号？

2023-04-16 23:46:00

How do I verify that a string only contains letters, numbers, underscores and dashes?

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

正则表达式只需很少的代码即可完成操作：

1
2
3
4
5
6

import re

...

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

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

使用string.translate替换字符串中的所有有效字符，然后查看是否还有剩余的无效字符。这非常快，因为它使用基础C函数来完成工作，并且只涉及很少的python字节码。

显然性能不是全部-在性能不关键的代码路径中，采用可读性最高的解决方案可能是最好的方法，而只是为了查看解决方案的堆叠方式，这里是所有方法的性能比较到目前为止提出。 check_trans是使用string.translate方法的那个。

测试代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

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

我的系统上的结果是：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

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，则在allow_set中使用x在allowed_set中)表现良好，但是如果必须遍历每个字符，则可能会很糟糕。 isSubSet和set差异是可比较的，并且与字符串的长度成正比，而与数据无关。

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

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

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

1
2
3
4
5

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

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

然后使用正则表达式，您可以使用re.match()进行此操作。请注意，\\'-\\'必须位于[]的末尾，否则它将用作\\'range \\'分隔符。还要注意$，它表示\\'字符串的结尾\\'。这个问题中提到的其他答案使用特殊的字符类\\'\\\\\\\\ w \\'，我总是更喜欢使用[]作为显式的字符类范围，因为它更容易理解，而无需查找快速参考指南，而且更容易出现特殊情况。

1
2
3
4

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

另一种解决方案指出，您可以对正则表达式进行逆向匹配，我现在将其包括在此处。请注意，[^ ...]会反转字符类，因为使用了^：

1
2
3

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

您也可以使用\\'set \\'对象做一些棘手的事情。看一下这个示例，该示例从原始字符串中删除了所有允许的字符，从而为我们提供了一个包含以下内容的集合：a)无，或b)字符串中令人反感的字符：

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

如果不使用破折号和下划线，则最简单的解决方法是

1	my_little_string.isalnum()

(Python库参考的3.6.1节)

作为使用正则表达式的替代方法，您可以在Sets中进行：

1
2
3
4
5
6
7

from sets import Set

allowed_chars = Set('0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-')

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

1
2
3
4

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

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

正则表达式可以非常灵活。

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

\\w：仅[a-zA-Z0-9_]

因此您需要添加- char以证明连字符char。

+：匹配前一个字符的一个或多个重复。我猜您不接受空白输入。但是，如果这样做，请更改为*。

^：匹配字符串的开头。

$：匹配字符串的结尾。

您需要使用这两个特殊字符，因为您需要避免以下情况。像&这样的多余字符可能会出现在匹配的模式之间。

&&&PATTERN&&PATTERN

好吧，您可以向regex寻求帮助，这里很棒：)

代码：

1
2
3
4
5
6
7
8

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

希望这会有所帮助：)

这是基于Jerub "天真的方法"(天真是他的话，不是我的话！)的内容：

1
2
3
4
5