Lorsque vous toucherez la carte pour la première fois, vous vous demanderez: "La définition est-elle comme celle-ci?"
map(function, list)
Mais c'est correct.
map(callable, *iterable)
J'expliquerai ce vrai sens d'une manière facile à comprendre tout en façonnant map (fonction, liste).
Ajouter une marque? À la définition au milieu de la mise en forme
? map(function, list)
Si vous souhaitez utiliser une chose qui a subi un certain traitement pour chaque élément de la liste, utilisez la fonction map. La valeur de retour est un objet de carte, qui est une sorte d'itérateur. Un itérateur est un objet qui peut être tourné avec une instruction for. L'objet de la carte n'est pas une liste.
>>> iterable = map(int, ["1", "2", "3", "4", "5"])
>>> for i in iterable:
... print(i)
...
1
2
3
4
5
Est-ce que la définition est comme ça?
? map(function, list)
Non, le deuxième argument prend en fait un itérable (un objet qui peut être un itérateur). En d'autres termes, tout ce qui peut être tourné avec une instruction ** for ** peut être reçu comme argument. Bien sûr, l'itérateur lui-même est itérable.
? map(function, iterable)
Ne vous inquiétez pas trop, l'itérateur et l'itérateur sont un peu différents.
Les itérables peuvent être utilisés pour extraire l'élément suivant à l'aide de la fonction suivante, et les itérables peuvent être convertis en itérateur à l'aide de la fonction iter. Par exemple, l'objet liste ne peut pas être extrait du premier élément par la fonction suivante, mais il peut être converti en itérateur (list_iterator) par la fonction iter. Ensuite, list_iterator peut récupérer l'élément suivant en utilisant la fonction suivante.
a = [100, 200, 300]
# next(a) <-Erreur!
a_iter = iter(a)
next(a_iter) #100 est sorti
Il existe de nombreux objets itérables autres que list. Ce qui suit est un exemple.
tuple
Étant donné que le tuple peut être tourné avec une instruction for, il peut être spécifié comme deuxième argument de la fonction map.
>>> list(map(int, ("1", "2", "3", "4", "5"))
[1, 2, 3, 4, 5]
dict
La clé est retirée en tournant dict avec l'instruction for. Par conséquent, si dict est spécifié comme deuxième argument de la fonction map, chaque clé sera utilisée pour le traitement.
>>> list(map(lambda k: k+k, {"a": 2, "b": 3, "c": 5, "d": 7})
['aa', 'bb', 'cc', 'dd']
Si vous souhaitez récupérer à la fois la clé et la valeur, utilisez la méthode items de dict. À ce moment-là, le tuple (disons x) de (clé, valeur) est passé à la fonction passée au premier argument de la méthode map, donc lors de l'utilisation de la clé, utilisez x [0], la valeur Dans ce cas, il devrait être «x [1]».
>>> list(map(lambda x: x[0]*x[1], {"a": 2, "b": 3, "c": 5, "d": 7}.items())
['aa', 'bbb', 'ccccc', 'ddddddd']
str
str peut également être tourné avec une instruction for.
>>> "".join(map(lambda c: f'{c}"', 'Pourquoi donc'))
'Faire"U"Shi"main"Est"Yo"Mm"Oh"'
L'expression du générateur est également un itérateur, mais l'utilisation de map est redondante. Il est préférable de tout décrire dans une formule génératrice.
Pas bien
map(lambda x: 2*x, i*i for i in range(9))
Yoshi
(2*i*i for i in range(9))
Étant donné que l'objet map est également un itérateur, il peut être spécifié dans le deuxième argument de la méthode map. Cependant, comme la formule du générateur, cette méthode est redondante. (La lisibilité peut être bonne)
python
map(bin, map(int, ["20","19","12","25"]))
python
map(lambda x: bin(int(x)), ["20","19","12","25"])
L'objet fichier créé par la fonction open est également un itérateur. Si vous le tournez avec l'instruction for, il sera extrait sous forme de chaîne de caractères ligne par ligne.
script.txt
Merci
Merci
Quels sont vos hobbies?
Un peu de LISP...
Ri...？
>>> print(*map(lambda line: f"「{line.strip()}」", open("script.txt")), sep="\n")
"Merci"
"Merci"
"Quels sont vos hobbies?"
"Un petit LISP...」
"Ri...？」
Il peut être appliqué à divers autres itérables.
? map(function, iterable)
La fonction définie par le ** mot-clé def ** peut également être spécifiée dans le premier argument correspondant à fonction.
>>> def f(x):
... a = x
... # ...Excellent traitement
... # ...
... return a
>>> list(map(f, [1,2,3,4,5,6]))
[43248956, 613134354, 6435432, 543575356, 45457623, 243543566]
Vous pouvez également spécifier ** une fonction qui accepte plusieurs arguments ** comme premier argument de map. Dans ce cas, ** l'itérable passé à la carte augmentera **.
? map(Fonction avec N arguments, iterable1, iterable2, ..., iterableN)
Par exemple, à propos des fonctions et de la liste suivantes
def f(first, second, third):
...
iterable1 = [100, 200, 300, 400]
iterable2 = ["a", "b", "c", "d"]
iterable3 = ["A", "B", "C", "D"]
Le tableau ci-dessous montre les appels lors de l'utilisation de la fonction de carte comme indiqué ci-dessous.
map(f, iterable1, iterable2, iterable3)
| Commande en traitement | iterable1 | iterable2 | iterable3 | Appel à la fonction f |
|---|---|---|---|---|
| 0 | 100 | "a" | "A" | f(100, "a", "A") |
| 1 | 200 | "b" | "B" | f(200, "b", "B") |
| 2 | 300 | "c" | "C" | f(300, "c", "C") |
| 3 | 400 | "d" | "D" | f(400, "d", "D") |
Puisque n'importe quel nombre d'itérables est reçu, le deuxième argument et les suivants de ** map sont des arguments de longueur variable **. Par conséquent, la description correcte est la suivante.
? map(function, *iterable)
Les modules d'opérateur ʻadd et mul` sont des exemples d'utilisation réelle.
ʻAjouter` est une fonction de "+".
>>> add(2, 3)
5
mul est une fonction de" * ".
>>> mul(4, 5)
20
Puisque mul est une fonction qui reçoit ** deux arguments **, préparez deux ** itérables ** lors de l'utilisation de la fonction map.
>>> from operator import mul
>>> list(map(mul, [1,2,3,4,5], [5,4,3,2,1]))
[5, 8, 9, 8, 5]
Le produit intérieur peut également être décrit clairement.
>>> sum(map(mul, [1,2,3,4,5], [5,4,3,2,1]))
35
Non seulement les ** fonctions peuvent être passées comme premier argument **. ** Tout objet appelable ** convient. ** Les objets appelables sont ceux qui peuvent être appelés avec "parenthèses ()" **.
? map(callable, *iterable)
Un autre exemple typique de fonction est ** class **. Comme la classe ** définie elle-même est également un objet appelable **, elle peut être spécifiée comme premier argument de map.
class Man:
def __init__(self, name):
self.name = name
def __repr__(self):
return f"Man('{self.name}')"
print(*map(Man, ["John", "Hideo", "Mitchell", "Chatarai"]))
# Man('John') Man('Hideo') Man('Mitchell') Man('Chatarai')
Bien sûr, si vous souhaitez recevoir plusieurs arguments dans le constructeur, vous pouvez spécifier l'itérable pour ce montant.
C'est tout ce qu'on peut en dire.
La définition de la fonction de carte est la suivante.
map(callable, *iterable)
Le premier argument est ** un objet appelable (fonction ou classe) avec un ou plusieurs arguments **
Après le deuxième argument, ** spécifiez un objet itérable (un objet qui peut être un itérateur tel que list) pour le nombre d'arguments requis par l'appelable du premier argument **.
Recommended Posts