Pourquoi est-str.traduire beaucoup plus rapide en Python de 3,5 par rapport à Python 3.4?

J'ai essayé de supprimer les caractères d'une chaîne à l'aide de text.translate() en Python 3.4.

Le code minimal est:

import sys 
s = 'abcde12345@#@$#%$'
mapper = dict.fromkeys(i for i in range(sys.maxunicode) if chr(i) in '@#$')
print(s.translate(mapper))

Qu'il fonctionne comme prévu. Cependant, le même programme lors de l'exécution en Python Python 3.4 et 3.5 donne une grande différence.

Le code pour calculer les temps est

python3 -m timeit -s "import sys;s = 'abcde12345@#@$#%$'*1000 ; mapper = dict.fromkeys(i for i in range(sys.maxunicode) if chr(i) in '@#$'); "   "s.translate(mapper)"

Le Python 3.4 programme prend 1.3 ms alors que le même programme en Python 3.5 prend seulement 26.4 µs.

Ce qui a amélioré en Python 3.5 qui le rend plus rapide par rapport à Python 3.4?

  • Tandis que nous parlons de la performance, ne serait-il pas préférable de générer votre mapper comme ceci: dict.fromkeys(ord(c) for c in '@#$')?
  • J'ai trouvé que cela fait une différence importante. Yep votre chemin, c'est mieux.
  • Vouliez-vous dire 50x plus rapide?
  • Je n'ai 1300 - 26.4 et ensuite divisé en 1300. J'ai obtenu près de 95%, donc j'ai écrit 🙂 C'est effectivement plus de 50x plus rapide... Mais c'est mon calcul de mal? Je suis peu faible en mathématiques. Je vais apprendre les mathématiques bientôt. 🙂
  • vous devriez en faire le tour: 26 / 1300 = 2% de plus pour la version plus rapide ne prend que 2% du temps pris par la version la plus lente => c'est 50x plus rapide.
InformationsquelleAutor Bhargav Rao | 2015-12-15
  1. 150

    TL;DR - QUESTION 21118

    La longue Histoire

    Josh Rosenberg a découvert que le str.translate() fonction est très lent par rapport à la bytes.translate, il a soulevé un question, en déclarant que:

    En Python 3, str.translate() est généralement un rendement pessimization, pas d'optimisation.

    Pourquoi str.translate() lent?

    La raison principale pour str.translate() très lent a été que la recherche dans un dictionnaire Python.

    L'utilisation de maketrans fait de ce problème pour le pire. La même approche à l'aide de octets construit un C tableau de 256 éléments de rapide de la table de recherche. Donc l'utilisation de plus haut niveau Python dict rend le str.translate() en Python 3.4 très lent.

    Ce qui s'est passé maintenant?

    La première approche a été d'ajouter un petit patch, translate_writer, Cependant, l'augmentation de la vitesse n'était pas agréable. Bientôt un autre patch fast_translate a été testé et il a donné de très bons résultats jusqu'à 55% plus rapide.

    Le principal changement que peut être vu à partir du fichier, c'est que le Python recherche dans le dictionnaire est changé en un C niveau de la recherche.

    Les vitesses de maintenant sont presque les mêmes que bytes

                                    unpatched           patched

str.translate                   4.55125927699919    0.7898181750006188
str.translate from bytes trans  1.8910855210015143  0.779950579000797

    Une petite note ici, c'est que l'amélioration de la performance est seulement important dans les chaînes ASCII.

    Comme J. F. Sebastian mentionne dans un commentaire ci-dessous, Avant de 3.5, traduire l'habitude de travailler de la même façon pour les deux ASCII et non-ASCII cas. Cependant, à partir de 3,5 ASCII cas est beaucoup plus rapide.

    Plus tôt ASCII vs non-ascii utilisé pour être presque la même, mais maintenant, nous pouvons voir un grand changement dans la performance.

    Il peut être une amélioration de 71.6 µs à 2,33 µs, comme on le voit dans cette réponse.

    Le code suivant illustre cette 

    python3.5 -m timeit -s "text = 'mJssissippi'*100; d=dict(J='i')" "text.translate(d)"
100000 loops, best of 3: 2.3 usec per loop
python3.5 -m timeit -s "text = 'm\U0001F602ssissippi'*100; d={'\U0001F602': 'i'}" "text.translate(d)"
10000 loops, best of 3: 117 usec per loop

