web-dev-qa-db-de.com

bereich über Zeichen in Python

Gibt es eine Möglichkeit, sich über Charaktere zu bewegen? etwas wie das.

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

Ich hoffe ihr könnt helfen.

64
huan

Dies ist eine großartige Verwendung für einen benutzerdefinierten Generator:

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)

dann:

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)

dann:

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

Siehe string constants für die anderen Möglichkeiten, einschließlich Großbuchstaben, Zahlen und vom Gebietsschema abhängige Zeichen, die Sie wie string.ascii_uppercase + string.ascii_lowercase zusammenfügen können, wenn Sie alle Zeichen in mehreren Sätzen verwenden möchten.

70
agf

Sie müssen die Zeichen in Zahlen und wieder zurück konvertieren.

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

Aus Gründen der Schönheit und Lesbarkeit können Sie dies in einen Generator einwickeln:

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))

Dieser Generator kann mit inclusive=False (Standard) aufgerufen werden, um das übliche Verhalten von Python zum Imitieren des Endelements zu imitieren, oder mit inclusive=True (Standard), um es einzuschließen. Mit der Standardeinstellung inclusive=False würde 'a', 'z' den Bereich von a bis y umfassen, ausgenommen z.

Wenn a, b Unicode ist, wird das Ergebnis in Unicode zurückgegeben, andernfalls wird chr verwendet.

Es funktioniert momentan (wahrscheinlich) nur in Py2.

24
glglgl

Es gibt noch andere gute Antworten (persönlich würde ich wahrscheinlich string.lowercase verwenden), aber der Vollständigkeit halber könnten Sie map () und chr () für die Kleinschreibung der ASCII-Werte verwenden:

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

Wenn Sie eine kurze festgelegte Liste von Zeichen haben, verwenden Sie Pythons Behandlung von Zeichenfolgen einfach als Liste.

for x in 'abcd':
    print x

oder

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

druckt:

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

Ich mag einen Ansatz, der so aussieht:

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

Es kann sicherlich mit viel mehr Komfort implementiert werden, ist aber schnell und einfach und sehr lesbar.

Python 3

Generatorversion:

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

Oder wenn Sie Listenauffassungen mögen:

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

Die ersten Erträge:

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

während die zweite ergibt:

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

Es ist wirklich bequem:

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

ausgänge

'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' '+' '/' 

Warum die list()? Ohne base64chars kann es zu einem Generator werden (abhängig von der gewählten Implementierung) und kann daher nur in der ersten Schleife verwendet werden.

Python 2

Ähnliches kann mit Python 2 archiviert werden. Es ist jedoch viel komplexer, wenn Sie auch Unicode unterstützen möchten. Um Sie zu ermutigen, die Verwendung von Python 2 zu Gunsten von Python 3 einzustellen, mache ich mir keine Mühe, hier eine Python 2-Lösung bereitzustellen;)

Versuchen Sie heute, Python 2 für neue Projekte zu vermeiden. Versuchen Sie auch, alte Projekte zuerst auf Python 3 zu portieren, bevor Sie sie erweitern - auf lange Sicht lohnt sich der Aufwand!

Die korrekte Handhabung von Unicode in Python 2 ist äußerst komplex und es ist fast unmöglich, Unicode-Unterstützung zu Python 2-Projekten hinzuzufügen, wenn diese Unterstützung nicht von Anfang an eingebaut wurde.

Hinweise, wie Sie dies zu Python 2 zurückportieren können:

  • Verwenden Sie xrange anstelle von range
  • Erstellen Sie eine zweite Funktion (unicodes?) Für die Handhabung von Unicode:
    • Verwenden Sie unichr anstelle von chr, um unicode anstelle von str zurückzugeben.
    • Vergessen Sie niemals, unicode-Zeichenfolgen als args einzugeben, damit ord und der Array-Index ordnungsgemäß funktionieren
4
Tino

Inspiriert vom oberen Beitrag oben, habe ich Folgendes gefunden:

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

ich hatte das gleiche Bedürfnis und benutzte das:

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

Hoffe das hilft jemandem

0
ayoub aboussaad

Mit der Antwort von @ ned-batchelder hier ändere ich es etwas für 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)

Dann dasselbe wie in Neds Antwort:

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

Danke Ned!

0
Andy K

Eine weitere Option (funktioniert wie ein Bereich - fügen Sie 1 hinzu, um den Stopp zu beenden, wenn der Stopp eingeschlossen werden soll).

>>> 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

Listenverständnis verwenden:

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

Verwenden Sie "for count in range" und chr & ord: 

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