diff --git a/Portefolio_samuel.ipynb b/Portefolio_samuel.ipynb deleted file mode 100644 index 1f1d192..0000000 --- a/Portefolio_samuel.ipynb +++ /dev/null @@ -1,1850 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Portefólio-Grupo 3\n", - "\n", - "- Duarte Velho\n", - "- Mariana Reis \n", - "- Ricardo Oliveira pg(53501)\n", - "- Samuel Baptista" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "y3M80NpQfegz" - }, - "source": [ - "\n", - "\n", - "## Tarefa 1- Métodos de strings\n", - "\n", - "
\n", - "Nesta primeira semana, vamos abordar alguns métodos que podem ser utilizados com strings, métodos que são bastante uteis quando é ncessário ao longo do codigo trabalhar com variaveis em formato string. Com o intuito de apresentar 3 métodos de strings, procedemos à criação de uma função que calcule o conteudo GC, em percentagem, numa cadeia de DNA.\n", - "\n", - "A função gc_content recebe como argumento uma sequência de nucleoticos em formato string e devolve um float que corresponde ao conteúdo de guaninas e citosinas, em percentagem, da sequência. Nesta função utilizaram-se métodos de strings de modo a trata a sequência fornecida com o intuito de padronizar a cadeia e permitir a contagem de \"C\" e \"G\". O método upper() garante que todos os caracteres fornecidos estão em letra maiúscula, enquanto o método strip () remove possíveis espaços em branco que possam ter sido inseridos nas extremidades da cadeia, o que levaria a erros no cálculo do conteudo CG. Este método apresenta um parâmetro opcional onde se pode forncer, em formato de string, os caracteres que se pretende eliminar, sendo que, por padrão, o método remove espaços em branco. Por fim, aplicou-se o método replace() de modo a garantir que a cadeia não possui espaços no seu interior. O método replace() apresenta 3 parâmetros, sendo 2 deles obrigatórios. O primeiro parâmetro corresponde ao caracter antigo que se pretende substituir, o segundo parâmetro diz respeito ao caracter que irá substituir o antigo e, por fim, o último parâmetro especifica quantas ocorrências do caracter antigo se pretendem substituir, por padrão ocorre a substituição de todas as ocorrências.
\n", - "Para se realizar a contagem das bases de interesse usou-se o método count(), que possui 3 parâmetros. O primeiro parâmetro é obrigatório e corresponde ao caracter que se pretende realizar a contagem. O segundo (opcional) corresponde a um valor inteiro que indica a partir de que posição da string se pretende iniciar a contagem, definido por padrão definido como 0. Por fim, o último parâmetro (opcional) é um valor inteiro que vai indicar a posição do local na string onde se vai terminar a contagem, por padrão, está definido para terminar no fim da string.
\n", - "\n", - "A função valid_strand verifica se a cadeia de nucleotidos fornecida recebe como argumento uma cadeia de DNA ou RNA valida devolvendo um booleano que será True se a cadeia for válida. Para verificar a validade da cadeia aplica-se os métodos strip(), upper() e replace dos caracteres A, C, G, T e ' ' por uma string vazia (''). Se a cadeia fornecida for válida é esperado que após a aplicação destes métodos se obtenha uma string vazia no final." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "id": "EW7p49Avq1zn" - }, - "outputs": [], - "source": [ - "def gc_content(DNA:str)->float:\n", - " '''\n", - " Função que recebe uma cadeia de DNA e calcula o teor de GC da cadeia\n", - " \n", - " Parameters\n", - " -----\n", - " DNA:str\n", - " cadeia de DNA na qual se pretende determinar o teor de GC\n", - "\n", - " Returns\n", - " -----\n", - " Float\n", - " Valor do teor de GC calculada para a cadeia de DNA fornecida\n", - "\n", - " Raises\n", - " ----\n", - " AssertionError\n", - " No caso de não ser fornecida nenhuma cadeia de DNA\n", - " \n", - " '''\n", - " assert len(DNA) != 0, 'A cadeia fornecida não pode ser uma string vazia' #garante que uma string vazia nao e fornecida\n", - " DNA = DNA.strip().upper().replace(' ','')\n", - " C_count = DNA.count('C')\n", - " G_count = DNA.count('G')\n", - " GC_content = (C_count/len(DNA))*100 + (G_count/len(DNA))*100\n", - " GC_content = round(GC_content, 2)\n", - " return GC_content\n", - "\n", - "\n", - "assert gc_content (\"aaataTaTTaa\") == (00.00)\n", - "assert gc_content ('atgc AG CT' ) == (50.00)\n", - "assert gc_content (' atgGCT ') == (50.00)\n", - "assert gc_content ('GGGCGCCCCGC') == (100.00)\n", - "\n", - "\n", - "def valid_strand(strand:str)->bool:\n", - " '''\n", - " Função que recebe uma cadeia e verifica se é uma cadeia válida de DNA\n", - " \n", - " Parameters\n", - " -----\n", - " Strand:str\n", - " cadeia que se pretende verificar se corresponde a uma cadeia de DNA válida\n", - "\n", - " Returns\n", - " -----\n", - " Bool\n", - " Retorna verdadeiro se a sequência for uma cadeia de DNA válido, caso contrário retorna falso\n", - "\n", - " '''\n", - " return strand.strip().upper().replace('A', '').replace('C', '').replace('G', '').replace('T', '').replace(' ','') == ''\n", - "\n", - "assert valid_strand ('')\n", - "assert valid_strand ('AAAAT')\n", - "assert valid_strand ('AAaaaaAA')\n", - "assert valid_strand ('AAA ttttcg t')\n", - "assert not valid_strand ('Uu')\n", - "assert not valid_strand ('aaaGTTT1TCCCC0')\n", - "assert not valid_strand ('XAAABQR')\n", - "assert not valid_strand ('AGT_CCA-GGGGCAA')\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "PNUoRKcqblJ-", - "outputId": "69517262-7e4d-4f25-dad0-2793c8597434" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "O teor de GC na cadeia fornecida é de 42.86%.\n" - ] - } - ], - "source": [ - "strand = input()\n", - "\n", - "if valid_strand (strand) == True:\n", - " print('O teor de GC na cadeia fornecida é de {}%.'.format(gc_content (strand)))\n", - "else:\n", - " print('Ocorreu um erro, verifica a cadeia fornecida')\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "wBpKyqE5yfkf" - }, - "source": [ - "\n", - "## Tarefa 2- Complemento inverso e tradução de codões\n", - "\n", - "A tarefa da semana 2 consiste em criar um conjunto de funções que permitam realizar a tradução de uma sequência de nucleótidos bem como a obtenção do complemento inverso de uma dada sequência de nucleotidos.\n", - "\n", - "**Tradução de codões**\n", - "
\n", - "Primeiramente definiou-se a função cadeia_valida, que é utilizada para verificar se a sequência de nucleotidos fornecida é uma sequência válida, pois apenas se pretende realizar a tradução de sequências de nucleótidos válidas. Esta função pode receber quer sequências de DNA, quer de RNA.
\n", - "Em seguida, definui-se a função tipo_seq que é necesária para identificar se a sequência fornecida é de DNA ou de RNA de modo a escolher a tabela de tradução de codões adequada.
\n", - "Depois definiu-se a função tabela_traducao, sendo que esta utiliza o resultado da função anterior e devolve a tabela de tradução de codões standard adequada para o tipo de ácido nucleico que se pretende realizar a tradução.
\n", - "Após isto, criou-se a função acid_nuc_2codons que é a responsável por extrair todos os codões da sequência de nucleotidos sendo que a função começa a extrair os codões apartir do início da sequência e apenas permite a obtenção dos codões para uma grelha de leitura que corresponde a grelha fornecida.
\n", - "Por fim, definiu-se a função traducao_acid_nuc que integra as 4 funções anteriores de modo a validar a sequência de nucleotidos, identificar o tipo da sequência de nucleotidos, escolher a tabela de tradução adequada e a obtenção de todos os codões presentes na sequência. Após isto, ocorre a tradução propiamente dita, onde os codões são substituidos pelo respetivo aminoacido e adicionados a variável seq_aa que no fim vai ser retornada e corresponde à sequência de aminoacidos obtida para a sequência de nucleotidos.
\n", - "
\n", - "\n", - "**Complemento inverso**\n", - "
\n", - "A funcão complemento_inverso, vai utilizar uma sequência de DNA e devolver o seu complemento inverso. Para isso utiliza a função tipo_seq que vai validar se a sequência de nucleotidos fornecida é valida e se corresponde a uma sequência de DNA. Caso isto se verifique, vai ocorrer a substituição de cada base pela sua base complementar e a inversão da sequência, isto é, a sequência passa a ser apresentada do fim para o início\n", - "
" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "id": "nszelJ0QyrC-" - }, - "outputs": [], - "source": [ - "# tradução de codões\n", - "def cadeia_valida (strand:str)->bool:\n", - " '''\n", - " Verifica se a cadeia de nucleotidos fornecida é válida\n", - "\n", - " Parameters\n", - " ----------\n", - " strand: str\n", - " Uma sequência de nucleótidos\n", - " DNA: bool\n", - " Identifica que a sequencia de nucleotidos é de DNA\n", - "\n", - " Returns\n", - " ---------\n", - " bool\n", - " Retorna verdadeiro se a cadeia fornecida for um cadeia de nucleótidos válida \n", - "\n", - " Raises\n", - " ---------\n", - " AssertionError\n", - " Se a sequencia não for fornecida no formato de string\n", - " '''\n", - " assert type(strand)==str, \"A cadeia deve ser fornecida no formato de string\"\n", - " \n", - " for pos,base in enumerate(strand.upper().replace(\" \",\"\")): \n", - " if base not in \"AGCTU\":\n", - " print(f'O elemento {base}, na posição {pos+1}, não é um nucleotido válido')\n", - " return False\n", - " \n", - " if \"T\" in strand.upper() and \"U\" in strand.upper():\n", - " print('A sequencia de nucleotidos não é valida, pois possui T e U na mesma cadeia')\n", - " return False\n", - " \n", - " return True\n", - "\n", - "def tipo_seq(strand:str)->str:\n", - " '''\n", - " Identifica o tipo de acido nucleico da sequencia fornecida\n", - "\n", - " Parameters\n", - " ----------\n", - " strand: str\n", - " Uma sequência de nucleótidos\n", - "\n", - " Returns\n", - " ---------\n", - " str\n", - " Retorna a classificação da cadeia de nucleótidos fornecida\\n\n", - " Por padrão, caso não esteja presente na sequencia a base uracilo, a sequência vai ser classificada como DNA\n", - " \n", - " Raises\n", - " -------\n", - " AssertionError\n", - " Quando não é fornecida nenhuma sequência\\n\n", - " Se a sequência fornecida não for válida\n", - " '''\n", - "\n", - " assert len(strand)!= 0, \"Nenhuma cadeia foi fornecida\"\n", - " strand_valida= cadeia_valida(strand) #verificacao da validade da cadeia\n", - " assert strand_valida,\"A cadeia fornecida não é válida\"\n", - "\n", - " if \"U\" in strand.upper(): return \"RNA\"\n", - " else: return \"DNA\"\n", - " \n", - "def tabela_traducao(tipo_acid_nuc:str)->dict[str:str]:\n", - " '''\n", - " Devolve a respetiva tabela de tradução para o acido nucleico fornecido\n", - "\n", - " Parameters\n", - " ----------\n", - " tipo_acid_nuc: str\n", - " Classificacao do acido nucleico. Apenas pode assumir o valor de DNA ou RNA\n", - " \n", - " Returns\n", - " ---------\n", - " dict\n", - " Devolve a tabela de tradução STANDARD para o respetivo acido nucleico\n", - "\n", - " Raises\n", - " ---------\n", - " AssertionError\n", - " Quando o tipo de acido nucleico fornecido nao e valido\n", - " '''\n", - "\n", - " assert tipo_acid_nuc.upper() in ['DNA','RNA'], f'O valor {tipo_acid_nuc} não é um tipo de acido nucleico valido'\n", - "\n", - " if tipo_acid_nuc.upper()==\"RNA\":\n", - " RNA_codon_table={\n", - " \"UUU\":\"F\", \"CUU\":\"L\", \"AUU\":\"I\", \"GUU\":\"V\", \"UUC\":\"F\", \"CUC\":\"L\", \"AUC\":\"I\", \"GUC\":\"V\",\n", - " \"UUA\":\"L\", \"CUA\":\"L\", \"AUA\":\"I\", \"GUA\":\"V\", \"UUG\":\"L\", \"CUG\":\"L\", \"AUG\":\"M\", \"GUG\":\"V\",\n", - " \"UCU\":\"S\", \"CCU\":\"P\", \"ACU\":\"T\", \"GCU\":\"A\", \"UCC\":\"S\", \"CCC\":\"P\", \"ACC\":\"T\", \"GCC\":\"A\",\n", - " \"UCA\":\"S\", \"CCA\":\"P\", \"ACA\":\"T\", \"GCA\":\"A\", \"UCG\":\"S\", \"CCG\":\"P\", \"ACG\":\"T\", \"GCG\":\"A\",\n", - " \"UAU\":\"Y\", \"CAU\":\"H\", \"AAU\":\"N\", \"GAU\":\"D\", \"UAC\":\"Y\", \"CAC\":\"H\", \"AAC\":\"N\", \"GAC\":\"D\",\n", - " \"UAA\":\"_\", \"CAA\":\"Q\", \"AAA\":\"K\", \"GAA\":\"E\", \"UAG\":\"_\", \"CAG\":\"Q\", \"AAG\":\"K\", \"GAG\":\"E\",\n", - " \"UGU\":\"C\", \"CGU\":\"R\", \"AGU\":\"S\", \"GGU\":\"G\", \"UGC\":\"C\", \"CGC\":\"R\", \"AGC\":\"S\", \"GGC\":\"G\",\n", - " \"UGA\":\"_\", \"CGA\":\"R\", \"AGA\":\"R\", \"GGA\":\"G\", \"UGG\":\"W\", \"CGG\":\"R\", \"AGG\":\"R\", \"GGG\":\"G\"}\n", - " return RNA_codon_table\n", - " \n", - " else:\n", - " DNA_codon_table={\n", - " \"ATA\":\"I\", \"ATC\":\"I\", \"ATT\":\"I\", \"ATG\":\"M\", \"ACA\":\"T\", \"ACC\":\"T\", \"ACG\":\"T\", \"ACT\":\"T\",\n", - " \"AAC\":\"N\", \"AAT\":\"N\", \"AAA\":\"K\", \"AAG\":\"K\", \"AGC\":\"S\", \"AGT\":\"S\", \"AGA\":\"R\", \"AGG\":\"R\", \n", - " \"CTA\":\"L\", \"CTC\":\"L\", \"CTG\":\"L\", \"CTT\":\"L\", \"CCA\":\"P\", \"CCC\":\"P\", \"CCG\":\"P\", \"CCT\":\"P\",\n", - " \"CAC\":\"H\", \"CAT\":\"H\", \"CAA\":\"Q\", \"CAG\":\"Q\", \"CGA\":\"R\", \"CGC\":\"R\", \"CGG\":\"R\", \"CGT\":\"R\",\n", - " \"GTA\":\"V\", \"GTC\":'V', \"GTG\":'V', \"GTT\":\"V\", \"GCA\":\"A\", \"GCC\":\"A\", \"GCG\":\"A\", \"GCT\":\"A\",\n", - " \"GAC\":\"D\", \"GAT\":\"D\", \"GAA\":\"E\", \"GAG\":\"E\", \"GGA\":\"G\", \"GGC\":\"G\", \"GGG\":\"G\", \"GGT\":\"G\",\n", - " \"TCA\":\"S\", \"TCC\":\"S\", \"TCG\":\"S\", \"TCT\":\"S\", \"TTC\":\"F\", \"TTT\":\"F\", \"TTA\":\"L\", \"TTG\":\"L\",\n", - " \"TAC\":\"Y\", \"TAT\":\"Y\", \"TAA\":\"_\", \"TAG\":\"_\", \"TGC\":\"C\", \"TGT\":\"C\", \"TGA\":\"_\", \"TGG\":\"W\"}\n", - " return DNA_codon_table\n", - "\n", - "def acid_nuc_2codons(strand:str)->list[str]:\n", - " '''\n", - " Devolve todos os codões para uma determinada sequencia de nucleotidos\n", - " \n", - " Parameters\n", - " ----------\n", - " Strand: str\n", - " Uma sequência válida de um acido nucleico\n", - "\n", - " Returns\n", - " ---------\n", - " codoes: list\n", - " Devolve uma lista de strings que contem todos os codões\n", - "\n", - " Raises\n", - " -------\n", - " AssertionError\n", - " Quando a sequencia fornecida não é valida\\n\n", - " Caso a sequência possua tamanho inferior a 3\n", - " '''\n", - " cad_valida=cadeia_valida(strand)\n", - " assert cad_valida, 'A cadeia fornecida não é valida'\n", - " assert len(strand)>=3, 'A cadeia fornecida apenas possui {} bases. São necessárias pelo menos 3 bases para formar codões'.format(len(strand))\n", - " codoes=[]\n", - " for I in range(0,len(strand)-2,3):\n", - " codao=strand[I:I+3]\n", - " codoes.append(codao.upper())\n", - " return codoes\n", - "\n", - "def traducao_acid_nuc(strand:str)->str:\n", - " '''\n", - " Realiza a traducao da sequencia de nucleotidos para uma sequencia de aminoacidos\n", - "\n", - " Parameters\n", - " ----------\n", - " Strand: str\n", - " Sequência de um acido nucleico\n", - "\n", - " Returns\n", - " ---------\n", - " seq_aa: str\n", - " Sequência de aminoácidos resultantes da tradução\n", - "\n", - " Raises\n", - " -------\n", - " AssertionError\n", - " Se a cadeia fornecida não for uma sequencia de nucleotidos valida\\n\n", - " Quando a cadeia fornecida é uma string vazia\\n\n", - " Caso a cadeia fornecida possua tamanho inferior a 3\n", - " '''\n", - "\n", - " tipo_acid_nuc=tipo_seq(strand) #classificacao do acido nucleico\n", - " codoes= acid_nuc_2codons(strand) #gerarcao de todos os codoes da sequencia\n", - " tabela_codoes=tabela_traducao(tipo_acid_nuc) #obtencao da tabela de traducao \n", - " seq_aa=\"\"\n", - "\n", - " for codao in codoes: seq_aa+=tabela_codoes[codao] #traducao dos codoes\n", - " return seq_aa" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "# complemento inverso\n", - "def complemento_inverso (strand:str)->str:\n", - " '''\n", - " Determina a cadeia complementar inversa de uma sequencia de DNA \n", - "\n", - " Parameters\n", - " ----------\n", - " Strand: str\n", - " Sequência de nucleotidos\n", - "\n", - " Returns\n", - " ---------\n", - " complementar_inv: str\n", - " Complementar inverso da sequência de DNA fornecida\n", - "\n", - " Raises\n", - " -------\n", - " AssertionError\n", - " Se não for fornecida nenhuma sequencia\\n\n", - " Caso a sequencia de nucleotidos não seja valida\\n\n", - " Quando a sequencia é de RNA\n", - " '''\n", - " tip_seq=tipo_seq(strand) #classificacao do acido nucleico e verificacao da sua validade\n", - " assert tip_seq==\"DNA\", \"A sequência fornecida tem de ser de DNA\"\n", - " complementar=\"\"\n", - " \n", - " DNA_bases_complementares={\"A\":\"T\",\"T\":\"A\",\"G\":\"C\",\"C\":\"G\"}\n", - " for base in strand.upper(): complementar+=DNA_bases_complementares[base]\n", - " \n", - " return complementar[::-1]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "### Testes de unidade" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "id": "T2etBLCW0_7h" - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "test_acid_nuc_2codons (__main__.Test_traducao.test_acid_nuc_2codons) ... ok\n", - "test_cadeia_valida (__main__.Test_traducao.test_cadeia_valida) ... ok\n", - "test_complemento_inverso (__main__.Test_traducao.test_complemento_inverso) ... ok\n", - "test_tabela_traducao (__main__.Test_traducao.test_tabela_traducao) ... ok\n", - "test_tipo_sequencia (__main__.Test_traducao.test_tipo_sequencia) ... ok\n", - "test_traducao_acid_nuc (__main__.Test_traducao.test_traducao_acid_nuc) ... ok\n", - "\n", - "----------------------------------------------------------------------\n", - "Ran 6 tests in 0.013s\n", - "\n", - "OK\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "A sequencia de nucleotidos não é valida, pois possui T e U na mesma cadeia\n", - "O elemento P, na posição 1, não é um nucleotido válido\n", - "O elemento 3, na posição 6, não é um nucleotido válido\n", - "A sequencia de nucleotidos não é valida, pois possui T e U na mesma cadeia\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "#testes de unidade\n", - "import unittest\n", - "\n", - "class Test_traducao(unittest.TestCase):\n", - " def test_cadeia_valida(self):\n", - " validas = [\"\",\"AAA\",\"ATTCG\",\"UUAGAAGCAG\",\"attcg\",\"AAA UUUGCGA\",\"aTTcg\"]\n", - " invalidas = [\"UAAGT\",\"PANDA\",\"AAGCG324G\",\"AAAaaggttgU\"]\n", - " for x in validas:\n", - " self.assertTrue(cadeia_valida(x))\n", - " for y in invalidas:\n", - " self.assertFalse(cadeia_valida(y))\n", - "\n", - " def test_tipo_sequencia(self):\n", - " rna = [\"AAAUGCUA\",\"UUU\",\"GGCgauCA\"]\n", - " dna = [\"AAAGTCG\",\"AAGGTCCCAG\",\"AAA\",\"TTTT\",\"GGGG\",\"CCCC\",\"ATcGT\"]\n", - " for x in rna:\n", - " self.assertEqual(tipo_seq(x),\"RNA\")\n", - " \n", - " for y in dna:\n", - " self.assertEqual(tipo_seq(y),\"DNA\")\n", - "\n", - " def test_complemento_inverso(self):\n", - " sequencia = [\"ATA\",\"ATAGC\",\"GGGGaaaaaaaatttatatat\"]\n", - " complento_reverso = [\"TAT\",\"GCTAT\",\"ATATATAAATTTTTTTTCCCC\"]\n", - "\n", - " for x,y in zip(sequencia,complento_reverso):\n", - " self.assertEqual(complemento_inverso(x),y)\n", - " \n", - " def test_tabela_traducao(self):\n", - " DNA_codon_table={\n", - " \"ATA\":\"I\", \"ATC\":\"I\", \"ATT\":\"I\", \"ATG\":\"M\", \"ACA\":\"T\", \"ACC\":\"T\", \"ACG\":\"T\", \"ACT\":\"T\",\n", - " \"AAC\":\"N\", \"AAT\":\"N\", \"AAA\":\"K\", \"AAG\":\"K\", \"AGC\":\"S\", \"AGT\":\"S\", \"AGA\":\"R\", \"AGG\":\"R\", \n", - " \"CTA\":\"L\", \"CTC\":\"L\", \"CTG\":\"L\", \"CTT\":\"L\", \"CCA\":\"P\", \"CCC\":\"P\", \"CCG\":\"P\", \"CCT\":\"P\",\n", - " \"CAC\":\"H\", \"CAT\":\"H\", \"CAA\":\"Q\", \"CAG\":\"Q\", \"CGA\":\"R\", \"CGC\":\"R\", \"CGG\":\"R\", \"CGT\":\"R\",\n", - " \"GTA\":\"V\", \"GTC\":'V', \"GTG\":'V', \"GTT\":\"V\", \"GCA\":\"A\", \"GCC\":\"A\", \"GCG\":\"A\", \"GCT\":\"A\",\n", - " \"GAC\":\"D\", \"GAT\":\"D\", \"GAA\":\"E\", \"GAG\":\"E\", \"GGA\":\"G\", \"GGC\":\"G\", \"GGG\":\"G\", \"GGT\":\"G\",\n", - " \"TCA\":\"S\", \"TCC\":\"S\", \"TCG\":\"S\", \"TCT\":\"S\", \"TTC\":\"F\", \"TTT\":\"F\", \"TTA\":\"L\", \"TTG\":\"L\",\n", - " \"TAC\":\"Y\", \"TAT\":\"Y\", \"TAA\":\"_\", \"TAG\":\"_\", \"TGC\":\"C\", \"TGT\":\"C\", \"TGA\":\"_\", \"TGG\":\"W\"}\n", - " \n", - " RNA_codon_table={\n", - " \"UUU\":\"F\", \"CUU\":\"L\", \"AUU\":\"I\", \"GUU\":\"V\", \"UUC\":\"F\", \"CUC\":\"L\", \"AUC\":\"I\", \"GUC\":\"V\",\n", - " \"UUA\":\"L\", \"CUA\":\"L\", \"AUA\":\"I\", \"GUA\":\"V\", \"UUG\":\"L\", \"CUG\":\"L\", \"AUG\":\"M\", \"GUG\":\"V\",\n", - " \"UCU\":\"S\", \"CCU\":\"P\", \"ACU\":\"T\", \"GCU\":\"A\", \"UCC\":\"S\", \"CCC\":\"P\", \"ACC\":\"T\", \"GCC\":\"A\",\n", - " \"UCA\":\"S\", \"CCA\":\"P\", \"ACA\":\"T\", \"GCA\":\"A\", \"UCG\":\"S\", \"CCG\":\"P\", \"ACG\":\"T\", \"GCG\":\"A\",\n", - " \"UAU\":\"Y\", \"CAU\":\"H\", \"AAU\":\"N\", \"GAU\":\"D\", \"UAC\":\"Y\", \"CAC\":\"H\", \"AAC\":\"N\", \"GAC\":\"D\",\n", - " \"UAA\":\"_\", \"CAA\":\"Q\", \"AAA\":\"K\", \"GAA\":\"E\", \"UAG\":\"_\", \"CAG\":\"Q\", \"AAG\":\"K\", \"GAG\":\"E\",\n", - " \"UGU\":\"C\", \"CGU\":\"R\", \"AGU\":\"S\", \"GGU\":\"G\", \"UGC\":\"C\", \"CGC\":\"R\", \"AGC\":\"S\", \"GGC\":\"G\",\n", - " \"UGA\":\"_\", \"CGA\":\"R\", \"AGA\":\"R\", \"GGA\":\"G\", \"UGG\":\"W\", \"CGG\":\"R\", \"AGG\":\"R\", \"GGG\":\"G\"}\n", - "\n", - " self.assertEqual(tabela_traducao(\"RNA\"),RNA_codon_table) \n", - " self.assertEqual(tabela_traducao(\"DNA\"),DNA_codon_table)\n", - "\n", - " def test_acid_nuc_2codons(self):\n", - " seq =[\"AAA\", \"AAGA\",\"CGAAGUACG\"]\n", - " codoes =[[\"AAA\"],[\"AAG\"],[\"CGA\",\"AGU\",\"ACG\"]]\n", - "\n", - " for x,y in zip(seq,codoes):\n", - " self.assertEqual(acid_nuc_2codons(x),y)\n", - " \n", - " def test_traducao_acid_nuc(self):\n", - " seq = [\"AUGUGGUUC\",\"ATGTGGTTC\",\"AUGAUCUCGUAA\",\"ATGATCTCGTAA\"]\n", - " seq_aa = [\"MWF\",\"MWF\",\"MIS_\", \"MIS_\"]\n", - "\n", - " for x,y in zip(seq,seq_aa):\n", - " self.assertEqual(traducao_acid_nuc(x),y)\n", - " \n", - "unittest.main(argv=[''], verbosity=2, exit=False)\n", - " " - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "W25Qvc7syufp" - }, - "source": [ - "\n", - "## Tarefa 3- Tradução do DNA, ORF (open reading frames) e extração de todas as proteínas possíveis\n", - "\n", - "
\n", - "\n", - "Nesta tarefa é proposto que a partir de uma sequência de DNA se proceda à extração de todas as proteínas que podem ser codificadas por uma sequência de DNA nas várias reading frames existentes. Para se realizar a extração de todas as proteínas que se encontram codificadas numa sequência de DNA é necessário determinar os codões de cada reading frame, realizar a tradução dos codões de acordo com uma tabela de tradução de codões considerando que podem existir vários codões de iniciação para cada tabela de tradução utilizada, extrair, para cada sequência de aminoacidos resultante, todas as possíveis proteínas e, por fim, apresentar as diversas proteínas que é possível obter da sequência de DNA.
\n", - "\n", - "Para atingir este objetivo é necessário definir as seguintes funções:
\n", - "Uma função que valide a sequência de DNA fornecida e uma função que permita obter o complementar inverso do DNA em estudo. Estas funções foram definidas na tarefa anterior (tipo_sep e complemento_inverso)
\n", - "Para se obter os codões de uma determinada reading frame criou-se a função rf_codoes, que foi posteriormente integrada na função all_rfs que permite obter os codões para todas as reading frames possíveis.
\n", - "Definiu-se a função codon_table de modo a poder selecionar a tablela de tradução adequada, isto é, permitir ajustar a tabela de tradução conforme o organismo da qual proveem o DNA. A função start_codon foi definida para verificar se o codão que se pretende usar para iniciar a tradução de proteínas constitui uma alternativa válida para a tabela de tradução utilizada enquanto a função stop_codons foi definida com o mesmo inuito, mas para os codões de stop.\n", - "Em seguida criou-se a função traducao_rf de modo a poder realizar a tradução dos codões para cada reading frame. Por fim, definiu-se a função find_prots que encontra as possíveis proteínas existentes na sequência de aminoacidos que resulta da tradução.
\n", - "A função all_prots integra todas as funções abordadas anteriormente e devolve um conjunto de proteínas que corresponde a todas as proteínas distinas que são codificadas.\n", - "
" - ] - }, - { - "cell_type": "code", - "execution_count": 45, - "metadata": {}, - "outputs": [], - "source": [ - "def rf_codoes(strand:str,reading_frame=0)->list[str]:\n", - " '''\n", - " Extrai todos os codões de uma sequência de DNA para uma determinada reading frame\n", - "\n", - " Parameters\n", - " -----\n", - " strand: str\n", - " Cadeia de DNA da qual se pretende realizar a extração dos codões para um determinada ORF\n", - " \n", - " reading_frame: int\n", - " Corresponde à reanding frame que se pretende utilizar. Por padrão assume o valor 0, mas pode também assumir o valor 1 e 2\n", - "\n", - " Returns\n", - " -------\n", - " codoes: list[str]\n", - " Corresponde aos vários codões para a reading frame indicada\n", - "\n", - " Raises\n", - " ------\n", - " AssertionError\n", - " Se a variavél strand não for do tipo string\\n\n", - " Caso a cadeia fornecida não seja válida e/ou não seja uma cadeia de DNA\\n\n", - " Quando o valor do parametro reading_frame não está entre 0 e 2 inclusive e/ou não é um inteiro\n", - " '''\n", - " assert type(strand)==str #forcar a variavel strand a ser uma string\n", - " assert tipo_seq(strand)=='DNA','A sequência fornecida deve ser de DNA' #funcao da semana anterior\n", - " assert reading_frame >=0 and reading_frame<=2 and type(reading_frame)==int,\"A reading frame fornecida deve ser um inteiro entre 0 e 2\"\n", - " \n", - " codoes=[strand[indice:indice+3].upper() for indice in range(reading_frame,len(strand)-2,3)]\n", - " \n", - " return codoes\n", - "\n", - "def all_rfs(strand:str)->list[list[str]] :\n", - " '''\n", - " Devolve todos os codões para cada reading frame possível da sequencia de DNA indicada\n", - "\n", - " Parameters\n", - " ----------\n", - " strand: str\n", - " Cadeia de DNA em estudo\n", - "\n", - " Returns\n", - " ----------\n", - " rfs_codoes: list[list[str]]\n", - " Corresponde a todos os codões possíveis para as várias reading frames\n", - "\n", - " Raises\n", - " -------\n", - " AssertionError\n", - " Se a sequencia fornecida não for válida e/ou não for uma sequência de DNA\\n\n", - " Quando a strand é uma string vazia\n", - " '''\n", - " assert type(strand)==str\n", - " inv=complemento_inverso(strand) #funcao da semana passada\n", - " rfs_codoes=[rf_codoes(strand,I)for I in range(3)] + [rf_codoes(inv,I) for I in range(3)]\n", - " return rfs_codoes\n", - "\n", - "def codon_table(genetic_code:str,nomes=False)->dict[str,str]:\n", - " '''\n", - " Devolve a tabela de tradução adequada para o codigo genético indicado\n", - "\n", - " Parameters\n", - " ----------\n", - " genetic_code: str\n", - " String que identifica o codigo genético a utilizar. Quando assume o valor de 'Vertebrate Mitochondrial' a\n", - " tabela fornecida é a da mitocondria do humano\n", - "\n", - " nomes: bool\n", - " Por padrao encontra-se definido como False. Pode também assumir o valor de True\n", - " \n", - " Returns\n", - " ---------\n", - " dict\n", - " Quando o parâmetros nomes assume o booleano False, devolve a tabela de tradução de codões para o \n", - " respetivo codigo genético na forma de dicionario\n", - "\n", - " codigos: list[str]\n", - " Quando o parâmetro nomes assume o valor True é devolvida uma lista com todos os códigos genéticos\n", - " que possuem uma tabela de tradução associada\n", - "\n", - " Raises\n", - " -------\n", - " AssertionError\n", - " Caso o codigo genético não seja fornecido em formato de string\\n\n", - " Quando o código genético fornecido não possui nenhuma tabela associada\n", - " '''\n", - " codigos=[\"Standard\",\"Vertebrate Mitochondrial\",\"Bacterial\"]\n", - " \n", - " if nomes:\n", - " return codigos\n", - "\n", - " else:\n", - " assert type(genetic_code)==str,'O parâmetro genetic_code apenas pode ser do tipo string'\n", - " assert genetic_code in codigos,f'O codigo genetico {genetic_code} não está disponível'\n", - " \n", - " if genetic_code==\"Standard\":\n", - " standard_table={\n", - " \"ATA\":\"I\", \"ATC\":\"I\", \"ATT\":\"I\", \"ATG\":\"M\", \"ACA\":\"T\", \"ACC\":\"T\", \"ACG\":\"T\", \"ACT\":\"T\",\n", - " \"AAC\":\"N\", \"AAT\":\"N\", \"AAA\":\"K\", \"AAG\":\"K\", \"AGC\":\"S\", \"AGT\":\"S\", \"AGA\":\"R\", \"AGG\":\"R\", \n", - " \"CTA\":\"L\", \"CTC\":\"L\", \"CTG\":\"L\", \"CTT\":\"L\", \"CCA\":\"P\", \"CCC\":\"P\", \"CCG\":\"P\", \"CCT\":\"P\",\n", - " \"CAC\":\"H\", \"CAT\":\"H\", \"CAA\":\"Q\", \"CAG\":\"Q\", \"CGA\":\"R\", \"CGC\":\"R\", \"CGG\":\"R\", \"CGT\":\"R\",\n", - " \"GTA\":\"V\", \"GTC\":'V', \"GTG\":'V', \"GTT\":\"V\", \"GCA\":\"A\", \"GCC\":\"A\", \"GCG\":\"A\", \"GCT\":\"A\",\n", - " \"GAC\":\"D\", \"GAT\":\"D\", \"GAA\":\"E\", \"GAG\":\"E\", \"GGA\":\"G\", \"GGC\":\"G\", \"GGG\":\"G\", \"GGT\":\"G\",\n", - " \"TCA\":\"S\", \"TCC\":\"S\", \"TCG\":\"S\", \"TCT\":\"S\", \"TTC\":\"F\", \"TTT\":\"F\", \"TTA\":\"L\", \"TTG\":\"L\",\n", - " \"TAC\":\"Y\", \"TAT\":\"Y\", \"TAA\":\"_\", \"TAG\":\"_\", \"TGC\":\"C\", \"TGT\":\"C\", \"TGA\":\"_\", \"TGG\":\"W\"}\n", - " return standard_table\n", - " \n", - " elif genetic_code == \"Vertebrate Mitochondrial\":\n", - " homo_verte_mito_table={\n", - " \"TTT\": \"F\", \"TCT\": \"S\", \"TAT\": \"Y\", \"TGT\": \"C\", \"TTC\": \"F\", \"TCC\": \"S\", \"TAC\": \"Y\", \"TGC\": \"C\", \n", - " \"TTA\": \"L\", \"TCA\": \"S\", \"TAA\": \"_\", \"TGA\": \"W\", \"TTG\": \"L\", \"TCG\": \"S\", \"TAG\": \"_\", \"TGG\": \"W\",\n", - " \"CTT\": \"L\", \"CCT\": \"P\", \"CAT\": \"H\", \"CGT\": \"R\", \"CTC\": \"L\", \"CCC\": \"P\", \"CAC\": \"H\", \"CGC\": \"R\",\n", - " \"CTA\": \"L\", \"CCA\": \"P\", \"CAA\": \"Q\", \"CGA\": \"R\", \"CTG\": \"L\", \"CCG\": \"P\", \"CAG\": \"Q\", \"CGG\": \"R\",\n", - " \"ATT\": \"I\", \"ACT\": \"T\", \"AAT\": \"N\", \"AGT\": \"S\", \"ATC\": \"I\", \"ACC\": \"T\", \"AAC\": \"N\", \"AGC\": \"S\",\n", - " \"ATA\": \"M\", \"ACA\": \"T\", \"AAA\": \"K\", \"AGA\": \"_\", \"ATG\": \"M\", \"ACG\": \"T\", \"AAG\": \"K\", \"AGG\": \"_\",\n", - " \"GTT\": \"V\", \"GCT\": \"A\", \"GAT\": \"D\", \"GGT\": \"G\", \"GTC\": \"V\", \"GCC\": \"A\", \"GAC\": \"D\", \"GGC\": \"G\",\n", - " \"GTA\": \"V\", \"GCA\": \"A\", \"GAA\": \"E\", \"GGA\": \"G\", \"GTG\": \"V\", \"GCG\": \"A\", \"GAG\": \"E\", \"GGG\": \"G\"}\n", - " return homo_verte_mito_table\n", - " \n", - " elif genetic_code==\"Bacterial\":\n", - " bacterial_table={\n", - " \"TTT\": \"F\", \"TCT\": \"S\", \"TAT\": \"Y\", \"TGT\": \"C\", \"TTC\": \"F\", \"TCC\": \"S\", \"TAC\": \"Y\", \"TGC\": \"C\",\n", - " \"TTA\": \"L\", \"TCA\": \"S\", \"TAA\": \"_\", \"TGA\": \"_\", \"TTG\": \"L\", \"TCG\": \"S\", \"TAG\": \"_\", \"TGG\": \"W\",\n", - " \"CTT\": \"L\", \"CCT\": \"P\", \"CAT\": \"H\", \"CGT\": \"R\", \"CTC\": \"L\", \"CCC\": \"P\", \"CAC\": \"H\", \"CGC\": \"R\",\n", - " \"CTA\": \"L\", \"CCA\": \"P\", \"CAA\": \"Q\", \"CGA\": \"R\", \"CTG\": \"L\", \"CCG\": \"P\", \"CAG\": \"Q\", \"CGG\": \"R\",\n", - " \"ATT\": \"I\", \"ACT\": \"T\", \"AAT\": \"N\", \"AGT\": \"S\", \"ATC\": \"I\", \"ACC\": \"T\", \"AAC\": \"N\", \"AGC\": \"S\",\n", - " \"ATA\": \"I\", \"ACA\": \"T\", \"AAA\": \"K\", \"AGA\": \"R\", \"ATG\": \"M\", \"ACG\": \"T\", \"AAG\": \"K\", \"AGG\": \"R\",\n", - " \"GTT\": \"V\", \"GCT\": \"A\", \"GAT\": \"D\", \"GGT\": \"G\", \"GTC\": \"V\", \"GCC\": \"A\", \"GAC\": \"D\", \"GGC\": \"G\", \n", - " \"GTA\": \"V\", \"GCA\": \"A\", \"GAA\": \"E\", \"GGA\": \"G\", \"GTG\": \"V\", \"GCG\": \"A\", \"GAG\": \"E\", \"GGG\": \"G\"}\n", - " return bacterial_table\n", - " \n", - "def start_codons(genetic_code:str)->list:\n", - " '''\n", - " Devolve todos os codões de iniciação possíveis para o codigo genético indicado\n", - "\n", - " Parameters\n", - " ----------\n", - " genetic_code: str\n", - " String que identifica o codigo genético a utilizar. Quando assume o valor de 'Vertebrate Mitochondrial' devolve os codões de iniciação\n", - " para a mitocondria do humano\n", - " \n", - " Returns\n", - " ----------\n", - " start: list[str]\n", - " Lista que contem todos os codões de iniciação possíveis para determinado código genético\n", - "\n", - " Raises\n", - " -------\n", - " AssertionError\n", - " Caso o codigo genético não seja fornecido em formato de string\\n\n", - " Quando o código genético fornecido não possui nenhuma tabela associada\n", - " '''\n", - " codigos=[\"Standard\",\"Vertebrate Mitochondrial\",\"Bacterial\"]\n", - " assert type(genetic_code)==str,'O parâmetro genetic_code apenas pode ser do tipo string'\n", - " assert genetic_code in codigos,f'O codigo genetico {genetic_code} não está disponível'\n", - " \n", - " if genetic_code==\"Standard\":\n", - " start=['ATG','CTG','TTG']\n", - " return start\n", - " \n", - " elif genetic_code == \"Vertebrate Mitochondrial\":\n", - " start=['ATG','ATT']\n", - " return start\n", - " \n", - " elif genetic_code==\"Bacterial\":\n", - " start=['ATG','ATA','ATC','ATT','CTG','TTG','GTC']\n", - " return start\n", - " \n", - "def stop_codons(genetic_code:str)->list[str]:\n", - " '''\n", - " Devolve todos os codões de stop possíveis para o codigo genético indicado\n", - "\n", - " Parameters\n", - " ----------\n", - " genetic_code: str\n", - " String que identifica o codigo genético a utilizar.\n", - " \n", - " Returns\n", - " ----------\n", - " stop: list[str]\n", - " Lista que contem todos os codões de stop possíveis para um determinado código genético\n", - "\n", - " Raises\n", - " -------\n", - " AssertionError\n", - " Caso o codigo genético não seja fornecido em formato de string\\n\n", - " Quando o código genético fornecido não possui nenhuma tabela associada\n", - " '''\n", - " codigos=[\"Standard\",\"Vertebrate Mitochondrial\",\"Bacterial\"]\n", - " assert type(genetic_code)==str,'O parâmetro genetic_code apenas pode ser do tipo string'\n", - " assert genetic_code in codigos,f'O codigo genetico {genetic_code} não está disponível'\n", - " \n", - " if genetic_code==\"Standard\":\n", - " stop=['TAA','TAG','TGA']\n", - " return stop\n", - " \n", - " elif genetic_code == \"Vertebrate Mitochondrial\":\n", - " stop=['TAA','TAG','AGA','AGG']\n", - " return stop\n", - " \n", - " elif genetic_code==\"Bacterial\":\n", - " stop=['TAA','TAG','TGA']\n", - " return stop\n", - "\n", - "def traducao_rf(all_rf_codoes:list[list[str]],genetic_code=\"Standard\",start_codon='ATG')-> list[str]:\n", - " '''\n", - " Devolve uma sequência de aminoácidos para cada reading frame\n", - "\n", - " Parameters\n", - " ----------\n", - " rf_codoes: list[list[str]]\n", - " Lista que contêm todos os codões em formato de string para uma determinada reading frame\n", - "\n", - " genetic_code: str\n", - " Indica que tabela de tradução deve ser utilizada. Por padrão utiliza a tabela standard\n", - "\n", - " start_codon: str\n", - " Indica qual o codão de iniciação a ser utilizada. Utiliza o codão ATG como default\n", - " \n", - " Returns\n", - " ---------\n", - " seq_aas: list[str]\n", - " Sequência de aminoácidos resultantes da tradução para cada reading frame\n", - "\n", - " Raises\n", - " -------\n", - " AssertionError\n", - " Caso o codão de start fornecido não seja um codão válido ou não seja fornecido no formato de string\\n\n", - " Se o código genético não for fornecido em formato de string ou não possuir tabela de tradução associada\n", - " '''\n", - " trans_table=codon_table(genetic_code)\n", - " assert type(start_codon)==str,'O codão de iniciação deve ser do tipo string'\n", - " start=start_codons(genetic_code)\n", - " assert start_codon.upper() in start,f'O codão de iniciação {start_codon} não ocorre no codigo genético {genetic_code}'\n", - " stop=stop_codons(genetic_code)\n", - " estado=False\n", - " seq_aas=[]\n", - " \n", - " for rf in all_rf_codoes:\n", - " seq_aa=''\n", - " for codao in rf:\n", - " if estado:\n", - " seq_aa+=trans_table[codao.upper()]\n", - " if codao.upper() in stop:\n", - " estado=False\n", - " continue\n", - "\n", - " if not estado:\n", - " if codao.upper()==start_codon.upper():\n", - " seq_aa+='M'\n", - " estado=True\n", - " \n", - " else:seq_aa+=trans_table[codao.upper()]\n", - "\n", - " seq_aas.append(seq_aa)\n", - "\n", - " return seq_aas\n", - "\n", - "def find_prots(seq_aa:str)->list[str]:\n", - " '''\n", - " Devolve todos as proteínas hipotéticas presentes em uma sequência de aminoácidos\n", - "\n", - " Parameters\n", - " ----------\n", - " seq_aa: str\n", - " Sequência de aminoacidos da qual se prende extrair todas as proteinas existentes na sequencia\n", - " \n", - " Returns\n", - " ---------\n", - " seq_aas: list[str]\n", - " Sequência de aminoácidos resultantes da tradução para cada reading frame\n", - "\n", - " Raises\n", - " -------\n", - " AssertionError\n", - " Quando a sequencia fornecida não está no formato de string\\n\n", - " Caso o aminoacido presente na sequencia não seja um aminoácido válido\n", - " '''\n", - " assert type(seq_aa)==str,'A sequencia de aminoacidos deve ser do tipo str'\n", - " alfabeto='ACDEFGHIKLMNPQRSTVWY_'\n", - " prots=[]\n", - " prot=''\n", - " estado=False\n", - "\n", - " for aa in seq_aa.upper():\n", - " assert aa in alfabeto,f'O aminoacido {aa} não esta presente no alfabeto dos aminoacidos'\n", - " if estado:\n", - " if aa==\"_\":\n", - " estado=False\n", - " prots.append(prot)\n", - " prot=''\n", - " continue\n", - " else:prot+=aa\n", - "\n", - " else:\n", - " if aa=='M':\n", - " prot+=aa\n", - " estado=True\n", - "\n", - " return prots\n", - "\n", - "def all_prots(strand:str, gen_code='Standard', start='ATG')->set:\n", - " '''\n", - " Devolve todos as proteínas possíveis que são codificas pela cadeia fornecida em todas as reading frames\n", - "\n", - " Parameters\n", - " ----------\n", - " strand: str\n", - " Cadeia de DNA da qual se pretende extrair todas as proteínas existentes nas 6 reading frames\n", - "\n", - " gen_code: str\n", - " Corresponde ao código genético a utilizar para realizar a tradução\n", - "\n", - " start: str\n", - " Codão de iniciação a utilizar para realizar a tradução dos codões\n", - "\n", - " Returns\n", - " ---------\n", - " todas_proteinas: set()\n", - " Corresonde ao conjunto de todas as proteínas distintas que podem ser codificadas pela sequênica nas 6\n", - " reading frames possíveis\n", - "\n", - " Raises\n", - " -------\n", - " AssertionError\n", - " Se a sequência fornecida não for válida e/ou não for uma sequência de DNA\\n\n", - " Quando a strand corresponde a uma string vazia\\n\n", - " Caso o codão start fornecido não seja válido ou não seja fornecido em formato de string\\n\n", - " Se o código não for fornecido em formato de string ou não possua tablea de tradução associada\\n\n", - " '''\n", - " rfs_cod=all_rfs(strand) #obtenção dos codoes para todas as reading frames\n", - " rfs_seq_aa=traducao_rf(rfs_cod,genetic_code=gen_code,start_codon=start) #traducao dos codoes de cada reading frame\n", - " todas_proteinas=set()\n", - " for seq in rfs_seq_aa: #navegacao entre as várias sequencias de aminoacidos\n", - " prots=find_prots(seq) #obtenção de todas as proteinas existens na sequencia de aminoacidos\n", - " for prot in prots:\n", - " todas_proteinas|=set([prot])\n", - "\n", - " if len(todas_proteinas)==0:\n", - " print('A sequência não codifica nenhuma proteína')\n", - " return todas_proteinas\n", - " \n", - " else:\n", - " print(f'A sequência codifica {len(todas_proteinas)} proteinas diferentes em todas as reading frames possíveis')\n", - " return todas_proteinas\n" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Exemplo variando a tabela de tradução:\n", - "A sequência codifica 1 proteinas diferentes em todas as reading frames possíveis\n", - "{'MLIM'}\n", - "A sequência codifica 1 proteinas diferentes em todas as reading frames possíveis\n", - "{'MLIM'}\n", - "A sequência não codifica nenhuma proteína\n", - "None\n", - "\n", - "Exemplo variando o codão de iniciação:\n", - "A sequência codifica 1 proteinas diferentes em todas as reading frames possíveis\n", - "{'MLIM'}\n", - "A sequência codifica 1 proteinas diferentes em todas as reading frames possíveis\n", - "{'MLMLIM'}\n", - "A sequência codifica 1 proteinas diferentes em todas as reading frames possíveis\n", - "{'MISIN'}\n" - ] - } - ], - "source": [ - "strand='CTGTTGATGCTGATTATGTGA'\n", - "#Exemplo do funcionamento da função all_prots variando a tabela de tradução\n", - "print('Exemplo variando a tabela de tradução:') \n", - "print(all_prots(strand,'Bacterial',start='ATG'))\n", - "print(all_prots(strand,'Standard',start='ATG'))\n", - "print(all_prots(strand,'Vertebrate Mitochondrial',start='ATG'),end='\\n\\n')\n", - "#Exemplo do funcionamento da função all_prots variando o codão de iniciação\n", - "print('Exemplo variando o codão de iniciação:') # os codões de inicação para cada codigo genético foram retirados da pagina do NCBI\n", - "print(all_prots(strand,'Bacterial',start='ATC'))\n", - "print(all_prots(strand,'Standard',start='CTG'))\n", - "print(all_prots('ATT'+strand,'Vertebrate Mitochondrial',start='ATT'))\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Testes de unidade" - ] - }, - { - "cell_type": "code", - "execution_count": 53, - "metadata": { - "id": "u_59x6Hu1Iax" - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "test_all_prots (__main__.Test_ORFs.test_all_prots) ... ok\n", - "test_all_rfs (__main__.Test_ORFs.test_all_rfs) ... ok\n", - "test_find_prots (__main__.Test_ORFs.test_find_prots) ... ok\n", - "test_rf_codoes (__main__.Test_ORFs.test_rf_codoes) ... ok\n", - "test_traducao_rf (__main__.Test_ORFs.test_traducao_rf) ... ok\n", - "test_acid_nuc_2codons (__main__.Test_traducao.test_acid_nuc_2codons) ... ok\n", - "test_cadeia_valida (__main__.Test_traducao.test_cadeia_valida) ... ok\n", - "test_complemento_inverso (__main__.Test_traducao.test_complemento_inverso) ... ok\n", - "test_tabela_traducao (__main__.Test_traducao.test_tabela_traducao) ... ok\n", - "test_tipo_sequencia (__main__.Test_traducao.test_tipo_sequencia) ... ok\n", - "test_traducao_acid_nuc (__main__.Test_traducao.test_traducao_acid_nuc) ... ok\n", - "\n", - "----------------------------------------------------------------------\n", - "Ran 11 tests in 0.022s\n", - "\n", - "OK\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "A sequência não codifica nenhuma proteína\n", - "A sequência codifica 1 proteinas diferentes em todas as reading frames possíveis\n", - "A sequência não codifica nenhuma proteína\n", - "A sequência codifica 1 proteinas diferentes em todas as reading frames possíveis\n", - "A sequencia de nucleotidos não é valida, pois possui T e U na mesma cadeia\n", - "O elemento P, na posição 1, não é um nucleotido válido\n", - "O elemento 3, na posição 6, não é um nucleotido válido\n", - "A sequencia de nucleotidos não é valida, pois possui T e U na mesma cadeia\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 53, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import unittest\n", - "\n", - "class Test_ORFs(unittest.TestCase):\n", - " def test_rf_codoes(self):\n", - " seqs=['ACGTAACGATTTAGCCAGCT','ACCTGAatgctagA']\n", - " rf_0=[['ACG','TAA','CGA','TTT','AGC','CAG'],['ACC','TGA','ATG','CTA']]\n", - " rf_1=[['CGT','AAC','GAT','TTA','GCC','AGC'],['CCT','GAA','TGC','TAG']]\n", - " rf_2=[['GTA','ACG','ATT','TAG','CCA','GCT'],['CTG','AAT','GCT','AGA']]\n", - " \n", - " for x,y,w,z in zip(seqs,rf_0,rf_1,rf_2):\n", - " self.assertEqual(rf_codoes(x,reading_frame=0),y)\n", - " self.assertEqual(rf_codoes(x,reading_frame=1),w)\n", - " self.assertEqual(rf_codoes(x,reading_frame=2),z)\n", - "\n", - " def test_all_rfs(self):\n", - " seqs={1:'ACGTAACGATTTAGCCAGCT', 2:'CTGTTGATGCTGATTATGTGa'}\n", - " rfs={\n", - " 1:[ ['ACG','TAA','CGA','TTT','AGC','CAG'],['CGT','AAC','GAT','TTA','GCC','AGC'],\n", - " ['GTA','ACG','ATT','TAG','CCA','GCT'],['AGC','TGG','CTA','AAT','CGT','TAC'],\n", - " ['GCT','GGC','TAA','ATC','GTT','ACG'],['CTG','GCT','AAA','TCG','TTA','CGT']],\n", - " 2:[ ['CTG','TTG','ATG','CTG','ATT','ATG','TGA'],['TGT','TGA','TGC','TGA','TTA','TGT'],\n", - " ['GTT','GAT','GCT','GAT','TAT','GTG'],['TCA','CAT','AAT','CAG','CAT','CAA','CAG'],\n", - " ['CAC','ATA','ATC','AGC','ATC','AAC'],['ACA','TAA','TCA','GCA','TCA','ACA']]}\n", - "\n", - " for I in seqs:\n", - " self.assertEqual(all_rfs(seqs[I]),rfs[I])\n", - " \n", - " def test_traducao_rf(self):\n", - " rfs_codoes={\n", - " 1:[ ['ACG','TAA','CGA','TTT','AGC','CAG'],['CGT','AAC','GAT','TTA','GCC','AGC'],\n", - " ['GTA','ACG','ATT','TAG','CCA','GCT'],['AGC','TGG','CTA','AAT','CGT','TAC'],\n", - " ['GCT','GGC','TAA','ATC','GTT','ACG'],['CTG','GCT','AAA','TCG','TTA','CGT']],\n", - " 2:[ ['CTG','TTG','ATG','CTG','ATT','ATG','TGA'],['TGT','TGA','TGC','TGA','TTA','TGT'],\n", - " ['GTT','GAT','GCT','GAT','TAT','GTG'],['TCA','CAT','AAT','CAG','CAT','CAA','CAG'],\n", - " ['CAC','ATA','ATC','AGC','ATC','AAC'],['ACA','TAA','TCA','GCA','TCA','ACA']]}\n", - " \n", - " res_traducao_standard_ATG={\n", - " 1:['T_RFSQ','RNDLAS','VTI_PA','SWLNRY','AG_IVT','LAKSLR'],\n", - " 2:['LLMLIM_', 'C_C_LC', 'VDADYV', 'SHNQHQQ', 'HIISIN', 'T_SAST']}\n", - " \n", - " res_traducao_standard_CTG={\n", - " 1:['T_RFSQ', 'RNDLAS', 'VTI_PA', 'SWLNRY', 'AG_IVT', 'MAKSLR'],\n", - " 2:['MLMLIM_','C_C_LC','VDADYV','SHNQHQQ','HIISIN','T_SAST']}\n", - "\n", - " res_traducao_mito_ATT={\n", - " 1:['T_RFSQ', 'RNDLAS', 'VTM_PA', 'SWLNRY', 'AG_IVT', 'LAKSLR'],\n", - " 2:['LLMLMMW','CWCWLC','VDADYV','SHNQHQQ','HMISIN','T_SAST']\n", - " }\n", - "\n", - " res_traducao_bacteria_TTG={\n", - " 1:['T_RFSQ', 'RNDLAS', 'VTI_PA', 'SWLNRY', 'AG_IVT', 'LAKSLR'],\n", - " 2:['LMMLIM_', 'C_C_LC', 'VDADYV', 'SHNQHQQ', 'HIISIN', 'T_SAST']\n", - " }\n", - " \n", - " for I in rfs_codoes:\n", - " self.assertEqual(traducao_rf(rfs_codoes[I]),res_traducao_standard_ATG[I]) #resultado tabela standard start codon ATG\n", - " self.assertEqual(traducao_rf(rfs_codoes[I],start_codon='CTG'),res_traducao_standard_CTG[I]) #resultado tabela standard start codon CTG\n", - " self.assertEqual(traducao_rf(rfs_codoes[I],genetic_code='Vertebrate Mitochondrial',start_codon='att'),res_traducao_mito_ATT[I]) #resultado tabela mito start codon ATT\n", - " self.assertEqual(traducao_rf(rfs_codoes[I],genetic_code='Bacterial',start_codon='TTG'),res_traducao_bacteria_TTG[I]) #resultado tabela bacteria start codon TTG\n", - " \n", - " def test_find_prots(self):\n", - " seqs_aa={\n", - " 1:['T_RFSQ', 'RNDLAS', 'VTI_PA', 'SWLNRY', 'AG_IVT', 'LAKSLR'],\n", - " 2:['LMMLIM_', 'C_C_LC', 'VDADYV', 'SHNQHQQ', 'HIISIN', 'T_SAST'],\n", - " 3:['CMCCLCIV_SWLASMIFTADS_MT','VDAMADYA_','SHNQHQQ', 'HIISIN']}\n", - " \n", - " prots={\n", - " 1:[],\n", - " 2:[['MMLIM']],\n", - " 3:[['MCCLCIV','MIFTADS'],['MADYA']]}\n", - "\n", - " for I in seqs_aa:\n", - " for seq,res in zip(seqs_aa[I],prots[I]):\n", - " self.assertEqual(find_prots(seq),res)\n", - "\n", - " def test_all_prots(self):\n", - " seqs={\n", - " 1:'ACGTAACGATTTAGCCAGCT', \n", - " 2:'CTGTTGATGCTGATTATGTGa',\n", - " 3:'ACCTGAatgctagA',\n", - " 4:'CTGTTGATGCTGATTATGTGACTGTTGATGCTGATTATGTGA' }# o 4 possui a mesma proteina reptida 2 vezes\n", - " \n", - " res={\n", - " 1:set() ,\n", - " 2:{'MLIM'} ,\n", - " 3: set(),\n", - " 4:{'MLIM'}}\n", - " \n", - " for I in seqs:\n", - " self.assertEqual(all_prots(seqs[I]),res[I])\n", - "\n", - "unittest.main(argv=[''], verbosity=2, exit=False)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "E6uw5EbfzHog" - }, - "source": [ - "# Tarefa semana 5\n", - "\n", - "- Alinhamento através de progração dinâmica/ recursividade" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "tentar acrescentar a reconstrução do alinhamento\n", - "\n", - "usar smith waterman" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Sem memoizing:" - ] - }, - { - "cell_type": "code", - "execution_count": 87, - "metadata": { - "id": "4VNcIgobzRGc" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "-2" - ] - }, - "execution_count": 87, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "\n", - "def score_basic(s1, s2, g = -4, match:int=2, mismatch:int=-1):\n", - " \n", - " assert g <0 and isinstance(g,int) , \"Gap penalty tem de ser valor inteiro e negativo \"\n", - " assert mismatch <0 and isinstance(mismatch,int) , \"Mismatch tem de ser valor inteiro e negativo\"\n", - " assert match > 0 and isinstance(match,int) , \"Match tem de ser valor inteiro e positivo\"\n", - " \n", - " subst = lambda X, Y: match if X == Y else mismatch\n", - " if s1 and s2:\n", - " return max(\n", - " score_basic(s1[:-1], s2[:-1]) + subst(s1[-1], s2[-1]),\n", - " score_basic(s1[:-1], s2) + g,\n", - " score_basic(s1, s2[:-1]) + g\n", - " )\n", - " else: return max(len(s1), len(s2)) * g\n", - "\n", - "score_basic(\"HGWAG\",\"PHSWG\")\n", - "\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Com memoizing usando um decorator:" - ] - }, - { - "cell_type": "code", - "execution_count": 86, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Alinhamento recursivo de s1: 'H' com s2: 'P' com indent: 4\n", - " Alinhamento recursivo de s1: 'H' com s2: 'PH' com indent: 4\n", - " Alinhamento recursivo de s1: 'HG' com s2: 'P' com indent: 4\n", - " Alinhamento recursivo de s1: 'HG' com s2: 'PH' com indent: 3\n", - " Alinhamento recursivo de s1: 'H' com s2: 'PHS' com indent: 4\n", - " Alinhamento recursivo de s1: 'HG' com s2: 'PHS' com indent: 3\n", - " Alinhamento recursivo de s1: 'HGW' com s2: 'P' com indent: 4\n", - " Alinhamento recursivo de s1: 'HGW' com s2: 'PH' com indent: 3\n", - " Alinhamento recursivo de s1: 'HGW' com s2: 'PHS' com indent: 2\n", - " Alinhamento recursivo de s1: 'H' com s2: 'PHSW' com indent: 4\n", - " Alinhamento recursivo de s1: 'HG' com s2: 'PHSW' com indent: 3\n", - " Alinhamento recursivo de s1: 'HGW' com s2: 'PHSW' com indent: 2\n", - " Alinhamento recursivo de s1: 'HGWA' com s2: 'P' com indent: 4\n", - " Alinhamento recursivo de s1: 'HGWA' com s2: 'PH' com indent: 3\n", - " Alinhamento recursivo de s1: 'HGWA' com s2: 'PHS' com indent: 2\n", - " Alinhamento recursivo de s1: 'HGWA' com s2: 'PHSW' com indent: 1\n", - " Alinhamento recursivo de s1: 'H' com s2: 'PHSWG' com indent: 4\n", - " Alinhamento recursivo de s1: 'HG' com s2: 'PHSWG' com indent: 3\n", - " Alinhamento recursivo de s1: 'HGW' com s2: 'PHSWG' com indent: 2\n", - " Alinhamento recursivo de s1: 'HGWA' com s2: 'PHSWG' com indent: 1\n", - " Alinhamento recursivo de s1: 'HGWAG' com s2: 'P' com indent: 4\n", - " Alinhamento recursivo de s1: 'HGWAG' com s2: 'PH' com indent: 3\n", - " Alinhamento recursivo de s1: 'HGWAG' com s2: 'PHS' com indent: 2\n", - " Alinhamento recursivo de s1: 'HGWAG' com s2: 'PHSW' com indent: 1\n", - "Alinhamento recursivo de s1: 'HGWAG' com s2: 'PHSWG' com indent: 0\n" - ] - }, - { - "data": { - "text/plain": [ - "-2" - ] - }, - "execution_count": 86, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "def memoize(func):\n", - " memoria = {}\n", - " def organizador(*positional_args, **keyword_args):\n", - " if positional_args not in memoria:\n", - " memoria[positional_args] = func(*positional_args, **keyword_args)\n", - " return memoria[positional_args]\n", - " return organizador\n", - "\n", - "@memoize\n", - "def score_memo(s1, s2, g = -4, match:int=2, mismatch:int=-1, indent=0, check_indent=False):\n", - " assert g <0 and isinstance(g,int) , \"Gap penalty tem de ser valor inteiro e negativo \"\n", - " assert mismatch <0 and isinstance(mismatch,int) , \"Mismatch tem de ser valor inteiro e negativo\"\n", - " assert match > 0 and isinstance(match,int) , \"Match tem de ser valor inteiro e positivo\"\n", - " subst = lambda X, Y: match if X == Y else mismatch\n", - "\n", - " \n", - " if s1 and s2:\n", - " val = max(\n", - " score_memo(s1[:-1], s2[:-1], g, match, mismatch, indent=indent + 1, check_indent=check_indent) + subst(s1[-1], s2[-1]),\n", - " score_memo(s1[:-1], s2, g, match, mismatch, indent=indent + 1, check_indent=check_indent) + g,\n", - " score_memo(s1, s2[:-1], g, match, mismatch, indent=indent + 1, check_indent=check_indent) + g\n", - " )\n", - " if check_indent==True:\n", - " print(\" \" * indent + f\"Alinhamento recursivo de s1: '{s1}' com s2: '{s2}' com indent: {indent}\")\n", - " return val\n", - " else:\n", - " return max(len(s1), len(s2)) * g\n", - " \n", - "score_memo(\"HGWAG\",\"PHSWG\", check_indent=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 89, - "metadata": { - "id": "-rgnERFA1LKP" - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "test_score_basic_gap_valor_positivo (__main__.TestAlinhamentoRecursivo.test_score_basic_gap_valor_positivo) ... ok\n", - "test_score_basic_gap_valor_real (__main__.TestAlinhamentoRecursivo.test_score_basic_gap_valor_real) ... ok\n", - "test_score_basic_match_valor_negativo (__main__.TestAlinhamentoRecursivo.test_score_basic_match_valor_negativo) ... ok\n", - "test_score_basic_match_valor_real (__main__.TestAlinhamentoRecursivo.test_score_basic_match_valor_real) ... ok\n", - "test_score_basic_mismatch_valor_positivo (__main__.TestAlinhamentoRecursivo.test_score_basic_mismatch_valor_positivo) ... ok\n", - "test_score_basic_mismatch_valor_real (__main__.TestAlinhamentoRecursivo.test_score_basic_mismatch_valor_real) ... ok\n", - "test_validar_score_basic (__main__.TestAlinhamentoRecursivo.test_validar_score_basic) ... ok\n", - "\n", - "----------------------------------------------------------------------\n", - "Ran 7 tests in 0.010s\n", - "\n", - "OK\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 89, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import unittest\n", - "\n", - "class TestAlinhamentoRecursivo(unittest.TestCase):\n", - "\n", - " def test_score_basic_gap_valor_positivo(self):\n", - " with self.assertRaises(AssertionError):\n", - " score_basic(\"HGWAG\",\"PHSWG\",g=9)\n", - " \n", - " def test_score_basic_gap_valor_real(self):\n", - " with self.assertRaises(AssertionError):\n", - " score_basic(\"HGWAG\",\"PHSWG\",g=-2.5)\n", - "\n", - " def test_score_basic_match_valor_negativo(self):\n", - " with self.assertRaises(AssertionError):\n", - " score_basic(\"HGWAG\",\"PHSWG\",match=-3)\n", - "\n", - " def test_score_basic_match_valor_real(self):\n", - " with self.assertRaises(AssertionError):\n", - " score_basic(\"HGWAG\",\"PHSWG\",match=3.2)\n", - "\n", - " def test_score_basic_mismatch_valor_positivo(self):\n", - " with self.assertRaises(AssertionError):\n", - " score_basic(\"HGWAG\",\"PHSWG\",mismatch=3)\n", - "\n", - " def test_score_basic_mismatch_valor_real(self):\n", - " with self.assertRaises(AssertionError):\n", - " score_basic(\"HGWAG\",\"PHSWG\",mismatch=-1.5)\n", - "\n", - " def test_validar_score_basic(self):\n", - " self.assertEqual(score_basic(\"HGWAG\",\"PHSWG\"),-2)\n", - "\n", - "suite = unittest.TestLoader().loadTestsFromTestCase(TestAlinhamentoRecursivo)\n", - "unittest.TextTestRunner(verbosity=3).run(suite)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "0ShqoNyHzRqo" - }, - "source": [ - "# Tarefa semana 6\n", - "\n", - "- Algoritmo de Needleman Wunsch" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "id": "U7bBgkuOzX2I" - }, - "outputs": [], - "source": [ - "def validar_prot(seq:str)->bool:\n", - " assert type(seq)==str,'A sequência não foi fornecida em formato de string'\n", - " assert len(seq) !=0 ,'Não foi fornecida nenhuma sequência'\n", - " lista_aminoacidos = ['A','C','D','E','F','G','H','I','K','L','M','N','P','Q','R','S','T','V','W','Y','_']\n", - " for aa in seq.upper():\n", - " if aa not in lista_aminoacidos:\n", - " return False\n", - " \n", - " return True\n", - "\n", - "def formatar(x):\n", - " if type(x) is int:\n", - " return f\"{x:>3d}\"\n", - " else:\n", - " return f\"{x:>3}\"\n", - " \n", - "def print_matrix(S1,S2,M):\n", - " \n", - " print(*list(\" \" + S1), sep=\" \")\n", - " for x2, L in zip(S2,M): #x2 caracter que vem da string S2\n", - " LL=[formatar(x) for x in L]\n", - " print(x2,*LL)\n", - " print()\n", - "\n", - "def score_sub_acid_nuc(x1:str,x2:str,match,mismatch)->int:\n", - " if x1==x2:return match\n", - " else: return mismatch\n", - "\n", - "def score_subst_prot(nome_matriz:str, aa1:str, aa2:str) -> int:\n", - " \"\"\"\n", - " Esta função abre e lê um destes ficheiros de texto: \"BLOSSOM62.txt\", \"BLOSSOM80.txt\", \"PAM30.txt\", \"PAM70.txt\" \n", - " retirando a matriz de substituição do ficheiro como uma matriz bidimensional.\n", - " Depois navega na matriz de substituição obtida e retorna o score correspondente ao ????alinhamento???? de dois dos seguintes caracteres: \n", - " 'A','C','D','E','F','G','H','I','K','L','M','N','P','Q','R','S','T','V','W','Y','_',\n", - " sendo que as letras representam os aminoácidos e o caracter '_' representa o codão stop.\n", - " \n", - " Parameters\n", - " ----------\n", - " nome_matriz:str\n", - " Nome da matriz de substituição que se pretende que seja lida e utilizada para fornecer os scores de substituição\n", - "\n", - " aa1:str\n", - " Aminoácido que vai ser procurado ao longo da primeira coluna da matriz de substituição\n", - "\n", - " aa2:str\n", - " Aminoácido que vai ser procurado ao longo da primeira linha da matriz de substituição\n", - "\n", - " Returns\n", - " -------\n", - " score:int\n", - " Score obtido para o alinhamento dos dois aminoácidos na matriz de substituição\n", - "\n", - " Raises\n", - " ------\n", - " AssertionError\n", - " Quando o nome da matriz fornecido não corresponde a uma das matrizes aceites pela função:\n", - " \"BLOSSOM62\", \"BLOSSOM80\", \"PAM30\", \"PAM70\"\n", - "\n", - " AssertionError\n", - " Quando o caracter inserido correspondente ao 'aa1' não é válido como aminoácido ou codão stop\n", - "\n", - " AssertionError\n", - " Quando o caracter inserido correspondente ao 'aa2' não é válido como aminoácido ou codão stop\n", - " \"\"\"\n", - " assert nome_matriz.upper() in [\"BLOSSOM62\", \"BLOSSOM80\", \"PAM30\", \"PAM70\"],\"A matriz de substituição escolhida é inválida, apenas aceita as matrizes 'BLOSSOM62', 'BLOSSOM80', 'PAM30', 'PAM70'\"\n", - " with open(nome_matriz.upper()+\".txt\", \"r\") as file:\n", - " matriz = []\n", - " for line in file:\n", - " line = line.strip()\n", - " linha = []\n", - " valor = \"\"\n", - " for elem in line:\n", - " if elem == \" \":\n", - " if len(valor) != 0:\n", - " linha.append(valor)\n", - " valor = \"\"\n", - " else:\n", - " valor += elem\n", - " linha.append(valor)\n", - " matriz.append(linha)\n", - " aa1, aa2 = aa1.upper(), aa2.upper()\n", - " lista_aminoacidos = ['A','R','N','D','C','Q','E','G','H','I','L','K','M','F','P','S','T','W','Y','V','B','J','Z','X','_']\n", - " assert aa1 in lista_aminoacidos,f\"O caracter {aa1} não é válido como aminoácido ou codão stop\"\n", - " assert aa2 in lista_aminoacidos,f\"O caracter {aa2} não é válido como aminoácido ou codão stop\"\n", - " coluna, linha = 0, 0\n", - " for i in range(1,len(matriz)):\n", - " if aa1 == matriz[i][0]:\n", - " linha = i\n", - " break\n", - " for pos, elem in enumerate(matriz[0]):\n", - " if elem == aa2:\n", - " coluna = pos\n", - " break\n", - " score = matriz[linha][coluna]\n", - " return int(score)\n", - "\n", - "def reconstrucao(seq1,seq2,trace):\n", - " aligned_seq1 = ''\n", - " aligned_seq2 = ''\n", - " linha=len(seq1)-1\n", - " coluna=len(seq2)-1\n", - "\n", - " while trace[linha][coluna]!=0:\n", - " if trace[linha][coluna] == '↖':\n", - " aligned_seq1 = seq1[linha] + aligned_seq1\n", - " aligned_seq2 = seq2[coluna] + aligned_seq2\n", - " linha -= 1\n", - " coluna -= 1\n", - " elif trace[linha][coluna] == '↑':\n", - " aligned_seq1 = seq1[linha] + aligned_seq1\n", - " aligned_seq2 = '-' + aligned_seq2\n", - " linha -= 1\n", - " elif trace[linha][coluna] == '←':\n", - " aligned_seq1 = '-' + aligned_seq1\n", - " aligned_seq2 = seq2[coluna] + aligned_seq2\n", - " coluna-= 1\n", - " print(aligned_seq1,aligned_seq2,sep='\\n')\n", - " return (aligned_seq1,aligned_seq2)\n", - "\n", - "def needleman_wunsch(seq1:str,seq2:str,seq_tipo:str,gap:int=-4,matriz:str='Blossom62',match:int=2,mismatch:int=-1,matrizes=True ):\n", - " \"\"\"\n", - " Realiza o alinhamento global de duas sequências recorrendo o algoritmo Needleman-Wunsch.\n", - "\n", - " Parameters\n", - " ----------\n", - " seq1 : str\n", - " Primeira sequência\n", - " seq2 : str\n", - " Segunda sequência\n", - "\n", - " seq_tipo: str\n", - " Identifica o tipo das sequências que se pretende alinhar\n", - "\n", - " gap: int\n", - " Valor a utilizar para penalizar os espaçamentos. Por padrão considera-se o valor de penalização como -4\n", - "\n", - " matriz: str\n", - " Matriz de substituição de aminoacidos a utilizar para realizar o alinhamento de proteínas\n", - "\n", - " match: int\n", - " Valor a utilizar para quando as duas bases nucleicas são iguais. Por default é 2. Apenas para o alinhamento de DNA/RNA\n", - "\n", - " mismatch: int\n", - " Valor a utilizar para quando as duas bases nucleicas são diferentes. Por default é -1. Apenas para o alinhamento de DNA/RNA\n", - "\n", - " matrizes: bool\n", - " Indica \n", - "\n", - " Returns\n", - " ----------\n", - " Tuple\n", - " devolve um tuplo com a matriz de pontuação, a matriz de rastreamento e o alinhamento ótimo\n", - " \n", - " \"\"\"\n", - " assert seq_tipo.upper() in ['DNA','RNA','PROTEIN'], 'O tipo de sequência fornecido não é valido, apenas pode assumir o valor de DNA, RNA ou protein'\n", - " \n", - " if seq_tipo.upper()=='DNA' or seq_tipo.upper()=='RNA':\n", - " assert tipo_seq(seq1) in ['DNA','RNA'], 'A sequencia 1 não é um acido nucleico'\n", - " assert tipo_seq(seq2) in ['DNA','RNA'], 'A sequencia 2 não é um acido nucleico'\n", - " assert tipo_seq(seq1)==tipo_seq(seq2), 'As cadeias fornecidas não são do mesmo tipo'\n", - "\n", - " else:\n", - " assert validar_prot(seq1), 'A sequencia 1 não é uma proteina'\n", - " assert validar_prot(seq2), 'A sequencia 2 não é uma proteina'\n", - "\n", - " seq1='-'+seq1\n", - " seq2='-'+seq2\n", - " nrows = len(seq1)\n", - " ncols = len(seq2)\n", - "\n", - " score_matrix=[[0]*ncols for linhas in range(nrows)] # iniciar a matriz score apenas com 0\n", - " score_matrix[0]=[c*gap for c in range(ncols)] #prenchimento da primeira linha da matriz score\n", - " for linha in range(1, nrows):score_matrix[linha][0] = linha * gap # preenchimento da primeira coluna da matriz score\n", - "\n", - " traceback_matrix = [[0] * ncols for linhas in range(nrows)] # iniciar a matriz traceback com 0\n", - " traceback_matrix[0] =[0 if col==0 else '←' for col in range(ncols)] # prenchimento da primeira linha da matriz traceback\n", - " for linha in range(1,nrows): traceback_matrix[linha][0]='↑' # preenchimento da primeira coluna da matriz traceback\n", - "\n", - " if seq_tipo.upper()=='DNA' or seq_tipo.upper()=='RNA': #alinhamento de acidos nucleicos\n", - " for linha in range(1, nrows):\n", - " for coluna in range(1, ncols):\n", - " diagonal = score_matrix[linha - 1][coluna - 1] + score_sub_acid_nuc(seq1[linha],seq2[coluna],match,mismatch)\n", - " cima = score_matrix[linha - 1][coluna] + gap\n", - " esquerda = score_matrix[linha][coluna - 1] + gap\n", - "\n", - " max_score = max(diagonal, esquerda, cima)\n", - " score_matrix[linha][coluna] = max_score\n", - "\n", - " if max_score == diagonal: traceback_matrix[linha][coluna] = '↖'\n", - " elif max_score == cima: traceback_matrix[linha][coluna] = '↑'\n", - " elif max_score == esquerda: traceback_matrix[linha][coluna] = '←'\n", - "\n", - " else: # alinhamento de proteinas\n", - " for linha in range(1, nrows):\n", - " for coluna in range(1, ncols):\n", - " diagonal = score_matrix[linha - 1][coluna - 1] + score_subst_prot(matriz,seq1[linha],seq2[coluna])\n", - " cima = score_matrix[linha - 1][coluna] + gap\n", - " esquerda = score_matrix[linha][coluna - 1] + gap\n", - "\n", - " max_score = max(diagonal, esquerda, cima)\n", - " score_matrix[linha][coluna] = max_score\n", - "\n", - " if max_score == diagonal: traceback_matrix[linha][coluna] = '↖'\n", - " elif max_score == cima: traceback_matrix[linha][coluna] = '↑'\n", - " elif max_score == esquerda: traceback_matrix[linha][coluna] = '←'\n", - "\n", - " if matrizes:\n", - " print(\"Matriz de Pontuação:\")\n", - " print_matrix(seq2,seq1,score_matrix)\n", - " print(\"Matriz de Rastreamento:\")\n", - " print_matrix(seq2,seq1,traceback_matrix)\n", - " return score_matrix[-1][-1],reconstrucao(seq1,seq2,traceback_matrix)\n", - " \n", - " else:\n", - " return score_matrix[-1][-1],reconstrucao(seq1,seq2,traceback_matrix)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "id": "qjG57vPT1NuE" - }, - "outputs": [], - "source": [ - "import unittest\n", - "\n", - "class Testneedlemanwunch(unittest.TestCase):\n", - " def test_nw_seq_tipo_caracter_errado_DNA(self): \n", - " with self.assertRaises(AssertionError):\n", - " needleman_wunsch(\"ACTGG\", \"AGA\",\"DNA/\") \n", - " \n", - " def test_nw_seq_tipo_caracter_errado_RNA(self): \n", - " with self.assertRaises(AssertionError):\n", - " needleman_wunsch(\"ACUGG\", \"AUA\",\"RNA/\")\n", - " \n", - " def test_nw_seq_tipo_caracter_errado_PROTEIN(self): \n", - " with self.assertRaises(AssertionError):\n", - " needleman_wunsch(\"CREATINNA\", \"BEEFFAA\",\"/PROTEIN\") \n", - " \n", - " def test_nw_caracter_seq1_DNA_errado(self): \n", - " with self.assertRaises(AssertionError):\n", - " needleman_wunsch(\"ACTGG-\", \"AGA\",\"DNA\")\n", - "\n", - " def test_nw_caracter_seq2_DNA_errado(self): \n", - " with self.assertRaises(AssertionError):\n", - " needleman_wunsch(\"ACTGG\", \"AGA%\",\"DNA\") \n", - "\n", - " def test_nw_caracter_seq1_RNA_errado(self): \n", - " with self.assertRaises(AssertionError):\n", - " needleman_wunsch(\"ACUGG-\", \"AUA\",\"RNA\")\n", - "\n", - " def test_nw_caracter_seq2_RNA_errado(self): \n", - " with self.assertRaises(AssertionError):\n", - " needleman_wunsch(\"ACUGG\", \"AUA/\",\"RNA\")\n", - "\n", - " def test_nw_caracter_seq1_PROTEINA_errado(self): \n", - " with self.assertRaises(AssertionError):\n", - " needleman_wunsch(\"CREATINNA%\", \"BEEFFAA\",\"PROTEIN\")\n", - "\n", - " def test_nw_caracter_seq2_PROTEINA_errado(self): \n", - " with self.assertRaises(AssertionError):\n", - " needleman_wunsch(\"CREATINNA\", \"BEEFFAA%/\",\"PROTEIN\")\n", - " \n", - " def test_nw_seq1_not_dna(self):\n", - " with self.assertRaises(AssertionError):\n", - " needleman_wunsch(\"ACUGG\", \"AGA\",\"DNA\")\n", - " \n", - " def test_nw_seq2_not_dna(self):\n", - " with self.assertRaises(AssertionError):\n", - " needleman_wunsch(\"ACTGG\", \"AUA\",\"DNA\")\n", - " \n", - " def test_nw_seq1_not_rna(self):\n", - " with self.assertRaises(AssertionError):\n", - " needleman_wunsch(\"ACTGG\", \"AUA\",\"RNA\")\n", - " \n", - " def test_nw_seq2_not_rna(self):\n", - " with self.assertRaises(AssertionError):\n", - " needleman_wunsch(\"ACUGG\", \"ATA\",\"RNA\")\n", - " \n", - " def test_seq1_vazio(self):\n", - " with self.assertRaises(AssertionError):\n", - " needleman_wunsch(\"\", \"ATA\",\"DNA\")\n", - "\n", - " def test_seq2_vazio(self):\n", - " with self.assertRaises(AssertionError):\n", - " needleman_wunsch(\"ACTGG\",\"\",\"DNA\")\n", - "\n", - " def test_needleman_wunsch_letras_maiusculas(self):\n", - " score, _ = needleman_wunsch(\"ACTGG\", \"AGA\", \"DNA\")\n", - " self.assertEqual(score, -5)\n", - "\n", - " def test_needleman_wunsch_letras_minusculas(self):\n", - " score, _ = needleman_wunsch(\"actgg\", \"aga\", \"dna\")\n", - " self.assertEqual(score, -5)\n", - "\n", - " def test_alinhamento_DNA_correto(self):\n", - " self.assertEqual(needleman_wunsch(\"AGATT\",\"ACTA\",\"DNA\"),(-2, ('AGATT', 'A-CTA')))\n", - "\n", - " def test_alinhamento_RNA_correto(self):\n", - " self.assertEqual(needleman_wunsch(\"UACAA\",\"AGAU\",\"RNA\"),(-2, ('UACAA', '-AGAU')))\n", - " \n", - " def test_alinhamento_PROTEIN_correto(self):\n", - " self.assertEqual(needleman_wunsch(\"PHSWG\",\"HGWAG\",\"PROTEIN\"),(17, ('PHSW-G', '-HGWAG')))\n", - "\n", - "suite = unittest.TestLoader().loadTestsFromTestCase(Testneedlemanwunch)\n", - "unittest.TextTestRunner(verbosity=3).run(suite)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "# Tarefa semana 7- Blast" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Tarefa x- Motifs" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# pensar se não será interessante usar na pwm uma forma automatica de identificar o tipo de sequência fornecida, mas também permitir que o utilizador forneça o tipo de sequência que quer fornecer, e nesse caso verificar com essa função se realmente está correto o que foi indicado" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def alfabeto(tipo_seq:str)->str:\n", - " '''\n", - " Esta função recebe o tipo de uma sequência e devolve o seu respetivo alfabeto\n", - "\n", - " Parameters\n", - " ---------\n", - " tipo_seq:str\n", - " Tipo válido de uma sequência biológica. Pode assumir os valores de DNA, RNA, protein,\n", - " proteína ou prot\n", - "\n", - " Returns\n", - " -------\n", - " list(str)\n", - " Composto pelo tipo de sequência e o seu respetivo alfabeto\n", - " \n", - " Raises\n", - " ------\n", - " ValueError\n", - " Quando o tipo de sequência fornecido não é um tipo de sequência biológica válida\n", - " '''\n", - " from unidecode import unidecode\n", - " if tipo_seq.upper()==\"DNA\":\n", - " DNA=\"ACGT\"\n", - " return [tipo_seq.upper(),DNA]\n", - " elif tipo_seq.upper()==\"RNA\":\n", - " RNA=\"ACGU\"\n", - " return [tipo_seq.upper(),RNA]\n", - " elif unidecode(tipo_seq.upper()) in [\"PROTEIN\",\"PROTEINA\",\"PROT\"]:\n", - " protein=\"ABCDEFGHIKLMNPQRSTVWYZ\"\n", - " return [\"Proteína\", protein]\n", - " else:\n", - " raise ValueError(f\"O tipo {tipo_seq} não é válido. Os tipos de cadeia válida são: DNA, RNA ou proteina\") \n", - "\n", - "def pwm (seqs: list, tipo_seq: str,pseudo=0)->list(dict[str,float]):\n", - " '''\n", - " Esta função recebe uma lista de sequências alinhadas e devolve uma matriz desingada de position weigth matrix (PWM), onde se representa\n", - " a probabilidade de cada letra de um dado alfabeto biológico estar presente numa determinada posição.\n", - "\n", - " Parameters\n", - " ----------\n", - " seqs:list(str)\n", - " Contêm um conjunto de sequências alinhadas em formato de string\n", - "\n", - " tipo_seq:str\n", - " Tipo da sequencia que se pretende realiazar a PWM. Pode assumir o valor de DNA, RNA, protein, proteína ou prot\n", - "\n", - " pseudo: int ou float\n", - " Valor a utilizar para realizar a pseudocontagem. Por padrão o valor é 0\n", - "\n", - " Returns\n", - " -------\n", - " PWM:list(dict)\n", - " Valor da probabilidade de cada letra do alfabeto estar presente em cada posição das sequências\n", - " \n", - " Raises\n", - " ------\n", - " AssertionError\n", - " Quando um elemento de uma das sequências fornecidas não está presente no alfabeto utilizado\n", - "\n", - " Quando o tamanho das sequências fornecidas é diferente\n", - " '''\n", - " alfa=alfabeto(tipo_seq)\n", - " \n", - " tamanho=[]\n", - " \n", - " for I,seq in enumerate(seqs):\n", - " tamanho.append(len(seq))\n", - " for pos,elem in enumerate(seq):\n", - " assert elem in alfa[1],f\"Na sequencia {seq}, o elemento {elem} na posição {pos+1} não se encontra no alfabeto do {alfa[0]}\"\n", - " assert tamanho[I]==tamanho[I-1],f\"A sequência {seq} não possui o mesmo tamanho que as restantes\"\n", - "\n", - " elementos_coluna=list(zip(*seqs))\n", - "\n", - " PWM=[]\n", - "\n", - " for coluna in elementos_coluna:\n", - " contagem={}\n", - " for elem in alfa[1]:\n", - " contagem[elem]=(coluna.count(elem) + pseudo)/(len(seqs)+len(alfa[1])*pseudo)\n", - " \n", - " PWM.append(contagem) \n", - " \n", - " return PWM\n", - "\n", - "def prob_seq (seq: str, pwm: list(dict[str,float])):\n", - " '''\n", - " Esta função calcula a probabilidade de uma determinada sequencia ter sido gerada pela PWM\n", - "\n", - " Parameters\n", - " ---------\n", - " seq:str\n", - " Sequência que se pretende calcular a probabilidade de ter sido gerada pela PWM\n", - " \n", - " pwm:list(dict[str,floar])\n", - " Corresponde às probabilidades de cada elemento aparecer nas várias posições da sequência\n", - "\n", - " Returns\n", - " -------\n", - " prod:float\n", - " Probabilidade de a sequencia fornecida ter sido gerada pela PWM\n", - "\n", - " Raises\n", - " ------\n", - " AssertionError\n", - " Quando o tamanho da sequência não é igual ao tamanho da PWM\n", - "\n", - " '''\n", - " assert len(seq)<=len(pwm),f\"A sequência {seq} não é do mesmo tamanho que a PWM\"\n", - "\n", - " prod=1\n", - " for I,elem in enumerate(seq):\n", - " prod=prod*pwm[I][elem]\n", - " return prod\n", - "\n", - "def seq_mais_provavel(seq,pwm,resultado=\"Max\"):\n", - " '''\n", - " Esta função recebe uma sequência e utiliza a PWM para determinar qual a subsequência mais provável de ter sido gerada pela PWM\n", - "\n", - " Parameters\n", - " --------\n", - " seq: str\n", - " sequência na qual se pretende analisar a probablidade de cada subsequência ter sido gerada pela PWM\n", - "\n", - " pwm: list(dict[str,float])\n", - " PWM de um determinado alinhamento\n", - "\n", - " Resultado: str\n", - " Corresponde ao valor que se pretende obter, por exemplo, quando assume o valor \"Máximo\" devolve a(s) subsequência(s) \n", - " com maior probabilidade de ter sido gerada pela PWM, quando assume o valor mínimo devolve a(s) sequência(s) com menor probabildade\n", - " de serem formadas pela PWM\n", - "\n", - " Returns\n", - " -------\n", - " str\n", - " Corresponde à sequência de maior/menor probabilidade\n", - " '''\n", - "\n", - " assert len(seq)>=len(pwm),f'''\n", - " A sequência {seq} não pode ser utilizada para determinar a sequência mais próvavel. A sequência deve ter, no mínimo, o mesmo tamnho da PWM\n", - " '''\n", - " w=len(pwm)\n", - " snips=[seq[P:P+w] for P in range(len(seq)-w+1)]\n", - " res={}\n", - " for snip in snips:\n", - " prob=prob_seq(snip,pwm)\n", - " res[snip]=prob\n", - " \n", - " if resultado.upper() in ['MAX','MAXIMO']:\n", - " return max(res, key=res.get)\n", - " \n", - " if resultado.upper() in ['MIN','MINIMO']:\n", - " return min(res, key=res.get)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Matrizes de substituição" - ] - } - ], - "metadata": { - "colab": { - "provenance": [] - }, - "kernelspec": { - "display_name": "Python 3", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.7" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -}