Collection_Data_Types.rst 18.9 KB
Newer Older
1
2
.. sectnum::
   :start: 5
Blaise Li's avatar
Blaise Li committed
3

Bertrand  NÉRON's avatar
Bertrand NÉRON committed
4
5
6
7
8
.. _Collection_Data_types:

*********************
Collection Data Types
*********************
Bertrand  NÉRON's avatar
Bertrand NÉRON committed
9

10
Exercises
Bertrand  NÉRON's avatar
Bertrand NÉRON committed
11
12
=========

13
Exercise
14
15
--------

16
17
| Draw the representation in memory of the following expressions.
| what is the data type of each object?
18

Blaise Li's avatar
Blaise Li committed
19
::
20
21
22
23
24

   x = [1, 2, 3, 4]
   y = x[1]
   y = 3.14
   x[1] = 'foo'
Blaise Li's avatar
Blaise Li committed
25

26
27
28
29
.. figure:: _static/figs/list_1.png
   :width: 400px
   :alt: set
   :figclass: align-center
Blaise Li's avatar
Blaise Li committed
30

31
32
33
34
35
::

   x = [1, 2, 3, 4]
   x += [5, 6]

Blaise Li's avatar
Blaise Li committed
36
.. figure:: _static/figs/augmented_assignment_list.png
37
38
   :width: 400px
   :alt: set
Blaise Li's avatar
Blaise Li committed
39
   :figclass: align-center
40
41
42
43
44
45
46
47
48

::

   >>> x = [1, 2, 3, 4]
   >>> id(x)
   139950507563632
   >>> x += [5,6]
   >>> id(x)
   139950507563632
Blaise Li's avatar
Blaise Li committed
49
50

With mutable object like ``list``, when we mutate the object, the state of the object is modified.
Bertrand  NÉRON's avatar
Bertrand NÉRON committed
51
But the reference to the object is still unchanged.
52

Blaise Li's avatar
Blaise Li committed
53
Comparison with the exercise on strings and integers:
54

Blaise Li's avatar
Blaise Li committed
55
56
Since lists are mutable, when ``+=`` is used, the original list object is modified, so no rebinding of *x* is necessary.
We can observe this using *id()* which gives the memory address of an object. This address does not change after the
57
58
59
``+=`` operation.

.. note::
Blaise Li's avatar
Blaise Li committed
60
61
62
   Even the results are the same, there is a subtelty to use augmented operator.
   In ``a operator= b`` opeeration, Python looks up ``a``'s value only once, so it is potentially faster
   than the ``a = a operator b`` operation.
63

64

Blaise Li's avatar
Blaise Li committed
65
Compare ::
66
67
68
69
70
71

   x = 3
   y = x
   y += 3
   x = ?
   y = ?
Blaise Li's avatar
Blaise Li committed
72
73
74


.. figure:: _static/figs/augmented_assignment_int2.png
75
76
   :width: 400px
   :alt: augmented_assignment
Blaise Li's avatar
Blaise Li committed
77
78
   :figclass: align-center

79
80
81
82
83
84
85

and ::

   x = [1,2]
   y = x
   y += [3,4]
   x = ?
Blaise Li's avatar
Blaise Li committed
86
   y = ?
87
88


Blaise Li's avatar
Blaise Li committed
89
.. figure:: _static/figs/augmented_assignment_list2.png
90
91
   :width: 400px
   :alt: list extend
Blaise Li's avatar
Blaise Li committed
92
93
   :figclass: align-center

94

Blaise Li's avatar
Blaise Li committed
95
96
97
In this example we have two ways to access to the list ``[1, 2]``.
If we modify the state of the list itself, but not the references to this object, then the two variables ``x`` and ``y`` still reference the list containing
``[1, 2, 3, 4]``.
98
99


100
Exercise
101
102
--------

Blaise Li's avatar
Blaise Li committed
103
104
105
wihout using python shell, what is the results of the following statements:

.. note::
106
   sum is a function which return the sum of each elements of a list.
Blaise Li's avatar
Blaise Li committed
107

108
::
109

110
111
112
   x = [1, 2, 3, 4]
   x[3] = -4 # what is the value of x now ?
   y = sum(x)/len(x) #what is the value of y ? why ?
Blaise Li's avatar
Blaise Li committed
113

Bertrand  NÉRON's avatar
Bertrand NÉRON committed
114
115
   y = 0.5
.. warning::
116

