Comment puis-je parcourir une chaîne de caractères en Python?

Comme un exemple, disons que je voulais à la liste de la fréquence de chaque lettre de l'alphabet dans une chaîne de caractères. Quelle serait la meilleure façon de le faire?

Ceci est un exemple de ce que je suis en train de penser... la question est de savoir comment faire allTheLetters égal à lettres sans quelque chose comme allTheLetters = "abcdefg...xyz". Dans de nombreuses autres langues, je pourrais juste faire une lettre++ et l'incrément de mon chemin à travers l'alphabet, mais jusqu'à présent je n'ai pas trouver un moyen de le faire en python.

def alphCount(text):
  lowerText = text.lower()
  for letter in allTheLetters:  
    print letter + ":", lowertext.count(letter)

InformationsquelleAutor Lawrence Johnston | 2008-10-23

python

72

La question que vous avez posée (comment parcourir l'alphabet) n'est pas la même question que le problème que vous essayez de résoudre (comment compter la fréquence des lettres dans une chaîne de caractères).

Vous pouvez utiliser des chaînes de caractères.minuscules, comme d'autres affiches ont suggéré:
```
import string
allTheLetters = string.lowercase
```
Faire les choses de la façon dont vous êtes en "habitués", le traitement des lettres que des chiffres, vous pouvez utiliser le bouton "ord" et "chr" des fonctions. Il n'y a absolument aucune raison de jamais faire exactement cela, mais peut-être à rapprocher de ce que vous êtes en train d'essayer de comprendre:
```
def getAllTheLetters(begin='a', end='z'):
    beginNum = ord(begin)
    endNum = ord(end)
    for number in xrange(beginNum, endNum+1):
        yield chr(number)
```
Vous pouvez dire qu'il fait la bonne chose parce que ce code imprime True:
```
import string
print ''.join(getAllTheLetters()) == string.lowercase
```
Mais, pour résoudre le problème que vous êtes en train d'essayer de le résoudre, vous souhaitez utiliser un dictionnaire et de recueillir les lettres que vous allez:
```
from collections import defaultdict    
def letterOccurrances(string):
    frequencies = defaultdict(lambda: 0)
    for character in string:
        frequencies[character.lower()] += 1
    return frequencies
```
Utiliser comme:
```
occs = letterOccurrances("Hello, world!")
print occs['l']
print occs['h']
```
Ce sera imprimée '3' et '1', respectivement.

Notez que cela fonctionne pour unicode ainsi:
```
# -*- coding: utf-8 -*-
occs = letterOccurrances(u"héĺĺó, ẃóŕĺd!")
print occs[u'l']
print occs[u'ĺ']
```
Si vous essayez l'autre approche sur unicode (incrémentation par le biais de chaque personnage), vous auriez du attendre un long moment; il y a des millions de caractères unicode.

Pour mettre en œuvre votre fonction d'origine (imprimer le nombre de chaque lettre dans l'ordre alphabétique) en termes de ceci:
```
def alphCount(text):
    for character, count in sorted(letterOccurrances(text).iteritems()):
        print "%s: %s" % (character, count)

alphCount("hello, world!")
```
- Excellent tutoriel!
- vous devriez vraiment utiliser des chaînes de caractères.ascii_lowercase au lieu d'écrire votre propre getAllTheLetters. aussi, c'est une horrible unpythonic nom pour une fonction!
- Votre letterOccurrances fonction de() sont également pris en compte les espaces et les signes de ponctuation, peut-être pas intentionnellement.
- Effectivement le nombre de caractères Unicode est encore moins d'un million. Aussi quelques-uns d'entre eux sont non-alphabétique, de sorte que vous voulez exclure des personnes lors de l'impression de fréquences.
- "chaîne de caractères.ascii_lowercase" -- j'espère qu'il y a un unicode_lowercase pour gérer Cyrillique, grec, etc. J'espère qu'il sait comment downcase turc je l'correctement en fonction de la localisation en cours.
- Plutôt que de collections.defaultdict(lambda: 0), à l'aide de collections.defaultdict(int) fera la même chose, et il est plus clair de l'OMI.
- Solution sympa Glyphe, mais je ne pense pas que votre dernière solution permet de résoudre le problème exactement de la même manière. Dans la solution d'origine de l'impression ": 0" s'il n'y avait pas de "a"dans la chaîne d'origine. Vôtre serait sauter par-dessus "une" dans ce cas, correct?
InformationsquelleAutor Glyph
14

