DESCRIPTION.

Créer une copie d'un objet tampon, ou d'une partie d'un objet tampon, en mémoire. 

SYNTAXE.

MRV_Copie = memoryview ( objet )

MRV_Copie = ⇨ Nom de la variable [ optionnel ]

memoryview ( ) ⇨ appel du constructeur de classe [ OBLIGATOIRE ]

objet ⇨ objet tampon valide [ OBLIGATOIRE ]

NOTES.

objet doit être un objet tampon valide pour Python.

Python gère de nombreux types d'objets_variables. Certains sont des collections de valeurs regroupées au sein d'un même objet_variable. Les vues mémoires d'objets tampons, ensembles, memoryview ( ),  sont des objets_variables composite.

Nativement, Python possède deux types d'objets tampon, les bytes ( ) et les bytearay ( ), mais il est possible d'en obtenir d'autres en important des modules, tel que array, dans le script. Les objets ainsi créer, en plus de ne pas modifier les objets copiés, permettent un traitement de leurs élément beaucoup plus rapide, surtout sur des objets contenant un très grand nombre d'éléments.

Les variables globales de type memoryview ( ) sont identifiées dans le site par : MRV_. 

Voir les conventions sur les variables utilisées dans ce site ...

CRÉER UNE VUE MEMOIRE.

Pour créer une nouvelle vue mémoire, il suffit d’appeler le constructeur de classe memoryview ( ) en lui passant la référence de l'objet tampon en paramètre.

BYT_Titre = bytes ( "Mon Python à moi." , "utf-8" )

MRV_Titre =  memoryview ( BYT_Titre )

print ( MRV_Titre ) retourne <memory at 0xb5095440>

print ( type ( MRV_Titre ) ) retourne <class 'memoryview'> 

Il est aussi possible de créer un vue mémoire pour une plage (partie) de l'objet tampon.

BYT_Titre = bytes ( "Mon Python à moi." , "utf-8" )

MRV_Langage =  memoryview ( BYT_Titre [ 4 : 10 ] )

print ( MRV_Langage ) retourne <memory at 0xb4fe6440>

print ( type ( MRV_Langage ) ) retourne <class 'memoryview'>

LECTURE D'UNE VUE MEMOIRE.

Pour connaitre les éléments d'une vue mémoire, il faut utiliser une boucle for.

MRV_Version =  memoryview ( b"Python 3." )

print ( MRV_Version ) retourne <memory at 0xb50ce440>

print ( type ( MRV_Version ) ) retourne <class 'memoryview'> 

print ( len ( MRV_Version ) ) retourne 9

for kelement in MRV_Version : print ( kelement , end = " " ) retourne 80 121 116 104 111 110 32 51 46  

Il est aussi possible de copier les élément d'une vue mémoire dans un objet tampon.

MRV_Version =  memoryview ( b"Python 3." )

BYT_Version =  bytes ( MRV_Version )

print ( BYT_Version ) retourne b'Python 3.'

print ( type ( BYT_Version ) ) retourne <class 'bytes'>

MRV_Titre =  memoryview ( bytes ( "Mon Python à moi." , "utf-8" ) )

BYT_Langage =  bytes ( MRV_Titre [ 4 : 10 ] )

print ( BYT_Langage ) retourne b'Python'

print ( type ( BYT_Langage ) ) retourne <class 'bytes'>

ATTRIBUTS DE CLASSE DES VUES MEMOIRES.

BYT_Version =  b"Python 3."

MRV_Version =  memoryview ( BYT_Version )

L'attribut memoryview.c_contiguous retourne True si les éléments de la vue mémoires sont c_contiguous.

print ( MRV_Version.c_contiguous ) retourne True

L'attribut memoryview.contiguous retourne True si les éléments de la vue mémoires sont Fortran_contiguous.

print ( MRV_Version.contiguous ) retourne True

L'attribut memoryview.f_contiguous retourne True si les éléments de la vue mémoires sont Fortran_contiguous.

print ( MRV_Version.f_contiguous ) retourne True

L'attribut memoryview.format retourne le format de structure pour les éléments de la vue mémoire.

print ( MRV_Version.format ) retourne B

L'attribut memoryview.itemsize retourne la taille en octets des éléments de la vue mémoire.

print ( MRV_Version.itemsize ) retourne 1

