Où sont python bytearrays utilisé?

Cette réponse a été sans vergogne arraché de ici

Exemple 1: Assemblage d'un message à partir de fragments

Supposons que vous êtes l'écriture de code de réseau qui reçoit un message de grande taille sur une connexion de socket. Si vous savez au sujet de douilles, vous savez que le recv() opération n'attendez pas que toutes les données arrivent. Au lieu de cela, il se contente de ce qui est actuellement disponible dans les tampons du système. Par conséquent, pour obtenir toutes les données, vous pouvez écrire du code qui ressemble à ceci:

# remaining = number of bytes being received (determined already)
msg = b""
while remaining > 0:
    chunk = s.recv(remaining)    # Get available data
    msg += chunk                 # Add it to the message
    remaining -= len(chunk)  

Le seul problème avec ce code, c'est que la concaténation (+=) a des performances horribles. Par conséquent, une commune de l'optimisation de la performance en Python 2 est de rassembler tous les morceaux dans une liste et effectuer une jointure lorsque vous avez terminé. Comme ceci:

# remaining = number of bytes being received (determined already)
msgparts = []
while remaining > 0:
    chunk = s.recv(remaining)    # Get available data
    msgparts.append(chunk)       # Add it to list of chunks
    remaining -= len(chunk)  
msg = b"".join(msgparts)          # Make the final message

Maintenant, voici une troisième solution à l'aide d'un bytearray:

# remaining = number of bytes being received (determined already)
msg = bytearray()
while remaining > 0:
    chunk = s.recv(remaining)    # Get available data
    msg.extend(chunk)            # Add to message
    remaining -= len(chunk)  

Remarquez comment le bytearray version est vraiment très propre. Vous n'avez pas de collecter des pièces dans une liste et vous n'effectuez pas que cryptic rejoindre à la fin. Nice.

Bien sûr, la grande question est de savoir si ou non il effectue. Pour un test, j'ai d'abord fait une liste de petites octet fragments comme ceci:

chunks = [b"x"*16]*512

J'ai ensuite utilisé le module timeit de comparer les deux fragments de code:

# Version 1
msgparts = []
for chunk in chunks:
    msgparts.append(chunk)
msg = b"".join(msgparts)

#Version 2
msg = bytearray()
for chunk in chunks:
    msg.extend(chunk)

Lors de l'essai, la version 1 du code couru dans 99.8 s alors que la version 2 a couru dans 116.6 s (une version à l'aide de += concaténation prend 230.3 s par comparaison). Ainsi, alors que l'exécution d'une opération de jointure est encore plus rapide, il est seulement plus rapide d'environ 16%. Personnellement, je pense que le nettoyeur de la programmation de la bytearray version peut faire pour elle.

Exemple 2: Binaire d'enregistrement d'emballage

Cet exemple est une légère torsion sur le dernier exemple. Supposons que vous avez eu un grand Python liste d'entiers (x,y) les coordonnées. Quelque chose comme ceci:
points = [(1,2),(3,4),(9,10),(23,14),(50,90),...]
Maintenant, supposons que vous avez besoin d'écrire des données binaires codées fichier constitué d'un entier de 32 bits longueur suivie par chaque point emballés dans une paire de nombres entiers de 32 bits. Une façon de le faire serait d'utiliser la structure de module comme ceci:

import struct
f = open("points.bin","wb")
f.write(struct.pack("I",len(points)))
for x,y in points:
    f.write(struct.pack("II",x,y))
f.close()

Le seul problème avec ce code, c'est qu'il effectue un grand nombre de petits write() opérations. Une approche alternative consiste à emballer le tout dans un bytearray et uniquement effectuer une opération d'écriture à la fin. Par exemple:

import struct
f = open("points.bin","wb")
msg = bytearray()
msg.extend(struct.pack("I",len(points))
for x,y in points:
    msg.extend(struct.pack("II",x,y))
f.write(msg)
f.close()

Bien sûr, la version qui utilise bytearray s'exécute beaucoup plus rapidement. Dans un simple test de chronométrage impliquant une liste de 100000 points, il fonctionne dans environ la moitié du temps que la version qui fait beaucoup de petites écrit.

Exemple 3: traitement Mathématique des valeurs d'octets

Le fait que bytearrays se présenter sous la forme de tableaux d'entiers rend plus facile l'exécution de certains types de calculs. Dans un récent des systèmes embarqués de projet, j'ai été à l'aide de Python pour communiquer avec un périphérique sur un port série. Dans le cadre du protocole de communication, tous les messages ont dû être signé avec un contrôle de Redondance Longitudinale (LRC) de l'octet. Un LRC est calculé en prenant un XOR sur toutes les valeurs d'octets.
Bytearrays faire de tels calculs facile. Voici une version:

message = bytearray(...)     # Message already created
lrc = 0
for b in message:
    lrc ^= b
message.append(lrc)          # Add to the end of the message

Voici une version qui augmente votre sécurité d'emploi:
message.append(functools.reduce(lambda x,y:x^y,message))
Et voici le même calcul en Python 2 sans bytearrays:

message = "..."       # Message already created
lrc = 0
for b in message:
    lrc ^= ord(b)
message += chr(lrc)        # Add the LRC byte

Personnellement, j'aime le bytearray version. Il n'y a pas besoin d'utiliser ord() et vous pouvez simplement ajouter le résultat à la fin du message au lieu d'utiliser la concaténation.

Voici un autre mignon exemple. Supposons que vous vouliez exécuter un bytearray par le biais d'un simple XOR-de chiffrement. Voici un one-liner pour le faire:

>>> key = 37
>>> message = bytearray(b"Hello World")
>>> s = bytearray(x ^ key for x in message)
>>> s
bytearray(b'm@IIJ\x05rJWIA')
>>> bytearray(x ^ key for x in s)
bytearray(b"Hello World")
>>> 

Ici est un lien vers la présentation

Wikipedia fournit un exemple de Chiffrement XOR à l'aide de Python bytearrays (docstrings réduit):

#!/usr/bin/python2.7

from os import urandom

def vernam_genkey(length):
    """Generating a key"""
    return bytearray(urandom(length))

def vernam_encrypt(plaintext, key):
    """Encrypting the message."""
    return bytearray([ord(plaintext[i]) ^ key[i] for i in xrange(len(plaintext))])

def vernam_decrypt(ciphertext, key):
    """Decrypting the message"""
    return bytearray([ciphertext[i] ^ key[i] for i in xrange(len(ciphertext))])

def main():
    myMessage = """This is a topsecret message..."""
    print 'message:',myMessage
    key = vernam_genkey(len(myMessage))
    print 'key:', str(key)
    cipherText = vernam_encrypt(myMessage, key)
    print 'cipherText:', str(cipherText)
    print 'decrypted:', vernam_decrypt(cipherText,key)

    if vernam_decrypt(vernam_encrypt(myMessage, key),key)==myMessage:
        print ('Unit Test Passed')
    else:
        print('Unit Test Failed - Check Your Python Distribution')

if __name__ == '__main__':
    main()