Bertrand  NÉRON's avatar
Bertrand NÉRON committed
117
118
119
    In python2 the result is ::

        y = 0
120

Bertrand  NÉRON's avatar
Bertrand NÉRON committed
121
122
    because sum(x) is an integer, len(x) is also an integer so in python2.x the result is an integer,
    all the digits after the periods are discarded.
123
124


125
Exercise
126
127
--------

128
129
130
131
132
133
Draw the representation in memory of the following expressions. ::

   x = [1, ['a','b','c'], 3, 4]
   y = x[1]
   y[2] = 'z'
   # what is the value of x ?
Blaise Li's avatar
Blaise Li committed
134

135
136
137
138
.. figure:: _static/figs/list_2-1.png
   :width: 400px
   :alt: set
   :figclass: align-center
Blaise Li's avatar
Blaise Li committed
139

140
141
142
143

.. container:: clearer

    .. image :: _static/figs/spacer.png
Blaise Li's avatar
Blaise Li committed
144

145
146
 When we execute *y = x[1]*, we create ``y`` wich reference the list ``['a', 'b', 'c']``.
 This list has 2 references on it: ``y`` and ``x[1]`` .
Blaise Li's avatar
Blaise Li committed
147
148


149
150
151
152
.. figure:: _static/figs/list_2-2.png
   :width: 400px
   :alt: set
   :figclass: align-center
Blaise Li's avatar
Blaise Li committed
153
154


155
156
157
.. container:: clearer

    .. image :: _static/figs/spacer.png
Blaise Li's avatar
Blaise Li committed
158
159


160
161
 This object is a list so it is a mutable object.
 So we can access **and** modify it by the two ways ``y`` or ``x[1]`` ::
Blaise Li's avatar
Blaise Li committed
162

163
   x = [1, ['a','b','z'], 3, 4]
Blaise Li's avatar
Blaise Li committed
164

165
166
167
168
169
170
171
172
173
Exercise
--------

from the list l = [1, 2, 3, 4, 5, 6, 7, 8, 9] generate 2 lists l1 containing all odd values, and l2 all even values.::

   l = [1, 2, 3, 4, 5, 6, 7, 8, 9]
   l1 = l[::2]
   l2 = l[1::2]

Blaise Li's avatar
Blaise Li committed
174

175
Exercise
176
--------
Blaise Li's avatar
Blaise Li committed
177

178
generate a list containing all codons.
Blaise Li's avatar
Blaise Li committed
179

180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
pseudocode:
"""""""""""

| *function all_codons()*
|     *all_codons <- empty list*
|     *let varying the first base*
|     *for each first base let varying the second base*
|     *for each combination first base, second base let varying the third base*
|     *add the concatenation base 1 base 2 base 3 to all_codons*
|     *return all_codons*

first implementation:
"""""""""""""""""""""
.. literalinclude:: _static/code/codons.py
   :linenos:
   :language: python

::

   python -i codons.py 
   >>> codons = all_codons()
Blaise Li's avatar
Blaise Li committed
201
202

:download:`codons.py <_static/code/codons.py>`.
203
204
205
206

second implementation:
""""""""""""""""""""""

Bertrand  NÉRON's avatar
Bertrand NÉRON committed
207
Mathematically speaking the generation of all codons can be the cartesian product
Blaise Li's avatar
Blaise Li committed
208
between 3 vectors 'acgt'.
Bertrand  NÉRON's avatar
Bertrand NÉRON committed
209
In python there is a function to do that in ``itertools module``: `https://docs.python.org/3/library/itertools.html#itertools.product <product>`_
210
211
212
213
214
215
216
217
218
219


.. literalinclude:: _static/code/codons_itertools.py
   :linenos:
   :language: python

::

   python -i codons.py 
   >>> codons = all_codons()
Blaise Li's avatar
Blaise Li committed
220

221
222
:download:`codons_itertools.py <_static/code/codons_itertools.py>` .

Blaise Li's avatar
Blaise Li committed
223

224
Exercise
Bertrand  NÉRON's avatar
Bertrand NÉRON committed
225
226
--------

Blaise Li's avatar
Blaise Li committed
227
From a list return a new list without any duplicate, regardless of the order of items.
Bertrand  NÉRON's avatar
Bertrand NÉRON committed
228
229
230
231
232
233
234
For example: ::

   >>> l = [5,2,3,2,2,3,5,1]
   >>> uniqify(l)
   >>> [1,2,3,5] #is one of the solutions 


235
236
pseudocode:
"""""""""""
Bertrand  NÉRON's avatar
Bertrand NÉRON committed
237

