efficacement la vérification de cette chaîne se compose d'un personnage dans Python

Ce qui est un moyen efficace pour vérifier qu'une chaîne de caractères s en Python se compose d'un seul caractère, disons 'A'? Quelque chose comme all_equal(s, 'A') qui se comporte comme ceci:

all_equal("AAAAA", "A") = True

all_equal("AAAAAAAAAAA", "A") = True

all_equal("AAAAAfAAAAA", "A") = False

Deux apparemment inefficace, seraient les suivants: d'abord convertir la chaîne en une liste et vérifier chaque élément, ou de seconde pour utiliser une expression régulière. Existe-il des moyens plus efficaces ou sont-ils les meilleurs, on peut le faire en Python? Merci.

Je suis un peu surpris pas encore posé la question suivante: qu'est-ce que la structure de la "non uniforme" les chaînes de la saisie? Si il y en a un (c'est à dire qu'ils ne sont pas complètement au hasard), vous pouvez utiliser les connaissances à ce sujet pour optimiser votre algorithme.
L'efficacité de ce vraiment important? Je me demande quel genre d'application aurait cette vérification dans le goulot d'étranglement de code.
À mon avis, l'efficacité de la que rarement, il peut être important, mais qui sait? De toute façon, la tâche est agréable, et la compréhension de ce qui se passe à l'intérieur du code, et pourquoi certaines solutions sont lents, et certains sont rapides, est une formation utile pour un développeur Python.

InformationsquelleAutor | 2013-01-14

python string

108

C'est de loin le plus rapide, plusieurs fois plus rapide que même count(), juste le temps avec cet excellent mgilson moment suite:
```
s == len(s) * s[0]
```
Ici tous la vérification se fait à l'intérieur de l'Python code C qui vient:
- alloue len(s) caractères;
- remplit l'espace avec le premier caractère;
- compare deux chaînes de caractères.
Plus la série est longue, plus grande est des bonus de temps. Cependant, comme mgilson écrit, il crée une copie de la chaîne, donc si votre chaîne est de longueur plusieurs millions de signes, il peut devenir un problème.

Comme on peut le voir à partir des résultats de minutage, généralement des moyens les plus rapides pour résoudre la tâche de ne pas exécuter n'importe quel code Python pour chaque symbole. Cependant, la set() solution aussi fait tout le travail à l'intérieur C le code de la bibliothèque Python, mais il est encore lent, probablement en raison de l'exploitation de la chaîne par le biais de Python interface d'un objet.

