Partage

Problème de return

me renvoie None

Sujet résolu

4 novembre 2011 à 22:26:36

Bonjour,

J'ai découvert Project Euler et je me fais des outils en Python pour résoudre les problèmes. Seulement j'ai un soucis avec ma fonction nextPrime, qui doit me renvoyer le nombre premier suivant le nombre x passé en paramètres. Je sais que ça fonctionne car si je met un print(x) avant le return, il m'affiche un bon résultat, mais le return me renvoie None. Je ne comprend pas pourquoi.

Mon code en Python3

def isPrime(self, x):
        """Return True if x is prime, False if not"""

        # A number is prime if it is only divisible by itself or 1
        # To test it, we divise x by numbers from 2 to sqrt(x)
        # To be faster, we test only odd numbers after 2
        limit = int(sqrt(x))

        if x <= 1:
            return False
        elif x % 2 == 0:
            return False

        for i in range(3, limit, 2):
            if x % i == 0:
                return False

        return True

def nextPrime(self, x):
        """Return next prime number after x"""
        x += 1
        if self.isPrime(x):
            return x
        else:
            self.nextPrime(x)

J'ai essayé de contourner le problème en faisant autrement, ce qui fait que j'ai encore des questions :-°

J'ai essayé de tout condenser en une list comprehension du genre :

return [i for i in ... if isPrime(x)]

C'est les trois points qui me manquent. Je pense qu'il me faut un itérateur qui compte tout seul de x à n en incrémentant de 1 à chaque fois. J'ai donc découvert itertools.count() mais je n'arrive pas à en faire quelque chose. Mais ce n'est peut-être pas faisable.

cerium50

4 novembre 2011 à 23:36:23

return self.nextPrime(x) tu as oublié le return (par contre faire ça de manière récursive ça n'est pas forcément une bonne idée, de manière itérative tu n'auras pas de problème de pile).

--