238
239
240
241
242
| *function uniqify(l)*
|     *uniq <- empty list*
|     *for each element of l*
|        *add element if is not in uniq*
|     *return uniq*
243

244
245
implementation:
"""""""""""""""
246

247
248
249
.. literalinclude:: _static/code/uniqify.py
   :linenos:
   :language: python
250

251
::
252

253
254
255
   >>> l=[1,2,3,2,3,4,5,1,2,3,3,2,7,8,9]
   >>> uniqify(l)
   [1, 2, 3, 4, 5, 7, 8, 9]
256

257
:download:`codons_itertools.py <_static/code/codons_itertools.py>` .
258

259
260
second implementation:
""""""""""""""""""""""
261

262
263
264
265
266
The problem with the first implementation come from the line 4.
Remember that the membership operator uses a linear search for list, which can be slow for very large collections.
If we plan to use ``uniqify`` with large list we should find a better algorithm.
In the specification we can read that uniqify can work *regardless the order of the resulting list*.
So we can use the specifycity of set ::
267

Blaise Li's avatar
Blaise Li committed
268

269
   >>> list(set(l))
270

271

272
273
Exercise
--------
274

Bertrand  NÉRON's avatar
Bertrand NÉRON committed
275
We need to compute the occurrence of all kmers of a given length present in a sequence.
276

Blaise Li's avatar
Blaise Li committed
277
Below we propose 2 algorithms.
278

279
280
pseudo code 1
"""""""""""""
281

282
283
|   *function get_kmer_occurences(seq, kmer_len)*
|      *all_kmers <- generate all possible kmer of kmer_len*
Blaise Li's avatar
Blaise Li committed
284
|      *occurences <- 0*
285
286
287
|      *for each kmer in all_kmers*
|         *count occurence of kmer*
|         *store occurence*
Blaise Li's avatar
Blaise Li committed
288

289
290
291
292
293
294
295
296
pseudo code 2
"""""""""""""

|  *function get_kmer_occurences(seq, kmer_len)*
|     *all_kmers <- empty*
|     *from i = 0 to sequence length - kmer_len*
|        *kmer <- kmer startin at pos i im sequence*
|        *increase by of occurence of kmer*
Blaise Li's avatar
Blaise Li committed
297

298

299
.. note::
300

Blaise Li's avatar
Blaise Li committed
301
302
303
   Computer scientists typically measure an algorithm’s efficiency in terms of its worst-case running time,
   which is the largest amount of time an algorithm can take given the most difficult input of a fixed size.
   The advantage to considering the worst case running time is that we are guaranteed that our algorithm
304
   will never behave worse than our worst-case estimate.
Blaise Li's avatar
Blaise Li committed
305
306
307
308
309
310
311

   Big-O notation compactly describes the running time of an algorithm.
   For example, if your algorithm for sorting an array of n numbers takes roughly n2 operations for the most difficult dataset,
   then we say that the running time of your algorithm is O(n2). In reality, depending on your implementation, it may be use any number of operations,
   such as 1.5n2, n2 + n + 2, or 0.5n2 + 1; all these algorithms are O(n2) because big-O notation only cares about the term that grows the fastest with
   respect to the size of the input. This is because as n grows very large, the difference in behavior between two O(n2) functions,
   like 999 · n2 and n2 + 3n + 9999999, is negligible when compared to the behavior of functions from different classes,
312
313
   say O(n2) and O(n6). Of course, we would prefer an algorithm requiring 1/2 · n2 steps to an algorithm requiring 1000 · n2 steps.

Blaise Li's avatar
Blaise Li committed
314
315
   When we write that the running time of an algorithm is O(n2), we technically mean that it does not grow faster than a function with a
   leading term of c · n2, for some constant c. Formally, a function f(n) is Big-O of function g(n), or O(g(n)), when f(n) <= c · g(n) for some
316
317
318
   constant c and sufficiently large n.

   For more on Big-O notation, see A `http://rob-bell.net/2009/06/a-beginners-guide-to-big-o-notation/Beginner's <Guide to Big-O Notation>`_.
Blaise Li's avatar
Blaise Li committed
319

320

321
Compare the pseudocode of each of them and implement the fastest one. ::
322

