Collections - Exercises.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Lab: Collections\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Learning Objectives**\n",
    "* To use *lists*, *tuples* or *dictionaries* to solve problemsas, as appropriate.\n",
    "* To become familiar with the notion of 'importing' code into an existing program for added functionality.\n",
    "\n",
    "**General notes about the exercises**\n",
    "* You should attempt the exercises below by using *only* the Python constructs that you learnt up to the end of topic **Collections**.\n",
    "* Spend a few minutes before you write code, to think about how to structure your proposed solution.\n",
    "* Add comments to your code.\n",
    "* Make your code neat, by using indentation and parentheses (where appropriate).\n",
    "* Give meaningful names to functions and variables.\n",
    "* You may find it easier to do some of these exercises directly in the notebook. Feel free to insert text with your comments or write your notes as you proceed. The Jupyter Notebook is \"yours for keeps\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1 - List basics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create an empty list [] called ```myList```.\n",
    "* Add the following words using the ``` .append() ``` method:\n",
    "    * \"the\"\n",
    "    * \"quick\"\n",
    "    * \"brown\"\n",
    "    * \"fox\"\n",
    "    * \"jumps\"\n",
    "    * \"over\"\n",
    "* Print the list to check all words are there.\n",
    "* Create another list called ```barker``` containing the words \"the\", \"lazy\", \"dog\".\n",
    "* Use the ``` .extend() ``` method to add the ```barker``` list at the end of ```myList```.\n",
    "* Print the result.\n",
    "* Print the first word of the list.\n",
    "* Print the word \"fox\" by indexing.\n",
    "* Print the length of the list (use the method ```len()```). \n",
    "* Print the last word of the list using ```myList[len(myList) - 1]```.\n",
    "* Print the last word of the list using ```myList[-1]```.\n",
    "* Print the first three words and the last three words.\n",
    "* Print the sublist [\"brown\", \"fox\"].\n",
    "* Use the ```.remove()``` method to delete \"the\".\n",
    "    * use the ```in``` operator to check if \"the\" is still in the list;\n",
    "    * inspect the list; call ```.remove()``` again.\n",
    "* Use ```.index('lazy')``` to find the index of the word \"lazy\".\n",
    "    * Check the result and store it in variable **i**.\n",
    "* Use ```del myList[i]``` to delete the word \"lazy\".\n",
    "* Use ```.sort()``` to sort the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2 - List comprehensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use the function ```range() ``` to create a list of numbers from **0** till **10**. Assign it to variable ```nums```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use a comprehension to create a list of the treble of each number in variable ```nums```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use your favourite editor to write a program that asks a user for a number between **1** and **10** and prints a list with the multiplication table for that number."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a comprehension to create the list ```[\"#\", \"##\", \"###\",...]``` (up to 10 hashes)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a list comprehension to compute the squares of all the numbers in ```nums```. Call this ```squares```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A trickier exercise: create a list that for each **x** in ```nums``` and **y** in ```squares``` that contains the sentence \"The square of *x* is *y*\".\n",
    "\n",
    "**Hint**: Try printing ```zip(nums, squares)```. Then, ```[ ... for (x,y) in zip(nums, squares)]```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3 - Reading frames"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a program that takes a string of nucleotides as input and outputs it in all the possible reading frames (without translating it):\n",
    "* use ```list()``` to convert the input string to a list;\n",
    "* index as appropriate to obtain the foward reading frames;\n",
    "* use the ```.reverse()``` method to reverse the list;\n",
    "* index as appropriate for the reverse reading frames;\n",
    "* use ``` ''.join(some_list)``` to convert the lists back to strings for printing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4 - Dictionaries: the basics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Create an empty dictionary {} called ```stop```.\n",
    "* Add the stop codons and their names, using the codon as the key:\n",
    "    * \"TAG\": \"amber\"\n",
    "    * \"TAA\": \"ochre\"\n",
    "    * \"TGA\": \"opal\"\n",
    "* Print the dictionary and notice the order of the elements.\n",
    "* Print out the list of ```.keys()```.\n",
    "* Print the list of ```.values()```.\n",
    "* Print the list of ```.items()```.\n",
    "* Use ```.has_key()``` to find out if \"ATG\" is a stop codon.\n",
    "* Use ```.pop() ``` to delete key \"TAA\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cut and paste the ```stop``` dictionary into an editor. Write a program that asks the user for a nucleotide sequence, checks the last three letters and prints \"Stop codon:\" followed by the name of the stop codon if indeed there is one, or by \"none\" otherwise. Use the ```.get()``` method of Python dictionaries."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5 - With complements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a program that takes a string of nucleotides as input and outputs its complement.\n",
    "* Use ```list()``` to convert the input string to a list.\n",
    "* Build a dictionary with the complement of each nucleotide.\n",
    "* Use this dictionary in a list comprehension to generate the list of complements.\n",
    "* Use ``` ''.join(complement_list) ``` to turn the resulting list into a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6 - Counting bases"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a program that counts the percentage of each nucleotide in a DNA sequence. Your program should:\n",
    "* ask the user for a sequence;\n",
    "* create a dictionary such as for instance\n",
    "    ``` {‘A': 1, ‘C': 4, ‘T': 2, ‘G': 2}```\n",
    "    (use the ```str.count``` method);\n",
    "* obtain the total length of the string using ```len()```;\n",
    "* print out a nice table with the relative frequency of each nucleotide.\n",
    "\n",
    "For instance if the input is \"AACG\" your program should output:\n",
    "```\n",
    "A: 0.5\n",
    "C: 0.25\n",
    "T: 0\n",
    "G: 0.25\n",
    "\n",
    "```\n",
    "Once you are satisfied that your program works, add the following line at the top:\n",
    "```\n",
    "from hivsequence import *\n",
    "```\n",
    "This assumes that the **hivsequence.py** file is in the same directory as your program; it will import a nucleotide sequence from HIV as a string called ```hivSeq```. Modify your program so that it processes that string, instead of keyboard input and see what you get.\n",
    "\n",
    "(This was adapted from [Kasper Munch](https://github.com/kaspermunch).)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7 - Going bananas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a dictionary called ```prices``` and add the following values:\n",
    "```\n",
    "\"banana\": 4,\n",
    "\"apple\": 2,\n",
    "\"orange\": 1.5,\n",
    "\"pear\": 3\n",
    "```\n",
    "\n",
    "Extract the list of prices and use ```sum()``` on that list to get the total price."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then create another dictionary called ```stock``` that lists the number of items for each fruit, for example:\n",
    "```\n",
    "\"banana\": 5,\n",
    "\"apple\": 12,\n",
    "\"orange\": 6,\n",
    "\"pear\": 2\n",
    "```\n",
    "Compute the money you would make by selling all the ```stock``` at the given ```price```.\n",
    "\n",
    "**Hint**: Start by obtaining the list of keys. Then use a list comprehension to multiply the stock by the price for each fruit.\n",
    "\n",
    "(This was adapted from [Erle Robotics](https://erlerobotics.gitbooks.io/erle-robotics-learning-python-gitbook-free/content/lists/exercises_list_and_dictionaries.html).)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 8 - Lord of the rings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists and dictionaries can be listed in arbitary ways. It is very common to find a dictionary with some keys corresponding to lists. Try to do the following exercise (from [Erle Robotics](https://erlerobotics.gitbooks.io/erle-robotics-learning-python-gitbook-free/content/lists/exercises_list_and_dictionaries.html)). Given the following dictionary:\n",
    "```\n",
    "inventory = {\n",
    "    'gold' : 500,\n",
    "    'pouch' : ['flint', 'twine', 'gemstone'],\n",
    "    'backpack' : ['xylophone', 'dagger', 'bedroll', 'bread loaf']\n",
    "}\n",
    "```\n",
    "* Add a key to an inventory called 'pocket'.\n",
    "* Set the value of 'pocket' to be a list consisting of the strings 'seashell', 'strange berry', and 'lint'.\n",
    "* Use the method ```.sort()``` the order items in the list stored under the 'backpack' key.\n",
    "* Then use ```.remove('dagger')``` to remove 'dagger' from the list of items stored under the 'backpack' key.\n",
    "* Add 50 to the number stored under the 'gold' key."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9 - Standard genetic code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a dictionary called ```sgc```. Add at least the three keys \"Ala\", \"Leu\", \"Arg\". Each key should correspond to a list of all codons for that aminoacid (refer to the [Genetic code](http://en.wikipedia.org/wiki/Genetic_code) entry on Wikipedia).\n",
    "\n",
    "Print the dictionary. Use the ```in``` list operator to check if \"GTT\" codes for Alanine and if \"CTG\" codes for Leucine."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}