Discussion :

[yooo38]

Bonjour,

Je suis en train de faire un programme pour crypter des texte selon le code cesar.

Pour la suite de mon programme je souhaiterais savoir comment dans un texte en majuscule, je voudrais connaitre le nombre de A, B, C, ... . Puis trouvez dans cette réponse, lequel est le plus grand, et donc, connaitre qu'elle est la lettre qui apparait le plus souvent. pour pouvoir affillier la lettre E qui apparrais statistiquement le plus souvent dans un texte.

Voici le début de mon programme que j'ai utilisé :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# -*- coding: cp1252 -*-
import string
 
alpha="ABCDEFGHIJKLMNOPQRSTUVWXYZ .ABCDEFGHIJKLMNOPQRSTUVWXYZ ."
 
print "Entrez le texte à crypter en MAJUSCULE"
text1=raw_input()
text=text1.upper()
 
 
print "Entrez le pas de codage"
pas=input()
 
for i in range(0,len(text)):
    code=code+alpha[alpha.index(text[i])+pas]
for i in range(0,len(code)):
    decode=decode+alpha[alpha.index(code[i])-pas]
 
print code
print decode

Si vous avez des idées pour faire la suite de mon programme pour pouvoir compter le nombre de lettre dans le texte, je vous remerci par avance.

Bonne journée.

[rambc]

Bonjour,
et bienvenue dans le monde Python.

Pour ton problème, c'est tout simple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
#! /usr/bin/env python
#coding=utf-8
 
chaine = 'aaaaabcdefg'
nbreDeAminuscules = chaine.count('a')

L'import de string est inutile.

[eyquem]

Bonjour,


Bienvenue sur le forum.


Il existe la fonction count():
avec ch = ’a la barre du bateau’
print ch.count(’a’) affiche 5
print ch.count(’ba’) affiche 2

Mais je te déconseille d’utiliser count() de façon répétitive pour trouver les décomptes de toutes les lettres l’un après l’autre:
decompte_A = texte.count(’A’)
decompte_B = texte.count(’B’) etc
parce que cela veut dire que tu ferais parcourir 26 fois à count() l’ensemble de ton texte.




Il vaut mieux parcourir une seule fois ton texte, et incrémenter pour chaque lettre rencontrée un compteur qui lui est consacré.

Le mieux à mon avis est l’utilisation d’un dictionnaire. Pour créer-initialiser ce dictionnaire avec le nom decompte:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
decompte = {}.fromkeys(’ABCDEFGHIJKLMNOPQRSTUVWXYZ’,0)

http://www.python.org/doc/2.5.4/lib/typesmapping.html

Ensuite un max(decompte.values())

PSÉvidemment, avant le max, il faut parcourir le txte en comptabilisant chaque apparition de lettre de l’alphabet dans son compteur: decompte[’F’] += 1 chaque fois que F est rencontrée par ex.
Mais pas besoin de if ’A’, if ’B’ ... (j’abrège la notation).

[rambc]

eyquem,
dans le cadre d'un programme de prise en man de Python, il ne me semble pas opportun d'attaquer de suite avec des choses techniques comme ton dictionnaire. Ceci peut venir dans une seconde phase d'optimisation du code.

[yooo38]

Merci pour réponse aussi rapide.

Je souhaite utiliser les fonctions de bases de pytho donc comme le dit Rambc je vais plutot utilisé la fonction count() même si elle est un peu lourde du à la répétition du texte.

J'ai donc

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
# -*- coding: cp1252 -*-
import string
 
 
alpha="ABCDEFGHIJKLMNOPQRSTUVWXYZ .ABCDEFGHIJKLMNOPQRSTUVWXYZ ."
code=""
decode=""
decode1=""
decode2=""
decode3=""
decode4=""
decode5=""
decode6=""
decode7=""
decode8=""
decode9=""
decode10=""
decode11=""
decode12=""
decode13=""
decode14=""
decode15=""
decode16=""
decode17=""
decode18=""
decode19=""
decode20=""
decode21=""
decode22=""
decode23=""
decode24=""
decode25=""
decode26=""
 
print "Entrez le texte à crypter"
text1=raw_input()
text=text1.upper()
 
 
print "Entrez le pas de codage"
pas=input()
 