la question est de savoir comment faire
allTheLetters égal à lettres
sans quelque chose comme allTheLetters =
"abcdefg...xyz"

C'est effectivement fourni par la chaîne de module, c'est pas comme si vous devez taper manuellement vous-même 😉
```
import string

allTheLetters = string.ascii_lowercase

def alphCount(text):
  lowerText = text.lower()
  for letter in allTheLetters:  
    print letter + ":", lowertext.count(letter)
```
- Cette solution est lente, car il a itérations imbriquées (lowertext.count() parcourt la chaîne afin de trouver le comte)
- Cependant, la question a été répondue. D'autres problèmes sont à l'origine des affiches problème.
- ou, vous pouvez obtenir toutes les lettres en minuscules pour faire une itération sur la liste suivante: allTheLetters=[chr(i+97) for i in range(26)]
InformationsquelleAutor Matthew Trevor
9

Si vous voulez juste faire un nombre d'occurrences d'une chaîne de caractères, essayez ceci:
```
s = 'hi there'
f = {}

for c in s:
        f[c] = f.get(c, 0) + 1

print f
```
- C'est un très goot solution, car il ne réitère une fois de plus de la chaîne, et c'est donc en O(n), par opposition à l'aide d'itérations imbriquées. mieux encore si vous utilisez f = defaultdict(int) et le simple f[c]+=1
- Est le membre get O(1)? Si c'est O(n), puis le tout est O(n^2).
- Diablo: les Mappages sont hachées. Dictionnaire obtient O(1).
InformationsquelleAutor Adam Pierce

Pour compter les objets, les évident solution est la Compteur

from collections import Counter
import string

c = Counter()
for letter in text.lower():
    c[letter] += 1

for letter in string.lowercase:
    print("%s: %d" % (letter, c[letter]))

Encore plus facile, vous pouvez remplacer l'affectation boucle avec: c = Counter(text.lower())

InformationsquelleAutor Kimvais

Entendez-vous à l'aide de:

import string
string.ascii_lowercase

puis,

counters = dict()
for letter in string.ascii_lowercase:
    counters[letter] = lowertext.count(letter)

Toutes les lettres minuscules sont pris en compte, manquant compteurs ont la valeur zéro.

à l'aide de générateurs:

counters = 
    dict( (letter,lowertext.count(letter)) for letter in string.ascii_lowercase )

InformationsquelleAutor gimel

3

Quelque chose comme cela?
```
for letter in range(ord('a'), ord('z') + 1):
  print chr(letter) + ":", lowertext.count(chr(letter))
```
- Je pense que votre "lettre" à l'intérieur de la fonction count() doit être "chr(lettre)"
- Depuis que vous avez fixé (et ne pas avoir mon tout-en-un bug entraînant la seule vérification jusqu'à 'y' :-), j'ai supprimé ma réponse et upvoted la vôtre.
- Cela semble bien pour moi, pourquoi est-il arriver voté contre ?
- J'ai temporairement voté vers le bas pour le retirer de la position supérieure et d'élever Matthieu réponse. Il n'est également pas très Pythonic code.
- oooh, la manipulation du marché. La SEC le suivi de ces forums? 🙂
InformationsquelleAutor Jacob Krall

Question principale est de "parcourir l'alphabet":

import string
for c in string.lowercase:
    print c

Comment obtenir la lettre de fréquences avec efficacité et sans compter non-lettre de caractères:

import string

sample = "Hello there, this is a test!"
letter_freq = dict((c,0) for c in string.lowercase)

for c in [c for c in sample.lower() if c.isalpha()]:
    letter_freq[c] += 1

print letter_freq

InformationsquelleAutor mhawke

0

Comment à ce sujet, d'utiliser des lettres, des chiffres et des signes de ponctuation (toutes utilisables pour former un Django clé):
```
import random
import string

chars = string.letters + string.digits + string.punctuation
chars_len = len(chars)
n = 40

print(''.join([chars[random.randint(0, chars_len)] for i in range(n)]))
```
Exemple de résultat: coOL:V!D+P,&S*hzbO{a0_6]2!{4|OIbVuAbq0:

InformationsquelleAutor user1956583

Suffit d'utiliser:

import string
string.lowercase  
string.uppercase

string.letters[:26]  
string.letters[26:]

InformationsquelleAutor guest

-1

C'est ce que je fais:

import string
for x in list(string.lowercase):
    print x

InformationsquelleAutor masnun

Vous devez vous connecter pour publier un commentaire.