## Fonctions LAMBDA ## Méthodes et fonctions avancées ### Données déstructurées dc_infos = ("Dale", "Cooper", "32") dc_prenom = dc_infos[0] dc_nom = dc_infos[1] dc_age = dc_infos[2] dc_prenom, dc_nom, dc_age = dc_infos ### Surcharge de méthode ```py range(10) # [0,1,2,3,4,5,6,7,8,9] range(2, 10) # [2,3,4,5,6,7,8,9] range(2, 10, 2) # [2,4,6,8] ``` ### A la place de `return` => `yield` ```py def generator(): for i in range(10): return i ``` Renverra [0], `return` étant un arrêt. Alors que : ```py def generator(): for i in range(10): yield i ``` Va renvoyer : `` ### Générateurs La fonction `next` permet d'économiser des ressources en mettant en mémoire la fonction et sa position. Par exemple : ```py def square_generator(n): for i in range(n): yield i ** 2 ``` Renverra ``. Maintenant, on utilise : ```py squares = square_generator(10) print(next(squares)) print(next(squares)) print(next(squares)) print(next(squares)) print(next(squares)) print(next(squares)) print(next(squares)) print(next(squares)) ``` Renverra : ``` 0 1 4 9 16 25 36 49 ``` ### Return, Yield et Continue ```py for square in generator: if square > 50: # Si le carré est supérieur à 50, la boucle cesse break if square % 2 == 0: # Si le carré est pair, on le zappe continue print(square) ``` ## Format String Le classique : ```py print("La lettre " + variable_str + " apparaît " + variable_int + " fois.") ``` Se remplace bien par : ```py print(f"La lettre {variable_str} apparaît {variable_int} fois.") ``` Le `%s` c'est un peu démodé face au f-string, franchement. ## Listes de compréhension Pour peupler une liste avec des formules, on peut faire du standard : ```py liste = [] for i in range(5) liste.append(i) print(liste) # [0, 1, 2, 3, 4] ``` Ou, une liste compréhensive, contenant l'algo de base amenant le résultat : ```py liste = [i for i in range(5)] print(liste) # [0, 1, 2, 3, 4] ``` Et même inclure des conditions : ```py liste = [i for i in range(5) if i % 2 == 0] print(liste) # [0, 2, 4] ```