Comment signer des fichiers PDF en Python

Découvrez comment générer des certificats auto-signés et les signer dans des fichiers PDF en tant que signatures numériques à l'aide des bibliothèques PyOpenSSL et PDFNetPython3 en Python.
Une signature numérique ajoutée à un document PDF équivaut à une signature à l'encre sur un document papier, mais la première est beaucoup plus sécurisée. 

Une signature numérique garantit l'intégrité d'un document PDF et certifie que ce document n'a pas été modifié par une personne inconnue. Il peut remplacer votre signature manuscrite pour accélérer pratiquement n'importe quel processus de signature manuelle sur papier et pour accélérer les flux de travail.

Dans ce tutoriel, vous apprendrez :

  • Comment générer un certificat auto-signé en Python.
  • Comment ajouter une signature numérique à un document PDF en Python.

Les composants suivants sont requis :

  • PDFNetPython3 : est un wrapper pour PDFTron SDK . Avec les composants PDFTron, vous pouvez créer des applications fiables et rapides capables d'afficher, de créer, d'imprimer, de modifier et d'annoter des PDF sur différents systèmes d'exploitation. Les développeurs utilisent PDFTron SDK pour lire, écrire et modifier des documents PDF compatibles avec toutes les versions publiées des spécifications PDF (y compris la dernière norme ISO32000 ). PDFTron n'est pas un freeware, il propose 2 types de licences selon que vous développez un produit externe/commercial ou une solution maison. Pour les besoins de ce didacticiel, nous utiliserons la version d'essai gratuite de ce SDK.
  • pyOpenSSL : Un wrapper Python autour de la bibliothèque OpenSSL. OpenSSL est une bibliothèque de sécurité populaire utilisée par de nombreux produits, applications et fournisseurs. 

Le but de ce tutoriel est de développer un utilitaire léger basé sur la ligne de commande, via des modules basés sur Python afin de signer numériquement un ou une collection de fichiers PDF situés sous un chemin spécifique.

Pour commencer, installons les bibliothèques :

$ pip install PDFNetPython3==8.1.0 pyOpenSSL==20.0.1

Au final, notre structure de dossiers ressemblera à ceci :

Structure du projet

Le signature.jpgfichier représente un spécimen de signature :

Le "Letter of confirmation.pdf"fichier représente un exemple de fichier PDF à signer.

Commençons, ouvrez un nouveau fichier Python et nommez-le sign_pdf.pyou peu importe :

# Import Libraries
import OpenSSL
import os
import time
import argparse
from PDFNetPython3.PDFNetPython import *
from typing import Tuple


def createKeyPair(type, bits):
    """
    Create a public/private key pair
    Arguments: Type - Key Type, must be one of TYPE_RSA and TYPE_DSA
               bits - Number of bits to use in the key (1024 or 2048 or 4096)
    Returns: The public/private key pair in a PKey object
    """
    pkey = OpenSSL.crypto.PKey()
    pkey.generate_key(type, bits)
    return pkey

La fonction ci-dessus crée une paire de clés publique/privée à utiliser lors de la génération du certificat auto-signé afin d'effectuer un chiffrement asymétrique.

Ensuite, créez une fonction pour créer un certificat auto-signé :

def create_self_signed_cert(pKey):
    """Create a self signed certificate. This certificate will not require to be signed by a Certificate Authority."""
    # Create a self signed certificate
    cert = OpenSSL.crypto.X509()
    # Common Name (e.g. server FQDN or Your Name)
    cert.get_subject().CN = "BASSEM MARJI"
    # Serial Number
    cert.set_serial_number(int(time.time() * 10))
    # Not Before
    cert.gmtime_adj_notBefore(0)  # Not before
    # Not After (Expire after 10 years)
    cert.gmtime_adj_notAfter(10 * 365 * 24 * 60 * 60)
    # Identify issue
    cert.set_issuer((cert.get_subject()))
    cert.set_pubkey(pKey)
    cert.sign(pKey, 'md5')  # or cert.sign(pKey, 'sha256')
    return cert

Cette fonction crée un certificat auto-signé qui ne nécessite pas d'être signé par une autorité de certification.

Cette fonction attribuera les attributs suivants au certificat :

  • Nom commun : BASSEM MARJI.
  • Numéro de série : un nombre aléatoire en fonction de la fonction horaire.
  • Pas après : Expiration après 10 ans.

