CATALOGUE Code & Data Formation Python Maîtriser Python Créer une Machine à Sous Complexe en Python

Créer une Machine à Sous Complexe en Python

Générateurs : Déléguer le travail à un sous-générateur
Vidéo non disponible ! Réessayez plus tard
Cette vidéo fait partie de la formation
Maîtriser Python
Revoir le teaser Je m'abonne
5,0
Transcription
99,00€ Je commande
Formation incluse dans l'abonnement Elephorm Je m'abonne à Elephorm
DescriptionProgrammeAvis
5,0
99,00€ Je commande
Formation incluse dans l'abonnement Elephorm Je m'abonne à Elephorm

Déléguer le Travail à des Sous-Générateurs

Objectifs

Les objectifs de cette vidéo incluent :

  • Comprendre comment créer et utiliser des générateurs en Python
  • Apprendre à simplifier le code avec yieldFrom
  • Être capable de générer des machines à sous complexes de manière dynamique et efficace

Résumé

Découvrez comment créer une machine à sous avancée en utilisant des générateurs en Python.

Description

Dans cette leçon, nous allons explorer la création d'une machine à sous complexe qui permet de générer un nombre variable de billets avec différentes valeurs. Plutôt que de coder chaque machine à sous manuellement, nous utiliserons des générateurs en Python pour automatiser ce processus de manière efficace.

Nous commencerons par la création de multiples générateurs basés sur le nombre de billets souhaités. Ensuite, nous couvrirons l'utilisation de la fonction zip pour la lecture parallèle des générateurs. Enfin, nous verrons comment simplifier notre code avec le mot-clé yieldFrom, qui permet de déléguer le travail à un sous-générateur en une seule ligne.

Ce tutoriel vous permettra d'optimiser votre code et de mieux comprendre le fonctionnement des générateurs en Python. Vous apprendrez également comment gérer les envois de données à travers yieldFrom pour un contrôle plus poussé, particulièrement utile dans des scénarios de programmation avancée.

Voir plus

Questions - réponses

Qu'est-ce qu'un générateur en Python ?
Un générateur en Python est une fonction qui permet de retourner un élément à la fois, en utilisant le mot-clé yield, ce qui permet de conserver l'état entre les appels.
Quelle est l'utilité de la fonction zip dans ce contexte ?
La fonction zip permet de lire les générateurs en parallèle, facilitant la synchronisation et l'agrégation des valeurs générées.
Quelle est la différence entre yield et yieldFrom ?
yieldFrom permet de déléguer la génération de valeurs à un sous-générateur, simplifiant ainsi le code en remplaçant une boucle for par une seule ligne.

Programme détaillé

2 commentaires
5,0
2 votes
5
4
3
2
1
michelkreutner
Il y a 11 months
Commentaire
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.vogel
Il y a 2 years
Commentaire
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")