Manipulation de grands nombres dans le code

Je suis en train de travailler sur un problème de programmation où j'ai besoin de gérer un certain nombre impliquant 100000 chiffres. Peut-python gérer les numéros de ce genre?

source d'informationauteur

  1. 23

    Comme d'autres réponses ont indiqué, Python n'a le soutien d'un nombre entier limité que par la quantité de mémoire disponible. Si vous voulez encore plus rapide de l'aide pour eux, essayez de gmpy (comme gmpy est auteur et co-responsable, je suis bien sûr un peu biaisé ici;-):

    $ python -mtimeit -s'import gmpy; x=10**100000; y=gmpy.mpz(x)' 'x+1'
10000 loops, best of 3: 114 usec per loop
$ python -mtimeit -s'import gmpy; x=10**100000; y=gmpy.mpz(x)' 'y+1'
10000 loops, best of 3: 65.4 usec per loop

    Généralement, l'arithmétique n'est pas le goulot d'étranglement de travailler avec de tels chiffres (bien que gmpydirects de prise en charge de certains combinatoire et théorie des nombres, les fonctions peuvent aider si c'est ce que vous faites avec de tels chiffres). Tournant les nombres en virgule chaînes est probablement la commune de l'opération qui sera plus lent...:

    $ python -mtimeit -s'import gmpy; x=10**100000; y=gmpy.mpz(x)' 'str(x)'
10 loops, best of 3: 3.11 sec per loop
$ python -mtimeit -s'import gmpy; x=10**100000; y=gmpy.mpz(x)' 'str(y)'
10 loops, best of 3: 27.3 msec per loop

    Comme vous le voyez, même dans gmpy stringification d'un grand nombre peut être des centaines de fois plus lent qu'un simple plus (hélas, c'est une intrinsèquement opération compliquée!); mais en natif code Python le ratio de fois pouvez aller à stringification être des dizaines de milliers fois plus lent qu'une simple addition, de sorte que vous voulez vraiment faire attention pour que, surtout si vous décidez de ne pas télécharger et installer gmpy (par exemple parce que vous ne pouvez pas: par exemple, gmpy n'est pas actuellement pris en charge sur Google App Engine).

    Enfin, un cas intermédiaire:

    $ python2.6 -mtimeit -s'import gmpy; x=10**100000; y=gmpy.mpz(x)' 'x*x'
10 loops, best of 3: 90 msec per loop
$ python2.6 -mtimeit -s'import gmpy; x=10**100000; y=gmpy.mpz(x)' 'y*y'
100 loops, best of 3: 5.63 msec per loop
$ python2.6 -mtimeit -s'import gmpy; x=10**100000; y=gmpy.mpz(x)' 'y*x'
100 loops, best of 3: 8.4 msec per loop

    Comme vous le voyez, la multiplication de deux nombres énormes en natif code Python peut être presque 1000 fois plus lent que le simple ajout, tandis qu'avec gmpy le ralentissement est moins de 100 fois (et c'est pas trop mal, même si un seul si le numéro est déjà dans gmpy's propre format, de sorte qu'il y a les frais généraux de la conversion de l'autre).

  2. 4

    Sûr qu'il peut:

    >>> s = 10 ** 100000
  3. 3

    Il semble bien fonctionner:

    >>> x = 10**100000
>>> x
10000000000000000000000000000000000000000000000000000000000000000000000000000000
[snip]
00000000L

    Selon http://docs.python.org/library/stdtypes.html"entiers Longs ont un nombre illimité de précision", ce qui veut probablement dire que leur taille n'est pas limitée.

  4. 3

    Comme l'a déjà souligné, Python peut traiter des nombres aussi grands que votre mémoire va permettre. Je voudrais seulement ajouter que, comme les numéros de grossir, le coût de toutes les opérations sur eux augmente. Ce n'est pas seulement pour l'impression/la conversion de chaîne de caractères (bien que c'est le plus lent), l'ajout de deux grands nombres (plus que ce que votre matériel peut nativement poignée) n'est plus O(1).

    Je suis juste de mentionner ce point que, bien que Python soigneusement cache les détails de travailler avec de grands nombres, vous devez toujours garder à l'esprit que ces chiffres ne sont pas toujours identiques à celles d'ordinaire ints.