Passer au contenu du pied de page
AIDE PYTHON

msgpack python (Comment ça marche pour les développeurs)

MessagePack est un format de sérialisation binaire efficace qui permet l'échange de données entre plusieurs langues. Il est similaire à JSON mais plus rapide et plus compact. La bibliothèque msgpack en Python offre les outils nécessaires pour travailler avec ce format, offrant à la fois des liaisons CPython et une implémentation en Python pur.

Principales caractéristiques de MessagePack

  1. Efficacité : MessagePack est conçu pour être plus efficace que JSON, à la fois en termes de vitesse et de taille. Il y parvient en utilisant un format binaire (spécification msgpack), ce qui réduit les frais généraux associés aux formats basés sur le texte comme JSON.
  2. Support multi-langage : MessagePack prend en charge plusieurs langages de programmation, ce qui le rend idéal pour les applications où les données doivent être partagées entre différents systèmes et langages.
  3. Compatibilité : La bibliothèque msgpack en Python est compatible avec Python 2 et Python 3, ainsi que les implémentations CPython et PyPy.
  4. Types de données personnalisés : MessagePack permet l'emballage et le déballage de types de données personnalisés avec un contrôle de déballage avancé, ce qui peut être utile pour des applications complexes.

Installation

Avant de pouvoir commencer à lire et écrire des données MessagePack, vous devez installer la bibliothèque msgpack, ce qui peut être fait en utilisant pip :

pip install msgpack
pip install msgpack
SHELL

Utilisation de base

Voici un exemple simple de comment utiliser MessagePack pour sérialiser et désérialiser des données :

import msgpack

# Serialize key-value pairs or file-like object
data = {'key': 'value', 'number': 42}
packed_data = msgpack.packb(data, use_bin_type=True)

# Deserialize data
unpacked_data = msgpack.unpackb(packed_data, raw=False)
print(unpacked_data)
import msgpack

# Serialize key-value pairs or file-like object
data = {'key': 'value', 'number': 42}
packed_data = msgpack.packb(data, use_bin_type=True)

# Deserialize data
unpacked_data = msgpack.unpackb(packed_data, raw=False)
print(unpacked_data)
PYTHON

Les fonctionnalités avancées

  1. Déballage en streaming : MessagePack prend en charge le déballage en streaming, qui déballe plusieurs objets à partir d'un seul flux. Ceci est utile pour traiter de grands ensembles de données ou des flux de données continus.
import msgpack
from io import BytesIO

# Create a buffer for streaming data
buf = BytesIO()
for i in range(100):
    buf.write(msgpack.packb(i))
buf.seek(0)

# Unpack data from the buffer
unpacker = msgpack.Unpacker(buf)
for unpacked in unpacker:
    print(unpacked)
import msgpack
from io import BytesIO

# Create a buffer for streaming data
buf = BytesIO()
for i in range(100):
    buf.write(msgpack.packb(i))
buf.seek(0)

# Unpack data from the buffer
unpacker = msgpack.Unpacker(buf)
for unpacked in unpacker:
    print(unpacked)
PYTHON
  1. Types de données personnalisés : Vous pouvez définir des fonctions d'emballage et de déballage personnalisées pour les types de données personnalisés. Par exemple, pour gérer le type de données personnalisé datetime :
import datetime
import msgpack

def encode_datetime(obj):
    """Encode datetime objects for MessagePack serialization."""
    if isinstance(obj, datetime.datetime):
        return {'__datetime__': True, 'as_str': obj.strftime('%Y%m%dT%H:%M:%S.%f')}
    return obj

def decode_datetime(obj):
    """Decode datetime objects after MessagePack deserialization."""
    if '__datetime__' in obj:
        return datetime.datetime.strptime(obj['as_str'], '%Y%m%dT%H:%M:%S.%f')
    return obj

# Serialize data with custom datetime support
data = {'time': datetime.datetime.now()}
packed_data = msgpack.packb(data, default=encode_datetime)

# Deserialize data with custom datetime support
unpacked_data = msgpack.unpackb(packed_data, object_hook=decode_datetime)
print(unpacked_data)
import datetime
import msgpack

def encode_datetime(obj):
    """Encode datetime objects for MessagePack serialization."""
    if isinstance(obj, datetime.datetime):
        return {'__datetime__': True, 'as_str': obj.strftime('%Y%m%dT%H:%M:%S.%f')}
    return obj