L'attribut memoryview.ndim retourne le nombre de dimensions du tableau d'octets de la vue mémoire.

print ( MRV_Version.ndim ) retourne 1

L'attribut memoryview.obj permet de connaitre l'objet tampon parent de la vue mémoire.

print ( MRV_Version.obj ) retourne b'Python 3.'

L'attribut memoryview.readonly retourne True si la  vue mémoire est en lecture seule, sinon False.

print ( MRV_Version.readonly ) retourne True

L'attribut memoryview.shape retourne le nombre d'éléments de chaque dimensions du tableau d'octets de la vue mémoire.

print ( MRV_Version.shape ) retourne (9,)

L'attribut memoryview.strides retourne la taille en octets d’accès des dimensions du tableau d'octets de la vue mémoire.

print ( MRV_Version.strides ) retourne (1,)

L'attribut memoryview.suboffsets retourne le détail d'implémentation dans le PIL de la vue mémoire.

print ( MRV_Version.suboffsets ) retourne ()

UTILITE DES VUES MEMOIRES.

Les vues mémoires sont particulièrement utiles pour les traitements des objets tampons contenant un très grand nombre d'éléments, par exemple, les manipulations ou opérations sur des fichiers enregistrés en mode bytes de plusieurs millions octets. Le petit script ci-après donnera une idée des gains de temps possibles pour des objets tampons de grandeurs différentes. Les résultats obtenus varient fortement en fonction du matériel et de l'environnement de l'utilisateur.

import time

for klongeur in ( 10000 , 25000 , 50000 , 75000 , 100000 , 250000  , 1000000 ) :

BYT_Test = bytes ( klongeur )

MRV_Test = memoryview ( BYT_Test )

kdepart = time.time (  ) 

while BYT_Test : BYT_Test = BYT_Test [ 1 : ]

kbyte = ( time.time (  ) - kdepart )

print ( "Durée de traitement pour un objet bytes :", kbyte )

kdepart = time.time (  )

while MRV_Test : MRV_Test = MRV_Test [ 1 : ]

kmemoryview = ( time.time (  ) - kdepart )

print ( "Durée de traitement pour un objet memoryview :", kmemoryview )

krapport =  kbyte / kmemoryview

print ( f"memoryview est environ {krapport : <-3_.2f} fois plus rapide pour { klongeur } itérations."  )

print ( )

retourne :

Durée de traitement pour un objet bytes : 0.027978897094726562

Durée de traitement pour un objet memoryview : 0.007957935333251953

memoryview est environ 3.52 fois plus rapide pour 10000 itérations.

Durée de traitement pour un objet bytes : 0.043930768966674805

Durée de traitement pour un objet memoryview : 0.0039980411529541016

memoryview est environ 10.99 fois plus rapide pour 25000 itérations.

Durée de traitement pour un objet bytes : 0.15348267555236816

Durée de traitement pour un objet memoryview : 0.012293338775634766

memoryview est environ 12.49 fois plus rapide pour 50000 itérations.

Durée de traitement pour un objet bytes : 0.32396411895751953

Durée de traitement pour un objet memoryview : 0.019992351531982422

memoryview est environ 16.20 fois plus rapide pour 75000 itérations.

Durée de traitement pour un objet bytes : 0.5431160926818848

Durée de traitement pour un objet memoryview : 0.02396368980407715

memoryview est environ 22.66 fois plus rapide pour 100000 itérations.

Durée de traitement pour un objet bytes : 3.154096841812134

Durée de traitement pour un objet memoryview : 0.06390047073364258

memoryview est environ 49.36 fois plus rapide pour 250000 itérations.

Durée de traitement pour un objet bytes : 49.69825625419617

Durée de traitement pour un objet memoryview : 0.263563871383667

memoryview est environ 188.56 fois plus rapide pour 1000000 itérations.

MÉTHODES SPÉCIFIQUES AUX OBJETS MEMORYVIEW ( ). 

hex ( ) : convertit un vue mémoire en valeurs hexadécimales.

release ( ) : autorise la modification des objets liés à la vue mémoire.

tobytes ( ) : créer un tableau d'octets correspondant à une vue mémoire.

tolist ( ) : créer une list ( ) correspondant à une vue mémoire.

toreadonly ( ) : retourne une vue mémoire non muable d'une vue mémoire.