De plus je te conseille d'optimiser c'est fonction (avec un crible d'Erathostène par exemple/ou miller rabin) car c'est le genre de fonctions qui servent souvent sur PE.

Edit: désolé je n'avais pas lu la fin du message, avec itertools une solution pourrait être: return next(x for x in itertools.count(x + 1) if isprime(x))

carrion crow

5 novembre 2011 à 9:34:00

Ah merci

ça fonctionne. C'est souvent comme ça, j'oublie : une ( ou un petit truc, return ici, et je "perds" 2h à chercher pourquoi ça ne fonctionne pas (mais j'apprends des trucs du coup).

La deuxième solution fonctionne également, merci. Je pense que c'est elle qui est la meilleure ?

Pour le crible d'Érathostène, j'en avais fait un pour m'entrainer il y a quelque temps, mais il n'est pas capable de faire des grands nombre (je suis au problème 3), ça sature la mémoire et ne retourne rien. C'est pour ça que j'ai fait ma fonction nextPrime, pour ne pas remplir une liste de nombres premiers.

Le code que j'avais fait (qui décompose un nombre en produit de facteurs premier) Python3 toujours:

# Script de décomposition en produit de facteurs premiers
# ProduitFacteursPremiers attend un entier en argument
# Il renvoi une liste

from math import sqrt

class ProduitFacteursPremiers(object):
    """Théorème fondamental de l'arithmétique:
    chaque entier strictement positif peut être écrit comme un produit de
    nombres premiers d'une unique façon, à l'ordre près des facteurs
    """

    def __init__(self, nb):
        self.nb = int(nb)    # int pour être sur que c'est un entier
        # un nombre est premier n si divisible
        # par les nombres de 2 à racine de n, c'est la raison du sqrt
        self.liste_premiers = self.eratosthene(sqrt(self.nb))

    def eratosthene(self, limite):
        """Calcule les nombres premiers de 2 à limite"""
        #liste des entiers de 2 à limite
        liste = list(range(2, int(limite)+1))
        # liste vide pour accueillir les nombres premiers
        liste_premiers = []
        #tant qu'il y a des éléments dans la liste
        while liste:
            liste_premiers.append(liste[0])    # on ajoute le premier élément
            # on vire de la liste les multiples du premier élément
            liste = list(filter(lambda x: x%liste[0], liste))
        return liste_premiers

    def decomp(self):
        "Décomposition de nb en produit de facteurs premiers, renvoi une liste"
        c = 0
        facteur = []    #liste pour stocker les facteurs premiers

        while 1:
        # on s'arrête si le nombre premier au carré est
        # supérieur au nombre à tester
            if self.nb < self.liste_premiers[c]**2:
                facteur.append(int(self.nb))    # on ajoute le reste
                return facteur

            elif self.nb % self.liste_premiers[c] == 0:
                self.nb = self.nb / self.liste_premiers[c]
                #ajout d'un facteur à la liste
                facteur.append(self.liste_premiers[c])
            else:
                c += 1

if __name__ == '__main__':
    n = input("Entre un entier : ")
    test = ProduitFacteursPremiers(n)
    print(test.decomp())

candide

5 novembre 2011 à 10:58:05

Citation : carrion crow

Pour le crible d'Érathostène, j'en avais fait un pour m'entrainer il y a quelque temps

Il est indispensable de coder un crible d'Ératosthène pour faire les exos du projet Euler.

Citation : carrion crow

mais il n'est pas capable de faire des grands nombre (je suis au problème 3), ça sature la mémoire et ne retourne rien.

Pas besoind e crible pour le problème 3.

Citation : carrion crow

class ProduitFacteursPremiers(object):

Je vois pas du tout l'intérêt de code une classe pour calculer la décomposition en facteurs premiers. A priori, aucun besoin de crible pour décomposer en facteurs premiers. Regarde par exemple cette discussion :

[exercice] Décomposition en facteurs premiers

Au passage, on peut simplifier ton crible.

carrion crow

5 novembre 2011 à 11:27:21

Citation : candide

Citation : carrion crow

Pour le crible d'Érathostène, j'en avais fait un pour m'entrainer il y a quelque temps

Il est indispensable de coder un crible d'Ératosthène pour faire les exos du projet Euler.

OK, je vais en faire un (autre) alors.

Citation : candide

Citation : carrion crow

mais il n'est pas capable de faire des grands nombre (je suis au problème 3), ça sature la mémoire et ne retourne rien.

Pas besoind e crible pour le problème 3.

C'était par rapport à mon "vieux" code. Devant le problème 3, je me suis dit : «J'ai déjà codé un truc du genre, je n'ai qu'à faire max(test.decomp())», mais ça ne fonctionnait pas.

Citation : candide

Citation : carrion crow
class ProduitFacteursPremiers(object):
Je vois pas du tout l'intérêt de code une classe pour calculer la décomposition en facteurs premiers. A priori, aucun besoin de crible pour décomposer en facteurs premiers. Regarde par exemple cette discussion :

[exercice] Décomposition en facteurs premiers

J'avais fait une classe car j'étais débutant total et que je voulais m'entrainer à faire de la POO. Je suis toujours débutant, mais un peu moins quand même, et je ne comprends pas bien quand en faire. Je pense que faire une class PrimeNumbers pour mon nouveau code, regroupant des fonctions pour jouer avec les nombres premiers, est plus justifiée (même si le fait d'avoir une __init__() vide me semble suspect).

Pour ton lien, c'est quoi l'opérateur //= ? Je l'ai déjà rencontré dans mes recherche mais je ne peux pas le trouver via 'rechercher'.

Citation : candide

Au passage, on peut simplifier ton crible.

Ça je me doute bien

Je vais essayer d'en refaire un de 0 je pense, plutôt que modifier celui-là.

Sinon, je suis content, ça fonctionne pour le problème 3.

# -*- coding:utf-8 -*-
from math import sqrt
import itertools

class PrimeNumbers(object):
    """A collection  of tools for prime numbers"""

    def __init__(self):
        pass

    def isPrime(self, x):
        """Return True if x is prime, False if not"""

        # A number is prime if it is only divisible by itself or 1
        # To test it, we divise x by numbers from 2 to sqrt(x)
        # To be faster, we test only odd numbers after 2
        limit = int(sqrt(x))

        if x <= 1:
            return False
        elif x % 2 == 0:
            return False

        for i in range(3, limit, 2):
            if x % i == 0:
                return False

        return True

    def nextPrime(self, x):
        """Return next prime number after x"""
        x += 1
        if self.isPrime(x):
            return x
        else:
            return self.nextPrime(x)

    def nextPrime2(self, x):
        """Return next prime number after x, second solution"""
        return next(x for x in itertools.count(x + 1) if self.isPrime(x))

    def primeDecomposer(self, x):
        """Return a list of prime factorisation"""
        prime_factor_list =[]
        div = 2

        while x**2 > div:
            if x % div == 0:
                prime_factor_list.append(div)
                x = x / div
            else:
                div = self.nextPrime(div)

        return prime_factor_list


if __name__ == '__main__':
    test = PrimeNumbers()
    print(test.isPrime(3))
    print(test.isPrime(1))

    print(test.nextPrime(3))

    print(test.nextPrime2(4))

    print(test.primeDecomposer(600851475143))

candide

5 novembre 2011 à 12:05:10

Citation : carrion crow

OK, je vais en faire un (autre) alors.
Ça je me doute bien Je vais essayer d'en refaire un de 0 je pense, plutôt que modifier celui-là.

Bien. Je te suggère de poursuivre ce fil en ouvrant un autre post où tu proposeras ton code pour le crible d'Ératosthène, je ne crois pas qu'on ait déjà proposé ce code sur le forum Python du sdz et cela peut intéresser pas mal d'habitués de ce forum.

Citation : carrion crow

J'avais fait une classe car j'étais débutant total et que je voulais m'entrainer à faire de la POO. Je suis toujours débutant, mais un peu moins quand même, et je ne comprends pas bien quand en faire. Je pense que faire une class PrimeNumbers pour mon nouveau code, regroupant des fonctions pour jouer avec les nombres premiers, est plus justifiée (même si le fait d'avoir une __init__() vide me semble suspect).

Ça aussi ça mériterait tout un débat. Personnellement, je ne coderais pas tout de suite une ou des classes pour faire de l'arithmétique avant d'avoir écrit les bonnes fonctions, les plus simples possible. Une fois que ce serait assez avancé, je verrais si ça peut valoir le coup de coder ça avec des classes. Mais il ne faut pas se tromper, le plus dur est de coder des fonctions arithmétiques efficace après, écrire des classes n'a d'intérêt que si tu changes d'échelle et c'est une question d'une autre nature (réutilisabilité, lisibilité).

Citation : carrion crow

Pour ton lien, c'est quoi l'opérateur //= ? Je l'ai déjà rencontré dans mes recherche mais je ne peux pas le trouver via 'rechercher'.

C'est l'équivalent de l'opérateur += mais pour la division. Voici un code qui explique la sémantique de //= :

>>> x=42
>>> x //= 2
>>> x
21
>>> x=42
>>> x
42
>>> x=x//2
>>> x
21
>>>

Citation : carrion crow

Sinon, je suis content, ça fonctionne pour le problème 3.

# -*- coding:utf-8 -*-
from math import sqrt
import itertools

class PrimeNumbers(object):
    """A collection  of tools for prime numbers"""

    def __init__(self):
        pass

    def isPrime(self, x):
        """Return True if x is prime, False if not"""

        # A number is prime if it is only divisible by itself or 1
        # To test it, we divise x by numbers from 2 to sqrt(x)
        # To be faster, we test only odd numbers after 2
        limit = int(sqrt(x))

        if x <= 1:
            return False
        elif x % 2 == 0:
            return False

        for i in range(3, limit, 2):
            if x % i == 0:
                return False

        return True

    def nextPrime(self, x):
        """Return next prime number after x"""
        x += 1
        if self.isPrime(x):
            return x
        else:
            return self.nextPrime(x)

    def nextPrime2(self, x):
        """Return next prime number after x, second solution"""
        return next(x for x in itertools.count(x + 1) if self.isPrime(x))

    def primeDecomposer(self, x):
        """Return a list of prime factorisation"""
        prime_factor_list =[]
        div = 2

        while x**2 > div:
            if x % div == 0:
                prime_factor_list.append(div)
                x = x / div
            else:
                div = self.nextPrime(div)

        return prime_factor_list


if __name__ == '__main__':
    test = PrimeNumbers()
    print(test.isPrime(3))
    print(test.isPrime(1))

    print(test.nextPrime(3))

    print(test.nextPrime2(4))

    print(test.primeDecomposer(600851475143))

Ok, je vais regarder ce que tu avais fait.

cerium50

5 novembre 2011 à 12:31:56

Une petite remarque sur l'opérateur // au passage (il faut mieux que tu sois au courant) il fait la division entière i.e.

>>> 3//2
1
>>> 5//3
1
>>> 7//3
2
>>> 2.5//1
2.0

carrion crow

5 novembre 2011 à 12:35:18

Citation : candide

Citation : carrion crow

OK, je vais en faire un (autre) alors.
Ça je me doute bien Je vais essayer d'en refaire un de 0 je pense, plutôt que modifier celui-là.

Bien. Je te suggère de poursuivre ce fil en ouvrant un autre post où tu proposeras ton code pour le crible d'Ératosthène, je ne crois pas qu'on ait déjà proposé ce code sur le forum Python du sdz et cela peut intéresser pas mal d'habitués de ce forum.

Ok, quand je l'aurai fait, je ferai un topic tout neuf pour le partager.

Citation : candide

Citation : carrion crow

J'avais fait une classe car j'étais débutant total et que je voulais m'entrainer à faire de la POO. Je suis toujours débutant, mais un peu moins quand même, et je ne comprends pas bien quand en faire. Je pense que faire une class PrimeNumbers pour mon nouveau code, regroupant des fonctions pour jouer avec les nombres premiers, est plus justifiée (même si le fait d'avoir une __init__() vide me semble suspect).

