CATALOGUE Code & Data Formation Python Maîtriser Python - Techniques avancées Gestion des Tâches Parallèles en Programmation Python

Gestion des Tâches Parallèles en Programmation Python

Introduction au partage de travail
Vidéo non disponible ! Réessayez plus tard
Cette vidéo fait partie de la formation
Maîtriser Python - Techniques avancées
Revoir le teaser Je m'abonne
5,0
Transcription
Cette leçon fait partie de la formation
99,00€ Ajouter au panier

Formation incluse dans l'abonnement Elephorm

Je m'abonne à Elephorm
DescriptionProgrammeAvis
5,0
Cette leçon fait partie de la formation
99,00€ Ajouter au panier

Formation incluse dans l'abonnement Elephorm

Je m'abonne à Elephorm

Introduction à la Concurrence en Python

Objectifs

Les objectifs de cette vidéo sont de vous apprendre à gérer plusieurs tâches en parallèle en Python, à comprendre les conséquences de différentes méthodes de partage de travail, et à optimiser l'efficacité de vos programmes par une utilisation appropriée des ressources.

Résumé

Apprenez à développer des programmes complexes qui peuvent gérer plusieurs tâches en parallèle en utilisant le langage Python.

Description

Dans cette vidéo, nous allons explorer comment gérer efficacement des tâches parallèles en programmation. En utilisant des exemples concrets, nous illustrerons la gestion des entrées et sorties multiples, ainsi que l'interaction avec les utilisateurs et d'autres systèmes tout en traitant des données. Nous discuterons également des différentes techniques de partage de travail et leurs conséquences spécifiques en Python. Cette leçon est cruciale pour comprendre comment éviter que certaines tâches ne consomment trop de ressources ou ne prennent trop d'avance.

Vous découvrirez les particularités du langage Python dans la gestion des tâches concurrentes et comment les utiliser à votre avantage pour améliorer vos programmes. Nous aborderons les concepts de l'équilibrage de charge, de la synchronisation des tâches et des précautions à prendre pour maintenir l'efficacité globale de votre application. Que vous soyez débutant ou programmeur expérimenté, cette vidéo vous fournira les bases nécessaires pour intégrer la concurrence dans vos projets Python.

Voir plus

Questions fréquentes

Pourquoi est-il important de gérer plusieurs tâches en parallèle dans un programme?
Il est important de gérer plusieurs tâches en parallèle pour améliorer l'efficacité et la réactivité du programme, permettant ainsi une meilleure utilisation des ressources et une meilleure interaction avec les utilisateurs.
Quelles sont les conséquences possibles d'une mauvaise gestion des tâches parallèles?
Une mauvaise gestion des tâches parallèles peut conduire à une consommation excessive de ressources, à des performances médiocres, ou à des conflits de synchronisation entre les tâches, compromettant ainsi le fonctionnement global du programme.
Que signifie l'équilibrage de charge en programmation concurrente?
L'équilibrage de charge signifie répartir équitablement les tâches et les ressources disponibles pour éviter qu'une seule tâche ne prenne le dessus et pour maintenir l'efficacité de l'ensemble du programme.

Programme détaillé

3 commentaires
5,0
3 votes
5
4
3
2
1
LELEU X.
Il y a 7 mois
Bonjour,
Les thèmes variés agrémentés d'exemples simples et clairs enrichissent toutes les notions exposées de façon particulièrement pédagogique. 👍
L'approche didactique m'a permis de beaucoup mieux comprendre tout un tas de concepts plus ou moins bien assimilés auparavant avec une vue d'ensemble nettement plus limpide aujourd'hui. 🤓
Merci pour cette belle prestation. 🙏
Profile picture for user michelkreutner
Michel K.
Il y a 1 an
Les explications sont claires et concises. Ce cours sur l'utilisation avancée de Python est tres intéressant. Il vous apportera des connaissances que vous pourrez ensuite approfondir.
Je suis vraiment tres satisfait par cette première formation suivie sur Python.
Yvan V.
Il y a 3 ans
Hello, sur la video autour de asyncio, vous utilisez python 2.7.12. J'utilise python 3.10, aussi je souhaite faire partager mon code (qui fonctionne) selon ma vision et compréhension sur le sujet d'étude que vous avez proposé. Yvan Vogel.

#CODE en python 3.10.0 64 bits (VScode 1.62.3)
import datetime
import asyncio
import aiohttp
import requests


# ----------------------------------------------------------------------------------------------------------------------------
def req_bloquante(num):
print(f"Get {num}")
uid = requests.get("https://httpbin.org/uuid").json()["uuid"]
print(f"Res {num}: {uid}")


def faire_toutes_les_requetes():
for x in range(51):
req_bloquante(x)


print("=====> ### Bloquant : ")
start = datetime.datetime.now()
faire_toutes_les_requetes()
exec_time = (datetime.datetime.now() - start).seconds
print(f"Downloading all take {exec_time} seconds\n")

# ----------------------------------------------------------------------------------------------------------------------------


async def requeteSansBloquer(semaphore, num, session):
print(f"Get {num}")
# await semaphore.acquire() # putting this await semaphore commande the Res is ordering but process very slow ~60 sec
async with session.get("https://httpbin.org/uuid") as response:
uid = (await response.json())["uuid"]
# await asyncio.sleep(delay=3) #delay = number of seconds
# semaphore.release()
print(f"Res {num}: {uid}")
# return uid # ?


async def main():
semaphore = asyncio.Semaphore(value=1)
tasks = []
async with aiohttp.ClientSession(
loop=loop, connector=aiohttp.TCPConnector(ssl=False)
) as session:
for x in range(51):
tasks.append(requeteSansBloquer(semaphore, x, session))
await asyncio.gather(*tasks)
print("This is after the loop...")


if __name__ == "__main__":
print("=====> ### Non Bloquant : ")
start = datetime.datetime.now()
loop = asyncio.get_event_loop()
loop.run_until_complete(main())
exec_time = (datetime.datetime.now() - start).microseconds
print(f"Downloading all take {exec_time} micro seconds\n")