def decode_datetime(obj):
    """Decode datetime objects after MessagePack deserialization."""
    if '__datetime__' in obj:
        return datetime.datetime.strptime(obj['as_str'], '%Y%m%dT%H:%M:%S.%f')
    return obj

# Serialize data with custom datetime support
data = {'time': datetime.datetime.now()}
packed_data = msgpack.packb(data, default=encode_datetime)

# Deserialize data with custom datetime support
unpacked_data = msgpack.unpackb(packed_data, object_hook=decode_datetime)
print(unpacked_data)
PYTHON

Présentation d'IronPDF

msgpack python (Comment ça fonctionne pour les développeurs) : Figure 1

IronPDF est une bibliothèque Python puissante conçue pour créer, éditer, et signer des PDFs en utilisant HTML, CSS, des images, et JavaScript. Elle offre des performances de qualité commerciale avec une empreinte mémoire faible. Les fonctionnalités clés incluent :

Conversion HTML en PDF

Convertissez des fichiers HTML, des chaînes HTML et des URLs en PDFs. Par exemple, vous pouvez rendre une page web en PDF en utilisant le moteur de rendu Chrome PDF.

Support multi-plateforme

Compatible avec diverses plateformes .NET, y compris .NET Core, .NET Standard et .NET Framework. Il prend en charge Windows, Linux et macOS.

Édition et signature

Définissez des propriétés, ajoutez de la sécurité avec des mots de passe et des permissions, et appliquez des signatures numériques à vos PDFs.

Templates de page et réglages

Personnalisez les PDFs avec des en-têtes, des pieds de page, des numéros de page et des marges ajustables. Prend en charge les mises en page adaptatives et les formats de papier personnalisés.

Conformité aux normes

Respecte les normes PDF telles que PDF/A et PDF/UA. Prend en charge l'encodage de caractères UTF-8 et gère les ressources comme les images, CSS et polices.

Générez des documents PDF à l'aide de IronPDF et msgpack

import msgpack
import datetime
from ironpdf import * 

# Apply your license key for IronPDF
License.LicenseKey = "key"

# Serialize data
data = {'key': 'value', 'number': 42}
packed_data = msgpack.packb(data, use_bin_type=True)

# Deserialize data
unpacked_data = msgpack.unpackb(packed_data, raw=False)
print(unpacked_data)

# Custom Data Types
def encode_datetime(obj):
    """Encode datetime objects for MessagePack serialization."""
    if isinstance(obj, datetime.datetime):
        return {'__datetime__': True, 'as_str': obj.strftime('%Y%m%dT%H:%M:%S.%f')}
    return obj

def decode_datetime(obj):
    """Decode datetime objects after MessagePack deserialization."""
    if '__datetime__' in obj:
        return datetime.datetime.strptime(obj['as_str'], '%Y%m%dT%H:%M:%S.%f')
    return obj

datat = {'time': datetime.datetime.now()}
packed_datat = msgpack.packb(datat, default=encode_datetime)
unpacked_datat = msgpack.unpackb(packed_datat, object_hook=decode_datetime)
print(unpacked_datat)  

# Render a PDF from a HTML string using Python
renderer = ChromePdfRenderer()
content = "<h1>Awesome Iron PDF with msgpack</h1>"
content += "<h3>Serialize data</h3>"
content += f"<p>{data}</p>"
content += f"<p> msgpack.packb(data, use_bin_type=True):</p><p>{packed_data}</p>"
content += "<h3>Deserialize data</h3>"
content += f"<p> msgpack.unpackb(packed_data, raw=False):</p><p>{unpacked_data}</p>"
content += "<h3>Encode Custom Data Types</h3>"
content += f"<p>{datat}</p>"
content += f"<p> msgpack.packb(datat, default=encode_datetime):</p><p>{packed_datat}</p>"

pdf = renderer.RenderHtmlAsPdf(content)
pdf.SaveAs("Demo-msgpack.pdf")  # Export to a file
import msgpack
import datetime
from ironpdf import * 

# Apply your license key for IronPDF
License.LicenseKey = "key"

# Serialize data
data = {'key': 'value', 'number': 42}
packed_data = msgpack.packb(data, use_bin_type=True)

# Deserialize data
unpacked_data = msgpack.unpackb(packed_data, raw=False)
print(unpacked_data)

# Custom Data Types
def encode_datetime(obj):
    """Encode datetime objects for MessagePack serialization."""
    if isinstance(obj, datetime.datetime):
        return {'__datetime__': True, 'as_str': obj.strftime('%Y%m%dT%H:%M:%S.%f')}
    return obj