for i in range(0,len(text)):
    code=code+alpha[alpha.index(text[i])+pas]
 
 
print "                       MESSAGE CODEE                    " 
print "------------------------------------------------------\n"
print code
print "\n------------------------------------------------------"
 
 
for i in range(0,len(code)):
    decode=decode+alpha[alpha.index(code[i])-pas]
 
print "                      MESSAGE DECODEE                   " 
print "------------------------------------------------------\n"
print decode
print "\n------------------------------------------------------"
 
for j in range(0,len(code)):
    decode1=decode1+alpha[alpha.index(code[j])-1]
    decode2=decode2+alpha[alpha.index(code[j])-2]
    decode3=decode3+alpha[alpha.index(code[j])-3]
    decode4=decode4+alpha[alpha.index(code[j])-4]
    decode5=decode5+alpha[alpha.index(code[j])-5]
    decode6=decode6+alpha[alpha.index(code[j])-6]
    decode7=decode7+alpha[alpha.index(code[j])-7]
    decode8=decode8+alpha[alpha.index(code[j])-8]
    decode9=decode9+alpha[alpha.index(code[j])-9]
    decode10=decode10+alpha[alpha.index(code[j])-10]
    decode11=decode11+alpha[alpha.index(code[j])-11]
    decode12=decode12+alpha[alpha.index(code[j])-12]
    decode13=decode13+alpha[alpha.index(code[j])-13]
    decode14=decode14+alpha[alpha.index(code[j])-14]
    decode15=decode15+alpha[alpha.index(code[j])-15]
    decode16=decode16+alpha[alpha.index(code[j])-16]
    decode17=decode17+alpha[alpha.index(code[j])-17]
    decode18=decode18+alpha[alpha.index(code[j])-18]
    decode19=decode19+alpha[alpha.index(code[j])-19]
    decode20=decode20+alpha[alpha.index(code[j])-20]
    decode21=decode21+alpha[alpha.index(code[j])-21]
    decode22=decode22+alpha[alpha.index(code[j])-22]
    decode23=decode23+alpha[alpha.index(code[j])-23]
    decode24=decode24+alpha[alpha.index(code[j])-24]
    decode25=decode25+alpha[alpha.index(code[j])-25]
    decode26=decode26+alpha[alpha.index(code[j])-26]
 
print "                   SOLUTIONS MULTIPLES                  " 
print "------------------------------------------------------\n"    
print decode1
print decode2    
print decode3
print decode4    
print decode5
print decode6    
print decode7
print decode8    
print decode9
print decode10    
print decode11
print decode12    
print decode13
print decode14    
print decode15
print decode16    
print decode17
print decode18    
print decode19
print decode20    
print decode21
print decode22    
print decode23
print decode24    
print decode25
print decode26
 
print "------------------------------------------------------\n"
 
decompte_A=text.count("A")
decompte_B=text.count("B")
decompte_C=text.count("C")
decompte_D=text.count("D")
decompte_E=text.count("E")
decompte_F=text.count("F")
decompte_G=text.count("G")
decompte_H=text.count("H")
decompte_I=text.count("I")
decompte_J=text.count("J")
decompte_K=text.count("K")
decompte_L=text.count("L")
decompte_M=text.count("M")
decompte_N=text.count("N")
decompte_O=text.count("O")
decompte_P=text.count("P")
decompte_Q=text.count("Q")
decompte_R=text.count("R")
decompte_S=text.count("S")
decompte_T=text.count("T")
decompte_U=text.count("U")
decompte_V=text.count("V")
decompte_W=text.count("W")
decompte_X=text.count("X")
decompte_Y=text.count("Y")
decompte_Z=text.count("Z")
 
max1=(decompte_A,decompte_B,decompte_C,decompte_D,decompte_E,decompte_F,decompte_G,decompte_H,decompte_I,decompte_J,decompte_K,decompte_L,decompte_M,decompte_N,decompte_O,decompte_P,decompte_Q,decompte_R,decompte_S,decompte_T,decompte_U,decompte_V,decompte_W,decompte_X,decompte_Y,decompte_Z)

