CATALOGUE Code & Data Formation Python Maîtriser Python - Techniques avancées 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 - 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

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 fréquentes

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é

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")