[Python] Utilisation correcte de la carte

introduction

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)

Reconnaissance fraîchement apprise

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)

Recevoir un objet (itérable) qui peut être un itérateur

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

Type de générateur

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

objet de carte

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

objet de fichier

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.

une fonction

? map(function, iterable)

Fonction propriétaire

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]

Fonction qui accepte plusieurs arguments

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

Pas seulement des fonctions

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.

Résumé

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

[Python] Utilisation correcte de la carte
[Python] Utilisation correcte de la jointure
[python] Utilisation correcte de l'instruction if
Utilisation des locaux Python ()
Exemple d'utilisation de pickle Python
Utilisation basique de la f-string Python
Les bases de Python ①
Bases de python ①
Copie de python
Utilisation d'opérateurs non logiques de ou en python
Introduction de Python
Comparez la vitesse d'ajout et de carte Python
[Python] Type de classe et utilisation du module datetime
[Introduction à Python] Utilisation de base des expressions lambda
[Python] Opération d'énumération
Unification de l'environnement Python
Copie des préférences python
Principes de base du grattage Python
Résumé de l'utilisation de pyenv
Utilisation basique de flask-classy
[python] comportement d'argmax
Utilisation de base de Jinja2
Ruby, Python et carte
le zen de Python
notes d'utilisation du décorateur python
Utilisation de base de SQL Alchemy
Installation de Python 3.3 rc1
# 4 [python] Bases des fonctions
Connaissance de base de Python
Anecdotes sobres de python3
Résumé des arguments Python
Bases de python: sortie
Installation de matplotlib (Python 3.3.2)
Application de Python 3 vars
Divers traitements de Python
Python - Explication et résumé de l'utilisation des 24 meilleurs packages
[Introduction à Python] Utilisation basique de la bibliothèque matplotlib
Utilisation super basique de pytest
Vers la retraite de Python2
résumé lié à l'opération de fichier python
Résumé des opérations de liste Python3
Utilisation de plusieurs versions de Python sur Mac OS X (2) Utilisation
Python - Démarrage rapide de la journalisation
Recommandation de la bibliothèque binpacking de python
Utilisation de base de l'interface graphique PySimple
[python] Valeur de l'objet fonction (?)
Remarques sur l'utilisation du test unittest standard Python
Création d'un environnement de développement local Python, partie 2 (pyenv-virtualenv, utilisation de pip)
python * args, ** kwargs Notes d'utilisation
Mise à jour automatique du module Python
Python - Vérifiez le type de valeurs
[Python] L'origine du nom de la fonction python
Analyse statique des programmes Python
À propos de divers encodages de Python 3
Jugement d'équivalence d'objet en Python
Résumé d'utilisation pratique de Flask
Introduction d'activités appliquant Python
python> Gestion des tableaux 2D