Donc maintenant je voudrais réussir a associer le maximum trouvé à la lettre E de la position de ma variable alpha.
Quelqu'un aurait il une idée.

Merci encore.
Bonne soirée.

[eyquem]

Bonjour rambc,



Tout d’abord, je précise que j’ai posté ma réponse sans avoir vu la tienne. Son contenu ne comportait donc pas de contradiction de la tienne mais simplement mon anticipation que yooo38 pouvait fort bien découvrir count() tout seul.




Ta réponse s’inscrit dans le cadre de vastes problématiques qui pourraient être discutées plus ou moins longuement: qu’est ce qu’une prise en main, en quoi doit elle consister ? qu’est ce qu’optimiser, comment fait on ?
J’avoue que ces sujets ne font pas partie de mes préoccupations de ces derniers temps.
Voici cependant quelques succintes remarques à la suite de ton avis qui me surprend quelque peu.

dans le cadre d'un programme de prise en man de Python

Qu’est ce qui permettait de croire que yooo38 est dans ce cas ?
Qu’est ce qui permettait de supputer qu’il n’attend que des réponses les plus simples possibles ?

Pour ma part, j’ai tendance à partir du principe que le questionneur sera plus heureux d’apprendre rapidement les meilleures pratiques et notions adaptées à son niveau (ce qui implique de ne pas l’abasourdir avec des choses trop poussées) plutôt que de mariner dans une progressivité balisée.

Il est vrai que la question se pose de savoir à quel niveau placer la réponse, je suis d’accord. Mais j’estime que parler de dictionnaire à un débutant n’a rien d’excessif. Avec les chaînes, les tuples et les listes, les dicos sont quand même parmi les structures de données basiques en Python.

Je n’ai pas fait allusion a defaultdict, alors qu’un tel dictionnaire est parfaitement adapté à ce cas, mais ne pas parler du tout de dictionnaire basique, cela serait aberrant.

Je reconnais que tu as raison sur un point: je n’aurais pas dû présenter la définition-initialisation avec fromkeys() , c’est déjà trop technique comme tu dis.
Mais simplement proposer

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
decompte = {}
for lettre in ’ABCDEFGHIJKLMNOPQRSTUVWXYZ’:
    decompte[lettre] = 0

J’ai deux autres remarques, un peu plus théoriques.




D’une part, ta formulation est ambigue: en parlant de “seconde phase d’optimisation“, tu induis l’idée que la prise en main en serait la première phase.

Mais ce sont deux choses de deux ordres différents: la prise en main concerne le langage, et une fois qu’elle sera faite, elle ne pourra pas être refaite.
Tandis que l’optimisation concerne des codes, et une nouvelle optimisation est faite pour chaque nouveau code.
Dit autrement, il ne va pas attendre d’avoir bien progressé en Python avant de reprendre son code pour l’optimiser.





D'autre part, je ne vois pas pourquoi tu parles d’optimisation, si je me réfère par exemple à cette définition:

En programmation informatique, l'optimisation est la pratique qui consiste généralement à réduire le temps d'exécution d'une fonction, l'espace occupé par les données et le programme, ou la consommation d'énergie.
La règle numéro un de l'optimisation est qu'elle ne doit intervenir qu'une fois que le programme fonctionne et répond aux spécifications fonctionnelles.
http://www.webpodium.fr/informatique...matique,4.html

Or ce n’est qu’en me relisant que je me suis aperçu que je n’ai même pas évoqué explicitement la vitesse d’exécution.
En réalité, mon avis est motivé par le fait que faire parcourir au programme une seule fois le texte paraît d’emblée "plus simple", "plus naturel", "plus logique", "plus efficace".
En posant sa question, yooo38 me semblait en effet se trouver encore à un stade de conception dans lequel il cherchait un algorithme et, dans la mesure où il s’en présente facilement deux à l’esprit, il convenait de lui indiquer que l’un est meilleur d’après ces critères.

Bien sûr, “plus efficace“ va se traduire aussi en définitive par plus rapide, mais ce n’était pas mon idée prioritaire parce que la vitesse d’exécution n’est pas importante pour ce genre d’application: qu’un cryptage soit réalisé en 0.5 secondes ou en 2, qu’importe ?

