Using Python, and your environment.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Using Python, and your environment\n",
    "\n",
    "## This article is for people who want to experiment with getting the right software and programming environment for them. If you just want to get started learning Python, use Spyder (included in Anaconda)\n",
    "\n",
    "So, you've installed Python, either by installing the distribution provided at Python's website, or you've installed Anaconda, which includes Python and much more. The next question is: how do we start using it?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Three main ways to use Python\n",
    "\n",
    "There are three main ways that we can use Python code to get things done. In general these three approaches play very well together, and it is worth developing skill in all of them, as they are useful for different situations.\n",
    "\n",
    "## Interactively\n",
    "\n",
    "Once Python is installed correctly, opening a command line interface and typing <code>python</code> will present you with a screen looking somethingl like this:"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Python 3.6.1 |Anaconda 4.4.0 (64-bit)| (default, May 11 2017, 13:09:58) \n",
    "[GCC 4.4.7 20120313 (Red Hat 4.4.7-1)] on linux\n",
    "Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n",
    ">>> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is the interactive Python interpreter, and those three little >'s mean Python is ready to talk to you. You can type anything in here, and the software will try to read it as if it is Python code. It will execute the line of code you typed, and then tell you the result.\n",
    "\n",
    "So the stuff we type has to be Python code. We cannot just say \"hello\", but if we do, nothing bad will happen. The interpreter just lets us know that this is not what it was expecting."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    ">>> Hello Python!\n",
    "  File \"<stdin>\", line 1\n",
    "    Hello Python!\n",
    "               ^\n",
    "SyntaxError: invalid syntax\n",
    ">>> \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try some arithmetic. Python understands that, at the very least:"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    ">>> 5 / 2\n",
    "2.5\n",
    ">>>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The interactive interface for Python has three main uses:\n",
    "\n",
    "- Performing very quick computations.\n",
    "- Testing bits of code before adding them to a big program.\n",
    "- Interacting with a program you've already written.\n",
    "\n",
    "### IPython vs. Python\n",
    "\n",
    "An alternative version of the interactive Python interpreter exists called IPython. It has loads of extra features to make inteteractive computing with Python easier, faster, and more readable. Both run the same code in the same way. The only downside, as I see it, to IPython is that it takes a good few seconds longer to start up. Therefore I tend to use <code>python</code> if I want to do something dead quick, and <code>ipython</code> if I anticipate an extended interactive session."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Editor + Interpreter\n",
    "\n",
    "So interactive computing is all well and good. But most of the time we want to write a larger program, that can perform more elaborate tasks, and we don't want to have to feed each step to the interpreter one at a time.\n",
    "\n",
    "So the alternative is to write all your code in a file, and then pass it to the Python interpreter to read through and execute. The Python file is called Python script, or Python module. Any software that can write a file of text can be used to write a Python module, but some are more suited to this task than others.\n",
    "\n",
    "### Important note\n",
    "\n",
    "When you are using Python interactively, the result of every computation is written to the screen as output. If you are running a Python script written in a text file, which may be thousands of lines long, it is unlikely that you will want to see the result of every single computation along the way. To see the result of a computation, use the <code>print()</code> command, for example, <code>print(5 / 2)</code> will display <code>2.5</code> to the screen.\n",
    "\n",
    "### IDEs\n",
    "\n",
    "An IDE is an \"integrated development environment\". Generally this means it's a piece of software that brings all the tools needed to write a program under one roof. So, the IDE will contain a text editor, for writing code. It may include a terminal, so you can access your computer's command line interface. It may include a Python interpreter, as well as debugging tools, version control, a file manager, and anything else a developer might need.\n",
    "\n",
    "Three good choices, in my opinion, divided by \"weight\" -- the number of features.\n",
    "\n",
    "- Weighing in at over 200mb, <b>PyCharm</b> is a heavyweight IDE. It has features galore, and takes a while to start up. This might be right for you if you're building something big, like the next Dropbox, which is written in Python. It has no cost if it's just for personal use.\n",
    "- Included with Anaconda, <b>Spyder</b> is a medium weight IDE that runs the IPython interface alongside the editor window. If you installed Anaconda, this is an easy way for you to get started!\n",
    "- <b>Geany</b> is a super lightweight IDE. It loads in moments, has a nice clean interface, and a terminal interface, which you can use to launch IPython.\n",
    "\n",
    "    ### Text editors\n",
    "\n",
    "    While IDEs provide many conveniences, many Python programmers prefer to edit text in a specialized programming text editor, and then run their program from the command line. A good text editor is really, really good at efficiently editing text. The various extra features provided by IDEs can be handled with other programs. A suitable text editor for programming should at least provide syntax highlighting, which changes the colours of the words you type to reflect their role in the program.\n",
    "\n",
    "On Windows, Notepad++ is very well-regarded text editor. It's a lot of fun to use, and has a nice tabs system for editing multiple files. On Mac, Text Wrangler is a very popular choice. On Linux, there's gedit, the GNOME text editor, but its feature-set is sparse: use Geany instead, which is so lightweight an IDE it is virtually just an editor. The \"best\" text editor, by popularity and editing speed (\"code at the speed of thought\"), is VIM, which is available on all platforms and probably already included on your computer if you have Mac or Linux. However, it takes a significant investment to learn to use this editor, as its vast number of tools for efficient editing are accessed via cryptic keyboard commands rather than using the mouse. Mac and Linux users can also use <code>nano</code> to easily edit from the command line.\n",
    "\n",
    "Once you have written your text file, save it with the extension <code>.py</code>. Then you can go to your command line,  navigate to the directory containing that file, and type <code>python fileyoujustmade.py</code> to run it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Jupyter Notebook\n",
    "\n",
    "This is a sort of hybrid between interactive and scripted Python. It is the Jupyter notebook, in which this document was created. Think of it as an interactive document, which talks to a Python interpreter and allows code to be written and executed, displaying the output within the document itself. It also, of course, allows segments of text to explain the code, supports $\\LaTeX$ for mathematical typesetting, and can display picture and other media. This makes Jupyter notebook great for data analysis, as your methodology (your code) and results (plots and such) can be displayed together in a single document. You can launch Juypter notebook from Anaconda, or from the command line with the command <code>jupyter-notebook</code>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}