Essayez de résoudre les problèmes / problèmes du "programmeur matriciel" (fonction du chapitre 0)

introduction

En lisant ce livre, j'essaierai de résoudre les problèmes.

• O'Reilly Japan - Programmeur de processus

Ce n'est que le chapitre 0, et cela ressemble à réétudier Python.

** Mise à jour du 04/01/2017 **

Ajout du numéro de "[Laboratoire 0.6: Python et Index inverse --- Module et structure de contrôle](http://qiita.com/Suna/items/881ce264cffd3301a54f#06-Lab python-et Index inverse --- Module et structure de contrôle)" fait.

Chapitre 0 Fonctions (et autres informations sur les mathématiques et l'informatique)

0.5 Lab: Premiers pas avec Python --- Ensembles, listes, dictionnaires, inclusions

0.5.1 Formule simple

Défi 0.5.1

Utilisez python pour connaître le nombre de secondes par semaine.

>>> 7 * 24 * 60 * 60
604800

Défi 0.5.2

Utilisez Python pour trouver le reste de 2304811 divisé par 47. Cependant, n'utilisez pas% (indice: utilisez //).

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

Défi 0.5.3

Entrez une expression booléenne pour voir si la somme de 673 et 909 est divisible par 3.

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

0.5.2 Déclaration de substitution

0.5.3 Expression conditionnelle

Défi 0.5.4

Remplacez -9 par x et 1/2 par y. Prédisez la valeur de la formule suivante et saisissez-la pour confirmer la prédiction. 2**(y+1/2) if x+10<0 else 2**(y-1/2)

Puisque x + 10 <0 devient Faux et que la partie else 2 ** (y-1/2) est exécutée, elle devient "1".

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

0.5.4 ensemble

Défi 0.5.5

Ecrivez une notation inclusive pour l'ensemble {1, 2, 3, 4, 5} qui renvoie le carré de chaque entier.

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

Défi 0.5.6

Notation inclusive pour l'ensemble {0, 1, 2, 3, 4}, avec chaque entier comme exposant de 2, c'est-à-dire 2 ^{0 </ sup>, 2 1 </ sup> Écrivez quelque chose qui renvoie, 2 2 </ sup>, etc.}

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

Défi 0.5.7

La valeur de la notation d'inclusion précédente {x * y pour x dans {1, 2, 3} pour y dans {2, 3, 4}} est un ensemble de sept éléments. Remplacez {1, 2, 3} et {2, 3, 4} par des ensembles séparés de trois éléments afin que leurs valeurs soient un ensemble de neuf éléments.

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

Défi 0.5.8

Remplacez les deux ensembles {1, 2, 3} et {2, 3, 4} dans la notation d'inclusion précédente par différents ensembles de trois éléments afin que le résultat soit un ensemble de cinq éléments. Cependant, on suppose que les deux ensembles à remplacer sont élémentaires l'un par rapport à l'autre, c'est-à-dire que les éléments ne se chevauchent pas.

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

Défi 0.5.9

Les variables S et T doivent représenter un ensemble. Écrivez une notation d'inclusion pour S qui renvoie la partie commune de S et T sans l'opérateur & (indice: utilisez un filtre à la fin de la notation d'inclusion et vérifiez les éléments). Essayez la notation incluse que vous avez créée avec S = {1, 2, 3, 4} et T = {3, 4, 5, 6}.

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

Défi 0.5.10

Ecrire une expression dont la valeur évaluée est la moyenne des éléments de la liste [20, 10, 15, 75].

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

Défi 0.5.11

Ecrire une notation d'inclusion de liste pour les listes ['A', 'B', 'C'] et [1, 2, 3] dont la valeur comprend toutes les combinaisons possibles de [lettre, nombre]. Autrement dit, la valeur est la suivante. [['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]]

Défi 0.5.12

Supposons que vous attribuez à LofL une liste contenant une liste de nombres comme éléments. À ce stade, écrivez une formule pour calculer la somme de toutes les valeurs numériques de la liste. Cette formule a la forme suivante et a une notation d'inclusion. sum([sum(... Remplacez [[0,25, 0,75, 0,1], [-1, 0], [4, 4, 4, 4]] par LofL et essayez la formule que vous avez créée (Remarque: quelle est la longueur de la formule que vous avez créée? Faites-le fonctionner sur la liste des).

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