Mon conseil relève donc du choix d’un algorithme, pas d’une recherche d’optimisation.
Certes, le choix d'un algorithme peut aussi devoir se faire pour raison d'optimisation, car l’optimisation postérieure d’un code peut réclamer un chamboulement plus ou moins prononcé de son algorithme, mais quand on est à un stade où on peut facilement envisager deux algorithmes, je ne vois pas pourquoi il faudrait éviter de les soupeser et choisir le plus satisfaisant sous prétexte que ça ressemble à de l’optimisation alors que ce n’en est pas.

Or parcourir une fois un texte en faisant 26 types de relevés n’est pas un algorithme demandant plus d’effort de conceptualisation immédiate que de parcourir 26 fois un texte en ne faisant à chaque fois qu’un type de relevé. Même un débutant est capable de comprendre une telle considération algorithmique.

Apprendre à programmer, c’est aussi apprendre l’algorithmique; ne pas faire remarquer à un débutant cette différence d’algorithme dont nous parlons est le priver d’une notion et d’une structure de données vraiment élémentaires qu’il aura de toutes façons à découvrir.





Mais je vois que yooo38 choisit une autre voie que celle de la concision dont je ne fais pas non plus preuve dans ce post, aussi vais je cesser ce qui n’est plus que du bavardage creux.

[rambc]

Tout d’abord, je précise que j’ai posté ma réponse sans avoir vu la tienne. Son contenu ne comportait donc pas de contradiction de la tienne mais simplement mon anticipation que yooo38 pouvait fort bien découvrir count() tout seul.

Pas de souci, ma remarque était gentille.

Pour ma part, j’ai tendance à partir du principe que le questionneur sera plus heureux d’apprendre rapidement les meilleures pratiques et notions adaptées à son niveau (ce qui implique de ne pas l’abasourdir avec des choses trop poussées) plutôt que de mariner dans une progressivité balisée.

Ici il y a déjà à régler la mise en place du codage, ensuite viennent les petits nettoyages.
De plus, j'apprends toujours quand je me plante. Je pense que c'est utile...

Il est vrai que la question se pose de savoir à quel niveau placer la réponse, je suis d’accord. Mais j’estime que parler de dictionnaire à un débutant n’a rien d’excessif. Avec les chaînes, les tuples et les listes, les dicos sont quand même parmi les structures de données basiques en Python.

Je suis d'accord mais comme tu définies le dico. decompte = {}.fromkeys(’ABCDEFGHIJKLMNOPQRSTUVWXYZ’,0), cela devient moins "élémentaire".

Mais simplement proposer

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
decompte = {}
for lettre in ’ABCDEFGHIJKLMNOPQRSTUVWXYZ’:
    decompte[lettre] = 0

On est d'accord.

D'autre part, je ne vois pas pourquoi tu parles d’optimisation, si je me réfère par exemple à cette définition.

Je ne vois pas de contradiction. Dernièrement, j'ai eu à faire un programme d'analyse syntaxique, j'ai fait une 1ère version, puis ensuite il a fallu revoir l'ensemble car mon programme était bancal. Mais ceci m'a appris plein de choses.
Quand on s'attaque à un algorithme dur, il vaut mieux faire une 1ère version fonctionnelle. Viennent ensuite les améliorations.

Or ce n’est qu’en me relisant que je me suis aperçu que je n’ai même pas évoqué explicitement la vitesse d’exécution.

Dans optimisation j'ajouterais l'idée d'un programme facile à mettre à jour, et à faire évoluer. On optimise ainsi la maintenance.

En réalité, mon avis est motivé par le fait que faire parcourir au programme une seule fois le texte paraît d’emblée "plus simple", "plus naturel", "plus logique", "plus efficace".

C'est vrai.

Apprendre à programmer, c’est aussi apprendre l’algorithmique; ne pas faire remarquer à un débutant cette différence d’algorithme dont nous parlons est le priver d’une notion et d’une structure de données vraiment élémentaires qu’il aura de toutes façons à découvrir.

Tes remarques sont toujours avisées. Tu m'as fait faire d'énormes améliorations. C'est juste qu'ici, ce que tu proposais me semblait faire passer la charrue avant les "meus".