Compter le nombre d'occurence

Bonjour, je cherche à compter le nombre d’occurence de chaque caractère d’un string et renvoyer une liste de tulle de cette forme, par exemple avec le mot ballon: [(1,’a'),(1,’b'),(2,’l'),(1,’o'),(1,’n’)] voici le début de ce que j’ai réalisé

def frequ(s):
    occ=0
    char=''
    L=[]
    for i in range (len(s)):
        occ2=0
        for j in range(i,len(s)):
            if s[i]==L[i][0] and len(L)>0:
                L[i][0]+=(s[i]==s[j])
            else:
                L.append((s[i],0))
                
    return L

merci d’avance de votre aide

Salut !

En fait, il existe déjà un module dans la librairie standard de Python qui fait ce travail-là, et qui se nomme Counter.

>>> from collections import Counter
>>> Counter("ballon")
Counter({'l': 2, 'b': 1, 'a': 1, 'o': 1, 'n': 1})
>>> list(Counter("ballon").items())
[('b', 1), ('a', 1), ('l', 2), ('o', 1), ('n', 1)]

Et si tu cherches à réaliser l’algorithme par toi-même, je te conseille aussi d’utiliser un dictionnaire intermédiaire pour compter, ce sera plus pratique d’avoir les lettres comme clés.

Oui je suis au courant, mais pour coder cette fonction je n’ai pas le droit d’utiliser Count

Salut !

En fait, il existe déjà un module dans la librairie standard de Python qui fait ce travail-là, et qui se nomme Counter.

>>> from collections import Counter
>>> Counter("ballon")
Counter({'l': 2, 'b': 1, 'a': 1, 'o': 1, 'n': 1})

list(Counter("ballon").items()) [(’b', 1), (’a', 1), (’l', 2), (’o', 1), (’n’, 1)]

