Bibm@th

Forum de mathématiques - Bibm@th.net

Bienvenue dans les forums du site BibM@th, des forums où on dit Bonjour (Bonsoir), Merci, S'il vous plaît...

Vous n'êtes pas identifié(e).

#1 22-12-2019 21:54:55

zizou47
Membre
Inscription : 05-07-2019
Messages : 20

Caractère plus fréquent

Bonjour,

réalisez une fonction plus Frequent qui recherche dans la chaîne de caractères passée en paramètre quelle est la lettre minuscule non accentuée qui présente le plus grand nombre d'occurrences, et retourne ce caractère. Si le plus grand nombre d'occurrences est commun à plusieurs lettres, c'est la première dans l'ordre alphabétique qui sera renvoyée par la fonction. Par ailleurs, si la chaîne reçue en paramètre est vide, la fonction doit renvoyer une chaine vide

Pour réaliser cet exercice, vous pouvez déclarer une variable alphabet de type chaîne de caractères qui contient toutes les lettres minuscules de l'alphabet et pour chacune d'elles compter le nombre d'occurrences dans la chaîne passée en paramètre..

def plus_Frequent (chaine):
    symbol = [0] * 26  # car il ya 26 minuscules
    for i in chaine:
        symbol [ord(i)] += 1
    return symbol          # retourne tous les nombres d'occurrences

j'arrive pas a finir, sans utiliser la fonction count,counter or list
merci

Dernière modification par yoshi (23-12-2019 07:36:39)

Hors ligne

#2 23-12-2019 10:08:42

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 14 768

Re : Caractère plus fréquent

Bonjour,

symbol = [0] * 26  # car il ya 26 minuscules

à comparer avec :

vous pouvez déclarer une variable alphabet de type chaîne de caractères qui contient toutes les lettres minuscules de l'alphabet