Défi 0.5.13

Voir ce qui se passe si la longueur de la liste sur le côté gauche ne correspond pas à la longueur de la liste sur le côté droit.

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

Défi 0.5.14

Soit S un ensemble d'entiers, par exemple {-4, -2, 1, 2, 5, 0}. Écrivez une notation à triple inclusion qui, lorsqu'elle est évaluée, est une liste de taples à trois éléments (i, j, k) qui remplissent les conditions suivantes: Ici, on suppose que i, j et k sont des éléments de S et que leur somme est égale à 0.

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

Défi 0.5.15

Modifiez la notation d'inclusion dans la question précédente afin que la liste résultante n'inclue pas (0, 0, 0) (indice: ajoutez un filtre).

>>> [(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)]

Défi 0.5.16

Modifiez davantage l'expression pour que la valeur de l'expression soit le premier taple au lieu de la liste de tous les tapples ci-dessus.

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

Défi 0.5.17

Trouvez un exemple de liste L avec différents len (L) et len (list (set (L))).

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

0.5.7 Autre traitement itératif

Défi 0.5.18

Ecrire une notation d'inclusion qui renvoie un ensemble impair entre 1 et 99 pour une plage de la plage de forme (n).

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

Défi 0.5.19

Remplacez L par une liste des cinq premières lettres de l'alphabet [«A», «B», «C», «D», «E»]. Écrivez une expression en utilisant L avec la liste suivante comme valeur. [(0, 'A'), (1, 'B'), (2, 'C'), (3, 'D'), (4, 'E')] range et zip peuvent être utilisés, mais la notation d'inclusion ne doit pas être utilisée.

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

Défi 0.5.20

Pour les listes [10, 25, 40] et [1, 15, 20], le premier élément est la somme de 10 et 1, le deuxième élément est la somme de 25 et 15, et le troisième élément est de 40 et 20. Écrivez une notation inclusive dont la valeur est une liste qui est la somme de. Vous pouvez utiliser zip, mais pas list.

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

0.5.8 dictionnaire

Défi 0.5.21

Soit dlist la liste des dictionnaires et k la clé commune à tous les dictionnaires de la liste. Ecrivez une notation d'inclusion de liste telle que le i-ème élément soit la valeur correspondant à la clé k dans le i-ème dictionnaire de dlist. Essayez la notation incluse que vous avez créée avec certaines données. Des exemples de données sont présentés ci-dessous.

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

Défi 0.5.22

Modifiez la notation d'inclusion dans l'exercice 0.5.21 afin qu'il puisse gérer certains dictionnaires qui n'ont pas k comme clé. Le i-ème élément de cette liste d'inclusion est la valeur correspondant à la clé si le i-ème dictionnaire de la liste contient la clé k, ou "NON PRESENT" si ce n'est pas le cas. Faire Testez la notation d'inclusion que vous avez créée pour chacun des k = 'Blibo' et k = 'Frodon' en utilisant la liste dans le dictionnaire ci-dessous.

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

Défi 0.5.23

Écrivez une notation d'inclusion qui est un dictionnaire où la clé est un entier de 0 à 99 et la valeur de la clé est le carré de la clé lorsqu'elle est évaluée à l'aide de range.

>>> {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}

Défi 0.5.24

Affectez l'ensemble approprié à la variable D. Par exemple, D = {"rouge", "blanc", "bleu"}. Écrivez une notation inclusive qui, lorsqu'elle est évaluée, est un dictionnaire qui représente une fonction égale pour D.

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

«Est-ce que ça va?

Défi 0.5.25

Un dictionnaire qui utilise les variables base = 10 et digits = set (range (base)) pour mapper chaque entier de 0 à 999 en une liste de trois chiffres représentant leurs chiffres respectifs lorsque la base est 10. Écrivez la notation d'inclusion.

{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]}

