[PYTHON] Versuchen Sie, die Probleme / Probleme des "Matrix-Programmierers" zu lösen (Kapitel 0-Funktion)

Einführung

Während ich dieses Buch lese, werde ich versuchen, die Probleme zu lösen.

• O'Reilly Japan - Prozessionsprogrammierer

Es ist nur Kapitel 0 und es fühlt sich an, als würde man Python neu studieren.

** Update 2017/01/04 **

Die Ausgabe von "[0.6 Lab: Python und Reverse Index --- Modul- und Kontrollstruktur](http://qiita.com/Suna/items/881ce264cffd3301a54f#06-Lab Python- und Reverse Index --- Modul- und Kontrollstruktur)" wurde hinzugefügt. tat.

Kapitel 0 Funktionen (und andere Hintergrundinformationen zu Mathematik und Computern)

0.5 Lab: Erste Schritte mit Python --- Sets, Listen, Wörterbücher, Einschlüsse

0.5.1 Einfache Formel

Herausforderung 0.5.1

Verwenden Sie Python, um herauszufinden, wie viele Sekunden pro Woche sind.

>>> 7 * 24 * 60 * 60
604800

Herausforderung 0.5.2

Verwenden Sie Python, um den Rest von 2304811 geteilt durch 47 zu finden. Verwenden Sie jedoch nicht% (Hinweis: Verwenden Sie //).

>>> 2304811 - (2304811 // 47) * 47
25

Herausforderung 0.5.3

Geben Sie einen Booleschen Ausdruck ein, um festzustellen, ob die Summe von 673 und 909 durch 3 teilbar ist.

>>> (643 + 909) % 3 == 0
False

0.5.2 Substitutionserklärung

0.5.3 Bedingter Ausdruck

Herausforderung 0.5.4

Ersetzen Sie x durch -9 und y durch 1/2. Sagen Sie den Wert der folgenden Formel voraus und geben Sie ihn ein, um die Vorhersage zu bestätigen. 2**(y+1/2) if x+10<0 else 2**(y-1/2)

Da x + 10 <0 falsch wird und der else-Teil 2 ** (y-1/2) ausgeführt wird, wird er zu "1".

>>> (lambda x, y: 2**(y+1/2) if x+10<0 else 2**(y-1/2))(-9, 1/2)
1

0,5,4 eingestellt

Herausforderung 0.5.5

Schreiben Sie eine inklusive Notation für die Menge {1, 2, 3, 4, 5}, die das Quadrat jeder Ganzzahl zurückgibt.

>>> {x * x for x in {1, 2, 3, 4, 5}}
set([16, 1, 4, 25, 9])

Herausforderung 0.5.6

Inklusive Notation für die Menge {0, 1, 2, 3, 4} mit jeder ganzen Zahl als Exponent von 2, dh 2 ^{0 </ sup>, 2 1 </ sup> Schreiben Sie etwas, das zurückgibt, 2 2 </ sup> usw.}

>>> {2**x for x in {0, 1, 2, 3, 4}}
set([8, 1, 2, 4, 16])

Herausforderung 0.5.7

Der Wert der vorherigen Einschlussnotation {x * y für x in {1, 2, 3} für y in {2, 3, 4}} besteht aus sieben Elementen. Ersetzen Sie {1, 2, 3} und {2, 3, 4} durch separate Sätze von drei Elementen, sodass ihre Werte ein Satz von neun Elementen sind.

>>> {x * y for x in {4, 5, 6} for y in {6, 7, 8}}
set([32, 35, 36, 40, 42, 48, 24, 28, 30])

Herausforderung 0.5.8

Ersetzen Sie die beiden Sätze {1, 2, 3} und {2, 3, 4} in der vorherigen Einschlussnotation durch verschiedene Sätze von drei Elementen, sodass das Ergebnis ein Satz von fünf Elementen ist. Es wird jedoch angenommen, dass die beiden zu ersetzenden Mengen elementar zueinander sind, dh die Elemente überlappen sich nicht.

>>> {x * y for x in {4, 5, 6} for y in {7, 8, 9} if x * y < 41}
set([32, 28, 35, 36, 40])

Herausforderung 0.5.9

Die Variablen S und T müssen eine Menge darstellen. Schreiben Sie eine Einschlussnotation für S, die den gemeinsamen Teil von S und T ohne den Operator & zurückgibt (Hinweis: Verwenden Sie einen Filter am Ende der Einschlussnotation und überprüfen Sie die Elemente). Probieren Sie die enthaltene Notation aus, die Sie mit S = {1, 2, 3, 4} und T = {3, 4, 5, 6} erstellt haben.

>>> {s for s in {1, 2, 3, 4} for t in {3, 4, 5, 6} if s == t}
set([3, 4])

0.5.5 Liste

Herausforderung 0.5.10

Schreiben Sie einen Ausdruck, dessen ausgewerteter Wert der Durchschnitt der Elemente in der Liste ist [20, 10, 15, 75].

>>> sum([20, 10, 15, 75]) / 4
30

Herausforderung 0.5.11

Schreiben Sie eine Listeneinschlussnotation für die Listen ['A', 'B', 'C'] und [1, 2, 3], deren Wert aus allen möglichen Kombinationen von [Buchstabe, Zahl] besteht. Das heißt, der Wert ist wie folgt. [['A', 1], ['A', 2], ['A', 3], ['B', 1], ['B', 2], ['B', 3], ['C', 1], ['C', 2], ['C', 3]]

>>> [[a, b] for a in ['A', 'B', 'C'] for b in [1, 2, 3]]
[['A', 1], ['A', 2], ['A', 3], ['B', 1], ['B', 2], ['B', 3], ['C', 1], ['C', 2], ['C', 3]]

Herausforderung 0.5.12

Angenommen, Sie weisen LofL eine Liste zu, deren Elemente eine Liste mit Zahlen enthalten. Schreiben Sie zu diesem Zeitpunkt eine Formel, um die Summe aller numerischen Werte in der Liste zu berechnen. Diese Formel hat die folgende Form und eine Einschlussnotation. sum([sum(... Setzen Sie [[0,25, 0,75, 0,1], [-1, 0], [4, 4, 4, 4]] in LofL ein und probieren Sie die von Ihnen erstellte Formel aus (Hinweis: Wie lang ist die von Ihnen erstellte Formel? Lass es auf der Liste von) funktionieren.

>>> sum([sum(x) for x in [[0.25, 0.75, 0.1], [-1, 0], [4, 4, 4, 4]]])
16.1

Herausforderung 0.5.13

Sehen Sie, was passiert, wenn die Länge der Liste auf der linken Seite nicht mit der Länge der Liste auf der rechten Seite übereinstimmt.

>>> [x, y, z] = [4*1, 4*2, 4*3, 4*4]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  ValueError: too many values to unpack

0,5,6 taple

Herausforderung 0.5.14

>>> S = {-4, -2, 1, 2, 5, 0}
>>> [(i, j, k) for i in S for j in S for k in S if i+j+k == 0]
[(0, 0, 0), (0, 2, -2), (0, -2, 2), (1, 1, -2), (1, -2, 1), (2, 0, -2), (2, 2, -4), (2, -4, 2), (2, -2, 0), (-4, 2, 2), (-2, 0, 2), (-2, 1, 1), (-2, 2, 0)]

>>> [(i, j, k) for i in S for j in S for k in S if i+j+k == 0 and (i != 0 or j != 0 or k != 0)]
[(0, 2, -2), (0, -2, 2), (1, 1, -2), (1, -2, 1), (2, 0, -2), (2, 2, -4), (2, -4, 2), (2, -2, 0), (-4, 2, 2), (-2, 0, 2), (-2, 1, 1), (-2, 2, 0)]

>>> [(i, j, k) for i in S for j in S for k in S if i+j+k == 0 and (i != 0 or j != 0 or k != 0)][0]
(0, 2, -2)

Übung 0.5.15> Ändern Sie die Einschlussnotation der vorherigen Frage so, dass die Ergebnisliste nicht (0, 0, 0) enthält (Hinweis: Fügen Sie einen Filter hinzu). Herausforderung 0.5.16> Ändern Sie die Formel weiter, sodass der Wert der Formel der erste Taple anstelle der vollständigen Liste der oben genannten Taples ist. Herausforderung 0.5.17> Finden Sie ein Beispiel für Liste L mit verschiedenen len (L) und len (Liste (set (L))).

>>> L = [1, 1, 2, 3]
>>> len(L)
4
>>> len(list(set(L)))
3

0.5.7 Andere iterative Verarbeitung

Herausforderung 0.5.18

Schreiben Sie eine Einschlussnotation, die eine ungerade Menge zwischen 1 und 99 für einen Bereich des Formularbereichs (n) zurückgibt.

>>> {x for x in range(100) if x % 2 == 1}
set([1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67, 69, 71, 73, 75, 77, 79, 81, 83, 85, 87, 89, 91, 93, 95, 97, 99])

Herausforderung 0.5.19

Ersetzen Sie eine Liste der ersten fünf Buchstaben des Alphabets durch L ['A', 'B', 'C', 'D', 'E']. Schreiben Sie einen Ausdruck mit L mit der folgenden Liste als Wert. [(0, 'A'), (1, 'B'), (2, 'C'), (3, 'D'), (4, 'E')] Reichweite und Reißverschluss können verwendet werden, die Einschlussnotation sollte jedoch nicht verwendet werden.

>>> L = ['A', 'B', 'C', 'D', 'E']
>>> zip(range(len(L)), L)
[(0, 'A'), (1, 'B'), (2, 'C'), (3, 'D'), (4, 'E')]

Herausforderung 0.5.20

Für die Listen [10, 25, 40] und [1, 15, 20] ist das erste Element die Summe von 10 und 1, das zweite Element die Summe von 25 und 15 und das dritte Element 40 und 20. Schreiben Sie eine inklusive Notation, deren Wert eine Liste ist, die die Summe von ist. Sie können zip verwenden, aber keine Liste.

>>> [sum(a) for a in zip([10, 25, 40], [1, 15, 20])]
[11, 40, 60]

0.5.8 Wörterbuch

Herausforderung 0.5.21

Sei dlist die Liste der Wörterbücher und k der Schlüssel, der allen dlist-Wörterbüchern gemeinsam ist. Schreiben Sie eine Listeneinschlussnotation so, dass das i-te Element der Wert ist, der dem Schlüssel k im i-ten Wörterbuch von dlist entspricht. Probieren Sie die enthaltene Notation aus, die Sie mit einigen Daten erstellt haben. Beispieldaten sind unten gezeigt.

dlist = [{'James':'Sean', 'director':'Terence'}, {'James':'Roger', 'director':'Lewis'}, {'James':'Pierce', 'director':'Roger'}] k = 'James'

>>> dlist = [{'James':'Sean', 'director':'Terence'}, {'James':'Roger', 'director':'Lewis'}, {'James':'Pierce', 'director':'Roger'}]
>>> k = 'James'
>>> [d[k] for d in dlist]
['Sean', 'Roger', 'Pierce']

Herausforderung 0.5.22

Ändern Sie die Einschlussnotation in Übung 0.5.21 so, dass einige Wörterbücher verarbeitet werden können, die kein k als Schlüssel haben. Das i-te Element dieser Einschlussliste ist der Wert, der dem Schlüssel entspricht, wenn das i-te Wörterbuch in der dliste den Schlüssel k enthält, oder "NICHT PRÄSENTIEREN", wenn der Schlüssel nicht enthalten ist. Machen Testen Sie die Einschlussnotation, die Sie für k = 'Blibo' und k = 'Frodo' erstellt haben, anhand der Liste im folgenden Wörterbuch.

dlist = [{'Blibo':'Ian', 'Frodo':'Elijah'}, {'Blibo':'Martin', 'Thorin':'Richard'}]

>>> dlist = [{'Blibo':'Ian', 'Frodo':'Elijah'}, {'Blibo':'Martin', 'Thorin':'Richard'}]
>>> k = 'Blibo'
>>> [d[k] if k in d else 'NOT PRESENT' for d in dlist]
['Ian', 'Martin']
>>> k = 'Frodo'
>>> [d[k] if k in d else 'NOT PRESENT' for d in dlist]
['Elijah', 'NOT PRESENT']

Herausforderung 0.5.23

Schreiben Sie eine Einschlussnotation, bei der es sich um ein Wörterbuch handelt, bei dem der Schlüssel eine Ganzzahl von 0 bis 99 ist und der Schlüsselwert das Quadrat des Schlüssels ist, wenn er anhand des Bereichs ausgewertet wird.

>>> {x:x*x for x in range(100)}
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81, 10: 100, 11: 121, 12: 144, 13: 169, 14: 196, 15: 225, 16: 256, 17: 289, 18: 324, 19: 361, 20: 400, 21: 441, 22: 484, 23: 529, 24: 576, 25: 625, 26: 676, 27: 729, 28: 784, 29: 841, 30: 900, 31: 961, 32: 1024, 33: 1089, 34: 1156, 35: 1225, 36: 1296, 37: 1369, 38: 1444, 39: 1521, 40: 1600, 41: 1681, 42: 1764, 43: 1849, 44: 1936, 45: 2025, 46: 2116, 47: 2209, 48: 2304, 49: 2401, 50: 2500, 51: 2601, 52: 2704, 53: 2809, 54: 2916, 55: 3025, 56: 3136, 57: 3249, 58: 3364, 59: 3481, 60: 3600, 61: 3721, 62: 3844, 63: 3969, 64: 4096, 65: 4225, 66: 4356, 67: 4489, 68: 4624, 69: 4761, 70: 4900, 71: 5041, 72: 5184, 73: 5329, 74: 5476, 75: 5625, 76: 5776, 77: 5929, 78: 6084, 79: 6241, 80: 6400, 81: 6561, 82: 6724, 83: 6889, 84: 7056, 85: 7225, 86: 7396, 87: 7569, 88: 7744, 89: 7921, 90: 8100, 91: 8281, 92: 8464, 93: 8649, 94: 8836, 95: 9025, 96: 9216, 97: 9409, 98: 9604, 99: 9801}

Herausforderung 0.5.24

Weisen Sie der Variablen D den entsprechenden Satz zu. Zum Beispiel ist D = {'rot', 'weiß', 'blau'}. Schreiben Sie eine inklusive Notation, die bei Auswertung ein Wörterbuch ist, das eine gleiche Funktion für D darstellt.

>>> D = {'red', 'white', 'blue'}
>>> {x:x for x in D}
{'blue': 'blue', 'white': 'white', 'red': 'red'}

――Ist das in Ordnung?

Herausforderung 0.5.25

Ein Wörterbuch, das die Variablen base = 10 und digits = set (range (base)) verwendet, um jede Ganzzahl von 0 bis 999 einer Liste von drei Ziffern zuzuordnen, die ihre jeweiligen Ziffern darstellen, wenn die Basis 10 ist. Schreiben Sie die Einschlussnotation.

{0: [0, 0, 0], 1: [0, 0, 1], 2: [0, 0, 2], 3: [0, 0, 3], ... 10: [0, 1, 0], 11: [0, 1, 1], 12: [0, 1, 2], ... 999: [9, 9, 9]}

Stellen Sie sicher, dass die von Ihnen erstellte Formel auf jedem Boden funktioniert. Wenn beispielsweise 2 der Basis und {0, 1} Ziffern zugewiesen sind, ist das Ergebnis wie folgt.

{0: [0, 0, 0], 1: [0, 0, 1], 2: [0, 1, 0], ..., 7: [1, 1, 1]}

>>> base = 10
>>> digits = set(range(base))
>>> {x:[x/(base**2)%base, x/(base**1)%base, x/(base**0)%base] for x in range(110)}
{0: [0, 0, 0], 1: [0, 0, 1], 2: [0, 0, 2], 3: [0, 0, 3], 4: [0, 0, 4], 5: [0, 0, 5], 6: [0, 0, 6], 7: [0, 0, 7], 8: [0, 0, 8], 9: [0, 0, 9], 10: [0, 1, 0], 11: [0, 1, 1], 12: [0, 1, 2], 13: [0, 1, 3], 14: [0, 1, 4], 15: [0, 1, 5], 16: [0, 1, 6], 17: [0, 1, 7], 18: [0, 1, 8], 19: [0, 1, 9], 20: [0, 2, 0], 21: [0, 2, 1], 22: [0, 2, 2], 23: [0, 2, 3], 24: [0, 2, 4], 25: [0, 2, 5], 26: [0, 2, 6], 27: [0, 2, 7], 28: [0, 2, 8], 29: [0, 2, 9], 30: [0, 3, 0], 31: [0, 3, 1], 32: [0, 3, 2], 33: [0, 3, 3], 34: [0, 3, 4], 35: [0, 3, 5], 36: [0, 3, 6], 37: [0, 3, 7], 38: [0, 3, 8], 39: [0, 3, 9], 40: [0, 4, 0], 41: [0, 4, 1], 42: [0, 4, 2], 43: [0, 4, 3], 44: [0, 4, 4], 45: [0, 4, 5], 46: [0, 4, 6], 47: [0, 4, 7], 48: [0, 4, 8], 49: [0, 4, 9], 50: [0, 5, 0], 51: [0, 5, 1], 52: [0, 5, 2], 53: [0, 5, 3], 54: [0, 5, 4], 55: [0, 5, 5], 56: [0, 5, 6], 57: [0, 5, 7], 58: [0, 5, 8], 59: [0, 5, 9], 60: [0, 6, 0], 61: [0, 6, 1], 62: [0, 6, 2], 63: [0, 6, 3], 64: [0, 6, 4], 65: [0, 6, 5], 66: [0, 6, 6], 67: [0, 6, 7], 68: [0, 6, 8], 69: [0, 6, 9], 70: [0, 7, 0], 71: [0, 7, 1], 72: [0, 7, 2], 73: [0, 7, 3], 74: [0, 7, 4], 75: [0, 7, 5], 76: [0, 7, 6], 77: [0, 7, 7], 78: [0, 7, 8], 79: [0, 7, 9], 80: [0, 8, 0], 81: [0, 8, 1], 82: [0, 8, 2], 83: [0, 8, 3], 84: [0, 8, 4], 85: [0, 8, 5], 86: [0, 8, 6], 87: [0, 8, 7], 88: [0, 8, 8], 89: [0, 8, 9], 90: [0, 9, 0], 91: [0, 9, 1], 92: [0, 9, 2], 93: [0, 9, 3], 94: [0, 9, 4], 95: [0, 9, 5], 96: [0, 9, 6], 97: [0, 9, 7], 98: [0, 9, 8], 99: [0, 9, 9], 100: [1, 0, 0], 101: [1, 0, 1], 102: [1, 0, 2], 103: [1, 0, 3], 104: [1, 0, 4], 105: [1, 0, 5], 106: [1, 0, 6], 107: [1, 0, 7], 108: [1, 0, 8], 109: [1, 0, 9]}

>>> base = 2
>>> {x:[x/(base**2)%base, x/(base**1)%base, x/(base**0)%base] for x in range(8)}
{0: [0, 0, 0], 1: [0, 0, 1], 2: [0, 1, 0], 3: [0, 1, 1], 4: [1, 0, 0], 5: [1, 0, 1], 6: [1, 1, 0], 7: [1, 1, 1]}

――Es dauert bis zu 999, also beeilen Sie sich bis zu 109.

• Sie verwenden keine Ziffern.

Herausforderung 0.5.26

Sei d ein Wörterbuch, das Mitarbeiternummern (ganze Zahlen zwischen 0 und n-1) dem Gehalt zuordnet. Angenommen, L ist eine Liste von n Elementen, wobei das i-te Element der Name des Mitarbeiters mit der Mitarbeiternummer i ist. Schreiben Sie die Einschlussnotation in das Wörterbuch, die den Namen des Mitarbeiters dem Gehalt zuordnet. Mitarbeiternamen können unterschiedlich angenommen werden. Testen Sie die enthaltene Notation, die Sie mit den folgenden Daten erstellt haben.

d = {0:1000.0, 3:990, 1:1200.50} L = ['Larry', 'Curly', '', 'Moe']

>>> d = {0:1000.0, 3:990, 1:1200.50}
>>> L = ['Larry', 'Curly', '', 'Moe']
>>> {L[k]:d[k] for k in d.keys()}
{'Larry': 1000.0, 'Moe': 990, 'Curly': 1200.5}

0.5.9 Definieren Sie eine einzeilige Prozedur

Herausforderung 0.5.27

Geben Sie die Definition von zweimal ein (z). Nach der Eingabe wird "..." angezeigt. Drücken Sie daher die Eingabetaste. Rufen Sie dann die Prozedur mit einigen tatsächlichen Argumenten auf. Es wäre interessant, es mit einer Zeichenfolge oder Liste zu versuchen. Bewerten Sie abschließend den Ausdruck, der aus der Variablen z besteht, und stellen Sie sicher, dass z an keinen Wert gebunden ist.

>>> def twice(z): return 2*z
...
>>> twice(2)
4
>>> twice(4)
8
>>> z
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  NameError: name 'z' is not defined

Herausforderung 0.5.28

Definieren Sie eine einzeilige Prozedur nextInts (L) wie folgt:

Eingabe: Liste der ganzen Zahlen L. Ausgabe: Eine Liste von ganzen Zahlen, deren i-tes Element 1 größer als das i-te Element von L ist Beispiel: Eingabe [1, 5, 7], Ausgabe: [2, 6, 8]

>>> def nextInts(L): return [x+1 for x in L]
...
>>> nextInts([1, 5, 7])
[2, 6, 8]

Herausforderung 0.5.29

Definieren Sie einzeilige Prozedurwürfel (L) wie folgt:

Eingabe: Liste der Zahlen L. Ausgabe: Liste der Zahlen, bei denen das i-te Element der Würfel des i-ten Elements von L ist Beispiel: Eingabe [1, 2, 3], Ausgabe [1, 8 27]

>>> def cubes(L): return [pow(x, 3) for x in L]
...
>>> cubes([1, 2, 3])
[1, 8, 27]

Herausforderung 0.5.30

Definieren Sie eine einzeilige Prozedur dict2list (dct, keylist) wie folgt:

Eingabe: Eine Liste der Schlüssel aus den Wörterbüchern dct und dct keylist Ausgabe: Listen Sie L so auf, dass L [i] = dct [Keylist [i]] für i = 0, 1, 2, ..., len (Keylist) -1 ist Beispiel: Eingabe dct = {'a': 'A', 'b': 'B', 'c': 'C'} und Keylist = ['b', 'c', 'a'], Ausgabe [ 'B', 'C', 'A']

>>> def dict2list(dct, keylist): return [dct[k] for k in keylist]
...
>>> dict2list({'a':'A', 'b':'B', 'c':'C'}, ['b', 'c', 'a'])
['B', 'C', 'A']

Herausforderung 0.5.31

Definieren Sie eine einzeilige Prozedur list2dict (L, Keylist) wie folgt:

Eingabe: Liste L, Liste der Keylisten für unveränderliche Elemente Ausgabe: Ein Wörterbuch, das die Keylist [i] für i = 0, 1, 2, ..., len (L) -1 auf L [i] abbildet Beispiel: Eingabe L = ['A', 'B', 'C'] und Keylist = ['a', 'b', 'c'], Ausgabe {'a': 'A', 'b': 'B', 'c': 'C'}

>>> def list2dict(L, keylist): return {keylist[k]:L[k] for k in range(len(keylist))}
...
>>> list2dict(['A', 'B', 'C'], ['a', 'b', 'c'])
{'a': 'A', 'c': 'C', 'b': 'B'}

Herausforderung 0.5.32

Schreiben Sie die folgende Prozedur all_3_digit_numbers (Basis, Ziffern).

Eingabe: Positive Ganzzahlbasis und eingestellte Ziffern von {0, 1, 2, ..., Basis-1} Ausgabe: Eine Reihe von Zahlen, die aus allen drei Zahlen mit Basis bestehen Ein Beispiel ist unten gezeigt.

>>> all_3_digit_number(2, {0, 1}) {0, 1, 2, 3, 4, 5, 6, 7} >>> all_3_digit_number(3, {0, 1, 2}) {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26} >>> all_3_digit_number(10, {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}) {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ..., 995, 996, 997, 998, 999}

>>> def all_3_digit_number(base, digits): return {a*pow(base, 2) + b*pow(base, 1) + c*pow(base, 0) for a in digits for b in digits for c in digits}
...
>>> all_3_digit_number(2, {0, 1})
set([0, 1, 2, 3, 4, 5, 6, 7])
>>> all_3_digit_number(3, {0, 1, 2})
set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26])
>>> all_3_digit_number(10, {0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, (Abkürzung)..., 995, 996, 997, 998, 999])

0.6 Lab: Python und Reverse Index --- Module und Kontrollstrukturen

0.6.1 Verwendung vorhandener Module

Herausforderung 0.6.1

Importieren Sie Mathematik mit dem folgenden Befehl.

>>> import math

Versuchen Sie, die Prozedurhilfe (Modulname) für das importierte Modul zu verwenden.

>>> help(math)

Infolgedessen wird die Dokumentation für das angegebene Modul auf der Konsole angezeigt. Sie können f verwenden, um nach unten zu gehen, und b, um wieder nach oben zu gehen. Sie können auch das Durchsuchen des q-Dokuments beenden. Ermitteln Sie die Quadratwurzel von 3 mithilfe des im Mathematikmodul definierten Verfahrens und suchen Sie dann das Quadrat. Dieses Ergebnis wird nicht Ihren Erwartungen entsprechen. Beachten Sie, dass Python eine begrenzte Genauigkeit für nicht ganzzahlige reelle Zahlen aufweist. Daher ist die Antwort eine Annäherung. Berechnen Sie als nächstes die Quadratwurzel von -1, cos für π und den natürlichen Logarithmus für e </ i>. Der Name der Funktion, die die Quadratwurzel berechnet, lautet sqrt, und der qualifizierte Name lautet math.sqrt. cos und log sind ihre Namen. Auch die Namen von π und e </ i> sind pi und e.

>>> import math

>>> math.sqrt(3)
1.7320508075688772

>>> pow(math.sqrt(3), 2)
2.9999999999999996

>>> math.sqrt(-1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: math domain error

>>> math.cos(math.pi)
-1.0

>>> math.log(math.e)
1.0

>>> from random import randint
>>> randint(0, 9)
3
>>> randint(0, 9)
1
>>> randint(0, 9)
9

>>> def movie_review(name): return ['See it!', 'A gem!', 'Ideological claptrap!'][randint(0, 2)]
...
>>> movie_review('movie_name')
'See it!'
>>> movie_review('movie_name')
'A gem!'
>>> movie_review('movie_name')
'Ideological claptrap!'
>>> movie_review('movie_name')
'A gem!'
>>> movie_review('movie_name')
'A gem!'

def dict2list(dct, keylist): return [dct[k] for k in keylist]

def list2dict(L, keylist): return {keylist[k]:L[k] for k in range(len(keylist))}

>>> import dictutil
>>> dictutil.dict2list({'a':'A', 'b':'B', 'c':'C'}, ['b', 'c', 'a'])
['B', 'C', 'A']
>>> dictutil.list2dict(['A', 'B', 'C'], ['a', 'b', 'c'])
{'a': 'A', 'c': 'C', 'b': 'B'}

...
def listrange2dict(L): return {i:L[i] for i in range(len(L))}

>>> reload(dictutil)
<module 'dictutil' from 'dictutil.py'>
>>> dictutil.listrange2dict(['A', 'B', 'C'])
{0: 'A', 1: 'B', 2: 'C'}

>>> for x in [1, 2, 3]:
...   y = x * x
...   print(y)
...
1
4
9

def makeInverseIndex(strlist):
  worddict = {}
  for no, line in enumerate(strlist):
    for word in list(set(line.split())):
      if word in worddict:
        worddict[word].add(no)
      else:
        worddict[word] = {no}
  return worddict

>>> import inverseindex
>>> f = open('stories_small.txt')
>>> stories = list(f)

>>> dict = inverseindex.makeInverseIndex(stories)

>>> dict['prep']
set([0, 17])
>>> dict['course']
set([0, 2, 3, 4, 5, 49, 9, 10, 13, 47, 17, 18, 20])

...

def orSearch(inverseIndex, query):
  result = set([])
  for k, v in inverseIndex.items():
    for q in query:
      if k == q:
		result = result | v
  return result

>>> inverseindex.orSearch(dict, ['prep', 'course'])
set([0, 2, 3, 4, 5, 49, 9, 10, 13, 47, 17, 18, 20])

$ egrep -n -e ' prep ' stories_small.txt | cut -c -80
1:A prep course for the month-long World Cup soccer tournament , a worldwide phe
18:A prep course for the month-long World Cup soccer tournament , a worldwide ph

$ egrep -n -e ' course ' stories_small.txt | cut -c -80
1:A prep course for the month-long World Cup soccer tournament , a worldwide phe
3:Are frequent-flier awards worth all the trouble travelers sometimes go through
4:The State Department is taking a wait-and-see attitude after an American touri
5:I think there are several reasons why , in polite company , we rarely talk abo
6:By conventional wisdom , there are certain things you simply don't do , right
10:Llamas will carry the load on a three-day guided hiking and camping trip in t
11:Considering that the United Nations has recently created a Bosnian war-crimes
14:When I first got off the Pennsylvania Turnpike at Morgantown , I barely glanc
18:A prep course for the month-long World Cup soccer tournament , a worldwide ph
19:It is only natural that a writer make the literary most of whatever happens t
21:Step by step , President Clinton seems to be maneuvering himself into a posit
48:HOLLYWOOD When the editor of Tricycle , the Buddhist Review , one of the few
50:Eddie Murphy has been telling interviewers , in no uncertain terms , that ``

...

def andSearch(inverseIndex, query):
  result = set([])
  for k, v in inverseIndex.items():
    for q in query:
      if k == q:
        if len(result) == 0:
          result = result | v
        else:
          result = result & v
  return result

>>> inverseindex.andSearch(dict, ['prep', 'course'])
set([0, 17])

$ egrep -n -e ' prep ' stories_small.txt | egrep -e ' course ' | cut -c -80
1:A prep course for the month-long World Cup soccer tournament , a worldwide phe
18:A prep course for the month-long World Cup soccer tournament , a worldwide ph