Getting Started with Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python-Writing Your First Python Code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Welcome!** This notebook will teach you the basics of the Python programming language. Although the information presented here is quite basic, it is an important foundation that will help you read and write Python code. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Table of Contents</h2>\n",
    "<div class=\"alert alert-block alert-info\" style=\"margin-top: 20px\">\n",
    "    <ul>\n",
    "        <li>\n",
    "            <a href=\"#hello\">Say \"Hello\" to the world in Python</a>\n",
    "            <ul>\n",
    "                <li><a href=\"version\">What version of Python are we using?</a></li>\n",
    "                <li><a href=\"comments\">Writing comments in Python</a></li>\n",
    "                <li><a href=\"errors\">Errors in Python</a></li>\n",
    "                <li><a href=\"python_error\">Does Python know about your error before it runs your code?</a></li>\n",
    "           </ul>\n",
    "        </li>\n",
    "        <li>\n",
    "            <a href=\"#types_objects\">Types of objects in Python</a>\n",
    "            <ul>\n",
    "                <li><a href=\"int\">Integers</a></li>\n",
    "                <li><a href=\"float\">Floats</a></li>\n",
    "                <li><a href=\"convert\">Converting from one object type to a different object type</a></li>\n",
    "                <li><a href=\"bool\">Boolean data type</a></li>\n",
    "            </ul>\n",
    "        </li>\n",
    "        <li>\n",
    "            <a href=\"#expressions\">Expressions and Variables</a>\n",
    "            <ul>\n",
    "                <li><a href=\"exp\">Expressions</a></li>\n",
    "                <li><a href=\"var\">Variables</a></li>\n",
    "            </ul>\n",
    "        </li>\n",
    "    </ul>\n",
    "    <p>\n",
    "        Estimated time needed: <strong>25 min</strong>\n",
    "    </p>\n",
    "</div>\n",
    "\n",
    "<hr>\n",
    "<h2 id=\"hello\">Say \"Hello\" to the world in python</h2>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Try your first Python output\n",
    "\n",
    "print('Hello, Python!')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After executing the cell above, you should see that Python prints Hello, Python!. Congratulations on running your first Python code!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What version of Python are we using?\n",
    "There are two popular versions of the Python programming language in use today: Python 2 and Python 3. The Python community has decided to move on from Python 2 to Python 3, and many popular libraries have announced that they will no longer support Python 2.\n",
    "\n",
    "Since Python 3 is the future, in this course we will be using it exclusively. How do we know that our notebook is executed by a Python 3 runtime? We can look in the top-right hand corner of this notebook and see \"Python 3\".\n",
    "\n",
    "We can also ask directly Python and obtain a detailed answer. Try executing the following code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Check the Python Version\n",
    "\n",
    "import sys\n",
    "print(sys.version)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Writing comments in Python\n",
    "In addition to writing code, note that it's always a good idea to add comments to your code. It will help others understand what you were trying to accomplish (the reason why you wrote a given snippet of code). Not only does this help other people understand your code, it can also serve as a reminder to you when you come back to it weeks or months later.\n",
    "\n",
    "To write comments in Python, use the number symbol # before writing your comment. When you run your code, Python will ignore everything past the # on a given line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Practice on writing comments\n",
    "\n",
    "print('Hello, Python!') # This line prints a string\n",
    "# print('Hi')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After executing the cell above, you should notice that This line prints a string did not appear in the output, because it was a comment (and thus ignored by Python).\n",
    "\n",
    "The second line was also not executed because print('Hi') was preceded by the number sign (#) as well!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Errors in Python\n",
    "Everyone makes mistakes. For many types of mistakes, Python will tell you that you have made a mistake by giving you an error message. It is important to read error messages carefully to really understand where you made a mistake and how you may go about correcting it.\n",
    "\n",
    "For example, if you spell print as frint, Python will display an error message. Give it a try:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print string as error message\n",
    "\n",
    "frint(\"Hello, Python!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The error message tells you:\n",
    "\n",
    "1. where the error occurred (more useful in large notebook cells or scripts), and\n",
    "2. what kind of error it was (NameError)\n",
    "\n",
    "Here, Python attempted to run the function frint, but could not determine what frint is since it's not a built-in function and it has not been previously defined by us either."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Does Python know about your error before it runs your code?\n",
    "Python is what is called an interpreted language. Compiled languages examine your entire program at compile time, and are able to warn you about a whole class of errors prior to execution. In contrast, Python interprets your script line by line as it executes it. Python will stop executing the entire program when it encounters an error (unless the error is expected and handled by the programmer, a more advanced subject that we'll cover later on in this course).\n",
    "\n",
    "Try to run the code in the cell below and see what happens:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print string and error to see the running order\n",
    "\n",
    "print(\"This will be printed\")\n",
    "frint(\"This will cause an error\")\n",
    "print(\"This will NOT be printed\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Types of objects in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Python is an object-oriented language. There are many different types of objects in Python. Let's start with the most common object types: strings, integers and floats. Anytime you write words (text) in Python, you're using character strings (strings for short). The most common numbers, on the other hand, are integers (e.g. -1, 0, 100) and floats, which represent real numbers (e.g. 3.14, -42.0)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Chapter%201/Images/TypesObjects.png\" width=\"500\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Integer\n",
    "\n",
    "11\n",
    "# Float\n",
    "\n",
    "2.14\n",
    "# String\n",
    "\n",
    "\"Hello, Python 101!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> You can get Python to tell you the type of an expression by using the built-in type() function. You'll notice that Python refers to integers as int, floats as float, and character strings as str."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Type of 12\n",
    "\n",
    "type(12)\n",
    "# Type of 2.14\n",
    "\n",
    "type(2.14)\n",
    "# Type of \"Hello, Python 101!\"\n",
    "\n",
    "type(\"Hello, Python 101!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Integers\n",
    "\n",
    "Here are some examples of integers. Integers can be negative or positive numbers:\n",
    "\n",
    "<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Chapter%201/Images/TypesInt.png\" width=\"500\">\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Floats\n",
    "\n",
    "Floats represent real numbers; they are a superset of integer numbers but also include \"numbers with decimals\". There are some limitations when it comes to machines representing real numbers, but floating point numbers are a good representation in most cases. You can learn more about the specifics of floats for your runtime environment, by checking the value of <code>sys.float_info</code>. This will also tell you what's the largest and smallest number that can be represented with them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# System settings about float type\n",
    "import sys\n",
    "sys.float_info"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Converting from one object type to a different object type\n",
    "\n",
    "You can change the type of the object in Python; this is called typecasting. For example, you can convert an integer into a float (e.g. 2 to 2.0).\n",
    "\n",
    "Let's try it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert 2 to a float\n",
    "\n",
    "float(2)\n",
    "# Convert integer 2 to a float and check its type\n",
    "\n",
    "type(float(2))\n",
    "# Casting 1.1 to integer will result in loss of information\n",
    "\n",
    "int(1.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Converting from strings to integers or floats\n",
    "\n",
    "Sometimes, we can have a string that contains a number within it. If this is the case, we can cast that string that represents a number into an integer using int():"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert a string into an integer\n",
    "\n",
    "int('1')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But if you try to do so with a string that is not a perfect match for a number, you'll get an error. Try the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert a string into an integer with error\n",
    "\n",
    "int('1 or 2 people')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert a float to a string\n",
    "\n",
    "str(1.2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Boolean Type\n",
    "\n",
    "Boolean is another important type in Python. An object of type Boolean can take on one of two values: True or False:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Value true\n",
    "\n",
    "True\n",
    "\n",
    "# Value false\n",
    "\n",
    "False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you ask Python to display the type of a boolean object it will show bool which stands for boolean:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Type of True\n",
    "\n",
    "type(True)\n",
    "# Type of False\n",
    "\n",
    "type(False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can cast boolean objects to other data types. If we cast a boolean with a value of True to an integer or float we will get a one. If we cast a boolean with a value of False to an integer or float we will get a zero. Similarly, if we cast a 1 to a Boolean, you get a True. And if we cast a 0 to a Boolean we will get a False. Let's give it a try:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert True to int\n",
    "\n",
    "int(True)\n",
    "# Convert 1 to boolean\n",
    "\n",
    "bool(1)\n",
    "# Convert 0 to boolean\n",
    "\n",
    "bool(0)\n",
    "# Convert True to float\n",
    "\n",
    "float(True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Expressions and Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Expressions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Expressions in Python can include operations among compatible types (e.g., integers and floats). For example, basic arithmetic operations like adding multiple numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Addition operation expression\n",
    "\n",
    "100 + 13 + 23 + 104\n",
    "\n",
    "# Subtraction operation expression\n",
    "\n",
    "50 - 60\n",
    "\n",
    "# Multiplication operation expression\n",
    "\n",
    "5 * 5\n",
    "\n",
    "# Division operation expression\n",
    "\n",
    "25 / 5\n",
    "\n",
    "# Integer division operation expression\n",
    "\n",
    "25 // 6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variables\n",
    "\n",
    "Just like with most programming languages, we can store values in variables, so we can use them later on. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Store value into variable\n",
    "\n",
    "x=100 + 13 + 23 + 104\n",
    "#To see the value of x in a Notebook, we can simply place it on the last line of a cell:\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also perform operations on <code>x</code> and save the result to a new variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use another variable to store the result of the operation between variable and value\n",
    "\n",
    "y = x / 60\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's a good practice to use meaningful variable names, so you and others can read the code and understand it more easily:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Name the variables meaningfully\n",
    "\n",
    "total_min = 43 + 42 + 57 # Total length of albums in minutes\n",
    "total_min\n",
    "\n",
    "# Name the variables meaningfully\n",
    "\n",
    "total_hours = total_min / 60 # Total length of albums in hours \n",
    "total_hours"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Good to Go!\n",
    "Congratulations, you have completed your first lesson and hands-on lab in Python. "
   ]
  },
  {
   "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.8.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}