Conversion lettres de l'alphabet en nombre en Python

Que penser de quelque chose comme ceci:

print [ord(char) - 96 for char in raw_input('Write Text: ').lower()]

ord

compréhension de la liste

codes ASCII

MODIFIER

Puisque tu m'as demandé d'expliquer, je le ferai... s'il a été expliqué assez bien dans les commentaires déjà par [?].

let's faire plus qu'une seule ligne de départ.

input = raw_input('Write Text: ')
input = input.lower()
output = []
for character in input:
    number = ord(character) - 96
    output.append(number)
print output

Cela fait la même chose, mais est plus lisible. Assurez-vous que vous pouvez comprendre ce qui se passe ici avant d'essayer de comprendre ma première réponse. Tout ici est assez standard, Python simple. La seule chose à noter est la fonction ord . ord signifie ordinal, et à peu près chaque langue de haut niveau aura ce type de fonction disponible. Il vous donne une cartographie de la représentation numérique de n'importe quel caractère. La fonction inverse d'ord est appelée chr.

chr(ord('x')) == 'x' # for any character, not just x.

si vous testez pour vous-même, l'ordinal de a est 97 (le troisième lien que j'ai posté ci-dessus montrera le jeu complet de caractères ASCII.) Chaque lettre minuscule se situe dans l'intervalle 97-122 (26 caractères.) Ainsi, si vous soustrayez simplement 96 de l'ordinal de n'importe quelle lettre minuscule, vous obtiendrez sa position dans l'alphabet en supposant que vous prenez 'a' = 1. Donc, ordinal de "b" = = 98, " c " = = 99, etc. Lorsque vous soustrayez 96, ' b ' = = 2,' c ' = = 3, etc.

le reste de la solution initiale que j'ai posté est juste une ruse Python que vous pouvez apprendre appelée compréhension de liste. Mais, je ne me concentrerais pas autant sur cela que je me concentrerais sur l'apprentissage pour résoudre le problème dans n'importe quelle langue, où ord est votre ami. J'espère que cette aide.

si vous allez utiliser cette conversion beaucoup, envisager de calculer une fois et de mettre les résultats dans un dictionnaire:

>>> import string
>>> di=dict(zip(string.letters,[ord(c)%32 for c in string.letters]))
>>> di['c'] 
3

l'avantage est que les recherches de dictionnaires sont très rapides vs itératives sur une liste sur chaque appel.

>>> for c in sorted(di.keys()):
>>>    print "{0}:{1}  ".format(c, di[c])
# what you would expect....

ne pas être trop basique, mais ceci:

>>> char1 = ['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']

est très différent de ceci:

>>> char2 = ['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']

le premier, sans virgule et ce que vous avez dans votre question, est une liste d'un élément avec une chaîne de 26 éléments. Le second est une liste de 26 éléments avec un seul caractère de longueur.

si vous imprimez chacun:

>>> print char1, len(char1), len(char1[0])
['abcdefghijklmnopqrstuvwxyz'] 1 26
>>> print char2, len(char2), len(char2[0])
['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'] 26 1

, Il devient évident qu'il faut une étape supplémentaire pour tourner la les caractères individuels de char1 dans un itérable .

si vous avez la séquence des caractères" a " à " z "et / ou" A " à "Z", Vous pouvez facilement retourner le numéro du caractère avec liste de compréhension :

>>> [ord(x)%32 for x in char2]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 
17, 18, 19, 20, 21, 22, 23, 24, 25, 26]

pour le type de structure de données que vous avez, vous devez accéder à la chaîne en premier:

>>> [ord(x)%32 for x in char1[0]]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 
17, 18, 19, 20, 21, 22, 23, 24, 25, 26]

donc si votre liste de codes est la même que dans votre question, cela peut être votre problème.

une alternative raisonnable est: [ord(x.lower())-96 for x in char1[0]]

Vous pouvez voir que votre characters=['a''b''c'...] , sans les virgules, c'est juste la même chose que de taper tous les caractères d'une chaîne dans une liste comme ça ['abc...'] .

alors maintenant essayez:

 >>> import string
 >>> [ord(x.lower())-96 for x in string.letters]
 [1,2,...26, 1,2,3...26]      # my ellipses 
 >>> char3=[string.letters]   # one string as element[0]
 >>> [ord(x)%32 for x in char3[0]]
 >>> [ord(x)%32 for x in [string.letters][0]]

c'est une fonction que j'utilisais dans ce but. Ça marche pour les majuscules et les minuscules.

def convert_char(old):
    if len(old) != 1:
        return 0
    new = ord(old)
    if 65 <= new <= 90:
        # Upper case letter
        return new - 64
    elif 97 <= new <= 122:
        # Lower case letter
        return new - 96
    # Unrecognized character
    return 0

Vous pouvez utiliser (chr) et ord() pour convertir entre les lettres et les nombres internes.

voici un exemple simple.

>>> chr(97)
'a'
>>> ord('a')
97

quelque chose comme ce

[str(ord(c)&31) for c in text]