Créons maintenant une fonction qui utilise les deux fonctions pour générer un certificat :

def load():
    """Generate the certificate"""
    summary = {}
    summary['OpenSSL Version'] = OpenSSL.__version__
    # Generating a Private Key...
    key = createKeyPair(OpenSSL.crypto.TYPE_RSA, 1024)
    # PEM encoded
    with open('.\static\private_key.pem', 'wb') as pk:
        pk_str = OpenSSL.crypto.dump_privatekey(OpenSSL.crypto.FILETYPE_PEM, key)
        pk.write(pk_str)
        summary['Private Key'] = pk_str
    # Done - Generating a private key...
    # Generating a self-signed client certification...
    cert = create_self_signed_cert(pKey=key)
    with open('.\static\certificate.cer', 'wb') as cer:
        cer_str = OpenSSL.crypto.dump_certificate(
            OpenSSL.crypto.FILETYPE_PEM, cert)
        cer.write(cer_str)
        summary['Self Signed Certificate'] = cer_str
    # Done - Generating a self-signed client certification...
    # Generating the public key...
    with open('.\static\public_key.pem', 'wb') as pub_key:
        pub_key_str = OpenSSL.crypto.dump_publickey(
            OpenSSL.crypto.FILETYPE_PEM, cert.get_pubkey())
        #print("Public key = ",pub_key_str)
        pub_key.write(pub_key_str)
        summary['Public Key'] = pub_key_str
    # Done - Generating the public key...
    # Take a private key and a certificate and combine them into a PKCS12 file.
    # Generating a container file of the private key and the certificate...
    p12 = OpenSSL.crypto.PKCS12()
    p12.set_privatekey(key)
    p12.set_certificate(cert)
    open('.\static\container.pfx', 'wb').write(p12.export())
    # You may convert a PKSC12 file (.pfx) to a PEM format
    # Done - Generating a container file of the private key and the certificate...
    # To Display A Summary
    print("## Initialization Summary ##################################################")
    print("\n".join("{}:{}".format(i, j) for i, j in summary.items()))
    print("############################################################################")
    return True

Cette fonction effectue les opérations suivantes :

  • Crée une paire de clés publique/privée.
  • Stocke la clé privée dans le fichier "private_key.pem"sous le staticdossier.
  • Génère un certificat auto-signé et l'enregistre dans le fichier "certificate.cer"sous le staticdossier.
  • Enregistre la clé publique dans le fichier "public_key.pem"sous le staticdossier.
  • Produit un fichier conteneur "container.pfx"combinant la clé privée et le certificat et le place sous le staticdossier.

Notez que la clé privée ne doit pas être imprimée dans la console. Cependant, il est inclus dans le dictionnaire récapitulatif (qui sera imprimé) à des fins de démonstration, assurez-vous de supprimer la clé privée de la sortie de la console si vous êtes sérieux à ce sujet.

Maintenant que nous avons la fonction principale pour générer un certificat, créons une fonction pour signer un fichier PDF :

def sign_file(input_file: str, signatureID: str, x_coordinate: int, 
            y_coordinate: int, pages: Tuple = None, output_file: str = None
              ):
    """Sign a PDF file"""
    # An output file is automatically generated with the word signed added at its end
    if not output_file:
        output_file = (os.path.splitext(input_file)[0]) + "_signed.pdf"
    # Initialize the library
    PDFNet.Initialize()
    doc = PDFDoc(input_file)
    # Create a signature field
    sigField = SignatureWidget.Create(doc, Rect(
        x_coordinate, y_coordinate, x_coordinate+100, y_coordinate+50), signatureID)
    # Iterate throughout document pages
    for page in range(1, (doc.GetPageCount() + 1)):
        # If required for specific pages
        if pages:
            if str(page) not in pages:
                continue
        pg = doc.GetPage(page)
        # Create a signature text field and push it on the page
        pg.AnnotPushBack(sigField)
    # Signature image
    sign_filename = os.path.dirname(
        os.path.abspath(__file__)) + "\static\signature.jpg"
    # Self signed certificate
    pk_filename = os.path.dirname(
        os.path.abspath(__file__)) + "\static\container.pfx"
    # Retrieve the signature field.
    approval_field = doc.GetField(signatureID)
    approval_signature_digsig_field = DigitalSignatureField(approval_field)
    # Add appearance to the signature field.
    img = Image.Create(doc.GetSDFDoc(), sign_filename)
    found_approval_signature_widget = SignatureWidget(
        approval_field.GetSDFObj())
    found_approval_signature_widget.CreateSignatureAppearance(img)
    # Prepare the signature and signature handler for signing.
    approval_signature_digsig_field.SignOnNextSave(pk_filename, '')
    # The signing will be done during the following incremental save operation.
    doc.Save(output_file, SDFDoc.e_incremental)
    # Develop a Process Summary
    summary = {
        "Input File": input_file, "Signature ID": signatureID, 
        "Output File": output_file, "Signature File": sign_filename, 
        "Certificate File": pk_filename
    }
    # Printing Summary
    print("## Summary ########################################################")
    print("\n".join("{}:{}".format(i, j) for i, j in summary.items()))
    print("###################################################################")
    return True