Assurez-vous que la formule que vous créez fonctionne sur n'importe quel fond. Par exemple, si 2 est attribué à la base et {0, 1} est attribué aux chiffres, le résultat est le suivant.

{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]}

Il est long jusqu'à 999, alors dépêchez-vous jusqu'à 109.

• Vous n'utilisez pas de chiffres.

Défi 0.5.26

Soit d un dictionnaire qui mappe les nombres d'employés (entiers entre 0 et n-1) au salaire. Supposons que L soit une liste de n éléments, le i-ème élément étant le nom de l'employé avec le numéro d'employé i. Écrivez la notation d'inclusion dans le dictionnaire qui fait correspondre le nom de l'employé au salaire. Les noms des employés peuvent être supposés différemment. Testez la notation incluse que vous avez créée avec les données suivantes.

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 Définir une procédure en une ligne

Défi 0.5.27

Entrez la définition de deux fois (z). Après la saisie, "..." s'affiche, appuyez donc sur Entrée. Appelez ensuite la procédure avec des arguments réels. Il serait intéressant de l'essayer avec une chaîne ou une liste. Enfin, évaluez l'expression constituée de la variable z et assurez-vous que z n'est lié à aucune valeur.

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

Défi 0.5.28

Définissez une procédure sur une ligne nextInts (L) comme ceci:

Entrée: Liste d'entiers L Sortie: Une liste d'entiers dont le i-ème élément est supérieur de 1 au i-ème élément de L Exemple: Entrée [1, 5, 7], Sortie: [2, 6, 8]

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

Défi 0.5.29

Définissez un cube de procédure sur une ligne (L) comme ceci:

Entrée: Liste des nombres L Sortie: Liste de nombres où le i-ème élément est le cube du i-ème élément de L Exemple: Entrée [1, 2, 3], Sortie [1, 8 27]

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

Défi 0.5.30

Définissez une procédure sur une ligne dict2list (dct, keylist) comme ceci:

Entrée: une liste de clés des dictionnaires dct et dct keylist Sortie: Liste L telle que L [i] = dct [liste de clés [i]] pour i = 0, 1, 2, ..., len (liste de clés) -1 Exemple: Input dct = {'a': 'A', 'b': 'B', 'c': 'C'} et keylist = ['b', 'c', 'a'], output [ «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']

Défi 0.5.31

Définissez une procédure sur une ligne list2dict (L, keylist) comme ceci:

Entrée: Liste L, liste des éléments immuables keylist Sortie: Un dictionnaire qui mappe la liste de clés [i] à L [i] pour i = 0, 1, 2, ..., len (L) -1 Exemple: Input L = ['A', 'B', 'C'] and keylist = ['a', 'b', 'c'], Output {'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'}

Défi 0.5.32

Ecrivez la procédure suivante all_3_digit_numbers (base, digits).

Entrée: base entière positive et ensemble de chiffres de {0, 1, 2, ..., base-1} Sortie: Un ensemble de nombres composé des trois nombres avec base Un exemple est présenté ci-dessous.

>>> 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, (Abréviation)..., 995, 996, 997, 998, 999])

0.6 Lab: Python et Reverse Index --- Modules et structures de contrôle

0.6.1 Utilisation des modules existants

Défi 0.6.1

Importez les mathématiques à l'aide de la commande suivante.

>>> import math

Essayez d'utiliser l'aide à la procédure (nom du module) pour le module importé.

>>> help(math)

En conséquence, la documentation du module spécifié s'affiche sur la console. Vous pouvez utiliser f pour descendre et b pour remonter. Vous pouvez également arrêter de parcourir le document q. Trouvez la racine carrée de 3 à l'aide de la procédure définie dans le module mathématique, puis trouvez son carré. Ce résultat ne sera pas celui que vous attendez. Gardez à l'esprit que Python a une précision limitée pour les nombres réels non entiers. Par conséquent, la réponse est une approximation. Ensuite, calculez la racine carrée de -1, cos pour π et le logarithme népérien pour e </ i>. Le nom de la fonction qui calcule la racine carrée est sqrt et le nom qualifié est math.sqrt. cos et log sont leurs noms. De plus, les noms de π et e </ i> sont pi et 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