trail1_NPS.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# - **Physics**     \n",
    "             #for bold use **  **"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math as mt              #scalar\n",
    "\n",
    "import numpy as np             # vector, numerical calculation,vector, matrix\n",
    "\n",
    "import scipy as sp            #scientific package calculus/ode/pde/stats/fft\n",
    "\n",
    "import pandas as pd            # data wrangling, exploratory data analysis (eda) .e.g csv read/write\n",
    "\n",
    "import matplotlib.pyplot as plt  # plotting\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-4-886082c99868>, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-4-886082c99868>\"\u001b[1;36m, line \u001b[1;32m2\u001b[0m\n\u001b[1;33m    +, -, /, *, **, =,\u001b[0m\n\u001b[1;37m     ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "# comment\n",
    "+, -, /, *, **, =, "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-  **Specific brackets:**\n",
    "- **Container:**\n",
    " -  **list [  ]**, **dict {  }**, **tuple(  )**    \n",
    "    \n",
    "    **print( )**"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "- list: List is built in data structure in python\n",
    "      :can edit\n",
    "      :can include integer,string,complex,boolen   \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "L=[]\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 45, 'python', 'physics']\n"
     ]
    }
   ],
   "source": [
    "L=[1,2,3,45,'python','physics']\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Indexing of list.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 'physics', 1)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L[0], L[-1],L[-6]                 # 0 stand for first element and -1 stand for last element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'python'"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L[-2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('physics', 3, 2)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L[-1],L[-4],L[-5]   # reverse indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 45, 'python', 'physics', 19, 19]"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L.append(19)   #add 19 at last\n",
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 45, 'python', 'physics', 19, 19, [19, 6]]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L.append([19,6])\n",
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-40-3520440cd37e>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0msum\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mL\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mmax\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mL\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mmin\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mL\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "sum(L),max(L),min(L)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5, 7, 9, 9.5, 35]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A=[1,3,5,7,9,9.5,35]\n",
    "A\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(35, 1, 7, 69.5)"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max(A), min(A),len(A),sum(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.pop(-3)         # removing 4th term "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5, 9.5, 35]"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "A.remove(35)  #To remove specific element form list\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5, 9.5]"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 100, 3, 5, 9.5]"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.insert(1,100)\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "A.insert(3,20)  # insert element at specific index ,add 20 at 4th place"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 100, 3, 20, 5, 9.5]"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23.083333333333332"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "np.mean(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "34.94807656446282"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.std(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(int, str, int)"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(L[0]),type(L[4]),type(L[-3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 45, 'python', 'physics', 19, 19, [19, 6], True, 1j, 'eye']"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L.append(True)\n",
    "L.append(1j)   # add complex no\n",
    "L.append('eye')\n",
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(int, str, bool, complex, str)"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(L[0]),type(L[4]),type(L[-3]),type(L[-2]),type(L[-1])   #type of elements of a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "LL = [[1,2.0,3],[9,4,1.0],[5,8,6]]         ## a list of list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[9, 4, 1.0]"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " LL[1]                                      # To find list inside a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LL[0][1]                                    #find list inside a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(LL[0][1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### - **use for**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = [x for x in range(10)]             #List comprehension\n",
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 4, 6, 8]"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = [x for x in range(0,10,2)]\n",
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199]\n"
     ]
    }
   ],
   "source": [
    "L = [x for x in range(200)]   # range(star,end,step) ## range(0,200,1) is same\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100, 105, 110, 115, 120, 125, 130, 135, 140, 145, 150, 155, 160, 165, 170, 175, 180, 185, 190, 195]\n"
     ]
    }
   ],
   "source": [
    "L = [x for x in range(200) if x%5==0]  # output with no ,having remender  zero on divided by 5\n",
    "print(L)   #L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "33"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import random as rn\n",
    "R= rn.randint(0,100)          # choose any no between 0 to 100\n",
    "R"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1j'"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S = rn.choice(['A','T','G','C','6','1j'])  # choose any item between of given list\n",
    "S"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[15, 70, 47, 18, 17, 63, 35, 2, 97, 7, 44, 88, 0, 22, 66, 3, 71, 26, 27, 86, 92, 0, 91, 20, 94, 74, 3, 67, 2, 86, 97, 48, 95, 29, 42, 25, 35, 88, 78, 21, 73, 39, 20, 97, 28, 51, 6, 86, 37, 39, 88, 35, 14, 60, 100, 15, 10, 2, 26, 58, 89, 14, 84, 89, 86, 13, 99, 17, 42, 45, 94, 85, 94, 40, 89, 98, 37, 43, 18, 97, 43, 35, 3, 48, 90, 83, 24, 42, 8, 7, 95, 47, 81, 93, 33, 42, 44, 36, 30, 71, 97, 70, 32, 80, 61, 11, 84, 51, 98, 10, 66, 69, 1, 48, 44, 95, 11, 18, 43, 34, 52, 52, 24, 36, 94, 76, 56, 0, 21, 98, 10, 84, 25, 65, 21, 82, 19, 83, 90, 81, 24, 45, 90, 70, 79, 85, 71, 67, 89, 7]\n"
     ]
    }
   ],
   "source": [
    "import random as rn\n",
    "R = [rn.randint(0,100) for k in range(150)]           # generate 150 nos betn 0 to 100\n",
    "print(R)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Counter({97: 5, 35: 4, 86: 4, 94: 4, 42: 4, 89: 4, 70: 3, 18: 3, 2: 3, 7: 3, 44: 3, 88: 3, 0: 3, 3: 3, 71: 3, 48: 3, 95: 3, 21: 3, 10: 3, 84: 3, 98: 3, 43: 3, 90: 3, 24: 3, 15: 2, 47: 2, 17: 2, 66: 2, 26: 2, 20: 2, 67: 2, 25: 2, 39: 2, 51: 2, 37: 2, 14: 2, 45: 2, 85: 2, 83: 2, 81: 2, 36: 2, 11: 2, 52: 2, 63: 1, 22: 1, 27: 1, 92: 1, 91: 1, 74: 1, 29: 1, 78: 1, 73: 1, 28: 1, 6: 1, 60: 1, 100: 1, 58: 1, 13: 1, 99: 1, 40: 1, 8: 1, 93: 1, 33: 1, 30: 1, 32: 1, 80: 1, 61: 1, 69: 1, 1: 1, 34: 1, 76: 1, 56: 1, 65: 1, 82: 1, 19: 1, 79: 1})\n"
     ]
    }
   ],
   "source": [
    "import collections \n",
    "#High Performance Counting   # counting how many and which are repeated numbers\n",
    "C = collections.Counter(R)\n",
    "print(C)    #C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['G', 'C', 'A', 'C', 'A', 'C', 'G', 'G', 'G', 'A', 'A', 'T', 'C', 'A', 'C', 'C', 'A', 'G', 'G', 'A', 'A', 'A', 'A', 'C', 'T', 'G', 'G', 'C', 'T', 'C', 'T', 'T', 'C', 'C', 'A', 'T', 'G', 'A', 'C', 'C', 'T', 'A', 'A', 'T', 'A', 'T', 'A', 'T', 'T', 'C']\n"
     ]
    }
   ],
   "source": [
    "R = [rn.choice(['A','T','G','C']) for i in range(50)]  # we can use any variable  i or x \n",
    "print(R)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GCACACGGGAATCACCAGGAAAACTGGCTCTTCCATGACCTAATATATTC\n"
     ]
    }
   ],
   "source": [
    "DNA = ''.join(R)   # mathiko list ko sabai element lai sangai lekhne\n",
    "print(DNA)         # or DNA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(16, 5, 1, 1)"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "DNA.count('A'), DNA.count('AT'), DNA.count('ATG'),DNA.count('ATC')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mini  Assignment:\n",
    "Create a DNA string of 10,000 characters and count the following: A,T,G,C,all combination of two charaters, all combinations of three characters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ACGTAGTTTAGGCCGTAATAGTCGGCGTACGCAGACCAACTGCTGAGAGCCAGACCTTGGTGAATGATCAGAGTCGGTCGTCTTTGAAGGCTTAATCCTAATAAGTCGACATCGGCTTGCTAACGTTGGAATACCAAACAGTTGCGGAGAGATCTCGAGTTGTAAGATGTTTTCCAGCGCGTCCTCACGAACATGTATAAAAGGCGACGCCGATAGTGACAAGACCCGCCTATACATCCGATCGGACCTCCGGCAGCAAGCAGCATCTGTTAAATGGCAGAGCTGGCCAGTAATAGATGGCCCCATACTGCTAGCTTCTCCACTATGTAAAATAGTGCGTCTATGTTACCGACATTTCCGTAAATGGAAAACGCTGTGGGTCTATCCACCATCTATTTGGATACGTCAGGTAATCGTGCAGCTATTGTATAATTTTGAAGACACCGCAGCGAGACGGCTATGTAGTTAATAATGCAAAGCCAAAGCACCTCTGAATGCTAGATATCCTGTCTAAGCGATAGTCTAATAGACACATAGATTCAGGCCGCCAATCCGCGAGCCTAGTTCACGCAAAGGGAAATATCGCTATGCTTAGAAGTTACATTGGTATCGCGGGGCCGGCGCGATAAATTAGGAGCTTAGCTTACAGATGACGCCGGTGTGATTCACCATCTTTCCCTACTTCTGGTCTAATTGCGTGTCTCGTAGGGCTAATGGGGCAGGGCGTCCTGTAGACGAGAACGTAGTCGCTGGCACTACCGACCCCATACCTCATTCTTCCTGTAGGTGTATATTAAAGCATCGCGATAGCGAGGGGATGCGCGGACAGTCAAACTGATCTCGTTAAGGTGAACGGACGACTAGCTTATGACGAATGAACCCCACGATGAGAGAGGCTACTCGTATAGTTTTGCTGCATCTTGAAAATGAAATCCCAATGCAGTATAGACAGTCACCGGTATGTAGCTTTCGGTATAATAGAGCGCTACGGCTTGGGGTACCCGGTAGTATTGGACCTCCGATGACTGGGTAAGCGGCACGGATCACGATATATCTGCTTGTGAGGAACAACCCAGCGCCACGCCATCCTCCAAAGCGCCTGTACGTGCTGCTCCCGTTGAGCCAGGGGTCAGATCATGACGCTTAAAGCTGTATTGCCGACGGTCTTTGACCATCAGCGTGGGGGCTCACAAACCTTCCACTTGACGGGATTTTGAAGACCTTTTAAACTAATGCTGGTATGCTGGCTTTTTCAGGCAACGAGCATTCTCGAAGGGCCCCATGTGCACACGACCCGCCCCAGGGTGGAAGTTGAGAACGCCGAATATGGCCTCACCTGCCAGAAAATGGCGTATGACTTCCATTATATCTGAACATTTTACGAGGCGTGAAGGTAGATTAGTATGGATCTGCCCCGTTCCTAATGGCTCCGCTGGCTCCTCTCTCGAGAACAATAGTGTCCTTTCAGACGTGTTGCTGCAACTGTGGGATAGTAACACGGTAGATTCGGGTGCCAGATGTTCGGGAAGTGTGAACAAATGATTGCGACATTCCACAGGTTACTTACATACTCCGTACTGGTTAATGAGACTGTTGACACTTCGCCGAGACCCTTCGGGCCAACGGACCGTTTCGACCATGAGGCGTAGACAGGGCTTTCTAACGGTGTCTAGAACCAAAGTTACTTTTCCAGTAAGAAGATCCGCAGGGATATTCTTCGGACACGGCGATATTTCCATATCGGTGCCATTGTGCGGACCTCCGAAAAATAACGTAAACGGTACCAGGTCGAAGAGGAAAGTAGTCACGAAGCTGGTCATAGCCCGGATAGTGGCCGGTGATCCAACAGCCAAGTGCGCTCTGATTCCGGACGACTACTATTAATTGTAATGCCAATTCCTTAAATGCCGTTATCCGGACGAGTATCAGGGAGTGTAGATTCAGAGGATAGGGCCATAGATGGCTCTTGCCTCGTACAACAGCAATGCGCGCTGCAATCTGTGACGGATGACGTGCATGACTGACTGTAAGACGTGTTGCCTCGAATTCTCTACAGTCATGTGACAATGCTCTCACTACAGCCCCAGCGAGTTCGATGGGATGGCACTTCACAAGGCGCGACCAGGTTAGAACCGCTAAATATCTGATCGGGAGTTATAGTCTTAATGTCCTATCAGCGAGGGCGTACGATTTACGTATGGTTCACGCCTCACATGCGTCTTCGTGGGGCTGGTGCTATGTAGAATCCTGAAGCACTTTGGCCGTAAACTCAGGACTGGTGAGGTGTTTCTTACGCAGGGTCTACTATCAACCTGCTCTATCAGATTGGTTACATCAATATGAAGCTGGTGGGAATAAGCGAGGATCTTGGAAAGCTGGTGGTAAATATAGGAGCCGACACCAATACTGATAAGCGAAGTCTCCTCGGCAAGTAGTTTCGCACTCCTTCGCTTACTTATCCAGGGATTCTGTATGATGCCGCCTACACCGTATGTGTACTCTCTTCCGCAGAGCTACCCGCTGGCGAGTCCCGCAGAAAACGATGAGATATCGTGTTGGTACCCTCACGTAAATTGTTGCCATATGCATAATTTGCTGCGCATCTTACTCACCGAACGTAAAGCATGACGCCGCTCGATACCCCAGGCGTTTGTAATTCCTATCGGCGAAGGCGCCTAAGTAGTGCTGATGTCTATGACATACGTTACATATATCTACGAATATACTTTGAGCACCCGGACTAGATCGACCTGCTTCGGGACGCCTAACCTGACTTTTTGTAGACTGCATTTGTTATCGTTTAACAATATGGCGTGCTATCACGGACACAACCAATATACACTAACGATGGTAGTTAGAGGTGAGCTACGAGACCTCAAGTTGGCCCCCTCCTTAGAGCCATTTGAAGGTCTGGCCTCGACAAATCCTGAGGGTCTACGCCTAAGTTTAGTTGGAACATGTGCTTATCTAACTTTGTTCGAATTGTAGCCTGGCTAACTCAATACAATGAATTCGCGGAGCTATCGGGGGTTAAGTCGAAGCCTTAGCAAACATGGGGATTAGGGGATCTGATATTGGGAGCTTTTGCCGCTGCGCCGTCACTCAAAAGTTCAGTTGCAACACTTACGCCCCTTCCTGCTGTCGCGTGACTAACCTGGGCTCCCGCAGGGGGGTGAGAGGGAGACTTTAGTTCCAACTATCCCTTACCTATAAACTAATGCGTGATTTTTCTTGATTCCGCCAGTTTCAACCACGACCGCACCTCACGCTCTTTGCGCTTAGGTATACCGAGCTTGGAGCGACGTTCTCGAGAATTCCATTCACGTCGCGAAACCTGAAGGCCTTGAGTACCACAATGCAACATATATTAGTTACCGAAAGTCCTATTGCTGTCTTCACCTTGAAATCCCTTAGACACGCGCTGCAACCTAGTATGAAACCTCCGTTTTTCGCTCGGCATATTGGGTGCCGATAAGTGTTCAGGTCGATCGTCGGTATCCATTAACGAGTCGAACGGTATTCCTATTGCACGGGCTTTTATTAATCGATACTTTACCAGAGGGGAGCGTACAATATGGCCCCCGGTTATGAGAGGTAAGATTTGAGAGCTTAGTGAATTCATTATGACTAGCGGACAACTGTAACACGCCAACACGTCCAGGGATCTGGCATACAGAGCAATGCCAGAATACGCGTTAGACCCTAAGTCGCGCTACCATTCTGCTAAGAGGACTAGCGCAACCACTTGTGCATTAGGAGCTGGGATGGTTTCCCCCAGCCCATTTCACCCATACTCGGCGTGAACCATCAGCAGGCATGTCCATAGTGTCTTCATACTAACAGACGGGGCTCGGCATACTGATTTACGCCTCTAGATTGTGCGTTCTTAATCATTCATTAGGGCATGTTGCTGACGCATATTAAGACGTTAGACAGTGATGTCATATCATGGAAGTTGTCTTCAATCTTCAGTTATTTTTTCATCCGGTATACGAGGTGCTATTTCAACAACCGGGGGTTTGCTTATCGACGATCGTCCCTCCTATCTATACCCGTCAAGGTCCGACGGAGCGCGAGAGGTACTGAAGCTGTAACCTCACCGGGAGCAATACATTCACAAGGATCCGATCAGCGGGGCATTCAGATAGCATGACCCTTACTACCCACGTCTGTTGACTCCAATACGACCCGATTTGAGTAAGGTGGGTGCGCAGGTAGCGCCGCTGTAGTTTACATTACGTCTAATACGTCGTGAAGCCGCTCTGGTGTACTGGTGTCTGTCACGCTTAGCGGCGTCCGAGACGGAGTGACGAGGGAATCACAATATCCTATTAAAAACCCTTTGACAAGGGCCACTCGTACGACGTGCCTATTAGGGAACATAATGGTTCCTAAATGGTAGATCGCCTCTGAAGTCGACGACTATGATTAGTGCAAGGTCGCCGTAACCGCTGTACTCAGAGAGCTTTGAACGGCACATTTAGAATTACATTACATCGAGAGGAGCTTTGTACTCGCTCCGATCGTTTTGGCGAGACCTAATGACCTACGCCTTGTGCGTGCGTCTAGATGAGGTGCCGGTTGGGAGCTGTATATTTTACTTTTCACGCTTTCATTATAAGATATAGGGGTCGTTGATGCCAGGTTAGCAGTGAACATTCTTGTGCCTAAACTATTCATGGATGGTGTACGGTGAGCGATGTCACCTATGTCTCTAGTGCTCTGACGCATCAGCAACCTGAGATCGGATTACTAAAGGCTAGGTCTACGGTTGGATGCCGTGTACTCAGAGCTAACAAACTCATACTCCCGACCTCCATTATGTGATTTAAATTTCATCACAGGCACCACCCGCCCAGAGATTAGAACGGAGCATCCAGATGCGGGCCACCGAACCCCGTATTTAGTGGCTCTGCTGCAACTGCCCCTTCAGACAGGTATCAGCGCTGAGGTAGGGGGCATGGACTCTATCGGTGGGAACGATCTAATGAGGCAAGATCACCCCGCAAGCTGCTGGGATCGGGATTGGAAGGTCGGGTGGGCACTAAAGACTGAGGCCTACCGAAACACATCATTTAAGTCGATACTTGCCCCATAACAAGCCAAAGACGGACGCCTCCATAGCCTCTAGGTATCAGATCCCTTGTCGGTGTGCTCCGTTCGCCTGAGCGGTGATCCCTTTTGAAACGGCCCCGAAAGTTCTCGTTTCATCCAATCTAAGCTGACTAACCAAAAAGCAAATGCGTCTGCCTAGTCACCCTGTTAGAATTAAGCAAAGCGGGCATTGACGGCGGACCTTACGGTGCTCTCGATAGTATATGTGGTTTCTTACTTGCGCTTGAGACCCTGTACTCCGGCCAGGTCTCGGCGCGGTGCACCAATAGTGACAGCGCCTACCATTCGACAAGAGATTGCACGCTCGAAACTTATGTGACAATTATACGCCTAAAGGATGAGGAGTCGTGGATGGTAGAACTAGCCTCATCTGGTCATTCTAGCCCTTGGTATCTGACCGCGACATCTTTATTATATGACGCTAGAAGCCATCCAGACCAACGGGACCTGCATCTTCCGGCTAAATCAATACTACTAGCCCCGTATGCCCCTCCTTGGAACCCAGCTCTATGAGAGACGGGCAACTTCAGGGCGTTACGTGCGAGGCAGTGAGGTGTTTGGAGCCCAACCAAGGACACACTACTGGCTCAACATCCAATTCTGAAAGTCCGAACGGTACAACTACCTCGGGCATCGATGCCTTTGTGAGTCCCTCGCAAGATACCATCACACATTGAGGACCGATACGCAGGTTTTAGGTAATCTTGCTCATTGGTCAGATAAGTCGCCGTGGTGGTTATCTCATGGCTAGCATGACATACGGACGCGAAAGCGCCTCCCGTCATACTAGCGGGTCTCGCTGGGCGTTCAGCTGTGTCTAGTTCCATGGCACGTGTCCTGAACGACCTTTAGCCTAAAGTTTGTCAAATCAGCTCGCGTATGTGGTGTGCTCAACAAATAACCGGTGTCATCATGCGGCTGTAAACCGTCCCCTTATACTGTGTAACGGCAAGGTTGCACGGTCACGCTACGAGGCTGAGGATATTATGAGGGTTCACTGTTTTGGGTAACGATTGAGTCACGGATCTCTGTGTTTCCAGCCTCGCTTAAAGGCCCGAAATAGTCGATTGGTGTACCTGGTTTACCGTAATCTAACTCTCGCATTGGCTGGGATACGATGTTAACACCGACGGGGCCGTTTACGACCAAGAGTACTATCCGGTGCAGCTAGTCATCAGAAGAGCCCCAGCTCTCCGATTTTTGGAGCCACCCGGTAAAAGTGTTGTGGAAACGAACTACACATCGAGCGAATGAAGGTACCGACAGCTCCCTACTCCGCCTTTCACGCACATGTTGGAGGCCGCATTCTTAGCTCTAGGGCCCAGTCCAAATAGAAGTGGGATGCGGAGATCTGTCGTATGAACTGAACGGTGCAGCCCTGGCACCTGGGCCGGGTGTAGGATAGCATCATTAATTCATTCCCAGTTCCAGGTAGAAATGAACGCAGCCTTCTTCTATGACAGATGAGGCGTACAGAAAGTCGCACGTCAAAAGAATATCAAGGATTATTACAACCCCCGTAGGCTCCGTTTCTTTACAAACGCCGGTCCTAGATGGTATCCTATTCAAAGGTGAACTCCATTTACTGCTAGCACTCGTCCTCATCAAGAAACGATAAACTTACTGCTTGTATTTCGCAAAATGCTTTACCTGCCGAATCTCTCGTGGCAAGGGAAGAGGAGAGTTCCAGAATGTTAGCGACTAATTAGTCGCCGCAGACACGATGGTGTTCAGCGGACCTAGGCTGGATAGTGGGGGTGATGCTACTACTATGCCAACCGGTCCTTGGGCGAGCATTTCAGTCCGCTGGACGGCCTCGCCGCCGGGCCCGGCCGCCAGCATATGCCTTGACCACTTTAATGGGCCGAACTGGTCTCTCATTAATCGCTGACTCACGGGCTTTGTAGCAGTTCAACAGTGCCTTCTCTCCGAGGCCGAGATACAAGCTGGCGCATGTGCCATCATTGCGTTTTGAGACGAGTGGTTTGGAACAAAAGGGTTAGACTCGATCCCCGGAAGATCAATGTTCTCGATCACATTGTTACGCTCGAGGACTCAGTGCGCCTGATGTTGGATGCTTTTTATTGCTTCGTTGTACCTCAGCCAGCAAGTATGCCCGGAGGGGGGGTCGCTGGATTACCGCGGCGCTGTCGGTAAACGAGCGCGGGTTTAAGCGATTGTCAACCACATCAGATCCGAAGCTGGCTGAGGCCCCGGCTATGCGGAACCCCGTAAGCTGCGGATGAACCTTGAATGGAGGATGAGTTCGGTGCGCAAAGAACAATCGACCGCACAAGGTGCTCTCCTGAAAGTCGGTAGCACCGCATTCTGGGCAATATGCGATGGTCGTGCGTAGACTCCACGGGATTGCAATCCGTGTCGGAGTTCCGAAGAGCGGCGTTCGGTAGGCGTCACGCTGTATAGGATTCGAATCAAGGCTGTTGAAGGACGCCGTGTTTCAACTGTAATCCCTGTATGGCTATAACCACAGATACGAGGATAGGTATTGGAATTCCGCCGGACGGCTTAACTGTTGGCATCTGGAATTACCGTTGAACAAATCCGATGCAGTGTACAATCCAATGCCATAACATGGCTATCCACGCACCAAGACCGTCTGCTTAGGAATTTGCGAATAAGGACTACGGACCTGTTATCCAGGTCACCCGGCCCGGTGGAAAGAAATGCCTCAATTCGAACCGTAGCTTACAACGTAGATTATTAAGAATCGAACCCTGACCCCTTCGTGTTCAGGCGAATGCATTAGCCGGTCCAACGAGGGTAGCAAGAGCAGGAGCTTGTGGTCATAAACAGTAATTGTCAAAGTGTGACCTGCTGCCGTCGTCTCGGCGACAAGGACGCCACGAGTTTCCAGTGGGTGTGACTGAGCTCTTTAAATACCCCTTTAGCCCGACATACGGGATTGAAGACGGGCGTGGCGGACGGATGTTGTTGTAATAGCGCCCGATGATGCAACCATCGTAGCTTCCCTAGAGTGGGACGTGGTTCTTTACATAGCGCACCTTTAAGGCCGCGGGCAAAGTATCGCTAGCTCGTCACTTACAAGCTTCTTGTTCACAGCACAATTCCGCGATTGCACAGGTAAGTCCCCTCTCATAATGGTCTCTAGCTTTGCCACATTAACATTACGGAAGTGTCGTCGTGATGATCCAACAATAAGCAGAACTCCATATATCCTGCTGGGCGGCAGTGTAAGTTCCCCGGGAAAAGTTCCGGCAAAATCTCTATTATGCCCATCGCGTTTGTCATCACGCGTACAGTGCATTCGCATACGATGTCACAGTGAGACAGCGTGTAGATCCGCTCTTAATATAATCGTTCCAGCATCCGCGGATGTATAGTTTTAGCTACAACGATGTTAAGTTGACGTGCCTTCCCATTGTTAAAACTACGCGTTCGCGTGGGCAACTTTACGCCTTCCCCTGGGTGGTGTCTACGAATTCCGATTATAACGGGCTATATCGTGCAACCGCATTCGGCTTTTGAAAAGGATGAGAAAGGCGGCCCCCAGGAACGTCGAACTTTACGTCTACTACCCACATACTCACGTTGGCTCGATGCGCTGCGCCAACATTCATGGATAAATAGATAGAGTGAGCCTAGATCCACCACGGATGCTAATTAATGTTTGAAAAAGTCATCGATAGCACAAGTGCAGCCTATCATACACAGGCGCGCGCCCGCACCCTGTGAGGTCATTCAATTACCCAAACGTCCCGGCAGAATCATCGAGGACAATATTCGAGCATGAGAGCTAGTTCCGGCTCTCACCTAAACCTGATCAACGTAGGCGACTCTACGGCGACGAATTAACGTGCCCAGAAGTCAAGTCGCTCCCTCCCTAACAGGGGTCCTGGCCGCATGTGTCTTTTTCTAAACCGCGAGTATCTAGACTGTACGACTATCACGGCGTCTCCTTACGATTGCAACGCTACAGTTGTGCATGGTGGCACGCTCTCTGGGTAATTGCCCACCCCCTATAGCTCTGGTCTTGCCGTCCTAGCGTGAAACGTTCCCAGAGAGCATAACTAGGTGAGTGGTGCGAGACAGTGTCAGGTAGCCCTAAACAGTCTTACTCCCGACAAGGGATAAGCATTAATTGGTTGAGCATTAATCCTCCGGGATGGTCCGTACCTGGTAACGGAAATCGTTATCTAATACCGGCGATGGGTTGGGGATCTATTCTGGAAGGGTCGTAACGCGCGATGAACAGTGCCCATGTTCGTTTACTGCCTGACGCGGAGGCAACGGGCTGTATTGGGGTCAGGATCGTAGTCACAAAAATCAGTTGTATTCGGGCTAAAATGGAGGGGGCGCTCACGGTTCTGTGCGATACCGTTAGTCAGGGTCTTCTTACTGGTATCTACGTGCCACTAGTGGAAAGGCGTTTAACACTCACTTTGCGCGCTGAGGGCAGAGGAATCACTTCGATTAGTTGATTACAAGCTGCAGTCAGCTTCGCGCCCTCGACTGTAATAGCGGTGGCTCTACAGCAGATCCGACCGGAGCCCCACTAAAGAAACTGACCAGACGGTGTCTACCGACCGGACCAGCACCGGGGCAGTACGAAGGTGGATTGTATTGCTGCTCATTGACAAACTCGAGAACCTGGTGAGGGCTCGAACCTGGAGACTATCGAGTTGTTAACAACGTCCATCAGGGAATAATACCGACCGCTTCGGCTTTACTCCCACAGCCCCGAGTTGGACGCTATATGCTAGTGGGCTGTCAGAAAATCGACGAGTTCCAGAGATTAAAGATCGACGAATACCAGGAGATGAGCACAGAGGCACCTTAGATCCCCTGCGAATCATGGGGTCCGTAAGTAAGAGCAAAGACCGAGGAGAATCCCAAGAAACACACG'"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import random as rn\n",
    "R = [rn.choice(['A','T','G','C']) for i in range(10000)]  # i or x variable\n",
    "DNA = ''.join(R)\n",
    "DNA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(647, 625, 620, 609, 640, 637, 646, 657, 610, 640, 597, 629, 649)"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "DNA.count('AT'), DNA.count('AG'), DNA.count('AC'),DNA.count('TC'),DNA.count('TG'),DNA.count('TA'),DNA.count('GC'),DNA.count('GA'),DNA.count('GT'),DNA.count('TG'),DNA.count('CA'),DNA.count('CT'),DNA.count('CG')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Counter({'G': 2540, 'A': 2490, 'C': 2486, 'T': 2484})\n"
     ]
    }
   ],
   "source": [
    "import collections\n",
    "#High Performance Counting   #how many and which are repeated numbers\n",
    "C = collections.Counter(DNA)\n",
    "print(C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(173, 151, 136, 178, 148, 153)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "DNA.count('ATG'), DNA.count('AGC'), DNA.count('ATC'),DNA.count('TGC'),DNA.count('TGA'),DNA.count('TCA')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- ### Try to solve using permutation and for"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "######## A Python program to print all ################## \n",
    "# permutations using library function \n",
    "from itertools import permutations\n",
    "#from itertools import combinations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ATGC\n"
     ]
    }
   ],
   "source": [
    "str_1 ='ATGC'    #string is list of character\n",
    "print(str_1)      # can use str_1 = ['A','T','G','C']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "perm = []    #open aempty list\n",
    "for r in range(1,4):   # range of start 1, to 4-1=3\n",
    "    print(r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('A',)\n",
      "('T',)\n",
      "('G',)\n",
      "('C',)\n",
      "('A', 'T')\n",
      "('A', 'G')\n",
      "('A', 'C')\n",
      "('T', 'A')\n",
      "('T', 'G')\n",
      "('T', 'C')\n",
      "('G', 'A')\n",
      "('G', 'T')\n",
      "('G', 'C')\n",
      "('C', 'A')\n",
      "('C', 'T')\n",
      "('C', 'G')\n",
      "('A', 'T', 'G')\n",
      "('A', 'T', 'C')\n",
      "('A', 'G', 'T')\n",
      "('A', 'G', 'C')\n",
      "('A', 'C', 'T')\n",
      "('A', 'C', 'G')\n",
      "('T', 'A', 'G')\n",
      "('T', 'A', 'C')\n",
      "('T', 'G', 'A')\n",
      "('T', 'G', 'C')\n",
      "('T', 'C', 'A')\n",
      "('T', 'C', 'G')\n",
      "('G', 'A', 'T')\n",
      "('G', 'A', 'C')\n",
      "('G', 'T', 'A')\n",
      "('G', 'T', 'C')\n",
      "('G', 'C', 'A')\n",
      "('G', 'C', 'T')\n",
      "('C', 'A', 'T')\n",
      "('C', 'A', 'G')\n",
      "('C', 'T', 'A')\n",
      "('C', 'T', 'G')\n",
      "('C', 'G', 'A')\n",
      "('C', 'G', 'T')\n"
     ]
    }
   ],
   "source": [
    "perm = []    #open an empty list\n",
    "for r in range(1,4):   # range of start 1, to 4-1=3\n",
    "    c = permutations(str_1,r) \n",
    "    for i in c:\n",
    "        print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A\n",
      "T\n",
      "G\n",
      "C\n",
      "AT\n",
      "AG\n",
      "AC\n",
      "TA\n",
      "TG\n",
      "TC\n",
      "GA\n",
      "GT\n",
      "GC\n",
      "CA\n",
      "CT\n",
      "CG\n",
      "ATG\n",
      "ATC\n",
      "AGT\n",
      "AGC\n",
      "ACT\n",
      "ACG\n",
      "TAG\n",
      "TAC\n",
      "TGA\n",
      "TGC\n",
      "TCA\n",
      "TCG\n",
      "GAT\n",
      "GAC\n",
      "GTA\n",
      "GTC\n",
      "GCA\n",
      "GCT\n",
      "CAT\n",
      "CAG\n",
      "CTA\n",
      "CTG\n",
      "CGA\n",
      "CGT\n"
     ]
    }
   ],
   "source": [
    "perm = []\n",
    "for r in range(1,4):\n",
    "    c = permutations(str_1,r)\n",
    "    for i in c:\n",
    "        j = ''.join(list(i))   # convert all term of tuple into list\n",
    "        print(j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['A', 'T', 'G', 'C', 'AT', 'AG', 'AC', 'TA', 'TG', 'TC', 'GA', 'GT', 'GC', 'CA', 'CT', 'CG', 'ATG', 'ATC', 'AGT', 'AGC', 'ACT', 'ACG', 'TAG', 'TAC', 'TGA', 'TGC', 'TCA', 'TCG', 'GAT', 'GAC', 'GTA', 'GTC', 'GCA', 'GCT', 'CAT', 'CAG', 'CTA', 'CTG', 'CGA', 'CGT']\n"
     ]
    }
   ],
   "source": [
    "perm = []    #open aempty list\n",
    "for r in range(1,4):   # range of start 1, to 4-1=3\n",
    "    c = permutations(str_1,r)  #    \n",
    "    for i in c:\n",
    "        el = ''.join(list(i))  #join all string of perm\n",
    "        perm.append(el)\n",
    "print(perm)       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the number of A in DNA is 2490\n",
      "the number of T in DNA is 2484\n",
      "the number of G in DNA is 2540\n",
      "the number of C in DNA is 2486\n",
      "the number of AT in DNA is 647\n",
      "the number of AG in DNA is 625\n",
      "the number of AC in DNA is 620\n",
      "the number of TA in DNA is 637\n",
      "the number of TG in DNA is 640\n",
      "the number of TC in DNA is 609\n",
      "the number of GA in DNA is 657\n",
      "the number of GT in DNA is 610\n",
      "the number of GC in DNA is 646\n",
      "the number of CA in DNA is 597\n",
      "the number of CT in DNA is 629\n",
      "the number of CG in DNA is 649\n",
      "the number of ATG in DNA is 164\n",
      "the number of ATC in DNA is 164\n",
      "the number of AGT in DNA is 144\n",
      "the number of AGC in DNA is 162\n",
      "the number of ACT in DNA is 135\n",
      "the number of ACG in DNA is 184\n",
      "the number of TAG in DNA is 156\n",
      "the number of TAC in DNA is 164\n",
      "the number of TGA in DNA is 161\n",
      "the number of TGC in DNA is 160\n",
      "the number of TCA in DNA is 159\n",
      "the number of TCG in DNA is 149\n",
      "the number of GAT in DNA is 172\n",
      "the number of GAC in DNA is 163\n",
      "the number of GTA in DNA is 154\n",
      "the number of GTC in DNA is 145\n",
      "the number of GCA in DNA is 150\n",
      "the number of GCT in DNA is 185\n",
      "the number of CAT in DNA is 160\n",
      "the number of CAG in DNA is 154\n",
      "the number of CTA in DNA is 165\n",
      "the number of CTG in DNA is 164\n",
      "the number of CGA in DNA is 180\n",
      "the number of CGT in DNA is 145\n"
     ]
    }
   ],
   "source": [
    "for each in perm:\n",
    "    #print(\"the number of {} in DNA is {}\".format(each, DNA.count(each)))\n",
    "    #print(\"the number of %s in DNA is %d\" %(each, DNA.count(each)))\n",
    "     print(f'the number of {each} in DNA is {DNA.count(each)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Note:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "######## A Python program to print all ################## \n",
    "# permutations using library function \n",
    "from itertools import permutations "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<itertools.permutations at 0x1caab61ba68>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " #Get all permutations of [1, 2, 3] \n",
    "perm = permutations([1, 2, 3]) \n",
    "perm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3)\n",
      "(1, 3, 2)\n",
      "(2, 1, 3)\n",
      "(2, 3, 1)\n",
      "(3, 1, 2)\n",
      "(3, 2, 1)\n"
     ]
    }
   ],
   "source": [
    "# Print the obtained permutations \n",
    " \n",
    "for x in list(perm): \n",
    "    print (x) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2)\n",
      "(1, 3)\n",
      "(2, 1)\n",
      "(2, 3)\n",
      "(3, 1)\n",
      "(3, 2)\n"
     ]
    }
   ],
   "source": [
    "####### A Python program to print all########## \n",
    "# permutations of given length \n",
    "from itertools import permutations \n",
    "  \n",
    "# Get all permutations of length 2 \n",
    "\n",
    "perm = permutations([1, 2, 3], 2) \n",
    "  \n",
    "# Print the obtained permutations \n",
    "for i in list(perm): \n",
    "    print(i) "
   ]
  },
  {
   "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}