little-helpers-in-jupyter-notebooks.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ...some little helpers\n",
    "\n",
    "- [0. Install Anaconda to run and execute the Notebooks on your Computer locally](#0)\n",
    "- [1. Jupyter Notebook Introduction](#1)\n",
    "- [2. Autocomplete Intellisense](#2)\n",
    "- [3. further help-functions...](#3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***In this Notebook you can find a little introduction to Jupyter Notebooks and some built-in-little-helper-functions.***\n",
    "\n",
    "all the *Jupyter Notebooks* in this Github-Repostory \n",
    "* you can either run it in your Browser, if you click the button below: [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/experimental-informatics/hands-on-python/HEAD)\n",
    "* or you can download this Repository via the *Clone or Download*-Button, see:\n",
    "\n",
    "![](https://www.stevejgordon.co.uk/wp-content/uploads/2018/01/CloneOrDownloadGitHub.png)\n",
    "\n",
    "* and after run it locally on your device."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 0.Install Anaconda to run and execute the Notebooks on your Computer locally\n",
    "for doing that, please visit: https://exmediawiki.khm.de/exmediawiki/index.php/KI_Workaround_installieren#Anaconda_2\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a class=\"anchor\" id=\"1\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.Jupyter Notebook Introduction \n",
    "\n",
    "parts of this Introduction are modified from [Allison Parrish's Python-Intro-Notebooks](https://github.com/aparrish/dmep-python-intro) < thanx Allison! \n",
    "\n",
    "---\n",
    "\n",
    "[Jupyter Notebook](https://jupyter-notebook.readthedocs.io/en/stable/) is part of the [Jupyter Project](https://jupyter.readthedocs.io/en/latest/), a nonprofit organization created to *\"develop open-source software, open-standards, and services for interactive computing across different programming languages\"* (Python, R, Julia).\n",
    "\n",
    "Beside of the *Notebook*. Project Jupyter has developed and supported more interactive computing products, like [JupyterHub](https://jupyterhub.readthedocs.io/en/latest/), [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/) or [Jupyter{Book}](https://jupyterbook.org/intro.html). Also [Binder](https://jupyter.org/binder), the service you are using if you click here: [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/experimental-informatics/hands-on-python/HEAD) is part of the *Jupyter Project*.\n",
    "\n",
    "[Binder](https://jupyter.org/binder) is meant for interactive and ephemeral interactive coding, meaning that it is ideally suited for relatively short sessions. Binder will automatically shut down user sessions that have more than 10 minutes of inactivity (if you leave your window open, this will be counted as “activity”). If your session times out, first try selecting `Kernel > Reconnect` in the above menu. If that doesn’t work, you’ll have to select `Kernel > Restart`.\n",
    "\n",
    "[Jupyter Notebook](https://jupyter-notebook.readthedocs.io/en/stable/) gives you a convenient way to experiment with Python code, interspersing your experiments with notes and documentation. You can do all of this without having to muck about on the command line, and the resulting file can be easily published and shared with other people. \n",
    "\n",
    "An [Jupyter Notebook](https://jupyter-notebook.readthedocs.io/en/stable/) consists of a number of \"cells,\" stacked on the page from top to bottom. Cells can have text or code in them. You can change a cell's type using the \"Cell\" menu at the top of the page; go to `Cell > Cell Type` and select either `Code` for Python code or `Markdown` for text. (You can also change this for the current cell using the drop-down menu in the toolbar.)\n",
    "\n",
    "### Text cells\n",
    "\n",
    "Make a new cell, change its type to `Markdown`, type some stuff and press `Ctrl-Enter`. Jupyter Notebook will \"render\" the text and display it on the page in rendered format. You can hit `Enter` or click in the cell to edit its contents again. Text in `Markdown` cells is rendered according to a set of conventions called Markdown. Markdown is a simple language for marking up text with basic text formatting information (such as bold, italics, hyperlinks, tables, etc.).\n",
    "\n",
    "see also our Notebook: [Markdown-basics.ipynb](https://github.com/experimental-informatics/hands-on-python/blob/master/Markdown-basics.ipynb).\n",
    "### Code cells\n",
    "\n",
    "You can also press `Alt-Enter` to render the current cell and create a new cell. \n",
    "\n",
    "New cells will by default be `Code` cells, as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a code cell.\n",
      "\n",
      "Any Python code you type in this cell will be run when you press the 'Run' button,\n",
      "or when you press Ctrl-Enter.\n",
      "\n",
      "If the code evaluates to something, or if it produces output, that output will be\n",
      "shown beneath the cell after you run it.\n"
     ]
    }
   ],
   "source": [
    "print(\"This is a code cell.\")\n",
    "print(\"\")\n",
    "print(\"Any Python code you type in this cell will be run when you press the 'Run' button,\")\n",
    "print(\"or when you press Ctrl-Enter.\")\n",
    "print(\"\")\n",
    "print(\"If the code evaluates to something, or if it produces output, that output will be\")\n",
    "print(\"shown beneath the cell after you run it.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "If your Python code generates an error, the error will be displayed in addition\n",
      "to any output already produced.\n"
     ]
    },
    {
     "ename": "ZeroDivisionError",
     "evalue": "division by zero",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-27-1ebad54fe81d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"to any output already produced.\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0;36m1\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mZeroDivisionError\u001b[0m: division by zero"
     ]
    }
   ],
   "source": [
    "print(\"If your Python code generates an error, the error will be displayed in addition\")\n",
    "print(\"to any output already produced.\")\n",
    "\n",
    "1 / 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Keyboard shortcuts\n",
    "\n",
    "As mentioned above, `Ctrl-Enter` runs the current cell; `Alt-Enter` runs the current cell and then creates a new cell. `Enter` will start editing whichever cell is currently selected. To quit editing a cell, hit `Esc`. If the cursor isn't currently active in any cell (i.e., after you've hit `Esc`), a number of other keyboard shortcuts are available to you:\n",
    "\n",
    "* `m` converts the selected cell to a Markdown cell\n",
    "* `b` inserts a new cell below the selected one\n",
    "* `x` \"cuts\" the selected cell; `c` \"copies\" the selected cell; `v` pastes a previously cut cell below the selected cell\n",
    "* `h` brings up a help screen with many more shortcuts.\n",
    "\n",
    "### Saving your work\n",
    "\n",
    "Please note that none of the changes you make in *Binder* will be saved. If you do make changes or notes, you will need to download the notebook to your own computer by clicking `File > Download as` > `Notebook.ipynb`.\n",
    "\n",
    "If you run *Jupyter Notebook* locally, then just hit `Cmd-S` at any time to save your notebook. Jupyter Notebook also automatically saves occasionally. Make sure to give your notebook a descriptive title by clicking on \"Untitled0\" at the top of the page and replacing the text accordingly. Notebooks you save will be available on your server whenever you log in again, from wherever you log into the server."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<a class=\"anchor\" id=\"2\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.Autocomplete Intellisense \n",
    "The auto-complete and Intellisese feature of Jupyter notebook mean the notebook will show you the possible code you may want to write, based on the Python language syntax in this case.\n",
    "\n",
    "Autocompletion is a form of intelligent code completion. This is a way to access names and signatures of functions, of a programming language like python. In other words, IntelliSense suggests what properties or functions the user may need to type, based on what the user has already typed.\n",
    "\n",
    "f.ex, if you wanna see the properties of a function or of an importet library\n",
    "\n",
    "Type the name of the library (in this case) *sklearn*, then type `dot` and press `TAB`\n",
    "\n",
    "![](https://miro.medium.com/max/2400/1*nLPbmMkG3zqAQG9lKFUmLw.png)\n",
    "\n",
    "Suppose you want to understand the signature of a function. \n",
    "\n",
    "You need to type the function name and then in the opening bracket of the function, type `shift` + `TAB`\n",
    "\n",
    "![](https://miro.medium.com/max/700/1*zRfegTd8gHi_tSs3P9VX7g.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<a class=\"anchor\" id=\"3\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "%config IPCompleter.greedy=True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. further help-functions...\n",
    "The interactive interpreter has all kinds of nuggets to help you program in Python. The first one worth mentioning is the help() function. \n",
    "\n",
    "Pass any function or method as a parameter to help() and you'll get a handy description of the method or function and what it does:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function len in module builtins:\n",
      "\n",
      "len(obj, /)\n",
      "    Return the number of items in a container.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(len)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "if you f.ex. ask yourself what kind of *methodes* you can use to work on certain types of value...\n",
    "\n",
    "Sometimes it's helpful to be reminded of exactly which methods an object supports. \n",
    "\n",
    "You can find this out right in the interactive interpreter without having to look it up in the documentation using the `dir()` built-in function. \n",
    "\n",
    "Just pass the value (in this case the string \"hello world\") that you want to know more about to `dir()`.\n",
    "\n",
    "then you will get a list on all of the methods that the string type supports. For now, please ignore anything that begins with two underscores (__) those are special built-in methods that aren't very useful to call on their own.)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__add__',\n",
       " '__class__',\n",
       " '__contains__',\n",
       " '__delattr__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__getitem__',\n",
       " '__getnewargs__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__iter__',\n",
       " '__le__',\n",
       " '__len__',\n",
       " '__lt__',\n",
       " '__mod__',\n",
       " '__mul__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__rmod__',\n",
       " '__rmul__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " 'capitalize',\n",
       " 'casefold',\n",
       " 'center',\n",
       " 'count',\n",
       " 'encode',\n",
       " 'endswith',\n",
       " 'expandtabs',\n",
       " 'find',\n",
       " 'format',\n",
       " 'format_map',\n",
       " 'index',\n",
       " 'isalnum',\n",
       " 'isalpha',\n",
       " 'isascii',\n",
       " 'isdecimal',\n",
       " 'isdigit',\n",
       " 'isidentifier',\n",
       " 'islower',\n",
       " 'isnumeric',\n",
       " 'isprintable',\n",
       " 'isspace',\n",
       " 'istitle',\n",
       " 'isupper',\n",
       " 'join',\n",
       " 'ljust',\n",
       " 'lower',\n",
       " 'lstrip',\n",
       " 'maketrans',\n",
       " 'partition',\n",
       " 'replace',\n",
       " 'rfind',\n",
       " 'rindex',\n",
       " 'rjust',\n",
       " 'rpartition',\n",
       " 'rsplit',\n",
       " 'rstrip',\n",
       " 'split',\n",
       " 'splitlines',\n",
       " 'startswith',\n",
       " 'strip',\n",
       " 'swapcase',\n",
       " 'title',\n",
       " 'translate',\n",
       " 'upper',\n",
       " 'zfill']"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(\"hello world\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "there are some operations on strings which all produce a new string or list\n",
    "\n",
    "![](./data/string-methods.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "If you want to know more about one method in particular, you can type this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function swapcase:\n",
      "\n",
      "swapcase() method of builtins.str instance\n",
      "    Convert uppercase characters to lowercase and lowercase characters to uppercase.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(\"hello\".swapcase)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "You can look up how f.ex. the `range` function is defined and what options it provides by going to the `?` documentation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[0;31mInit signature:\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m/\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
       "\u001b[0;31mDocstring:\u001b[0m     \n",
       "range(stop) -> range object\n",
       "range(start, stop[, step]) -> range object\n",
       "\n",
       "Return an object that produces a sequence of integers from start (inclusive)\n",
       "to stop (exclusive) by step.  range(i, j) produces i, i+1, i+2, ..., j-1.\n",
       "start defaults to 0, and stop is omitted!  range(4) produces 0, 1, 2, 3.\n",
       "These are exactly the valid indices for a list of 4 elements.\n",
       "When step is given, it specifies the increment (or decrement).\n",
       "\u001b[0;31mType:\u001b[0m           type\n",
       "\u001b[0;31mSubclasses:\u001b[0m     \n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "range?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### Exercises:\n",
    "Use dir() and help() to find string methods. Then write an expression using that method, f.ex.:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#set variable with string\n",
    "TB = \"»Tender Buttons«, from Gertrude Stein\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'»tENDER bUTTONS«, FROM gERTRUDE sTEIN'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#example for swapcase\n",
    "TB.swapcase()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#output all in lowercase\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#output all in uppercase\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "#replace \"from\" with \"by\" in Variable TB\n",
    "## help(str.replace)\n",
    "## TB.replace(\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# now set a new variable from the  last output (replace) \n",
    "# name the variable TB2\n",
    "# print TB2\n",
    "\n",
    "\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.7.8"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}