mutations_identification.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3cafc0e7",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Investigating an Existing Dataset\n",
    "# Define a 'dna_comparison' function that takes two arguments (the wildtype and mutated sequences as strings)\n",
    "def dna_comparison(wild_type, mut_seq):    \n",
    "    # Check if the two sequences are the same size\n",
    "        if len(wild_type) != len(mut_seq):\n",
    "            print(\"error, sequences of different lengths\")\n",
    "            return 'transitions =0, transversions = 0'\n",
    "\n",
    "    # Using a 'for' loop, check each sequence for non-DNA characters\n",
    "        dna_list = ['A','T','G','C']\n",
    "        for i in wild_type:\n",
    "            if i not in dna_list:\n",
    "                print (\"wild type is not a dna\")\n",
    "                return 'transitions =0, transversions = 0'\n",
    "        for i in mut_seq:\n",
    "            if i not in dna_list:\n",
    "                print (\"mut seq is not a dna\")\n",
    "                return 'transitions =0, transversions = 0'\n",
    "    # Create two variables to store the number of transitions and transversions\n",
    "        transitions = 0\n",
    "        transversions = 0\n",
    "        purines = ['A','G']\n",
    "        pyrimidines = ['T','C']\n",
    "    # Write a 'for' loop with a loop variable that iterates from 0 to the length of the DNA sequences\n",
    "        for pos in range(0, len(wild_type)):\n",
    "            if (wild_type[pos] in purines):\n",
    "                if (mut_seq[pos] in purines and wild_type[pos] != mut_seq[pos]):\n",
    "                    transitions += 1\n",
    "                    \n",
    "                elif (mut_seq[pos] in pyrimidines):\n",
    "                    transversions += 1\n",
    "                    \n",
    "            if (wild_type[pos] in pyrimidines):\n",
    "                if (mut_seq[pos] in pyrimidines and wild_type[pos] != mut_seq[pos]):\n",
    "                    transitions += 1\n",
    "                   \n",
    "                elif mut_seq[pos] in purines:\n",
    "                    transversions += 1\n",
    "                   \n",
    "        return  transitions, transversions\n",
    "       \n",
    "    \n",
    "#-------------------------\n",
    "# load the contents of the wildtype DNA sequence file (wildtype.txt) into a variable\n",
    "wild_type = open(\"wildtype.txt\").read()\n",
    "# create variables to store the number of transitions and transversions\n",
    "transitions = 0\n",
    "transversions = 0\n",
    "\n",
    "# Create a list of all the mutation files using the 'glob' library\n",
    "import glob\n",
    "glob_list = glob.glob(\"mutation*.txt\")\n",
    "# Write a 'for' loop that iterates over each mutation file in this list\n",
    "for file in glob_list:\n",
    "    # load the mutated DNA sequence pointed at by the loop variable\n",
    "    mut_seq = open(file).read()\n",
    "    # Call the 'dna_comparison' function to find the mutation types between this and the wildtype\n",
    "    arr = [[dna_comparison(wild_type= wild_type, mut_seq= mut_seq)]]\n",
    "    \n",
    "    # Add to the total number of transitions and transversions\n",
    "    for i in arr:\n",
    "        for v in i:\n",
    "            transitions = transitions + v[0]\n",
    "            transversions = transversions + v[1]\n",
    "print(transitions, transversions )\n",
    "    \n",
    "                                        \n",
    "    \n",
    "#-------------------------\n",
    "# Define a 'protein_comparison' function that takes two arguments (the wildtype and mutated protein sequences as strings)\n",
    "def protein_comparison(wild_prot, mut_prot): \n",
    "    \n",
    "    # Create three variables to store the number of silent missense and nonsense mutations\n",
    "    silent = 0\n",
    "    missense = 0\n",
    "    nonsense = 0\n",
    "    \n",
    "    wild_type = open(\"wildtype.txt\").read()\n",
    "    for file in glob_list:\n",
    "        mut_seq = open(file).read()\n",
    "    \n",
    "    \n",
    "    # Using a 'for' loop, check each sequence for non-protein characters\n",
    "    for i in wild_prot:\n",
    "        if i not in \"ACDEFGHIKLMNPQRSTVWY\" :\n",
    "            print (\"wild type is not a protein sequence\")\n",
    "            return 'Zero mutations'\n",
    "    for i in mut_prot:\n",
    "        if i not in \"ACDEFGHIKLMNPQRSTVWY\" :\n",
    "            print (\"mutated protein is not a protein sequence\")\n",
    "            return 'Zero mutations'\n",
    "        \n",
    "    # compare the protein strings and decide on the type of mutation\n",
    "    if wild_prot == mut_prot and wild_type != mut_seq :\n",
    "            silent += 1\n",
    "\n",
    "    if  wild_prot != mut_prot and len(wild_prot) ==len(mut_prot):\n",
    "            missense +=1\n",
    "\n",
    "    if len(wild_prot) != len(mut_prot):\n",
    "            nonsense += 1\n",
    "            \n",
    "    # return the number of each type of mutations found\n",
    "    return silent, missense, nonsense\n",
    "\n",
    "    \n",
    "#-------------------------\n",
    "# create the protein string for the wildtype DNA sequence using the 'create_protein_string' function\n",
    "wildprotein = create_protein_string(wild_type)\n",
    "\n",
    "# create variables to store the number of silent, missense and nonsense mutations\n",
    "silent = 0\n",
    "missense = 0\n",
    "nonsense = 0\n",
    "# Write a 'for' loop that iterates over each mutation file in the mutated DNA file list used previously\n",
    "for file in glob_list:\n",
    "    # load the mutated DNA sequence pointed at by the loop variable\n",
    "    mut_seq = open(file).read() \n",
    "    # create and store the mutated protein sequence from this DNA sequence using 'create_protein_string' \n",
    "    mutatedprotein = create_protein_string(mut_seq)\n",
    "    #find the mutation type between this and the wildtype using the 'protein_comparison' function\n",
    "    protein_comparison(wildprotein, mutatedprotein)\n",
    "    # Add to the total number of silent, missense and nonsense mutations \n",
    "    arr = [[[protein_comparison(wildprotein, mutatedprotein)]]]\n",
    "    for i in arr:\n",
    "        for v in i:\n",
    "            for x in v:\n",
    "                silent = silent + x[0]\n",
    "                missense = missense + x[1]\n",
    "                nonsense = nonsense + x[2]\n",
    "print(silent, missense, nonsense)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b0476ab5",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Simulating Random SNP Mutations\n",
    "# Define a 'mutation_dna' function that takes three arguments (wildtype DNA sequence, index and mutation type)\n",
    "\n",
    "def mutation_dna(wild_seq, index, mut_type):\n",
    "    # Check all the characters in the string are DNA bases\n",
    "    dna_list = ['A', 'T', 'G', 'C']\n",
    "    for i in wild_seq:\n",
    "        if i not in dna_list:\n",
    "            print(\"wild type is not a dna\")\n",
    "            return \"\"\n",
    "    # Check if the index is out of range\n",
    "    if index >= len(wild_seq):\n",
    "        print(\"string index out of range\")\n",
    "        return \"\"\n",
    "    # Check a 0 or 1 has been given for the index type\n",
    "    if mut_type != 0 and mut_type != 1:\n",
    "        print(\"Incorrect entry, accepted values are 0 or 1\")\n",
    "        return \"\"\n",
    "\n",
    "    # find the DNA base at the requested index\n",
    "    base = wild_seq[index]\n",
    "    mut_seq = \"\"\n",
    "    # If the type of mutation requested is a transition, identify the base it will change to\n",
    "    if mut_type == 0:\n",
    "        if base == 'A':\n",
    "            base = base.replace('A','G')\n",
    "        elif base == 'G':\n",
    "            base = base.replace('G','A')\n",
    "        elif base == 'T':\n",
    "            base = base.replace('T','C')\n",
    "        elif base == 'C':\n",
    "            base = base.replace('C','T')\n",
    "\n",
    "    # If the type of mutation requested is a transversion, randomly decide which base it will change to (50% probability for each option)\n",
    "    import random\n",
    "    if mut_type == 1:\n",
    "        if base == 'G':\n",
    "             base = base.replace('G', random.choice(['C','T']))\n",
    "        elif base == 'A':\n",
    "            base = base.replace('A', random.choice(['C','T']))\n",
    "        elif base == 'C':\n",
    "            base = base.replace('C', random.choice(['A','G']))\n",
    "        elif base == 'T':\n",
    "            base = base.replace('T', random.choice(['A','G']))\n",
    "    # construct the new DNA string using the mutated base decided above\n",
    "    mut_seq = wild_seq[0:index]+ base + wild_seq[index+1:]\n",
    "     #return the new DNA string\n",
    "    return mut_seq\n",
    "\n",
    "# -------------------    \n",
    "# Define a 'generate_mutations' function that takes two arguments (wildtype DNA sequence and number of sequences to generate)\n",
    "def generate_mutations (wild_seq, seq_no):\n",
    "# Create an empty list to store the mutated strings\n",
    "    mut_str =[]\n",
    "\n",
    "# Write a 'for' loop that iterates from 0 to the requested number of mutations\n",
    "    import random\n",
    "    for i in range(0, seq_no):\n",
    "# randomly generate the index position for the mutation\n",
    "        index = random.randrange(0,len(wild_seq))\n",
    "# decide if it should be a transition or transversion using your frequency from Task 1\n",
    "        if random.random() < 0.7:\n",
    "            mut_type = 0\n",
    "        else:\n",
    "            mut_type = 1\n",
    "# Use this info to call your mutation_dna function to create the mutated sequence\n",
    "        mutation_dna(wild_seq = wild_seq, index = index,  mut_type= mut_type)\n",
    "# Add this to the list\n",
    "        mut_str += [mutation_dna(wild_seq = wild_seq, index = index,  mut_type= mut_type)]\n",
    "# return the list of mutated DNA strings\n",
    "    return mut_str\n",
    "# -------------------    \n",
    "# generate 500 mutated DNA sequences\n",
    "list = generate_mutations(open(\"wildtype.txt\").read(), 500)\n",
    "# redo Task 1 analysis on this population\n",
    "transitions = 0\n",
    "transversions = 0\n",
    "for file in list:\n",
    "    arr = [[dna_comparison(open(\"wildtype.txt\").read(), file)]]\n",
    "   \n",
    "    # Add to the total number of transitions and transversions\n",
    "    for i in arr:\n",
    "        for v in i:\n",
    "            transitions = transitions + v[0]\n",
    "            transversions = transversions + v[1]\n",
    "print(transitions, transversions)\n",
    "\n",
    "#-----------------------------------\n",
    "silent = 0\n",
    "missense = 0\n",
    "nonsense = 0\n",
    "\n",
    "for file in list:\n",
    "    \n",
    "    wildprotein = create_protein_string(open(\"wildtype.txt\").read())\n",
    "    mutatedprotein = create_protein_string(file)\n",
    "    \n",
    "    protein_comparison(wildprotein, mutatedprotein)\n",
    "    \n",
    "    arr = [[[protein_comparison(wildprotein, mutatedprotein)]]]\n",
    "    for i in arr:\n",
    "        for v in i:\n",
    "            for x in v:\n",
    "                silent = silent + x[0]\n",
    "                missense = missense + x[1]\n",
    "                nonsense = nonsense + x[2]\n",
    "print(silent, missense, nonsense)\n",
    "\n",
    "   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4cfbdbed",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}