2

I am writing a program in which I want to use 3 variables in my for loop and every variable should run from a different start index. Here is a snippet from my code. I have a table named codons in which I have some value for every three letter for e.g 'atg':'F', 'ggg':'Q' , 'ttg':'E' etc

seq='atgggggggcccccc'
seqlen= len(seq)
aaseq1=[]
aaseq2=[]
aaseq3=[]
for i in range(0,seqlen,3):
     codon1 = seq[i:i+3]
     aa1 = codons[codon1]
     aaseq1.append(aa1)  
print ''.join(aaseq1)

In this code, I am running variable i from position 0 but I want to use 2 more variables (j and k) which will run from 1 and 2 respectively and append the result in aaseq2 and aaseq3 list. 

 codon2 = seq[j:j+3]
 codon3 = seq[k:k+3]
Improve this question
6
  • 2
    Could you not simply use i+1 and i+2 with some if statements to prevent out of bounds? Commented Oct 2, 2015 at 2:40
  • but with which variable I will compare the if statement.. I am unable to do like this Commented Oct 2, 2015 at 2:41
  • can I use a variable at the place of 0 in for loop and then I can compare using if statement ? Commented Oct 2, 2015 at 2:43
  • Why can't you use 3 separate loops? i, j, and k don't seem to be related to one another? Commented Oct 2, 2015 at 2:51
  • 1
    From your description, it’s unclear what the job of j and k is and what makes them different to i. Can you show a concrete example, for example using that sequence you have in the question? What should happen exactly? Commented Oct 2, 2015 at 7:23

3 Answers 3

Reset to default
2

There are various ways to do this and the best one to use depends on how big your seq is in real life. The other answers give some nice ways to utilise Python features to avoid building lists explictly.

I'll give you one solution that goes through every group of three consecutive letters, but assigns them to one of three arrays depending on whether i%3 is 0,1 or 2.

For the example you've given - to me this is very easy to read but retains roughly the data structure you began with and I assume are familiar with. I've taken the liberty of adding a truncated dict for codons so that the code runs.

codons = {'atg':'Methionine','tgg':'Tryptophan','ggg':'Glycine',
          'ggc':'Glycine','gcc':'Alanine','ccc':'Proline'}

seq='atgggggggcccccc'
seqlen= len(seq)
aaseq=[[],[],[]]

for i in range(seqlen-2):
     codon = seq[i:i+3]    
     aa = codons[codon]
     aaseq[i%3].append(aa)  

print 'aaseq1 ='
print ''.join(aaseq[0])  
print 'aaseq2 ='
print ''.join(aaseq[1])  
print 'aaseq3 ='
print ''.join(aaseq[2])

This gives the output:

aaseq1 =
MethionineGlycineGlycineProlineProline
aaseq2 =
TryptophanGlycineGlycineProline
aaseq3 =
GlycineGlycineAlanineProline

If you want a more concise form - try this:

#Make every codon by zipping the sequence offset by one each time
codon_sequence = [''.join(z) for z in zip(seq,seq[1:],seq[2:])]
#Print every 3rd codon - starting at zero...
print 'aaseq1 = ',''.join([codons[c] for c in codon_sequence[::3]])
#...then starting at 1...
print 'aaseq2 = ',''.join([codons[c] for c in codon_sequence[1::3]])
#...you get the picture...
print 'aaseq3 = ',''.join([codons[c] for c in codon_sequence[2::3]])

Of course - rather than printing the sequences as the last step, you can assign them to variables if you need to do further processing.

Improve this answer
Sign up to request clarification or add additional context in comments.

3 Comments

The first two should have one more Proline on the end. Now you have gone and grown antlers or a third ear!. Biology is sooooo picky.
@uhoh. Yes - you're right. Thanks. Hmm - my -3 should be -2. I think it's only the first one actually... Unless a cc on it's own should also resolve to Proline. My Biology is as good as you'd expect from an electronic engineer...
...but +1 I like your methods + explanation! (and your right, just the first one). That's the gift that zip gives, it manages the stragglers so you don't have to think about it and double check.
2

You seem to be looking for the built-in zip function, which allows for lock-step iteration. Combined with tuple unpacking, it works like this:

>>> for i,j in zip(range(3), range(10,13)):
...   print(i,j)
... 
0 10
1 11
2 12

The arguments to zip are anything you can normally use in that part of the for loop, and you can have any number of them (as long as you assign to the same number of variables, or to only one variable which will be a tuple at each iteration).

Improve this answer

Comments

2

(I usually) Try not to use loops in Python. While (as @PM-2ring points out in a comment) list expressions are not necessarily any faster than explicit loops, some find that they can write, understand, and debug a lot faster by letting python handle the details of iterating over data as much as possible.

Below are a few version of your program, ultimately "pythonified" down to four lines, just to see where it went.

Usually there are ways to let Python do things for you, using indexing and list expressions. These can be concise and powerful things, and many python functions just do what you would want them to. For example, zip just drops the dangling base pairs at the end without complaining.

The print statements are there just to see what's happening, of course delete them later.

seq='atgggggggcccccc'

s1 = seq[0::3]  # you can drop the zero, it's just for readability
s2 = seq[1::3]
s3 = seq[2::3]

c1 = zip( s1,    s2,     s3     )
c2 = zip( s2,    s3,     s1[1:] )  # frame shift of 1
c3 = zip( s3,    s1[1:], s2[1:] )  # frame shift of 2