def decode_datetime(obj):
    """Decode datetime objects after MessagePack deserialization."""
    if '__datetime__' in obj:
        return datetime.datetime.strptime(obj['as_str'], '%Y%m%dT%H:%M:%S.%f')
    return obj

datat = {'time': datetime.datetime.now()}
packed_datat = msgpack.packb(datat, default=encode_datetime)
unpacked_datat = msgpack.unpackb(packed_datat, object_hook=decode_datetime)
print(unpacked_datat)  

# Render a PDF from a HTML string using Python
renderer = ChromePdfRenderer()
content = "<h1>Awesome Iron PDF with msgpack</h1>"
content += "<h3>Serialize data</h3>"
content += f"<p>{data}</p>"
content += f"<p> msgpack.packb(data, use_bin_type=True):</p><p>{packed_data}</p>"
content += "<h3>Deserialize data</h3>"
content += f"<p> msgpack.unpackb(packed_data, raw=False):</p><p>{unpacked_data}</p>"
content += "<h3>Encode Custom Data Types</h3>"
content += f"<p>{datat}</p>"
content += f"<p> msgpack.packb(datat, default=encode_datetime):</p><p>{packed_datat}</p>"

pdf = renderer.RenderHtmlAsPdf(content)
pdf.SaveAs("Demo-msgpack.pdf")  # Export to a file
PYTHON

Explication du code

Ce script démontre l'intégration de msgpack avec IronPDF pour la sérialisation et la désérialisation des données, ainsi que la création d'un document PDF à partir de contenu HTML.

Décomposition

  1. Sérialisation des données avec msgpack :

    • Convertit les données Python (dict dans ce cas) en un format binaire (packed_data) en utilisant msgpack.packb() avec use_bin_type=True.
  2. Désérialisation des données avec msgpack :

    • Convertit les packed_data binaires en données Python (unpacked_data) en utilisant msgpack.unpackb() avec raw=False.
  3. Gestion des types de données personnalisés :

    • Définit des fonctions d'encodage (encode_datetime) et de décodage (decode_datetime) personnalisées pour gérer les objets datetime lors de la sérialisation et de la désérialisation en utilisant msgpack.
  4. Contenu HTML pour la génération de PDF :

    • Construit une chaîne HTML (content) qui inclut :
      • En-tête et sous-sections détaillant les données sérialisées (data et packed_data).
      • Données désérialisées (unpacked_data).
      • Sérialisation des types de données personnalisés (datat et packed_datat).
  5. Génération PDF avec IronPDF :

    • Utilise IronPDF (ChromePdfRenderer) pour générer un document PDF (pdf) à partir du contenu HTML construit (content).
  6. Enregistrement du PDF :

    • Enregistre le document PDF généré sous le nom "Demo-msgpack.pdf".

Sortie

msgpack python (Comment ça fonctionne pour les développeurs) : Figure 2

PDF

msgpack python (Comment ça fonctionne pour les développeurs) : Figure 3

Licence IronPDF

IronPDF fonctionne sur la clé de licence pour Python. IronPDF pour Python offre une clé de licence d’essai gratuite pour permettre aux utilisateurs de découvrir ses fonctionnalités étendues avant l'achat.

Placez la clé de licence au début du script avant d'utiliser le package IronPDF :

from ironpdf import * 
# Apply your license key
License.LicenseKey = "key"
from ironpdf import * 
# Apply your license key
License.LicenseKey = "key"
PYTHON

Conclusion

MessagePack est un outil puissant pour la sérialisation efficace des données en Python. Son format binaire compact, son support multi-langage et sa capacité à gérer les types de données personnalisés en font un choix polyvalent pour diverses applications. Que vous travailliez sur l'échange de données entre différents systèmes ou sur l'optimisation des performances de vos tâches de traitement de données, MessagePack offre une solution robuste.

IronPDF est une bibliothèque Python polyvalente conçue pour créer, manipuler et rendre des documents PDF directement depuis des applications Python. Il simplifie les tâches telles que la conversion d'HTML en PDF, la création de formulaires PDF interactifs, et l'exécution de diverses manipulations de documents comme la fusion et la division de fichiers PDF. Avec une intégration transparente dans les technologies web existantes, IronPDF offre aux développeurs un ensemble d'outils puissants pour générer des PDF dynamiques, améliorant la productivité dans les tâches de gestion et de présentation de documents.

Curtis Chau
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite