Python - Basics and Strings.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Basics and String"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "m4xu4gt4gIcA"
   },
   "source": [
    "## Introduction\n",
    "\n",
    "* Python is a dynamic, interpreted (bytecode-compiled) language. \n",
    "* There are no type declarations of variables, parameters, functions, or methods in source code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "1K-rPXhGfyvX",
    "outputId": "69f48af8-8a3d-4232-fa9c-51b1564bdba0"
   },
   "outputs": [],
   "source": [
    "a_number = 12\n",
    "a_string = 'hello' # Strings must be within quotations\n",
    "a_pi = 3.14"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n",
      "hello\n",
      "3.14\n"
     ]
    }
   ],
   "source": [
    "# shows how to print a string message template\n",
    "# prints variables separated by a new line\n",
    "\n",
    "print(a_number, a_string, a_pi, sep=\"\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Ct8rOXa5hULj"
   },
   "source": [
    "Let's try to mix types and see what happens"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 167
    },
    "colab_type": "code",
    "id": "UE7oZRcKgLQb",
    "outputId": "57447ef1-7fb1-4b02-e88b-450328b73015"
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-8-82ebd5d786b4>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# The below line will raise a 'TypeError'\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0ma_number\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0ma_string\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "# The below line will raise a 'TypeError'\n",
    "a_number + a_string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "sChVqABUhlcB"
   },
   "source": [
    "Since we do not declare types, runtime checks for types and does not allow invalid operations. `TypeError` is a type of expection, we will comeback to it when we learn about exception handling\n",
    "\n",
    "## Python source code\n",
    "\n",
    "* Python source files use the `.py` extension and are called `modules`. \n",
    "* With a Python module `hello.py`, the easiest way to run it is with the shell command `python hello.py Alice` which calls the Python interpreter to execute the code in `hello.py`, passing it the command line argument `Alice`.\n",
    "* Here we will use an notebook to learn the basics of python. Notebooks provide an easy way to play with the python interpreter. Later we will create python files in exercises.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "MM-Hmfc4i-Ie"
   },
   "source": [
    "## Importing modules and packages\n",
    "\n",
    "- To import a python module we use the `import` statement\n",
    "- We will import the `os` builtin module and print the current working directory\n",
    "- [Python documentation](https://docs.python.org/3/) provides the language reference \n",
    "- Reference to [OS module](https://docs.python.org/3/library/os.html?highlight=os#module-os)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "5QWCkJvEhebt",
    "outputId": "deafd41e-8107-491b-ce2f-802d14713cc4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current Working Directory - d:\\Users\\Krishna_Alagiri\\projects\\Misc\\CBSE-Computer-Science\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "\n",
    "curr_working_dir = os.getcwd()\n",
    "print(\"Current Working Directory -\", curr_working_dir)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "n4p5eXaOr207"
   },
   "source": [
    "* `from` keyword can be used to import specific item within a module\n",
    "* item could be a variable, sub-module or a function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "collapsed": true,
    "id": "k9fZoDPnj9xJ"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.7.9 (tags/v3.7.9:13c94747c7, Aug 17 2020, 18:58:18) [MSC v.1900 64 bit (AMD64)]\n"
     ]
    }
   ],
   "source": [
    "from sys import version\n",
    "print(version)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We're using `python3` for learning python. You don't have to worry about the `os` and `sys` right now."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "WHBkEj6cskrj"
   },
   "source": [
    "## User defined functions\n",
    "\n",
    "- A function is a set of statements that take inputs, do some specific computation and produce output. \n",
    "- The idea is to put some commonly or repeatedly done tasks together and make a function so that instead of writing the same code again and again for different inputs, we can call the function.\n",
    "- Let's write a simple function to greet the user"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `greet_user()` function accepts a variable `username` as argument/input and it prints a message.\n",
    "- `format()` function used inside print function,is a predefined function used to replace `{}` with a data. Thats' why you see `John Doe` in the place of `{}` in the output string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "tkECQoz3sDvJ"
   },
   "outputs": [],
   "source": [
    "def greet_user(username):\n",
    "  print(\"Hello {}. You're Awesome!\".format(user))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "bjuDt-KztIW1",
    "outputId": "3a2b79e4-425f-4b50-83f8-6c8f20e8531c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello John Doe. You're Awesome!\n"
     ]
    }
   ],
   "source": [
    "greet_user('John Doe')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Q8MFDh7ktaJp"
   },
   "source": [
    "## Indentation\n",
    "\n",
    "* Whitespace indentation of a piece of code affects its meaning. \n",
    "* A logical block of statements such as the ones that make up a function should all have the same indentation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "IggqLbmPuCCj"
   },
   "source": [
    "## Python Strings\n",
    "\n",
    "* `Strings` are just like Arrays. Like many other popular programming languages, strings in Python are arrays of bytes representing unicode characters.\n",
    "* The len(string) function returns the length of a string.\n",
    "* Characters in a string can be accessed using the standard `[ ]` syntax, and like Java and C++, Python uses zero-based indexing, so if `s` is `'hello'` `s[1]` is `'e'`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 69
    },
    "colab_type": "code",
    "id": "ob7mf3nDtKzi",
    "outputId": "66232b56-7364-4704-b964-ef61292e7a31"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i\n",
      "2\n",
      "Hi there\n"
     ]
    }
   ],
   "source": [
    "s = 'Hi'\n",
    "print(s[1])         # Returns the second character\n",
    "print(len(s))        # Finds length of the string variable.\n",
    "print(s + ' there')  # Concatenates value stored in variable `s` and ' there'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "ly3zXz1punzA",
    "outputId": "5ee7c270-1f22-4a32-e078-4e581896930c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value of pi is 3.14\n"
     ]
    }
   ],
   "source": [
    "pi = 3.14\n",
    "\n",
    "# The below line will raise an exception/error.\n",
    "# You cannot concatenate sting and float\n",
    "# text = 'The value of pi is ' + pi\n",
    "\n",
    "# You can do it by converting float to string by using str()\n",
    "text = 'The value of pi is '  + str(pi)\n",
    "print(text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "nkjfqYm4vhru"
   },
   "source": [
    "# String methods\n",
    "- Python has a built-in string class named \"str\" with many handy features.\n",
    "- **Documentation**: https://docs.python.org/3/library/stdtypes.html#string-methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "lfNNM885vagl",
    "outputId": "4796a354-46b4-4a1c-9349-7f444fefb777"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'the value of pi is 3.14'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Return a copy of the string with all the cased characters converted to lowercase. \n",
    "text.lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "2VMR0BAhveTH",
    "outputId": "265af1d2-ec76-43e0-c1df-edcba36b6a40"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'THE VALUE OF PI IS 3.14'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Return a copy of the string with all the cased characters converted to uppercase.\n",
    "text.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "A4R2GTDHu6u7",
    "outputId": "4dcded1d-0027-4a06-c8b5-ecb76102a0ee"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Return True if all characters in the string are alphabetic and there is at least one character, \n",
    "# False otherwise.\n",
    "text.isalpha()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "djfgeLpSu9nn",
    "outputId": "1f7e848a-7702-40ee-b0e9-2468dcd0919f"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Return True if all characters in the string are numeric characters, and there is at least one character, \n",
    "# False otherwise.\n",
    "text.isnumeric()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "M4S1IQ0PvAiw",
    "outputId": "60ca5a08-4eb1-4a0a-eed7-18ea3ef88e5d"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Return True if string starts with the prefix, otherwise return False. \n",
    "text.startswith('T')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "ApEW-cIUvC7N",
    "outputId": "3e85cfd6-a820-41eb-d0e2-7a2ed4b52342"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Returns True if the text contains a substring, otherwise return False. \n",
    "# The below will return True since 'pi' is substring of text.\n",
    "\n",
    "'pi' in text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "0zxIHZf_wLqD",
    "outputId": "64d8f101-ef13-452d-9e4b-c53e63ba5c90"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Return the lowest index in the string where substring sub is found.\n",
    "# Returns -1 if not found.\n",
    "text.find('pizza')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "WDwwH-hnRpgk",
    "outputId": "05cab35f-bf8d-49ea-c9b2-1cb5e77c1b7e"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['abc', 'ced', 'def', 'hij']"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "csv = \"abc,ced,def,hij\"\n",
    "\n",
    "# Return a list of the words in the string, using `sep` (argument) as the delimiter string.\n",
    "csv.split(\",\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "_uFjp64ivveU"
   },
   "source": [
    "##  Conditonal Statements\n",
    "> `IF...ELIF...ELSE` Statements\n",
    "\n",
    "The syntax of the `if...else` statement is −\n",
    "```\n",
    "if expression:\n",
    "   statement(s)\n",
    "else:\n",
    "   statement(s)\n",
    "```\n",
    "\n",
    "Similar to the `else`, the `elif` statement is optional. However, unlike `else`, for which there can be at most one statement, there can be an arbitrary number of `elif` statements following an `if`.\n",
    "\n",
    "The syntax of the `if..elif..else` statement is −\n",
    "```\n",
    "if expression1:\n",
    "   statement(s)\n",
    "elif expression2:\n",
    "   statement(s)\n",
    "elif expression3:\n",
    "   statement(s)\n",
    "else:\n",
    "   statement(s)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 52
    },
    "colab_type": "code",
    "id": "BQHa4yHDvHDX",
    "outputId": "93d25507-4593-435e-d1bf-c5f15e226b04"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Text contains the substring 'pi'\n",
      "13\n"
     ]
    }
   ],
   "source": [
    "if 'pi' in text.lower():\n",
    "  print(\"Text contains the substring 'pi'\")\n",
    "  pi_index = text.find('pi')\n",
    "  print(pi_index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "UippAYsT5A7D",
    "outputId": "9a5f4522-8f2e-43c3-b75e-d88e5bdae0ca"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Text contains the substring 'pi'\n"
     ]
    }
   ],
   "source": [
    "if 4 < 3:\n",
    "  # pass is a command to do nothing\n",
    "  pass \n",
    "elif 'pi' in text.lower():\n",
    "  print('Text contains the substring \\'pi\\'')\n",
    "else:\n",
    "  pass"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "name": "Python Basics and Strings",
   "provenance": [],
   "version": "0.3.2"
  },
  "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}