DESCRIPTION.

Retourne un objet iterateur généré en exécutant une fonction pour chaque élément d'un itérable.

SYNTAXE.

TRT_Collection = map ( fonction , iterable )

TRT_Collection = ⇨ variable qui recevra la collection [ optionnel ]

map ( ) ⇨ appel de la méthode [ OBLIGATOIRE ]

fonction ⇨ fonction à exécuter [ OBLIGATOIRE ]

iterable ⇨ itérable à parcourir [ optionnel ]

REMARQUES.

fonction peut être : une fonction personnalisée ou méthode. C'est la valeur retournée, par le traitement de l'élément par fonction, qui sera inséré dans l'itérateur.

iterable doit être un objet collection, ou séquence, tel que : range ( ), list ( ), tuple ( ), bytes ( ) ou bytearray ( ).

map ( ) est maintenant devenue peu usité avec l'apparition des compréhensions de listes, plus simples et intuitives. Voir la fonction list ( ) pour plus de détails sur les compréhensions de listes.

map ( ) s'utilise, le plus souvent, en association avec la fonction filter ( ) (et reduce ( ) du module functools)

map ( ) donne un itérateur en appliquant fonction à chaque élément de iterable, et donnant ses résultats au fur et à mesure avec yield.

Si d'autres iterable sont fournis, fonction doit prendre autant d'arguments, et sera appelée avec les éléments de tous les iterable en parallèle. Avec plusieurs iterable, l'itération s'arrête avec iterable le plus court. 

EXEMPLES.

Depart = input ( "Indiquez l'heure de départ (hh:mm:ss) ..." )

Arrivee = input ( "indiquez l'heure d'arrivée (hh:mm:ss) ..." )

kheured , kminuted , kseconded = map ( int , Depart.split ( ":" ) )

kheurea , kminutea , ksecondea = map ( int , Arrivee.split ( ":" ) )

kdepart = ( kheured * 3600 ) + ( kminuted * 60 ) + kseconded

karrivee = ( kheurea * 3600 ) + ( kminutea * 60 ) + ksecondea

kduree = karrivee - kdepart

print ( f"Votre trajet à durée : { kduree } secondes." )

kheures = kduree // 3600

kminutes = (kduree - ( kheures * 3600 ) ) // 60

ksecondes = kduree - ( kheures * 3600 ) - ( kminutes * 60 )

print ( f"Soit : { kheures } heures , { kminutes } minutes et { ksecondes } secondes." )

retourne

Indiquez l'heure de départ (hh:mm:ss) ...10:23:12

indiquez l'heure d'arrivée (hh:mm:ss) ...14:37:21

Votre trajet à durée : 15249 secondes.

Soit : 4 heures , 14 minutes et 9 secondes.

TPL_Chiffres = ( 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 )

def FNC_Carre ( Q ) :

return Q * Q

TRT_Carres = map ( FNC_Carre  , TPL_Chiffres )

print ( TRT_Carres )

print ( )

TPL_Carres = tuple ( map ( FNC_Carre  , TPL_Chiffres ) )

print ( )

print ( TPL_Carres )

print ( )

for kcarre in TRT_Carres :

print ( f"La racine carrée de { kcarre } est { kcarre ** .5 }." )

retourne :

<map object at 0x0000022018806890>

(1, 4, 9, 16, 25, 36, 49, 64, 81)

La racine carrée de 1 est 1.0.

La racine carrée de 4 est 2.0.

La racine carrée de 9 est 3.0.

La racine carrée de 16 est 4.0.

La racine carrée de 25 est 5.0.

La racine carrée de 36 est 6.0.

La racine carrée de 49 est 7.0.

La racine carrée de 64 est 8.0.

La racine carrée de 81 est 9.0.

Lors du premier appel (TRT_Carres = map ( FNC_Carre  , TPL_Chiffres )) c'est un itérable qui est retourné. La fonction ( FNC_Carre ) ne sera réalisée que lors de l'utilisation de cet itérable (ici dans la boucle).

