Wenn Sie die Karte zum ersten Mal berühren, werden Sie sich fragen: "Ist die Definition so?"
map(function, list)
Das ist aber richtig.
map(callable, *iterable)
Ich werde diese wahre Bedeutung auf leicht verständliche Weise erklären, während ich "map (function, list)" gestalte.
Fügen Sie der Definition während der Formatierung ein? Mark hinzu
? map(function, list)
Wenn Sie ein Objekt verwenden möchten, das für jedes Listenelement eine bestimmte Verarbeitung durchlaufen hat, verwenden Sie die Kartenfunktion. Der Rückgabewert ist ein Kartenobjekt, das eine Art Iterator ist. Ein Iterator ist ein Objekt, das mit einer for-Anweisung gedreht werden kann. Das Kartenobjekt ist keine Liste.
>>> iterable = map(int, ["1", "2", "3", "4", "5"])
>>> for i in iterable:
... print(i)
...
1
2
3
4
5
Ist die Definition so?
? map(function, list)
Nein, das zweite Argument nimmt tatsächlich eine Iterable an (ein Objekt, das ein Iterator sein kann). Mit anderen Worten, alles, was mit einer ** for-Anweisung ** gedreht werden kann, kann als Argument empfangen werden. Natürlich ist der Iterator selbst iterierbar.
? map(function, iterable)
Mach dir keine Sorgen, iterable und iterator sind etwas anders.
Iterable kann verwendet werden, um das nächste Element mit der Funktion next zu extrahieren, und iterable kann mit der Funktion iter in einen Iterator konvertiert werden. Beispielsweise kann das Listenobjekt von der nächsten Funktion nicht aus dem ersten Element extrahiert werden, es kann jedoch von der Iterationsfunktion in einen Iterator (list_iterator) konvertiert werden. Dann kann list_iterator mit der nächsten Funktion das nächste Element abrufen.
a = [100, 200, 300]
# next(a) <-Error!
a_iter = iter(a)
next(a_iter) #100 wird herausgenommen
Es gibt viele andere iterierbare Objekte als list. Das Folgende ist ein Beispiel.
tuple
Da das Tupel mit einer for-Anweisung gedreht werden kann, kann es als zweites Argument der Map-Funktion angegeben werden.
>>> list(map(int, ("1", "2", "3", "4", "5"))
[1, 2, 3, 4, 5]
dict
Der Schlüssel wird durch Drehen des Diktats mit der for-Anweisung herausgenommen. Wenn daher dict als zweites Argument der Map-Funktion angegeben wird, wird jeder Schlüssel zur Verarbeitung verwendet.
>>> list(map(lambda k: k+k, {"a": 2, "b": 3, "c": 5, "d": 7})
['aa', 'bb', 'cc', 'dd']
Wenn Sie sowohl den Schlüssel als auch den Wert abrufen möchten, verwenden Sie die Methode items von dict. Zu diesem Zeitpunkt wird das Tupel (sagen wir "x") von (Schlüssel, Wert) an die Funktion übergeben, die an das erste Argument der Map-Methode übergeben wird. Wenn Sie also den Schlüssel verwenden, verwenden Sie "x [0]", den Wert. In diesem Fall sollte es "x [1]" sein.
>>> list(map(lambda x: x[0]*x[1], {"a": 2, "b": 3, "c": 5, "d": 7}.items())
['aa', 'bbb', 'ccccc', 'ddddddd']
str
str kann auch mit einer for-Anweisung gedreht werden.
>>> "".join(map(lambda c: f'{c}"', 'Warum das'))
'Machen"U."Shi"Hand"Ist"Yo"Mm"Oh"'
Der Generatorausdruck ist ebenfalls ein Iterator, die Verwendung von map ist jedoch redundant. Es ist besser, alles in einer Generatorformel zu beschreiben.
Nicht gut
map(lambda x: 2*x, i*i for i in range(9))
Yoshi
(2*i*i for i in range(9))
Da das Kartenobjekt auch ein Iterator ist, kann es im zweiten Argument der Kartenmethode angegeben werden. Diese Methode ist jedoch wie die Generatorformel redundant. (Lesbarkeit kann gut sein)
python
map(bin, map(int, ["20","19","12","25"]))
python
map(lambda x: bin(int(x)), ["20","19","12","25"])
Das von der Funktion open erstellte Dateiobjekt ist auch ein Iterator. Wenn Sie es mit der for-Anweisung drehen, wird es zeilenweise als Zeichenfolge extrahiert.
script.txt
Vielen Dank
Vielen Dank
Was sind deine Hobbies?
Ein bisschen LISP...
Ri...？
>>> print(*map(lambda line: f"「{line.strip()}」", open("script.txt")), sep="\n")
"Vielen Dank"
"Vielen Dank"
"Was sind deine Hobbies?"
"Ein bisschen LISP...」
"Ri...？」
Es kann auf verschiedene andere Iterables angewendet werden.
? map(function, iterable)
Die durch das Schlüsselwort ** def ** definierte Funktion kann auch im ersten Argument angegeben werden, das function entspricht.
>>> def f(x):
... a = x
... # ...Tolle Verarbeitung
... # ...
... return a
>>> list(map(f, [1,2,3,4,5,6]))
[43248956, 613134354, 6435432, 543575356, 45457623, 243543566]
Sie können auch ** eine Funktion angeben, die mehrere Argumente ** als erstes Argument der Karte akzeptiert. In diesem Fall erhöht sich ** die an die Karte übergebene Iteration **.
? map(Funktion mit N Argumenten, iterable1, iterable2, ..., iterableN)
Zum Beispiel über die folgenden Funktionen, Liste
def f(first, second, third):
...
iterable1 = [100, 200, 300, 400]
iterable2 = ["a", "b", "c", "d"]
iterable3 = ["A", "B", "C", "D"]
Die folgende Tabelle zeigt die Aufrufe bei Verwendung der Kartenfunktion wie unten gezeigt.
map(f, iterable1, iterable2, iterable3)
| Bearbeitungsauftrag | iterable1 | iterable2 | iterable3 | Aufruf zur Funktion 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") |
Da eine beliebige Anzahl von Iterables empfangen wird, sind das zweite und die nachfolgenden Argumente von ** map Argumente mit variabler Länge **. Daher lautet die korrekte Beschreibung wie folgt.
? map(function, *iterable)
Beispiele für die tatsächliche Verwendung sind die Bedienermodule "add" und "mul".
add ist eine Funktion von" + ".
>>> add(2, 3)
5
mul ist eine Funktion von" * ".
>>> mul(4, 5)
20
Da mul eine Funktion ist, die ** zwei Argumente ** empfängt, bereiten Sie bei Verwendung der Map-Funktion zwei ** Iterables ** vor.
>>> from operator import mul
>>> list(map(mul, [1,2,3,4,5], [5,4,3,2,1]))
[5, 8, 9, 8, 5]
Das innere Produkt kann auch klar beschrieben werden.
>>> sum(map(mul, [1,2,3,4,5], [5,4,3,2,1]))
35
Nicht nur ** Funktionen können als erstes Argument übergeben werden **. ** Jedes aufrufbare Objekt ** ist in Ordnung. ** Aufrufbare Objekte sind solche, die mit "Klammern ()" aufgerufen werden können **.
? map(callable, *iterable)
Ein weiteres typisches Beispiel für eine Funktion ist ** Klasse **. Da die definierte ** Klasse selbst auch ein aufrufbares Objekt ** ist, kann sie als erstes Argument der Karte angegeben werden.
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')
Wenn Sie mehrere Argumente im Konstruktor erhalten möchten, können Sie natürlich die Iterable für diesen Betrag angeben.
Dies ist abgeschlossen.
Die Definition der Kartenfunktion lautet wie folgt.
map(callable, *iterable)
Das erste Argument ist ** ein aufrufbares Objekt (Funktion oder Klasse) mit einem oder mehreren Argumenten **
Geben Sie nach dem zweiten Argument ** iterierbare Objekte (Objekte, die Iteratoren wie list sein können) für die Anzahl der Argumente an, die für den Aufruf des ersten Arguments erforderlich sind **.
Recommended Posts