[PYTHON] 100 Amateur-Sprachverarbeitungsklopfen: 02

Es ist ein Herausforderungsrekord von 100 Sprachverarbeitungsklopfen 2015. Klicken Sie hier für eine Liste (http://qiita.com/segavvy/items/fb50ba8097d59475f760).

Umwelt verändert sich wieder

Ich habe bisher nur zwei Fragen gestellt, mich aber entschlossen, die Umgebung erneut zu ändern. Ändern Sie Python in 3.x.

Ich habe gezögert, Python 3.x zu installieren, da dies ein Problem zu sein schien, aber ich habe _ha1f gebeten, mir Anaconda in Vorherige Frage mitzuteilen. Ich könnte es leicht machen 3.5.2. Vielen Dank!

Anaconda ist wie eine Auswahl häufig verwendeter Pakete. Sie können viele Erklärungen von Google finden, aber für die Installation ist [Installieren von Python mit Anaconda (Ubuntu Linux)](http://pythondatascience.plavox.info/ Installieren von Python / anaconda-ubuntu-linux /) leicht zu verstehen. Es war.

Kapitel 1: Vorbereitende Bewegung

02. "Pat car" + "Tax" = "Patatokukasie"

Erhalten Sie die Zeichenkette "Patatokukashi", indem Sie die Zeichen "Pattocar" + "Tax" von Anfang an abwechselnd verbinden.

Der fertige Code:

main.py


# coding: utf-8
target1 = 'Pat Auto'
target2 = 'Taxi'
result = ''
for (a, b) in zip(target1, target2):
	result += a + b
print(result)

main2.py


# coding: utf-8
from functools import reduce

target1 = 'Pat Auto'
target2 = 'Taxi'
result = ''.join(reduce(lambda x, y: x + y, zip(target1, target2)))
print(result)

Ausführungsergebnis:

Terminal


Patatoku Kashii

Über zip () unditertools.zip_longest ()

zip () erstellt eine Liste von Elementen aus mehreren iterablen Elementen (Listen, Taples usw.). Python ist erstaunlich, eine so nützliche Funktion zu haben!

Ich werde verschiedene Dinge ausprobieren.

Dolmetscher


>>> target1 = 'abcde'
>>> target2 = '12345'
>>> zip(target1, target2)
<zip object at 0x7f1294d76108>

Das? Hattest du ein Zip-Objekt?

Als ich es nachgeschlagen habe, hat Python 2.x anscheinend eine Liste zurückgegeben, aber 3.x hat einen Iterator zurückgegeben. Es ist möglicherweise effizienter geworden, als es nach und nach von vorne mit der Verarbeitung begann (es scheint, dass dies als Generator bezeichnet wird). Achten Sie immer auf die Version, wenn Sie sich die Python-Dokumentation und den Kommentar ansehen!

Da es sich um einen Iterator handelt, können Sie den Inhalt überprüfen, indem Sie ihn in eine Liste konvertieren.

Dolmetscher 1


>>> target1 = 'abcde'
>>> target2 = '12345'
>>> res_zip = zip(target1, target2)
>>> list(res_zip)
[('a', '1'), ('b', '2'), ('c', '3'), ('d', '4'), ('e', '5')]

Jedes Element wird einzeln abgerufen und in einen Taple verpackt. Dies ist der Fluss des Herausnehmens nacheinander.

Wenn die ursprüngliche Anzahl der Elemente unterschiedlich ist, wird sie an die kleinere angepasst.

Dolmetscher 2


>>> target1 = 'abc'
>>> target2 = '12345'
>>> res_zip = zip(target1, target2)
>>> list(res_zip)
[('a', '1'), ('b', '2'), ('c', '3')]

Wenn Sie mit dem längeren übereinstimmen möchten, können Sie itertools.zip_longest () verwenden.

Dolmetscher 3


>>> import itertools
>>> res_zip = itertools.zip_longest(target1, target2)
>>> list(res_zip)
[('a', '1'), ('b', '2'), ('c', '3'), (None, '4'), (None, '5')]

Wenn nicht genügend Elemente vorhanden sind, wird Keine eingegeben, Sie können es jedoch auch angeben.

Dolmetscher 4


>>> res_zip = itertools.zip_longest(target1, target2, fillvalue = 'zzz')
>>> list(res_zip)
[('a', '1'), ('b', '2'), ('c', '3'), ('zzz', '4'), ('zzz', '5')]

Es ist ein Chaos.

Gehen Sie zurück zu "zip ()" und versuchen Sie, drei oder mehr zusammenzuhalten.

Dolmetscher 5


>>> target1 = 'abcde'
>>> target2 = '12345'
>>> target3 = 'AIUEO'
>>> res_zip = zip(target1, target2, target3)
>>> list(res_zip)
[('a', '1', 'Ah'), ('b', '2', 'ich'), ('c', '3', 'U.'), ('d', '4', 'e'), ('e', '5', 'Oh')]

Das Ergebnis ist wie erwartet.

Gibt das Ergebnis von zip () zurück

Wenn Sie das Ergebnis von "zip ()" erneut an "zip ()" übergeben, können Sie es zurückerhalten. Verwenden Sie zuerst "zip ()", um 3 Listen zu übergeben und 5 Taples zu erstellen.

Dolmetscher 6


>>> target1 = 'abcde'
>>> target2 = '12345'
>>> target3 = 'AIUEO'
>>> res_zip = zip(target1, target2, target3)
>>> list(res_zip)
[('a', '1', 'Ah'), ('b', '2', 'ich'), ('c', '3', 'U.'), ('d', '4', 'e'), ('e', '5', 'Oh')]

Wenn Sie diese 5 Taples erneut an "zip ()" übergeben, nehmen Sie dieses Mal jedes Element aus den 5 Taples, um einen Taple zu erstellen, und kehren zu den ursprünglichen drei zurück. Das war's!

Dolmetscher 7


>>> res_zip = zip(target1, target2, target3)
>>> res_list = list(res_zip)
>>> res2_zip = zip(res_list[0], res_list[1], res_list[2], res_list[3], res_list[4])
>>> list(res2_zip)
[('a', 'b', 'c', 'd', 'e'), ('1', '2', '3', '4', '5'), ('Ah', 'ich', 'U.', 'e', 'Oh')]

kam zurück! Es ist ein Taple anstelle eines Strings, aber wie man es zurückgibt, wird später beschrieben.

Das Argument von "zip ()" ist variabel, aber wenn Sie \ * vor dem iterablen hinzufügen, wird es in die Argumente getrennt. Daher müssen Sie nicht "res_list [0], res_list [1] ..." einzeln schreiben, sondern können "* res_list" verwenden. Praktisch!

Dolmetscher 8


>>> res_zip = zip(target1, target2, target3)
>>> res_list = list(res_zip)
>>> res2_zip = zip(*res_list)
>>> list(res2_zip)
[('a', 'b', 'c', 'd', 'e'), ('1', '2', '3', '4', '5'), ('Ah', 'ich', 'U.', 'e', 'Oh')]

Stellen Sie den Taple wieder auf die Zeichenfolge

Dolmetscher 9


>>> chars_tuple = ('a', 'b', 'c', 'd', 'e')
>>> ''.join(chars_tuple)
'abcde'

Über functools.reduce ()

Dolmetscher 10


>>> def add(x, y):
...     return x + y
... 
>>> import functools
>>> functools.reduce(add, [1, 2, 3, 4, 5])
15

functools.reduce () übergibt das vorherige Ergebnis und den von der Iterable übernommenen Wert an die Funktion, um ein neues Ergebnis zu erstellen, das bis zum Ende der Iterable wiederholt wird. Die functools.reduce (add, [1, 2, 3, 4, 5]) im obigen Beispiel führt ungefähr den folgenden Code aus.

Dolmetscher 11


>>> result = 0
>>> for x in [1, 2, 3, 4, 5]:
...     result = add(result, x)
... 
>>> result
15

Der Anfangswert des Ergebnisses, das "result = 0" entspricht, kann durch das dritte Argument von "functools.reduce ()" angegeben werden. Wenn nicht angegeben, werden zwei nur zum ersten Mal aus dem Iterable extrahiert, und das Ergebnis der Übergabe an die Funktion wird als Anfangswert verwendet.

Im zweiten Lösungsbeispiel "main2.py" wird im Funktionsteil der Lambda-Ausdruck "Lambda x, y: x + y" angegeben. Für den Lambda-Ausdruck klopft [100 Amateur-Sprachverarbeitung: 18](https://qiita.com/segavvy/items/adee520db1a257e347d5#%E3%83%A9%E3%83%A0%E3%83%80%E5 % BC% 8F) erklärt ein wenig, also beziehen Sie sich bitte darauf.

Ich war süchtig nach dem Zustandsübergang des Iterators

Was mich zu dieser Zeit süchtig machte, war, dass der Iterator nach seiner Konvertierung in eine Liste nicht mehr verwendet werden konnte (der erweiterte Iterator kann nicht zurückgesetzt werden).

Wenn Sie beispielsweise Interpreter 7 unmittelbar nach dem Ausführen von Interpreter 6 oben ausführen, erscheint die erste Zeile von Interpreter 7 "res_zip = zip (target1, target2, target3)" auf den ersten Blick unnötig. Es läuft bereits in Zeile 4 von Interpreter 6. Wenn Sie jedoch in eine Liste mit der 5. Zeile "list (res_zip)" von Interpreter 6 konvertieren, wird der Iterator von res_zip weiterentwickelt. Selbst wenn Sie "list (res_zip)" erneut verwenden, handelt es sich um eine leere Liste.

Wenn Sie an Python gewöhnt sind, können Sie sich natürlich um den Zustandsübergang des Iterators kümmern, aber ich war eine Weile süchtig danach, ohne es zu merken.   Das ist alles für den dritten Schlag. Wenn Sie Fehler haben, würde ich mich freuen, wenn Sie darauf hinweisen könnten.

Recommended Posts

100 Amateur-Sprachverarbeitungsklopfen: 41
100 Amateur-Sprachverarbeitungsklopfen: 56
100 Amateur-Sprachverarbeitungsklopfen: 24
100 Amateur-Sprachverarbeitungsklopfen: 50
100 Amateur-Sprachverarbeitungsklopfen: 59
100 Amateur-Sprachverarbeitungsklopfen: 70
100 Amateur-Sprachverarbeitungsklopfen: 62
100 Amateur-Sprachverarbeitungsklopfen: 92
100 Amateur-Sprachverarbeitungsklopfen: 06
100 Amateur-Sprachverarbeitungsklopfen: 81
100 Amateur-Sprachverarbeitungsklopfen: 46
100 Amateur-Sprachverarbeitungsklopfen: 88
100 Amateur-Sprachverarbeitungsklopfen: 89
100 Amateur-Sprachverarbeitungsklopfen: 43
100 Amateur-Sprachverarbeitungsklopfen: 55
100 Amateur-Sprachverarbeitungsklopfen: 94
100 Amateur-Sprachverarbeitungsklopfen: 54
100 Amateur-Sprachverarbeitungsklopfen: 63
100 Amateur-Sprachverarbeitungsklopfen: 78
100 Amateur-Sprachverarbeitungsklopfen: 12
100 Amateur-Sprachverarbeitungsklopfen: 14
100 Amateur-Sprachverarbeitungsklopfen: 08
100 Amateur-Sprachverarbeitungsklopfen: 42
100 Amateur-Sprachverarbeitungsklopfen: 73
100 Amateur-Sprachverarbeitungsklopfen: 75
100 Amateur-Sprachverarbeitungsklopfen: 98
100 Amateur-Sprachverarbeitungsklopfen: 83
100 Amateur-Sprachverarbeitungsklopfen: 95
100 Amateur-Sprachverarbeitungsklopfen: 32
100 Amateur-Sprachverarbeitungsklopfen: 96
100 Amateur-Sprachverarbeitungsklopfen: 87
100 Amateur-Sprachverarbeitungsklopfen: 72
100 Amateur-Sprachverarbeitungsklopfen: 79
100 Amateur-Sprachverarbeitungsklopfen: 05
100 Amateur-Sprachverarbeitungsklopfen: 00
100 Amateur-Sprachverarbeitungsklopfen: 02
100 Amateur-Sprachverarbeitungsklopfen: 37
100 Amateur-Sprachverarbeitungsklopfen: 21
100 Amateur-Sprachverarbeitungsklopfen: 68
100 Amateur-Sprachverarbeitungsklopfen: 11
100 Amateur-Sprachverarbeitungsklopfen: 90
100 Amateur-Sprachverarbeitungsklopfen: 74
100 Amateur-Sprachverarbeitungsklopfen: 66
100 Amateur-Sprachverarbeitungsklopfen: 28
100 Amateur-Sprachverarbeitungsklopfen: 64
100 Amateur-Sprachverarbeitungsklopfen: 34
100 Amateur-Sprachverarbeitungsklopfen: 36
100 Amateur-Sprachverarbeitungsklopfen: 77
100 Amateur-Sprachverarbeitungsklopfen: 01
100 Amateur-Sprachverarbeitungsklopfen: 16
100 Amateur-Sprachverarbeitungsklopfen: 27
100 Amateur-Sprachverarbeitungsklopfen: 10
100 Amateur-Sprachverarbeitungsklopfen: 03
100 Amateur-Sprachverarbeitungsklopfen: 82
100 Amateur-Sprachverarbeitungsklopfen: 69
100 Amateur-Sprachverarbeitungsklopfen: 53
100 Amateur-Sprachverarbeitungsklopfen: 18
100 Amateur-Sprachverarbeitungsklopfen: 35
100 Amateur-Sprachverarbeitungsklopfen: 91
100 Amateur-Sprachverarbeitungsklopfen: 15
100 Amateur-Sprachverarbeitungsklopfen: 38