![\"Python\"](\"images/python-logo.png\"){kind=logo}
\n",
+ "\n",
+ "\n",
+ "Python is a\n",
+ "\n",
+ "- general purpose programming language\n",
+ "- interpreted, not compiled\n",
+ "- both **dynamically typed** _and_ **strongly typed**\n",
+ "- supports multiple programming paradigms: object oriented, functional\n",
+ "- comes in 2 main versions in use today: 2.7 and 3.x\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "\n",
+ "## Python's Interactive Console : The Interpreter\n",
+ "\n",
+ "***\n",
+ "- The Python interpreter is a console that allows interactive development\n",
+ "- We are currently using the Jupyter notebook, which uses an advanced Python interpreter called IPython\n",
+ "- This gives us much more power and flexibility\n",
+ "\n",
+ "**Let's try it out !**\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Hello Data World!\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"Hello Data World!\") #As usual with any language we start with with the print function"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# What are we going to learn today?\n",
+ "***\n",
+ "- CHAPTER 1 - **Python Basics**\n",
+ " - **Strings**\n",
+ " - Creating a String, variable assignments\n",
+ " - String Indexing & Slicing\n",
+ " - String Concatenation & Repetition\n",
+ " - Basic Built-in String Methods\n",
+ " - **Numbers**\n",
+ " - Types of Numbers\n",
+ " - Basic Arithmetic\n",
+ " \n",
+ "\n",
+ "\n",
+ "- CHAPTER 2 - **Data Types & Data Structures**\n",
+ " - Lists\n",
+ " - Dictionaries\n",
+ " - Sets & Booleans\n",
+ "\n",
+ "\n",
+ "- CHAPTER 3 - **Python Programming Constructs**\n",
+ " - Loops & Iterative Statements\n",
+ " - if,elif,else statements\n",
+ " - for loops, while loops\n",
+ " - Comprehensions\n",
+ " - Exception Handling\n",
+ " - Modules, Packages, \n",
+ " - File I/O operations\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#Your turn print = \"Hello Data Science World!\"\n",
+ "print(\"Hello Data Science World!\")\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Double-click __here__ for the solution.\n",
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# CHAPTER - 1 : Python Basics\n",
+ "***\n",
+ "Let's understand \n",
+ "- Basic data types\n",
+ "- Variables and Scoping\n",
+ "- Modules, Packages and the **`import`** statement\n",
+ "- Operators\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "![\"Concept-Alert\"](\"images/python_string.png\")
\n",
+ "![\"Concept-Alert\"](\"images/variable.png\")
\n",
+ "![\"Concept-Alert\"](\"images/indexing.png\")
\n",
+ "![\"Concept-Alert\"](\"images/string_concat.png\")
\n",
+ "![\"Concept-Alert\"](\"images/string-slicing-in-python.png\")
\n",
+ "![\"Concept-Alert\"](\"images/numbers.png\")
\n",
+ "\n", + "Having worked with string we will turn our attention to numbers\n", + "We'll learn about the following topics:\n", + "\n", + " 1.) Types of Numbers in Python\n", + " 2.) Basic Arithmetic\n", + " 3.) Object Assignment in Python" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Types of numbers\n", + "***\n", + "Python has various \"types\" of numbers (numeric literals). We'll mainly focus on integers and floating point numbers.\n", + "\n", + "Integers are just whole numbers, positive or negative. For example: 2 and -2 are examples of integers.\n", + "\n", + "Floating point numbers in Python are notable because they have a decimal point in them, or use an exponential (e) to define the number. For example 2.0 and -2.1 are examples of floating point numbers. 4E2 (4 times 10 to the power of 2) is also an example of a floating point number in Python.\n", + "\n", + "Throughout this course we will be mainly working with integers or simple float number types.\n", + "\n", + "Here is a table of the two main types we will spend most of our time working with some examples:\n", + "\n", + "
| Examples | \n", + "Number \"Type\" | \n", + "
|---|---|
| 1,2,-5,1000 | \n", + "Integers | \n", + "
| 1.2,-0.5,2e2,3E2 | \n", + "Floating-point numbers | \n", + "
![\"Concept-Alert\"](\"images/py.png\")
\n",
+ "\n", + "\n", + "# CHAPTER - 2 : Data Types & Data Structures\n", + "***\n", + "- Everything in Python is an \"object\", including integers/floats\n", + "- Most common and important types (classes)\n", + " - \"Single value\": None, int, float, bool, str, complex\n", + " - \"Multiple values\": list, tuple, set, dict\n", + "\n", + "
![\"Concept-Alert\"](\"images/datatypes.png\")
\n",
+ "\n", + "\n", + "- Single/Multiple isn't a real distinction, this is for explanation\n", + "- There are many others, but these are most frequently used" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Identifying Data Types\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2017-09-25T05:47:32.052311Z", + "start_time": "2017-09-25T05:47:32.041864Z" + }, + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "
![\"Concept-Alert\"](\"images/python-list.jpeg\")
\n",
+ "\n", + "\n", + "Lists are constructed with brackets [] and commas separating every element in the list.\n", + "\n", + "Let's go ahead and see how we can construct lists!" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Assign a list to an variable named my_list\n", + "my_list = [1,2,3]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We just created a list of integers, but lists can actually hold different object types. For example:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "my_list = [1,2,3,4,5,6,7]" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[1, 2, 3, 4, 5, 6, 7]" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_list" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Just like strings, the len() function will tell you how many items are in the sequence of the list." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "7" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(my_list)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Create a list which includes a numbers, floating point, strings and character" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Double-click __here__ for the solution.\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "### Adding New Elements to a list\n", + "***\n", + "We use two special commands to add new elements to a list. Let's make a new list to remind ourselves of how this works:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "my_list = ['one','two','three',4,5]" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['one', 'two', 'three', 4, 5]" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_list" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "my_list.append(\"six\")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['one', 'two', 'three', 4, 5, 'six']" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_list" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 2.3, ['a', 'b'], 'New York', 3.1]\n" + ] + } + ], + "source": [ + "# append a value to the end of the list\n", + "l = [1, 2.3, ['a', 'b'], 'New York']\n", + "l.append(3.1)\n", + "print(l)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "l = [1, 2, 3]" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "ename": "IndexError", + "evalue": "list index out of range", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/var/folders/0n/nb074wzd4kl1nmdvkbdnpgym0000gn/T/ipykernel_27358/1388274891.py\u001b[0m in \u001b[0;36m
**Other `list` operations**
\n",
+ "\n",
+ "***\n",
+ "- **`.append`**: add element to end of list\n",
+ "- **`.insert`**: insert element at given index\n",
+ "- **`.extend`**: extend one list with another list"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Mini Challenge\n",
+ "***\n",
+ "Now that you have understood how to access elements in a list. Can you access the last element of l which is a list and find the last element of that list."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "l = [1, 2.3, ['a', 'b'], 'New York']"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#print Last element of the list\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Double-click __here__ for the solution.\n",
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "\n",
+ "# Dictionaries\n",
+ "***\n",
+ "Now we're going to switch gears and learn about *mappings* called *dictionaries* in Python. If you're familiar with other languages you can think of these Dictionaries as hash tables. \n",
+ "\n",
+ "This section will serve as a brief introduction to dictionaries and consist of:\n",
+ "\n",
+ " 1.) Constructing a Dictionary\n",
+ " 2.) Accessing objects from a dictionary\n",
+ " 3.) Nesting Dictionaries\n",
+ " 4.) Basic Dictionary Methods\n",
+ "\n",
+ "![\"Concept-Alert\"](\"images/dictionaries-in-python.jpeg\")
\n",
+ "\n", + "\n", + "A Python dictionary consists of a key and then an associated value. That value can be almost any Python object.\n", + "\n", + "\n", + "## Constructing a Dictionary\n", + "Let's see how we can construct dictionaries to get a better understanding of how they work!" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [], + "source": [ + "# Make a dictionary with {} and : to signify a key and a value\n", + "my_dict = {'key1':'value1','key2':'value2'} " + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'key1': 'value1', 'key2': 'value2'}\n" + ] + } + ], + "source": [ + "print(my_dict)" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'value2'" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Call values by their key\n", + "my_dict['key2']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can effect the values of a key as well. For instance:" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'key1': 123, 'key2': 'value2'}" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_dict['key1']=123\n", + "my_dict\n" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_dict['key1'] - 123" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [], + "source": [ + "# Subtract 123 from the value\n", + "my_dict['key1'] = my_dict['key1'] - 123" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Check\n", + "my_dict['key1']" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'key1': 0, 'key2': 'value2'}" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_dict" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [], + "source": [ + "my_new_dict = {'name': [\"darshil\", 'jac', 'rahul'], \"surname\": [\"parmar\",'asd','asdas'], \"age\": [25,26,27]}" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'rahul'" + ] + }, + "execution_count": 66, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_new_dict['name'][-1]" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [], + "source": [ + "my_new_dict['country'] = ['india', 'us', 'india']" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'name': ['darshil', 'jac', 'rahul'],\n", + " 'surname': ['parmar', 'asd', 'asdas'],\n", + " 'age': [25, 26, 27],\n", + " 'country': ['india', 'us', 'india']}" + ] + }, + "execution_count": 71, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_new_dict" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A quick note, Python has a built-in method of doing a self subtraction or addition (or multiplication or division). We could have also used += or -= for the above statement. For example:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "my_dict['key1'] = my_dict['key1'] + 123" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "246" + ] + }, + "execution_count": 69, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Set the object equal to itself minus 123 \n", + "my_dict['key1'] += 123\n", + "my_dict['key1']" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now its your turn to get hands-on with Dictionary, create a empty dicts. Create a new key calle animal and assign a value 'Dog' to it..\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Create a new dictionary\n", + "d = {}\n", + "# Create a new key through assignment\n", + "d['animal'] = 'Dog'" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2017-09-25T05:47:45.662927Z", + "start_time": "2017-09-25T05:47:45.654794Z" + }, + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "# Set and Booleans\n", + "***\n", + "There are two other object types in Python that we should quickly cover. Sets and Booleans. \n", + "\n", + "## Sets\n", + "\n", + "Sets are an unordered collection of *unique* elements. We can construct them by using the set() function. Let's go ahead and make a set to see how it works" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "#### Set Theory\n", + "
![](\"images/sets2.png\")
"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 72,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "l = [1,1,1,1,1,2,3,3,3]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 73,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[1, 1, 1, 1, 1, 2, 3, 3, 3]"
+ ]
+ },
+ "execution_count": 73,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "l"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 74,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "l_sets = set(l)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 75,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "{1, 2, 3}"
+ ]
+ },
+ "execution_count": 75,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "l_sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 76,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "{1}"
+ ]
+ },
+ "execution_count": 76,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x = set()\n",
+ "\n",
+ "# We add to sets with the add() method\n",
+ "x.add(1)\n",
+ "\n",
+ "#Show\n",
+ "x"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 77,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x.add(2)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 81,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "{1, 2}"
+ ]
+ },
+ "execution_count": 81,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Note the curly brackets. This does not indicate a dictionary! Although you can draw analogies as a set being a dictionary with only keys.\n",
+ "\n",
+ "We know that a set has only unique entries. So what happens when we try to add something that is already in a set?"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 82,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "{1, 2}"
+ ]
+ },
+ "execution_count": 82,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# Add a different element\n",
+ "x.add(2)\n",
+ "\n",
+ "#Show\n",
+ "x"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 94,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "{1, 2, 3}"
+ ]
+ },
+ "execution_count": 94,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# Try to add the same element\n",
+ "x.add(3)\n",
+ "\n",
+ "#Show\n",
+ "x"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 86,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#Try adding 2 to x\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Double-click __here__ for the solution.\n",
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Notice how it won't place another 1 there. That's because a set is only concerned with unique elements! We can cast a list with multiple repeat elements to a set to get the unique elements. For example:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 95,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Create a list with repeats\n",
+ "l = [1,1,2,2,3,4,5,6,1,1]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 107,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "{1, 2, 3, 4, 5, 6}"
+ ]
+ },
+ "execution_count": 107,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# Cast as set to get unique values\n",
+ "set(l)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "# Python Tuples\n",
+ "***\n",
+ "Tuples are used to store multiple items in a single variable.\n",
+ "\n",
+ "Tuple is one of 4 built-in data types in Python used to store collections of data, the other 3 are List, Set, and Dictionary, all with different qualities and usage.\n",
+ "\n",
+ "A tuple is a collection which is ordered and unchangeable.\n",
+ "\n",
+ "Tuples are written with round brackets."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 98,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "subslide"
+ }
+ },
+ "source": [
+ "\n",
+ "# Python Programming Constructs\n",
+ "***\n",
+ "We'll be talking about\n",
+ "- Conditional Statements\n",
+ "- Looping\n",
+ "- Comprehensions"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# If,elif,else Statements\n",
+ "\n",
+ "if Statements in Python allows us to tell the computer to perform alternative actions based on a certain set of results.\n",
+ "\n",
+ "Verbally, we can imagine we are telling the computer:\n",
+ "\n",
+ "\"Hey if this case happens, perform some action\"\n",
+ "\n",
+ "We can then expand the idea further with elif and else statements, which allow us to tell the computer:\n",
+ "\n",
+ "\"Hey if this case happens, perform some action. Else if another case happens, perform some other action. Else-- none of the above cases happened, perform this action\"\n",
+ "\n",
+ "![](\"images/python-if-else.png\")
\n",
+ "\n",
+ "Let's go ahead and look at the syntax format for if statements to get a better idea of this:\n",
+ "\n",
+ " if case1:\n",
+ " perform action1\n",
+ " elif case2:\n",
+ " perform action2\n",
+ " else: \n",
+ " perform action 3"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 126,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "a = 4\n",
+ "b = 2"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 123,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False"
+ ]
+ },
+ "execution_count": 123,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "a > b"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "if a > b {\n",
+ " asdasd\n",
+ " \n",
+ "}\n",
+ "else{\n",
+ " asdasd\n",
+ " \n",
+ "}"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 127,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "a is greater than b\n"
+ ]
+ }
+ ],
+ "source": [
+ "if a > b:\n",
+ " print(\"a is greater than b\")\n",
+ "elif b > a:\n",
+ " print(\"b is greater than a\")\n",
+ "else:\n",
+ " print(\"a and b are equal\")\n",
+ " print(\"asdas\")\n",
+ " \n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 128,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2017-09-25T05:49:17.584649Z",
+ "start_time": "2017-09-25T05:49:17.562599Z"
+ },
+ "slideshow": {
+ "slide_type": "fragment"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "a is greater than b\n"
+ ]
+ }
+ ],
+ "source": [
+ "a = 6\n",
+ "b = 2\n",
+ "\n",
+ "if a > b:\n",
+ " print(\"a is greater than b\")\n",
+ "elif b > a:\n",
+ " # we are inside the elif block\n",
+ " print(\"b is greater than a\")\n",
+ "else:\n",
+ " # we are inside the else block\n",
+ " print(\"a and b are equal\")\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Indentation\n",
+ "***\n",
+ "It is important to keep a good understanding of how indentation works in Python to maintain the structure and order of your code. We will touch on this topic again when we start building out functions!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# For Loops\n",
+ "***\n",
+ "A **for** loop acts as an iterator in Python, it goes through items that are in a *sequence* or any other iterable item. Objects that we've learned about that we can iterate over include strings,lists,tuples, and even built in iterables for dictionaries, such as the keys or values.\n",
+ "\n",
+ "We've already seen the **for** statement a little bit in past lectures but now lets formalize our understanding.\n",
+ "\n",
+ "Here's the general format for a **for** loop in Python:\n",
+ "\n",
+ " for item in object:\n",
+ " statements to do stuff\n",
+ " \n",
+ "![](\"images/forloop.jpeg\")
\n",
+ "\n",
+ "The variable name used for the item is completely up to the coder, so use your best judgment for choosing a name that makes sense and you will be able to understand when revisiting your code. This item name can then be referenced inside you loop, for example if you wanted to use if statements to perform checks.\n",
+ "\n",
+ "Let's go ahead and work through several example of **for** loops using a variety of data object types.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 134,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "users = list(range(10))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 135,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
+ ]
+ },
+ "execution_count": 135,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "users"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 136,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "This is my 0 user\n",
+ "This is my 1 user\n",
+ "This is my 2 user\n",
+ "This is my 3 user\n",
+ "This is my 4 user\n",
+ "This is my 5 user\n",
+ "This is my 6 user\n",
+ "This is my 7 user\n",
+ "This is my 8 user\n",
+ "This is my 9 user\n"
+ ]
+ }
+ ],
+ "source": [
+ "for user in users:\n",
+ " print(f\"This is my {user} user\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 140,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "0"
+ ]
+ },
+ "execution_count": 140,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "27 % 9 "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 142,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "This is an even number 2\n",
+ "This is an even number 4\n",
+ "This is an odd number 5\n",
+ "This is an even number 6\n",
+ "This is an even number 8\n",
+ "This is an odd number 7\n",
+ "This is an odd number 9\n",
+ "This is an even number 10\n"
+ ]
+ }
+ ],
+ "source": [
+ "#Simple program to find the even numbers in a list\n",
+ "\n",
+ "list_1 = [2,4,5,6,8,7,9,10] # Initialised the list\n",
+ "\n",
+ "for number in list_1: # Selects one element in list_1 \n",
+ " if number % 2 == 0: # Checks if it is even. IF even, only then goes to next step else performs above step and continues iteration\n",
+ " print(f\"This is an even number {number}\") # prints no if even. end=' ' prints the nos on the same line with a space in between. Try deleting this command & seeing the difference.\n",
+ " else:\n",
+ " print(f\"This is an odd number {number}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now its time for you to code again can you create a list of 10 numbers iterate through the list and print the square of each number."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#Write your \"for_loop\" and print all elements\n",
+ "list_1 = [2,4,5,6,8,7,9,10]\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Double-click __here__ for the solution.\n",
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "# While loops\n",
+ "***\n",
+ "The **while** statement in Python is one of most general ways to perform iteration. A **while** statement will repeatedly execute a single statement or group of statements as long as the condition is true. The reason it is called a 'loop' is because the code statements are looped through over and over again until the condition is no longer met.\n",
+ "\n",
+ "The general format of a while loop is:\n",
+ "\n",
+ " while test:\n",
+ " code statement\n",
+ " else:\n",
+ " final code statements\n",
+ " \n",
+ "![](\"images/whileloop.png\")
\n",
+ "\n", + "\n", + "\n", + "Let’s look at a few simple while loops in action. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 147, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "x is currently: 11 x is still less than 10, adding 1 to x\n" + ] + } + ], + "source": [ + "x = 11\n", + "\n", + "while x > 10:\n", + " print ('x is currently: ',x,end=' ') #end=' ' to put print below statement on the same line after thsi statement\n", + " print (' x is still less than 10, adding 1 to x')\n", + " x = x - 1 # this adds 1 to x " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "
\n",
+ "\n", + "\n", + "## Modules, Packages, and `import`\n", + "***\n", + "A module is a collection of functions and variables that have been bundled together in a single file. Module helps us: \n", + "- Used for code organization, packaging and reusability\n", + "- Module: A Python file\n", + "- Package: A folder with an ``__init__.py`` file\n", + "- Namespace is based on file's directory path\n", + "\n", + "Module's are usually organised around a theme. Let's see how to use a module. To access our module we will import it using python's import statement. Math module provides access to the mathematical functions. " + ] + }, + { + "cell_type": "code", + "execution_count": 149, + "metadata": { + "ExecuteTime": { + "end_time": "2017-09-25T05:46:46.840463Z", + "start_time": "2017-09-25T05:46:46.832495Z" + }, + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "8.0" + ] + }, + "execution_count": 149, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# import the math module\n", + "import math\n", + "\n", + "# use the log10 function in the math module\n", + "math.pow(2,3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
\n",
+ "\n", + "\n", + "### Mini Challenges\n", + "***\n", + "Can you compute the square of a 3 assigned to a variable a using the math module?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#wite your code\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Double-click __here__ for the solution.\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2017-09-19T10:03:27.500870Z", + "start_time": "2017-09-19T10:03:27.495827Z" + }, + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "## Comprehensions\n", + "***\n", + "- Python provides syntactic sugar to write small loops to generate lists/sets/tuples/dicts in one line\n", + "- These are called comprehensions, and can greatly increase development speed and readability\n", + "\n", + "Syntax:\n", + "```\n", + " sequence = [expression(element) for element in iterable if condition]\n", + "```\n", + "\n", + "The brackets used for creating the comprehension define what type of object is created.\n", + "\n", + "Use **[ ]** for lists, **()** for _generators_, **{}** for sets and dicts" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### `list` Comprehension" + ] + }, + { + "cell_type": "code", + "execution_count": 151, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['Ravi', 'Pooja', 'Vijay', 'Kiran']" + ] + }, + "execution_count": 151, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "names = [\"Ravi\", \"Pooja\", \"Vijay\", \"Kiran\"]\n", + "names" + ] + }, + { + "cell_type": "code", + "execution_count": 154, + "metadata": {}, + "outputs": [], + "source": [ + "new_list = []\n", + "for name in names:\n", + " new_list.append(\"Hello \" + name)" + ] + }, + { + "cell_type": "code", + "execution_count": 155, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['Hello Ravi', 'Hello Pooja', 'Hello Vijay', 'Hello Kiran']" + ] + }, + "execution_count": 155, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "new_list" + ] + }, + { + "cell_type": "code", + "execution_count": 153, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Hello Ravi', 'Hello Pooja', 'Hello Vijay', 'Hello Kiran']\n" + ] + } + ], + "source": [ + "names = [\"Ravi\", \"Pooja\", \"Vijay\", \"Kiran\"]\n", + "hello = [\"Hello \" + name for name in names]\n", + "print(hello)" + ] + }, + { + "cell_type": "code", + "execution_count": 156, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[32, 10, 54, 32]\n", + "[(55, 3025), (87, 7569), (99, 9801)]\n" + ] + } + ], + "source": [ + "numbers = [55, 32, 87, 99, 10, 54, 32]\n", + "even = [num for num in numbers if num % 2 == 0]\n", + "print(even)\n", + "\n", + "odd_squares = [(num, num * num) for num in numbers if num % 2 == 1]\n", + "print(odd_squares)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exception Handling\n", + "***\n", + "#### try and except\n", + "\n", + "The basic terminology and syntax used to handle errors in Python is the **try** and **except** statements. The code which can cause an exception to occue is put in the *try* block and the handling of the exception is the implemented in the *except* block of code. The syntax form is:\n", + "\n", + "
![](\"images/try_except_else_finally.webp\")
\n",
+ "\n",
+ "We can also just check for any exception with just using except: To get a better understanding of all this lets check out an example: We will look at some code that opens and writes a file:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 159,
+ "metadata": {},
+ "outputs": [
+ {
+ "ename": "NameError",
+ "evalue": "name 'asdasd' is not defined",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)",
+ "\u001b[0;32m/var/folders/0n/nb074wzd4kl1nmdvkbdnpgym0000gn/T/ipykernel_27358/2488089185.py\u001b[0m in \u001b[0;36m![](\"images/exception.png\")
\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "\n",
+ "## File I/O : Helps you read your files\n",
+ "***\n",
+ "- Python provides a `file` object to read text/binary files.\n",
+ "- This is similar to the `FileStream` object in other languages.\n",
+ "- Since a `file` is a resource, it must be closed after use. This can be done manually, or using a context manager (**`with`** statement)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Create a file in the current directory
"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 175,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "with open(\"myfile.txt\",'w') as f:\n",
+ " f.write(\"This is my file \\n\")\n",
+ " f.write(\"Second line \\n\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 177,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "/Users/darshil/Documents/DataWithDarshil/Python Course/Code/DWD - Python Code/2. Python Basics\n"
+ ]
+ }
+ ],
+ "source": [
+ "with open('myfile.txt', 'w') as f:\n",
+ " f.write(\"This is my first file!\\n\")\n",
+ " f.write(\"Second line!\\n\")\n",
+ " f.write(\"Last line!\\n\")\n",
+ "\n",
+ "\n",
+ "# let's verify if it was really created.\n",
+ "# For that, let's find out which directory we're working from\n",
+ "import os\n",
+ "print(os.path.abspath(os.curdir))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Read the newly created file
"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 178,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "This is my first file!\n",
+ "\n",
+ "Second line!\n",
+ "\n",
+ "Last line!\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "with open(\"myfile.txt\",'r') as f:\n",
+ " for line in f:\n",
+ " print(line)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 179,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "f.close()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# read the file we just created\n",
+ "with open('myfile.txt', 'r') as f:\n",
+ " for line in f:\n",
+ " print(line)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Mini Challenge - 5\n",
+ "***\n",
+ "Can you create a list of 10 numbers iterate through the list and print the square of each number ?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# In-session Recap Time\n",
+ "***\n",
+ "* Python Basics\n",
+ " * Variables and Scoping\n",
+ " * Modules, Packages and Imports\n",
+ " * Data Types & Data Structures\n",
+ " * Python Programming Constructs\n",
+ "* Data Types & Data Structures\n",
+ " * Lists\n",
+ " * Dictionaries\n",
+ " * Sets & Booleans\n",
+ "* Python Prograamming constructs\n",
+ " * Loops and Conditional Statements\n",
+ " * Exception Handling\n",
+ " * File I/O"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Thank You\n",
+ "***\n",
+ "### Coming up next...\n",
+ "\n",
+ "- **Python Functions and Object Oriendted Programming**: How to write modular functions to enable code reuse\n",
+ "- **NumPy**: Learn the basis of most numeric computation in Python"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "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.10.6"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Tutorials/Python_Data_Engineering/2. Python Basics/Untitled.ipynb b/Tutorials/Python_Data_Engineering/2. Python Basics/Untitled.ipynb
new file mode 100644
index 0000000000..1c54864904
--- /dev/null
+++ b/Tutorials/Python_Data_Engineering/2. Python Basics/Untitled.ipynb
@@ -0,0 +1,6 @@
+{
+ "cells": [],
+ "metadata": {},
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/Tutorials/Python_Data_Engineering/2. Python Basics/images/21_cent.jpg b/Tutorials/Python_Data_Engineering/2. Python Basics/images/21_cent.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..b3b608a4680a312e9f507c07423f07caefe5748c
GIT binary patch
literal 84357
zcmc$_1#}&~vL?FC5M#{D%*@Qp%naMioWzcqneCWkW~P|gj&YkAVrHiCf6o2S-1FwH
z``)}YYmK(LRBB08pSpXuRISqc;`=55MOIQq5&#AU0Dyh`0PiaRF#tH&U*Rtb{#Ss6
z_=`e8LP9`7LqS9T