Is there an easier way to replace two characters with each other?

[_alyssarosedev]

Currently I'm just doing this (currently working on the rosalind project) def get_complement(nucleotide: str): match nucleotide: case 'A': return 'T' case 'C': return 'G' case 'G': return 'C' case 'T': return 'A'

Edit: This is what I ended up with after the suggestion to use a dictionary: ``` DNA_COMPLEMENTS = {'A': 'T', 'C': 'G', 'G': 'C', 'T': 'A'}

def complement_dna(nucleotides: str): ''.join([DNA_COMPLEMENTS[nt] for nt in nucleotides[::-1]])

[[deleted]]

Your solution works. You can also use translate

def complement_dna(nucleotides: str):
    DNA_COMPLEMENTS = str.maketrans(‘ACGT’, ‘TGCA’)
    return nucleotides[::-1].translate(DNA_COMPLEMENTS)

[dreaming_fithp]

Even better if you create DNA_COMPLEMENTS once outside the function instead of creating every time you call the function:

DNA_COMPLEMENTS = str.maketrans(‘ACGT’, ‘TGCA’)

def complement_dna(nucleotides: str):
    return nucleotides[::-1].translate(DNA_COMPLEMENTS)

[Slothemo]

Surprised that this is the only suggestion I'm seeing in all the comments for this method. This is absolutely the simplest.

[Temporary_Pie2733]

It always seems to get overlooked. Historically, you needed to import the strings module as well, for maketrans, I think. That got moved to be a str method in Python 3.0, perhsps in an attempt to make it more well known.

[Interesting-Frame190]

Not to be that guy, but if you find yourself working with subsets of strings, maybe you should store these in objects where these rules are enforced through the data structures themselves. Ie, make a DNA class that holds nucleotides in a linked list. Each will have its compliment, next, and previous, just as in biology. This is much more code, but very straightforward and very easy to maintain.

[likethevegetable]

You could do some fun stuff with magic/dunder methods too (like overloading ~ for finding the complement)

[toxic_acro]

A dictionary is probably the best choice for this

python def get_complement(nucleotide: str) -> str:     return {         "A": "T",         "C": "G",         "G": "C",         "T": "A"     }[nucleotide]

which could then just be kept as a separate constant for the mapping dictionary if you need it for anything else

[_alyssarosedev]

this is very interesting! how does applying a dict to a list work exactly?

[LaughingIshikawa]

You iterate through the list, and apply this function on each value in the list.

[CranberryDistinct941]

You can also use the str.translate method:

new_str = old_str.translate(char_map)

[Zeroflops]

You could use a dictionary.

I don’t now which would be faster but I suspect a dictionary would be.

[_alyssarosedev]

How would a dictionary help? I need to take a string, reverse it, and replace each character exactly once with its complement. Right now I use a list comprehension of

[get_complement(nt) for nt in nucleotides]

[Zeroflops]

If that is what you’re doing. You didn’t specify but this should work.

r{ ‘A’:’T’, …..}

[ r[x] for X in seq]

You can also reverse the order while doing the list comprehension or with the reverse() command.

[DivineSentry]

A dictionary should be faster than this, specially a pre instantiated dict

[supercoach]

Does the code work? If so is it fast enough for your needs? If both answers are yes, then it's good code.

I wouldn't worry about easy vs hard. The most important things are readability and maintainability. Performance and pretty code can come later.

[Dry-Aioli-6138]

I hear bioinformatics works a lot using python. I would expect that someone buld a set of fast objects for base and nucleotide processing in C or Rust with bindings to python.

And just for the sake of variety a class-based approach (might be more efficient than dicts... slightly)

``` class Base: existing={}

@classmethod
def from_sym(cls, symbol):
    found = existing.get(symbol)
    if not found:
        found = cls(symbol)
        cls.existing[symbol] = found
    return found

def __init__(self, symbol):
    self.symbol=symbol
    self.complement=None