Ça aussi ça mériterait tout un débat. Personnellement, je ne coderais pas tout de suite une ou des classes pour faire de l'arithmétique avant d'avoir écrit les bonnes fonctions, les plus simples possible. Une fois que ce serait assez avancé, je verrais si ça peut valoir le coup de coder ça avec des classes. Mais il ne faut pas se tromper, le plus dur est de coder des fonctions arithmétiques efficace après, écrire des classes n'a d'intérêt que si tu changes d'échelle et c'est une question d'une autre nature (réutilisabilité, lisibilité).

Citation : candide

Citation : carrion crow

Pour ton lien, c'est quoi l'opérateur //= ? Je l'ai déjà rencontré dans mes recherche mais je ne peux pas le trouver via 'rechercher'.

C'est l'équivalent de l'opérateur += mais pour la division. Voici un code qui explique la sémantique de //= :
>>> x=42
>>> x //= 2
>>> x
21
>>> x=42
>>> x
42
>>> x=x//2
>>> x
21
>>>

Merci

edit : merci aussi cerium50

Citation : candide

Citation : carrion crow

Sinon, je suis content, ça fonctionne pour le problème 3.

# -*- coding:utf-8 -*-
from math import sqrt
import itertools

class PrimeNumbers(object):
    """A collection  of tools for prime numbers"""

    def __init__(self):
        pass

    def isPrime(self, x):
        """Return True if x is prime, False if not"""

        # A number is prime if it is only divisible by itself or 1
        # To test it, we divise x by numbers from 2 to sqrt(x)
        # To be faster, we test only odd numbers after 2
        limit = int(sqrt(x))

        if x <= 1:
            return False
        elif x % 2 == 0:
            return False

        for i in range(3, limit, 2):
            if x % i == 0:
                return False

        return True

    def nextPrime(self, x):
        """Return next prime number after x"""
        x += 1
        if self.isPrime(x):
            return x
        else:
            return self.nextPrime(x)

    def nextPrime2(self, x):
        """Return next prime number after x, second solution"""
        return next(x for x in itertools.count(x + 1) if self.isPrime(x))

    def primeDecomposer(self, x):
        """Return a list of prime factorisation"""
        prime_factor_list =[]
        div = 2

        while x**2 > div:
            if x % div == 0:
                prime_factor_list.append(div)
                x = x / div
            else:
                div = self.nextPrime(div)

        return prime_factor_list


