Python_Course_MeInBio_PART4_solution.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"IMAGES_PYTHON_COURSE_2018/LOGO_MEINBIO_TRANSPARENT.png\" width=\"200\" height=\"200\" />\n",
    "\n",
    "# <center>Python course 2018\n",
    "### <center>MeInBio Training Group\n",
    "#### <center> by Florian Heyl & Francesco Ferrari \n",
    "<center> Welcome to this introduction to Python. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PART 4: FUNCTIONS\n",
    "\n",
    "Functions in python are a very handy tool to define routines that you will use in your code more than one time. \n",
    "We already used functions in the previous exercises without you knowing. For example, to split a string you wrote the code:\n",
    "    \n",
    "## Exercise 1: Defintion of a Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['_']\n"
     ]
    }
   ],
   "source": [
    "message = \"hello_world\"\n",
    "print(str.split(\"_\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What you execute is the split() function. All these functions are pre-defined and sitting in the python libaries or in other packages. But what if you need something of your own. Lets delve into this topic."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world!\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "def my_new_test_function():\n",
    "    print(\"hello world!\")\n",
    "print(my_new_test_function())  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First of all lets look how you define a function. \n",
    "\n",
    "- **def** states that you want to define a function\n",
    "- **test_function** is your name you give the function you can name it like you want\n",
    "- **()** are the arguments the function takes\n",
    "- **:** signalises the start of the function body\n",
    "\n",
    "As soon as you invoke the function with test_function() the body will be executed. \n",
    "What you have to learn is, that every function automatically return a value. Since we did not declared anything, we get next to our print message the value **None** for missing value. \n",
    "\n",
    "Lets see how I can change this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world!\n",
      "5.0\n",
      "hello world!\n",
      "5.0\n",
      "hello world!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def test_function():\n",
    "    print(\"hello world!\")\n",
    "    return 5.0 #\"this is the output\"\n",
    "    \n",
    "print(test_function()) # 1st execution\n",
    "a = test_function() # 2nd execution\n",
    "print(a)\n",
    "type(a)\n",
    "test_function()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The word **return** can be used to define an object, value or anything that will be returned from a function. \n",
    "Thus I can also safe this value inside a new variable **a** and print it out. As you see both invokations \n",
    "**print(test_function())** and **a = test_function()**\n",
    "print the message \"hello world\" because the function is executed every time.\n",
    "\n",
    "How to think about functions: \n",
    "Function are like mathematically functions you learnd from school. You throw in something and get something back f(x) = y.\n",
    "\n",
    "So how can we throw something in a function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 2\n",
      "y = 5\n",
      "7\n",
      "x = -3\n",
      "y = 7\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "def sum_func(x,y):\n",
    "    print(\"x = \" + str(x))\n",
    "    print(\"y = \" + str(y))\n",
    "    return(x+y)\n",
    "    \n",
    "print(sum_func(2,5))\n",
    "\n",
    "result = sum_func(-3,7)\n",
    "#print(sum_func(-3,7))\n",
    "print(result)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, function arguments can be passed inside **()**.\n",
    "\n",
    "### TASK\n",
    "\n",
    "Define a function that divides to numbers **x** and **y**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 8\n",
      "y = 4\n",
      "2.0\n"
     ]
    }
   ],
   "source": [
    "### put your code here\n",
    "def div_func(x,y):\n",
    "    print(\"x = \" + str(x))\n",
    "    print(\"y = \" + str(y))\n",
    "    return(x/y)\n",
    "    \n",
    "print(div_func(8,4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 2: Scope of Functions\n",
    "\n",
    "Lets talk about something more complicated. You have to be careful how you think about function in terms of variables. Varaibles that you define inside a functions are not working outside. However varaibels that are defined outside the function can be used inside. \n",
    "\n",
    "Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14\n"
     ]
    }
   ],
   "source": [
    "outside = 4\n",
    "\n",
    "def add_inside(inside):\n",
    "    return(outside + inside)\n",
    "\n",
    "print(add_inside(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14\n"
     ]
    }
   ],
   "source": [
    "outside = 4\n",
    "\n",
    "def add_inside(inside):\n",
    "    return(outside + inside)\n",
    "\n",
    "print(add_inside(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example I declared the varaible **outside** which can be used in the function **add_inside()** since its above the scope. Lets see if I can use the variable **inside** also like the varaible **outside**. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "outside = 4\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'inside' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-7-683dc0eb95dd>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"outside =\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moutside\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"inside =\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minside\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'inside' is not defined"
     ]
    }
   ],
   "source": [
    "print(\"outside =\", outside)\n",
    "print(\"inside =\", inside)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see we get the error **NameError: name 'inside' is not defined** because the varaible **inside** is only defined in the function **add_inside()** but it was never declared above the scope. \n",
    "\n",
    "**GOOD PRACTICE:** Try not to use variables like **outside** and always define arguments for your functions to make it more readable, or you produce code which is hard to read.\n",
    "\n",
    "### TASK \n",
    "\n",
    "Correct my function that I defined to calculate the mean of a list of numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16\n",
      "4.0\n",
      "30\n"
     ]
    }
   ],
   "source": [
    "a = 30\n",
    "def mean_func(l):\n",
    "    a = sum(l)\n",
    "    print(a)\n",
    "    b = len(l)\n",
    "    mean_val = a/b\n",
    "    return(mean_val)\n",
    "\n",
    "out = mean_func([2,2,6,6])\n",
    "print(out)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 3: Reading and Writing with a Function\n",
    "\n",
    "### TASK \n",
    "\n",
    "Rememeber from chapter 3 where we read a file and printed the ID, foldchange and p-value. Lets see if we can automize it with the help of a function to read more than one file. Take the list I provided and define the function **read_peak_file()** to do exactly that."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test_data/test_peaks_1.csv\n",
      "1,3.2378015976911367,1.749078078385043e-05\n",
      "\n",
      "2,3.226332510136887,6.2548766858851105e-06\n",
      "\n",
      "5,4.410160029802366,0.0011333599022769559\n",
      "\n",
      "6,4.793154500726722,0.0010002192710420724\n",
      "\n",
      "test_data/test_peaks_2.csv\n",
      "16,3.9417937672900725,0.0007143902996521523\n",
      "\n",
      "17,5.515757832750586,1.341572971985603e-06\n",
      "\n",
      "18,5.533529651295307,1.3607085826675132e-06\n",
      "\n",
      "19,3.973804795704803,6.005465401585325e-05\n",
      "\n",
      "20,3.9032026593530262,0.0001725138617881825\n",
      "\n",
      "21,4.072386405636012,0.00010888493930551161\n",
      "\n",
      "22,3.8254624870252245,8.00040597283419e-05\n",
      "\n",
      "23,5.721952893667009,1.648471856269721e-08\n",
      "\n",
      "24,5.844399717868446,1.0384073296427449e-08\n",
      "\n"
     ]
    }
   ],
   "source": [
    "### put your code here\n",
    "peak_files = [\"test_data/test_peaks_1.csv\", \"test_data/test_peaks_2.csv\"]\n",
    "\n",
    "def read_peak_file(peak_files):\n",
    "    for file in peak_files:\n",
    "        peakfile = open(file)\n",
    "        print(file)\n",
    "        #signifpeakfile=open(\"test_data/significant_peaks_2.csv\", \"w\")\n",
    "        next(peakfile) # skip header\n",
    "        for goldfish in peakfile:\n",
    "            split=goldfish.split()\n",
    "            peak_id=split[1]\n",
    "            log2foldchange=split[12]\n",
    "            #print(type(log2foldchange))\n",
    "            p_value=split[16]\n",
    "            if float(log2foldchange)>=1 and float(p_value)<=0.01:              #have to 'cast' value as float because it thinks it's a string after reading the file\n",
    "                print(peak_id + \",\"+log2foldchange +\",\" + p_value +\"\\n\") #need to add comma to separate values in new file\n",
    "\n",
    "            #print(peak_id, log2foldchange, p_value)\n",
    "\n",
    "### needs to work:\n",
    "read_peak_file(peak_files)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "true\n"
     ]
    }
   ],
   "source": [
    "if float(\"2.0\") >= 1:\n",
    "    print(\"true\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "print(type(float(\"2.0\")))\n",
    "print(type(\"2.0\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "success!\n",
      "success!\n"
     ]
    }
   ],
   "source": [
    "peak_files = [\"test_data/test_peaks_1.csv\", \"test_data/test_peaks_2.csv\"]\n",
    "\n",
    "#open(peak_files)\n",
    "for file in peak_files: \n",
    "    open(file)\n",
    "    print(\"success!\")\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}