web-dev-qa-db-fra.com

range over character en python

Y a-t-il un moyen de varier les personnages? quelque chose comme ça.

for c in xrange( 'a', 'z' ):
    print c

J'espere que vous pouvez m'aider.

pythonrangecharacter
64
huan

Ceci est une excellente utilisation pour un générateur personnalisé:

Python 2: 

def char_range(c1, c2):
    """Generates the characters from `c1` to `c2`, inclusive."""
    for c in xrange(ord(c1), ord(c2)+1):
        yield chr(c)

puis:

for c in char_range('a', 'z'):
    print c

Python 3:  

def char_range(c1, c2):
    """Generates the characters from `c1` to `c2`, inclusive."""
    for c in range(ord(c1), ord(c2)+1):
        yield chr(c)

puis:

for c in char_range('a', 'z'):
    print(c)
85
Ned Batchelder
import string
for char in string.ascii_lowercase:
    print char

Voir constantes de chaînes pour les autres possibilités, y compris les majuscules, les nombres et les caractères dépendants de la langue, que vous pouvez joindre ensemble comme string.ascii_uppercase + string.ascii_lowercase si vous voulez que tous les caractères de plusieurs jeux.

70
agf

Vous devez convertir les caractères en chiffres et inversement.

for c in xrange(ord('a'), ord('z')+1):
    print chr(c) # resp. print unicode(c)

Par souci de beauté et de lisibilité, vous pouvez envelopper ceci dans un générateur:

def character_range(a, b, inclusive=False):
    back = chr
    if isinstance(a,unicode) or isinstance(b,unicode):
        back = unicode
    for c in xrange(ord(a), ord(b) + int(bool(inclusive)))
        yield back(c)

for c in character_range('a', 'z', inclusive=True):
    print(chr(c))

Ce générateur peut être appelé avec inclusive=False (par défaut) pour imiter le comportement habituel de Python afin d’exclure l’élément final ou avec inclusive=True (par défaut) pour l’inclure. Donc, avec la valeur par défaut inclusive=False, 'a', 'z' couvrirait simplement la plage allant de a à y, à l'exclusion de z.

Si l'un des a, b est unicode, il renvoie le résultat en unicode, sinon il utilise chr.

Il ne fonctionne (probablement) actuellement que dans Py2.

24
glglgl

Il y a d'autres bonnes réponses ici (personnellement, j'utiliserais probablement string.lowercase), mais par souci d'exhaustivité, vous pouvez utiliser map () et chr () sur les valeurs ascii minuscules:

for c in map(chr, xrange(97, 123)):
   print c
10
GreenMatt

Si vous avez une courte liste fixe de caractères, utilisez simplement le traitement des chaînes par Python en tant que listes.

for x in 'abcd':
    print x

ou

[x for x in 'abcd']
5
Dannid
for character in map(   chr, xrange( ord('a'), ord('c')+1 )   ):
   print character

impressions:

a
b
c
5
securecurve
# generating 'a to z' small_chars.
small_chars = [chr(item) for item in range(ord('a'), ord('z')+1)]
# generating 'A to Z' upper chars.
upper_chars = [chr(item).upper() for item in range(ord('a'), ord('z')+1)]
5
user1630938

J'aime une approche qui ressemble à ceci:

base64chars = list(chars('AZ', 'az', '09', '++', '//'))

Il peut certainement être mis en œuvre avec beaucoup plus de confort, mais il est rapide, facile et très lisible.

Python 3

Version du générateur:

def chars(*args):
    for a in args:
        for i in range(ord(a[0]), ord(a[1])+1):
            yield chr(i)

Ou, si vous aimez les compréhensions de liste:

def chars(*args):
    return [chr(i) for a in args for i in range(ord(a[0]), ord(a[1])+1)]

Les premiers rendements:

print(chars('ĀĈ'))
<generator object chars at 0x7efcb4e72308>
print(list(chars('ĀĈ')))
['Ā', 'ā', 'Ă', 'ă', 'Ą', 'ą', 'Ć', 'ć', 'Ĉ']

tandis que le second cède:

print(chars('ĀĈ'))
['Ā', 'ā', 'Ă', 'ă', 'Ą', 'ą', 'Ć', 'ć', 'Ĉ']

C'est vraiment pratique:

base64chars = list(chars('AZ', 'az', '09', '++', '//'))
for a in base64chars:
   print(repr(a),end='')
