---
# System prepended metadata

title: BioCoding 2023

---

## Shared URLS

- Learn more markdown: [link](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet)
- Human genome: [link](https://www.ncbi.nlm.nih.gov/projects/genome/guide/human/index.shtml)
- SNPedia: [link](https://www.snpedia.com/index.php/SNPedia)
- Project Jupyter: [link](https://jupyter.org/)
- Interesting Jupyter notebooks: [link](https://github.com/jupyter/jupyter/wiki/A-gallery-of-interesting-Jupyter-Notebooks)
- Try Linux terminal: [link](https://cocalc.com/doc/terminal.html)
- Rapid DNA extraction protocol: [link](https://dnabarcoding101.org/lab/protocol-2.h(tml#standard)
- mybinder.org: [link](https://mybinder.org/)
- Notebooks: https://github.com/JasonJWilliamsNY/biocoding-2022-notebooks
- Zoom link: [TBD](TBD)
- JupyterHub: [TBD](TBD)

---
## Learning more after the class

   **Notebooks used in this course**
   - Biocoding 2020 Notebooks [link](https://github.com/JasonJWilliamsNY/biocoding-2020-notebooks)
   - - You can download these materials: [link](https://github.com/JasonJWilliamsNY/biocoding-2020-notebooks/archive/master.zip)

   **General Coding**

   - CodeCademy: [link](https://www.codecademy.com/)
   - Hour of code (also in languages other than English): [link](https://code.org/learn)

   **Software installations**

   Be sure you have permission to install software

   - Try Ubuntu: [link](https://tutorials.ubuntu.com/tutorial/try-ubuntu-before-you-install#0)
   - Python: [link](https://www.python.org/downloads/)
   - Jupyter: [link](https://jupyter.org/)
   - Wing IDE: [link](https://wingware.com/)
   - Atom text editor: [link](https://atom.io/)

   **Bioinformatics**

   - Learn bioinformatics in 100 hours: [link](https://www.biostarhandbook.com/edu/course/1/)
   - Rosalind bioinformatics: [link](http://rosalind.info/about/)
   - Bioinformatics coursera: [link](https://www.coursera.org/learn/bioinformatics)
   - Bioinformatics careers: [link](https://www.iscb.org/bioinformatics-resources-for-high-schools/careers-in-bioinformatics)

   **Help**

   - General software help: [link](https://stackoverflow.com/)
   - Bioinformatics-specific software help: [link](https://www.biostars.org/)


---




## Account names 
zhong
navas
lee
labelson
suskin
paval
polevoy
reed
saur
dimaio
kim
mingoia_murphy
shohdy
marinescu

### Jupyter

- [Hub address](http://3.228.2.183:8000/hub/login)


### Notebook setup 

    git clone https://github.com/JasonJWilliamsNY/biocoding-2021-notebooks.git
    
    
### DNA Barcoding

- [silica DNA isolation](https://dnabarcoding101.org/lab/protocol-2.html#alternateb)


---

## Shared notes

**Linux commands for the Command Line/Terminal**

* [linux explainer](https://explainshell.com)
* *PWD* - print working directory (prints the name of the current folder)
* *ls* - list (lists all the files in the current folder)
* *cd **foldername*** - change directory (changes the current folder to "foldername")
* *rm **filename*** - deletes the file "filename"
* *whoami* - prints your username

**Github specific**
* *git clone **github-link*** copies the github repository to your computer

**General Info**
- Logging in to Jupyter:
    - username: **lastname**
    - password: **lastname.123**

### DAY ONE 
**Summary**
We discussed what a **computer** is, what **bioinformatics** is, as well as different programs that are used for programming such as **Github**, **Jupyter**, and the **Command Line**. We logged in to Jupyter for the first time and downloaded the notebooks. We went through biocoding_2021_intro_python_01 and learned about functions and the **print()** function as well as **strings** and **variables**. We **isolated our plant dna** for pcr.

**General**
**--Vocab--**
IP address - the computer's internet address
Github - a place for sharing software/code and data
**=** "assignment operator"
String - 0 or more characters enclosed in quotes

**--Concepts--**
* In Jupyter Notebooks, there are a combination of text and code
    * Grey blocks/cells are code, and can be run with the **play button** on top of the screen, on the side of the cell, or by pressing **shift and enter**
    * You can create a new cell with the plus at the top of the screen

--
* In python, a function is represented as **functionName()**
    * A function (sometimes) takes input (in the parentheses) and then gives output

--
* A variable is something that stores data
    * The value on the right of "=" is stored in the variable to the left of it
        * ***variableName** = **4*** <- stores 4 in variableNAme

--
* anything with quotation marks around it is a **string**
    * "A string is 0 or more characters enclosed in quotes"

**--Code--**

* *print("**text**")* - prints "text"
* Math
    * ***a** + **b*** addition
    * ***a** - **b*** subtraction
    * ***a** / **b*** division
    * ***a** * **b*** multiplication
    * ***a** ** **b*** exponent
---
### DAY TWO
**Summary**
We went through biocoding_2021_pythonlab_02, and learned about **strings**, the **type()** function, how to name variables and some **python style guidelines**,

**General**
**--Vocab--**

**--Concepts--**
* Naming
    * variable_name - "snake case"
    * variableName - "camel case"
    * both are fine
* [Python Style Guide](https://peps.python.org/pep-0008/#naming-conventions)
* Clusivity - whether a number is included or excluded from a list
* File format - a consistent way of writing/storing data
* FASTA format - 

**--Code--**
* *type(**variable**)* - returns the type of variable (string, int, etc)
* "*#*" - comment (not code)
* *len(**variable**)* - returns the length of a variable
* ***string**[**beginIndex**:**endIndex**:**stepSize**]* - get a slice of a string
    * the endIndex will go up to the endIndex, but not include it
    * ":" is "everything"
* ***variable**.**method**()* is a method call
    * ***variable**.count(**letter**)* counts the number of letters
* *help(**something**)* - tells you about "something"
* 



----
**Variable names for Average weight of a mouse group?**
* avg_mouse_mass
* avgmofm
* groupnameAM
* groupname_avg_mass
* avg_mouse_g
* avg_weight
* groupname_avg_weight
* avg_weight
* avg_mouse_weight
* avgWeight
* groupname_avgmass
* avg_mouse_mass

**Variable names for Number of mice in a group?**
* numMice
* groupname_num
* groupname_numMice
* group_num
* group_num
* groupname_num_mice
* groupname_Groupnum
* groupnameNum
* mice#
* groupname_mice#

**Challenge In the cell below, print the alpha_id character by character in reverse**

alpha_id[::-1]

-----
print(alpha_id[7]+alpha_id[6]+alpha_id[5]+alpha_id[4]+alpha_id[3]+alpha_id[2]+alpha_id[1]+alpha_id[0])

-----
print(alpha_id[7])
print(alpha_id[6])
print(alpha_id[5])
print(alpha_id[4])
print(alpha_id[3])
print(alpha_id[2])
print(alpha_id[1])
print(alpha_id[0])
    
----
**Create new variables that contain the initials of the experimenter**

print(alpha_id[0:3])
print(beta_id[0:3])
print(gamma_id[0:3])

----
print(alpha_id[:3])
print(beta_id[:3])
print(gamma_id[:3])


**Create new variables that contain the ID of the experimenter**

print(alpha_id[3:])
print(beta_id[3:])
print(gamma_id[3:])


----
print(alpha_id[3:])
print(beta_id[3:])
print(gamma_id[3:])

----



initial_alpha = alpha_id[0:3]
initial_beta = beta_id[0:3]
initial_gamma = gamma_id[0:3]
print(initial_alpha)
print(initial_beta)
print(initial_gamma)


------
alphaExp = alpha_id[0:3]
betaExp = beta_id[0:3]
gammaExp = gamma_id[0:3]
print("alpha experimenter: " + alphaExp + '     beta experimentor: ' + betaExp + "     gamma experimentor: " + gammaExp)


----
##### Creating a Fasta file printer

name = 'Bob'
seq = 'GTACTAATTAGGGCTAGAC'
print(">" + name + '\n' + seq)


-----
ranSeqName = "sequence 1"
ranSeq = "ACGTACGATCGTAGCTACGTATCGTCGGCTACGAT"
print(">"+ranSeqName+"\n"+ranSeq)

-----
```
sequence_name = "sequence 1"
sequence = "TCGTAGCGGTGTACATGACCCCTGGATACGTGCGCCTGCTA"
print(f">{sequence_name}\n{sequence}")
```
-----
    seq_name = "sequence_1"
    sequence = "ATTCGAGGATCGATTTCGATCGATGCTTAGCTTTAGCTTTTTTAGATCTCCCA"
    print(">"+seq_name+"\n"+sequence)

-----
sequence_001_name = "sequence 001"
sequence_001 = "ATTCGAGGATCGATTTCGATCGATGCTTAGCTTTAGCTTTTTTAGATCTCCCA"
print(">"+sequence_001_name+"\n"+sequence_001)



#### Determine and print the length of the HIV genome


print(len(hiv_genome))









##### Create variables for and print the sequences for the following HIV genes
- gag
- pol
- vif
- vpr
- env

-----
gag = hiv_genome[790:2292]
pol = hiv_genome[2085:5096]
vif = hiv_genome[5041:5619]
vpr = hiv_genome[5559:5850]
env = hiv_genome[6225:8795]
print("gag: "+gag +"\n \n pol: "+pol+"\n \n vif: "+vif+"\n \n vpr: "+vpr+"\n \n env:"+env)

-----
gag_seq = hiv_genome[790:2293]
pol_seq = hiv_genome[2085:5097]
vif_seq = hiv_genome[5041:5620]
vpr_seq = hiv_genome[5559:5851]
env_seq = hiv_genome[6225:8796]

-----

gag = hiv_genome[789:2292:]
pol = hiv_genome[2084:5096:]
vif = hiv_genome[5040:5619:]
vpr = hiv_genome[5558:5850:]
env = hiv_genome[6044:8795:]

----
gag = hiv_genome[789:2291]
pol = hiv_genome[2084:5095]
vif = hiv_genome[5040:5618]
vpr = hiv_genome[5558:5849]
env = hiv_genome[6224:8794]
print(gag + '\n' + '\n' + pol + '\n' + '\n' + vif + '\n' + '\n' + vpr + '\n' + '\n' + env

----
gag_seq = hiv_genome[789:2292]
pol_seq = hiv_genome[2084:5096]
vif_seq = hiv_genome[5040:5619]
vpr_seq = hiv_genome[5558:5850]
env_seq = hiv_genome[6224:8795]

----
##### Generate the RNA sequence for each of the genes you have isolated above

gag_rna = gag.replace('t','u')
pol_rna= pol.replace('t','u')
vif_rna = vif.replace('t','u')
vpr_rna = vpr.replace('t','u')
env_rna= env.replace('t','u')
print("gag rna: "+gag_rna +"\n \n pol rna: "+pol_rna+"\n \n vif rna: "+vif_rna+"\n \n vpr rna: "+vpr_rna+"\n \n env rna:"+env_rna)

-----


-----
gag_rna = gag_seq.replace("t", "u")
pol_rna = pol_seq.replace("t", "u")
vif_rna = vif_seq.replace("t", "u")
vpr_rna = vpr_seq.replace("t", "u")
env_rna = env_seq.replace("t", "u")

-----

#### For each gene, generate a sum for each of the nuclotides in that gene (e.g., #of 'A',#of'U',#of'G',#of'C')

gagT = str(gag.count('t'))
gagC = str(gag.count('c'))
gagG = str(gag.count('g'))
gagA = str(gag.count('a'))

polT = str(pol.count('t'))
polC = str(pol.count('c'))
polG = str(pol.count('g'))
polA = str(pol.count('a'))

vifT = str(vif.count('t'))
vifC = str(vif.count('c'))
vifG = str(vif.count('g'))
vifA = str(vif.count('a'))

vprT = str(vpr.count('t'))
vprC = str(vpr.count('c'))
vprG = str(vpr.count('g'))
vprA = str(vpr.count('a'))

envT = str(env.count('t'))
envC = str(env.count('c'))
envG = str(env.count('g'))
envA = str(env.count('a'))

print("gag: A - "+ gagA+ " C - "+gagC+" T - "+gagT+" G - "+gagG + "\n"+"pol: A - "+ polA+ " C - "+polC+" T - "+polT+" G - "+polG + "\n"+"vif: A - "+ vifA+ " C - "+vifC+" T - "+vifT+" G - "+vifG + "\n"+"vpr: A - "+ vprA+ " C - "+vprC+" T - "+vprT+" G - "+vprG + "\n"+"env: A - "+ envA+ " C - "+envC+" T - "+envT+" G - "+envG)

-----
print("gag: A - "+str(gag_rna.count("a"))+", U - "+str(gag_rna.count("u"))+", G - "+str(gag_rna.count("g"))+", C - "+str(gag_rna.count("c")))
print("pol: A - "+str(pol_rna.count("a"))+", U - "+str(pol_rna.count("u"))+", G - "+str(pol_rna.count("g"))+", C - "+str(pol_rna.count("c")))
print("vif: A - "+str(vif_rna.count("a"))+", U - "+str(vif_rna.count("u"))+", G - "+str(vif_rna.count("g"))+", C - "+str(vif_rna.count("c")))
print("vpr: A - "+str(vpr_rna.count("a"))+", U - "+str(vpr_rna.count("u"))+", G - "+str(gag_rna.count("g"))+", C - "+str(vpr_rna.count("c")))
print("env: A - "+str(env_rna.count("a"))+", U - "+str(env_rna.count("u"))+", G - "+str(env_rna.count("g"))+", C - "+str(env_rna.count("c")))

-----

#### For each gene, caculate the GC content (%)
#percent GC = sum of (G) + sum (C) / total number of nuclotides in a given gene

gagGC = ((int(gagC) + int(gagG)) / len(gag))*100
envGC = ((int(envC) + int(envG)) / len(env))*100
vprGC = ((int(vprC) + int(vprG)) / len(vpr))*100
vifGC = ((int(vifC) + int(vifG)) / len(vif))*100
polGC = ((int(polC) + int(polG)) / len(pol))*100
print(" gag GC %: " + str(gagGC) + "% \n env GC %: " + str(envGC) +"% \n vpr GC %: "+str(vprGC)+"% \n vif GC %: "+str(vifGC)+"% \n pol GC %: "+str(polGC)+"%")

-----

-----
print("gag %: "+str(((gag_rna.count("g")+gag_rna.count("c"))/len(gag_rna))*100))
print("pol %: "+str(((pol_rna.count("g")+pol_rna.count("c"))/len(pol_rna))*100))
print("vif %: "+str(((vif_rna.count("g")+vif_rna.count("c"))/len(vif_rna))*100))
print("vpr %: "+str(((vpr_rna.count("g")+vpr_rna.count("c"))/len(vpr_rna))*100))
print("env %: "+str(((env_rna.count("g")+env_rna.count("c"))/len(env_rna))*100))

-----

sequence_data = {
    'gag sequence': gag_sequence,
    'pol sequence': pol_sequence,
    'vif sequence': vif_sequence,
    'vpr sequence': vpr_sequence,
    'env sequence': env_sequence
}

for name, data in sequence_data.items():
    print(name, "percent GC:", (data.count('g') + data.count('c')) / len(data))

-----

gag = hiv_genome[789:2292]
print(gag)

pol = hiv_genome[2084:5096]
print(pol)

vif = hiv_genome[5040:5619]
print(vif)

vpr = hiv_genome[5558:5850]
print(vpr)

env = hiv_genome[6224:8795]
print(env)

RNA_gag = gag.replace('t', 'u')


)


gag = hiv_genome[790:2292]
print(gag)
pol = hiv_genome[2085:5096]
print(pol)
vif = hiv_genome[5041:5619]
print(vif)
vpr = hiv_genome[5559:5850]
print(vpr)
env = hiv_genome[6225:8795]
print(env)


-----
#### Print the list of these HIV genes in order given the list below The correct order is 
- gag, pol, vif, vpr, vpu, env, nef



print(hiv_gene_names[1] , hiv_gene_names[3], hiv_gene_names[2], hiv_gene_names[5], hiv_gene_names[0], hiv_gene_names[6])

-----
print(hiv_gene_names[1])
print(hiv_gene_names[3])
print(hiv_gene_names[2])
print(hiv_gene_names[4])
print(hiv_gene_names[5])
print(hiv_gene_names[0])
print(hiv_gene_names[6])

-----
-----
print(hiv_gene_names[1] + ', ' + hiv_gene_names[3] + ', ' + hiv_gene_names[2] + ', ' + hiv_gene_names[4] + ', ' + hiv_gene_names[5] + ', ' + hiv_gene_names[0] + ', ' + hiv_gene_names[6])

-----
print(hiv_gene_names[1])
print(hiv_gene_names[3])
print(hiv_gene_names[2])
print(hiv_gene_names[4])
print(hiv_gene_names[5])
print(hiv_gene_names[0])
print(hiv_gene_names[6])

-----

print(hiv_gene_names[1],hiv_gene_names[3],hiv_gene_names[2],hiv_gene_names[4],hiv_gene_names[5],hiv_gene_names[0],hiv_gene_names[6])

-----

### DAY THREE

#### Use conditionals so that if the float is greater than or equal to 0.5 consider that 
- 'Heads' otherwise 'Tails'




from numpy import random
my_random_int = random.randint(1,10)
my_random_float = random.ranf()
print('My random float is %f' % my_random_float)

if my_random_int>=.5:
    print('heads') 
if my_random_int<.5:
    print('tails')

-----

import random
coin_flip = random.uniform(0.0,1.0)
print(coin_flip)
if coin_flip >= 0.5:
    print("Heads")
elif coin_flip < 0.5:
    print("Tails")

-----
ran_num = random.ranf()
if ran_num >= 0.5:
    print("Heads")
else:
    print("Tails")

-----

ranFloat = random.ranf()
if ranFloat>=0.5:
    print("heads")
elif ranFloat<=0.001 or ranFloat>=0.999:
    print("on its side")
else:
    print("tails")
    
-----

coinflip = (int) (random.ranf()*2)+1

if(coinflip==2):
    print("It's heads")
else:
    print("It's tails")
    
-----
from numpy import random

coin_flip=random.randint(0,1)
if coin_flip>.5:
    print ("heads")
elif coin_flip=<.5:
    print ("tails")

print(coin_flip)

-----

from numpy import random
num = random.random()
if num >= 0.5:
    print("Heads")
else:
    print("Tails")

from numpy import random
my_random_coin = random.ranf()
if my_random_coin <= 0.5:
    print("The coin is heads")
else:
    print("The coin is tails")
    
    
    
    
#### 2. Determine how often would HIV mutate in 20 rounds of replication

-----

from numpy import random
replication_states = ['mutation','no_mutation']
hiv_mutation_probibilities = [0.000044,0.999956]

for flip in range(1,21):
    mutation_probibility = random.choice(replication_states,p = hiv_mutation_probibilities)
    print("%s" %mutation_probibility)
    

-----


-----
from numpy import random
mut_state = ['Mutation','No Mutation']
overall_prob = 0.44
mut_probabilities = [overall_prob,1-overall_prob]

for x in range(1,21):
    opt = random.choice(mut_state, p=mut_probabilities)
    print(opt)

-----
HIV_state = ['yes', 'no']
HIV_probability = [0.044, 0.956]
mutation_results = []
mutation_success = []
for mutation in range(1,21):
    mutation_rate = random.choice(HIV_state,p = HIV_probability)
    mutation_results.append(mutation_rate)
    print("Mutation: %s" %mutation_rate)
for result in mutation_results:
    if result == 'yes':
        mutation_success.append("success")
if len(mutation_success) == 1:
    print("The HIV mutated %d time" % len(mutation_success))
else:
    print("The HIV mutated %d times" % len(mutation_success))
    

#### determine which nucleotide in the HIV-1 genome to mutate


mutation_pos = random.randint(0, len(hiv_genome))
old_base = hiv_genome[mutation_pos]


# In one line

base = hiv_genome[random.randint(0, len(hiv_genome))]

-----

if(mutate == 'mutation'):
    substitutionState = ['ca', 'ga', 'ta', 'ac', 'gc', 'tc', 'ag', 'tg', 'at', 'ct', 'gt']
    substitutionP = [0.04320988, 0.45061693, 0.0617284, 0.00308632, 0.00617284, 0.055556, 0.08950617, 0.01851852, 0.00925926, 0.25, 0.01234568]
    whatSubstitute = random.choice(substitutionState, p = substitutionP)
    whichSubstitute = random.choice(find_all_indices(hiv_genome, whatSubstitute[0]))
    
    
def find_all_indices(text, letter):
    indices_of_letter = []
    for i, ch in enumerate(text):
        if ch == letter:
            indices_of_letter.append(i)
    return indices_of_letter

-----
index = random.randint(0, len(hiv_genome))

        
        
#### flip a coin weighted to the probabilities of mutation given in the 'Class 1: single nt substitution' chart above. In each the number of observed mutations of a nucleotide on the y-axis changing to one on the x-axis is shown.use the replace() function to mutate your HIV-1 genome


-----
```
****import numpy

mutationState = ['mutation', 'no_mutation']
mutationP = [0.000044, 0.999956]
mutate = random.choice(mutationState, p = mutationP)

if(mutate == 'mutation'):
    substitutionState = ['ca', 'ga', 'ta', 'ac', 'gc', 'tc', 'ag', 'tg', 'at', 'ct', 'gt']
    substitutionP = [0.04320988, 0.45061693, 0.0617284, 0.00308632, 0.00617284, 0.055556, 0.08950617, 0.01851852, 0.00925926, 0.25, 0.01234568]
```

    whatSubstitute = random.choice(substitutionState, p = substitutionP)


```
whichSubstitute = random.choice(find_all_indices(hiv_genome, whatSubstitute[0]))

```

    temp = list(hiv_genome)

    temp[whichSubstitute] = whatSubstitute[1]

    mutatedGenome = ''.join(temp)

def find_all_indices(text, letter):
    indices_of_letter = []
    for i, ch in enumerate(text):

        if ch == letter:
            indices_of_letter.append(i)
    return indices_of_letter**

-----
print(hiv_genome[718])

from numpy import random
mut_nuc_nuc = ["G_A", "G_C", "G_T", "G"]
fair_mut_probabilities_nuc = [0.96052631578, 0.01315789473, 0.02631578947, 0.00000000002]
mut_outcome_nuc = []

for mut in range(1):
    fair_mut_nuc = random.choice(mut_nuc_nuc,p = fair_mut_probabilities_nuc)
    mut_outcome_nuc.append(fair_mut_nuc)
    
for result in mut_outcome_nuc:
    if result == "G_A":
        print("G changed to A")
    elif result == "G_C":
        print("G changed to C")
    elif result == "G_T":
        print("G changed to T")
    else:
        print("G did not mutate")
    
-----

mutation_pos = random.randint(0, len(hiv_genome))

old_base = hiv_genome[mutation_pos]
print(old_base)
if old_base == 'a':
    new_base = random.choice(['c', 'g', 't'], p=[1/33, 29/33, 3/33])
elif old_base == 'c':
    new_base = random.choice(['a', 't'], p=[14/95, 81/95])
elif old_base == 'g':
    new_base = random.choice(['a', 'c', 't'], p=[146/152, 2/152, 4/152])
else:
    new_base = random.choice(['a', 'c', 'g'], p=[20/44, 18/44, 6/44])

hiv_genome = hiv_genome[:mutation_pos] + new_base + hiv_genome[mutation_pos + 1:]
print(hiv_genome[mutation_pos])


-----
(this has the random mutation but because it uses replace the first occurrence of that letter gets changed instead of a random one)

    # setting up mutation counts
    # setting up mutation rates
    mutation_state = ["mutation", "no_mutation"]
    mutation_prob = 0.000044
    mutation_rate = [mutation_prob, 1-mutation_prob]
    # check for mutation
    state = random.choice(mutation_state, p=mutation_rate)
    #     print(state)

    # setting up what kind of mutation
    mutation_specific_states = ["ac", "ag", "at", "ca", "cg", "ct", "ga", "gc", "gt", "ta", "tc", "tg"]
    mutation_specific_rates_temp = [14, 146, 20, 1, 2, 18, 29, 0, 6, 3, 81, 4]
        # transforming values into a decimal/percentage
    mutation_specific_rates = []
    for r in mutation_specific_rates_temp:
        mutation_specific_rates.append(r/sum(mutation_specific_rates_temp))


    if state == "mutation":
        # if mutation, choose the type
        change = random.choice(mutation_specific_states, p=mutation_specific_rates)
        print(change[1]+" change to "+change[0])
        # actually change the genome
        mutated_hiv_genome = mutated_hiv_genome.replace(change[1], change[0], 1)

-----

random_int_hiv = random.randint(0,9718)
if (hiv_genome[random_int_hiv]) == (hiv_genome[0]):
    random_inta = random.randint(1,33)
    if random_inta in range (1,1):
        print('adenine mutates into cytosine at' + (random_int_hiv))
    if random_inta in range(2,30):
        print('adenine mutates into guanine at' + (random_int_hiv))
    if random_inta in range(31,33):
        print('adenine mutates into thymine at' + (random_int_hiv))
if (hiv_genome[random_int_hiv]) == (hiv_genome[8]):
    random_intc = random.randint(1,95)
    if random_intc in range(1,14):
        print('cytosine mutates into adenine at' + (random_int_hiv))
    if random_intc in range(15,95):
         print('cytosine mutates into thymine at' + (random_int_hiv))
if (hiv_genome[random_int_hiv]) == (hiv_genome[2]):
    random_intg = random.randint(1,152)
    if random_intg in range(1,146):
        print('guanine mutates into adenine at' + (random_int_hiv))
    if random_intg in range(147,148):
        print('guanine mutates into cytosine at' + (random_int_hiv))
    if random_intg in range(149,152):
        print('guanine mutates into thymine at' + (random_int_hiv))
if (hiv_genome[random_int_hiv]) == (hiv_genome[1]):
    random_intt = random.randint(1,44)
    if random_intt in range(1,20):
        print('thymine mutates into adenine at' + (random_int_hiv))
    if random_intt in range(21,38):
        print('thymine mutates into cytosine at' + (random_int_hiv))
    if random_intt in range(39,44):
        print('thymine mutates into guanine at' + (random_int_hiv))
if result == 'no_mutation':
    print("no_mutation")
    
-----


mutation_pos = random.randint(0, len(hiv_genome))
nuc = hiv_genome[mutation_pos]
if nuc=='a':
    mutation_state=['A-T','A-G','A-C']
    mutation_probs = [0.0909090909,0.87878787878,0.0303030303]
elif nuc=='t':
    mutation_state=['T-A','T-G','T-C']
    mutation_probs=[0.45454545454,0.13636363636,0.40909090909]
elif nuc=='g':
    mutation_state=['G-T','G-A','G-C']
    mutation_probs=[0.02631578947,0.9605263158,0.01315789473]
elif nuc=='c':
    mutation_state=['C-A','C-G','C-T']
    mutation_probs=[0.14736842105,0,0.85263157894]
    
mutation_results = random.choice(mutation_state,p=mutation_probs)
print(mutation_results,'\nin nucleotide position',mutation_pos,'of the hiv genome')


----

#### Write the appropriate code to translate an RNA string to a protein sequence:
- rna = 'AUGCAUGCGAAUGCAGCGGCUAGCAGACUGACUGUUAUGCUGGGAUCGUGCCGCUAG'

counter = 0
while counter < len(rna):
    print(amino_acids[rna[counter:counter+3]])
    counter = counter + 3
    
-----

proteinSeq = ''
lengthOfProtein = int(len(rna)/3)
for x in range(0, lengthOfProtein):
    proteinSeq += amino_acids[rna[x*3:x*3+3]]
print(proteinSeq)

-----
protein = ""
for x in range(0, len(rna), 3):
    codon = rna[x:x+3]
    protein += amino_acids[codon]

print(protein)


#### Does your code work on the following RNA sequence?
    rna = 'AUGCAAGACAGGGAUCUAUUUACGAUCAGGCAUCGAUCGAUCGAUGCUAGCUAGCGGGAUCGCACGAUACUAGCCCGAUGCUAGCUUUUAUGCUCGUAGCUGCCCGUACGUUAUUUAGCCUGCUGUGCGAAUGCAGCGGCUAGCAGACUGACUGUUAUGCUGGGAUCGUGCCGCUAG'

yes

-----
if it's supposed to stop:

    protein = ""
    for x in range(0, len(rna), 3):
        codon = rna[x:x+3]
        if amino_acids[codon] != "_":
            protein += amino_acids[codon]
        else:
            break

    print(protein)
otherwise it's the same
or if it's supposed to have multiple proteins:

    protein = ""
    for x in range(0, len(rna), 3):
        codon = rna[x:x+3]
        if amino_acids[codon] != "-":
            protein += amino_acids[codon]
        else:
            print(protein)
            protein = ""
            
####  Can you translate this sequence in all 3 reading frames?

for frame in range(3):
    protein_seq = ''
    for start_pos in range(frame, len(rna), 3):
        amino = amino_acids[rna[start_pos:start_pos + 3]]
        if amino == '_': break
        protein_seq += amino
    print(protein_seq)

-----
protien_seq = ''
len_protien = int(len(rna)/3)
for x in range(0,len_protien):
    protien_seq+=amino_acids[rna[x*3:x*3+3]]
    if(protien_seq[len(protien_seq)-1:len(protien_seq)])=='_':
        protien_seq+='\n'
print(protien_seq)

----

    for frame in range(3):
        protein = ""
        for x in range(frame, len(rna), 3):
            if x+3 < len(rna):
                codon = rna[x:x+3]
                if amino_acids[codon] != "-":
                    protein += amino_acids[codon]
                else:
                    break
        print(protein)
        
or if there's supposed to be multiple proteins

    for frame in range(3):
        protein = ""
        for x in range(frame, len(rna), 3):
            if x+3 < len(rna):
                codon = rna[x:x+3]
                if amino_acids[codon] != "-":
                    protein += amino_acids[codon]
                else:
                    print(protein)
                    protein = ""
        print(protein)
        
        
        
#### Write a function that calculates the GC content of a DNA string

def calcGCContent(seq):
    return seq.count('G') + seq.count('C') + seq.count('g') + seq.count('c')

-----

def GC_count():
    GC_count=0
    for i in range(len(dna_string)):
        if dna_string[i]=='g' | dna_string[i]=='c':
            GC_count+=1
    return GC_count

-----

def gc_content(dna):
    g_count = dna.upper().count("G")
    c_count = dna.upper().count("C")
    return (g_count+c_count)/len(dna)
    
-----

def dna_gc_content():
    dna_gc_count = (dna.count('c') + dna.count('g')) / len(dna)
    return (dna_gc_count*100)
print (dna_gc_content() , '%')


#### Write a function that generates a random string of DNA of random length


import numpy
def dna_maker():
    length=random.randint(0,10000)
    probs=[0.25,0.25,0.25,0.25]
    chances=['a','t','c','g']
    dna = ''
    for i in range(length):
        dna+=random.choice(chances,p=probs)
    return dnahttps://hackmd.io/
    print(dna)
dna_maker()

------
import numpy
def ranDNA():
    sequenceState = ["A", "C", "G", "T"]
    sequenceP = [.25, .25, .25, .25]
    lengDNA = random.randint(0, 100000)
    DNAStrand = ''
    for x in range(lengDNA):
        DNAStrand += random.choice(sequenceState, p = sequenceP)
    return DNAStrand

print(ranDNA())

-----

from numpy import random

def ran_dna():
    length = random.randint(10, 500)
    print("Length:", length)
    dna = ""
    for x in range(length):
        dna += random.choice(["A", "T", "C", "G"])
    return dna

print(ran_dna())

----
















#### Challenge: Write a function that generates a random string of DNA of random a random length: use optional arguments to set the length of the strings and the probabilities of the nucleotides.


-----
    from numpy import random

    def ran_dna(length=random.randint(10, 500), aProb=0.25, tProb=0.25, cProb=0.25, gProb=0.25):
        print("Length:", length)
        dna = ""
        for x in range(length):
            dna += random.choice(["A", "T", "C", "G"], p=[aProb, tProb, cProb, gProb])
        return dna

    print(ran_dna(100, 0.1, 0.1, 0.4, 0.4))

or it could just be a list (it works either way)

    from numpy import random

    def ran_dna(length=random.randint(10, 500), probs=[0.25, 0.25, 0.25, 0.25]):
        print("Length:", length)
        dna = ""
        for x in range(length):
            dna += random.choice(["A", "T", "C", "G"], p=probs)
        return dna

    print(ran_dna(100, 0.1, 0.1, 0.4, 0.4))

-----


```
import numpy
def ranDNA(probA = 0.25, probC = 0.25, probG = 0.25, probT= 0.25):
        sequenceState = ["A", "C", "G", "T"]
        sequenceP = [probA, probC, probG, probT]
        not25s = []
        if(sum(sequenceP)!=1):
            for x in range(0,len(sequenceP)):
                if(sequenceP[x] == 0.25):
                    not25s.append(x)
            differenceFrom1 = probA+probC+probG+probT -1
            changeMade = -differenceFrom1/len(not25s)
            for x in range(0, len(not25s)):
                sequenceP[not25s[x]] += changeMade
        lengDNA = random.randint(0, 1000)
        DNAStrand = ''
        for x in range(lengDNA):
            DNAStrand += random.choice(sequenceState, p = sequenceP)
        return DNAStrand
```



#### Write a function that generates a random protein of length L



-----





-----

```
def ranRNA():
    sequenceState = ["A", "C", "G", "U"]
    sequenceP = [.25, .25, .25, .25]
    lengRNA = random.randint(1, 100)
    RNAStrand = ''
    for x in range(lengRNA):
        RNAStrand += random.choice(sequenceState, p = sequenceP)
    return RNAStrand
urMom = True
proteinSeq = ''
while urMom == True:
    RNAStrand = ranRNA()
    if(len(RNAStrand)>=3):
        if(amino_acids[RNAStrand[:3]] == 'M'):
            lengthOfProtein = int(len(RNAStrand)/3)
            for x in range(0, lengthOfProtein):
                proteinSeq += amino_acids[RNAStrand[x*3:x*3+3]]
                if(amino_acids[RNAStrand[x*3:x*3+3]] == '_'):
                    urMom = False
                    break
print(proteinSeq)
```




-----
    from numpy import random

    amino_acids = {
        'AUA':'I', 'AUC':'I', 'AUU':'I', 'AUG':'M',
        'ACA':'T', 'ACC':'T', 'ACG':'T', 'ACU':'T',
        'AAC':'N', 'AAU':'N', 'AAA':'K', 'AAG':'K',
        'AGC':'S', 'AGU':'S', 'AGA':'R', 'AGG':'R',
        'CUA':'L', 'CUC':'L', 'CUG':'L', 'CUU':'L',
        'CCA':'P', 'CCC':'P', 'CCG':'P', 'CCU':'P',
        'CAC':'H', 'CAU':'H', 'CAA':'Q', 'CAG':'Q',
        'CGA':'R', 'CGC':'R', 'CGG':'R', 'CGU':'R',
        'GUA':'V', 'GUC':'V', 'GUG':'V', 'GUU':'V',
        'GCA':'A', 'GCC':'A', 'GCG':'A', 'GCU':'A',
        'GAC':'D', 'GAU':'D', 'GAA':'E', 'GAG':'E',
        'GGA':'G', 'GGC':'G', 'GGG':'G', 'GGU':'G',
        'UCA':'S', 'UCC':'S', 'UCG':'S', 'UCU':'S',
        'UUC':'F', 'UUU':'F', 'UUA':'L', 'UUG':'L',
        'UAC':'Y', 'UAU':'Y', 'UAA':'-', 'UAG':'-',
        'UGC':'C', 'UGU':'C', 'UGA':'-', 'UGG':'W'
    }

    # set up the variables
    def generate_protein(length = 100):
        trials = 0
        starts = 0
        stops = 0
        protein = ""
        rna = ""
        while len(protein) != length:
            protein = ""
            rna = ""
            # get the start working
            codon = random.choice(["A", "U", "C", "G"])+random.choice(["A", "U", "C", "G"])+random.choice(["A", "U", "C", "G"]) #random codon
            while amino_acids[codon] != "M": #while the codon is not a start, try again (create a new codon)
                codon = random.choice(["A", "U", "C", "G"])+random.choice(["A", "U", "C", "G"])+random.choice(["A", "U", "C", "G"]) #random codon
                trials += 1
                starts += 1
            # if it worked, add the codon and amino acid to the protein and rna
            protein += amino_acids[codon]
            rna += codon

            # while the codon is not a stop, keep generating and adding codons
            while amino_acids[codon] != "-":
                codon = random.choice(["A", "U", "C", "G"])+random.choice(["A", "U", "C", "G"])+random.choice(["A", "U", "C", "G"]) #random codon
                protein += amino_acids[codon]
                rna += codon
            # once there's a stop, check if it is the right length or not
            if len(protein) != length:
                trials += 1
                stops += 1

        print("Total trials:", trials)
        print("Total restarts from start:", starts)
        print("Total restarts from end:", stops)
        print(protein)
        print("")
        print(rna)
        return protein, rna

    generate_protein(50)
    print("Done")

-----



#### M&M Plotting 

|Sample name|Blue|Brown|Green|Orange|Red|Yellow|
|-----------|----|-----|-----|------|---|------|

tube_x = [,,,,,,]
tube_3 = [14,9,14,9,1,1]
tube_4 = [11,12,5,6,5,7]
tube_6 = [7,2,6,10,4,18]
tube_5 = [12,8,4,12,4,8]
tube_7 = [10,8,11,8,8,3]
tube_9 = [11,4,5,12,13,2]
tube_10 = [23,2,3,8,4,9]


#### How would you make a plot for all of the tubes in the class?

-----
data = {
          'tube 3': [14,9,14,9,1,1],
          'tube 5': [12,8,4,12,4,8],
          'tube 6': [7,2,6,10,4,18],
          'tube 7': [10,8,11,8,8,3],
          'tube 9': [11,4,5,12,13,2],
          'tube 10': [23,2,3,8,4,9]
         }

for key in data:
    plot_1 = plot.bar(index,
                  data[key],
                  color=colors,
                  tick_label=colors,
                  align='center')
    plot.title(key)
    plot.show(plot_1)

-----

    # function to plot the data
    def bar_plot(tube, name=""):
        n = len(tube)
        index = np.arange(n)
        colors = ['blue',
                  'brown',
                  'green',
                  'orange',
                  'red',
                  'yellow']
        plot_1 = plot.bar(index,
                      tube,
                      color=colors,
                      tick_label=colors,
                      align='center')
        plot.title("Tube "+name)
        plot.show(plot_1)

    # defining tubes
    tube_3 = [14,9,14,9,1,1]
    tube_4 = [11,12,5,6,5,7]
    tube_5 = [12,8,4,12,4,8]
    tube_6 = [7,2,6,10,4,18]
    tube_7 = [10,8,11,8,8,3]
    tube_9 = [11,4,5,12,13,2]
    tube_10 = [23,2,3,8,4,9]

    # putting the tubes into a list for looping in the future
    tubes = [tube_3, tube_4, tube_5, tube_6, tube_7, tube_9, tube_10]
    tube_names = ["3", "4", "5", "6", "7", "9", "10"]

    # loop through the tubes and plot them
    for x in range(len(tubes)):
        bar_plot(tubes[x], tube_names[x])
-----

counter = 0

while counter <= len(tubes):
    observations = tubes[counter]
    n = len(observations)
    index = np.arange(n)
    colors = ['blue',
              'brown',
              'green',
              'orange',
              'red',
              'yellow']
    plot_1 = plot.bar(index,
                  observations,
                  color=colors,
                  tick_label=colors,
                  align='center')
    plot.show(plot_1)
    counter = counter + 1
    
-----
    
```
def graph(x):
#function to graph the graph
thing = observations[x]
n = len(thing)
index = np.arange(n)
colors = ['blue',
          'brown',
          'green',
          'orange',
          'red',
          'yellow']
plot1 = plot.bar(index,
              thing,
              color=colors,
              tick_label=colors,
              align='center')
plot.show(plot1)
#list of the tubes with values 
observations = [tube_0, tube_3, tube_4, tube_5, tube_6, tube_7, tube_9, tube_10]
#loop to graph the tubes
for x in range(len(observations)):
    graph(x)
```

-----

tube_3 = [14,9,14,9,1,1,3]
tube_4 = [11,12,5,6,5,7,4]
tube_6 = [7,2,6,10,4,18,6]
tube_5 = [12,8,4,12,4,8,5]
tube_7 = [10,8,11,8,8,3,7]
tube_9 = [11,4,5,12,13,2,9]
tube_10 = [23,2,3,8,4,9,10]
def graph(tube):
    observations = tube[0:6]
    n = len(observations)
    index = np.arange(n)
    colors = ['blue',
              'brown',
              'green',
              'orange',
              'red',
              'yellow']
    plot_1 = plot.bar(index,
                  observations,
                  color=colors,
                  tick_label=colors,
                  align='center')
    plot.title(tube[6])
    plot.show(plot_1)
observations=[tube_3,tube_4,tube_5,tube_6,tube_7,tube_9,tube_10]
for x in range(len(observations)):
    graph(observations[x])

------