UN Gestionnaire de téléchargement est essentiellement un programme informatique dédié à la tâche de téléchargement de fichiers autonomes depuis Internet. Ici, nous allons créer un simple gestionnaire de téléchargement à l'aide de threads en Python. Grâce au multithreading, un fichier peut être téléchargé sous forme de morceaux simultanément à partir de différents threads. Pour mettre en œuvre cela, nous allons créer un outil de ligne de commande simple qui accepte l'URL du fichier puis le télécharge.

Prérequis : Machine Windows avec Python installé.

Installation

Téléchargez les packages mentionnés ci-dessous à partir de l’invite de commande.

comment trier un tableau en Java

1. Package Click : Click est un package Python permettant de créer de superbes interfaces de ligne de commande avec aussi peu de code que nécessaire. Il s'agit du kit de création d'interface de ligne de commande.

pip installer cliquez

2. Package de requêtes : Dans cet outil, nous allons télécharger un fichier basé sur l'URL (adresses HTTP). Requests est une bibliothèque HTTP écrite en Python qui vous permet d'envoyer des requêtes HTTP. Vous pouvez ajouter des en-têtes de fichiers et des paramètres de données en plusieurs parties avec de simples dictionnaires Python et accéder aux données de réponse de la même manière.

demandes d'installation pip

3. Package de threading : pour travailler avec des threads, nous avons besoin d'un package de threading.

pip installer le filetage

Mise en œuvre

Note:

Le programme a été divisé en parties pour le rendre facile à comprendre. Assurez-vous qu'il ne vous manque aucune partie du code lors de l'exécution du programme.

Étape 1 : Importer les packages requis

Ces packages fournissent les outils nécessaires pour que les requêtes Web gèrent les entrées de ligne de commande et créent des threads.

import click import requests import threading 

Étape 2 : créer la fonction de gestionnaire

Chaque thread exécutera cette fonction pour télécharger sa partie spécifique du fichier. Cette fonction est chargée de demander uniquement une plage spécifique d'octets et de les écrire à la position correcte dans le fichier.

variable Java variable

def Handler(start end url filename): headers = {'Range': f'bytes={start}-{end}'} r = requests.get(url headers=headers stream=True) with open(filename 'r+b') as fp: fp.seek(start) fp.write(r.content) 

Étape 3 : Définir la fonction principale avec un clic

Transforme la fonction en un utilitaire de ligne de commande. Cela définit la manière dont les utilisateurs interagissent avec le script à partir de la ligne de commande.

#Note: This code will not work on online IDE @click.command(help='Downloads the specified file with given name using multi-threading') @click.option('--number_of_threads' default=4 help='Number of threads to use') @click.option('--name' type=click.Path() help='Name to save the file as (with extension)') @click.argument('url_of_file' type=str) def download_file(url_of_file name number_of_threads): 

Étape 4 : Définir le nom du fichier et déterminer la taille du fichier

Nous avons besoin de la taille du fichier pour diviser le téléchargement entre les threads et garantir que le serveur prend en charge les téléchargements à distance.

 r = requests.head(url_of_file) file_name = name if name else url_of_file.split('/')[-1] try: file_size = int(r.headers['Content-Length']) except: print('Invalid URL or missing Content-Length header.') return 

Étape 5 : Préallouer de l'espace fichier

La préallocation garantit que le fichier a la bonne taille avant d'écrire des morceaux dans des plages d'octets spécifiques.

 part = file_size // number_of_threads with open(file_name 'wb') as fp: fp.write(b'' * file_size) 

Étape 6 : Créer des fils de discussion

Les threads se voient attribuer des plages d’octets spécifiques à télécharger en parallèle.

 threads = [] for i in range(number_of_threads): start = part * i end = file_size - 1 if i == number_of_threads - 1 else (start + part - 1) t = threading.Thread(target=Handler kwargs={ 'start': start 'end': end 'url': url_of_file 'filename': file_name }) threads.append(t) t.start() 

Étape 7 : Rejoignez les discussions

Garantit que tous les threads sont terminés avant la fin du programme.

 for t in threads: t.join() print(f'{file_name} downloaded successfully!') if __name__ == '__main__': download_file() 

Code:

import click import requests import threading def Handler(start end url filename): headers = {'Range': f'bytes={start}-{end}'} r = requests.get(url headers=headers stream=True) with open(filename 'r+b') as fp: fp.seek(start) fp.write(r.content) @click.command(help='Downloads the specified file with given name using multi-threading') @click.option('--number_of_threads' default=4 help='Number of threads to use') @click.option('--name' type=click.Path() help='Name to save the file as (with extension)') @click.argument('url_of_file' type=str) def download_file(url_of_file name number_of_threads): r = requests.head(url_of_file) if name: file_name = name else: file_name = url_of_file.split('/')[-1] try: file_size = int(r.headers['Content-Length']) except: print('Invalid URL or missing Content-Length header.') return part = file_size // number_of_threads with open(file_name 'wb') as fp: fp.write(b'' * file_size) threads = [] for i in range(number_of_threads): start = part * i # Make sure the last part downloads till the end of file end = file_size - 1 if i == number_of_threads - 1 else (start + part - 1) t = threading.Thread(target=Handler kwargs={ 'start': start 'end': end 'url': url_of_file 'filename': file_name }) threads.append(t) t.start() for t in threads: t.join() print(f'{file_name} downloaded successfully!') if __name__ == '__main__': download_file() 

Nous avons terminé la partie codage et suivons maintenant les commandes indiquées ci-dessous pour exécuter le fichier .py.

np std

python filename.py –-help

Sortir:

Cette commande affiche l'utilisation de l'outil de commande clic et les options que l'outil peut accepter. Vous trouverez ci-dessous un exemple de commande dans laquelle nous essayons de télécharger un fichier image jpg à partir d'une URL et donnons également un nom et un nombre de threads.

Après avoir tout exécuté avec succès, vous pourrez voir votre fichier ( flower.webp dans ce cas) dans votre répertoire de dossiers comme indiqué ci-dessous :

Enfin, nous en avons terminé avec succès et c'est l'un des moyens de créer un simple gestionnaire de téléchargement multithread en Python.