Collection_Data_Types.rst 19.2 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
.. note::
Blaise Li's avatar
Blaise Li committed
104
105
106
   ``sum`` is a function which return the sum of all the elements of a list.

Wihout using the Python shell, tell what are the effects of the following statements::
Blaise Li's avatar
Blaise Li committed
107

108

109
   x = [1, 2, 3, 4]
Blaise Li's avatar
Blaise Li committed
110
111
112
113
114
115
116
117
118
119
120
121
122
123
   x[3] = -4  # What is the value of x now?
   y = sum(x) / len(x)  # What is the value of y? Why?

Solution (using the Python shell ;) )::

    >>> x = [1, 2, 3, 4]
    >>> x[3] = -4
    >>> x
    [1, 2, 3, -4]
    >>> y = sum(x) / len(x)
    >>> y
    0.5

Here, we compute the mean of the values contained in the list ``x``, after having changed its last element to -4.
Blaise Li's avatar
Blaise Li committed
124

Blaise Li's avatar
Blaise Li committed
125
.. .. warning::
126

Blaise Li's avatar
Blaise Li committed
127
..    In python2 the result is ::
Bertrand  NÉRON's avatar
Bertrand NÉRON committed
128

Blaise Li's avatar
Blaise Li committed
129
..        y = 0
130

Blaise Li's avatar
Blaise Li committed
131
..    because sum(x) is an integer, len(x) is also an integer so in python2.x the result is an integer,
Bertrand  NÉRON's avatar
Bertrand NÉRON committed
132
    all the digits after the periods are discarded.
133
134


135
Exercise
136
137
--------

138
139
140
141
142
143
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
144

145
146
147
148
.. figure:: _static/figs/list_2-1.png
   :width: 400px
   :alt: set
   :figclass: align-center
Blaise Li's avatar
Blaise Li committed
149

150
151
152
153

.. container:: clearer

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

155
156
 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
157
158


159
160
161
162
.. figure:: _static/figs/list_2-2.png
   :width: 400px
   :alt: set
   :figclass: align-center
Blaise Li's avatar
Blaise Li committed
163
164


165
166
167
.. container:: clearer

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


170
171
 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
172

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

175
176
177
178
179
180
181
182
183
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
184

185
Exercise
186
--------
Blaise Li's avatar
Blaise Li committed
187

188
generate a list containing all codons.
Blaise Li's avatar
Blaise Li committed
189

190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
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
211
212

:download:`codons.py <_static/code/codons.py>`.
213
214
215
216

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

Bertrand  NÉRON's avatar
Bertrand NÉRON committed
217
Mathematically speaking the generation of all codons can be the cartesian product
Blaise Li's avatar
Blaise Li committed
218
between 3 vectors 'acgt'.
Bertrand  NÉRON's avatar
Bertrand NÉRON committed
219
In python there is a function to do that in ``itertools module``: `https://docs.python.org/3/library/itertools.html#itertools.product <product>`_
220
221
222
223
224
225
226
227
228
229


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

::

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

231
232
:download:`codons_itertools.py <_static/code/codons_itertools.py>` .

Blaise Li's avatar
Blaise Li committed
233

234
Exercise
Bertrand  NÉRON's avatar
Bertrand NÉRON committed
235
236
--------

Blaise Li's avatar
Blaise Li committed
237
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
238
239
240
241
242
243
244
For example: ::

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


245
246
pseudocode:
"""""""""""
Bertrand  NÉRON's avatar
Bertrand NÉRON committed
247

248
249
250
251
252
| *function uniqify(l)*
|     *uniq <- empty list*
|     *for each element of l*
|        *add element if is not in uniq*
|     *return uniq*
253

254
255
implementation:
"""""""""""""""
256

257
258
259
.. literalinclude:: _static/code/uniqify.py
   :linenos:
   :language: python
260

261
::
262

263
264
265
   >>> 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]
266

