Python Multiprocesting For-Boop

Le multiprocessement est comparable au multithreading. Cependant, il se différencie en ce que nous ne pouvons exécuter qu'un seul thread à un moment en raison du gil qui est utilisé pour le filetage. Le multiprocessement est le processus de réalisation des opérations séquentiellement à travers plusieurs cœurs CPU. Les threads ne peuvent pas être utilisés en parallèle. Cependant, le multiprocessement nous permet d'établir les processus et de les exécuter simultanément sur divers cœurs de CPU. La boucle, comme la boucle for, est l'une des langues de script les plus souvent utilisées. Répétez le même travail en utilisant diverses données jusqu'à ce qu'un critère, comme un nombre prédéterminé d'itérations, soit atteint. La boucle accomplit chaque itération une par une.

Exemple 1: Utilisation de la boucle pour le module multiprocesseur Python

Dans cet exemple, nous utilisons le processus de classe de module multiprocesseur Python et Python. Nous commençons par un exemple très simple afin que vous puissiez rapidement comprendre comment fonctionne le multiprocessement Python. En utilisant une interface comparable au module de threading, le multiprocessement contient la création de processus.

En utilisant les sous-processus plutôt que les threads, le package multiprocesseur fournit une concurrence locale et distante, évitant ainsi le verrouillage mondial de l'interprète. Utilisez une boucle à forte. Cela fonctionne moins comme le mot-clé vu dans d'autres langages de programmation et plus comme une méthode d'itérateur trouvée dans d'autres langages de programmation. En démarrant un nouveau multiprocessement, vous pouvez exécuter une boucle pour exécuter simultanément une procédure.

Commençons par implémenter le code pour l'exécution du code en utilisant l'outil «Spyder». Nous pensons que «Spyder» est également le meilleur pour faire fonctionner Python. Nous importons un processus de module multiprocesseur que le code exécute. Le multiprocessement dans Python Concept appelé une «classe de processus» crée un nouveau processus Python, lui donne une méthode pour exécuter du code et donne à l'application parent un moyen de gérer l'exécution. La classe de processus contient les procédures start () et join (), toutes deux cruciales.

Ensuite, nous définissons une fonction définie par l'utilisateur appelé «Func». Puisqu'il s'agit d'une fonction définie par l'utilisateur, nous lui donnons un nom de notre choix. À l'intérieur du corps de cette fonction, nous passons la variable «sujet» comme argument et la valeur «mathématiques». Ensuite, nous appelons la fonction «print ()», passant l'instruction «le nom du sujet commun est» ainsi que son argument «sujet» qui contient la valeur. Ensuite, dans l'étape suivante, nous utilisons le «if name == _main_», ce qui vous empêche d'exécuter le code lorsque le fichier est importé en tant que module et vous permet de le faire lorsque le contenu est exécuté sous forme de script.

La section de condition dont vous commencez peut être considérée dans la plupart des cas comme un emplacement pour fournir le contenu qui ne devrait être exécuté que lorsque votre fichier s'exécute en tant que script. Ensuite, nous utilisons le sujet de l'argument et stockons certaines valeurs qui sont «scientifiques», «anglais» et «ordinateur». Le processus est ensuite donné le nom «Process1 []» à l'étape suivante. Ensuite, nous utilisons le «processus (cible = func)» pour appeler la fonction dans le processus. La cible est utilisée pour appeler la fonction, et nous enregistrons ce processus dans la variable «P».

Ensuite, nous utilisons la fonction «Process1» pour appeler la fonction «APPEND ()» qui ajoute un élément à la fin de la liste que nous avons dans la fonction «Func."Parce que le processus est stocké dans la variable" P ", nous passons" P "à cette fonction comme son argument. Enfin, nous utilisons la fonction «start ()» avec «p» pour démarrer le processus. Après cela, nous exécutons à nouveau la méthode tout en fournissant l'argument «sujet» et utilisons «pour» dans le sujet. Ensuite, en utilisant la méthode «process1» et la méthode «add ()», nous commençons le processus. Le processus s'exécute alors et la sortie est renvoyée. La procédure est alors invitée à terminer en utilisant la technique «join ()». Les processus qui n'appellent pas la procédure «join ()» ne quitteront pas. Un point crucial est que le paramètre de mot-clé «args» doit être utilisé si vous souhaitez fournir des arguments tout au long du processus.

