Python_Course_MeInBio_PART6_solution.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"IMAGES_PYTHON_COURSE_2018/LOGO_MEINBIO_TRANSPARENT.png\" width=\"200\" height=\"200\" />\n",
    "\n",
    "# <center>Python course 2018\n",
    "### <center>MeInBio Training Group \n",
    "#### <center> by Florian Heyl & Francesco Ferrari "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PART 6: DICTIONARIES\n",
    "\n",
    "For some type of problems, you may want to make a 1:1 association between one value and another. For example, we may want to associate each gene name with its length, or associate each gene name with a list of information about that gene, for example its length, its symbol, its expression level, etc. \n",
    "\n",
    "A python dictionary allows you to do just that! You can associate one item, that we call \"key\", with a certain \"value\", that can be any python object (a string, a number, a list, a tuple, a dictionary, a dataframe, etc.). \n",
    "\n",
    "The syntax for creating a dictionary is similar to that used for creating a list, but we use curly brackets rather than square ones. Each pair of data, consisting of a key and a value, is called an item. When storing items in a dictionary, we separate them with commas. Within an individual item, we separate the key and the value with a colon.\n",
    "Here's a bit of code that creates a dictionary of restriction enzymes with three items:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a dictionary\n",
    "\n",
    "enzymes = { 'EcoRI':'GAATTC', 'AvaII':'GG(A|T)CC', 'BisI':'GC[ATGC]GC'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To retrieve a bit of data from the dictionary – i.e. to look up the motif for a particular enzyme – we write the name of the dictionary, followed by the key in square brackets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GAATTC\n"
     ]
    }
   ],
   "source": [
    "# retrieve a value from a dictionary through its assoaciated key\n",
    "\n",
    "print(enzymes['EcoRI'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### IMPORTANT NOTE: \n",
    "\n",
    "There are two important restrictions concerning dictionaries that we should ***NEVER*** forget:\n",
    "\n",
    "1) We can use as keys only strings, numbers or tuples.\n",
    "\n",
    "2) The keys **MUST** be **UNIQUE**; if we use the same key and we want it to be associated with multiple values, this will not work. Only one of these values will be associated with a given key.\n",
    "\n",
    "3) Dictionaries are inherently unordered: that means, the order of the keys in a dictionary is random (contrary to the order of objects in a list).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usually, we don't build dictionaries by writing each key-value pair by hand. Often, we populate the dictionary through a for loop. \n",
    "\n",
    "For example, given a sequence, we want to count all possible trinucleotides that are present in that sequence. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'AAA': 1, 'AAT': 0, 'AAC': 1, 'AAG': 0, 'ATA': 0, 'ATT': 2, 'ATC': 0, 'ATG': 1, 'ACA': 0, 'ACT': 1, 'ACC': 0, 'ACG': 2, 'AGA': 1, 'AGT': 1, 'AGC': 0, 'AGG': 0, 'TAA': 1, 'TAT': 0, 'TAC': 1, 'TAG': 1, 'TTA': 2, 'TTT': 1, 'TTC': 1, 'TTG': 0, 'TCA': 1, 'TCT': 0, 'TCC': 0, 'TCG': 0, 'TGA': 1, 'TGT': 0, 'TGC': 1, 'TGG': 0, 'CAA': 0, 'CAT': 0, 'CAC': 0, 'CAG': 1, 'CTA': 0, 'CTT': 0, 'CTC': 0, 'CTG': 0, 'CCA': 0, 'CCT': 0, 'CCC': 0, 'CCG': 0, 'CGA': 1, 'CGT': 2, 'CGC': 2, 'CGG': 0, 'GAA': 0, 'GAT': 2, 'GAC': 1, 'GAG': 0, 'GTA': 1, 'GTT': 1, 'GTC': 0, 'GTG': 1, 'GCA': 0, 'GCT': 0, 'GCC': 0, 'GCG': 2, 'GGA': 0, 'GGT': 0, 'GGC': 0, 'GGG': 0}\n"
     ]
    }
   ],
   "source": [
    "# count the occurrances of all possible trinucleotides that are present in a DNA sequence\n",
    "\n",
    "sequence = \"ATGCGCGTAGTTCAGATTTAAAACGCGATTACGTGACT\"\n",
    "nucleotides = ['A','T','C','G']\n",
    "\n",
    "trinuc_dic = {}\n",
    "for a in nucleotides:\n",
    "    # 1st iteration: a = \"A\", 2nd: a = \"T\", 3rd = \"C\"\n",
    "    for b in nucleotides:\n",
    "        # go through A, T, C, G\n",
    "        for c in nucleotides:\n",
    "            # go through A, T, C, G\n",
    "            \n",
    "            trinuc_dic[a+b+c] = sequence.count(a+b+c) \n",
    "print(trinuc_dic)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AA\n",
      "AT\n",
      "AC\n",
      "AG\n",
      "TA\n",
      "TT\n",
      "TC\n",
      "TG\n",
      "CA\n",
      "CT\n",
      "CC\n",
      "CG\n",
      "GA\n",
      "GT\n",
      "GC\n",
      "GG\n"
     ]
    }
   ],
   "source": [
    "nucleotides = ['A','T','C','G']\n",
    "\n",
    "for a in nucleotides:\n",
    "    for b in nucleotides:\n",
    "        print(a+b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then, if we want to retrieve the number of occurrences of the trinucleotide \"CGT\", how do we do?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### insert your code in the space below\n",
    "\n",
    "\n",
    "trinuc_dic['CGT']\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 1 (medium)\n",
    "\n",
    "Given a sequence and a value for k, count how many time each k-mer is present in the sequence\n",
    "\n",
    "(hint: if k is 4, that means that we want to count all possible four-nucleotides combinations. To do that for any k, we can use a function present in the itertools library, as in the example below)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import itertools as it\n",
    "\n",
    "def get_possible_kmers(k=3):\n",
    "    \n",
    "    if k > 10:\n",
    "        print(\"Choose a value of k between 1 and 10\")\n",
    "    \n",
    "    else:\n",
    "        combi = it.product([\"A\",\"T\",\"G\",\"C\"],repeat=k)\n",
    "        combi = [\"\".join(j) for j in combi]\n",
    "\n",
    "        if k < 5:\n",
    "            #print(combi, len(combi))\n",
    "            pass\n",
    "        else:\n",
    "            pass\n",
    "            #print(\"The first 10 items in the list are:\\n {}\\n\\nThe list contains {} {}-mers\".format(combi[1:10], len(combi), k))\n",
    "    return combi\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['AAAA', 'AAAT', 'AAAG', 'AAAC', 'AATA', 'AATT', 'AATG', 'AATC', 'AAGA', 'AAGT', 'AAGG', 'AAGC', 'AACA', 'AACT', 'AACG', 'AACC', 'ATAA', 'ATAT', 'ATAG', 'ATAC', 'ATTA', 'ATTT', 'ATTG', 'ATTC', 'ATGA', 'ATGT', 'ATGG', 'ATGC', 'ATCA', 'ATCT', 'ATCG', 'ATCC', 'AGAA', 'AGAT', 'AGAG', 'AGAC', 'AGTA', 'AGTT', 'AGTG', 'AGTC', 'AGGA', 'AGGT', 'AGGG', 'AGGC', 'AGCA', 'AGCT', 'AGCG', 'AGCC', 'ACAA', 'ACAT', 'ACAG', 'ACAC', 'ACTA', 'ACTT', 'ACTG', 'ACTC', 'ACGA', 'ACGT', 'ACGG', 'ACGC', 'ACCA', 'ACCT', 'ACCG', 'ACCC', 'TAAA', 'TAAT', 'TAAG', 'TAAC', 'TATA', 'TATT', 'TATG', 'TATC', 'TAGA', 'TAGT', 'TAGG', 'TAGC', 'TACA', 'TACT', 'TACG', 'TACC', 'TTAA', 'TTAT', 'TTAG', 'TTAC', 'TTTA', 'TTTT', 'TTTG', 'TTTC', 'TTGA', 'TTGT', 'TTGG', 'TTGC', 'TTCA', 'TTCT', 'TTCG', 'TTCC', 'TGAA', 'TGAT', 'TGAG', 'TGAC', 'TGTA', 'TGTT', 'TGTG', 'TGTC', 'TGGA', 'TGGT', 'TGGG', 'TGGC', 'TGCA', 'TGCT', 'TGCG', 'TGCC', 'TCAA', 'TCAT', 'TCAG', 'TCAC', 'TCTA', 'TCTT', 'TCTG', 'TCTC', 'TCGA', 'TCGT', 'TCGG', 'TCGC', 'TCCA', 'TCCT', 'TCCG', 'TCCC', 'GAAA', 'GAAT', 'GAAG', 'GAAC', 'GATA', 'GATT', 'GATG', 'GATC', 'GAGA', 'GAGT', 'GAGG', 'GAGC', 'GACA', 'GACT', 'GACG', 'GACC', 'GTAA', 'GTAT', 'GTAG', 'GTAC', 'GTTA', 'GTTT', 'GTTG', 'GTTC', 'GTGA', 'GTGT', 'GTGG', 'GTGC', 'GTCA', 'GTCT', 'GTCG', 'GTCC', 'GGAA', 'GGAT', 'GGAG', 'GGAC', 'GGTA', 'GGTT', 'GGTG', 'GGTC', 'GGGA', 'GGGT', 'GGGG', 'GGGC', 'GGCA', 'GGCT', 'GGCG', 'GGCC', 'GCAA', 'GCAT', 'GCAG', 'GCAC', 'GCTA', 'GCTT', 'GCTG', 'GCTC', 'GCGA', 'GCGT', 'GCGG', 'GCGC', 'GCCA', 'GCCT', 'GCCG', 'GCCC', 'CAAA', 'CAAT', 'CAAG', 'CAAC', 'CATA', 'CATT', 'CATG', 'CATC', 'CAGA', 'CAGT', 'CAGG', 'CAGC', 'CACA', 'CACT', 'CACG', 'CACC', 'CTAA', 'CTAT', 'CTAG', 'CTAC', 'CTTA', 'CTTT', 'CTTG', 'CTTC', 'CTGA', 'CTGT', 'CTGG', 'CTGC', 'CTCA', 'CTCT', 'CTCG', 'CTCC', 'CGAA', 'CGAT', 'CGAG', 'CGAC', 'CGTA', 'CGTT', 'CGTG', 'CGTC', 'CGGA', 'CGGT', 'CGGG', 'CGGC', 'CGCA', 'CGCT', 'CGCG', 'CGCC', 'CCAA', 'CCAT', 'CCAG', 'CCAC', 'CCTA', 'CCTT', 'CCTG', 'CCTC', 'CCGA', 'CCGT', 'CCGG', 'CCGC', 'CCCA', 'CCCT', 'CCCG', 'CCCC']\n"
     ]
    }
   ],
   "source": [
    "print(get_possible_kmers(k=4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'AAA': 2, 'AAT': 0, 'AAG': 1, 'AAC': 1, 'ATA': 1, 'ATT': 1, 'ATG': 4, 'ATC': 1, 'AGA': 0, 'AGT': 1, 'AGG': 0, 'AGC': 1, 'ACA': 1, 'ACT': 0, 'ACG': 1, 'ACC': 1, 'TAA': 1, 'TAT': 1, 'TAG': 1, 'TAC': 1, 'TTA': 0, 'TTT': 0, 'TTG': 1, 'TTC': 1, 'TGA': 1, 'TGT': 0, 'TGG': 2, 'TGC': 3, 'TCA': 0, 'TCT': 0, 'TCG': 1, 'TCC': 1, 'GAA': 1, 'GAT': 4, 'GAG': 0, 'GAC': 1, 'GTA': 0, 'GTT': 0, 'GTG': 0, 'GTC': 0, 'GGA': 3, 'GGT': 0, 'GGG': 2, 'GGC': 1, 'GCA': 1, 'GCT': 2, 'GCG': 1, 'GCC': 1, 'CAA': 0, 'CAT': 2, 'CAG': 0, 'CAC': 0, 'CTA': 2, 'CTT': 1, 'CTG': 1, 'CTC': 0, 'CGA': 2, 'CGT': 0, 'CGG': 2, 'CGC': 0, 'CCA': 0, 'CCT': 2, 'CCG': 1, 'CCC': 3}\n"
     ]
    }
   ],
   "source": [
    "possible_kmers = get_possible_kmers(k=3) # select the k of your choice (from 1 to 10)\n",
    "\n",
    "sequence_1 = \"ATTCGATGCTAGCTTGGGATATACGGGCCCCCGGATGACCCCTGGAAACATGCGATGCATCCCTAAAAGT\"\n",
    "\n",
    "kmer_dic = {}\n",
    "\n",
    "# now it's up to you! Insert your code in the space below\n",
    "\n",
    "for kmer in possible_kmers:\n",
    "    kmer_dic[kmer] = sequence_1.count(kmer)\n",
    "print(kmer_dic)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, try to retrieve a value using a key that does not exist in the dictionary. For example, try to retrieve the counts of the k-mer \"NNNN\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'NNNN'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-10-fbbc8133b7a0>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkmer_dic\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"NNNN\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m: 'NNNN'"
     ]
    }
   ],
   "source": [
    "print(kmer_dic[\"NNNN\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You get a **KeyError**. Remember it, as you may encounter it often when working with dictionaries. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use the dictionary's **get** method to retrieve values from a dictionary. The thing that makes **get** really useful, however, is that it can take an optional\n",
    "second argument, which is the default value to be returned if the key isn't present\n",
    "in the dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "# syntax for get method\n",
    "\n",
    "print(kmer_dic.get(\"NNN\",0))\n",
    "print(kmer_dic.get(\"AAA\",0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterating over a dictionary \n",
    "\n",
    "We can iterate over a dictionary in two main ways:\n",
    "\n",
    "1) iterate over the keys of a dictionary;  \n",
    "2) iterate over items (pairs of key, value)\n",
    "\n",
    "Here are some examples that show you the syntax to use"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The keys present in the dictionary are:\n",
      "['EcoRI', 'AvaII', 'BisI']\n",
      "\n",
      "EcoRI --> GAATTC\n",
      "AvaII --> GG(A|T)CC\n",
      "BisI --> GC[ATGC]GC\n",
      "\n",
      "\n",
      "The tuples (key,value) present in the dictionary are:\n",
      "[('EcoRI', 'GAATTC'), ('AvaII', 'GG(A|T)CC'), ('BisI', 'GC[ATGC]GC')]\n",
      "\n",
      "EcoRI --> GAATTC\n",
      "AvaII --> GG(A|T)CC\n",
      "BisI --> GC[ATGC]GC\n"
     ]
    }
   ],
   "source": [
    "# 1) \n",
    "# get all keys in a dictionary\n",
    "all_keys = enzymes.keys()\n",
    "print(\"The keys present in the dictionary are:\\n{}\\n\".format(list(all_keys)))\n",
    "\n",
    "# iterate over the keys to retrieve the corresponding value of each key\n",
    "for key in all_keys:\n",
    "    print(\"{} --> {}\".format(key, enzymes[key]))\n",
    "print(\"\\n\")\n",
    "\n",
    "\n",
    "# 2)\n",
    "# get all items in a dictionary\n",
    "all_items = enzymes.items()\n",
    "print(\"The tuples (key,value) present in the dictionary are:\\n{}\\n\".format(list(all_items)))\n",
    "\n",
    "# iterate over key and values at the same time\n",
    "for key, value in all_items:\n",
    "    print(\"{} --> {}\".format(key, value))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The keys present in the dictionary are:\n",
      "['EcoRI', 'AvaII', 'BisI']\n",
      "\n",
      "EcoRI GAATTC\n",
      "AvaII GG(A|T)CC\n",
      "BisI GC[ATGC]GC\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# 1) \n",
    "enzymes = { 'EcoRI':'GAATTC', 'AvaII':'GG(A|T)CC', 'BisI':'GC[ATGC]GC'}\n",
    "# get all keys in a dictionary\n",
    "all_keys = enzymes.keys()\n",
    "#print(all_keys)\n",
    "print(\"The keys present in the dictionary are:\\n{}\\n\".format(list(all_keys)))\n",
    "\n",
    "# iterate over the keys to retrieve the corresponding value of each key\n",
    "for name in all_keys:\n",
    "    cuttingsite=enzymes[name]\n",
    "    print(name, cuttingsite)\n",
    "    #print(\"{} --> {}\".format(key, enzymes[key]))\n",
    "print(\"\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 2 (easy/medium)\n",
    "\n",
    "Given a dictionary storing the genetic code and a DNA sequence, translate the DNA sequence into the corresponding amino acids (protein) sequence. Assume that the sequence you are given is the open reading frame (ORF) of the gene (so you don't have to search through all possible ORFs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3859\n",
      "1287\n",
      "ALCSSCSTVSRIFFCVAR_RRAERNPGG_GRPEGGRGGRRPDVFAPLRGGPGRPPHCRGGRRT_CGAGWAWRPGGGGEGRRVCRPGPLGAHCSLPPRSRATSLRHHGEGEGRSQRVSSRVAGGPWAATAPEPRLRALRAPGLCSRMGAG_LFPARRAQGQRSDLAEPRTQAVAPCAAPPLRRHLPGASFP_SPETGGPYSRPRSRPGPLGGGRFLSFRALRGHVSQRSPSPTASGTAGPGMLVRSGCIPVRMLRLR_SGRHVATGKEMNGQPLGKPAGD_PCAPASMGGVACGGEVRWSEASWPDFSSG_CFS_IILW_IKEVGLWRSSCVPSPQRCGGCGMVPSREKLSHG_LEKDISTAKWPLWWWPLPAAPAHLTAPPFPCQPSVDPTPKARL_MSPGGLGVWAPRGTCPSPHSVFRKPDLPPHPGLRLNIAADLSVAGGLGWGSLPSLLPTHMHLPVLPLLISGKELGRTGNLANQSPGTRGLKYSFPSSHPPQSLSLL_EGLREGVGLPCPVNF_PLLLPFEFDDAECTSVFSLKGAAELGSSKHSWGGIVGW_IPCTKLVPRLWVAVPHMAASPGRASYDWGCWAALEPSVAAMP_ARPAWQGSSREIKFNLLGPPGGKEMLHSPS_WGGGLGLLTYSGGASPPHAFLPLVS_IWSYWAPGHQGCF_LW_SGYCCHQ_PLH_PQLHGECYMVSPKAGVGGATWLMGSPFIPSRIPPGLHVPI_FHPWQIPWHRQG_EREACHQWKSHHHLPGVSGRQNGRNVLWGGN_DGVAPLGIW_PCVPQYGPVPISPPPP_ARSLQNQVGRCWR_VRRGVHWRLHHHGEGWGECRRARGRGS_LSPAKAGPGFITVCFSAVGSFAGGSQKGHHLCPLC_CPHVRHGCEP_EV_QQPQDHQVRKAGPVEKRPAWHPMDTLP_LAPRSLFLCSNASCTTNCLAPLAKVIHDNFGIVEGLMV_ELGNGTEAPTFLIQDWLLPAGAACNPGVGGSGDWLSHNFLSRWGGR_RGDVGSTLQGLTPFADHSPCHHCHPEDCGWPLRETVA_WPRGSPEHHPCLYWRCQGCGQGHP_AEREAHWHGLPCPHCQRVSGGPDLPSRKTCQI__HQEGGEAGVGGPPQGHPGLH_APGGLL_LQQRHPLLHL_RWGWHCPQRPLCQAHFLVCGWGQRLALKKCRVWRPLVAGSEKGP_QLFSSSRYDNEFGYSNRVVDLMAHMASKE_DPWTTSPSKSTRGRERPSLLGSPCHTQSPTTLNLPSSQLPCRPLEEGRGLGSRTLSCTINKVPCAQPV#\n"
     ]
    }
   ],
   "source": [
    "# genetic code dictionary\n",
    "gencode = {\n",
    "'ATA':'I', 'ATC':'I', 'ATT':'I', 'ATG':'M',\n",
    "'ACA':'T', 'ACC':'T', 'ACG':'T', 'ACT':'T',\n",
    "'AAC':'N', 'AAT':'N', 'AAA':'K', 'AAG':'K',\n",
    "'AGC':'S', 'AGT':'S', 'AGA':'R', 'AGG':'R',\n",
    "'CTA':'L', 'CTC':'L', 'CTG':'L', 'CTT':'L',\n",
    "'CCA':'P', 'CCC':'P', 'CCG':'P', 'CCT':'P',\n",
    "'CAC':'H', 'CAT':'H', 'CAA':'Q', 'CAG':'Q',\n",
    "'CGA':'R', 'CGC':'R', 'CGG':'R', 'CGT':'R',\n",
    "'GTA':'V', 'GTC':'V', 'GTG':'V', 'GTT':'V',\n",
    "'GCA':'A', 'GCC':'A', 'GCG':'A', 'GCT':'A',\n",
    "'GAC':'D', 'GAT':'D', 'GAA':'E', 'GAG':'E',\n",
    "'GGA':'G', 'GGC':'G', 'GGG':'G', 'GGT':'G',\n",
    "'TCA':'S', 'TCC':'S', 'TCG':'S', 'TCT':'S',\n",
    "'TTC':'F', 'TTT':'F', 'TTA':'L', 'TTG':'L',\n",
    "'TAC':'Y', 'TAT':'Y', 'TAA':'_', 'TAG':'_',\n",
    "'TGC':'C', 'TGT':'C', 'TGA':'_', 'TGG':'W'}\n",
    "\n",
    "sequence_gapdh = \"\"\"GCTCTCTGCTCCTCCTGTTCGACAGTCAGCCGCATCTTCTTTTGCGTCGCCAGGTGAAGACGGGCGGAGA\n",
    "GAAACCCGGGAGGCTAGGGACGGCCTGAAGGCGGCAGGGGCGGGCGCAGGCCGGATGTGTTCGCGCCGCT\n",
    "GCGGGGTGGGCCCGGGCGGCCTCCGCATTGCAGGGGCGGGCGGAGGACGTGATGCGGCGCGGGCTGGGCA\n",
    "TGGAGGCCTGGTGGGGGAGGGGAGGGGAGGCGTGTGTGTCGGCCGGGGCCACTAGGCGCTCACTGTTCTC\n",
    "TCCCTCCGCGCAGCCGAGCCACATCGCTCAGACACCATGGGGAAGGTGAAGGTCGGAGTCAACGGGTGAG\n",
    "TTCGCGGGTGGCTGGGGGGCCCTGGGCTGCGACCGCCCCCGAACCGCGTCTACGAGCCTTGCGGGCTCCG\n",
    "GGTCTTTGCAGTCGTATGGGGGCAGGGTAGCTGTTCCCCGCAAGGAGAGCTCAAGGTCAGCGCTCGGACC\n",
    "TGGCGGAGCCCCGCACCCAGGCTGTGGCGCCCTGTGCAGCTCCGCCCTTGCGGCGCCATCTGCCCGGAGC\n",
    "CTCCTTCCCCTAGTCCCCAGAAACAGGAGGTCCCTACTCCCGCCCGAGATCCCGACCCGGACCCCTAGGT\n",
    "GGGGGACGCTTTCTTTCCTTTCGCGCTCTGCGGGGTCACGTGTCGCAGAGGAGCCCCTCCCCCACGGCCT\n",
    "CCGGCACCGCAGGCCCCGGGATGCTAGTGCGCAGCGGGTGCATCCCTGTCCGGATGCTGCGCCTGCGGTA\n",
    "GAGCGGCCGCCATGTTGCAACCGGGAAGGAAATGAATGGGCAGCCGTTAGGAAAGCCTGCCGGTGACTAA\n",
    "CCCTGCGCTCCTGCCTCGATGGGTGGAGTCGCGTGTGGCGGGGAAGTCAGGTGGAGCGAGGCTAGCTGGC\n",
    "CCGATTTCTCCTCCGGGTGATGCTTTTCCTAGATTATTCTCTGGTAAATCAAAGAAGTGGGTTTATGGAG\n",
    "GTCCTCTTGTGTCCCCTCCCCGCAGAGGTGTGGTGGCTGTGGCATGGTGCCAAGCCGGGAGAAGCTGAGT\n",
    "CATGGGTAGTTGGAAAAGGACATTTCCACCGCAAAATGGCCCCTCTGGTGGTGGCCCCTTCCTGCAGCGC\n",
    "CGGCTCACCTCACGGCCCCGCCCTTCCCCTGCCAGCCTAGCGTTGACCCGACCCCAAAGGCCAGGCTGTA\n",
    "AATGTCACCGGGAGGATTGGGTGTCTGGGCGCCTCGGGGAACCTGCCCTTCTCCCCATTCCGTCTTCCGG\n",
    "AAACCAGATCTCCCACCGCACCCTGGTCTGAGGTTAAATATAGCTGCTGACCTTTCTGTAGCTGGGGGCC\n",
    "TGGGCTGGGGCTCTCTCCCATCCCTTCTCCCCACACACATGCACTTACCTGTGCTCCCACTCCTGATTTC\n",
    "TGGAAAAGAGCTAGGAAGGACAGGCAACTTGGCAAATCAAAGCCCTGGGACTAGGGGGTTAAAATACAGC\n",
    "TTCCCCTCTTCCCACCCGCCCCAGTCTCTGTCCCTTTTGTAGGAGGGACTTAGAGAAGGGGTGGGCTTGC\n",
    "CCTGTCCAGTTAATTTCTGACCTTTACTCCTGCCCTTTGAGTTTGATGATGCTGAGTGTACAAGCGTTTT\n",
    "CTCCCTAAAGGGTGCAGCTGAGCTAGGCAGCAGCAAGCATTCCTGGGGTGGCATAGTGGGGTGGTGAATA\n",
    "CCATGTACAAAGCTTGTGCCCAGACTGTGGGTGGCAGTGCCCCACATGGCCGCTTCTCCTGGAAGGGCTT\n",
    "CGTATGACTGGGGGTGTTGGGCAGCCCTGGAGCCTTCAGTTGCAGCCATGCCTTAAGCCAGGCCAGCCTG\n",
    "GCAGGGAAGCTCAAGGGAGATAAAATTCAACCTCTTGGGCCCTCCTGGGGGTAAGGAGATGCTGCATTCG\n",
    "CCCTCTTAATGGGGAGGTGGCCTAGGGCTGCTCACATATTCTGGAGGAGCCTCCCCTCCTCATGCCTTCT\n",
    "TGCCTCTTGTCTCTTAGATTTGGTCGTATTGGGCGCCTGGTCACCAGGGCTGCTTTTAACTCTGGTAAAG\n",
    "TGGATATTGTTGCCATCAATGACCCCTTCATTGACCTCAACTACATGGTGAGTGCTACATGGTGAGCCCC\n",
    "AAAGCTGGTGTGGGAGGAGCCACCTGGCTGATGGGCAGCCCCTTCATACCCTCACGTATTCCCCCAGGTT\n",
    "TACATGTTCCAATATGATTCCACCCATGGCAAATTCCATGGCACCGTCAAGGCTGAGAACGGGAAGCTTG\n",
    "TCATCAATGGAAATCCCATCACCATCTTCCAGGAGTGAGTGGAAGACAGAATGGAAGAAATGTGCTTTGG\n",
    "GGAGGCAACTAGGATGGTGTGGCTCCCTTGGGTATATGGTAACCTTGTGTCCCTCAATATGGTCCTGTCC\n",
    "CCATCTCCCCCCCACCCCCATAGGCGAGATCCCTCCAAAATCAAGTGGGGCGATGCTGGCGCTGAGTACG\n",
    "TCGTGGAGTCCACTGGCGTCTTCACCACCATGGAGAAGGCTGGGGTGAGTGCAGGAGGGCCCGCGGGAGG\n",
    "GGAAGCTGACTCAGCCCTGCAAAGGCAGGACCCGGGTTCATAACTGTCTGCTTCTCTGCTGTAGGCTCAT\n",
    "TTGCAGGGGGGAGCCAAAAGGGTCATCATCTCTGCCCCCTCTGCTGATGCCCCCATGTTCGTCATGGGTG\n",
    "TGAACCATGAGAAGTATGACAACAGCCTCAAGATCATCAGGTGAGGAAGGCAGGGCCCGTGGAGAAGCGG\n",
    "CCAGCCTGGCACCCTATGGACACGCTCCCCTGACTTGCGCCCCGCTCCCTCTTTCTTTGCAGCAATGCCT\n",
    "CCTGCACCACCAACTGCTTAGCACCCCTGGCCAAGGTCATCCATGACAACTTTGGTATCGTGGAAGGACT\n",
    "CATGGTATGAGAGCTGGGGAATGGGACTGAGGCTCCCACCTTTCTCATCCAAGACTGGCTCCTCCCTGCC\n",
    "GGGGCTGCGTGCAACCCTGGGGTTGGGGGTTCTGGGGACTGGCTTTCCCATAATTTCCTTTCAAGGTGGG\n",
    "GAGGGAGGTAGAGGGGTGATGTGGGGAGTACGCTGCAGGGCCTCACTCCTTTTGCAGACCACAGTCCATG\n",
    "CCATCACTGCCACCCAGAAGACTGTGGATGGCCCCTCCGGGAAACTGTGGCGTGATGGCCGCGGGGCTCT\n",
    "CCAGAACATCATCCCTGCCTCTACTGGCGCTGCCAAGGCTGTGGGCAAGGTCATCCCTGAGCTGAACGGG\n",
    "AAGCTCACTGGCATGGCCTTCCGTGTCCCCACTGCCAACGTGTCAGTGGTGGACCTGACCTGCCGTCTAG\n",
    "AAAAACCTGCCAAATATGATGACATCAAGAAGGTGGTGAAGCAGGCGTCGGAGGGCCCCCTCAAGGGCAT\n",
    "CCTGGGCTACACTGAGCACCAGGTGGTCTCCTCTGACTTCAACAGCGACACCCACTCCTCCACCTTTGAC\n",
    "GCTGGGGCTGGCATTGCCCTCAACGACCACTTTGTCAAGCTCATTTCCTGGTATGTGGCTGGGGCCAGAG\n",
    "ACTGGCTCTTAAAAAGTGCAGGGTCTGGCGCCCTCTGGTGGCTGGCTCAGAAAAAGGGCCCTGACAACTC\n",
    "TTTTCATCTTCTAGGTATGACAACGAATTTGGCTACAGCAACAGGGTGGTGGACCTCATGGCCCACATGG\n",
    "CCTCCAAGGAGTAAGACCCCTGGACCACCAGCCCCAGCAAGAGCACAAGAGGAAGAGAGAGACCCTCACT\n",
    "GCTGGGGAGTCCCTGCCACACTCAGTCCCCCACCACACTGAATCTCCCCTCCTCACAGTTGCCATGTAGA\n",
    "CCCCTTGAAGAGGGGAGGGGCCTAGGGAGCCGCACCTTGTCATGTACCATCAATAAAGTACCCTGTGCTC\n",
    "AACCAGTTA\"\"\"\n",
    "\n",
    "sequence_gapdh = sequence_gapdh.replace(\"\\n\",\"\")\n",
    "\n",
    "# insert your code in the space below\n",
    "\n",
    "n = 3\n",
    "chunks = [sequence_gapdh[i:i+n] for i in range(0, len(sequence_gapdh), n)]\n",
    "print(len(sequence_gapdh))\n",
    "print(len(chunks))\n",
    "#print(chunks)\n",
    "#translated = []\n",
    "aa_sequence = \"\"\n",
    "\n",
    "for code in chunks:\n",
    "    #print(code)\n",
    "    aa = gencode.get(code,\"#\")\n",
    "    aa_sequence = aa_sequence + aa\n",
    "    #translated.append(aa)\n",
    "    \n",
    "#print(\"\".join(translated))\n",
    "print(aa_sequence)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Expected Outcome  \n",
    "\n",
    "ALCSSCSTVSRIFFCVAR_RRAERNPGG_GRPEGGRGGRRPDVFAPLRGGPGRPPHCRGGRRT_CGAGWAWRPGGGGEGRRVCRPGPLGAHCSLPPRSRATSLRHHGEGEGRSQRVSSRVAGGPWAATAPEPRLRALRAPGLCSRMGAG_LFPARRAQGQRSDLAEPRTQAVAPCAAPPLRRHLPGASFP_SPETGGPYSRPRSRPGPLGGGRFLSFRALRGHVSQRSPSPTASGTAGPGMLVRSGCIPVRMLRLR_SGRHVATGKEMNGQPLGKPAGD_PCAPASMGGVACGGEVRWSEASWPDFSSG_CFS_IILW_IKEVGLWRSSCVPSPQRCGGCGMVPSREKLSHG_LEKDISTAKWPLWWWPLPAAPAHLTAPPFPCQPSVDPTPKARL_MSPGGLGVWAPRGTCPSPHSVFRKPDLPPHPGLRLNIAADLSVAGGLGWGSLPSLLPTHMHLPVLPLLISGKELGRTGNLANQSPGTRGLKYSFPSSHPPQSLSLL_EGLREGVGLPCPVNF_PLLLPFEFDDAECTSVFSLKGAAELGSSKHSWGGIVGW_IPCTKLVPRLWVAVPHMAASPGRASYDWGCWAALEPSVAAMP_ARPAWQGSSREIKFNLLGPPGGKEMLHSPS_WGGGLGLLTYSGGASPPHAFLPLVS_IWSYWAPGHQGCF_LW_SGYCCHQ_PLH_PQLHGECYMVSPKAGVGGATWLMGSPFIPSRIPPGLHVPI_FHPWQIPWHRQG_EREACHQWKSHHHLPGVSGRQNGRNVLWGGN_DGVAPLGIW_PCVPQYGPVPISPPPP_ARSLQNQVGRCWR_VRRGVHWRLHHHGEGWGECRRARGRGS_LSPAKAGPGFITVCFSAVGSFAGGSQKGHHLCPLC_CPHVRHGCEP_EV_QQPQDHQVRKAGPVEKRPAWHPMDTLP_LAPRSLFLCSNASCTTNCLAPLAKVIHDNFGIVEGLMV_ELGNGTEAPTFLIQDWLLPAGAACNPGVGGSGDWLSHNFLSRWGGR_RGDVGSTLQGLTPFADHSPCHHCHPEDCGWPLRETVA_WPRGSPEHHPCLYWRCQGCGQGHP_AEREAHWHGLPCPHCQRVSGGPDLPSRKTCQI__HQEGGEAGVGGPPQGHPGLH_APGGLL_LQQRHPLLHL_RWGWHCPQRPLCQAHFLVCGWGQRLALKKCRVWRPLVAGSEKGP_QLFSSSRYDNEFGYSNRVVDLMAHMASKE_DPWTTSPSKSTRGRERPSLLGSPCHTQSPTTLNLPSSQLPCRPLEEGRGLGSRTLSCTINKVPCAQPV?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "solution = \"ALCSSCSTVSRIFFCVAR_RRAERNPGG_GRPEGGRGGRRPDVFAPLRGGPGRPPHCRGGRRT_CGAGWAWRPGGGGEGRRVCRPGPLGAHCSLPPRSRATSLRHHGEGEGRSQRVSSRVAGGPWAATAPEPRLRALRAPGLCSRMGAG_LFPARRAQGQRSDLAEPRTQAVAPCAAPPLRRHLPGASFP_SPETGGPYSRPRSRPGPLGGGRFLSFRALRGHVSQRSPSPTASGTAGPGMLVRSGCIPVRMLRLR_SGRHVATGKEMNGQPLGKPAGD_PCAPASMGGVACGGEVRWSEASWPDFSSG_CFS_IILW_IKEVGLWRSSCVPSPQRCGGCGMVPSREKLSHG_LEKDISTAKWPLWWWPLPAAPAHLTAPPFPCQPSVDPTPKARL_MSPGGLGVWAPRGTCPSPHSVFRKPDLPPHPGLRLNIAADLSVAGGLGWGSLPSLLPTHMHLPVLPLLISGKELGRTGNLANQSPGTRGLKYSFPSSHPPQSLSLL_EGLREGVGLPCPVNF_PLLLPFEFDDAECTSVFSLKGAAELGSSKHSWGGIVGW_IPCTKLVPRLWVAVPHMAASPGRASYDWGCWAALEPSVAAMP_ARPAWQGSSREIKFNLLGPPGGKEMLHSPS_WGGGLGLLTYSGGASPPHAFLPLVS_IWSYWAPGHQGCF_LW_SGYCCHQ_PLH_PQLHGECYMVSPKAGVGGATWLMGSPFIPSRIPPGLHVPI_FHPWQIPWHRQG_EREACHQWKSHHHLPGVSGRQNGRNVLWGGN_DGVAPLGIW_PCVPQYGPVPISPPPP_ARSLQNQVGRCWR_VRRGVHWRLHHHGEGWGECRRARGRGS_LSPAKAGPGFITVCFSAVGSFAGGSQKGHHLCPLC_CPHVRHGCEP_EV_QQPQDHQVRKAGPVEKRPAWHPMDTLP_LAPRSLFLCSNASCTTNCLAPLAKVIHDNFGIVEGLMV_ELGNGTEAPTFLIQDWLLPAGAACNPGVGGSGDWLSHNFLSRWGGR_RGDVGSTLQGLTPFADHSPCHHCHPEDCGWPLRETVA_WPRGSPEHHPCLYWRCQGCGQGHP_AEREAHWHGLPCPHCQRVSGGPDLPSRKTCQI__HQEGGEAGVGGPPQGHPGLH_APGGLL_LQQRHPLLHL_RWGWHCPQRPLCQAHFLVCGWGQRLALKKCRVWRPLVAGSEKGP_QLFSSSRYDNEFGYSNRVVDLMAHMASKE_DPWTTSPSKSTRGRERPSLLGSPCHTQSPTTLNLPSSQLPCRPLEEGRGLGSRTLSCTINKVPCAQPV#\"\n",
    "\n",
    "print(aa_sequence == solution)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}