Joindre chaine de caractères

18 décembre 2011 à 19:11:47

Bonjour à tous !

Voila, j'essaie de faire un programme qui décrypte selon le code césar.. Pour ceux qui ne connaissent pas, c'est ici.
Voila mon code :

chainead = "abcd"
clef = 2
for lettre in chainead:
    lettre = lettre.replace("a","0")
    lettre = lettre.replace("b","1")
    lettre = lettre.replace("c","2")
    lettre = lettre.replace("d","3")
    lettre = int(lettre)
    nl = (lettre-clef)%26
    nl = str(nl)
    nl = nl.replace("24","y")
    nl = nl.replace("25","z")
    nl = nl.replace("0","a")
    nl = nl.replace("1","b")
    print nl

Mais il y a un problème le résultat est :

y
z
a
b

Je voudrais savoir si il est possible de joindre et de mettre le tout dans une variable de façon à ce que le résultat soit de la sorte :

code_decrypte = "yzab"

Merci d'avance !

Anonyme

18 décembre 2011 à 19:23:25

>>> machaine = ''
>>> for i in 'abcd':
...     if i != 'b':
...         machaine += i

		
>>> print(machaine)
acd

pierrot1105

18 décembre 2011 à 19:36:19

Citation : fred1599

>>> machaine = ''
>>> for i in 'abcd':
...     if i != 'b':
...         machaine += i

		
>>> print(machaine)
acd

Encore une fois, merci fred.. Voila mon nouveau code, je ne sais pas si c'est à ça que tu pensais, mais ce que tu m'as dit m'a fait penser à ça :

# -*- coding: UTF-8 *-

chainead = "abcd"
clef = 2
machaine = ''
for lettre in chainead:
    lettre = lettre.replace("a","0")
    lettre = lettre.replace("b","1")
    lettre = lettre.replace("c","2")
    lettre = lettre.replace("d","3")
    lettre = int(lettre)
    nl = (lettre-clef)%26
    nl = str(nl)
    nl = nl.replace("24","y")
    nl = nl.replace("25","z")
    nl = nl.replace("0","a")
    nl = nl.replace("1","b")
    print nl
    machaine += nl
print machaine

Et cela fonctionne, donc merci à toi encore une fois

Anonyme

18 décembre 2011 à 19:40:16

Eh bien si je pensais à ça

candide

18 décembre 2011 à 19:56:50

Citation : pierrot1105

Voila mon code :

chainead = "abcd"
clef = 2
for lettre in chainead:
    lettre = lettre.replace("a","0")
    lettre = lettre.replace("b","1")
    lettre = lettre.replace("c","2")
    lettre = lettre.replace("d","3")
    lettre = int(lettre)
    nl = (lettre-clef)%26
    nl = str(nl)
    nl = nl.replace("24","y")
    nl = nl.replace("25","z")
    nl = nl.replace("0","a")
    nl = nl.replace("1","b")
    print nl

Ta «résolution» du problème est une horreur, tu n'as pas assimilé la notion de boucle dont tu n'as pas compris les possibilités d'abstraction. En plus pourquoi choisis-tu "abcd" pour exemple, choisis une chaîne quelconque, genre "typhon" ou "zero".

L'exercice que tu proposes est en général codé avec un dictionnaire (connais-tu ?). On peut aussi le faire en utilisant les fonctions ord et chr mais il faut te limiter à l'ascii. Ça peut aussi se faire en plaçant l'alphabet dans une chaîne.

Anonyme

18 décembre 2011 à 20:03:07

Citation : candide

Ta «résolution» du problème est une horreur, tu n'as pas assimilé la notion de boucle dont tu n'as pas compris les possibilités d'abstraction. En plus pourquoi choisis-tu "abcd" pour exemple, choisis une chaîne quelconque, genre "typhon" ou "zero".

L'exercice que tu proposes est en général codé avec un dictionnaire (connais-tu ?). On peut aussi le faire en utilisant les fonctions ord et chr mais il faut te limiter à l'ascii. Ça peut aussi se faire en plaçant l'alphabet dans une chaîne.

Tu as raison! Je pense que le PO veut aller plus vite que la musique...

pierrot1105

