{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Introduction to Jupyter-notebooks and Python primer" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- Python is a modern complete an open source programming language\n", "- Widespread in the scientific community\n", "- Easy to understand and human-readable\n", "- Still C wins on speed - but python is versatile and has packages that compete with C (such as NumPy)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "See an extended python tutorial here: https://docs.python.org/3/contents.html" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## How to use Jupyter-notebook" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- Each cell can be run independently, regardless of the order\n", "- Intersting short-cuts:\n", " - Press shift+Enter to run a cell\n", " - Press ESC+D to delete a cell\n", " - Press ESC+A to create a cell above your current cell\n", " - Press ESC+B to create a cell below your current cell" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Programming basics with Python" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Indentation" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Python uses indentation for blocks, instead of curly braces. Both tabs and spaces are supported, but the standard indentation requires standard Python code to use four spaces. For example:\n", "\n" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "x is 1.\n" ] } ], "source": [ "x=1\n", "if x==1:\n", " print(\"x is 1.\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Variables and types" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Python is completely object oriented, and not \"statically typed\". You do not need to declare variables before using them, or declare their type. Every variable in Python is an object.\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Numbers " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Python supports two types of numbers - integers and floating point numbers." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "7\n" ] } ], "source": [ "myint=7 # this is an integer\n", "print(myint)" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "7.0\n" ] } ], "source": [ "myfloat = 7.0 # this is a float number\n", "print(myfloat)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Strings" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Strings are defined either with a single quote or a double quotes. The difference between the two is that using double quotes makes it easy to include apostrophes (whereas these would terminate the string if using single quotes)" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "hello\n", "hello\n" ] } ], "source": [ "mystring = 'hello'\n", "print(mystring)\n", "mystring = \"hello\"\n", "print(mystring)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Simple operators can be executed on numbers and strings:" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "3\n", "hello world\n" ] } ], "source": [ "one = 1\n", "two = 2\n", "three = one + two\n", "print(three)\n", "\n", "hello = \"hello\"\n", "world = \"world\"\n", "helloworld = hello + \" \" + world\n", "print(helloworld)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Assignments can be done on more than one variable \"simultaneously\" on the same line like this" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "3 4\n" ] } ], "source": [ "a, b = 3, 4\n", "print(a,b)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Mixing operators between numbers and strings is not supported:" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "# This will not work!\n", "one = 1\n", "two = 2\n", "hello = \"hello\"\n", "\n", "#print(one + two + hello)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Lists" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Lists are very similar to arrays. They can contain any type of variable, and they can contain as many variables as you wish. Lists can also be iterated over in a very simple manner. Here is an example of how to build a list." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1\n", "2\n", "3\n" ] } ], "source": [ "mylist = []\n", "mylist.append(1)\n", "mylist.append(2)\n", "mylist.append(3)\n", "print(mylist[0]) # prints 1\n", "print(mylist[1]) # prints 2\n", "print(mylist[2]) # prints 3" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To see all lists built-in methods: https://docs.python.org/3/tutorial/datastructures.html" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Standard arithmetical operations" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "7\n" ] } ], "source": [ "a=3+4\n", "print(a)" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "5\n" ] } ], "source": [ "b=25-20\n", "print(b)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "60\n" ] } ], "source": [ "c=30*2\n", "print(c)" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "8\n" ] } ], "source": [ "d=2**3 # Exponentiation (everything written after '#' is a comment and is ignored by the interpreter)\n", "print(d)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Another operator available is the modulo (%) operator, which returns the integer remainder of the division. dividend % divisor = remainder." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2\n" ] } ], "source": [ "remainder = 11 % 3\n", "print(remainder)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Using operators with lists:" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1, 3, 5, 7, 2, 4, 6, 8]\n" ] } ], "source": [ "even_numbers = [2,4,6,8]\n", "odd_numbers = [1,3,5,7]\n", "all_numbers = odd_numbers + even_numbers\n", "print(all_numbers)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### String formatting and basic string operations" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You can print variables within strings. Add the tag f\" before the string and insert the variables in curly brackets: {variable}\n" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The list of even numbers is [2, 4, 6, 8]\n" ] } ], "source": [ "print(f\"The list of even numbers is {even_numbers}\")" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "my_string=\"Today is Monday\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You can perform several operations on strings:" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "15\n" ] } ], "source": [ "# Such as obtaining the length:\n", "print(len(my_string))" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2\n" ] } ], "source": [ "# counting the number of times a letter appears:\n", "print(my_string.count(\"o\"))" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "day\n", "day is Monday\n", "dyi ody\n" ] } ], "source": [ "# you can slice the string:\n", "print(my_string[2:5])\n", "print(my_string[2:15:1])\n", "print(my_string[2:15:2])\n", "#This prints the characters of string from 3 to 7 skipping one character. \n", "#This is extended slice syntax. The general form is [start:stop:step]." ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "yadnoM si yadoT\n" ] } ], "source": [ "# you can reverse a string:\n", "print(my_string[::-1])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "See other string methods here: https://docs.python.org/3/library/string.html#module-string" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Conditions" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Python uses boolean variables to evaluate conditions. The boolean values True and False are returned when an expression is compared or evaluated. For example:" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "True\n", "False\n", "True\n" ] } ], "source": [ "x = 2\n", "print(x == 2) # prints out True\n", "print(x == 3) # prints out False\n", "print(x < 3) # prints out True" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Notice that variable assignment is done using a single equals operator \"=\", whereas comparison between two variables is done using the double equals operator \"==\". The \"not equals\" operator is marked as \"!=\"." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Boolean operators" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The \"and\" and \"or\" boolean operators allow building complex boolean expressions, for example:" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Your name is John, and you are also 23 years old.\n", "Your name is either John or Rick.\n" ] } ], "source": [ "name = \"John\"\n", "age = 23\n", "if name == \"John\" and age == 23:\n", " print(\"Your name is John, and you are also 23 years old.\")\n", "\n", "if name == \"John\" or name == \"Rick\":\n", " print(\"Your name is either John or Rick.\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### The \"in\" operator" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The \"in\" operator could be used to check if a specified object exists within an iterable object container, such as a list:" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Your name is either John or Rick.\n" ] } ], "source": [ "name = \"John\"\n", "if name in [\"John\", \"Rick\"]:\n", " print(\"Your name is either John or Rick.\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### The \"is\" operator" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Unlike the double equals operator \"==\", the \"is\" operator does not match the values of the variables, but the instances themselves. For example:" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "True\n", "False\n" ] } ], "source": [ "x = [1,2,3]\n", "y = [1,2,3]\n", "print(x == y) # Prints out True\n", "print(x is y) # Prints out False" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### The \"not\" operator" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Using \"not\" before a boolean expression inverts it:\n", "\n" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "True\n", "False\n" ] } ], "source": [ "print(not False) # Prints out True\n", "print((not False) == (False)) # Prints out False" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Loops" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### the for loop" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "For loops iterate over a given sequence. Here is an example:\n", "\n" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2\n", "3\n", "5\n", "7\n" ] } ], "source": [ "primes = [2, 3, 5, 7]\n", "for prime in primes:\n", " print(prime)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "For loops can iterate over a sequence of numbers using the \"range\" and \"xrange\" functions. The difference between range and xrange is that the range function returns a new list with numbers of that specified range, whereas xrange returns an iterator, which is more efficient. (Python 3 uses the range function, which acts like xrange). Note that the range function is zero based." ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n", "1\n", "2\n", "3\n", "4\n", "3\n", "4\n", "5\n", "3\n", "5\n", "7\n" ] } ], "source": [ "# Prints out the numbers 0,1,2,3,4\n", "for x in range(5):\n", " print(x)\n", "\n", "# Prints out 3,4,5\n", "for x in range(3, 6):\n", " print(x)\n", "\n", "# Prints out 3,5,7\n", "for x in range(3, 8, 2):\n", " print(x)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### while loops" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n", "1\n", "2\n", "3\n", "4\n" ] } ], "source": [ "# Prints out 0,1,2,3,4\n", "\n", "count = 0\n", "while count < 5:\n", " print(count)\n", " count += 1 # This is the same as count = count + 1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### break and continue statements" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "break is used to exit a for loop or a while loop, whereas continue is used to skip the current block, and return to the \"for\" or \"while\" statement. A few examples:" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n", "1\n", "2\n", "3\n", "4\n", "1\n", "3\n", "5\n", "7\n", "9\n" ] } ], "source": [ "# Prints out 0,1,2,3,4\n", "\n", "count = 0\n", "while True:\n", " print(count)\n", " count += 1\n", " if count >= 5:\n", " break\n", "\n", "# Prints out only odd numbers - 1,3,5,7,9\n", "for x in range(10):\n", " # Check if x is even\n", " if x % 2 == 0:\n", " continue\n", " print(x)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Functions" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Functions are a convenient way to divide your code into useful blocks, allowing us to order our code, make it more readable, reuse it and save some time. Also functions are a key way to define interfaces so programmers can share their code.\n", "Functions in python are defined using the block keyword \"def\", followed with the function's name as the block's name. For example:" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [], "source": [ "def my_function():\n", " print(\"Hello From My Function!\")" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Hello From My Function!\n" ] } ], "source": [ "# Now we can call the function\n", "my_function()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's make something more interesting. Python functions also receive arguments:" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [], "source": [ "def sum_two_numbers(a, b):\n", " return a + b" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "17" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "sum_two_numbers(5,12)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Dictionaries" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A dictionary is a data type similar to arrays, but works with keys and values instead of indexes. Each value stored in a dictionary can be accessed using a key, which is any type of object (a string, a number, a list, etc.) instead of using its index to address it.\n", "\n", "For example, a database of phone numbers could be stored using a dictionary like this:" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'John': 938477566, 'Jack': 938377264, 'Jill': 947662781}\n" ] } ], "source": [ "phonebook = {}\n", "phonebook[\"John\"] = 938477566\n", "phonebook[\"Jack\"] = 938377264\n", "phonebook[\"Jill\"] = 947662781\n", "print(phonebook)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "##### Iterating over dictionaries" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Phone number of John is 938477566\n", "Phone number of Jack is 938377264\n", "Phone number of Jill is 947662781\n" ] } ], "source": [ "phonebook = {\"John\" : 938477566,\"Jack\" : 938377264,\"Jill\" : 947662781}\n", "for name, number in phonebook.items():\n", " print(\"Phone number of %s is %d\" % (name, number))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Modules and packages" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Modules in Python are simply Python files with a .py extension. They can also be packages that contain several .py files. The name of the module will be the name of the file or package. A Python module can have a set of functions, classes or variables defined and implemented." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Modules are imported using the import command. We will use the protlego module through these tutorials" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [], "source": [ "from protlego import *" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Plots using matplotlib module" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "from matplotlib.pylab import plot,title,xlabel,ylabel,grid,show,savefig,gcf\n", "import numpy as np\n", "#Optional: magic line to make plots inline\n", "%matplotlib inline\n", "\n", "x = np.arange(0,50,.5)\n", "y = np.sin(x/3) - np.cos(x/5)\n", "plot(x,y, '.-k')\n", "plot(x,np.sin(x/2) - np.cos(x/5),'.r')\n", "title('A simple double plot')\n", "xlabel('variable 1'), ylabel('variable 2'), grid(True)\n", "fig = gcf() # Get current figure\n", "show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Getting help" ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Help on function show in module matplotlib.pyplot:\n", "\n", "show(*args, **kw)\n", " Display a figure.\n", " \n", " When running in ipython with its pylab mode, display all\n", " figures and return to the ipython prompt.\n", " \n", " In non-interactive mode, display all figures and block until\n", " the figures have been closed; in interactive mode it has no\n", " effect unless figures were created prior to a change from\n", " non-interactive to interactive mode (not recommended). In\n", " that case it displays the figures but does not block.\n", " \n", " A single experimental keyword argument, *block*, may be\n", " set to True or False to override the blocking behavior\n", " described above.\n", "\n" ] } ], "source": [ "help(show)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Some exercises" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "- Sum the first 50 numbers with a for loop\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- Write a Python function to display the first and last items from a list. \n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- Write a Python function to concatenate all elements in a list into a string and return it." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "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.7" } }, "nbformat": 4, "nbformat_minor": 2 }