UPD: Concernant la chaîne vide en cas. Quoi faire avec elle, dépend fortement de la tâche. Si la tâche est de "vérifier si tous les symboles en une chaîne de caractères sont les mêmes", s == len(s) * s[0] est une réponse valide (pas de symboles signifient une erreur, et l'exception est ok). Si la tâche est de "vérifier si il y a exactement un symbole unique", une chaîne vide devrait nous donner de Faux, et la réponse est s and s == len(s) * s[0], ou bool(s) and s == len(s) * s[0] si vous préférez recevoir des valeurs booléennes. Enfin, si nous comprenons la tâche comme "vérifier si il n'y a pas de symboles", le résultat pour la chaîne vide est Vrai, et la réponse est not s or s == len(s) * s[0].
- C'est probablement beats comte dans la non-égalité des cas, car il peut court-circuit de la comparaison de chaînes de caractères. Elle toujours me surprend qu'il gagne très bien si. Il semble que count devrait être une simple boucle qui ferait environ la même quantité de travail que le remplissage de l'espace permettrait de le faire. Je suppose que le remplissage est probablement fait par le biais de certaines impressionnant vectorisé/code optimisé dans le C de la bibliothèque string. (Comme c'est la comparaison qui peut être court-circuitée).
- Je pense que count() recherche une chaîne, pas pour un seul caractère. Probablement son algorithme est beaucoup plus complexe que de simples strncmp() dans la comparaison de deux chaînes de caractères. Si il y avait un cas particulier de la fonction count() recherche pour un seul personnage, ce serait beaucoup plus rapide, mais il n'est apparemment pas un tel cas.
- Ahh, à droite. Qui doit être le cas. J'avais oublié que count pourrait fonctionner sur les cordes avec plus de longueur que de 1 :). Je suis bête.
- Que si s est la chaîne vide?
- Est == profitant de la machine au niveau de "mot" de comparaisons pour une rapide comparaison des chaînes? Ainsi, sur un système 64 bits correspondant à 4 ou 8 caractères à la fois. Pour battre le problème de la mémoire, vous pouvez parcourir et match contre une chaîne de caractères fixe s[0]*1024 et plus jusqu'à la fin. lol belle réponse!
- lol strmul, et à un certain degré, le comte, comme la chaîne d'échelles. Voici les fois que je reçois une source de la chaîne de 1024 caractères: [('test_strmul', 0.9134591826614835), ('test_set', 45.61518321462644), ('test_count', 2.706394388113573)]
- chaîne vide demande de vérifier, ici, nous étions juste à tester les idées. En plus, je ne sais pas quoi dire sur les cordes à vide, Vrai ou Faux (c'est la question de "vérifier si une chaîne contient EXACTEMENT UN unique cheracter", ou "vérifier si il n'y a pas plus d'un caractère unique"). Selon que la réponse est "pas de s ou s[0] * len(s) == s" ou "s et s[0] * len(s) == s"
- En tant que mathématicien, mon instinct me dit que la fonction doit retourner True si s est la chaîne vide. Mais l'OP doit vraiment indiquer.
- Vous dites " Si la tâche est de "vérifier si tous les symboles en une chaîne de caractères sont les mêmes"... [puis lancer une exception est fine]'. Je suis en désaccord. Tous les symboles à la chaîne vide sont les mêmes, dans le sens que vous ne pouvez pas me montrer deux symboles différents qui sont dans la chaîne vide.
- "Tous les symboles à la chaîne vide sont les mêmes"? Je dirais plutôt qu'aucun d'entre eux sont différents. Quel est le point principal: l'existence de l'égalité, ou l'absence de pas égaux? 🙂 C'est comme une question "qui sont des points d'un cas particulier de l'infiniment court ligne?" Purement dépend de la première série de définitions. Donc, je trouve toutes les trois options possibles.
- Sûrement, il doit être s == len(s) * c[0] comme il me semble s == len(s) * s[0] juste des tests qu'une chaîne est composée d'un même caractère. Alors qu'à l'origine de l'OP était ce qui implique qu'il y avait 2 variables s(tring) à tester et (c)du caractère à vérifier.
InformationsquelleAutor Ellioh
42
```
>>> s = 'AAAAAAAAAAAAAAAAAAA'
>>> s.count(s[0]) == len(s)
True
```
Ce n'est pas de court-circuit. Une version qui ne court-circuit:
```
>>> all(x == s[0] for x in s)
True
```
Cependant, j'ai le sentiment qu'en raison de la l'C optimisés mise en œuvre, la non-court-circuit version sera probablement plus performant sur certaines chaînes (en fonction de la taille, etc)

Ici est un simple timeit script pour tester quelques-uns des autres options posté le:
```
import timeit
import re

def test_regex(s,regex=re.compile(r'^(.)*$')):
    return bool(regex.match(s))

def test_all(s):
    return all(x == s[0] for x in s)

def test_count(s):
    return s.count(s[0]) == len(s)

def test_set(s):
    return len(set(s)) == 1

def test_replace(s):
    return not s.replace(s[0],'')

def test_translate(s):
    return not s.translate(None,s[0])

def test_strmul(s):
    return s == s[0]*len(s)

tests = ('test_all','test_count','test_set','test_replace','test_translate','test_strmul','test_regex')

print "WITH ALL EQUAL"
for test in tests:
    print test, timeit.timeit('%s(s)'%test,'from __main__ import %s; s="AAAAAAAAAAAAAAAAA"'%test)
    if globals()[test]("AAAAAAAAAAAAAAAAA") != True:
        print globals()[test]("AAAAAAAAAAAAAAAAA")
        raise AssertionError

print
print "WITH FIRST NON-EQUAL"
for test in tests:
    print test, timeit.timeit('%s(s)'%test,'from __main__ import %s; s="FAAAAAAAAAAAAAAAA"'%test)
    if globals()[test]("FAAAAAAAAAAAAAAAA") != False:
        print globals()[test]("FAAAAAAAAAAAAAAAA")
        raise AssertionError
```
Sur ma machine (OS X 10.5.8, core2duo, python2.7.3) avec ces artificiel (court) les chaînes de caractères, str.count fume set et all, et bat str.replace par un peu, mais il est devancé par str.translate et strmul est actuellement en tête par une bonne marge:
```
WITH ALL EQUAL
test_all 5.83863711357
test_count 0.947771072388
test_set 2.01028490067
test_replace 1.24682998657
test_translate 0.941282987595
test_strmul 0.629556179047
test_regex 2.52913498878

WITH FIRST NON-EQUAL
test_all 2.41147494316
test_count 0.942595005035
test_set 2.00480484962
test_replace 0.960338115692
test_translate 0.924381017685
test_strmul 0.622269153595
test_regex 1.36632800102
```
Le timing risque d'être un peu (ou même de manière significative?) différents entre les différents systèmes et différentes chaînes, alors que ce serait intéressant de regarder dans une chaîne de caractères que vous avez l'intention de passer.

Finalement, si vous frappez le meilleur des cas pour all assez, et vos chaînes sont assez longtemps, vous pourriez envisager qu'un. C'est un meilleur algorithme ... je voudrais éviter les set solution mais comme je ne vois pas de cas où il pourrait battre la count solution.

Si la mémoire pourrait être un problème, vous aurez besoin pour éviter str.translate, str.replace et strmul que ceux de créer une deuxième chaîne, mais ce n'est pas un sujet de préoccupation ces jours-ci.
- WOW! Il semble que j'ai trouvé une version plus rapide: s == len(s) * s[0]
- En effet, vous avez. des acclamations.
- +1 pour réellement mesurer
- Vous ne savez jamais vraiment rien jusqu'à ce que vous avez réellement mesurer 🙂
- Comment le RE ^(.)\1*$ comparer?
- Je ne sais pas? Désolé, je ne suis pas une regex gourou, de sorte que vous pourriez avoir besoin de sort de ça pour moi afin que je puisse l'ajouter à la suite de test.
- Et je ne suis pas un régulier Python programmeur. Mais quelque chose comme re.match('^(1)\1*$', s).
- Votre regex solution est dans le milieu quelque part. C'est pas mal.
- '^' dans la regex n'est pas requis pour le match(), et la suppression de '^' rend les regex solution un peu plus vite.
InformationsquelleAutor mgilson
15

Vous pouvez convertir à un ensemble et vérifier qu'il n'y est qu'un seul membre:
```
len(set("AAAAAAAA"))
```
InformationsquelleAutor Daniel Roseman
12

Essayez d'utiliser la fonction intégrée all:
```
all(c == 'A' for c in s)
```
- à l'aide de is est effectivement plus rapide, stackoverflow.com/a/14321001/1561176
- Ces différences de temps sont de l'ordre de 1% -- Ce n'est pas la peine de s'inquiéter à propos de mon humble avis. Surtout considérant que is est en s'appuyant sur un Cpython détail d'implémentation.
- Je ne me souviens pas exactement où je l'ai lu, mais je me souviens que lorsque vous traitez avec des char comparaison de son mieux pour utiliser is.
- J'en doute. Autant que je sache, il n'y a aucune garantie que les caractères sont des singletons (mais je suppose que je peux me tromper à ce sujet)
- Je ne pense pas que is est garanti pour fonctionner. Elle s'appuie sur un détail de l'implémentation de l'interprète, à savoir un stage de cordes, qui n'est pas garanti selon le Python spec autant que je me souvienne. Oui, il sera probablement de travail partout au moins pour de courtes chaînes, mais "probablement" n'est pas vraiment la meilleure chose à compter.
- seulement si vous voulez vraiment le caisson vide sémantique de all
InformationsquelleAutor Mark Byers
6

Ajoutant une autre solution à ce problème
```
>>> not "AAAAAA".translate(None,"A")
True
```
- Étonnamment, translate est gagnant dans mes timings ... (mais pas de beaucoup) (+1).
- Et, apparemment, ne pas gagner trop longtemps. Vous avez été battu par s == s[0]*len(s) 🙂
InformationsquelleAutor Abhijit
5

Si vous avez besoin de vérifier si tous les caractères de la chaîne sont les mêmes et est égale à un personnage donné, vous devez supprimer tous les doublons et de vérifier si le résultat final est égal au caractère unique.
```
>>> set("AAAAA") == set("A")
True
```
Dans le cas où vous souhaitez déterminer s'il existe un double, il suffit de cocher la longueur
```
>>> len(set("AAAAA")) == 1
True
```
InformationsquelleAutor Abhijit
3

Intéressant de réponses. Voici un autre:
```
flag = True
for c in 'AAAAAAAfAAAA':
    if not c == 'A': 
        flag = False
        break
```
Le seul avantage que je peux penser à la mienne, c'est qu'il n'est pas nécessaire de parcourir l'ensemble de la chaîne si elle trouve un caractère incohérent.
- c'est ce que all fait aussi bien. une fois qu'il trouve une valeur qui est faux, il s'arrête.
- Intéressant. Du sens. Encore, sans doute plus efficace que la méthode de jeu, non?
- vous pouvez vérifier vous-même avec timeit
- -1 Ceci repose sur la mise en œuvre des détails que seule les caractères de la chaîne sont internés sur disponible, et échoue sur jython.
- Merci pour les commentaires @phihag , j'ai appris quelque chose de nouveau, et ont mis à jour pour faire jython compatible.
InformationsquelleAutor Master_Yoda
2
```
not len("AAAAAAAAA".replace('A', ''))
```
- pas len("AAAAAAAAA".replace('A', ")) #0 signifie Vrai, afin de ne pas l'exploitant est tenu
- la droite. Merci pour la correction moi 🙂
- Fait un ajout à votre calendrier suite. Ma version est encore bien pire que la fonction count() si la chaîne consiste en Un "s", mais un peu mieux quand le premier caractère est "f".
InformationsquelleAutor Ellioh

Vous devez vous connecter pour publier un commentaire.