python3 -m timeit -s "text = 'm\U0001F602ssissippi'*100; d={'\U0001F602': 'i'}" "text.translate(d)"
10000 loops, best of 3: 91.2 usec per loop
python3 -m timeit -s "text = 'mJssissippi'*100; d=dict(J='i')" "text.translate(d)"
10000 loops, best of 3: 101 usec per loop

    Dépouillement des résultats:

             Python 3.4    Python 3.5  
Ascii     91.2          2.3 
Unicode   101           117
    • C'est l'un des commits: github.com/python/cpython/commit/...
    • remarque: ascii vs non-ascii cas peuvent différer de manière significative dans les performances. Il n'est pas sur 55%: comme votre réponse montre, la vitesse peut être 1000s%.
    • comparer: python3.5 -m timeit -s "text = 'mJssissippi'*100; d=dict(J='i')" "text.translate(d)" (ascii) vs python3.5 -m timeit -s "text = 'm\U0001F602ssissippi'*100; d={'\U0001F602': 'i'}" "text.translate(d)" (non ascii). Le dernier est beaucoup (10x) plus lent.
    • Oh, je l'ai compris maintenant. J'ai couru votre code pour les 3.4 et 3.5. Je suis Py3.4 plus rapide pour les non-ascii choses. Est-ce par hasard? Les résultats de dpaste.com/15FKSDQ
    • Avant de 3.5, ascii et non-ascii cas sont probablement la même pour les caractères Unicode .translate() c'est à dire, ascii cas est beaucoup plus rapide en Python 3.5 seul (vous n'avez pas besoin bytes.translate() pour les performances).
    • Je ne veux pas laisser entendre que bytes.translate() est adapté pour un non-ascii cas, par exemple, '\U0001F602' est un multi-séquence d'octets (dans la plupart des encodages) et, par conséquent, vous ne pouvez pas la carte à l'aide de bytes.translate() (ce n'est pas la seule raison mais c'est suffisant). Remarque: le premier cas c'est de l'ascii uniquement.
    • À mon oreille 1000% d'amélioration suggère le code n'est pas seulement 9 fois plus rapide, mais en fait s'exécute en arrière dans le temps et se termine avant que ça commence 😛 je plaisante, bien sûr, mais je ne le vois que peu claire de ce que 1000% d'amélioration des moyens. Si vous trouvez vous-même de faire une autre édition de toute façon, je vous recommande la modification de ce texte. (Les résultats du réglage que vous avez posté sont ce que je voudrais examiner d'un peu près 90% d'amélioration: la version améliorée prend (100%-90%)=10% tant que l'original.)
    • Je suis vraiment confus avec les calculs! 😛 Pouvez-vous svp me dire le pourcentage.. à Partir de 91.2 à 2.3? (Je suis mauvais en maths 🙁 )
    • ah, c'est sûr. Pour la variation en pourcentage, toujours diviser par le original valeur, pas le nouveau. Dans ce cas, (91.2 - 2.3) / 91.2 x 100% = 97.5% d'amélioration.
    • Merci beaucoup. J'ai été en divisant par la valeur faux (le dernier). o merveille, je suis à 3000% d'amélioration quand les devs revendiquée 55%.... Merci encore. 🙂
    • 97.5% n'est pas lisible par l'homme -- il y a plusieurs formules possibles. 1000s% est de mon commentaire ci-dessus (Python 3.5 est la base de 100%). Le but est de communiquer les l'ordre de grandeur (des dizaines de fois, des milliers de pourcents à la différence de cinquante pour cent qui étaient dans la réponse avant, sinon je n'aurais pas utilisé les pourcentages à tous ici). Le point est unicode .translate() était le chien de ralentir dans les deux cas, avant de Python 3.5. Aussi, 97.5% promet beaucoup trop (contrairement à 1000%) -- le benchmarking est une tâche complexe pour obtenir le droit si nous arrêter de parler de l'ordre de grandeur des nombres.
    • Je crois que dans votre dernière ligne. Je pense que la chose importante est d'obtenir le point principal que .translate() a été améliorée. J'ai pour le moment supprimé les comparaisons. Merci beaucoup.

    InformationsquelleAutor Bhargav Rao