La sign_file()fonction effectue les opérations suivantes :

  • Itère sur les pages du fichier PDF d'entrée.
  • Insère un widget de signature dans les pages choisies de ce fichier à un emplacement spécifique.
  • Ajoute l'image de la signature et signe le fichier à l'aide du certificat auto-signé.

Assurez-vous d'avoir les certificats sous le staticdossier (nous verrons comment les générer plus tard).

Facultativement, la fonction suivante est utile pour signer tous les fichiers PDF dans un dossier spécifique :

def sign_folder(**kwargs):
    """Sign all PDF Files within a specified path"""
    input_folder = kwargs.get('input_folder')
    signatureID = kwargs.get('signatureID')
    pages = kwargs.get('pages')
    x_coordinate = int(kwargs.get('x_coordinate'))
    y_coordinate = int(kwargs.get('y_coordinate'))
    # Run in recursive mode
    recursive = kwargs.get('recursive')
    # Loop though the files within the input folder.
    for foldername, dirs, filenames in os.walk(input_folder):
        for filename in filenames:
            # Check if pdf file
            if not filename.endswith('.pdf'):
                continue
            # PDF File found
            inp_pdf_file = os.path.join(foldername, filename)
            print("Processing file =", inp_pdf_file)
            # Compress Existing file
            sign_file(input_file=inp_pdf_file, signatureID=signatureID, x_coordinate=x_coordinate,
                      y_coordinate=y_coordinate, pages=pages, output_file=None)
        if not recursive:
            break

Cette fonction est destinée à signer les fichiers PDF d'un dossier spécifique.

Il parcourt les fichiers du dossier spécifié de manière récursive ou non selon la valeur du recursiveparamètre et traite ces fichiers un par un. Il accepte les paramètres suivants :

  • input_folder: Le chemin du dossier contenant les fichiers PDF à traiter.
  • signatureID: L'identifiant du widget de signature à créer.
  • x_coordinateet y_coordinate: Les coordonnées indiquant l'emplacement de la signature. 
  • pages: La plage des pages à signer.
  • recursive: s'il faut exécuter ce processus de manière récursive en bouclant les sous-dossiers ou non.

Très bien, maintenant que nous avons tout, créons le code nécessaire pour analyser les arguments de la ligne de commande :

def is_valid_path(path):
    """Validates the path inputted and checks whether it is a file path or a folder path"""
    if not path:
        raise ValueError(f"Invalid Path")
    if os.path.isfile(path):
        return path
    elif os.path.isdir(path):
        return path
    else:
        raise ValueError(f"Invalid Path {path}")


def parse_args():
    """Get user command line parameters"""
    parser = argparse.ArgumentParser(description="Available Options")
    parser.add_argument('-l', '--load', dest='load', action="store_true",
                        help="Load the required configurations and create the certificate")
    parser.add_argument('-i', '--input_path', dest='input_path', type=is_valid_path,
                        help="Enter the path of the file or the folder to process")
    parser.add_argument('-s', '--signatureID', dest='signatureID',
                        type=str, help="Enter the ID of the signature")
    parser.add_argument('-p', '--pages', dest='pages', type=tuple,
                        help="Enter the pages to consider e.g.: [1,3]")
    parser.add_argument('-x', '--x_coordinate', dest='x_coordinate',
                        type=int, help="Enter the x coordinate.")
    parser.add_argument('-y', '--y_coordinate', dest='y_coordinate',
                        type=int, help="Enter the y coordinate.")
    path = parser.parse_known_args()[0].input_path
    if path and os.path.isfile(path):
        parser.add_argument('-o', '--output_file', dest='output_file',
                            type=str, help="Enter a valid output file")
    if path and os.path.isdir(path):
        parser.add_argument('-r', '--recursive', dest='recursive', default=False, type=lambda x: (
            str(x).lower() in ['true', '1', 'yes']), help="Process Recursively or Non-Recursively")
    args = vars(parser.parse_args())
    # To Display The Command Line Arguments
    print("## Command Arguments #################################################")
    print("\n".join("{}:{}".format(i, j) for i, j in args.items()))
    print("######################################################################")
    return args

