{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "Python Boot Camp\n", "=================================\n", "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "
\n", "

Learning Objectives

\n", "
\n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> - introduce you to Python\n", "> - explain why you need Python in your life\n", "> - help you install Python on your own laptop\n", "> - get you *writing* Python- introduce you to Python\n", "> - explain why you need Python in your life\n", "> - help you install Python on your own laptop\n", "> - get you *writing* Python\n", "\n", "-----------" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "What is Python?\n", "==================================\n", "\n", "Python is a modern computing language that is designed to be simple and easy to use. It is excellent for writing functional code *quickly*, and supports modules (libraries) that make achieving complicated tasks relatively simple. It was created in the early 90's by the Benevolent Dictator For Life (BDFL), Guido van Rossum. \n", "\n", "### Python - History\n", "\n", "You need to be aware that there are two versions of the Python language around at the moment. Python 2 was first released in 2000, and the latest version is 2.7. Python 3 is a slightly different language, and the one we will use for this course. It was released in 2008 and is rapidly becoming the standard version. Python 3 is **not** backwards compatible with Python 2.\n", "\n", "-------------------------------\n", "# Why should you learn Python?\n", "\n", "- Python is free and highly portable (Linux, Mac OSX, Windows, etc.) \n", "- Python is easy to understand and learn\n", "- Python has *great* documentation\n", "- **Python has a large library of useful scientific modules**\n", "\n", "These points mean that Python can be installed by anyone, anywhere. The simple syntax means Python is easy to learn. Most importantly however, the third party modules that exist for Python allow us to do **very complex tasks** with **very little code**. Let's look at an example - we'll use a third party module to quickly analyse survival statistics from the Titanic. Don't try and understand the code; it's simply intended to show you the power of Python." ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# This is a comment line\n", "# The next lines import external modules so we can use them\n", "%matplotlib inline\n", "import numpy as np\n", "from matplotlib import pyplot as plt\n", "import seaborn as sns\n", "sns.set_style('darkgrid')\n", "\n", "# open titanic survival data\n", "titanic = sns.load_dataset(\"titanic\")\n", "\n", "# plot it\n", "ax= plt.figure(figsize=(10,6))\n", "sns.barplot(x=\"sex\", y=\"survived\", hue=\"class\", data=titanic);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Notice how the adage \"women and children first\" does seem to be true; for a given class of ticket, women are much more likely to survive. However, we should note that males in first class had almost as much chance of survival as women in third class... " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## More reasons to learn Python\n", "\n", "In 2024, Python overtook Javascript as the most popular language on Github. It's used in the tech industry, financial services, web development and, of course, in science.\n", "\n", "Take a look at the recent [jobs](https://www.python.org/jobs/) listings for Python developers. In fact, the question should be, why not learn python?\n", "\n", "\n", "\n", "## Why shouldn't I learn Python?\n", "\n", "Python is what is known as a \"dynamically typed\" language. That means that if I want to store a value in a variable I just type \n", "\n", "```python\n", "x = 3\n", "```\n", "\n", "What you are doing here is storing a value in computer memory. In this case we are storing a value (3) in a box in memory, which is labelled \"x\". \n", "\n", "Python hides a lot of complicated stuff from us here. For example, we need to know what will be stored in the box to know how much computer memory we should use. Python figures out for me that ```x``` is a variable that should store an integer (3). \n", "\n", "Python's ability to guess the types of variables on the fly is very powerful. If I try to add two variables together, Python will try and guess what I want to do, and do something sensible. So" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "7\n" ] } ], "source": [ "x = 3\n", "y = 4\n", "print (x+y)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "works exactly as we expect. Many computer languages are not like this! For example, let's look at the same code in C\n", "\n", "```c\n", "int x, y;\n", "int total;\n", "x = 3;\n", "y = 4;\n", "total = 3+4;\n", "std::cout << total << std::endl;\n", "```\n", "\n", "First of all, you can see that we have to tell C what *type* of object goes into each variable. You can see from these examples just how clean and easy to understand Python's syntax is in comparison to C. But wasn't I supposed to be explaining why **not** to use Python?\n", "\n", "The point is that Python is *slow*. To calculate ```x+y``` above, the computer needs to convert the code you write into a series of instructions for the computer. Because C knows it is adding two integers, it can just run the instructions to add two integers. When running Python, the computer doesn't know in advance the *type* of the things we are asking it to add. So the computer has to execute the following instructions:\n", "\n", "- what is the type of x? [integer]\n", "- what is the type of y? [integer]\n", "- what instruction can add these two types?\n", "- run that instruction\n", "\n", "This extra overhead makes Python slow to run compared to languages like C and Fortran. However, the speed of *writing* the Python often makes up for this, and when it does not, there are workarounds. The most common is to use Python as **glue** to stick together bits of C code. In fact, many of the libraries you can use in Python actually run C behind the scenes to speed things up. \n", "\n", "This leads us to an important realisation about the best way to use Python. Many people have written efficient third-party libraries, many of which run C behind the scenes. The best Python code uses snippets of Python to glue these libraries together. We'll see this approach a lot in this bootcamp.\n", "\n", "### Installation\n", "\n", "Now we have (hopefully) motivated you to learn Python - let's look at how to install it on your own laptop." ] } ], "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.5.1" } }, "nbformat": 4, "nbformat_minor": 0 }