4 <title>Affine ciphers
</title>
5 <meta http-equiv=
"Content-Type" content=
"text/html; charset=UTF-8"/>
6 <style type=
"text/css">
15 h1 { font-size:
3em; }
16 h2 { font-size:
2em; }
17 h3 { font-size:
1.6em; }
19 text-decoration: none;
22 -moz-border-radius:
5px;
23 -web-border-radius:
5px;
31 text-shadow:
0 0 20px #
333;
37 text-shadow:
0 0 20px #
333;
46 <textarea id=
"source">
48 # Breaking keyword ciphers
50 a | b | c | d | e | f | g | h | i | j | k | l | m | n | o | p | q | r | s | t | u | v | w | x | y | z
51 --|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|--
52 k | e | y | w | o | r | d | a | b | c | f | g | h | i | j | l | m | n | p | q | s | t | u | v | x | z
56 # Duplicate and extend your `affine_break()` function
58 * How to cycle through all the keys? What _are_ all the keys?
66 * `
2013/
4a.ciphertext`
67 * `
2013/
4b.ciphertext`
69 This will take a while. Fire up a system monitor. What's wrong?
73 # Python, threads, and the GIL
75 Thread-safe shared-memory code is hard.
77 Python's Global Interpreter Lock prevents shooting yourself in the foot.
79 Where you want true parallelism, need different threads (Python processes).
80 * Thread-safe shared-memory code is hard.
82 The `multiprocessing` library makes this easier.
84 But before we get there, a couple of diversions...
90 A common task is to apply a function to each item in a sequence, returning a sequence of the results.
96 >>> map(double, [
1,
2,
3])
100 * `map()` is a higher-order function: its first argument is the function that's applied.
102 How can we use this for keyword cipher breaking?
106 # Mapping keyword decipherings
108 Define a function that takes a possible key (keyword and cipher type) and returns the key and its fitness.
110 * (Also pass in the message and the fitness function)
112 Use `map()` and `max()` to find the best key
118 How many arguments does this take?
120 How do you write a function that takes this many arguments?
126 ## Positional, keyword
128 * Common or garden parameters, as you're used to.
129 * `def keyword_encipher(message, keyword, wrap_alphabet=
0):`
132 * `def mean(x, *xs):`
134 First number goes in `x`, remaining go in the tuple `xs`
138 * `def myfunc(arg1=
0, **kwargs):`
140 `kwargs` will be a Dict of the remaining keywords (not `arg1`)
144 # Back to `multiprocessing`
146 What does `Pool.starmap()` do?
151 from multiprocessing import Pool
153 def keyword_break_mp(message, wordlist=keywords, fitness=Pletters, chunksize=
500):
154 helper_args = [??? for word in wordlist] # One tuple for each possible key
156 breaks = pool.starmap(keyword_break_worker, helper_args, chunksize)
157 return max(breaks, key=lambda k: k[
1])
159 def keyword_break_worker(???):
161 return (key, fitness)
164 * Gotcha: the function in `Pool.starmap()` must be defined at the top level
165 * This is definitely a
"feature"
169 # Performance and chunksize
171 Try the multiprocessing keyword break. Is it using all the resources?
173 Setting `chunksize` is an art.
175 ## Map-reduce as a general pattern for multiprocessing
178 <script src=
"http://gnab.github.io/remark/downloads/remark-0.6.0.min.js" type=
"text/javascript">
181 <script type=
"text/javascript"
182 src=
"http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML&delayStartupUntil=configured"></script>
184 <script type=
"text/javascript">
185 var slideshow = remark.create({ ratio:
"16:9" });
190 skipTags: ['script', 'noscript', 'style', 'textarea', 'pre']
193 MathJax.Hub.Queue(function() {
194 $(MathJax.Hub.getAllJax()).map(function(index, elem) {
195 return(elem.SourceElement());
196 }).parent().addClass('has-jax');
198 MathJax.Hub.Configured();