La is_valid_path()fonction valide un chemin saisi en paramètre et vérifie s'il s'agit d'un fichier ou d'un répertoire.

La parse_args()fonction définit et définit les contraintes appropriées pour les arguments de ligne de commande à spécifier par l'utilisateur lors de l'exécution de cet utilitaire.

Je décrirai ci-après les arguments définis :

  • --loadou -l: Initialisez les paramètres de configuration en générant un certificat auto-signé. Cette étape doit être exécutée une fois ou en fonction des besoins.
  • --input_pathou -i: Permet de saisir le chemin du fichier ou du dossier à traiter, ce paramètre est associé à la is_valid_path()fonction précédemment définie.
  • --signatureIDou -s: L'identifiant à attribuer au widget de signature. (au cas où plusieurs signataires doivent signer le même document PDF).
  • --pagesou -p: Les pages à valider.
  • --x_coordinateou -xet --y_coordinateou -y: Spécifie l'emplacement de la signature sur la page.
  • --output_fileou -o: Le chemin du fichier de sortie. Le remplissage de cet argument est contraint par la sélection d'un fichier en entrée, et non d'un répertoire.
  • --recursiveou -r: s'il faut traiter un dossier de manière récursive ou non. Le remplissage de cet argument est contraint par la sélection d'un répertoire. 

Écrire le code principal maintenant :

if __name__ == '__main__':
    # Parsing command line arguments entered by user
    args = parse_args()
    if args['load'] == True:
        load()
    else:
        # If File Path
        if os.path.isfile(args['input_path']):
            sign_file(
                input_file=args['input_path'], signatureID=args['signatureID'],
                x_coordinate=int(args['x_coordinate']), y_coordinate=int(args['y_coordinate']), 
                pages=args['pages'], output_file=args['output_file']
            )
        # If Folder Path
        elif os.path.isdir(args['input_path']):
            # Process a folder
            sign_folder(
                input_folder=args['input_path'], signatureID=args['signatureID'], 
                x_coordinate=int(args['x_coordinate']), y_coordinate=int(args['y_coordinate']),
                pages=args['pages'], recursive=args['recursive']
            )

Ce qui précède représente la fonction principale de notre programme qui appelle les fonctions respectives en fonction du paramètre de charge ou du chemin sélectionné.

Testons notre programme :

Tout d'abord, passons --helppour voir les arguments de ligne de commande disponibles pour passer :

$ python sign_pdf.py --help

Sortir:

usage: sign_pdf.py [-h] [-l] [-i INPUT_PATH] [-s SIGNATUREID] [-p PAGES] [-x X_COORDINATE] [-y Y_COORDINATE]

Available Options

optional arguments:
  -h, --help            show this help message and exit
  -l, --load            Load the required configurations and create the certificate
  -i INPUT_PATH, --input_path INPUT_PATH
                        Enter the path of the file or the folder to process
  -s SIGNATUREID, --signatureID SIGNATUREID
                        Enter the ID of the signature
  -p PAGES, --pages PAGES
                        Enter the pages to consider e.g.: [1,3]
  -x X_COORDINATE, --x_coordinate X_COORDINATE
                        Enter the x coordinate.
  -y Y_COORDINATE, --y_coordinate Y_COORDINATE
                        Enter the y coordinate.

Très bien, commençons par générer un certificat auto-signé :

$ python sign_pdf.py --load

Une fois exécuté, vous remarquerez que les fichiers associés ont été créés sous le staticdossier :

Fichiers de signature générésDe plus, vous présenterez le récapitulatif suivant sur votre console :