267
:download:`codons_itertools.py <_static/code/codons_itertools.py>` .
268

269
270
second implementation:
""""""""""""""""""""""
271

272
273
274
275
276
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 ::
277

Blaise Li's avatar
Blaise Li committed
278

279
   >>> list(set(l))
280

281

282
283
Exercise
--------
284

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

Blaise Li's avatar
Blaise Li committed
287
Below we propose 2 algorithms.
288

289
290
pseudo code 1
"""""""""""""
291

292
293
|   *function get_kmer_occurences(seq, kmer_len)*
|      *all_kmers <- generate all possible kmer of kmer_len*
Blaise Li's avatar
Blaise Li committed
294
|      *occurences <- 0*
295
296
297
|      *for each kmer in all_kmers*
|         *count occurence of kmer*
|         *store occurence*
Blaise Li's avatar
Blaise Li committed
298

299
300
301
302
303
304
305
306
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
307

308

309
.. note::
310

Blaise Li's avatar
Blaise Li committed
311
312
313
   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
314
   will never behave worse than our worst-case estimate.
Blaise Li's avatar
Blaise Li committed
315
316
317
318
319
320
321

   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,
322
323
   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
324
325
   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
326
327
328
   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
329

330

331
Compare the pseudocode of each of them and implement the fastest one. ::
332

333
334
335
336
337
338
339
340
341
   """gtcagaccttcctcctcagaagctcacagaaaaacacgctttctgaaagattccacactcaatgccaaaatataccacag
      gaaaattttgcaaggctcacggatttccagtgcaccactggctaaccaagtaggagcacctcttctactgccatgaaagg
      aaaccttcaaaccctaccactgagccattaactaccatcctgtttaagatctgaaaaacatgaagactgtattgctcctg
      atttgtcttctaggatctgctttcaccactccaaccgatccattgaactaccaatttggggcccatggacagaaaactgc
      agagaagcataaatatactcattctgaaatgccagaggaagagaacacagggtttgtaaacaaaggtgatgtgctgtctg
      gccacaggaccataaaagcagaggtaccggtactggatacacagaaggatgagccctgggcttccagaagacaaggacaa
      ggtgatggtgagcatcaaacaaaaaacagcctgaggagcattaacttccttactctgcacagtaatccagggttggcttc
      tgataaccaggaaagcaactctggcagcagcagggaacagcacagctctgagcaccaccagcccaggaggcacaggaaac
      acggcaacatggctggccagtgggctctgagaggagaaagtccagtggatgctcttggtctggttcgtgagcgcaacaca"""
Bertrand  NÉRON's avatar
Bertrand NÉRON committed
342
343


Blaise Li's avatar
Blaise Li committed
344
In the first alogrithm.
Bertrand  NÉRON's avatar
Bertrand NÉRON committed
345

346
347
| 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
348
| 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
349

Blaise Li's avatar
Blaise Li committed
350
| In the secon algorithm we read the sequence only once
351
| So the algorithm is in O(sequence length)
Bertrand  NÉRON's avatar
Bertrand NÉRON committed
352
353


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

356
357
358
.. literalinclude:: _static/code/kmer.py
   :linenos:
   :language: python
Bertrand  NÉRON's avatar
Bertrand NÉRON committed
359

360
::
Bertrand  NÉRON's avatar
Bertrand NÉRON committed
361

362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
   >>> 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
379
380
381


:download:`kmer.py <_static/code/kmer.py>`.
Bertrand  NÉRON's avatar
Bertrand NÉRON committed
382
383
384


bonus:
385
""""""
Bertrand  NÉRON's avatar
Bertrand NÉRON committed
386

387
Print the kmers by ordered by occurences.
Bertrand  NÉRON's avatar
Bertrand NÉRON committed
388

Bertrand  NÉRON's avatar
Bertrand NÉRON committed
389
390
| 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
391
392


393
394
395
.. literalinclude:: _static/code/kmer_2.py
   :linenos:
   :language: python
396

397
::
Bertrand  NÉRON's avatar
Bertrand NÉRON committed
398

399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
   >>> 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
416
417
418


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


421
422
423
Exercise
--------

424
425
426
427
428
| Write a function which take a sequence as parameter and return it's reversed complement.
| Write the pseudocode before to propose an implementation.

pseudocode:
"""""""""""
429