Ce qui me paraît plus clair à utiliser..
Le problème est le stockage des résultats (et le "tri")... Il t'est interdit d'utiliser count (ce n'est pas un problème) ou une liste ?

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

#3 23-12-2019 17:54:19

zizou47
Membre
Inscription : 05-07-2019
Messages : 20

Re : Caractère plus fréquent

pardon, listes ok
le problème ce que, comment je peux faire ca car les minuscule réservent les places 97- 122 dans le codes ASCII.
en plus renvoie que les lettre minuscules parmi 256 symboles

Hors ligne

#4 23-12-2019 18:11:58

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 14 768

Re : Caractère plus fréquent

Re,

Je n'ai pas utilisé de liste supplémentaire par rapport à toi.
Je n'ai pas utilisé ni count, ni counter...
J'ai rebaptisé occurrences ta liste symbol.
J'ai utilisé la chaine alphabet suggérée : alphabet="abcdefghijklmnopqrstuvwxyz"

Pour chaque élément de la chaîne passée en paramètres, je teste si elle est dans alphabet...
Je n'ai pas besoin de chercher s'il y a des ex aequo, le maximum trouvé en premier aura comme position dans occurences, celle de la 1ere lettre placée dans l'ordre alphabétique...

Moyennant quoi, mon affichage qui ne sera pas dans la fonction (que je ne te donne pas, réfléchis, essaie et discutons), géré par ce code :

                             
chaine="Pour réaliser cet exercice, vous pouvez déclarer une variable alphabet de type\
chaîne de caractères qui contient toutes les lettres minuscules de l'alphabet et pour\
chacune d'elles compter le nombre d'occurrences dans la chaîne passée en paramètre"

resultat=plus_Frequent(chaine)
if resultat=="":
    print("Pas de résultat. La chaîne entrée était vide")
else :
    print("La lettre minuscule, non accentuée, la plus fréquente de la chaîne est", resultat[0]+".")
    print ("Elle est présente",resultat[1:]+" fois.")

Et dans le cas présent, j'obtiens :

La lettre minuscule, non accentuée, la plus fréquente de la chaîne est e.
Elle est présente 36 fois.

.

Pour tester la correction de la réponse, j'ai relancé en ayant changé le "é" de "réaliser" en un e.
Le nombre de présences est passé à 37...

Voila ce que contient ma variable chaîne résultat : "e36"...
La seule fonction supplémentaire que j'ai utilisée est max().
J'aurais pu en utiliser encore d'autres - moins connues - et j'aurais ou raccourcir la fonction plus_Frequente(chaine)

A toi de jouer

@+

[EDIT]
Je viens de voir ta question :
ord(lettre)-97 te renvoie un nombre entre 0 et 25...
Seules les lettres non accentuées t'intéressent...
Si un élément de chaine est dans alphabet alors j'incrémente de 1 sa position dans occurrences qui est celle qu'il occupe dans alphabet...

Dernière modification par yoshi (23-12-2019 18:16:40)


Arx Tarpeia Capitoli proxima...

Hors ligne

#5 02-01-2020 21:10:38

zizou47
Membre
Inscription : 05-07-2019
Messages : 20

Re : Caractère plus fréquent

def plus_frequent(chaine):
    alpha = 'abcdefghijklmnopqrstuvwxyz'
    resultat = ''
    ch=''
    for i in range(len(chaine)):
        if chaine[i] in alpha:
            resultat += chaine[i]  #j'ai trié toutes lettres minuscules
    for j in  range(len(resultat)):
      if  ord (max(resultat)) <  ord (resultat[j]): # la je veux tester le total des ord  ce que je vois logique car  l'ord des minuscules est entre 97 et 122 donc si la lettre se presente au moins deux fois alors  son ord il est surement plus grande que ord de max(resultat) z par exemple est tjr le max si la chaine  contiet la lettre z mais j'arrive pas afficher ce caractère
          ch = ord (resultat[j])
    print(ch)
print(plus_frequent('loolaaa'))

Hors ligne

#6 03-01-2020 11:23:05

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 14 768

Re : Caractère plus fréquent

Bonjour,

Et je suis censé faire quoi avec ça ?
Un petit mot d'explication eût été le bienvenu...
Donc à moi de voir si ça marche ou pas...

Et bien, ça ne marche pas.
Rien ne s'affiche...
Pourquoi ?
ch est vide !

Cherchons donc pourquoi.
Donc, tant qu'à écrire print (ch), testons donc resultat, donc j'écris print(resultat)
Et là s'affiche : 'loolaaa' qui est ta chaîne de départ...
Or resultat devrait être un nombre : 3
Là, déjà, tu n'as plus aucune chance d'arriver à quelque chose de cohérent :


    for i in range(len(chaine)):
        if chaine[i] in alpha:
            resultat += chaine[i]  #j'ai trié toutes lettres minuscules
 

Ça veut dire quoi le verbe trier pour toi ? trier comment ? pourquoi ?
Que fait ce morceau de code ?
Si la lettre de chaine en position i est dans alphabet alors tu ajoutes cette lettre à la chaîne vide resultat.
Résultat des courses comme tous les caractères de la chaîne passée en paramètre, sont des lettres de l'alphabet, lorsque tu auras fini de parcourir chaine, resultat contiendra exactement la même chose que chaine...
Tu étais pourtant censé augmenter, à chacune des présences rencontrées, de 1 le nombre d'occurrences des lettres l, o, a présentes dans chaine... Où le fais-tu ?
Corrigé a minima de cette façon, ta fonction est cohérente :


def plus_Frequent(chaine):
    alpha="abcdefghijklmnopqrstuvwxyz"
    resultat=[0]*26
    for i in range(len(chaine)):
        if chaine[i] in alpha:
      resultat[ord(chaine[i])-97]+=1
    return resultat

print (plus_Frequent("amstram gram pic et pic et colegram")
 

puisque resultat vaut [4, 0, 3, 0, 3, 0, 2, 0, 2, 0, 0, 1, 4, 0, 1, 2, 0, 3, 1, 3, 0, 0, 0, 0, 0, 0]
Et tu vois que le maxi est 4 qui correspondent aux lettres a et m...

Je t'en propose 3 versions de plus en plus élaborées avec un return parce que l'énoncé fait usage 2 fois du verbe renvoyer et 1 fois du verbe retourner.
Informatiquement quand on demande à une fonction de retourner ou renvoyer, c'est synonyme. La fonction doit retourner un résultat...

Version 1

def plus_Frequent (chaine):
    if chaine=="":
        resultat=""
        return resultat
    alphabet="abcdefghijklmnopqrstuvwxyz"
    occurrences = [0 for i in range(26)]
    for element in chaine:
        if element in alphabet:
            occurrences[ord(element)-97] += 1
    maxi=max(occurrences)
    for i in range(26):
        if occurrences[i]==maxi:        
            lettreplusfrequente=alphabet[i]
            break        
    return lettreplusfrequente+str(maxi)

chaine="Pour réaliser cet exercice, vous pouvez déclarer une variable alphabet de type chaîne de\
caractères qui contient toutes les lettres minuscules de l'alphabet et pour chacune d'elles\
compter le nombre d'occurrences dans la chaîne passée en paramètre"

resultat=plus_Frequent(chaine)
if resultat=="":
    print("Pas de résultat. La chaîne entrée était vide")
else :
    print("La lettre minuscule, non accentuée, la plus fréquente de la chaîne est", resultat[0]+".")
    print ("Elle est présente",resultat[1:]+" fois.")

Version 2


def plus_Frequent (chaine):
    if chaine=="":
        resultat=""
        return resultat
    alphabet="abcdefghijklmnopqrstuvwxyz"
    occurrences = [0 for i in range(26)]
    for element in chaine:
        if element in alphabet:
            occurrences[ord(element)-97] += 1
    maxi=max(occurrences)
    lettreplusfrequente=alphabet[occurrences.index(maxi)]  
    return lettreplusfrequente+str(maxi)
chaine="Pour réaliser cet exercice, vous pouvez déclarer une variable alphabet de type chaîne de\
caractères qui contient toutes les lettres minuscules de l'alphabet et pour chacune d'elles\
compter le nombre d'occurrences dans la chaîne passée en paramètre"

resultat=plus_Frequent(chaine)
if resultat=="":
    print("Pas de résultat. La chaîne entrée était vide")
else :
    print("La lettre minuscule, non accentuée, la plus fréquente de la chaîne est", resultat[0]+".")
    print ("Elle est présente",resultat[1:]+" fois.")
 

Version 3


def plus_Frequent (chaine):
    if chaine=="":
        resultat=""
        return resultat
    alphabet="abcdefghijklmnopqrstuvwxyz"
    occurrences = [0 for i in range(26)]
    for i,element in enumerate(alphabet):
       occurrences[i]=chaine.count(element)
    maxi=max(occurrences)  
    return alphabet[occurrences.index(maxi)]+str(maxi)

chaine="Pour réaliser cet exercice, vous pouvez déclarer une variable alphabet de type chaîne de\
caractères qui contient toutes les lettres minuscules de l'alphabet et pour chacune d'elles\
compter le nombre d'occurrences dans la chaîne passée en paramètre"

resultat=plus_Frequent(chaine)
if resultat=="":
    print("Pas de résultat. La chaîne entrée était vide")
else :
    print("La lettre minuscule (non accentuée) la plus fréquente de la chaîne est", resultat[0]+".")
    print ("Elle est présente",resultat[1:]+" fois.")
 

Et tu es prié de tester les 3 pour vérifier qu'elles me donnent la réponse :

La lettre minuscule, non accentuée, la plus fréquente de la chaîne est e.
Elle est présente 36 fois.

En commun elles ont le même début :

def plus_Frequent (chaine):
    if chaine=="":
        resultat=""
        return resultat
    alphabet="abcdefghijklmnopqrstuvwxyz"
    occurrences = [0 for i in range(26)]

1. Ton énoncé stipule :
   Par ailleurs, si la chaîne reçue en paramètre est vide, la fonction doit renvoyer une chaine vide
   D'où le :
   


     if chaine=="":
           resultat=""
           return resultat

2. Je construis aussi la liste occurrences qui contient 26 zéros, un pour le nombre d'occurences de chaque lettre minuscule de l'alphabet.
    Et j'ajoute par ordre alphabétique...
    Je ne la construis pas avec *, procédé dangereux...
    Avec une seule liste passe encore...
    Avec une liste de listes, tu auras des ennuis.
    Exemple :
    L=[0]*3  --> L=[0,0,0]
    M=[L]*3  --> M=[[0,0,0],[0,0,0],[0,0,0]]
    Et maintenant je décide que le 1er élément de la 2e liste de M vaut 7 (par exemple).
    Donc j'écris : M[1][0]=7.
    "Logiquement", j'attends que M soit [[0,0,0],[0,7,0],[0,0,0]]
    En fait, non :   [[0,7,0],[0,7,0],[0,7,0]]
   Je construis occurrences avec une autre méthode que je vais te traduire en français :
   dans la liste occurrences, pour chaque i de 0 à 26 (rappel Python arrête à 25) ajoute un zéro.

Et la même fin :


chaine="Pour réaliser cet exercice, vous pouvez déclarer une variable alphabet de type chaîne de\
caractères qui contient toutes les lettres minuscules de l'alphabet et pour chacune d'elles\
compter le nombre d'occurrences dans la chaîne passée en paramètre"

resultat=plus_Frequent(chaine)
if resultat=="":
    print("Pas de résultat. La chaîne entrée était vide")
else :
    print("La lettre minuscule (non accentuée) la plus fréquente de la chaîne est", resultat[0]+".")
    print ("Elle est présente",resultat[1:]+" fois.")
 

1. Je construis ma chaîne et pour l'affichage, je la mets sur plusieurs lignes grâce à la coupure \ qui ne sera pas comptabilisée.

2. J'envoie ma chaîne, mais je demande à récupérer le résultat pour pouvoir le traiter :
   

resultat=plus_Frequent(chaine)

3. Et je traite d'abord le cas chaine vide demandé par l'énoncé :
   

if resultat=="":
    print("Pas de résultat. La chaîne entrée était vide")

Différences
Version 1. et Version 2
Je parcours la chaîne caractère après caractère et je vérifie si le caractère est dans alphabet.
Si oui j'augmente la valeur stockée à la position ord(element)-97 de 1 :

    for element in chaine:
        if element in alphabet:
            occurrences[ord(element)-97] += 1

Version 3.
J'utilise count() pour compter en parcourant les 26 lettres de l'alphabet pour compter le nombre de fois où chacune est présente dans la chaîne.  Je fonctionne à l'envers par rapport à V1 et V2...
L'intérêt est que j'évite de chercher ord(element), de soustraire 97 et d'ajouter 1 à la valeur en position calculée.
Mais pour ça, je dois connaître cette position.
Donc je vais traiter chaque lettre de l'alphabet une par une, tout en demandant à Python de pouvoir connaître sa position
Que fait alors Python ?
il énumère chaque lettre de l'alphabet comme ça :
0, a
1, b
2, c
c'est le boulot de la ligne for i, element in enumerate(alphabet):
puis occurrences[ i] va stocker en position i le compte du nombre du caractère (stocké dans element) qui figure (ou pas, dans ce cas 0) dans chaine

Dans les 3 versions, j'utilise la fonction max()
Supposons L =[8,5,7,1,12,6,0,4], alors max(L) me renvoie la valeur maximum stockée dans la liste.
Si je ne l'utilise pas, je suis obligé de créer une autre boucle comme ça :

maxi=0
for nb in range(len(L):
    if L[nb]>maxi:
        maxi=L[nb]

Version 1.
Dès que j'ai trouvé la position de maxi, comme j'ai utilisé l'ordre alphabétique, je connais la position de la lettre et je me "casse" de la boucle (to break = casser) : je sors sana aller plus loin.
L'énoncé dit :
Si le plus grand nombre d'occurrences est commun à plusieurs lettres, c'est la première dans l'ordre alphabétique qui sera renvoyée par la fonction.
Donc c'est automatique, je n'ai pas besoin de me casser la tête...

Version 2.
j'utilise la méthode index  (ça s'appelle comme ça et non fonction, tout comme count())
Dans l'exemple L =[8,5,7,1,12,6,0,4]
Si e demande l'index de 12, comme ça : print(L.index(12)) j'obtiens 4, c'est le n° de la position de 12 dans L, en commençant à 0.
La preuve print(L[4]) renvoie 12.

Systématiquement, je choisis de renvoyer la lettre la plus fréquente qui est du type string à qui j'ai concaténé la valeur de maxi convertie en chaîne par str, soit lettreplusfrequente +str(maxi)...
Et je récupère cette chaine dans resultat, chaine que je vais traiter.
Si resultat est non vide, resultat[0] est le contenu de resultat à la première position  : c'est la lettre cherchée.
Après, à partir de la position 1 c'est le nombre (transformé en chaine) de fois que la lettre minuscule non accentuée a été trouvée...
Comme, selon la longueur de la chaîne passée en paramètre, ce nombre peut avoir 1, 2, 3... chiffres, le m'adapte à toutes les situations rn disant 1: de 1 à la fin... Comme ça : resultat[1:]...

A te lire...

@+

Dernière modification par yoshi (03-01-2020 13:21:28)


Arx Tarpeia Capitoli proxima...

Hors ligne

#7 03-01-2020 22:39:10

zizou47
Membre
Inscription : 05-07-2019
Messages : 20

Re : Caractère plus fréquent

re :)
merci bq mr yoshi
ce que j'ai compris dans votre première réponse  c de remplacer la variable symbole par alphabet
- (je suis étranger )mais la le verbe trier sa fonction est de stocker ou sélectionner  toutes les lettres minuscules dans la liste résultat par
           les tester par la fonction for i in range (len(chaine):
- dans cet exemple oui, résultat contiendra la même chose que chaîne... ce que je voulu faire " calculer l' ORD des lettres comme j'ai expliqué dans ma première réponse" mais j'arrive pas a calculer l'occurance de chaque lettre quand j'ai remplacé symbole par alphabet
aussi (je suis débutant) l'habitude  il vous donne une variable str et il vous demande de calculer son occurrence dans une chaîne
mais la vous me montrez l'instruction - 97 ( montre votre intelligence aussi ) ou bien - ord ('a') si on veut la traduire
moi je connais que - 32 ou + 32 pour faire l'upper ou lower d'une lettre. merci yoshi encore.

Hors ligne

#8 04-01-2020 13:44:09

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 14 768

Re : Caractère plus fréquent

Bonjour,

J'ai donc perdu mon temps (waste my time) en te donnant 3 exemples de codes qui fonctionnent (running well or ) ?
Tu ne les as ni lus, ni testés, ni compris ?
Je t'ai dit que ces lignes ne donnent pas le résultat attendu  :

for i in range(len(chaine)):
    if chaine[i] in alpha:
        resultat += chaine[i]

Regarde

alphabet="abcdefghijklmnopqrstuvwxyz"
resultat=""
chaine="wastemytime"
for i in range(len(chaine)):
    if chaine[i] in alpha:
        resultat += chaine[i]
print("resultat ",resultat)
 

Lance-le et regarde ce que tu obtiens (let it run and take a look on w hat you obtain) :
resultat = "wastemytime"
c'est à dire exactement la même chose que ce que contient la variable la variable chaine...
Quel était l'intérêt de ces lignes ? Réponse : elles sont inutiles
Certainement pas de trier... Trier c'est ranger dans un certain ordre.
Tri de chaine par ordre alphabétique : aeeimmsttwy
Tri de chaine par nombre d'occurrences croissant et dans l'ordre alphabétique : aiswyeemmtt

Par contre, je t'ai signalé que :

chaine="wastemytime"
alpha="abcdefghijklmnopqrstuvwxyz"
resultat=[0]*26
for i in range(len(chaine)):
    if chaine[i] in alpha:
        resultat[ord(chaine[i])-97]+=1
print("resultat =", resultat

)
après fonctionnement (running) nous donne :
resultat = [1, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 0, 0, 1, 2, 0, 0, 1, 0, 1, 0]
Que voit-on ?
le maximum est 2.
Nous avons 2 fois le "e", 2 fois le "m" et 2 fois le "t".

chaine[0] = "w"
ord(chaine[0])=119
ord(chaine[0])-97 = 22
Dans la liste resultat, où est donc le nombre d'occurrences de "w" ?
Simplement ici : resultat[22]=1

Et pour le "e" ? le "m" ? le "t" ?
"e" --> ord(chaine[4])-97=101-97=4 et resultat[4]= 2 : il y a bien 2 fois la lettre "e"

"m"--> ord(chaine[4])-97=109-97=12 et resultat[12]= 2 : il y a bien 2 fois la lettre m"

"t" --> ord(chaine[3])-97=116-97=19 et resultat[19]= 2 : il y a bien 2 fois la lettre "t"

Si tu ne connais pas l'instruction "break", on peut faire avec une boucle while :


i=0
while resultat[i]<maxi:
  i+=1
 

Ton code devient :

def plus_Frequent(chaine):
    if chaine=="":
        resultat=""
        return resultat
    alpha="abcdefghijklmnopqrstuvwxyz"
    occurences=[0]*26
    for i in range(len(chaine)):
        if chaine[i] in alpha:
            occurences[ord(chaine[i])-97]+=1
    maxi=max(occurences)
    i=0
    while occurences[i]<maxi:
        i+=1
    resultat=chr(97+i)+str(maxi)
    return resultat

chaine="wastemytime"
reponse=plus_Frequent(chaine)
if reponse=="":
    print("Pas de résultat. La chaîne entrée était vide")
else :
    print("La chaîne contient",reponse[1:],"fois la lettre",reponse[0])

L'énoncé a demandé que ton code renvoie une chaine vide si ru as entré une chaine vide :
   traité avec ces lignes :

    if chaine=="":
        resultat=""
        return resultat

L'énoncé a demandé que si plusieurs lettres étaient présentes un maximum de fois que la réponse soit celle placée avant les autres dans l'ordre alplabétique :
    c'est fait grâce à la ligne : 

occurrences[ord(chaine[i])-97]+=1

Si j'essaie ce code, j'obtiens la réponse :
La chaîne contient 2 fois la lettre e
rester ici : https://pynative.com/online-python-code … thon-code/
avec un copier/coller
To run the script, clique sur le 4e icône en partant de la gauche : le triangle noir, pointe vers la droite...

Comprends-tu ce nouveau code ?
Comprends-tu ces lignes ?
C'est ce que j'ai trouvé de plus proche de ce que tu as présenté au post#5

Si tu ne comprends pas ce que j'ai fait, pose des questions précises, je te répondrai.

@+
@+


Arx Tarpeia Capitoli proxima...

Hors ligne

#9 04-01-2020 15:13:36

zizou47
Membre
Inscription : 05-07-2019
Messages : 20

Re : Caractère plus fréquent

bonjour

J'ai donc perdu mon temps (waste my time)
nn j'essaye de comprendre la premiére version et la tester et puis je passe a les autres, c juste répondu a vos questions
Regarde


c'est à dire exactement la même chose que ce que contient la variable la variable chaine

comme j'ai  dis hier ce qu'était dans ma tété ce que j'ai voulu sélectionner que les lettres minuscules et (imaginez que la chaîne contiendra ZZZ) et puis je crée une autre boucle (vous faites tout ça dans seule chaîne) pour calculer les lettres qui ont le même ord(i) par exemple ord(a) = 97 et si le résultat contiendra  2 a  alors on obtiendra  97 * 2 = 194, car la liste résultat n'est pas trier pas l'ordre alphabétique... le but :
on assure que si z celui le max car la fonction max renvoie z (s'il existe dans cette chaîne ) donc automatiquement 194 > 122
et après je vais essayer de trouver une solution pour    (comparer si on a deux lettres ont le même nombre d'occurrences) ex: si on a (3 b) et (3 c) alors : 3 * ord(b) < 3 ord(c) la fonction renvoie b je sais que j'ai compliqué les choses mais... ça ce qui m'arrive dans ma tète
pour la chaine  vide c pas un problème je me suis concentré pour les question difficile

- oui merci j'ai bien compris la V1 et je vais voir  la boucle while et puis les 2  V qui restent :) :)

Dernière modification par zizou47 (04-01-2020 15:18:34)

Hors ligne

#10 04-01-2020 16:23:33

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 14 768

Re : Caractère plus fréquent

Bonjour,

pour calculer les lettres qui ont le même ord(i)

Si deux lettres ont le même ord(i), il s'agit de la même lettre.
Et je vois pas, si j'ai deux fois la lettre a, je calculerais 97 * 2 =194...
C'est illogique et inutile.

Je répète :
ton idée de liste que tu appelais symbole et que moi j'appelle occurrences parce que c'est plus approprié, était bonne...
Dans cette liste : [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], à la place de chacun des zéros, on trouvera le nombre de fois que la fonction aura trouvé dans l'ordre les lettres 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
Parce que la fonction à chaque fois qu'elle rencontrera a, b, c, d, e, f, g, h, i... dans chaine, ajoutera 1 au nombre placé dans l'ordre en :
occurrences[0], occurrences[1], occurrences[2], occurrences[3], occurrences[4], occurrences[5],  occurrences[6], occurrences[7]...
Ceci est rendu possible par le calcul ord(chaine[ i])-97.
En effet,
* chaine[ i] donne la lettre en position i dans chaine,
* ord(chaine[ i]) donne le code ASCII de cette lettre,
* ord(chaine[ i])-97 donne la place occupée par cette lettre dans alpha
L'énoncé demande, si plusieurs lettres ont le même nombre d'occurrences, de choisir la première dans l'ordre alphabétique : je ne m'en occupe pas, parce que grâce à ce qui expliqué ci-dessus, c'est automatique : la première fois où le maxi est présent dans la liste occurrences est celle de la lettre cherchée...

L'énoncé demande demande de compter le nombre d'occurrences de chaque minuscule non accentuée...
Et bien, je me conforme totalement aux demandes de l'énoncé:
- je ne m'occupe que des minuscules de l'alphabet, je ne compte pas :
  les majuscules, s'il en y en a ou n'importe que autre caractère disponible avec le clavier
- parmi les minuscules, je ne compte pas les minuscules accentuées...
Je fais donc ce que demande l'énoncé : compter les minuscules non accentuées...
Sinon, il faudrait encore avant de commencer le comptage, remplacer :
é, è, ë, ê par e
à, â, ä par a
ù, ü, û par u
ï, î par i
ô par o
ç par c

L'énoncé ne demande pas, avant de la passer en paramètre, d'appliquer la méthode lower() à la chaîne :

print("PourQUoI".lower())

donne : pourquoi...

L'énoncé ne dit pas de prévoir le cas où chaine ne contient que des majuscules.
Mais si ce cas te tourmente, j'ai modifié légèrement le traitement de la réponse (pas la fonction ) :

chaine="ZZEDCFGIUYT"
reponse=plus_Frequent(chaine)
if reponse=="":
    print("Pas de résultat. La chaîne entrée était vide")
elif reponse[1]=="0":
    print("La chaîne entrée ne contenait pas de minuscule non accentuée.")
else:    
    print("La chaîne contient",reponse[1:],"fois la lettre",reponse[0])

La j'aurais l'affichage : La chaîne entrée ne contenait pas de minuscule non accentuée.

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

#11 04-01-2020 20:06:07

zizou47
Membre
Inscription : 05-07-2019
Messages : 20

Re : Caractère plus fréquent

oui, vous avez raison illogique et inutiles, le problème ce que je suis débutant et je ne réfléchis pas comme la machine.
merci bq mr yoshi vous donnez les réponses en détail

Hors ligne

#12 04-01-2020 21:14:11

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 14 768

Re : Caractère plus fréquent

Salut,

Avant de penser à utiliser le clavier pour programmer, tu dois :
- avoir l'idée de ce que tu vas faire, donc réfléchir...
- prendre un papier et un stylo et écrire ton code ans le détail avec les mots de tous les jours. On appelle ça : écrire du pseudo-code...
  Pseudo = faux, pas du "vrai" code. Mais tu dois énumérer dans l'ordre toutes les "opérations" que tu veux faire
- quand c'est fait, te relire et voir si tu n'as rien oublié
- seulement à ce moment passer à l'écriture du vrai code et là chercher quelles sont les instructions de Python ç utiliser.
  Puisque tu programmes en Python, alors je parle de Python mais ce pourrait être du C, du C++, du Visual Basic, du Java etc..
  C'est suffisamment difficile en soi, pour ne pas négliger les points précédents...
- lorsque tu as fini de taper ton code, alors exécuter ton programme.
  * si tout fonctionne comme prévu, bravo ! Mais cela représente 10% des cas...
  * s'il y a des erreurs grossières  (syntaxe, oublis, mauvais emploi des mots Python, alors les messages d'erreur te le diront...
  * si ce genre d'erreurs est absente, c'est plus ennuyeux : il faut trouver la faute de conception et cela peut être long...
     Là, tu reprends ton stylo et du papier, tu te mets à la place de Python, et tu suis ligne après ligne ton code.
     C'est à dire, tu vas faire exactement ce que fait Python, pas ce que toi tu crois qu'il fait.
     Tu as un bon moyen de savoir ce qui se passe entre les murs de la fonction : mettre des print à des endroits stratégiques...
     ... pour savoir à partir de quelle ligne, Python ne fait pas ce que tu croyais :
     si tu avais fait ça tu aurais vu dans ton code post#5 que ton "tri" n'en étais pas un, puisqu'à la sortie de ta boucle, tu avais en fait
     resultat=chaine ce qui n'était pas du tout ce que tu attendais.
     (Comment crois-tu que je l'ai vu ? Grâce à un print ajouté en sortie de boucle !)
     Donc retour en arrière, réflexion, modification du code et nouvel essai. Et là tu te retrouves à la première étoile ci-dessus et tout    recommence !

La programmation est une école de patience, de ténacité, de précision, de rigueur comme les Maths mais en presque plus sévère...
Un langage de programmation, c'est bête mais obéissant : il fait exactement ce que tu lui demandes de faire !

Pose des questions si nécessaire, n'hésite pas !

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

#13 06-01-2020 15:52:29

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 14 768

Re : Caractère plus fréquent

Bonjour,

Quelle que soit la version que je t'ai proposée (sauf la V3 où je parcours alphabet et je compte le nombre d'occurrences dans la variable chaine passée en paramètre) elles suivent le pseudo-code suivant :

def plus_Frequent(chaine):
    Cas où la variable chaine est vide. Retourner une chaîne vide.
    Déclarer liste alphabet de 26 minuscules (1)
    Déclarer liste de 26 zéros chaque emplacement représentera le nombre d'occurrences.(2)
    Parcourir un par un les caractères de la variable chaine
          Si caractère dans alphabet augmenter de 1 la valeur de l'emplacement correspondant de la liste (2)
    Trouver le maximum de cette liste.
    Trouver la position de ce maximum de cette liste (2)
    En déduire la lettre cherchée.
    Retourner la réponse.

Définir la chaîne à transmettre en paramètre à la fonction :
   en "dur" ? (chaine=...)
   via input(chaine) ?
Appeler la fonction en lui passant le paramètre chaine et récupérer le résultat retourné

Traitement du résultat
Si chaine entrée vide, afficher message le signalant...
Sinon afficher la lettre retournée

Comprends-tu ce qu'est un pseudo-code ?
Il est inapproprié de commencer le codage tant qu'on n'a pas établi ce qui précède.

C'est seulement au passage à la phase codage que tu cherches par quel myen tu vas réaliser en python les objectifs fixés par le pseudo-code.

Puis lorsque tu disposes d'un script Python correct, alors tu peux chercher à l'améliorer : c'est comme ça que j'ai écrit la version V3.

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

#14 15-01-2020 23:58:16

zizou47
Membre
Inscription : 05-07-2019
Messages : 20

Re : Caractère plus fréquent

merci encore j'ai bien compris :) , par contre  j'ai fais ca ( je voulais mettre ma petite touche lol) :
     

if occurance[i] == maxi:
     maxi = occurance[i] # la je sais que la boucle commence par le premier élément dans la liste donc automatiquement si c le cas alors je suis sur que maxi c'est la première dans l'ordre alphabétique
- je vois que break est nécessaire nn ?
- return maxi, alphabet[i]
c pas dangereux ce que j'ai fais, et aussi pour éviter de créer une autre variable (lettre_plus_ fréquent)?

Dernière modification par zizou47 (16-01-2020 00:00:39)

Hors ligne

#15 16-01-2020 10:09:46

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 14 768

Re : Caractère plus fréquent

Salut,

Tu vas encore disparaître pour 8/10 jours et dans ce laps de temps, je suis passé à autre chose...
Il faut donc que je me replonge dans le sujet. De plus, tu ne me fais pas gagner de temps en extrayant deux lignes de l'une des versions proposées sans me dire laquelle !

if occurrencs[i]==maxi:
    break

suffit largement...
Ton maxi=occurrences[ i] est totalement inutile...
C'est dans le code  suivant que tu veux mettre ta touche ?

maxi=max(occurrences)
    for i in range(26):
        if occurrences[i]==maxi:        
            lettreplusfrequente=alphabet[i]
            break        
    return lettreplusfrequente+str(maxi)

D'autant que occurrance est une faute d'orthographe et que c'est quand même gênant de faire une faute d'orthographe  simplement en recopiant un mot qu'on a sous les yeux...
Par rapport à ce code, c'est même 2 fautes de recopie dans le nom de la la liste ! Belle "touche" en vérité...
Alors je te mets en garde, si tu fais une faute d'orthographe dans un mot, tu as intérêt à faire la même à chaque fois que tu utiliseras ce mot, sinon plantage assuré...

Si tu as déclaré comme je l'ai fait la liste occurrences
* soit en "dur" : occurrences=[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
* soit avec une multiplication (méthode peu recommandée) :

occurrences =[0]*26

* soit par une définition en compréhension (le mieux) :

occurrences=[0 for i in range(26)]

* soit standard sur 3 lignes :

occurrences=[]
for i in range(26):
    occurrences.append(0)

après cela, tu justifies ta "touche" ainsi :

la je sais que la boucle commence par le premier élément dans la liste donc automatiquement si c le cas alors je suis
sur

Tu as écrit : "Si c'est le cas" :
Pour qui ou pour quoi est mis le c de c' ? Qu'est-ce qui est le cas ?
1. Que la boucle commence bien par le premier élément ? (élément de qui ? de quoi ?).
    Syntaxe de range : range(debut, fin, pas).
    Si on écrit : range (26), on a omis debut, on n'a écrit que la valeur de fin
    Donc, par défaut, Python démarre la boucle par 0 (il ne peut pas faire plus petit)
2. Si c'est le début de alphabet, alors ça se passe avant... Et alphabet commence par "a"...
    Avant, il n'y a pas de lettre minuscule...
3. Si tu n'es pas sûr (je te l'ai pourtant expliqué au moins deux fois) que
    - occurrences[0] soit le nombre d'occurrences de "a"
    - occurrences[1] soit le nombre d'occurrences de "b"
    ......................
    - occurrences[25] soit le nombre d'occurrences de "z" 
   je recommence une n+1e fois.
   En lisant caractère après caractère de la variable chaine, avec ord(lettre)-97, ta variable chaine ne doit contenir
   rien d'autre que des lettres, sinon boum ! C'est pourquoi, il y avait le test préalable :
   

if chaine[i] in alphabet

.
   Dans ce cas : ord("a")-97=0  et ord("z") -97=25...
   donc occurrences(ord(lettre)-97)+=1 augmente de 1 le nombre d'occurrences de lettre dans la liste occurrences
   à la même position que celle de lettre dans alphabet...
   Donc, ton "si" est vraiment très mal pensé...

Si le "c', de c'est, est mis pour "s'il s'agit bien du maxi", alors
1. Et si maxi n'est pas la bonne valeur ? Ce que tu écris change-t-il quelque chose ? Non, rien du tout...
    Si tu demandes à python : maxi = max(occurrences) cela signifierait  que la liste occurrences n'est pas bonne...
    Donc, c'est de ta faute...
2. Et donc, c'est la façon dont occurrences est construite qui est en cause !

Et donc si tu n'es sûr de rien, à quoi sert d'écrire :

if occurrences[i]==maxi:
    maxi ==occurrences[i]

que je traduis en français :
si le nombre en position i dans la liste occurrences est égale au maxi :
    alors le maxi est égale au nombre en position i dans la liste occurrences

Que je caricature en:
Si maxi==2:
    alors 2=maxi

Ca y est, tu as compris ?
Contente-toi de :

for i in range(26):
    if occurrences[i]==maxi:
        break

Du moment que tu as trouvé la position du maxi (qui est contenue dans i) tu sors de la boucle avec break...

Avec le code v3 que je t'avais proposé,
je prenais toutes les minuscules de l'alphabet une par une et je comptais leur présence chaine :

    for i,element in enumerate(alphabet):
       occurrences[i]=chaine.count(element)

Et là, pas de test préalable nécessaire puisque les seuls caractères envisagés sont ceux de alphabet.
Même si chaine="&²@oh_ç@làm^^%£$¤vraiment >>*tordu%§ comme §:/#exemple" et les lettres normales accentuées sont ignorées...
C'est pourquoi dans le traitement de ce que retourne la fonction, je prends la précaution d'utiliser les mots exacts de l'énoncé : "minuscules non accentuées"


Pourquoi, si j'écris :

for i in range(26):        
    if occurrences[i]==maxi:
        lettreplusfrequente=alphabet[i]
        break
return maxi, lettreplusfrequente
 

cela serait-il dangereux ???
Oui cela fait une variable de plus, mais même si cette variable n'est pas indispensable, elle a au moins le mérite
de la clarté : on sait ce que l'on fait... C'est recommandé.
Ce que je ne faisais pas, il y a 30 ans et il y a quelques programmes de plusieurs centaines de lignes où je ne
sais plus maintenant à quoi j'avais pensé...

Je t'ai écrit plus haut :
En lisant caractère après caractère de la variable chaine, avec ord(lettre)-97, ta variable chaine ne doit contenir
rien d'autre que des lettres, sinon boum ! C'est pourquoi, il y avait le test préalable :

 

if chaine[i] in alphabet.

Soyons plus clair.
Si je passe en paramètre la chaîne chaine="ohlala" pas de souci...
As-tu essayé chaine ="oh la la"  sans le if préparatoire ?
Non, sinon, tu serais vite revenu en disant : j'ai un plantage avec ce que tu as écrit ! Pourquoi ?
Simple :

for in range(len (chaine)):
    occurrences[ord(chaine[i]-97])+=1

Quand j'arrive à l'espace : ord(" ") vaut 32 et 32-97 = -65 alors que on veut

0<=ord(chaine[i]-97<=25

@+

Dernière modification par yoshi (16-01-2020 21:25:10)


Arx Tarpeia Capitoli proxima...

Hors ligne

#16 17-01-2020 00:44:33

zizou47
Membre
Inscription : 05-07-2019
Messages : 20

Re : Caractère plus fréquent

bonsoir,


Encore une fois désole pour les fautes d'orthographe j'essaye d’améliorer mon français pendant 2 ans :)
pour bien explique ce que j'essaye de vous dire hier:
j'ai bien compris les 2 versions (la troisième pas maintenant, je vais la voir un autre jour), mais moi juste je voulais ajouter ma touche sur votre code comme ça je confirmerai que j'ai bien compris pratiquement et ce que je fais :

for i in range(26):
        if occurrences[i]==maxi:        
            maxi=occurrences[i]
            break        
    return maxi,alphabet[i]

la je sais que j'ai 26 lettres dans la variable alphabet et la boucle commence par occurrences [0] jusqu’à  25 donc elle va boucler 26 fois
en gros la je suis sure que maxi contiendra la première lettre qui a plus nombre d’occurrences et l'index de occurrences [ i] celle la lettre mais pour l’afficher je dois l'indexer a partir de la variable alphabet  donc alphabet[ i]
j'ai posé la question est que c dangereux de faire ça si il y a un cas ou la chaîne contiendra "je sais pas je pose une question"... 
sinon je ne  fais pas ma touche je laisse votre code tranquille
ah oui, vous avez complètement raison, au début j'ai eu ce problème j'arrive pas a trouvé l'idée de  - 97 pourtant je la connais dans l’exercice qui demande de transformer toutes les lettres majuscules non accentuées d'une chaîne en lettres minuscules
merci encore mr yoshi  :) :) :)

Hors ligne

#17 17-01-2020 11:23:30

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 14 768

Re : Caractère plus fréquent

Bonjour,


Orthographe.
J'ai attiré ton attention, non pas sur ton orthographe en général, mais que tu as été capable de faire deux fautes dans le nom de la liste occurrences alors qu'elle figurait plusieurs fois dans les textes précédent. Faire deux fautes dans un mot en le recopiant n'est pas acceptable :
- soit tu as un gros problème de mémorisation
- soit tu n'es pas assez attentif...

Tes explications sur tes certitudes.

je suis sure que maxi contiendra la première lettre qui a plus nombre d’occurrences

Faux. La variable maxi contient un nombre, pas une lettre, le nombre d'occurrences de la lettre la plus fréquente.
C'est i qui est la valeur de l'index de cette lettre dans la liste alphabet : c'est pourquoi, j'écris lettreplusfrequente = alphabet[ i]


Je pense que tu n'as compris ce que je t'ai expliqué, puisque tu sembles tenir à conserver ces lignes :


for i in range(26):
    if occurrences[i]==maxi:        
        maxi=occurrences[i]
        break        
    return maxi,alphabet[i]

Je vais essayer de réexpliquer plus clairement pourquoi elles ne servent à rien...

Point n°1
Je passe en paramètre cette chaîne :
chaine="Je vais essayer de réexpliquer plus clairement pourquoi elles ne servent à rien..."
Et la liste occurrences est :
[3, 0, 1, 1, 14, 0, 0, 0, 5, 0, 0, 5, 1, 4, 2, 3, 2, 7, 6, 2, 4, 2, 0, 1, 1, 0]

Grâce à la méthode de remplissage de occurrences, je sais, je suis absolument certain, que
occurrences[0] est le nombre de "a", occurrences[1] le nombre de "b", occurrences[2] le nombre de "c",  occurrences[3] le nombre de "d", occurrences[4] le nombre de "e"... etc
autrement dit pour généraliser :
pour $0\leqslant i \leqslant 25$, occurrences[ i] est le nombre de fois où la lettre alphabet[ i] est présente dans chaine.

Est-ce que c'est plus clair ? Il n'y a pas de question à se poser : c'est une certitude due  à la méthode de remplissage ee la liste occurrences...

Point n°2
Je récupère le nombre d'occurrences maximum :
maxi = max(occurrences)
Ce maxi peut-il être faux ?
Absolument pas...
Python ne fait pas d'erreur (ni aucun autre langage de programmation).
Donc la valeur de maxi est la bonne, ici 14.

Point n°3
Je connais le maxi, mais pas à quelle lettre il se rattache...
Donc je vais parcourir toutes les positions de occurrences de 0 à 5 (inclus), jusqu'à ce que je trouve maxi (ici 14).
Dès que je l'aurai trouvé, je saurais que le i est le n° de la lettre dans alphabet, je note  lettreplusfrequente= alphabet[ i] et je sors de la boucle : inutile d'aller plus loin : voir Point n°1. Une fois sorti de la boucle je connais la lettre et le nombre d'occurrences de cette lettre dans chaine. Je n'ai plus qu'à sortir de la fonction.
Ma boucle s'écrit donc

for i in range(26):
    if occurrences[i]==maxi: #si j'ai trouvé le maxi (et c'est forcément la 1ere fois)
        lettreplusfrequente=alphabet[i] # le i est la position de la lettre dans alphabet
        break # Je sors de la boucle

Toi, tu écris :


for i in range(26):
    if occurrences[i]==maxi: # si j'ai trouvé le maxi
        maxi=occurrences[i]  # alors le maxi est occurrences[i]
        break                # Je sors de la boucle

Autrement dit tu parcours la boucle de l'indice 0 à l'indice 25
A chaque tour, tu poses la question : la valeur occurrences[ i] est-elle égale au maxi ?
(Jusque là, pas de problème, rien à redire)
Si la réponse est oui alors maxi est égal à la valeur de occurrences[ i]
Par contre c'est cette ligne qui est incohérente.

Reprenons mon dernier exemple :
je sais que maxi=14
Que fait ta boucle ?
Je vais suivre pas à pas.
i=0
    Est-ce que occurrences[0]= maxi ? (non, c'est 3)
    Non, on passe au i suivant.
i=1
    Est-ce que occurrences[1]= maxi ? (non, c'est 0)
    Non, on passe au i suivant.
i=2
    Est-ce que occurrences[2]= maxi ? (non, c'est 1)
    Non, on passe au i suivant.
i=3
    Est-ce que occurrences[3]= maxi ? (non, c'est 1)
    Non, on passe au i suivant.
i=4
    Est-ce que occurrences[4]= maxi ?
    oui.
    Alors maxi=occurrences[4]=14
    Pourquoi fais-tu cela ? Quel intérêt ?
    Tu connais maxi (c'est 14).
    Tu viens de trouver donc que occurrences[4] =14, alors pourquoi écris-tu donc maxi=occurrences[4]=14 ?
    Là, tu affectes à maxi la valeur de occurrences[4], tu mets 14 dans maxi...
    Pourquoi ? Ne le savais-tu pas avant ?
    - Non ? Dans ce cas la boucle complète ne sert à rien, Python ne connaît pas maxi.
      Alors crois-tu que chercher pour quelle valeur de i, occurrences[ i] est égal à un nombre inconnu ait un sens ?
      Et Python répondra à cette question avec un message d'erreur...
    - Oui ? alors pourquoi écrire que maxi = occurrences[4] ? Quel intérêt ?

Tu as compris cette fois ?

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

#18 17-01-2020 21:32:36

zizou47
Membre
Inscription : 05-07-2019
Messages : 20

Re : Caractère plus fréquent

bonsoir,

wow si je dis occurrences [ i] contiendra la lettre c'est a dire que je comprends rien, le problème c'est que j'ai mal exprimé la preuve dans  l’instruction" return maxi, alphabet[ i]" qui contiendra la lettre et j'ai dis ceci : "je dois l'indexer a partir de la variable alphabet"
pour ma touche: maintenant je comprends que la condition if occurrences[ i] == maxi: est suffisante;
car souvent dans les exercices que j'ai fais, j'ai mais dans ma tète: après chaque if aura des instruction de remplacer ou d'ajouter  ou afficher mais c'est pas le cas ici, alors ici, la condition "if" c'est une condition et en même temps résultat qui nous donne le nombre d'occurrences de la lettre la plus fréquente et la première dans l'ordre alphabétique.
la prochaine fois je vais éviter le maximum de fautes car ce que j'ai fais c'est trop ;)

merci infiniment mr yoshi a chaque réponse de vous elle m'apprend beaucoup de choses :) :)

Dernière modification par zizou47 (17-01-2020 23:58:50)

Hors ligne

#19 18-01-2020 12:00:39

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 14 768

Re : Caractère plus fréquent

Bonjour,

Mais si le
return maxi, alphabet[ i]
est parfaitement correct...
J'ai simplement dit que je préfère utiliser une variable de plus et retourner lettreplusfrequente, lettrecherchee, lettre_attendue, lettrereponse, peu importe pourvu que le nom soit clair, plutôt que alphabet[ i].

Ce code :

def plus_Frequent(chaine):    
    if chaine=="":
        return 0,""
    occurrences=[0 for i in range(26)]
    alphabet=[chr(97+i) for i in range(26)]
    for i in range(26):
        caractere= chaine[i]
        if caractere in alphabet:
            occurrences[ord(caractere)-97]+=1
    maxi =occurrences[i]
    for i in range(26):
        if occurrences[i]==maxi:
            break
    return maxi,alphabet[i]

chaine="J'ai simplement dit que je préfère utiliser une variable de plus et retourner lettreplusfrequente, lettrecherchee, lettre_attendue, lettrereponse, peu importe pourvu que le nom soit clair, plutôt que alphabet[ i]."

maximum, lettre=plus_Frequent(chaine)
if lettre="":
    print ("La chaîne entrée était vide.")
else:
    print ("La lettre minuscule non accentuée",lettre,"était présente", maximum, "fois dans la chaine entrée")

est parfaitement fonctionnel... La preuve :

La lettre minuscule non accentuée e était présente 36 fois dans la chaine.

Ce code est très proche de celui que tu te proposais d'écrire au début.
Si je n'utilise pas .count(), et que je veux partir de alphabet et chercher les occurrences dans chaine, je suis obligé d'utiliser une double boucle comme ça :

for i range(26):
    lettre = alphabet[i]
    for j in range(len(chaine)):
        if chaine[j]==lettre:
            occurrences[i]+=1

Bon, si tu examines de près le return (inchangé par rapport à ta dernière proposition) et que tu regardes bien comment je passe le paramètre à la fonction et comment je récupère les résultats, si personne ne t'a encore signalé ce que tu remarques, alors tu sera surpris et devras questionner...
Sans question, soit tu n'auras rien remarqué, soit tu savais déjà...

Une astuce pour terminer qui t'évitera à l'avenir de placer toute ta réponse ente balises code, regarde donc ce que j'ai fait pour pouvoir poster : j'écris occurrences[ i], alphabet[ i] en ajoutant une espace (mot féminin en informatique) entre le [ et le i...
Ça ne se produit que si tu utilises un compteur nommé i, b, u, s parce que le "moteur" du forum considère que i, b, u, s entre crochets sont les baliss de début pour italic, bold (gras), rayer, et souligner et comme alors il ne trouve pas les balises de fermeture, il refuse de valider ou de Prévisualiser en te signalant que cette balise est absente.

@+

[EDIT]
Je me suis mis en tête d'écrire une fonction la plus courte possible. Voilà le code :

def Plus_Frequent(chaine):    
    if chaine=="":
        return 0,""
    alphabet=[chr(i) for i in range(97,123)]
    occurrences=[chaine.count(lettre)for lettre in alphabet]
    maxi=max(occurrences)
    return maxi,alphabet[occurrences.index(maxi)]

chaine="J'ai simplement dit que je préfère utiliser une variable de plus et retourner lettreplusfrequente, lettrecherchee, lettre_attendue, lettrereponse, peu importe pourvu que le nom soit clair, plutôt que alphabet[ i]"
maximum, lettre=Plus_Frequent(chaine)
if lettre=="":
    print ("La chaîne entrée était vide.")
else:
    print ("La lettre minuscule non accentuée",lettre,"était présente", maximum, "fois dans la chaine.")

Et j'obtiens de nouveau :

La lettre minuscule non accentuée e était présente 36 fois dans la chaine.

Dernière modification par yoshi (18-01-2020 16:35:03)


Arx Tarpeia Capitoli proxima...

Hors ligne

#20 20-01-2020 18:04:20

zizou47
Membre
Inscription : 05-07-2019
Messages : 20

Re : Caractère plus fréquent

génial, Manipulation totale de chaînes de caractères.
merci aussi pour vos conseils

Hors ligne

#21 20-01-2020 21:43:36

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 14 768

Re : Caractère plus fréquent

Re;

Ce que je voulais te faire remarquer, c'était ça :

   

return maxi,alphabet[occurrences.index(maxi)]

maximum, lettre=Plus_Frequent(chaine)

Je retourne maxi
et je récupère maximum

Je retourne alphabet[occurrences.index(maxi)]
et je récupère lettre.

De même, tu pourrais passer chaine en paramètre à la fonction et la définir
comme ça :

def Plus_Frequent(message):    
    if message=="":
        return 0,""
    alphabet=[chr(i) for i in range(97,123)]
    occurrences=message.count(lettre) for lettre in alphabet]
    maxi=max(occurrences)
    return maxi,alphabet[occurrences.index(maxi)]

en récupérant le paramètre chaine sous le nom de message...

As-tu déjà essayé de taper, en dehors de la fonction, print(occurrences) (ou print(alphabet)), par ex en toute fin de programme obtenir un message d'erreur a priori surprenant ?
Traceback (most recent call last):
  File "C:\Python35\Progs persos\v3.x\Lettre plus frequente v4.py", line 16, in <module>
    print(occurrences)
NameError: name 'occurrences' is not defined

ou
Traceback (most recent call last):
  File "C:\Python35\Progs persos\v3.x\Lettre plus frequente v4.py", line 16, in <module>
    print(alphabet)
NameError: name 'alphabet' is not defined

Rien ne te surprend ??

Manipulation totale de chaînes de caractères.

Attrention !

    alphabet=[chr(i) for i in range(97,123)]
    occurrences=[chaine.count(lettre) for lettre in alphabet]

alphabet et occurrences sont des listes pas des chaînes.
La méthode de construction s'appelle en anglais "list compréhension', liste définie en compréhension...
Puisque j'utilise range(97,123): alors comme i est le code ASCII de chaque minuscule, chr(i) te donne les lettres a, b, c...
Quant à occurrences, au lieu de la remplir avec 26 zéros, je pars d'une liste vide à laquelle j'ajoute (--> append()) le nombre de présences lu après l'autre de chaque lettre dans l'ordre alphabétique...
J'airais pu l'écrire comme ça :

    occurrences=[]
    for i in range (97,123):
        occurrences.append(chaine.count(alphabet[i]))

Ou mieux, parce que plus clair, comme ça :

    occurrences=[]
    for lettre in alphabet:
        occurrences.append(chaine.count(lettre))

Et ça prenait 3 lignes au lieu d'une...

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

#22 21-01-2020 23:53:26

zizou47
Membre
Inscription : 05-07-2019
Messages : 20

Re : Caractère plus fréquent

en fait, j'ai pas l'essayer  et je voulais pas mtn car j'ai pas encore fais des cours avec index et count... j'ai déclaré ca auparavant que je  vais voir la 3 eme versions.
pour le moment j'ai vu que les 2 premières versions :)

Hors ligne

Réponse rapide

Veuillez composer votre message et l'envoyer
Nom (obligatoire)

E-mail (obligatoire)

Message (obligatoire)

Programme anti-spam : Afin de lutter contre le spam, nous vous demandons de bien vouloir répondre à la question suivante. Après inscription sur le site, vous n'aurez plus à répondre à ces questions.

Quel est le résultat de l'opération suivante (donner le résultat en chiffres)?
trente sept plus soixante
Système anti-bot

Faites glisser le curseur de gauche à droite pour activer le bouton de confirmation.

Attention : Vous devez activer Javascript dans votre navigateur pour utiliser le système anti-bot.

Pied de page des forums