## Command Arguments #################################################
load:True
input_path:None
signatureID:None
pages:None
x_coordinate:None
y_coordinate:None
######################################################################
## Initialization Summary ##################################################
OpenSSL Version:20.0.1
Private Key:b'-----BEGIN PRIVATE KEY-----\nMIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAM5HRS/5iLztVPxp\nnKUpjrECxVgqH+/BFh5A8v7KJcUsHY6ht6yL3D+vXxgiv170pOml2tGmW3zmvL/j\nEkWI/duMSyvPjc03SUp6rQqCnjw/dG2tSsOhzC51WwI8+bwDrdhNZ7x0UEdleeQw\n5NtwQ6MqwiLNLhJLT8V/dtVsK/LxAgMBAAECgYEAglt31cGUMBCrzHfRjm6cxjBC\nFl1IoXMcTzIsXefRxrECXMjGEjywi26AYfhTh+aC8UTm6+Z9mokWbw1I1rij85/y\nvx4CTSGFAkMGAzmRTkmliPZoQDUxjr2XmSZaRhipo0atLY5dQYhQcINXq80lLAxZ\nsS3Tl7mxnssRo0hcHCECQQDyTVQEE5YLKpAsLWYRqMP3L2EDKNmySycIvVKh9lKB\nSlaHWzUfdHgzONcTA5Egd2CQchifPLx9KrykkusXs4knAkEA2fCYpKaaDDY+CjUI\nrY5RsYYoh5v2tZZ3PB3ElbN5afZY+dHa+mXsI6eBZgaUmsHeT0/OyymfsxZk//mI\n85pCJwJBAI54h4kqFxSTv1gqjZSenjOO6UUZVP/wDpCl+ZuAIb0h/8TxDUhkjHTZ\n3CSy+TeU2fO1EuM2rEIQygEe3hr+lwsCQFMCgwFju5UfK+4zWQTSCme1k8ZjL0rm\n7q9lHzVt0Lb9b9JnjiKFo7XI3U6A/yUa5pQK79cOGZfa1clxwCoY/U0CQBu4vATn\nyWVfp6lgLgY9T9FsCp7wPIRJJA1sUfhDvNeNt7WK6ynhVDaD0bZ+lX0sYG2RxI3m\nVSgAaAyqkMcYl5Q=\n-----END PRIVATE KEY-----\n'
Self Signed Certificate:b'-----BEGIN CERTIFICATE-----\nMIIBoTCCAQoCBQPMisZRMA0GCSqGSIb3DQEBBAUAMBcxFTATBgNVBAMMDEJBU1NF\nTSBNQVJKSTAeFw0yMTA5MTQyMTI3NDhaFw0zMTA5MTIyMTI3NDhaMBcxFTATBgNV\nBAMMDEJBU1NFTSBNQVJKSTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAzkdF\nL/mIvO1U/GmcpSmOsQLFWCof78EWHkDy/solxSwdjqG3rIvcP69fGCK/XvSk6aXa\n0aZbfOa8v+MSRYj924xLK8+NzTdJSnqtCoKePD90ba1Kw6HMLnVbAjz5vAOt2E1n\nvHRQR2V55DDk23BDoyrCIs0uEktPxX921Wwr8vECAwEAATANBgkqhkiG9w0BAQQF\nAAOBgQBLqfxOdXkXO2nubqSTdLEZYKyN4L+BxlYm2ZuG8ki0tAOrAAVIcmCM6QYf\n0oWURShZko+a6YP5f4UmZh1DVO7WnnBOytDf+f+n3SErw5YEkfbCDQp5MSjz+79N\nvJtQOPr3RjtyuDFWvNlcit2q6JW2lsmfD2+CdG7iSbiKLC8Bag==\n-----END CERTIFICATE-----\n'
Public Key:b'-----BEGIN PUBLIC KEY-----\nMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDOR0Uv+Yi87VT8aZylKY6xAsVY\nKh/vwRYeQPL+yiXFLB2Oobesi9w/r18YIr9e9KTppdrRplt85ry/4xJFiP3bjEsr\nz43NN0lKeq0Kgp48P3RtrUrDocwudVsCPPm8A63YTWe8dFBHZXnkMOTbcEOjKsIi\nzS4SS0/Ff3bVbCvy8QIDAQAB\n-----END PUBLIC KEY-----\n'
############################################################################

Comme vous pouvez le voir, les clés privées et publiques ont été générées avec succès, ainsi que le certificat. Encore une fois, comme indiqué précédemment. Si vous utilisez ce code, vous devez exclure la clé privée du dictionnaire récapitulatif afin qu'elle ne soit pas imprimée sur la console.

Signons maintenant le document intitulé "Letter of confirmation.pdf"placé sous le dossier statique :