print('')
for a in base64chars:
   print(repr(a),end=' ')

les sorties

'A''B''C''D''E''F''G''H''I''J''K''L''M''N''O''P''Q''R''S''T''U''V''W''X''Y''Z''a''b''c''d''e''f''g''h''i''j''k''l''m''n''o''p''q''r''s''t''u''v''w''x''y''z''0''1''2''3''4''5''6''7''8''9''+''/'
'A' 'B' 'C' 'D' 'E' 'F' 'G' 'H' 'I' 'J' 'K' 'L' 'M' 'N' 'O' 'P' 'Q' 'R' 'S' 'T' 'U' 'V' 'W' 'X' 'Y' 'Z' 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 's' 't' 'u' 'v' 'w' 'x' 'y' 'z' '0' '1' '2' '3' '4' '5' '6' '7' '8' '9' '+' '/'

Pourquoi la list()? Sans base64chars pourrait devenir un générateur (selon l'implémentation que vous avez choisie) et ne pourrait donc être utilisé que dans la toute première boucle.

Python 2

Les mêmes peuvent être archivés avec Python 2. Mais c'est beaucoup plus complexe si vous voulez aussi supporter Unicode. Pour vous encourager à cesser d’utiliser Python 2 au profit de Python 3, je ne me donne pas la peine de fournir ici une solution Python 2;)

Essayez d'éviter Python 2 aujourd'hui pour les nouveaux projets. Essayez également de porter les anciens projets sur Python 3 avant de les étendre - à long terme, cela en vaudra la peine!

La gestion correcte de Unicode dans Python 2 est extrêmement complexe et il est presque impossible d'ajouter la prise en charge Unicode aux projets Python 2 si cette prise en charge n'était pas intégrée depuis le début.

Astuces sur la manière de backporter ceci vers Python 2:

  • Utilisez xrange au lieu de range
  • Créez une 2ème fonction (unicodes?) Pour le traitement de Unicode:
    • Utilisez unichr au lieu de chr pour renvoyer unicode au lieu de str
    • N'oubliez jamais de nourrir les chaînes unicode sous la forme args afin que ord et l'indice de tableau fonctionnent correctement
4
Tino

Inspiré du post ci-dessus, j'ai trouvé ceci:

map(chr,range(ord('a'),ord('z')+1))
2
sjs7007

j'ai eu le même besoin et j'ai utilisé ceci:

chars = string.ascii_lowercase
range = list(chars)[chars.find('a'):chars.find('k')+1]

J'espère que cela aidera quelqu'un

0
ayoub aboussaad

En utilisant la réponse de @ ned-batchelder ici, je la modifie un peu pour python3

def char_range(c1, c2):
    """Generates the characters from `c1` to `c2`, inclusive."""
    """Using range instead of xrange as xrange is deprecated in Python3""" 
    for c in range(ord(c1), ord(c2)+1):
        yield chr(c)

Alors même chose que dans la réponse de Ned:

for c in char_range('a', 'z'):
    print c

Merci Ned!

0
Andy K

Une autre option (fonctionne comme une plage - ajoutez 1 pour arrêter si vous voulez que le système soit inclus)

>>> import string
>>> def crange(arg, *args):
...     """character range, crange(stop) or crange(start, stop[, step])"""
...     if len(args):
...         start = string.ascii_letters.index(arg)
...         stop = string.ascii_letters.index(args[0])
...     else:
...         start = string.ascii_letters.index('a')
...         stop = string.ascii_letters.index(arg)
...     step = 1 if len(args) < 2 else args[1]
...     for index in range(start, stop, step):
...         yield string.ascii_letters[index]
...
>>> [_ for _ in crange('d')]
['a', 'b', 'c']
>>>
>>> [_ for _ in crange('d', 'g')]
['d', 'e', 'f']
>>>
>>> [_ for _ in crange('d', 'v', 3)]
['d', 'g', 'j', 'm', 'p', 's']
>>>
>>> [_ for _ in crange('A', 'G')]
['A', 'B', 'C', 'D', 'E', 'F']
0
Wyrmwood

Utiliser la compréhension de la liste:

for c in [chr(x) for x in range(ord('a'), ord('z'))]:
    print c
0
Bugalugs Nash

Utilisez "for count in range" et chr & ord: 

print [chr(ord('a')+i) for i in range(ord('z')-ord('a'))]
0
erjemin