18 décembre 2011 à 20:40:14

Après réflexion, je me suis rendu compte que je voulais apprendre à faire du vélo avant de s'avoir marcher...
Je vais donc me replonger dans les cours et retourner dans quelques mois vers les challenges...
Mon jeune age me permet de prendre mon temps...

Merci de vos réponses.. A bientot sur le forum !

nohar

18 décembre 2011 à 22:34:53

Juste au cas où :

Python 3.2.2 (default, Nov 21 2011, 16:51:01) 
[GCC 4.6.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> cle = 4
>>> alph = "abcdefghijklmnopqrstuvwxyz"
>>> corr = alph[cle:] + alph[0:cle]
>>> crypt = str.maketrans(alph, corr)
>>> decrypt = str.maketrans(corr, alph)
>>> message = "hello, world!".translate(crypt)
>>> message
'lipps, asvph!'
>>> message.translate(decrypt)
'hello, world!'

Zeste de Savoir, le site qui en a dans le citron !

candide

18 décembre 2011 à 23:41:13

Citation : nohar

Python 3.2.2 (default, Nov 21 2011, 16:51:01) 
[GCC 4.6.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> cle = 4
>>> alph = "abcdefghijklmnopqrstuvwxyz"
>>> corr = alph[cle:] + alph[0:cle]
>>> crypt = str.maketrans(alph, corr)
>>> decrypt = str.maketrans(corr, alph)
>>> message = "hello, world!".translate(crypt)
>>> message
'lipps, asvph!'
>>> message.translate(decrypt)
'hello, world!'

Ah oui, ya encore cette solution ci-dessus mais je suis pas familier de maketrans ni de translate. D'après le code-source de CPython, maketrans est écrite en Python et construit la table look-up avec ord et chr. Par contre, translate est écrit en C et semble utiliser un dictionnaire (? bon pas très clair dans le source) donc inutile de chercher à rivaliser en écrivant l'équivalent en Python.

nohar

19 décembre 2011 à 8:21:36

Je n'ai pas encore eu la curiosité d'analyser le code source de ces méthodes encore. Je le ferai dès que j'aurai un peu de temps.

Cela dit, l'algorithme de translate est plutôt intuitif : avec une chaîne de caractères et une table associative (un objet qui se comporte comme un dict) en entrée, retourne une nouvelle chaîne dont chaque caractère est :

* soit la "traduction" du caractère de même indice dans la chaîne d'origine.
* soit le caractère d'origine si celui-ci n'a pas de traduction.

En réalité il y a aussi moyen d'ignorer purement et simplement des caractères de la première chaîne, mais dans le cas présent ça ne nous intéresse pas (voir la doc de maketrans).

Je pense que ce serait un bon exercice pour le PO de recoder ces fonctions (du moins en partie).

Edit :

Citation : candide

D'après le code-source de CPython, maketrans est écrite en Python et construit la table look-up avec ord et chr.

Hum, je ne trouve pas la même chose dans le code source que j'ai sous les yeux (la branche 'default' actuelle, soit Python 3.3a0) :

PyDoc_STRVAR(maketrans__doc__,
"maketrans(frm, to) -> string\n"
"\n"
"Return a translation table (a string of 256 bytes long)\n"
"suitable for use in string.translate.  The strings frm and to\n"
"must be of the same length.");

static PyObject *
strop_maketrans(PyObject *self, PyObject *args)
{
    unsigned char *c, *from=NULL, *to=NULL;
    Py_ssize_t i, fromlen=0, tolen=0;
    PyObject *result;

    if (!PyArg_ParseTuple(args, "t#t#:maketrans", &from, &fromlen, &to, &tolen))
        return NULL;

    if (fromlen != tolen) {
        PyErr_SetString(PyExc_ValueError,
                        "maketrans arguments must have same length");
        return NULL;
    }

    result = PyString_FromStringAndSize((char *)NULL, 256);
    if (result == NULL)
        return NULL;
    c = (unsigned char *) PyString_AS_STRING((PyStringObject *)result);
    for (i = 0; i < 256; i++)
        c[i]=(unsigned char)i;
    for (i = 0; i < fromlen; i++)
        c[from[i]]=to[i];

    return result;
}


PyDoc_STRVAR(translate__doc__,
"translate(s,table [,deletechars]) -> string\n"
"\n"
"Return a copy of the string s, where all characters occurring\n"
"in the optional argument deletechars are removed, and the\n"
"remaining characters have been mapped through the given\n"
"translation table, which must be a string of length 256.");

static PyObject *
strop_translate(PyObject *self, PyObject *args)
{
    register char *input, *table, *output;
    Py_ssize_t i;
    int c, changed = 0;
    PyObject *input_obj;
    char *table1, *output_start, *del_table=NULL;
    Py_ssize_t inlen, tablen, dellen = 0;
    PyObject *result;
    int trans_table[256];

    WARN;
    if (!PyArg_ParseTuple(args, "St#|t#:translate", &input_obj,
                          &table1, &tablen, &del_table, &dellen))
        return NULL;
    if (tablen != 256) {
        PyErr_SetString(PyExc_ValueError,
                      "translation table must be 256 characters long");
        return NULL;
    }

    table = table1;
    inlen = PyString_GET_SIZE(input_obj);
    result = PyString_FromStringAndSize((char *)NULL, inlen);
    if (result == NULL)
        return NULL;
    output_start = output = PyString_AsString(result);
    input = PyString_AsString(input_obj);

    if (dellen == 0) {
        /* If no deletions are required, use faster code */
        for (i = inlen; --i >= 0; ) {
            c = Py_CHARMASK(*input++);
            if (Py_CHARMASK((*output++ = table[c])) != c)
                changed = 1;
        }
        if (changed)
            return result;
        Py_DECREF(result);
        Py_INCREF(input_obj);
        return input_obj;
    }

    for (i = 0; i < 256; i++)
        trans_table[i] = Py_CHARMASK(table[i]);

    for (i = 0; i < dellen; i++)
        trans_table[(int) Py_CHARMASK(del_table[i])] = -1;

    for (i = inlen; --i >= 0; ) {
        c = Py_CHARMASK(*input++);
        if (trans_table[c] != -1)
            if (Py_CHARMASK(*output++ = (char)trans_table[c]) == c)
                continue;
        changed = 1;
    }
    if (!changed) {
        Py_DECREF(result);
        Py_INCREF(input_obj);
        return input_obj;
    }
    /* Fix the size of the resulting string */
    if (inlen > 0)
        _PyString_Resize(&result, output - output_start);
    return result;
}

Les deux fonctions sont implémentées en C, apparemment. La table associative, dans le cas d'une chaîne de caractères simple (c'est différent pour les objets Unicode, je crois), est en fait simplement un tableau d'octets de longueur 256 (il a fallu que je fouille pour trouver à quoi correspond le caractère "t" non-documenté¹ dans la doc de PyArgs_ParseTuple — réponse dans Python/getargs.c ligne 1318) et pas un dict.

¹: Il faudrait probablement proposer un patch de la doc pour corriger ça. C'est documenté dans la doc de la version 2.7, donc sûrement déprécié, et il est probable que ce code ne soit plus là que pour des raisons de compatibilité.

Edit 2:

Au temps pour moi, la version actuelle de ces méthodes fonctionne bien avec des dictionnaires, puisque les chaînes de caractères sont en Unicode en interne :

Python 3.2.2 (default, Nov 21 2011, 16:51:01) 
[GCC 4.6.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> trans = str.maketrans("abcd", "efgh")
>>> trans
{97: 101, 98: 102, 99: 103, 100: 104}
>>> trans = str.maketrans("abcd♥", "efgh⇥")
>>> trans
{97: 101, 98: 102, 99: 103, 100: 104, 9829: 8677}
>>> type(trans)
<class 'dict'>

Mon précédent edit ne concerne donc que la façon dont ça fonctionne dans Python 2 :

Python 2.7.2 (default, Nov 21 2011, 17:24:32) 
[GCC 4.6.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import string
>>> trans = string.maketrans("abcd", "efgh")
>>> trans
'\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`efghefghijklmnopqrstuvwxyz{|}~\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff'
>>> type(trans)
<type 'str'>

Je regardais le mauvais code.

Zeste de Savoir, le site qui en a dans le citron !