Playing_with_DNA.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AsTUvuUTWAjk"
      },
      "source": [
        "Mario Fiorino\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8fwarf-vX4G3"
      },
      "source": [
        "# Modules"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8A9aG7p4Xss1"
      },
      "outputs": [],
      "source": [
        "import random\n",
        "import string\n",
        "from collections import Counter"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zrcdNlz5mRZL"
      },
      "source": [
        " # Task 1 -- Basic sequencing"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aXOL6VTeZjUY"
      },
      "source": [
        "## Generate a random sequence\n",
        "\n",
        "Generate an input sequence of nucleotides: adenine (A), guanine (G), cytosine (C), and thymine (T); mixed up with other elements, chosen at random."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Un2D_5KfaW8P"
      },
      "outputs": [],
      "source": [
        "def random_sequence(length):\n",
        "    \n",
        "    keep = True\n",
        "\n",
        "    while keep:\n",
        "\n",
        "      # One or max two disturbing elements are random chosen   \n",
        "      other_element1 = random.choice(string.ascii_uppercase) \n",
        "      other_element2 = random.choice(string.ascii_uppercase)\n",
        "\n",
        "      s = {other_element1,other_element2}  # We can have also one element but the probability is low\n",
        "      #print(s)\n",
        "\n",
        "      z = {'A','C','T','G'}.intersection(s) \n",
        "      #print(z)\n",
        "\n",
        "      if not z: # oppure  z == set():  \n",
        "        keep = False  # exit the loop only if the noise elements are different from 'A','C','T','G'\n",
        "\n",
        "    #print(other_element1,other_element2)\n",
        "    \n",
        "\n",
        "    result  = \"\".join(random.choices([other_element1,other_element2,'A','C','T','G'],[.20, .20, .15, .15, .15, .15], k=length))\n",
        "    \n",
        "\n",
        "    return result\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZJPQuiAgoMQi"
      },
      "source": [
        "## Core Algorithm Task 1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "taRyQ9T2ptzc"
      },
      "outputs": [],
      "source": [
        "def list_sub_seq_nucl(seq):\n",
        "  \n",
        "  st = \"\"   # initialize a sub_sequence of ACTG\n",
        "  l_n = []  # initialize list of sub-sequences containing only contiguous subsets of ACTG\n",
        "  c = 0     # counter, needed if nucleotides are closing of sequence;  for situation like this : \"\"..XTTGT\"\n",
        "\n",
        "  for i in seq:\n",
        "    \n",
        "    c+=1\n",
        "\n",
        "    if i in NUCLE:\n",
        "      st = st + i \n",
        "      #print(st) \n",
        "  \n",
        "    elif (i not in NUCLE)  and (not (st == \"\")):\n",
        "      l_n.append(st)\n",
        "      st = \"\"\n",
        "\n",
        "    if   (c == (len(seq))) and (not (st == \"\")) : # closing\n",
        "      l_n.append(st)  \n",
        "\n",
        "\n",
        "  return l_n\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ve0-Y0FJld4n"
      },
      "source": [
        "## Parameters"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "G338OjZelfuM"
      },
      "outputs": [],
      "source": [
        "ls    = 40  # length of input random sequence to generate\n",
        "NUCLE = {'A','C','T','G'}"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kqU-cqmxoD8f"
      },
      "source": [
        "## Task 1 - Main"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sTKdchIWl0CM",
        "outputId": "a25de057-dd50-4cfb-c33c-d0075364beb1"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "AATCACGGANAAAACTGTNTGTVGVNGAGTTTNNNCCCGV\n",
            "['AATCACGGA', 'AAAACTGT', 'TGT', 'G', 'GAGTTT', 'CCCG']\n",
            "['AATCACGGA', 'AAAACTGT', 'GAGTTT', 'CCCG', 'TGT', 'G']\n"
          ]
        }
      ],
      "source": [
        "sh = random_sequence(ls)\n",
        "#sh = \"ACCGXXCXXGTTACTGGGCXTTGTXC\"\n",
        "##out = [\"GTTACTGGGC\", \"ACCG\", \"TTGT\", \"C\", \"C\"]\n",
        "\n",
        "print(sh)\n",
        "\n",
        "l_s_n = list_sub_seq_nucl(sh)\n",
        "print(l_s_n)\n",
        "\n",
        "l_s_n = sorted(l_s_n, key=len,  reverse=True) # oppure  reverse=False)\n",
        "print(l_s_n)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "v4PtegP22ss4"
      },
      "source": [
        "#Task 2 - - Counting bases"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "56UHmQ4dKN33"
      },
      "source": [
        "##Parameters"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "XX7ISCONKTJa"
      },
      "outputs": [],
      "source": [
        "len_in_seq = 25\n",
        "letters = string.ascii_uppercase"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uZBXEkYmNFvh"
      },
      "source": [
        "## Display Task 2"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ZHhCTk67NJ3q"
      },
      "outputs": [],
      "source": [
        "def display(diz, len_in_seq):\n",
        "  \n",
        "  sorted_list = sorted(diz.items(), key=lambda x:x[0])  # sort a dictionary by key with the sorted() method\n",
        "  #print(sorted_list)\n",
        "  \n",
        "  sorted_list = sorted(sorted_list, key=lambda x:x[1], reverse=True)  # sort list by second value: the \"Count\"\n",
        "  #print(sorted_list)\n",
        "\n",
        "  for i in sorted_list :\n",
        "    perc = round((i[1]/len_in_seq)*100,2)\n",
        "    print(f\"Base: {i[0]}, Count: {i[1]}, Percentage: {perc}%\")\n",
        "    #The two proceedings sorted():\n",
        "    #first, sort the elements based on \"Letter\". And after, sort the list based on the \"Count\"\n",
        "    #Final result : \n",
        "    #a list sorted primarily by values \"Count\"; if there are equal counts, they are subordinated by alphabetical order, \n",
        "    # according to the associated \"Letter\"."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kV9Z4ouwJplA"
      },
      "source": [
        "## Task 2 - Main \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QQXT0YSzJ4WK",
        "outputId": "f9748a03-8595-4373-c2d4-e8c94c16cf40"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "VFQRSJRTBIMXDUVKUVXYLZTYD\n",
            "Base: G, Count: 6, Percentage: 25.0%\n",
            "Base: T, Count: 6, Percentage: 25.0%\n",
            "Base: A, Count: 3, Percentage: 12.5%\n",
            "Base: C, Count: 3, Percentage: 12.5%\n",
            "Base: W, Count: 2, Percentage: 8.33%\n",
            "Base: Y, Count: 2, Percentage: 8.33%\n",
            "Base: R, Count: 1, Percentage: 4.17%\n",
            "Base: Z, Count: 1, Percentage: 4.17%\n"
          ]
        }
      ],
      "source": [
        "in_seq = (''.join(random.choice(letters) for i in range(len_in_seq)) )  #Generate an input sequence of various bases\n",
        "print(in_seq)\n",
        "\n",
        "#in_seq = \"ACTWGTGCTYGATRGTAGCYZGTW\"\n",
        "#len_in_seq =len(in_seq)\n",
        "\n",
        "d = Counter(in_seq)\n",
        "\n",
        "display(d,len_in_seq)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6SD5Jz4ieLM4"
      },
      "source": [
        "# Task 3 - Counting amino acids"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Stt5wSvhcCpe"
      },
      "source": [
        "## Parameters"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4wopTlBtXvx3"
      },
      "outputs": [],
      "source": [
        "   table = {  \n",
        "      'ATA':'Isoleucine' , 'ATC':'Isoleucine', 'ATT':'Isoleucine',\n",
        "      'ATG':'Methionine' ,  \n",
        "      'ACA':'Threonine' , 'ACC':'Threonine', 'ACG':'Threonine', 'ACT':'Threonine',  \n",
        "      'AAC':'Asparagine', 'AAT':'Asparagine',\n",
        "      'AAA':'Lysine', 'AAG':'Lysine',  \n",
        "      'AGC':'Serine', 'AGT':'Serine', \n",
        "      'AGA':'Arginine', 'AGG':'Arginine',   \n",
        "      'CTA':'Leucine', 'CTC':'Leucine', 'CTG':'Leucine', 'CTT':'Leucine',  \n",
        "      'CCA':'Proline', 'CCC':'Proline', 'CCG':'Proline', 'CCT':'Proline',  \n",
        "      'CAC':'Histidine', 'CAT':'Histidine', \n",
        "      'CAA':'Glutamine', 'CAG':'Glutamine',  \n",
        "      'CGA':'Argimine', 'CGC':'Argimine', 'CGG':'Argimine', 'CGT':'Argimine',  \n",
        "      'GTA':'Valine', 'GTC':'Valine', 'GTG':'Valine', 'GTT':'Valine',  \n",
        "      'GCA':'Alanine', 'GCC':'Alanine', 'GCG':'Alanine', 'GCT':'Alanine',  \n",
        "      'GAC':'Aspartic acid', 'GAT':'Aspartic acid', \n",
        "      'GAA':'Glutamic acid', 'GAG':'Glutamic acid',  \n",
        "      'GGA':'Glycine', 'GGC':'Glycine', 'GGG':'Glycine', 'GGT':'Glycine',  \n",
        "      'TCA':'Serine', 'TCC':'Serine', 'TCG':'Serine', 'TCT':'Serine',  \n",
        "      'TTC':'Phenylalanine', 'TTT':'Phenylalanine', \n",
        "      'TTA':'Leucine', 'TTG':'Leucine',  \n",
        "      'TAC':'Tyrosine', 'TAT':'Tyrosine',\n",
        "      'TAA':'STOP', 'TAG':'STOP',  \n",
        "      'TGC':'Cysteine', 'TGT':'Cysteine',\n",
        "      'TGA':'STOP',\n",
        "      'TGG':'Trytophan',  \n",
        "      } \n",
        "\n",
        "LEN = 99   # length of input DNA sequences\n",
        "BASES = ['A', 'C', 'T', 'G']      "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "onbOLYpGimX4"
      },
      "source": [
        "## Display Task 3"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8XMklA3Limw5"
      },
      "outputs": [],
      "source": [
        "def displayT3(diz,codo):   # \"codo\" is a flag for the correct display of condon / name\n",
        "  \n",
        "  sorted_list = sorted(diz.items(), key=lambda x:x[1], reverse = True)  # sort a dictionary by value with the sorted() method\n",
        "  #print(sorted_list)  \n",
        "\n",
        "  for i in sorted_list :\n",
        "    if codo == True:\n",
        "        print(f\"Codon: {i[0]},   Count: {i[1]}\")\n",
        "    else:\n",
        "        print(f\"Name : {i[0]},   Count: {i[1]}\")\n",
        "  "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aGbpos2cvFUV"
      },
      "source": [
        "## Core Algorithm Task 3"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "HKWSyEwZvFtD"
      },
      "outputs": [],
      "source": [
        "def coreT3(dna_seq):\n",
        "  protein = [] \n",
        "  list_codon = []\n",
        "\n",
        "  for i in range(0, len(dna_seq), 3):    #  range(start, stop, step)\n",
        "        codon = dna_seq[i:i + 3] \n",
        "        #print(codon) \n",
        "        list_codon.append(codon) \n",
        "        \n",
        "        protein.append(table[codon]) \n",
        "        \n",
        "  return list_codon, protein    "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kBdfblW-hMpE"
      },
      "source": [
        "## Task 3 - Main"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LUcjKFEfg4Fd",
        "outputId": "f55cc44a-7d9a-46b3-a5a8-33e85cb2650d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "GGAAGTCTGCGCGGATGACAAAAGCGTATTATATCGGGTAACACCTGTTGAAGGGAATTATGTTCGTGCGCGTACCCGCGGCGGAAAAGAAAGTCTTGG \n",
            "\n",
            "Codon: GGA,   Count: 2\n",
            "Codon: TGA,   Count: 2\n",
            "Codon: AAG,   Count: 2\n",
            "Codon: TCG,   Count: 2\n",
            "Codon: TGT,   Count: 2\n",
            "Codon: CGG,   Count: 2\n",
            "Codon: AGT,   Count: 1\n",
            "Codon: CTG,   Count: 1\n",
            "Codon: CGC,   Count: 1\n",
            "Codon: CAA,   Count: 1\n",
            "Codon: CGT,   Count: 1\n",
            "Codon: ATT,   Count: 1\n",
            "Codon: ATA,   Count: 1\n",
            "Codon: GGT,   Count: 1\n",
            "Codon: AAC,   Count: 1\n",
            "Codon: ACC,   Count: 1\n",
            "Codon: AGG,   Count: 1\n",
            "Codon: GAA,   Count: 1\n",
            "Codon: TTA,   Count: 1\n",
            "Codon: TGC,   Count: 1\n",
            "Codon: GCG,   Count: 1\n",
            "Codon: TAC,   Count: 1\n",
            "Codon: CCG,   Count: 1\n",
            "Codon: AAA,   Count: 1\n",
            "Codon: AGA,   Count: 1\n",
            "Codon: TCT,   Count: 1\n",
            "Codon: TGG,   Count: 1\n",
            "\n",
            "\n",
            "Name : Serine,   Count: 4\n",
            "Name : Argimine,   Count: 4\n",
            "Name : Glycine,   Count: 3\n",
            "Name : Lysine,   Count: 3\n",
            "Name : Cysteine,   Count: 3\n",
            "Name : Leucine,   Count: 2\n",
            "Name : STOP,   Count: 2\n",
            "Name : Isoleucine,   Count: 2\n",
            "Name : Arginine,   Count: 2\n",
            "Name : Glutamine,   Count: 1\n",
            "Name : Asparagine,   Count: 1\n",
            "Name : Threonine,   Count: 1\n",
            "Name : Glutamic acid,   Count: 1\n",
            "Name : Alanine,   Count: 1\n",
            "Name : Tyrosine,   Count: 1\n",
            "Name : Proline,   Count: 1\n",
            "Name : Trytophan,   Count: 1\n"
          ]
        }
      ],
      "source": [
        "dna_seq = (''.join(random.choice(BASES) for _ in range(LEN)) )  #Generate an input DNA sequence \n",
        "print(dna_seq,\"\\n\")\n",
        "\n",
        "assert len(dna_seq)%3 == 0 , \"DNA sequence should be a multiple of three to be processed\"  \n",
        "\n",
        "list_codon, protein = coreT3(dna_seq)\n",
        "\n",
        "d_cod = Counter(list_codon)\n",
        "displayT3(d_cod,True)\n",
        "\n",
        "print(\"\\n\")\n",
        "\n",
        "d_pro = Counter(protein)\n",
        "displayT3(d_pro,False)\n"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}