Bonjour, j'ai pu trouver tous les diviseurs d'un entier positif k, mais le résultat s'affiche en colonne. Comment faire pour qu'il s'affiche dans une liste? Je pense qu'il faut utiliser la méthode "append" mais je ne parviens pas à trouver la façon de l'inclure dans le programme. Par ailleurs, il y a "None" qui s'affiche à la fin de la colonne. A quoi correspond-il puisque, en principe, les divisions devraient s'arrêter à k+1. Comment ne pas faire apparaître ce "None" dans la liste? Merci beaucoup pour votre aide.

def all_divisors_of(k):				    
    for i in range(1, k + 1):
        if k % i == 0:
            print (i)
            
print (all_divisors_of(24)) #pour vérification
1
2
3
4
6
8
12
24
None

Voici pour la liste:

def all_divisors_of(k):
    result = []
    for i in range(1, k + 1):
        if k % i == 0:
            result.append(i)

    return result

print(all_divisors_of(24))

 Sinon pour le None, il s'explique simplement par le fait que tu essayes d'afficher le resultat de ta fonction "all_divisors_of". Or ta fonction ne renvoie rien du tout d'où le None. Quand tu print quelque chose dans une fonction pas besoin de faire un print de ta fonction pour l'afficher.

Une version améliorée de ta fonction en utilisant les listes en intentions:

def all_divisors_of(k):
    return [i for i in range(1, k+1) if k % i == 0]

print(all_divisors_of(24))

J'espère que cela t'aura aidé. N'hésites pas si tu as des questions

-
Edité par Kynarth 15 février 2016 à 9:48:11

Merci beaucoup, Kynarth, pour ta précieuse aide et tes explications qui m'éviteront de faire des erreurs dans l'avenir. Evidemment, ta solution est parfaite. Je vais garder la version la plus simple qui cadre mieux avec mes connaissances actuelles. La version améliorée, je la garde pour plus tard, lorsque j'aurai progressé.

Je ne m’attend pas à ce qu’une fonction appelé all_divisors_of affiche quelque chose à l’écran, elle doit renvoyer un itérable et l’affichage est réalisé par le corps du programme, c’est ce qu’a fait Kynarth.

Sinon, algorithmiquement parlant ont peut faire le même travail pour deux fois moins d’effort. Par la nature même d’un diviseur, quand on en trouve un il n’est pas bien difficile d’en générer un deuxième. Comme ceci par exemple :

from math import sqrt
def all_divisors_of(k):
    div = []
    for i in range(1, int(sqrt(k+1))):
        if k % i == 0:
            div.append(i)
            div.append(k//i)
    return div

-
Edité par talpa 15 février 2016 à 10:27:12

Merci beaucoup, talpa, pour ton message: je suis toujours intéressée à tester d'autres chemins d'accès pour obtenir le résultat désiré.

La solution de Kynarth a le mérite d'être accessible à tout débutant, comme moi. Elle affiche le résultat de la façon désirée:

[1, 2, 3, 4, 6, 8, 12, 24]

Mais en testant ton programme, je m'aperçois que les résultats ne sont pas dans l'ordre croissant, ce qui obligerait à faire encore un classement :

[1, 24, 2, 12, 3, 8, 4, 6]

Encore merci pour m'avoir fait progresser, bonne journée. 

Anpiet a écrit:

Mais en testant ton programme, je m'aperçois que les résultats ne sont pas dans l'ordre croissant

C’est évident puisque j’insère les diviseurs au fur et a mesure que je les trouves. Par exemple pour 24 dès que l’on trouve 1, on a tout de suite 24, lorsque l’on trouve 2, on a tout de suite 12, idem pour les couple (3, 8) et (4, 6). J’ajoute qu’avoir les diviseurs dans l’ordre croissant ne fait pas parti de l’énoncé.

Si c’est un besoin on peut éventuellement faire un tri mais c’est une opération relativement coûteuse. Le plus malin est sans doute de stocker les diviseurs que l’on trouve par essai successif dans une liste et les diviseurs complémentaires dans une autre puis de les concaténer. Comme ceci :

from math import sqrt
def all_divisors_of(k):
    small_div = []
    big_div = []
    for i in range(1, int(sqrt(k))+1):
        if k % i == 0:
            small_div.append(i)
            big_div.append(k//i)
    big_div.reverse()
    return small_div + big_div

Il y a encore un tout petit problème avec cette fonction, tu le verras en lui passant un carré parfait. Il n’est pas bien difficile de corriger le problème, je te laisse le faire. Cette solution te semble peut être un peu plus compliqué (en fait elle reste très simple) mais elle est beaucoup plus efficace, si tu essayes d’obtenir les facteurs d’un nombre un peu plus costaud, mettons 987654321, tu verras que la solution naïve montre rapidement ses limites.

Bon après soyons clair, l’algorithme que je propose est bête à manger du foin lui aussi, et la factorisation de grand nombre est un problème difficile qui est encore un sujet actif de recherche.

-
Edité par talpa 16 février 2016 à 14:46:52

Bonjour, talpa. Je me doutais que la méthode naïve allait mettre beaucoup de temps pour traiter de grands nombres puisqu'elle doit effectuer une quantité de divisions dont beaucoup sont inutiles. Et en effet, en testant un nombre à 10 chiffres, la première méthode a mis si longtemps que j'ai fait autre chose pendant qu'elle faisait son travail. Alors qu'avec le tout dernier programme, le résultat a été instantané, et de plus, classé par ordre croissant.   

En analysant ton programme étape par étape en utilisant pythontutor, j'ai vraiment bien compris comment il fonctionnait. C'est sûr que je n'aurais pas su le concevoir par moi-même mais il est très clair et je m'en inspirerai pour l'avenir. Merci beaucoup.