Est-il une meilleure façon de trouver si la chaîne contient des chiffres?

Je travaille avec des chaînes de caractères qui contiennent à la fois des chiffres et des caractères alphanumériques, ou tout simplement des chiffres, mais pas seulement alphas. Afin de tester les mauvais résultats, j'ai besoin de vérifier si les chaînes de caractères contenant au moins un chiffre, l'impression d'un message d'erreur s'il ne le fait pas. J'ai été en utilisant le code suivant:

s = '0798237 sh 523-123-asdjlh'

def contains_digits(s):
    for char in list(s):
        if char.isdigit():
            return True
            break
    return False

if contains_digits(s) == True:
    print s
else:
    print 'Error'

Est-il plus pythonic ou de façon plus simple de le faire, ou cela suffit-il? Aussi, je ne peux pas juste vérifier pour voir si la chaîne est alphanumérique, parce que la chaîne peut contenir des symboles différents ('-', espaces, etc.)

Par la voie, contains_digits == True est redondante. Vous pouvez déposer le == True partie et il va fonctionner de la même manière.

OriginalL'auteur aensm | 2012-06-27

python string

C'est un de ces endroits où une expression régulière est juste la chose:

_digits = re.compile('\d')
def contains_digits(d):
    return bool(_digits.search(d))

Petite démo:

>>> _digits = re.compile('\d')
>>> def contains_digits(d):
...     return bool(_digits.search(d))
... 
>>> contains_digits('0798237 sh 523-123-asdjlh')
True
>>> contains_digits('sh asdjlh')
False

Vous pouvez utiliser le any méthode avec .isdigit() comme décrit dans @Wallacolloo réponse, mais c'est plus lent que la simple expression régulière:

>>> import timeit
>>> timeit.timeit("contains_digits('0798237 sh 523-123-asdjlh')", 'from __main__ import contains_digits')
0.77181887626647949
>>> timeit.timeit("contains_digits_any('0798237 sh 523-123-asdjlh')", 'from __main__ import contains_digits_any')
1.7796030044555664

La if méthode est sur le pair avec l'expression régulière:

>>> timeit.timeit("contains_digits_if('0798237 sh 523-123-asdjlh')", 'from __main__ import contains_digits_if')
0.87261390686035156

Mais les choses s'aggraver si les chiffres apparaissent plus tard dans le texte:

>>> timeit.timeit("contains_digits('asdjlhtaheoahueoaea 11 thou')", 'from __main__ import contains_digits')
1.202538013458252
>>> timeit.timeit("contains_digits_any('asdjlhtaheoahueoaea 11 thou')", 'from __main__ import contains_digits_any')
5.0348429679870605
>>> timeit.timeit("contains_digits_if('asdjlhtaheoahueoaea 11 thou')", 'from __main__ import contains_digits_if')
3.707183837890625

Timings testé sur la version 2.6 de python sur Mac OS X 10.7.

Pourquoi ne pas tout simplement return bool(_digits.search(d))?
Parce que je n'avais pas pensé à ça assez rapidement? 🙂
Le timeit résultats sur les miens sont à peu près la même chose... (d'environ .6 pour les deux)
Je reçois 0.84 s vs 0.96 s (2.7.3). Mais même le RE étaient plusieurs fois plus rapide, j'avais seulement l'utiliser si c'était un goulot d'étranglement. Je préfère de beaucoup écrit en Python.
ma conjecture est que le isdigit() test est inefficace; le plus de caractères, elle est appelée avant un chiffre est trouvé, le pire c'est.

OriginalL'auteur Martijn Pieters

12

Utiliser le any fonction, en passant dans une séquence.

Si tout élément de la séquence est vrai (c'est à dire est un chiffre, dans ce cas), puis any retourne True, sinon False. https://docs.python.org/library/functions.html#any
```
def contains_digits(s):
    return any(char.isdigit() for char in s)
```
Si vous êtes inquiet au sujet de la performance que votre méthode actuelle est effectivement plus rapide.

Malheureusement, dans ce cas particulier, cela fonctionne à la moitié de la vitesse d'une expression régulière.
Merci, tu ne connaissais pas le "tout" de la fonction. Il semble donc que python chaînes sont itératif, et "pour l'omble de s" se fera par le biais de chaque caractère dans la chaîne?
En effet, python chaînes sont séquences trop.
Pierre: Merci pour l'affichage de la référence. Je n'aurais jamais pu s'attendre à une expression régulière pour surpasser même unoptimized code comme celui-ci. Je ne pensais pas en termes de performance - si je l'étais, j'aurais évité any et écrit quelque chose comme ce que je suis sur le point de monter dans mon post, ce qui surpasse l'expression régulière de la solution (en 32 bits, la version 2.6 de Python sur Win7) d'environ 1.062 vs 1.254.
J'aurais attendu any pour être aussi rapide que ça, en fait.

OriginalL'auteur Ponkadoodle
1

Pour ceux qui recherchent la plus courte de la solution: any(d in s for d in'0123456789')

OriginalL'auteur Nickmaovich

Après la lecture de la discussion ci-dessus, j'ai été curieux de connaître les performances d'un jeu basé sur la version comme ceci:

def contains_digit(s, digits=set('0123456789')):
    return bool(digits.intersection(s))

Dans mes tests, cela a été un peu plus rapide en moyenne que les re version sur un ordinateur et un peu plus lent sur l'autre (?). Juste pour le fun, j'ai comparé par certains à d'autres versions.

import math
import re
import timeit
def contains_digit_set_intersection(s, digits=set('0123456789')):
return bool(digits.intersection(s))
def contains_digit_iter_set(s, digits=set('0123456789')):
for c in s:
if c in digits:
return True
return False
def contains_digit_iter_str(s, digits='0123456789'):
for c in s:
if c in digits:
return True
return False
def contains_digit_re(s, digits=re.compile(r'\d')):
return bool(digits.search(s))
def print_times(func, times):
name = func.__name__
average = sum(times) / len(times)
formatted_times = ' '.join('{:.3f}'.format(t) for t in times)
message = '{name:<31} {times} ~{average:.3f}'
print(message.format(name=name, times=formatted_times, average=average))
funcs = [
contains_digit_set_intersection,
contains_digit_iter_set,
contains_digit_iter_str,
contains_digit_re,
]
cases = [
'1bcdefg7',
'abcdefg7',
'abcdefgh',
'0798237 sh 523-123-asdjlh',
'asdjlhtaheoahueoaea 11 thou',
]
for func in funcs:
times = []
for case in cases:
func_case = '{func.__name__}("{case}")'.format(func=func, case=case)
time = timeit.timeit(func_case, globals={func.__name__: func})
times.append(time)
print_times(func, times)

Échantillon fonctionne pour les deux ordinateurs (de temps pour chaque cas, et le ~moyenne):

contains_digit_set_intersection 0.744 0.731 0.724 1.227 1.113 ~0.908
contains_digit_iter_set         0.264 0.541 0.566 0.260 1.068 ~0.540
contains_digit_iter_str         0.272 0.649 0.632 0.274 1.211 ~0.607
contains_digit_re               0.748 0.854 0.679 0.744 1.006 ~0.806
contains_digit_set_intersection 0.860 0.870 0.855 1.456 1.357 ~1.080
contains_digit_iter_set         0.285 0.613 0.617 0.307 1.163 ~0.597
contains_digit_iter_str         0.295 0.748 0.799 0.288 1.595 ~0.745
contains_digit_re               1.157 1.236 0.927 1.086 1.450 ~1.171

OriginalL'auteur

Vous devez vous connecter pour publier un commentaire.