323
324
325
326
327
328
329
330
331
   """gtcagaccttcctcctcagaagctcacagaaaaacacgctttctgaaagattccacactcaatgccaaaatataccacag
      gaaaattttgcaaggctcacggatttccagtgcaccactggctaaccaagtaggagcacctcttctactgccatgaaagg
      aaaccttcaaaccctaccactgagccattaactaccatcctgtttaagatctgaaaaacatgaagactgtattgctcctg
      atttgtcttctaggatctgctttcaccactccaaccgatccattgaactaccaatttggggcccatggacagaaaactgc
      agagaagcataaatatactcattctgaaatgccagaggaagagaacacagggtttgtaaacaaaggtgatgtgctgtctg
      gccacaggaccataaaagcagaggtaccggtactggatacacagaaggatgagccctgggcttccagaagacaaggacaa
      ggtgatggtgagcatcaaacaaaaaacagcctgaggagcattaacttccttactctgcacagtaatccagggttggcttc
      tgataaccaggaaagcaactctggcagcagcagggaacagcacagctctgagcaccaccagcccaggaggcacaggaaac
      acggcaacatggctggccagtgggctctgagaggagaaagtccagtggatgctcttggtctggttcgtgagcgcaacaca"""
Bertrand  NÉRON's avatar
Bertrand NÉRON committed
332
333


Blaise Li's avatar
Blaise Li committed
334
In the first alogrithm.
Bertrand  NÉRON's avatar
Bertrand NÉRON committed
335

336
337
| we first compute all kmers we generate 4\ :sup:`kmer length`
| then we count the occurence of each kmer in the sequence
Blaise Li's avatar
Blaise Li committed
338
| so for each kmer we read all the sequence so the algorith is in O( 4\ :sup:`kmer length` * ``sequence length``)
Bertrand  NÉRON's avatar
Bertrand NÉRON committed
339

Blaise Li's avatar
Blaise Li committed
340
| In the secon algorithm we read the sequence only once
341
| So the algorithm is in O(sequence length)
Bertrand  NÉRON's avatar
Bertrand NÉRON committed
342
343


344
Compute the 6 mers occurences of the sequence above, and print each 6mer and it's occurence one per line.
Bertrand  NÉRON's avatar
Bertrand NÉRON committed
345

346
347
348
.. literalinclude:: _static/code/kmer.py
   :linenos:
   :language: python
Bertrand  NÉRON's avatar
Bertrand NÉRON committed
349

350
::
Bertrand  NÉRON's avatar
Bertrand NÉRON committed
351

352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
   >>> s = """"gtcagaccttcctcctcagaagctcacagaaaaacacgctttctgaaagattccacactcaatgccaaaatataccacag
   ... gaaaattttgcaaggctcacggatttccagtgcaccactggctaaccaagtaggagcacctcttctactgccatgaaagg
   ... aaaccttcaaaccctaccactgagccattaactaccatcctgtttaagatctgaaaaacatgaagactgtattgctcctg
   ... atttgtcttctaggatctgctttcaccactccaaccgatccattgaactaccaatttggggcccatggacagaaaactgc
   ... agagaagcataaatatactcattctgaaatgccagaggaagagaacacagggtttgtaaacaaaggtgatgtgctgtctg
   ... gccacaggaccataaaagcagaggtaccggtactggatacacagaaggatgagccctgggcttccagaagacaaggacaa
   ... ggtgatggtgagcatcaaacaaaaaacagcctgaggagcattaacttccttactctgcacagtaatccagggttggcttc
   ... tgataaccaggaaagcaactctggcagcagcagggaacagcacagctctgagcaccaccagcccaggaggcacaggaaac
   ... acggcaacatggctggccagtgggctctgagaggagaaagtccagtggatgctcttggtctggttcgtgagcgcaacaca"""
   >>> s = s.replace('\n', '')
   >>> kmers = get_kmer_occurences(s, 6)
   >>> for kmer in kmers:
   >>>   print kmer[0], '..', kmer[1]
   gcagag .. 2
   aacttc .. 1
   gcaact .. 1
   aaatat .. 2
Blaise Li's avatar
Blaise Li committed
369
370
371


:download:`kmer.py <_static/code/kmer.py>`.
Bertrand  NÉRON's avatar
Bertrand NÉRON committed
372
373
374


bonus:
375
""""""
Bertrand  NÉRON's avatar
Bertrand NÉRON committed
376