if __name__ == '__main__':
    test = PrimeNumbers()
    print(test.isPrime(3))
    print(test.isPrime(1))

    print(test.nextPrime(3))

    print(test.nextPrime2(4))

    print(test.primeDecomposer(600851475143))

Ok, je vais regarder ce que tu avais fait.

Il met ~26ms à s'exécuter, c'est pas mal non ?
Je mesure en faisant :

import time
debut = time.clock()
print(test.primeDecomposer(600851475143))
fin = time.clock()
print("Temps d'exécution : {} s".format(fin-debut))

Il y a peut-être mieux ? (je suis sur windows 7, il n'y a pas de fonction time comme sous GNU/Linux dans l'invite de commande)

candide

5 novembre 2011 à 12:44:46

Citation : carrion crow

Il met ~26ms à s'exécuter, c'est pas mal non ?

Ah oui mais j'avais pas vu que t'avais repris le code de mon lien. Sinon que ce soit très rapide, c'est normal car le nombre avait des facteurs premiers pas trop grands. Maintenant essaye avec un nombre premier assez grand (au hasard, une quinzaine de chiffres) et tu verras que c'est beaucoup plus long.

carrion crow

5 novembre 2011 à 13:15:47

Citation : candide

Citation : carrion crow

Il met ~26ms à s'exécuter, c'est pas mal non ?