>>> [str(ord(string.lower(c)) - ord('a') + 1) for c in string.letters]
['1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15', '16', '17',
'18', '19', '20', '21', '22', '23', '24', '25', '26', '1', '2', '3', '4', '5', '6', '7', '8',
'9', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '20', '21', '22', '23', '24',
 '25', '26']

def letter_to_int(letter):
    alphabet = list('abcdefghijklmnopqrstuvwxyz')
    return alphabet.index(letter) + 1

ici, la fonction index (x) renvoie la valeur de position de x si la liste contient X.

voici quelque chose que j'utilise pour convertir les lettres de colonne excel en nombres (donc une limite de 3 lettres mais il est assez facile de l'étendre si vous avez besoin de plus). Probablement pas la meilleure façon mais ça marche pour ce dont j'ai besoin.

def letter_to_number(letters):
    letters = letters.lower()
    dictionary = {'a':1,'b':2,'c':3,'d':4,'e':5,'f':6,'g':7,'h':8,'i':9,'j':10,'k':11,'l':12,'m':13,'n':14,'o':15,'p':16,'q':17,'r':18,'s':19,'t':20,'u':21,'v':22,'w':23,'x':24,'y':25,'z':26}
    strlen = len(letters)
    if strlen == 1:
        number = dictionary[letters]
    elif strlen == 2:
        first_letter = letters[0]
        first_number = dictionary[first_letter]
        second_letter = letters[1]
        second_number = dictionary[second_letter]
        number = (first_number * 26) + second_number
    elif strlen == 3:
        first_letter = letters[0]
        first_number = dictionary[first_letter]
        second_letter = letters[1]
        second_number = dictionary[second_letter]
        third_letter = letters[2]
        third_number = dictionary[third_letter]
        number = (first_number * 26 * 26) + (second_number * 26) + third_number
    return number

si le but est de transformer seulement les lettres abcd....xyz et ABCD....XYZ, j'utiliserais une fonction:

from string import letters
def rank(x, d = dict((letr,n%26+1) for n,letr in enumerate(letters[0:52]))):
    return d[x]

j'ai écrit [0:52] parce que ma version python 2.7 affiche la valeur

* ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz *ƒŠŒŽšœžŸÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØùúûüýþßàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿ

pour la corde.lettres argument.

parce que le paramètre d reçoit une valeur comme argument par défaut, le calcul de cette valeur n'est effectué qu'une seule fois, au moment où la définition de la fonction est exécutée pour produire l'objet de la fonction. Ainsi, la fonction peut alors être utilisée sans que cette valeur soit calculée à nouveau, même si la fonction est appelée trois mille fois.

soit dit en passant, lower() n'est plus utilisé pour chaque appel de la fonction. Le cas des Lettres Supérieures a été traités lors de la construction de l'argument par défaut.

.

un exemple d'utilisation:

word = 'supercalifragilisticexpialidocious'
print ''.join( letter if rank(letter)%3!=0 else '.' for letter in word)

résultat:

S. pe..a....ag ... st .. E. p. a..d.....s

.

il peut aussi être utilisé avec map ():

print map(rank,'ImmunoElectroPhoresis')

résultat:

[9, 13, 13, 21, 14, 15, 5, 12, 5, 3, 20, 18, 15, 16, 8, 15, 18, 5, 19, 9, 19]

si vous cherchez simplement à faire correspondre un numéro à une lettre, alors faites quelque chose de simple comme ceci:

def letter_to_index(letter):
    _alphabet = 'abcdefghijklmnopqrstuvwxyz'
    return next((i for i, _letter in enumerate(_alphabet) if _letter == letter), None)

bien sûr, si vous voulez l'avoir commencer à 1, puis il suffit d'ajouter (i+1 pour i, ... etc.

voici ma solution pour un problème où vous voulez convertir toutes les lettres dans une chaîne avec la position de ces lettres dans l'alphabet anglais et retourner une chaîne de ces nos.

https://gist.github.com/bondnotanymore/e0f1dcaacfb782348e74fac8b224769e

faites-moi savoir si vous voulez le comprendre en détail.J'ai utilisé les concepts suivants - Compréhension de liste - Compréhension du dictionnaire

si vous regardez le contraire comme 1 = a , 2 = B etc, Vous pouvez utiliser le code suivant. S'il vous plaît noter que je suis allé seulement jusqu'à 2 niveaux que j'ai dû convertir les divisions dans une classe à A, B, C etc.

loopvariable = 0 
    numberofdivisions = 53
    while (loopvariable <numberofdivisions):
        if(loopvariable<26):
            print(chr(65+loopvariable))
        loopvariable +=1
        if(loopvariable > 26 and loopvariable <53):
            print(chr(65)+chr(65+(loopvariable-27)))

utilisez cette fonction. Il convertit une chaîne d'alphabet à sa valeur numérique équivalente:

def convAlph2Num(sent):
    alphArray = list(string.ascii_lowercase)
    alphSet = set(alphArray)
    sentArray = list(sent.lower())
    x = []
    for u in sentArray:
        if u in alphSet:
            u = alphArray.index(u) + 1
            x.append(u)
    print(x)
    return