print c1
print c2
print c3

co1 = [bp1+bp2+bp3 for (bp1, bp2, bp3) in c1]
co2 = [bp1+bp2+bp3 for (bp1, bp2, bp3) in c2]
co3 = [bp1+bp2+bp3 for (bp1, bp2, bp3) in c3]

print co1
print co2
print co3

aaseq1 = [codons(thing) for thing in c1]
aaseq2 = [codons(thing) for thing in c2]
aaseq3 = [codons(thing) for thing in c3]

...which could also be written like this:

s1, s2, s3 = [seq[i::3] for i in range(3)]   # use list comprehension and unpacking

c1 = zip( s1,    s2,     s3     )
c2 = zip( s2,    s3,     s1[1:] )  # frame shift of 1
c3 = zip( s3,    s1[1:], s2[1:] )  # frame shift of 2

co1, co2, co3 = [[tr[0]+tr[1]+tr[2] for tr in c] for c in [c1,c2,c3]]

aaseq1, asseq2, asseq3 = [[codons(trip) for trip in co] for co in [co1, co2, co3]]

That was just to advertise more python. For beginners it may be less readable.

This is a further pythonification (just to see where this goes...):

S = [seq[i::3] for i in range(3)]   # three reading frames

C = zip(S[0], S[1], S[2]), zip(S[1], S[2], S[0][1:]), zip(S[2], S[0][1:], S[1][1:]) # group

CO = [[''.join(tr) for tr in c] for c in C]    # tuples to triplet strings

AASEQs = [[codons(trip) for trip in co] for co in CO]  # look up Amino Acids

and finally, if you want to change the three AA sequences into just three long strings:

final_AASEQs = [''.join(AASEQ) for AASEQ in AASEQs]

Just for fun, here is what the dictionary codons might look like (from Wikipedia, note upper case for A, T, G, C bases. So in the question seq = 'ATGGGGGGGCCCCCC'

codons = {'CTT': 'Leu', 'ATG': 'Met', 'AAG': 'Lys', 'AAA': 'Lys', 'ATC': 'Ile',
          'AAC': 'Asn', 'ATA': 'Ile', 'AGG': 'Arg', 'CCT': 'Pro', 'ACT': 'Thr',
          'AGC': 'Ser', 'ACA': 'Thr', 'AGA': 'Arg', 'CAT': 'His', 'AAT': 'Asn',
          'ATT': 'Ile', 'CTG': 'Leu', 'CTA': 'Leu', 'CTC': 'Leu', 'CAC': 'His',
          'ACG': 'Thr', 'CAA': 'Gln', 'AGT': 'Ser', 'CAG': 'Gln', 'CCG': 'Pro',
          'CCC': 'Pro', 'TAT': 'Tyr', 'GGT': 'Gly', 'TGT': 'Cys', 'CGA': 'Arg',
          'CCA': 'Pro', 'CGC': 'Arg', 'GAT': 'Asp', 'CGG': 'Arg', 'TTT': 'Phe',
          'TGC': 'Cys', 'GGG': 'Gly', 'TAG': 'STOP', 'GGA': 'Gly', 'TGG': 'Trp',
          'GGC': 'Gly', 'TAC': 'Tyr', 'GAG': 'Glu', 'TCG': 'Ser', 'TTA': 'Leu',
          'GAC': 'Asp', 'CGT': 'Arg', 'GAA': 'Glu', 'TCA': 'Ser', 'GCA': 'Ala',
          'GTA': 'Val', 'GCC': 'Ala', 'GTC': 'Val', 'GCG': 'Ala', 'GTG': 'Val',
          'TTC': 'Phe', 'GTT': 'Val', 'GCT': 'Ala', 'ACC': 'Thr', 'TGA': 'STOP',
          'TTG': 'Leu', 'TCC': 'Ser', 'TAA': 'STOP', 'TCT': 'Ser'}  # ATG also START
Improve this answer

11 Comments

“Try not to use loops in Python.” – Eh? Creating lots of intermediary lists in-memory is a lot worse than having a simple loop that does what you want in a single iteration.
It of course depends a lot on your use cases but blindly saying to avoid loops altogether is just wrong. There are many situations where list comprehensions simply are a bad idea (readability is also a big concern here), and many things that simply cannot be done with list comprehensions. And in your example, a simple for loop that does the job in a rather naive but readable way is about 30 percent faster than your solution.
I love list comprehensions, but they aren't magic. A for loop in a list comp is still a plain old Python for loop, it doesn't run at C speed. The list-building process itself is certainly faster than an explicit for loop using append because a list comp uses a dedicated LIST_APPEND bytecode, so it avoids the overhead of a method call (and method lookup, unless the append method has been cached).
(cont) Sure, use a list comp when it's appropriate, but don't try to shoe-horn all list processing into list comps (or generator expressions): if it takes fancy gymnastics to write the code as a list comp / gen exp, it's probably better to use explicit looping. Also, readability counts: an explicit loop that's a few percent slower than a list comp may be preferable if the list comp code is twice as hard to read. For further thoughts on these matters, please see Efficiency of list comprehensions.
I've edited the wording. Now I would like to see an answer to the question here that uses explicit loops. I'm going to continue to try to avoid reaching for the for loop first, and instead pause, and see how the problem can be cast with the handy tools Python gives us.
|

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.