python - online - ¿Cómo verifico que una cadena solo contiene letras, números, guiones bajos y guiones?

python split regex

Question

Sé cómo hacer esto si repito todos los caracteres de la cadena, pero estoy buscando un método más elegante.

Answer 1

¡use una expresión regular y vea si coincide!

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

Answer 2

Aquí hay algo basado en el "enfoque ingenuo" de Jerub (¡siendo ingenuo sus palabras, no las mías!):

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

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

Si ALLOWED era una cadena, entonces creo que c in ALLOWED implicaría iterar sobre cada carácter en la cadena hasta que encuentre una coincidencia o llegue al final. Lo cual, para citar a Joel Spolsky, es algo así como un algoritmo de Shlemiel the Painter .

Pero probar la existencia en un conjunto debería ser más eficiente, o al menos menos dependiente de la cantidad de caracteres permitidos. Ciertamente, este enfoque es un poco más rápido en mi máquina. Está claro y creo que funciona bastante bien para la mayoría de los casos (en mi máquina lenta puedo validar decenas de miles de cadenas cortas en una fracción de segundo). Me gusta.

REALMENTE en mi máquina una expresión regular funciona varias veces más rápido, y es tan simple como esto (podría decirse que más simple). Entonces, ese es probablemente el mejor camino a seguir.

Answer 3

Bueno, puedes pedir la ayuda de Regex, el gran aquí :)

código:

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''

Salida:

yes  

Espero que esto ayude :)

Answer 4

Como alternativa al uso de expresiones regulares, puedes hacerlo en Conjuntos:

from sets import Set

allowed_chars = Set(''0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-'')

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

Answer 5

Hay una variedad de formas de lograr este objetivo, algunas son más claras que otras. Para cada uno de mis ejemplos, ''Verdadero'' significa que la secuencia que se pasa es válida, ''Falsa'' significa que contiene caracteres no válidos.

En primer lugar, está el enfoque ingenuo:

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

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

Luego está el uso de una expresión regular, puede hacer esto con re.match (). Tenga en cuenta que ''-'' debe estar al final de [] de lo contrario se usará como un delimitador ''rango''. También tenga en cuenta el $ que significa ''final de la cadena''. Otras respuestas indicadas en esta pregunta usan una clase de caracteres especial, ''/ w'', siempre prefiero usar un rango de clase de caracteres explícito usando [] porque es más fácil de entender sin tener que buscar una guía de referencia rápida, y más fácil de especializar. caso.

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

Otra solución señaló que puede hacer una combinación inversa con expresiones regulares, lo he incluido aquí ahora. Tenga en cuenta que [^ ...] invierte la clase de caracteres porque se usa ^

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

También puede hacer algo complicado con el objeto ''establecer''. Eche un vistazo a este ejemplo, que elimina de la cadena original todos los caracteres que están permitidos, dejándonos con un conjunto que contiene a) nada, o b) los caracteres ofensivos de la cadena:

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

Answer 6

Si no fuera por los guiones y los guiones bajos, la solución más fácil sería

my_little_string.isalnum()

(Sección 3.6.1 de la Referencia de la Biblioteca de Python)

Answer 7

Siempre puedes usar una lista de comprensión y verificar los resultados con todo, sería un poco menos intensivo en recursos que usar una expresión regular: all([c in string.letters + string.digits + ["_", "-"] for c in mystring])

Answer 8

Una expresión regular hará el truco con muy poco código:

import re

...

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

Answer 9

[Editar] Hay otra solución aún no mencionada, y parece superar a los otros dados hasta ahora en la mayoría de los casos.

Utilice string.translate para reemplazar todos los caracteres válidos en la cadena, y vea si nos quedan algunos inválidos. Esto es bastante rápido ya que usa la función C subyacente para hacer el trabajo, con muy poco bytecode de python involucrado.

Obviamente, el rendimiento no lo es todo; ir por las soluciones más legibles es probablemente el mejor enfoque cuando no está en un código de ruta crítico, pero para ver cómo se compaginan las soluciones, aquí hay una comparación de rendimiento de todos los métodos propuestos hasta ahora. check_trans es el que usa el método string.translate.

Código de prueba:

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

Los resultados en mi sistema son:

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

El enfoque de traducción parece ser el mejor en la mayoría de los casos, de forma espectacular con cadenas largas válidas, pero es superado por expresiones regulares en test_long_invalid (Presumiblemente porque la expresión regular puede rescatar inmediatamente, pero la traducción siempre tiene que analizar toda la cadena). Los enfoques establecidos suelen ser peores, superando las expresiones regulares solo para el caso de cadena vacía.

Usar todo (x en permitido_juego para x en s) funciona bien si se rescata temprano, pero puede ser malo si tiene que recorrer cada carácter. isSubSet y set difference son comparables, y son consistentemente proporcionales a la longitud de la cadena, independientemente de los datos.

Hay una diferencia similar entre los métodos regex que coinciden con todos los caracteres válidos y la búsqueda de caracteres no válidos. La coincidencia funciona un poco mejor cuando se busca una cadena larga, pero totalmente válida, pero peor para los caracteres no válidos cerca del final de la cadena.

Answer 10

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

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