Partage
  • Partager sur Facebook
  • Partager sur Twitter

exercice programmation fonctionnelle

programme python

    12 septembre 2020 à 18:27:46

    Bonjour je dois faire 4 exercices et je voudrais avoir de l'aide. J'ai essayer de fairela 1ière mais je ne suis même pas approché à la réponse.

    Exercices: En utilisant la programmation fonctionnelle: (i.e. les compréhensions de listes ou les fonctions "map","filter","enumerate","zip")

    Exo1: Donner la liste des entiers au cube inférieurs à 2000

    list1=[(x**3) for x in range (1,20) if ((x**3)<2000]
    print(list1)

    Exo2: Donner l'ensemble des triplets pythagoriciens dont les nombres sont tous inférieurs à 100.

    L'exemple le plus connu est (3,4,5) mais il y en a d'autres ... Par exemple: (9,12,15) car 9²+12²=15²

    Exo3: Donner la liste des mots de 2 lettres ayant un écart de 1 par rapport à l'ordre alphabétique. Ex: "EF" ou "KJ" ...

    Exo4: Trouver l'ensemble des points à coordonnées entières d'abscisse strictement inférieur à 1000 se trouvant sur la parabole d'équation p(x) = 3/5 x**2  -3x + 2/5

    Par exemple, le point (16,106) a des coordonnées entières et se trouve sur cette parabole

    --> savoir si sur un parabole, on remplace x et y avec le point.

    • Partager sur Facebook
    • Partager sur Twitter
      12 septembre 2020 à 19:07:57

      > Exo1: Donner la liste des entiers au cube inférieurs à 2000
      C'est le nombre ou le cube qui doit être inférieur à 2000?
      liste = [ x**3 for x in range(1, 2000) ]
      ou:
      liste = [ x**3 for x in range(1, 2000**(1/3)) ]
      Pour les triplets Pythagoriciens, on remarque que si i et j sont deux entiers relativement premiers, on aura:
      (i**2 - j**2)**2 + (2*i*j)**2 = (i**2 + j**2)**2
      Ça marche pour tous les entiers positifs, mais si i et j sont relativement premiers, on ne retrouvera pas les multiples d'autres déjà retrouvés.
      Par exemple 3, 4, 5 -> 6, 8, 10 -> 9, 12, 15 -> ...
      Pour les lettres consécutives, voir la fonction ord().
      ord('f') + 1 = ord('g')
      ou bien:
      alphabet = "abcdefghijklmnopqrstuvwxyz"
      for i in range(len(alphabet)-1):
          print(alphabet[i:i+2])
      Pour les points de la parabole, La fonction p() pourrait être une fonction lambda
      p = lambda x: 3/5 * x**2 - 3 * x + 2/5
      for x in range(0, 1000):
          print(x, p(x))
      Ça ne garantit pas que le résultat soit entier ...

      -
      Edité par PierrotLeFou 12 septembre 2020 à 19:17:25

      • Partager sur Facebook
      • Partager sur Twitter

      Le Tout est souvent plus grand que la somme de ses parties.

        12 septembre 2020 à 21:35:33

        l'exercice 1: il faut que le nombre au cube soit en dessous de 2000.

        j'ai essayer d'executer comme vous l'aviez écrite mais ça ne marche .

        • Partager sur Facebook
        • Partager sur Twitter
          13 septembre 2020 à 1:25:21

          Comme quoi il faut faire attention aux conversions flottant -> entier. Essaies ce code:
          liste = [x**3 for x in range(1, 2000) if x**3 < 2000 ]
          print(liste)
          print(int(2000**(1/3)))
          liste = [x**3 for x in range(1, int(2000**(1/3))) ]
          print(liste)
          Et voici ce que ça donne:
          [1, 8, 27, 64, 125, 216, 343, 512, 729, 1000, 1331, 1728]                                                               
          12                                                                                                                     
          [1, 8, 27, 64, 125, 216, 343, 512, 729, 1000, 1331]                                                                      
          Tu as présumé que le cube de 20 était supérieur à 2000 (ce qui est vrai)
          Mais si on saisit la limite, comment sais-tu quel nombre placer.
          Ce qui suit donne le bon intervalle et ne fait pas d'opération inutile en allant jusqu'à 2000.
          liste = [x**3 for x in range(1, int(2000**(1/3))+1) ]
          Et si j'entre 1728 qui est 12**3, il sera inclus. Alors que faire?
          limite = 2000 # ou 1728
          liste = [ x**3 for x in range(1, int(limite**(1/3))+1) if x**3 < limite ]
          Je fais un minimum d'opérations en n'incluant pas la limite.
          Je me suis amusé à élaborer une réponse par étapes. Ceci est encore plus efficace:
          limite = 2000  # ou 1728
          maximum = int(limite**(1/3))
          if maximum**3 >= limite:
              maximum -= 1
          liste = [ x**3 for x in range(1, maximum+1) ]
          Pour les triplets pithagoriciens, on aura:
          pgcd=lambda a,b: a if b==0 else pgcd(b,a%b)
          liste = [(i*i-j*j, 2*i*j, i*i+j*j) for j in range(1, 100) for i in range(1, 100) if j<i and (i-j)%2==1 and pgcd(i,j)==1 and i*i+j*j <= 100 ]
          print(liste)
          Pour les lettres consécutives, on pourra écrire:
          alpha="abcdefghijklmnopqrstuvwxyz"
          liste = [ alpha[i:i+2] for i in range(len(alpha)-1) ]
          print(liste)
          Pour la parabole, il faut que (3*x**2+2) soit divisible par 5 pour avoir un entier:
          liste = [(x, (3*x**2+2)//5-3*x) for x in range(1000) if (3*x**2+2)%5==0 ]
          print(liste)

          -
          Edité par PierrotLeFou 13 septembre 2020 à 6:45:10

          • Partager sur Facebook
          • Partager sur Twitter

          Le Tout est souvent plus grand que la somme de ses parties.

            13 septembre 2020 à 11:53:25

            merci beaucoup!!!

            mais j'ai juste une question pour la dernière. Vous pourriez juste expliquer les calculs pour l'exos 4 parce que j'ai pas vraiment compris. C'est une formule de maths que vous utiliser ?

            • Partager sur Facebook
            • Partager sur Twitter
              13 septembre 2020 à 12:10:45

              Il utilise juste la fonction de l'énoncé.

              Pour la 3 j'aurais utilisé zip :

              alp = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
              liste = [a + b for a, b in zip(alp, alp[:1])]
              


              On peut même utiliser map :

              liste = list(map("".join, zip(alp, alp[1:])))



              -
              Edité par thelinekioubeur 13 septembre 2020 à 12:17:02

              • Partager sur Facebook
              • Partager sur Twitter
                13 septembre 2020 à 13:00:51

                thelinekioubeur a écrit:

                Il utilise juste la fonction de l'énoncé.

                Pour la 3 j'aurais utilisé zip :

                alp = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                liste = [a + b for a, b in zip(alp, alp[:1])]
                
                alp[:1] erreur de frappe je suppose ...


                On peut même utiliser map :

                liste = list(map("".join, zip(alp, alp[1:])))

                mais 'BA' es valide et n'y est pas ...

                ma contrib.

                alp = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                
                foo = lambda x1,x2,*xs: (x1+x2,x2+x1)+(xs and foo(x2,*xs))
                
                print(foo(*alp))
                
                # ~ ('AB', 'BA', 'BC', 'CB', 'CD', 'DC', 'DE', 'ED', 'EF', 'FE', 'FG', 'GF', 'GH', 'HG', 'HI', 'IH', 'IJ', 'JI', 'JK', 'KJ', 'KL', 'LK', 'LM', 'ML', 'MN', 'NM', 'NO', 'ON', 'OP', 'PO', 'PQ', 'QP', 'QR', 'RQ', 'RS', 'SR', 'ST', 'TS', 'TU', 'UT', 'UV', 'VU', 'VW', 'WV', 'WX', 'XW', 'XY', 'YX', 'YZ', 'ZY')



                -
                Edité par josmiley 13 septembre 2020 à 13:01:35

                • Partager sur Facebook
                • Partager sur Twitter

                Python c'est bon, mangez-en. 

                  13 septembre 2020 à 14:12:31

                  ya rien de plus moche que d'assigner un lambda.
                  • Partager sur Facebook
                  • Partager sur Twitter
                    13 septembre 2020 à 14:37:32

                    thelinekioubeur a écrit:

                    ya rien de plus moche que d'assigner un lambda.


                    Ha ? Sur quelle base ?
                    • Partager sur Facebook
                    • Partager sur Twitter

                    Python c'est bon, mangez-en. 

                      13 septembre 2020 à 17:37:17

                      Si tu veux donner un nom à ta fonction, le def est fait pour ça.

                      Les lambda c'est bien pour passer directement la fonction en argument.

                      • Partager sur Facebook
                      • Partager sur Twitter
                        13 septembre 2020 à 18:40:57

                        Le message original disait:
                        «Exo4: Trouver l'ensemble des points à coordonnées entières d'abscisse strictement inférieur à 1000 se trouvant sur la parabole d'équation p(x) = 3/5 x**2  -3x + 2/5»
                        Si je reprend la formule de la fonction:
                        p(x) =3/5*x**2 - 3*x + 2/5
                        On choisit x parmi des entiers, mais comme je l'ai dit dans mon premier message, ce n'est pas certain que le résultat soit un entier.
                        Je remarque que le premier et le dernier terme ont un diviseur de 5.
                        Le deuxième terme (3*x) est entier puisque je choisis x comme entier.
                        Pour que 3/5*x**2 + 2/5 soit entier, il faut que (3*x**2 + 2/5) soit un entier.
                        Donc, il faut que (3*x**2+2) soit divisible par 5, donc que (3*x**2+2)%5 == 0.
                        Finalement, on peut écrire la fonction de la façon suivante:
                        p(x) = (3*x**2+2)/5-3*x
                        Mais comme on veut un résultat entier, on remplace la division flottante par la division entière:
                        p(x) = (3*x**2+2)//5-3*x
                        CQFD
                        @josmiley:
                        Pour les triplets pythagoriciens, j'ai écrit:
                        liste = [(i*i-j*j, 2*i*j, i*i+j*j) for j in range(1, 100) for i in range(1, 100) if j<i and (i-j)%2==1 and pgcd(i,j)==1 and i*i+j*j <= 100 ]
                        J'aurais voulu écrire:
                        liste = [(i*i-j*j, 2*i*j, i*i+j*j) for j in range(i+1, 100, 2) for i in range(1, 100) if pgcd(i,j)==1 and i*i+j*j <= 100 ]
                        Mais Python me dit qu'il ne reconnait pas la variable 'i', comment je ferais pour y arriver?
                        Il y a un truc plus compliqqué pour changer les limites des range. Je l'ai déjà fait en Fortran et en C, mais je ne me rappelle plus ce que c'est.
                        L'expression serait beaucoup plus simple et plus rapide et donnerait:
                        liste = [(i*i-j*j, 2*i*j, i*i+j*j) for j in range(i+1, limj, 2) for i in range(1, limi) if pgcd(i,j)==1 ]

                        -
                        Edité par PierrotLeFou 13 septembre 2020 à 19:00:03

                        • Partager sur Facebook
                        • Partager sur Twitter

                        Le Tout est souvent plus grand que la somme de ses parties.

                          13 septembre 2020 à 18:50:50

                          Les lambdas, c'est des valeurs, et quand on a besoin de les mettre dans une variable, il n'y a aucune raison de s'en priver.

                          Les lambdas, ce n'est PAS comme les fonctions, parce que ça capture des variables.

                          minimum = 2
                          maximum = 5
                          
                          valide = lambda x : minimum <= x and x <= maximum
                          
                          list(filter(valide, [1, 3, 5, 8, 12 ]))
                          
                          => [3, 5]
                          
                          
                          maximum = 10
                          list(filter(valide, [1, 3, 5, 8, 12 ]))
                          
                          => [3, 5, 8, 12]



                          -
                          Edité par michelbillaud 13 septembre 2020 à 18:58:26

                          • Partager sur Facebook
                          • Partager sur Twitter
                            13 septembre 2020 à 19:36:55

                            Pour que i soit maximum, il faut que j soit minimum:
                            i*i+1*1<maximum
                            i*i<maximum-1
                            i<sqrt(maximum-1)
                            limi=int(sqrt(maximum-1))
                            Pour que j soit maximum pour chaque i, il faut que j soit égal à i-1
                            i**2 + (i-1)**2 = i**2 + i**2 - 2*i + 1 < maximum
                            2*x**2 - 2*x +1 < maximum
                            Formule générale: x = -b  ±sqrt(b²-4ac) / 2a
                            ...

                            -
                            Edité par PierrotLeFou 13 septembre 2020 à 19:38:52

                            • Partager sur Facebook
                            • Partager sur Twitter

                            Le Tout est souvent plus grand que la somme de ses parties.

                              13 septembre 2020 à 19:54:20

                              josmiley a écrit:

                              thelinekioubeur a écrit:

                              ya rien de plus moche que d'assigner un lambda.


                              Ha ? Sur quelle base ?


                              La PEP8
                              • Partager sur Facebook
                              • Partager sur Twitter

                              Celui qui trouve sans chercher est celui qui a longtemps cherché sans trouver.(Bachelard)
                              La connaissance s'acquiert par l'expérience, tout le reste n'est que de l'information.(Einstein)

                                13 septembre 2020 à 19:58:20

                                fred1599 a écrit:

                                josmiley a écrit:

                                thelinekioubeur a écrit:

                                ya rien de plus moche que d'assigner un lambda.


                                Ha ? Sur quelle base ?


                                La PEP8

                                Tu te doutes bien que je ne l'ai jamais lu ^^

                                @PierrotLeFou

                                comme ça peut-être:

                                liste = [(i*i-j*j, 2*i*j, i*i+j*j)for i in range(1, 100) for j in range(i+1, 100, 2)  if pgcd(i,j)==1 and i*i+j*j <= 100 ]

                                -
                                Edité par josmiley 13 septembre 2020 à 20:02:53

                                • Partager sur Facebook
                                • Partager sur Twitter

                                Python c'est bon, mangez-en. 

                                  14 septembre 2020 à 2:42:11

                                  En ce qui concerne les triplets pythagoriciens primitifs (sans facteurs communs)
                                  Pour ceux qui n'aiment pas les lambda, j'ai commis ceci :)
                                  Ça me semble la façon la plus efficace de le faire du point de vue du nombre d'évaluations.
                                  -
                                  from math import sqrt
                                  maximum=100
                                  jmax=int((sqrt(2*maximum-0.5)-1)/2)
                                  imax=lambda j: int(sqrt(maximum-j*j+0.5))
                                  pgcd=lambda a,b: a if b==0 else pgcd(b,a%b)
                                  liste=[[(i*i-j*j, 2*i*j, i*i+j*j) for i in range(j+1, imax(j), 2) if pgcd(i,j)==1] for j in range(1, jmax)]
                                  print(liste)

                                  -
                                  Edité par PierrotLeFou 14 septembre 2020 à 2:51:00

                                  • Partager sur Facebook
                                  • Partager sur Twitter

                                  Le Tout est souvent plus grand que la somme de ses parties.

                                    14 septembre 2020 à 7:58:09

                                    Il faut que tu colore ton code pierrot, c'est chiant à lire...

                                    Aussi il y a une fonction math.gcd.

                                    Voici une solution simple pour les pythagoriciens :

                                    from itertools import combinations
                                    
                                    def is_pyt(a, b, c):
                                        return a ** 2 + b ** 2 == c ** 2
                                    
                                    liste = [c for c in combinations(range(1, 101), 3) if is_pyt(*c)]


                                    Si je ne veux que les primitifs il suffit de changer ça

                                    def is_pyt(a, b, c):
                                        return math.gcd(a, b) == 1 and a ** 2 + b ** 2 == c ** 2



                                    -
                                    Edité par thelinekioubeur 14 septembre 2020 à 8:01:58

                                    • Partager sur Facebook
                                    • Partager sur Twitter
                                      14 septembre 2020 à 8:26:05

                                      Mon prof a commenter mon devoir, il m'a  dit d'améliorer:

                                      Exo 1: OK

                                      Exo 2: cela fonctione mais il y avait plus simple.

                                      Exo 3: il manque des mots comme 'ba', 'ih'...

                                      Exo 4: l'équation de la parabole ne contient pas de "//" et la condition "if" est à revoir.

                                      • Partager sur Facebook
                                      • Partager sur Twitter
                                        14 septembre 2020 à 9:40:34

                                        Pour le 3 si t'as pris mon code c'est normal, j'ai mal lu l'énoncé :-°

                                        Pour le 4 tu as du prendre le deuxième de Pierrot ? (le liste = [(x, (3 * x ** 2 + 2) // 5 - 3 * x) for x in range(1000) if (3 * x ** 2 + 2) % 5 == 0] ?)

                                        Je crois qu'il est tout à fait correct. Ce n'est pas parce que l'équation n'a pas de // qu"il ne faut pas l'utiliser. On ne peut pas utiliser / à cause de l'imprécision des flottants.

                                        • Partager sur Facebook
                                        • Partager sur Twitter
                                          14 septembre 2020 à 10:20:36

                                          roro15151626 a écrit:

                                          Exo 4: l'équation de la parabole ne contient pas de "//" et la condition "if" est à revoir.


                                          au départ, on peut commencer par écrire:

                                          for x in range(20):
                                              y = (3/5)* x**2  -3*x + 2/5
                                              print(x, y) 

                                          Comme on nous a dit que pour x = 16, on devait avoir y = 106, on peut vérifier qu'on a la sortie correspondante et être confiant sur le codage de la fonction p(x).

                                          Reste à ajouter une condition pour filtrer les y entiers.

                                          Ce qu'on peut faire avec y == int(y) ou en utilisant y.is_integer()

                                          Enfin on peut faire varier x de  0 à 999.

                                          • Partager sur Facebook
                                          • Partager sur Twitter
                                            14 septembre 2020 à 10:33:08

                                            mps a écrit:

                                            Reste à ajouter une condition pour filtrer les y entiers.

                                            Tu ne peux pas vraiment filtrer les entiers si tu utilise le type float, à cause des erreurs d'arrondi :

                                            >>> (3 / 5) * 6 ** 2 + 2 / 5
                                            21.999999999999996
                                            


                                            Après plutôt que de faire des modulo on peut aussi plus naturellement utiliser le type Fraction :

                                            >>> from fractions import Fraction
                                            >>> Fraction(3, 5) * 6 ** 2 + Fraction(2, 5)
                                            Fraction(22, 1)
                                            



                                            -
                                            Edité par thelinekioubeur 14 septembre 2020 à 10:34:56

                                            • Partager sur Facebook
                                            • Partager sur Twitter
                                              14 septembre 2020 à 11:13:48

                                              thelinekioubeur a écrit:

                                              mps a écrit:

                                              Reste à ajouter une condition pour filtrer les y entiers.

                                              Tu ne peux pas vraiment filtrer les entiers si tu utilise le type float, à cause des erreurs d'arrondi :

                                              >>> (3 / 5) * 6 ** 2 + 2 / 5
                                              21.999999999999996

                                              Ok, alors on ré-écrit la fonction pour virer les nombres flottants (en multipliant par 5 les différents termes) et on teste la divisibilité par 5:

                                              for x in range(20):
                                                  u = 3*x**2 - 15*x + 2
                                                  q, r = divmod(u, 5)
                                                  if r == 0:
                                                     print(x, q)



                                              • Partager sur Facebook
                                              • Partager sur Twitter
                                                14 septembre 2020 à 14:56:01

                                                Pour précision, je ne peux pas colorer mon code, j'utilise une synthèse vocale (voir mon profil)
                                                Pour l'exo4, j'ai assez bien décrit pourquoi j'ai utilisé le // au lieu du /
                                                si on fait y=int(y) pour toutes les valeurs de x, on verra que c'est différent de la formule avec le // dans la plupart des cas.
                                                Il faut choisir les x tels que (3*x**2+2)%5==0
                                                • Partager sur Facebook
                                                • Partager sur Twitter

                                                Le Tout est souvent plus grand que la somme de ses parties.

                                                  14 septembre 2020 à 15:17:56

                                                  Ah désolé, j'ai pensé que tu utilisais un clavier braille ou quelque chose comme ça.
                                                  Sinon, comme on l'a vu il y a plus d'un moyen d'éviter le problème des floats. Encore faut-il avoir conscience du problème, et on peut se demander si c'est le cas du professeur de @roro s'il trouve que le code est faux...
                                                  • Partager sur Facebook
                                                  • Partager sur Twitter
                                                    14 septembre 2020 à 17:25:29

                                                    roro15151626 a écrit:

                                                    Mon prof a commenter mon devoir, il m'a  dit d'améliorer:

                                                    Exo 1: OK

                                                    Exo 2: cela fonctione mais il y avait plus simple.

                                                    Exo 3: il manque des mots comme 'ba', 'ih'...

                                                    Exo 4: l'équation de la parabole ne contient pas de "//" et la condition "if" est à revoir.

                                                    Pour l'exo2, d'autres ont montré que c'était possible de faire plus simple.

                                                    J'aimerais tout de même voir la solution du prof.

                                                    Pour l'exo4, il s'agit d'une expression algébrique.

                                                    3x**2 et 3x ne sont pas valides en Python.

                                                    Il était exigé que les deux coordonnées soient des entiers, et j'ai précisé quelle était la condition.

                                                    Pour l'exo3, je n'ai pas remarqué que les suites inverses devaient être incluses.

                                                    • Partager sur Facebook
                                                    • Partager sur Twitter

                                                    Le Tout est souvent plus grand que la somme de ses parties.

                                                      14 septembre 2020 à 19:06:24

                                                      Je n'avais pas remarqué non plus, mais en fait ya l'exemple de "KJ" dans l'énoncé.
                                                      • Partager sur Facebook
                                                      • Partager sur Twitter
                                                        15 septembre 2020 à 1:46:34

                                                        La méthode que j'ai présenté pour les triplets pythagoriciens me garantit que ce sont bien des triplets valides.
                                                        Cependant, cela ne me garantit pas que je les ai tous trouvés. En utilisant la force brute, je me rend compte qu'il en manque.
                                                        J'ai donc écrit ceci qui pourrait sûrement être amélioré:
                                                        -
                                                        import math
                                                        maximum=100
                                                        check=lambda t: True if t[0]<t[1] and t[2]<maximum and t[0]**2+t[1]**2==t[2]**2 and math.gcd(t[0],t[1])==1 else False
                                                        liste=list(filter(check, [(a, b, int(math.sqrt(a*a+b*b+0.5))) for a in range(1,maximum) for b in range(1,maximum)]))
                                                        print(liste)
                                                        • Partager sur Facebook
                                                        • Partager sur Twitter

                                                        Le Tout est souvent plus grand que la somme de ses parties.

                                                          17 septembre 2020 à 8:20:22

                                                          michelbillaud a écrit: > Les lambdas, ce n'est PAS comme les fonctions, parce que ça capture des variables.

                                                          >>> minimum = 2
                                                          >>> maximum = 5
                                                          >>> def valide(x): return minimum <= x <= maximum
                                                          ... 
                                                          >>> list(filter(valide, [1, 3, 5, 8, 12 ]))
                                                          [3, 5]
                                                          >>> maximum = 10
                                                          >>> list(filter(valide, [1, 3, 5, 8, 12 ]))
                                                          [3, 5, 8]
                                                          

                                                          J'imagine que le 12 dans ton résultat était une erreur, ça donne donc bien la même chose avec une fonction.

                                                          PierrotLeFou a écrit: > Pour précision, je ne peux pas colorer mon code, j'utilise une synthèse vocale (voir mon profil)

                                                          Pas de soucis concernant la coloration, on connaît tous la bonne accessibilité de ce forum. Mais est-ce que tu aurais moyen d'espacer un peu plus, rien que délimiter les blocs de code par des lignes vides de part et d'autre aiderait beaucoup à sa lecture.

                                                          -
                                                          Edité par entwanne 17 septembre 2020 à 8:21:05

                                                          • Partager sur Facebook
                                                          • Partager sur Twitter
                                                            17 septembre 2020 à 12:09:45

                                                            Ah oui, ptet bien un fausse manip

                                                            • Partager sur Facebook
                                                            • Partager sur Twitter
                                                              17 septembre 2020 à 18:49:37

                                                              @entwanne:
                                                              « Pas de soucis concernant la coloration, on connaît tous la bonne accessibilité de ce forum. Mais est-ce que tu aurais moyen d'espacer un peu plus, rien que délimiter les blocs de code par des lignes vides de part et d'autre aiderait beaucoup à sa lecture.»
                                                              Il arrive souvent que l'éditeur du forum me bouffe des lignes vides ou ne comportant que des espaces. C'est pourquoi je n'en mets plus.
                                                              Quand j'insère beaucoup de code, je le précède avec des tirets ('-').
                                                              Mais je ne le fais pas pour une seule ligne. Je peux le faire si ça aide les autres.
                                                              En Python, je peux également séparer les parties de mon code avec une ligne ne contenant que '#' comme commentaire vide.
                                                              #
                                                                  print(...)
                                                              #
                                                              Commentaire ...
                                                              #
                                                                  autre code
                                                              • Partager sur Facebook
                                                              • Partager sur Twitter

                                                              Le Tout est souvent plus grand que la somme de ses parties.

                                                              exercice programmation fonctionnelle

                                                              × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                                                              × Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
                                                              • Editeur
                                                              • Markdown