377
Print the kmers by ordered by occurences.
Bertrand  NÉRON's avatar
Bertrand NÉRON committed
378

Bertrand  NÉRON's avatar
Bertrand NÉRON committed
379
380
| see `https://docs.python.org/3/library/stdtypes.html#mutable-sequence-types <sort>`_
| see `https://docs.python.org/3/library/operator.html#operator.itemgetter <operator.itemgetter>`_
Bertrand  NÉRON's avatar
Bertrand NÉRON committed
381
382


383
384
385
.. literalinclude:: _static/code/kmer_2.py
   :linenos:
   :language: python
386

387
::
Bertrand  NÉRON's avatar
Bertrand NÉRON committed
388

389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
   >>> s = """"gtcagaccttcctcctcagaagctcacagaaaaacacgctttctgaaagattccacactcaatgccaaaatataccacag
   ... gaaaattttgcaaggctcacggatttccagtgcaccactggctaaccaagtaggagcacctcttctactgccatgaaagg
   ... aaaccttcaaaccctaccactgagccattaactaccatcctgtttaagatctgaaaaacatgaagactgtattgctcctg
   ... atttgtcttctaggatctgctttcaccactccaaccgatccattgaactaccaatttggggcccatggacagaaaactgc
   ... agagaagcataaatatactcattctgaaatgccagaggaagagaacacagggtttgtaaacaaaggtgatgtgctgtctg
   ... gccacaggaccataaaagcagaggtaccggtactggatacacagaaggatgagccctgggcttccagaagacaaggacaa
   ... ggtgatggtgagcatcaaacaaaaaacagcctgaggagcattaacttccttactctgcacagtaatccagggttggcttc
   ... tgataaccaggaaagcaactctggcagcagcagggaacagcacagctctgagcaccaccagcccaggaggcacaggaaac
   ... acggcaacatggctggccagtgggctctgagaggagaaagtccagtggatgctcttggtctggttcgtgagcgcaacaca"""
   >>> s = s.replace('\n', '')
   >>> kmers = get_kmer_occurences(s, 6)
   >>> for kmer, occ in kmers:
   >>>   print kmer, '..', occ
   cacagg .. 4
   aggaaa .. 4
   ttctga .. 3
   ccagtg .. 3
Blaise Li's avatar
Blaise Li committed
406
407
408


:download:`kmer_2.py <_static/code/kmer_2.py>`.
Bertrand  NÉRON's avatar
Bertrand NÉRON committed
409
410


411
412
413
Exercise
--------

414
415
416
417
418
| Write a function which take a sequence as parameter and return it's reversed complement.
| Write the pseudocode before to propose an implementation.