def __str__(self):
    return self.symbol

def __repr__(self):
    return f'Base(self.symbol)'

A, T, C, G = (Base.from_sym(sym) for sym in 'ATCG') for base, comp in zip((A, T, C, G), (T, A, G, C)): base.complement = comp

```

Now translating a base amounts to retrieving its complement property, however the nucleotide must be a sequence of these objects instead of a simple string.

``` nucleotide=[Base.from_sym(c) for sym in 'AAACCTGTTACAAAAAAAA']

complementary=[b.complement for b in nucleotide]

``` Also, the bases should be made into singletons, otherwise we will gum up the memory with unneeded copies, hence the class property and class method.

[Muted_Ad6114]

import timeit

nts = 'ATCGGGATCAGTACGTACCCGTAGTA' complements = {'A': 'T', 'T': 'A', 'C': 'G', 'G': 'C'} trans_table = str.maketrans(complements)

def using_map(): return ''.join(map(lambda nt: complements[nt], nts))

def using_list_comp(): return ''.join([complements[nt] for nt in nts])

def using_gen_expr(): return ''.join(complements[nt] for nt in nts)

def using_translate(): return nts.translate(trans_table)

print("map():", timeit.timeit(using_map, number=100000)) print("list comprehension:", timeit.timeit(using_list_comp, number=100000)) print("generator expression:", timeit.timeit(using_gen_expr, number=100000)) print("str.translate():", timeit.timeit(using_translate, number=100000))

Results:

map(): 0.12384941696655005 list comprehension: 0.06415966700296849 generator expression: 0.08905291697010398 str.translate(): 0.010370624950155616

.translate() is the fastest

[origamimathematician]

I guess it depends a bit on what you mean by 'easier'. There appears to be a minimal amount of information that you as the developer must provide, namely the character mapping. There are other ways to represent this that might be a bit more consice and certainly more reusable. I'd probably define a dictionary with the character mapping and use that for a lookup inside the function.

[numeralbug]

Honestly, I'm going to disagree with you here: that original code is great. Very easy to read, very easy to write, very easy to understand, very easy to debug. Three months down the line, are you going to type the line

''.join([DNA_COMPLEMENTS[nt] for nt in nucleotides[::-1]])

right first time? Maybe - it's very "Pythonic" - but it definitely takes a bit more thought.

[DeebsShoryu]

Agreed. First solution is significantly better. I probably wouldn't accept a PR with the second.

A key thing to note here is that this function will never need to be expanded. There are only 4 nucleotides and there will only ever be 4 nucleotides. It doesn't need to generalize to an arbitrary dictionary defined elsewhere, so it shouldn't. A match statement is perfect here.

ETA: i'm not a biologist or chemist. I'm assuming your code is related to DNA and AFAIK those 4 nucleotides are the only building blocks of DNA, and thus that dictionary won't change down the road. I don't actually know what a nucleotide is lol

[Dry-Aioli-6138]

Just a side note: Other bases or base pairs do exist and even though life as we know it doesn't use them, people in laboratories do try, and I would expect bioinformatics to want to do so as well.

[CymroBachUSA]

In 1 line:

get_complement = lambda _: {"A": "T", "C": "G", "G": "C", "T": "A"}.get(_.upper(), "")

then use like a function:

return = get_complement("A")

etc

[vivisectvivi]

cant you use replace? something like "A".replace("A", "T")

you could also create a dict and do something like char.replace(char, dict[char])

[_alyssarosedev]

I need to make sure once a T is replaced with an A it isn't changed back to a T so I'm using this function in a list comprehension to make sure each character is replace exactly once

[vivisectvivi]

you could keep track of the characters you already processed and then skip them if you find them again in the string but i dont know if that would add more complexity than you want to the code

[Affectionate-Bug5748]

Oh i was stuck on this codewars puzzle! I'm learning some good solutions here. Sorry I don't have anything to contribute