msgpack python (Comment cela fonctionne pour les développeurs)

Introduction

MessagePackest un format de sérialisation binaire efficace qui permet l'échange de données entre plusieurs langages, similaire à JSON mais plus rapide et plus compact. LesmsgpackLa bibliothèque en Python fournit les outils nécessaires pour travailler avec ce format, offrant à la fois des liaisons CPython et une implémentation purement en Python.

Principales caractéristiques de MessagePack

1. Efficacité :MessagePackest conçu pour être plus efficace que JSON, tant en termes de vitesse que de taille. Il y parvient en utilisant un format binaire.(msgpack spec), ce qui réduit la surcharge associée aux formats basés sur le texte comme JSON.

2. Support multilingue : 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 à la fois avec Python 2 et Python 3, ainsi qu'avec les implémentations CPython et PyPy.

4. Types de données personnalisés : MessagePack permet le packaging et le déballage de types de données personnalisés avec un contrôle de déballage avancé véritable, ce qui peut être utile pour des applications complexes.

Installation

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

pip install msgpack

Utilisation de base

Voici un exemple simple de l'utilisation de 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)

Fonctionnalités avancées

1. Déballage en streaming : MessagePack prend en charge le déballage en streaming, qui extrait plusieurs objets 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
buf = BytesIO()
for i in range(100):
    buf.write(msgpack.packb(i))
buf.seek(0)
unpacker = msgpack.Unpacker(buf)
for unpacked in unpacker:
    print(unpacked)

import msgpack
from io import BytesIO
# Create a buffer
buf = BytesIO()
for i in range(100):
    buf.write(msgpack.packb(i))
buf.seek(0)
unpacker = msgpack.Unpacker(buf)
for unpacked in unpacker:
    print(unpacked)

1. Types de données personnalisés : Vous pouvez définir des fonctions personnalisées de compression et de décompression pour les types de données personnalisés. Par exemple, pour gérer le type de données personnalisé datetime :

import datetime
import msgpack
# uses default sequence type
def encode_datetime(obj): # default value
    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):
    if '__datetime__' in obj:
        return datetime.datetime.strptime(obj['as_str'], '%Y%m%dT%H:%M:%S.%f')
    return obj
data = {'time': datetime.datetime.now()}
packed_data = msgpack.packb(data, default=encode_datetime)
unpacked_data = msgpack.unpackb(packed_data, object_hook=decode_datetime)
print(unpacked_data)

import datetime
import msgpack
# uses default sequence type
def encode_datetime(obj): # default value
    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):
    if '__datetime__' in obj:
        return datetime.datetime.strptime(obj['as_str'], '%Y%m%dT%H:%M:%S.%f')
    return obj
data = {'time': datetime.datetime.now()}
packed_data = msgpack.packb(data, default=encode_datetime)
unpacked_data = msgpack.unpackb(packed_data, object_hook=decode_datetime)
print(unpacked_data)

Présentation d'IronPDF

IronPDF est une puissante bibliothèque Python conçue pour créer, modifier et signer des PDF à l'aide de HTML, CSS, images et JavaScript. Il offre des performances de niveau commercial avec une faible empreinte mémoire. Les principales caractéristiques sont les suivantes :

Conversion de HTML en PDF

Convertissez des fichiers HTML, des chaînes HTML et des URL en PDF. Par exemple, rendre une page web sous forme de PDF à l'aide du moteur de rendu PDF de Chrome.

Support multiplateforme

Compatible avec diverses plateformes .NET, notamment .NET Core, .NET Standard et .NET Framework. Il est compatible avec Windows, Linux et macOS.

Édition et signature

Définissez des propriétés, renforcez la sécurité à l'aide de mots de passe et d'autorisations, et appliquez des signatures numériques à vos PDF.

Modèles de page et paramètres

Personnalisez les PDF avec des en-têtes, des pieds de page, des numéros de page et des marges réglables. Prend en charge les mises en page réactives et les formats de papier personnalisés.

Respect des normes

Respecter les normes PDF telles que PDF/A et PDF/UA. Prend en charge le codage des caractères UTF-8 et gère les ressources telles que les images, les feuilles de style CSS et les polices.

Générez des documents PDF en utilisant IronPDF et msgpack

import msgpack
import datetime
from ironpdf import * 
# Apply your license key
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):
    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):
    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)  
renderer = ChromePdfRenderer()
# Create a PDF from a HTML string using Python
content = "<h1>Awesome Iron PDF with msgpack</h1>"
content += "<h3>Serialize data</h3>"
content += "<p>"+str(data)+"</p>"
content += "<p> msgpack.packb(data, use_bin_type=True):</p><p>"+str(packed_data)+"</p>"
content += "<h3>Deserialize data</h3>"
content += "<p> msgpack.unpackb(packed_data, raw=False):</p><p>"+str(unpacked_data)+"</p>"
content += "<h3>Encode Custom Data Types</h3>"
content += "<p>"+str(datat)+"</p>"
content += "<p>  msgpack.packb(datat, default=encode_datetime):</p><p>"+str(packed_datat)+"</p>"
pdf = renderer.RenderHtmlAsPdf(content)
    # Export to a file or Stream
pdf.SaveAs("Demo-msgpack.pdf")

import msgpack
import datetime
from ironpdf import * 
# Apply your license key
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):
    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):
    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)  
renderer = ChromePdfRenderer()
# Create a PDF from a HTML string using Python
content = "<h1>Awesome Iron PDF with msgpack</h1>"
content += "<h3>Serialize data</h3>"
content += "<p>"+str(data)+"</p>"
content += "<p> msgpack.packb(data, use_bin_type=True):</p><p>"+str(packed_data)+"</p>"
content += "<h3>Deserialize data</h3>"
content += "<p> msgpack.unpackb(packed_data, raw=False):</p><p>"+str(unpacked_data)+"</p>"
content += "<h3>Encode Custom Data Types</h3>"
content += "<p>"+str(datat)+"</p>"
content += "<p>  msgpack.packb(datat, default=encode_datetime):</p><p>"+str(packed_datat)+"</p>"
pdf = renderer.RenderHtmlAsPdf(content)
    # Export to a file or Stream
pdf.SaveAs("Demo-msgpack.pdf")

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.

Répartition

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

   • Convertit les données Python(dictionnaire dans ce cas)en format binaire(packed_data)using msgpack.packb()avec use_bin_type=True.

2. Désérialisation des données avec msgpack :

   • Convertit le binary packed_data en données Python(données_décompressées)using msgpack.unpackb()avec raw=False.

3. Gestion des types de données personnalisés :

   • Définit un encodage personnalisé(encode_datetime)et décodage(decode_datetime)fonctions 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(contenu) qui comprend

     • En-tête et sous-sections détaillant les données sérialisées(données et données_emballées).

     • Données désérialisées(données_déballées).
     • Sérialisation des types de données personnalisés(datat et packed_datat).

5. Génération de PDF avec IronPDF:

   • Utilise IronPDF(ChromePdfRenderer)générer un document PDF(pdf)du contenu HTML construit(contenu).

6. Enregistrement du PDF :

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

Sortie

PDF (EN ANGLAIS)

Licence d'IronPDF

IronPDF fonctionne avec la clé de licence pour Python. IronPDF python offre unessai gratuit afin de permettre aux utilisateurs de vérifier ses nombreuses fonctionnalités avant de l'acheter.

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

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

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

Conclusion

MessagePack est un outil puissant pour la sérialisation efficace des données en Python. Son format binaire compact, sa prise en charge multilingue et sa capacité à gérer des 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.

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