pseudocode:
"""""""""""
419

420
421
422
423
424
425
| *function reverse_comp(sequence)*
|     *complement <- establish a correpondance and each base and its complement*
|     *rev_seq <- revert the sequence*
|     *rev_comp <- empty*
|     *for each nt of rev_seq*
|        *concatenate nt complement to rev_comp*
426
|     *return rev_comp*
427

428
.. literalinclude:: _static/code/rev_comp.py
429
430
   :linenos:
   :language: python
431

432
433
434
435
436
::
   >>> from rev_comp import rev_comp
   >>>
   >>> seq = 'acggcaacatggctggccagtgggctctgagaggagaaagtccagtggatgctcttggtctggttcgtgagcgcaacaca'
   >>> print rev_comp(seq)
437
   tgtgttgcgctcacgaaccagaccaagagcatccactggactttctcctctcagagcccactggccagccatgttgccgt
438

Blaise Li's avatar
Blaise Li committed
439
440
441
:download:`rev_comp.py <_static/code/rev_comp.py>`.


442
443
444
445
446
447
448
449
450
451
452
453
other solution
""""""""""""""

python provide an interresting method for our problem. 
The ``translate`` method work on string and need a parameter which is a object
that can do the correspondance between characters in old string a the new one.
``maketrans`` is a function in module ``string`` that allow us to build this object.
``maketrans`` take 2 arguments, two strings, the first string contains the characters
to change, the second string the corresponding characters in the new string.
Thus the two strings **must** have the same lenght. The correspondance between
the characters to change and their new values is made in funtion of thier position.
the first character of the first string will be replaced by the first character of the second string,
Blaise Li's avatar
Blaise Li committed
454
the second character of the first string will be replaced by the second character of the second string, on so on.
455
So we can write the reverse complement without loop.
Blaise Li's avatar
Blaise Li committed
456

457
458
459
.. literalinclude:: _static/code/rev_comp2.py
   :linenos:
   :language: python
460
461

::
462
463
464
465
466
   >>> from rev_comp2 import rev_comp
   >>>
   >>> seq = 'acggcaacatggctggccagtgggctctgagaggagaaagtccagtggatgctcttggtctggttcgtgagcgcaacaca'
   >>> print rev_comp(seq)
   tgtgttgcgctcacgaaccagaccaagagcatccactggactttctcctctcagagcccactggccagccatgttgccgt
Blaise Li's avatar
Blaise Li committed
467

468
:download:`rev_comp2.py <_static/code/rev_comp2.py>` .
469

470
471
472
Exercise
--------

Bertrand  NÉRON's avatar
Bertrand NÉRON committed
473
474
475
476
let the following enzymes collection:
We decide to implement enzymes as tuple with the following structure
("name", "comment", "sequence", "cut", "end")
::
Blaise Li's avatar
Blaise Li committed
477

Bertrand  NÉRON's avatar
Bertrand NÉRON committed
478
479
480
481
482
483
484
485
486
487

   ecor1 = ("EcoRI", "Ecoli restriction enzime I", "gaattc", 1, "sticky")
   ecor5 = ("EcoRV", "Ecoli restriction enzime V", "gatatc", 3, "blunt")
   bamh1 = ("BamHI", "type II restriction endonuclease from Bacillus amyloliquefaciens ", "ggatcc", 1, "sticky")
   hind3 = ("HindIII", "type II site-specific nuclease from Haemophilus influenzae", "aagctt", 1 , "sticky")
   taq1 = ("TaqI", "Thermus aquaticus", "tcga", 1 , "sticky")
   not1 = ("NotI", "Nocardia otitidis", "gcggccgc", 2 , "sticky")
   sau3a1 = ("Sau3aI", "Staphylococcus aureus", "gatc", 0 , "sticky")
   hae3 = ("HaeIII", "Haemophilus aegyptius", "ggcc", 2 , "blunt")
   sma1 =  ("SmaI", "Serratia marcescens", "cccggg", 3 , "blunt")
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503

and the 2 dna fragments: ::

   dna_1 = """tcgcgcaacgtcgcctacatctcaagattcagcgccgagatccccgggggttgagcgatccccgtcagttggcgtgaattcag
   cagcagcgcaccccgggcgtagaattccagttgcagataatagctgatttagttaacttggatcacagaagcttccaga
   ccaccgtatggatcccaacgcactgttacggatccaattcgtacgtttggggtgatttgattcccgctgcctgccagg"""

   dna_2 = """gagcatgagcggaattctgcatagcgcaagaatgcggccgcttagagcgatgctgccctaaactctatgcagcgggcgtgagg
   attcagtggcttcagaattcctcccgggagaagctgaatagtgaaacgattgaggtgttgtggtgaaccgagtaag
   agcagcttaaatcggagagaattccatttactggccagggtaagagttttggtaaatatatagtgatatctggcttg"""

| which enzymes cut the dna_1 ?
|                  the dna_2 ?
|                  the dna_1 but not the dna_2?


Bertrand  NÉRON's avatar
Bertrand NÉRON committed
504
505
506
507
508
509
510
511
512
* In a file <my_file.py>
    #. Write a function *seq_one_line* which take a multi lines sequence and return a sequence in one line.
    #. Write a function *enz_filter* which take a sequence and a list of enzymes and return a new list containing
       the enzymes which have a binding site in the sequence
    #. open a terminal with the command python -i <my_file.py>
    #. copy paste the enzymes and dna fragments
    #. use the functions above to compute the enzymes which cut the dna_1
       apply the same functions to compute the enzymes which cut the dna_2
       compute the difference between the enzymes which cut the dna_1 and enzymes which cut the dna_2
Blaise Li's avatar
Blaise Li committed
513

514
.. literalinclude:: _static/code/enzyme_1.py
515
516
517
518
519
   :linenos:
   :language: python

::
   from enzyme_1 import *
Blaise Li's avatar
Blaise Li committed
520

521
522
523
524
   enzymes = [ecor1, ecor5, bamh1, hind3, taq1, not1, sau3a1, hae3, sma1]
   dna_1 = one_line(dna_1)
   dans_2 = one_line(dna_2)
   enz_1 = enz_filter(enzymes, dna_1)
Blaise Li's avatar
Blaise Li committed
525
   enz_2 = enz_filter(enzymes, dna_2)
526
527
   enz1_only = set(enz_1) - set(enz_2)

Blaise Li's avatar
Blaise Li committed
528
:download:`enzymes_1.py <_static/code/enzyme_1.py>`.
529
530
531
532
533
534
535
536

with this algorithm we find if an enzyme cut the dna but we cannot find all cuts in the dna for an enzyme. ::

   enzymes = [ecor1, ecor5, bamh1, hind3, taq1, not1, sau3a1, hae3, sma1]
   digest_1 = []
   for enz in enzymes:
      print enz.name, dna_1.count(enz.sequence)

Bertrand  NÉRON's avatar
Bertrand NÉRON committed
537
the latter algorithm display the number of occurrence of each enzyme, But we cannot determine the position of every sites.
538
We will see how to do this later.
539

Bertrand  NÉRON's avatar
Bertrand NÉRON committed
540
Bonus
541
^^^^^
Bertrand  NÉRON's avatar
Bertrand NÉRON committed
542
543
544
545
546
547
548
549
550

There is another kind of tuple which allow to access to itmes by index or name.
This data collection is called NamedTuple. The NamedTuple are not accessible directly they are in `collections` package,
so we have to import it before to use it.
We also have to define which name correspond to which item::

    import collections
    RestrictEnzyme = collections.namedtuple("RestrictEnzyme", ("name", "comment", "sequence", "cut", "end"))

Bertrand  NÉRON's avatar
typos    
Bertrand NÉRON committed
551
Then we can use this new kind of tuple::
Bertrand  NÉRON's avatar
Bertrand NÉRON committed
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568

    ecor1 = RestrictEnzyme("EcoRI", "Ecoli restriction enzime I", "gaattc", 1, "sticky")
    ecor5 = RestrictEnzyme("EcoRV", "Ecoli restriction enzime V", "gatatc", 3, "blunt")
    bamh1 = RestrictEnzyme("BamHI", "type II restriction endonuclease from Bacillus amyloliquefaciens ", "ggatcc", 1, "sticky")
    hind3 = RestrictEnzyme("HindIII", "type II site-specific nuclease from Haemophilus influenzae", "aagctt", 1 , "sticky")
    taq1 = RestrictEnzyme("TaqI", "Thermus aquaticus", "tcga", 1 , "sticky")
    not1 = RestrictEnzyme("NotI", "Nocardia otitidis", "gcggccgc", 2 , "sticky")
    sau3a1 = RestrictEnzyme("Sau3aI", "Staphylococcus aureus", "gatc", 0 , "sticky")
    hae3 = RestrictEnzyme("HaeIII", "Haemophilus aegyptius", "ggcc", 2 , "blunt")
    sma1 =  RestrictEnzyme("SmaI", "Serratia marcescens", "cccggg", 3 , "blunt")

The code must be adapted as below

.. literalinclude:: _static/code/enzyme_1_namedtuple.py
   :linenos:
   :language: python

Blaise Li's avatar
Blaise Li committed
569
:download:`enzymes_1_namedtuple.py <_static/code/enzyme_1_namedtuple.py>`.
570

571
Exercise
Bertrand  NÉRON's avatar
Bertrand NÉRON committed
572
573
574
575
576
--------

given the following dict : ::

   d = {1 : 'a', 2 : 'b', 3 : 'c' , 4 : 'd'}
Blaise Li's avatar
Blaise Li committed
577

Bertrand  NÉRON's avatar
Bertrand NÉRON committed
578
579
580
581
582
583
584
585
586
We want obtain a new dict with the keys and the values inverted so we will obtain: ::

   inverted_d  {'a': 1, 'c': 3, 'b': 2, 'd': 4}

solution ::

   inverted_d = {}
   for key in d.keys():
       inverted_d[d[key]] = key
Blaise Li's avatar
Blaise Li committed
587

Bertrand  NÉRON's avatar
Bertrand NÉRON committed
588
589
590
591
592
solution ::

   inverted_d = {}
   for key, value in d.items():
       inverted_d[value] = key
Blaise Li's avatar
Blaise Li committed
593

Bertrand  NÉRON's avatar
Bertrand NÉRON committed
594
595
solution ::

596
   inverted_d = {v : k for k, v in d.items()}
Blaise Li's avatar
Blaise Li committed
597