430
431
432
433
434
435
| *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*
436
|     *return rev_comp*
437

438
.. literalinclude:: _static/code/rev_comp.py
439
440
   :linenos:
   :language: python
441

442
443
444
445
446
::
   >>> from rev_comp import rev_comp
   >>>
   >>> seq = 'acggcaacatggctggccagtgggctctgagaggagaaagtccagtggatgctcttggtctggttcgtgagcgcaacaca'
   >>> print rev_comp(seq)
447
   tgtgttgcgctcacgaaccagaccaagagcatccactggactttctcctctcagagcccactggccagccatgttgccgt
448

Blaise Li's avatar
Blaise Li committed
449
450
451
:download:`rev_comp.py <_static/code/rev_comp.py>`.


452
453
454
455
456
457
458
459
460
461
462
463
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
464
the second character of the first string will be replaced by the second character of the second string, on so on.
465
So we can write the reverse complement without loop.
Blaise Li's avatar
Blaise Li committed
466

467
468
469
.. literalinclude:: _static/code/rev_comp2.py
   :linenos:
   :language: python
470
471

::
472
473
474
475
476
   >>> from rev_comp2 import rev_comp
   >>>
   >>> seq = 'acggcaacatggctggccagtgggctctgagaggagaaagtccagtggatgctcttggtctggttcgtgagcgcaacaca'
   >>> print rev_comp(seq)
   tgtgttgcgctcacgaaccagaccaagagcatccactggactttctcctctcagagcccactggccagccatgttgccgt
Blaise Li's avatar
Blaise Li committed
477

478
:download:`rev_comp2.py <_static/code/rev_comp2.py>` .
479

480
481
482
Exercise
--------

Bertrand  NÉRON's avatar
Bertrand NÉRON committed
483
484
485
486
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
487

Bertrand  NÉRON's avatar
Bertrand NÉRON committed
488
489
490
491
492
493
494
495
496
497

   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")
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513

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
514
515
516
517
518
519
520
521
522
* 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
523

524
.. literalinclude:: _static/code/enzyme_1.py
525
526
527
528
529
   :linenos:
   :language: python

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

531
532
533
534
   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
535
   enz_2 = enz_filter(enzymes, dna_2)
536
537
   enz1_only = set(enz_1) - set(enz_2)

Blaise Li's avatar
Blaise Li committed
538
:download:`enzymes_1.py <_static/code/enzyme_1.py>`.
539
540
541
542
543
544
545
546

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
547
the latter algorithm display the number of occurrence of each enzyme, But we cannot determine the position of every sites.
548
We will see how to do this later.
549

Bertrand  NÉRON's avatar
Bertrand NÉRON committed
550
Bonus
551
^^^^^
Bertrand  NÉRON's avatar
Bertrand NÉRON committed
552
553
554
555
556
557
558
559
560

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
561
Then we can use this new kind of tuple::
Bertrand  NÉRON's avatar
Bertrand NÉRON committed
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578

    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
579
:download:`enzymes_1_namedtuple.py <_static/code/enzyme_1_namedtuple.py>`.
580

581
Exercise
Bertrand  NÉRON's avatar
Bertrand NÉRON committed
582
583
584
585
586
--------

given the following dict : ::

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

Bertrand  NÉRON's avatar
Bertrand NÉRON committed
588
589
590
591
592
593
594
595
596
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
597

Bertrand  NÉRON's avatar
Bertrand NÉRON committed
598
599
600
601
602
solution ::

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

Bertrand  NÉRON's avatar
Bertrand NÉRON committed
604
605
solution ::

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