Maintenant, vous pouvez voir dans la sortie que l'instruction est affichée en premier en passant la valeur du sujet «mathématiques» que nous transmettons dans la fonction «Func» parce que nous l'appelons d'abord en utilisant la fonction «Process». Ensuite, nous utilisons la commande «APPEND ()» pour avoir des valeurs qui figuraient déjà dans la liste qui est ajoutée à la fin. Ensuite, «Science», «Computer» et «l'anglais» ont été présentés. Mais, comme vous pouvez le voir, les valeurs ne sont pas dans la séquence correcte. C'est parce qu'ils le font aussi rapidement que la procédure est terminée et signalez leur message.

Exemple 2: Conversion de la boucle séquentielle en boucle parallèle multiprocesse

Dans cet exemple, la tâche de boucle de multiprocessement est exécutée séquentiellement avant d'être convertie en une tâche de boucle parallèle. Vous pouvez parcourir des séquences comme une collection ou une chaîne dans l'ordre où elles se produisent en utilisant les boucles.

Maintenant, commençons à implémenter le code. Tout d'abord, nous importons «sommeil» à partir du module temporel. En utilisant la procédure «sleep ()» dans le module Time, vous pouvez suspendre l'exécution du fil d'appel aussi longtemps que vous le souhaitez. Ensuite, nous utilisons «aléatoire» à partir du module aléatoire, définissons une fonction avec le nom «func» et passons le mot-clé «argu». Ensuite, nous créons une valeur aléatoire en utilisant «Val» et la définissons sur «aléatoire». Ensuite, nous bloquons pendant une petite période en utilisant la méthode "Sleep ()" et passons "Val" comme paramètre. Ensuite, pour transmettre un message, nous exécutons la méthode «print ()», passant les mots «Ready» et le mot-clé «arg» comme paramètre, ainsi que «créé» et passer la valeur en utilisant «Val».

Enfin, nous utilisons «Flush» et le fixons sur «vrai». L'utilisateur peut décider de tamponner la sortie à l'aide de l'option Flush dans la fonction d'impression de Python. La valeur par défaut de ce paramètre de faux indique que la sortie ne sera pas tamponnée. La sortie est affichée comme une série de lignes qui se suivent si vous la définissez sur true. Ensuite, nous utilisons le «if name == main» pour sécuriser les points d'entrée. Ensuite, nous exécutons le travail séquentiellement. Ici, nous définissons la plage sur «10», ce qui signifie que la boucle se termine après 10 itérations. Ensuite, nous appelons la fonction «print ()», passons à l'instruction d'entrée «Ready» et utilisons l'option «Flush = true».

Vous pouvez maintenant voir que lorsque nous exécutons le code, la boucle fait fonctionner la fonction «10». Il itère 10 fois, commençant à l'index zéro et se terminant à l'index neuf. Chaque message contient un numéro de tâche qui est un numéro de fonction que nous passons en tant que «arg» et un numéro de création.

Cette boucle séquentielle est maintenant transformée en une boucle parallèle multiprocesseur. Nous utilisons le même code, mais nous allons dans des bibliothèques et des fonctions supplémentaires pour le multiprocessement. Par conséquent, nous devons importer le processus du multiprocessement, tout comme nous l'avons expliqué plus tôt. Ensuite, nous créons une fonction appelée «func» et passons le mot-clé «arg» avant d'utiliser «val = aléatoire» pour obtenir un nombre aléatoire.

Ensuite, après avoir invoqué la méthode «print ()» pour afficher un message et donner au paramètre «Val» pour retarder une petite période, nous utilisons la fonction «if name = main» pour sécuriser les points d'entrée. Sur quoi, nous créons un processus et appelons la fonction du processus en utilisant «Processus» et passons le «Target = Func». Ensuite, nous passons le «func», «arg», passons la valeur «M» et passant la plage «10», ce qui signifie que la boucle termine la fonction après «10» itérations. Ensuite, nous commençons le processus à l'aide de la méthode "start ()" avec "Processus". Ensuite, nous appelons la méthode «join ()» pour attendre l'exécution du processus et pour terminer tout le processus après.

Par conséquent, lorsque nous exécutons le code, les fonctions appellent le processus principal et commencent leur exécution. Ils sont cependant terminés jusqu'à ce que toutes les tâches soient accomplies. Nous pouvons le voir parce que chaque tâche est effectuée simultanément. Il rapporte son message dès sa fin. Cela signifie que bien que les messages soient en panne, la boucle se termine une fois que «10» itérations sont terminées.

Conclusion

Nous avons couvert le multiprocessement Python pour la boucle dans cet article. Nous avons également présenté deux illustrations. La première illustration montre comment utiliser une boucle pour la boucle de boucle de Python. Et la deuxième illustration montre comment changer une boucle séquentielle en une boucle multiprocesse parallèle. Avant de construire le script pour le multiprocessement Python, nous devons importer le module multiprocesseur.