Le comte de lettres dans un mot en python de débogage

Je suis en train de compter le nombre de " e " apparaît dans un mot.

def has_no_e(word):     #counts 'e's in a word
    letters = len(word)
    count = 0
    while letters >= 0:
        if word[letters-1] == 'e':
            count = count + 1
        letters = letters - 1
    print count

Il semble que cela fonctionne bien sauf lorsque le mot se termine par un "e". Il comptera que 'e' deux fois. Je n'ai aucune idée pourquoi. Toute aide?

Je sais que mon code ne peut être bâclée, je suis un débutant! Je suis juste essayer de comprendre la logique derrière ce qui se passe.

Quand les lettres == 0 ce qui va arriver? Pourquoi êtes-vous tester pour while letters >= 0? Pouvez-vous expliquer pourquoi vous êtes en train de faire cela? Une explication serait utile.

OriginalL'auteur Johnny | 2010-12-30

10

Que d'autres mentionnent, vous pouvez mettre en œuvre le test avec un simple word.count('e'). Sauf si vous faites cela comme un simple exercice, c'est beaucoup mieux que d'essayer de réinventer la roue.

Le problème avec votre code est qu'il compte le dernier caractère à deux reprises parce que vous passez le test de l'indice de -1 à la fin, ce qui en Python renvoie le dernier caractère de la chaîne. Réparer en changeant while letters >= 0 à while letters > 0.

Il y a d'autres façons que vous pouvez nettoyer votre code (en supposant que c'est un exercice d'apprentissage):
- Python fournit un moyen agréable de parcourir une chaîne de caractères à l'aide d'un for boucle. C'est beaucoup plus concis et plus facile à lire qu'à l'aide d'un while boucle et de maintenir votre propre variable de compteur. Comme vous l'avez déjà vu ici, en ajoutant de la complexité des résultats dans les bogues. Garder les choses simples.
- La plupart des langues de fournir un += opérateur, qui pour les entiers ajoute le montant d'une variable. C'est plus concis que count = count + 1.
- Utiliser un paramètre pour définir le personnage que vous faites le décompte de la rendre plus souple. Définir une valeur par défaut de l'argument pour l'utilisation de char='e' dans la liste des paramètres lorsque vous avez un évident défaut.
- Choisir un nom plus approprié pour la fonction. Le nom has_no_e() rend le lecteur pense que le code vérifie si le code n'a pas e, mais ce qu'il fait réellement est compte les occurrences de e.
Mettre tous ensemble, nous obtenons:
```
def count_letter(word, char='e'):
    count = 0
    for c in word:
        if c == char:
            count += 1
    return count
```
Quelques tests:
```
>>> count_letter('tee')
2
>>> count_letter('tee', 't')
1
>>> count_letter('tee', 'f')
0
>>> count_letter('wh' + 'e'*100)
100
```
OriginalL'auteur marcog

>>> word = 'eeeooooohoooooeee'
>>> word.count('e')
6

Pourquoi pas?

OriginalL'auteur user225312

Pourquoi ne pas tout simplement

def has_no_e(word):
    return sum(1 for letter in word if letter=="e")

OriginalL'auteur Tim Pietzcker

1

Le problème est que la dernière valeur de 'lettres' dans votre itération est "0", et quand cela arrive vous regardez:
```
  word[letters-1]
```
sens, vous regardez word[-1], qui en python signifie "la dernière lettre du mot".

si vous êtes réellement en compte correctement, et l'ajout d'un "bonus" si la dernière lettre est un "e".

OriginalL'auteur Yonatan
1

Il va compter deux fois quand se terminant par un e parce que vous décrémenter letters une fois de trop (parce qu'on boucle tout en letters >= 0 et vous devriez être en boucle tout en letters > 0). Lorsque letters atteint zéro, vous vérifiez word[letters-1] == word[-1] qui correspond à la dernière lettre dans le mot.

OriginalL'auteur Klaus Byskov Pedersen
1

Beaucoup de ces solutions fonctionnent bien.

Savoir que, en Python, liste[-1] renvoie le dernier élément de la liste.

Donc, dans votre code, quand vous étiez référencement word[lettres-1] dans une boucle while contraint par lettres >= 0, le " e " à la fin du mot deux fois (une fois, quand les lettres a la longueur-1 et une seconde fois lorsque les lettres a 0).

Par exemple, si ma parole a été "Pete" votre code de trace devrait ressembler à ceci (si vous avez imprimé le mot[lettre] de chaque boucle.

e (pour word[3])
t (pour word[2])
e (pour word[1])
P (mot[0])
e (pour word[-1])

Espère que cela aide à clarifier les choses et de révéler un intéressant petit caprice à propos de Python.

OriginalL'auteur sjberry

@marcog fait quelques excellents points;

en attendant, vous pouvez faire la correction simple en insérant des instructions d'impression -

def has_no_e(word):
    letters = len(word)
    count = 0
    while letters >= 0:
        ch = word[letters-1]         # what is it looking at?
        if ch == 'e':
            count = count + 1
            print('{0} <-'.format(ch))
        else:
            print('{0}'.format(ch))
        letters = letters - 1
    print count

puis

has_no_e('tease')

retourne

e <-
s
a
e <-
t
e <-
3

à partir de laquelle vous pouvez voir que

vous allez par le biais de la chaîne dans l'ordre inverse
il est correctement reconnaissant e
que vous êtes "en s'enroulant autour d'' à la fin de la chaîne, d'où le e supplémentaire si votre chaîne se termine dans une

OriginalL'auteur Hugh Bothwell

Si ce que vous voulez vraiment est "has_no_e", alors ce qui suit peut être plus approprié que le comptage 'e s et puis plus tard, la vérification de zéro,

def has_no_e(word):
  return 'e' not in word

>>> has_no_e('Adrian')
True
>>> has_no_e('test')
False
>>> has_no_e('NYSE')
True

Si vous voulez vérifier si il n'y a pas de "E", soit,

def has_no_e(word):
  return 'e' not in word.lower()

>>> has_no_e('NYSE')
False

OriginalL'auteur aid

Vous n'avez pas à utiliser un tout en boucle. Les chaînes peuvent être utilisés pour des boucles dans Python.

def has_no_e(word):
    count = 0
    for letter in word:
        if letter == "e":
            count += 1
    print count

ou quelque chose de plus simple:

def has_no_e(word):
    return sum(1 for letter in word if letter=="e")

OriginalL'auteur Nope

Vous devez vous connecter pour publier un commentaire.