Lors du second appel (TPL_Carres = tuple ( map ( FNC_Carre  , TPL_Chiffres ) )) c'est un objet collection (tuple ( )) qui est retourné. La fonction ( FNC_Carre ) est appelée pour chaque éléments de l'itérateur fournis en deuxième argument.

TPL_Chiffres = ( 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 )

TPL_Carres = tuple ( map ( lambda kchiffre : kchiffre ** 2 , TPL_Chiffres ) )

print ( TPL_Carres )

retourne :

(1, 4, 9, 16, 25, 36, 49, 64, 81)

TPL_Chiffres = ( 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 )

TPL_Premiers = ( 1 , 2 , 3 , 5 , 7 )

TPL_TestA = tuple ( map ( lambda kchiffre , kpremier : kchiffre * kpremier , TPL_Chiffres , TPL_Premiers ) )

print ( TPL_TestA )

TPL_TestB = tuple ( map ( lambda kpremier , kchiffre : kpremier * kchiffre , TPL_Chiffres , TPL_Premiers ) )

print ( TPL_TestB )

TPL_TestC = tuple ( map ( lambda kchiffre , kpremier : kpremier * kchiffre , TPL_Chiffres , TPL_Premiers ) )

print ( TPL_TestB )

TPL_TestD = tuple ( map ( lambda kchiffre , kpremier : kchiffre * 2 , TPL_Chiffres , TPL_Premiers ) )

print ( TPL_TestD )

TPL_TestE = tuple ( map ( lambda kchiffre , kpremier : ( kpremier , kchiffre ) , TPL_Chiffres , TPL_Premiers ) )

print ( TPL_TestE )

TPL_TestF = tuple ( map ( lambda kchiffre , kpremier : f"{ kchiffre }. Le carré de { kpremier } est { kpremier ** 2 }." , TPL_Chiffres , TPL_Premiers ) )

print ( TPL_TestF )

retourne :

(1, 4, 9, 20, 35)

(1, 4, 9, 20, 35)

(1, 4, 9, 20, 35)

(2, 4, 6, 8, 10)

((1, 1), (2, 2), (3, 3), (5, 4), (7, 5))

('1. Le carré de 1 est 1.', '2. Le carré de 2 est 4.', '3. Le carré de 3 est 9.', '4. Le carré de 5 est 25.', '5. Le carré de 7 est 49.')

TPL_Chiffres = ( 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 )

TPL_Voyelles = ( "A" , "E" , "I" , "O" , "U"  , "Y" )

TPL_Jours = ( "Lundi" , "Mardi" , "Jeudi" , "Vendredi" , "Samedi"  , "Dimanche" )

TPL_Fruits = ( "Pomme" , "Poire" , "Cerise" , "Fraise" , "Orange"  , "Kiwi"  , "Banane" , "Framboise"  , "Myrtille" )

def FNC_Test ( *Q ) :

kanalyse = [ Q [ 0 ] ]

if Q [ 0 ] % 2 == 0 : kanalyse.append ( Q [ 1 ] )

if Q [ 0 ] % 3 == 0 : kanalyse.append ( Q [ 2 ] )

if Q [ 0 ] % 2.5 == 0 : kanalyse.append ( Q [ 3 ] )

print ( Q , "retourne" , kanalyse )

return kanalyse

TPL_Test = tuple ( map ( FNC_Test  , TPL_Chiffres , TPL_Voyelles , TPL_Jours , TPL_Fruits ) )

print ( )

print ( TPL_Test )

retourne :

(0, 'A', 'Lundi', 'Pomme') retourne [0, 'A', 'Lundi', 'Pomme']

(1, 'E', 'Mardi', 'Poire') retourne [1]

(2, 'I', 'Jeudi', 'Cerise') retourne [2, 'I']

(3, 'O', 'Vendredi', 'Fraise') retourne [3, 'Vendredi']

(4, 'U', 'Samedi', 'Orange') retourne [4, 'U']

(5, 'Y', 'Dimanche', 'Kiwi') retourne [5, 'Kiwi']

([0, 'A', 'Lundi', 'Pomme'], [1], [2, 'I'], [3, 'Vendredi'], [4, 'U'], [5, 'Kiwi'])