Source:[rezemika](https://zestedesavoir.com/forums/sujet/12301/compter-le-nombre-doccurence/?page=1#p201350)

Utilise un dictionnaire comme structure de donnée intermédiaire.

def frequ(s):
  alphabet = dict() # Normalement on écrit plutôt alpha = {} mais c'est pour que tu comprennes que c'est un dictionnaire
  for alpha in s:  # On a pas besoin de l'index. Seulement de la valeur. Autant utiliser cette boucle.
     pass # À remplacer par le reste de ton code
  
  return list(a.items()) # Transforme le dictionnaire en liste de tuple (clé, valeur)

L’idée, c’est que tu ajoutes dans le dictionnaire chaque occurrence de nouvelle lettre.
Si une lettre n’est pas dans le dictionnaire, tu ajoutes et tu fixes son nombre occurrence à 1. Si une lettre est déjà dans le dictionnaire alors tu augmentes de 1 son nombre d’occurrence.

Le dictionnaire n’est pas la seule manière, une autre manière algorithmique de faire cela avec une simple liste et d’initialiser chaque lettre de l’alphabet à 0.

>>> ord('a')
97
>>> occurences = [0] * 26
>>> occurences
[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]
>>> s = 'example'
>>> for c in s:
...     index = ord(c)-97
...     occurences[index] += 1
... 
>>> occurences
[1, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0]

On n’a pas d’information sur la composition de la chaîne et tu prends ici le parti qu’elle ne soit composée que de caractères latins minuscules non accentués. Je trouve difficilement gérable d’avoir un tel tableau pour tous les caractères unicode.

La liste est envisageable lorsque l’on peut dénombrer l’alphabet (et de cardinal raisonnable).

Ici, c’est pas évident.

Je pense que mon code est à peu près correct je voudrais juste le débugger ce serait plus simple que de tout refaire

@did1: Pourtant tu es loin de la solution. Ton code n’est pas beau et surtout pas claire !

On essaye pourtant de t’aider.

Par exemple quel est l’utilité de ta deuxième boucle ? Pourquoi ajouter L.append((s[i],0)) si tu sais que s[i] est déjà présent au moins une fois ?

Écrit déjà ton code en pseudo code, donne nous l’intention de ton code car là, c’est assez mal parti.

Il serait plus utile de connaître le niveau que tu as @did1, en nous disant entre autre d’où vient ce besoin de compter les occurrences des caractères. Est-ce un exercice scolaire ? Ça y ressemble en tout cas. Sinon la seule bonne réponse c’est : « Utilises les outils à ta disposition, ne réinvente pas la roue. » (donc utilises Counter(string)).

Vu le résultat attendu - une liste de tuples contenant chacun le nombre d’occurrence en premier et la caractère concerné en deuxième - et vu le code - il démontre que tu débutes depuis peu - je pense qu’il s’agit d’un exercice.

Tu ferais bien de fournir l’énoncé exact de l’exercice, ainsi que les notions de programmation que tu as étudié jusque-là, si tu veux vraiment des réponses utiles à ton apprentissage.

Il est assez peu lisible donc c’est plus compliqué de t’aider. J’y vois toutefois quelques principaux problèmes :

• Tu ne vérifies jamais que l[i] existe avant d’y accéder, alors que la liste ne peut jamais avoir assez d’éléments.
• Tu incrémentes L[i][0] qui est censée être une chaîne de caractères.
• Tu démarres ta boucle intérieure à i, ce qui te comptera toujours une occurrence, et donc les caractères présents plusieurs fois seront comptés en doubles, triples, etc.
• À quoi servent les variables occ, occ2 et char ?

Oui je suis au courant, mais pour coder cette fonction je n’ai pas le droit d’utiliser Count

Salut !

En fait, il existe déjà un module dans la librairie standard de Python qui fait ce travail-là, et qui se nomme Counter.

>>> from collections import Counter
>>> Counter("ballon")
Counter({'l': 2, 'b': 1, 'a': 1, 'o': 1, 'n': 1})

list(Counter("ballon").items()) [(’b', 1), (’a', 1), (’l', 2), (’o', 1), (’n’, 1)]

Source:[rezemika](https://zestedesavoir.com/forums/sujet/12301/compter-le-nombre-doccurence/?page=1#p201350)
Source:[did1](https://zestedesavoir.com/forums/sujet/12301/compter-le-nombre-doccurence/?page=1#p201366)

Dans ce cas, pourquoi ne pas essayer de la ré-implementer ? As-tu une idée de comment ça pourrait marcher, sous le capot ?

Yes j’ai rajouté la condition qui permet de checker si ma liste existe bienn, sinon pour L[i][0] c’est une petite erreur de frappe je cherche à incrémenter L[i][1] qui représente un int qui est le nombre d’occurence de ma lettre voici une deuxième version "améliorée" de mon travail sauf que j’ai un problème je n’arrive pas à incrémenter le deuxième élément de mon tuple;

def frequ(s):
    occ=0
    L=[]
    for i in range (len(s)):
        for j in range (i,len(s)):
            if i<len(L) and len(L)>0 and s[i]==L[i][0] :
                if s[i]==s[j]:
                    L[i][1]+=1
            else:
                L.append((s[i],0))

En effet, les tuples ne sont pas des objets modifiables, donc impossible de réassigner la valeur d’un élément.

Tu peux soit réassigner tout le tuple soit utiliser un autre type de données.

C’est sûr que ça se complique avec cette manière de faire… Plusieurs remarques

1. On peut initialiser L en y ajoutant déjà le 1er caractère de s avec une occurence de 1 avec L = [(s[0], 1)] et en testant qu’on a bien une chaîne non vide.
2. Il faut vérifier la présence d’une lettre, et ajouter 1 occurence si cette lettre est présente, pour ensuite remplacer ce tuple dans L, il est donc conseillé de jouer avec l’index de la liste pour le remplacement, enumerate semble bien pour ça.

C’est bien plus complexe que toutes les solutions proposées, et ça demande un esprit un peu plus tordu dans l’utilisation du type de données, car on écrase un tuple par un autre, quelque chose du genre,

L[index] = (letter, occ)

Je ne sais pas si ça vaut le coup d’aller au bout de cette méthode, même si elle a le mérite d’être une solution faîte par tes soins.

Pour simplifier le travail :

s = "Ceci est un exemple"
e = set(s)
e
{'x', 'n', 'l', 'C', 'u', 't', ' ', 'm', 'c', 'i', 'p', 'e', 's'}

Comme ça, tu sais quelles lettres chercher.

Ton exemple me fait penser à une possibilité d’implémentation qui a le mérite de tenir sur une ligne.

En créant un dictionnaire en intension à partir d’une itération sur ce set, en prenant pour clé les caractères, et pour valeur leur nombre d’apparitions dans la chaine, on peut obtenir très facilement un dictionnaire du nombre d’occurrences de chaque élément.

s = "Ceci est un exemple"
print(list({k: s.count(k) for k in set(s)}.items()))

[('s', 1), ('x', 1), ('t', 1), ('n', 1), ('u', 1), ('p', 1), ('e', 5), ('m', 1), ('c', 1), ('l', 1), (' ', 3), ('i', 1), ('C', 1)]

mais,

si on devait regarder l’ensemble des solutions, Counter est la solution ultime. Cependant c’est plus un travail algorithmique, donc faut réinventer la roue.