$ python sign_pdf.py -i ".\static\Letter of confirmation.pdf" -s "BM" -x 330 -y 280

Le résumé suivant s'affichera sur la console :

## Command Arguments #################################################
load:False
input_path:static\Letter of confirmation.pdf
signatureID:BM
pages:None
x_coordinate:330
y_coordinate:280
output_file:None
######################################################################

PDFNet is running in demo mode.
Permission: read
Permission: write
## Summary ########################################################
Input File:static\Letter of confirmation.pdf
Signature ID:BM
Output File:static\Letter of confirmation_signed.pdf
Signature File:C:\pythoncode-tutorials\handling-pdf-files\pdf-signer\static\signature.jpg
Certificate File:C:\pythoncode-tutorials\handling-pdf-files\pdf-signer\static\container.pfx
###################################################################

Le document sera mis à jour "Letter of confirmation_signed.pdf"comme suit :

Document PDF signé avec Python

Lorsque vous cliquez sur le champ de signature en surbrillance, vous remarquerez le message d'avertissement affiché ci-après :

Avertissement de signature numériqueLa raison de cet avertissement est que le nouveau certificat auto-signé n'est pas encore approuvé par Acrobat Reader. Appuyez sur le bouton Propriétés de la signature et vous verrez les détails du certificat auto-signé.

Remarque : Veuillez vous reporter à l'annexe ci-jointe détaillant les instructions d'utilisation pour faire confiance au certificat auto-signé par Adobe Reader.

Conclusion

Vous pouvez également spécifier l' -poption de signer plusieurs pages dans un fichier PDF, par exemple :

$ python sign_pdf.py -i pdf_file.pdf -s "BM" -x 330 -y 300 -p [1, 3]

Ou signer plusieurs fichiers PDF inclus dans un dossier :

$ python sign_pdf.py -i pdf-files-folder -s "BM" -p [1] -x 330 -y 300 -r 0

La signature numérique de documents permet de gagner du temps, réduit le besoin de processus papier et vous offre la flexibilité d'approuver un document de presque n'importe où.

J'espère que cet article vous a plu et qu'il vous a aidé à construire vos outils !

Vérifiez le code complet ici .

What is GEEK

Buddha Community

Ray  Patel

Ray Patel

1619510796

Lambda, Map, Filter functions in python

Welcome to my Blog, In this article, we will learn python lambda function, Map function, and filter function.

Lambda function in python: Lambda is a one line anonymous function and lambda takes any number of arguments but can only have one expression and python lambda syntax is

Syntax: x = lambda arguments : expression

Now i will show you some python lambda function examples:

#python #anonymous function python #filter function in python #lambda #lambda python 3 #map python #python filter #python filter lambda #python lambda #python lambda examples #python map

Shardul Bhatt

Shardul Bhatt

1626775355

Why use Python for Software Development

No programming language is pretty much as diverse as Python. It enables building cutting edge applications effortlessly. Developers are as yet investigating the full capability of end-to-end Python development services in various areas. 

By areas, we mean FinTech, HealthTech, InsureTech, Cybersecurity, and that's just the beginning. These are New Economy areas, and Python has the ability to serve every one of them. The vast majority of them require massive computational abilities. Python's code is dynamic and powerful - equipped for taking care of the heavy traffic and substantial algorithmic capacities. 

Programming advancement is multidimensional today. Endeavor programming requires an intelligent application with AI and ML capacities. Shopper based applications require information examination to convey a superior client experience. Netflix, Trello, and Amazon are genuine instances of such applications. Python assists with building them effortlessly. 

5 Reasons to Utilize Python for Programming Web Apps 

Python can do such numerous things that developers can't discover enough reasons to admire it. Python application development isn't restricted to web and enterprise applications. It is exceptionally adaptable and superb for a wide range of uses.

Robust frameworks 

Python is known for its tools and frameworks. There's a structure for everything. Django is helpful for building web applications, venture applications, logical applications, and mathematical processing. Flask is another web improvement framework with no conditions. 

Web2Py, CherryPy, and Falcon offer incredible capabilities to customize Python development services. A large portion of them are open-source frameworks that allow quick turn of events. 

Simple to read and compose 

Python has an improved sentence structure - one that is like the English language. New engineers for Python can undoubtedly understand where they stand in the development process. The simplicity of composing allows quick application building. 

