When working with nucleotide sequences, you can obtain the complements of the sequence : 

```python
my_seqq = Seq("GATCGATATATAGGAAATCGC")
print(my_seqq.complement()) 
```

You can also obtain the reverse complements : 

```python
print(my_seqq.reverse_complement()) 
```

When printed out, the result will be : 

```python
CTAGCTATATATCCTTTAGCG
GCGATTTCCTATATATCGATC
``` 

Complements and Reverse Complements 

Creating the coding and the template DNA strands : 

```python
coding_dna = Seq("ATGAGCCGCTGAAAGGGTGCCCGATAG")
template_dna = coding_dna.reverse_complement()
print(coding_dna)
print(template_dna)
```

Transcribing the coding strand into the mRNA strand (by replacing T with U) : 

```python
messengar_rna = coding_dna.transcribe()
print(messengar_rna)
```

You can also transcribe by starting with the template strand : 

```python
print(template_dna.reverse_complement().transcribe())
```

When printed out, the result will be: 
```python
ATGAGCCGCTGAAAGGGTGCCCGATAG
CTATCGGGCACCCTTTCAGCGGCTCAT
AUGAGCCGCUGAAAGGGUGCCCGAUAG
AUGAGCCGCUGAAAGGGUGCCCGAUAG
```

Transcription 

Translating the messenger rna into a protein sequence : 

```python
messenger_rna = Seq("AUGGCCAUUGUAAUGGUAG")
messenger_rna.translate()
print(messenger_rna.translate())
```

Translating from the DNA coding sequence : 

```python
coding_dna = Seq("ATGGCCATTGTAATGGTAG")
coding_dna.translate()
print(coding_dna.translate())
```

When dealing with different types of sequences, the specific translation table can be specified : 

```python
coding_dna.translate(table="Vertebrate Mitochondrial")
print (coding_dna.translate(table="Vertebrate Mitochondrial"))
```

You can also stop translating when it gets to the first in frame stop codon : 

```python
coding_dna2 = Seq("ATGGCCATTGTAATGGGCCGCTGAAAGGGTGCCCGATAG")
translate_2 = coding_dna2.translate(to_stop = True)
print(translate_2)
```

When printed, the result will be :

```python
MAIVMV
MAIVMV
MAIVMV
MAIVMGR
```


Translation 

Translation Tables 

The default for seq objects in BioPython - just like in Python -  is for seq objects to be read only or immutable to avoid changing the sequence data. However, it is possible to convert it into a mutable sequence. 

Converting a seq object into a mutable seq object : 

```python
from Bio.Seq import MutableSeq
seq1 = Seq("GCCATTGTAATGGGCCGCTGAAAGGGTGCCCGA")
mutable_sequence = MutableSeq(seq1)
print(mutable_sequence)
mutable_sequence[0] = "A"
print(mutable_sequence)
```

Creating a mutable seq object from a string : 

```python
from Bio.Seq import MutableSeq
mutable_sequence2 = MutableSeq("GCCATTGTAATGGGCCGCTGAAAGGGTGCCCGA")
print(mutable_sequence2)
```

When printed in Python, the result will be:

```python
GCCATTGTAATGGGCCGCTGAAAGGGTGCCCGA
ACCATTGTAATGGGCCGCTGAAAGGGTGCCCGA
GCCATTGTAATGGGCCGCTGAAAGGGTGCCCGA
```

Mutable Seq Objects

-      Complements and Reverse Complements 
-      Transcription
-      Translation 
-      Translation Table 
-      Mutable Seq Objects 

Boston University

In BioPython, sequences act similarly to normal string objects in Python as they are essentially a bunch of letters. While there a lot of methods that support both the Seq and string object, the Seq object differs from string objects in the methods that can be used on it. 

Sequences 

This link leads to a page describing a large overview of BioPython and what it can do : 
http://biopython.org/DIST/docs/tutorial/Tutorial.html

BioPython Tutorial 

A few examples....
You can iterate over the elements in the Seq object the same as a string object : 

```python
from Bio.Seq import Seq
my_seq = Seq("ATGCA")
for index, letter in enumerate(my_seq):
    print((index, letter)) 
```

You can find the length of the Seq object: 

```python
print(len(my_seq))
```

You can access elements of a Seq object: 

```python
print(my_seq[2])
print(my_seq[-1])
```

You can also slice a Seq object:

```python
print(my_seq[4:0:-2])
```

You can add Seq objects together: 

```python
my_seq2 = Seq("GTCATC")
print(my_seq + my_seq2)
```

You can change the case of Seq objects: 

```python
print(my_seq2.lower())
```

When run in Python, the output will be: 

```python
(0, 'A')
(1, 'T')
(2, 'G')
(3, 'C')
(4, 'A')
5
G
A
AG
ATGCAGTCATC
gtcatc
```

Learn Before

Related

Learn After