Ah oui mais j'avais pas vu que t'avais repris le code de mon lien. Sinon que ce soit très rapide, c'est normal car le nombre avait des facteurs premiers pas trop grands. Maintenant essaye avec un nombre premier assez grand (au hasard, une quinzaine de chiffres) et tu verras que c'est beaucoup plus long.

En fait, je n'ai pas repris le code de ton lien. J'ai écrit le mien et en allant regarder ton lien, j'ai vu qu'il y avait une grosse similitude

(c'est plutôt un bon signe de ma progression ça, non ?)

Concernant le crible d'Ératosthène, quel est l'intérêt de procéder par élimination maintenant que j'ai isPrime() ?
Car pour construire une liste de premiers entre a et b, j'ai juste à faire :

def primeList(self, a, b):
        """Return a list of prime numbers between a and b"""
        return list([n for n in range(a, b) if self.isPrime(n)])

Et là, c'est le drame car en testant entre 1 et 100, ça me mets 9, 15, 25... qui ne sont pas des nombres premiers

C'est isPrime qui doit merder je pense.

cerium50

5 novembre 2011 à 13:42:47

C'est une question de complexité, en général il est plus coûteux de calculer isPrime de chaque x donné dans un intervalle plutôt que d'utiliser un crible. Mais j'admets que le problème 3 est un peu particulier car le plus simple pour le résoudre c'est probablement:

n = la_grande_valeur_que_jai_la_flemme_de_copier_coller
i = 2

while n != 1:
  while n % i == 0:
    print(i)
    n //= i
  i += 1

Mais quand tu seras dans des problèmes plus compliqué, tu n'auras pas vraiment le choix d'utiliser un crible d’Ératosthène

carrion crow

5 novembre 2011 à 15:02:33

Citation : carrion crow

...
Et là, c'est le drame car en testant entre 1 et 100, ça me mets 9, 15, 25... qui ne sont pas des nombres premiers
C'est isPrime qui doit merder je pense.

C'est bon, j'ai rajouté +1 à ma limit et ça roule.

Du coup isPrime() devient :

def isPrime(self, x):
        """Return True if x is prime, False if not"""

        # A number is prime if it is only divisible by itself or 1
        # To test it, we divise x by numbers from 2 to sqrt(x)
        # To be faster, we test only odd numbers after 2
        limit = int(sqrt(x)+1)    # +1 or it will return True for 9, 15, 25...

        if x <= 1:
            return False
        elif x % 2 == 0:
            return False

        for i in range(3, limit, 2):
            if x % i == 0:
                return False

        return True

@ cerium50 : ok. Ta solution est rapide et simple. Par contre, tu passes par des i qui ne sont pas premiers (quoique moi aussi, et en pire, à travers deux fonctions nextPrime() et isPrime() ) Bon du coup, j'étais content de mes fonctions, et bien plus maintenant, j'ai fait un truc "compliqué" alors que je pouvais faire très simple.

candide

5 novembre 2011 à 15:39:54

Citation : carrion crow

def isPrime(self, x):
        """Return True if x is prime, False if not"""

        # A number is prime if it is only divisible by itself or 1
        # To test it, we divise x by numbers from 2 to sqrt(x)
        # To be faster, we test only odd numbers after 2
        limit = int(sqrt(x)+1)    # +1 or it will return True for 9, 15, 25...

        if x <= 1:
            return False
        elif x % 2 == 0:
            return False

        for i in range(3, limit, 2):
            if x % i == 0:
                return False

        return True

On voit bien qu'utiliser une classe est ici artificiel : ta méthode n'utilise pas self. De tous les programmes de théorie élémentaire des nombres écrits par des spécialistes, je n'en ai vu aucun qui utilisait des classes. Pour de l'arithmétique moins élémentaire (entiers de Gauss, corps finis, etc), utiliser des classes me paraît beaucoup plus justifié. Disons que utiliser des classes pour surcharger ou dériver certaines méthodes (comme le pgcd par l'algorithme d'Euclide) pourrait à la rigueur se justifier.

On est en hors-sujet complet et tu devrais ouvrir un nouveau fil portant sur l'arithmétique avec Python.

Un détail mais 2 est déclaré non premier dans ton code, ce qui est incorrect bien sûr.

Francky__laH

5 novembre 2011 à 16:05:49

Sur le forum d'Euler, je t'avais déjà dit de regarder pour 9, 25, 49, ...
Bon courage pour la suite.

carrion crow

5 novembre 2011 à 19:28:47

Citation : candide

Citation : carrion crow

...

On voit bien qu'utiliser une classe est ici artificiel : ta méthode n'utilise pas self. De tous les programmes de théorie élémentaire des nombres écrits par des spécialistes, je n'en ai vu aucun qui utilisait des classes. Pour de l'arithmétique moins élémentaire (entiers de Gauss, corps finis, etc), utiliser des classes me paraît beaucoup plus justifié. Disons que utiliser des classes pour surcharger ou dériver certaines méthodes (comme le pgcd par l'algorithme d'Euclide) pourrait à la rigueur se justifier.

On est en hors-sujet complet et tu devrais ouvrir un nouveau fil portant sur l'arithmétique avec Python.

Un détail mais 2 est déclaré non premier dans ton code, ce qui est incorrect bien sûr.

Ok, je ne persiste pas avec une classe, je vais la virer. Je vais ouvrir un nouveau topic quand je serai de retour sur mon pc.

Citation : la Hache

Sur le forum d'Euler, je t'avais déjà dit de regarder pour 9, 25, 49, ...
Bon courage pour la suite.

Oui, je n'avais pas vu. Merci.
edit : c'est grâce à (à cause de ?) ta signature que j'ai découvert project euler

candide

5 novembre 2011 à 20:10:36

Citation : carrion crow

Citation : la Hache

Sur le forum d'Euler, je t'avais déjà dit de regarder pour 9, 25, 49, ...
Bon courage pour la suite.

Oui, je n'avais pas vu.

Le 9 et le 25 n'ont aucun rapport avec l'arithmétique (notre propos actuel) et sont assez simples. Le 49, lui, utilise un crible (enfin, il y a peut-être moyen de faire autrement).

carrion crow

5 novembre 2011 à 20:49:53

Citation : candide

Citation : carrion crow

Citation : la Hache

Sur le forum d'Euler, je t'avais déjà dit de regarder pour 9, 25, 49, ...
Bon courage pour la suite.

Oui, je n'avais pas vu.

Le 9 et le 25 n'ont aucun rapport avec l'arithmétique (notre propos actuel) et sont assez simples. Le 49, lui, utilise un crible (enfin, il y a peut-être moyen de faire autrement).

Je pense qu'il parlait des résultats de ma fonction et pas des numéros d'exercice

Francky__laH

5 novembre 2011 à 21:00:48

En effet. Je voulais attirer l'attention sur les carrés qui était premier avec sa fonction, je lui avait laissé un message sur Euler ; il a été vu, mais un peu tard.
--

Mode HS : le problème 357 est accessible pour beaucoup de monde. Allez-y !

candide

5 novembre 2011 à 22:31:59

Citation : la Hache

Mode HS : le problème 357 est accessible pour beaucoup de monde. Allez-y !

Oui, assez facile, je viens de le soumettre, quasi brute force, ça passe en quelques minutes en Python.

La suite est répertoriée sur le site de Sloane : A080715

Francky__laH

5 novembre 2011 à 22:42:14

PE357 : 50s pour moi, en enlevant un peu de gras.
Les idées les plus simples étant ici les meilleures.

carrion crow

6 novembre 2011 à 11:14:47

Sur ton conseil, candide, j'ai fait un topic sur le crible d'Ératosthène :
http://www.siteduzero.com/forum-83-706 [...] tosthene.html

Je dois en faire un autre sur l'arithmétique avec Python tu crois ?

candide

6 novembre 2011 à 14:25:25

Citation : carrion crow

Je dois en faire un autre sur l'arithmétique avec Python tu crois ?

Pour l'instant, non (on est que trois à discuter ...).