The motivation behind building Python, as said by its maker Guido Van Rossum, was to empower even beginner engineers to comprehend the programming language. The simple coding likewise permits developers to roll out speedy improvements without getting confused by pointless subtleties. 

Utilized by the best 

Alright - Python isn't simply one more programming language. It should have something, which is the reason the business giants use it. Furthermore, that too for different purposes. Developers at Google use Python to assemble framework organization systems, parallel information pusher, code audit, testing and QA, and substantially more. Netflix utilizes Python web development services for its recommendation algorithm and media player. 

Massive community support 

Python has a steadily developing community that offers enormous help. From amateurs to specialists, there's everybody. There are a lot of instructional exercises, documentation, and guides accessible for Python web development solutions. 

Today, numerous universities start with Python, adding to the quantity of individuals in the community. Frequently, Python designers team up on various tasks and help each other with algorithmic, utilitarian, and application critical thinking. 

Progressive applications 

Python is the greatest supporter of data science, Machine Learning, and Artificial Intelligence at any enterprise software development company. Its utilization cases in cutting edge applications are the most compelling motivation for its prosperity. Python is the second most well known tool after R for data analytics.

The simplicity of getting sorted out, overseeing, and visualizing information through unique libraries makes it ideal for data based applications. TensorFlow for neural networks and OpenCV for computer vision are two of Python's most well known use cases for Machine learning applications.

Summary

Thinking about the advances in programming and innovation, Python is a YES for an assorted scope of utilizations. Game development, web application development services, GUI advancement, ML and AI improvement, Enterprise and customer applications - every one of them uses Python to its full potential. 

The disadvantages of Python web improvement arrangements are regularly disregarded by developers and organizations because of the advantages it gives. They focus on quality over speed and performance over blunders. That is the reason it's a good idea to utilize Python for building the applications of the future.

#python development services #python development company #python app development #python development #python in web development #python software development

August  Larson

August Larson

1624428000

Creating PDF Invoices in Python with pText

Introduction

The Portable Document Format (PDF) is not a WYSIWYG (What You See is What You Get) format. It was developed to be platform-agnostic, independent of the underlying operating system and rendering engines.

To achieve this, PDF was constructed to be interacted with via something more like a programming language, and relies on a series of instructions and operations to achieve a result. In fact, PDF is based on a scripting language - PostScript, which was the first device-independent Page Description Language.

In this guide, we’ll be using pText - a Python library dedicated to reading, manipulating and generating PDF documents. It offers both a low-level model (allowing you access to the exact coordinates and layout if you choose to use those) and a high-level model (where you can delegate the precise calculations of margins, positions, etc to a layout manager).

We’ll take a look at how to create a PDF invoice in Python using pText.

#python #pdf #creating pdf invoices in python with ptext #creating pdf invoices #pdf invoice #creating pdf invoices in python with ptext

Paula  Hall

Paula Hall

1620437073

Statements And Comments In Python

When you write a program in python that particular code is written line by line. Which means there are kind of sentences in your code. These sentences can be identified under two main groups according to the reason why you are adding them into your code.

To make it easy for you I will name them as Python statements and Python comments.

Python Statements

Instructions that you write in your code and that a **Python interpreter **can execute are called statements.

Wait what! Python interpreter? What’s that?

Let me make it clear to you.

Python interpreter is nothing but a converter which converts the Python language to machine language. Your computer’s hardware obviously can’t understand Python. Therefore, there has to be something that makes the computer understand what you want to be done using your Python code. That is basically done by the Python interpreter. Piece of cake!

Still no idea what really Python statements are?

Don’t worry! Help is on the way!

#python-programming #comments-in-python #statements-in-python #python-comments #python-statements

Art  Lind

Art Lind

1602968400

Python Tricks Every Developer Should Know

Python is awesome, it’s one of the easiest languages with simple and intuitive syntax but wait, have you ever thought that there might ways to write your python code simpler?

In this tutorial, you’re going to learn a variety of Python tricks that you can use to write your Python code in a more readable and efficient way like a pro.

Let’s get started

Swapping value in Python

Instead of creating a temporary variable to hold the value of the one while swapping, you can do this instead

>>> FirstName = "kalebu"
>>> LastName = "Jordan"
>>> FirstName, LastName = LastName, FirstName 
>>> print(FirstName, LastName)
('Jordan', 'kalebu')

#python #python-programming #python3 #python-tutorials #learn-python #python-tips #python-skills #python-development