diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000..7a15242 Binary files /dev/null and b/.DS_Store differ diff --git a/.gitignore b/.gitignore index 6df01d6..e41f390 100644 --- a/.gitignore +++ b/.gitignore @@ -3,23 +3,23 @@ # https://wiki.jenkins-ci.org/display/JENKINS/Administering+Jenkins #ignore all JENKINS_HOME except jobs directory, root xml config, and .gitignore file -/* -!/jobs -!/.gitignore -!/*.xml +#/* +#!/jobs +#!/.gitignore +#!/*.xml #ignore all files in jobs subdirectories except for folders #note: git doesn't track folders, only file content -jobs/** -!jobs/**/ +#jobs/** +#!jobs/**/ #uncomment the following line to save next build numbers with config #!jobs/**/nextBuildNumber #exclude only config.xml files in repository subdirectories -!config.xml +#!config.xml #don't track workspaces (when users build on the master) -jobs/**/*workspace +#jobs/**/*workspace #as a result only settings and job config.xml files in JENKINS_HOME will be tracked by git diff --git a/Basic/(Updated)Python_Basics_withLinks_noCode.ipynb b/Basic/(Updated)Python_Basics_withLinks_noCode.ipynb new file mode 100644 index 0000000..62dc5bd --- /dev/null +++ b/Basic/(Updated)Python_Basics_withLinks_noCode.ipynb @@ -0,0 +1,2333 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "X01f_sPwOnmX" + }, + "source": [ + "

Python Basics

\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "sAxrb2-DOwQ2" + }, + "source": [ + "![image.png](https://pythonawesome.com/content/images/2019/09/Edward2.jpg)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 321 + }, + "id": "j6_2OG08Onmh", + "outputId": "1fdf47f9-61f5-40f8-f1c2-fea6b87b5c88" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import YouTubeVideo\n", + "YouTubeVideo('https://www.youtube.com/watch?v=izgBmCnp1Oc&list=PLsR_0x6BuM-HJZT6Xzj-088N4hN3KsDME&index=1',width=600,height=300)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rw6fWHMFOnmj" + }, + "source": [ + "Python is emerging as the popular language used more in data science applications.\n", + "\n", + "Take the case of the tech giant Google that has created the deep learning framework called tensorflow – Python is the primary language used for creating this framework. Its footprint has continued to increase in the environment promoted by Netflix. Production engineers at Facebook and Khan Academy have for long been using it as a prominent language in their environment.\n", + "\n", + "Python became the most popular language in the data science world.\n", + "So what are you waiting for? Lets start learning python basic as your first assignment.\n", + "\n", + "\n", + "Add-on Reference: https://youtu.be/HGOBQPFzWKo\n", + "\n", + "Add-on reference: https://youtu.be/8DvywoWv6fI\n", + "\n", + "\n", + "## Variable declaration" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_B2hCySwOnmm" + }, + "source": [ + "Covers the topic of variable declaration and type of variables\n", + "\n", + "

1+1+1+1+1 = 5 points

\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 321 + }, + "id": "ixKyik4SQj1y", + "outputId": "9909f016-7240-4b93-8c86-f4b80cf0464f" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#1 Variables\n", + "\n", + "YouTubeVideo('https://www.youtube.com/watch?v=YdDfEbaUPJs&list=PLsR_0x6BuM-HJZT6Xzj-088N4hN3KsDME&index=2',width=600,height=300)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 321 + }, + "id": "UlSqi2TSQvgw", + "outputId": "b0b3019b-ed2d-4abc-fc7d-6d7dac0cdbde" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#2 Variables\n", + "\n", + "YouTubeVideo('https://www.youtube.com/watch?v=gOcRxdGovhc&list=PLsR_0x6BuM-HJZT6Xzj-088N4hN3KsDME&index=3',width=600,height=300)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "XgolDndUOnmn" + }, + "outputs": [], + "source": [ + "# declare two variables, a = 5, b = 'city'\n", + "a = 5 # your code here\n", + "b = 'city'# your code here" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "0UNQOo-QOnmo", + "outputId": "7f46fd0c-652e-4071-e349-308268524be9" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "# print type of a\n", + "print(type(a))" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "HvaV3dnoOnms", + "outputId": "63c125b0-35fb-4a34-8548-dd5f4ff78b10" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "# print type of b\n", + "print(type(b))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "8fnWzilIOnmu" + }, + "outputs": [], + "source": [ + "# swap the values of a and b\n", + "# hint, if a = 3 and b = \"cloudyML\" then u can swap values like this\n", + "\"\"\"\n", + "a = 3\n", + "b = \"cloudyML\"\n", + "temp = a # defined a temporary variable and store value of a in temp\n", + "a = b # swap\n", + "b = temp # give value of a stored in temp to b\n", + "\"\"\"\n", + "a = 3\n", + "b = \"cloudyML\"\n", + "temp = a # store in temp variable\n", + "a = b # swap value\n", + "b = temp # swap value from temp" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "SWd_9g8YOnmv", + "outputId": "40fa8635-1619-4101-a2af-5b3e4a0f854f" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a= cloudyML\n", + "b= 3\n" + ] + } + ], + "source": [ + "# run this to confirm \n", + "print('a=',a)\n", + "print('b=',b)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jZxcxXV2Onmx" + }, + "source": [ + "Cool! so variable declaration and getting it's type was easy." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 321 + }, + "id": "iGEGIEOsRG4N", + "outputId": "6ffa9eef-8db8-4b03-d5d3-ee2c76f541e0" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#3 Data Structure\n", + "\n", + "YouTubeVideo('https://www.youtube.com/watch?v=R0yDN07Jw_c&list=PLsR_0x6BuM-HJZT6Xzj-088N4hN3KsDME&index=4',width=600,height=300)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "pDfT0V3IOnmx" + }, + "source": [ + "## Arithmetic Operations" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "s7I8ndJiOnmy" + }, + "source": [ + "Hey novice! this will be easy for you until you know basic arithmetic symbols like +, -, /, * etc.\n", + "\n", + "\n", + "

1 + 7 = 8 points

\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 321 + }, + "id": "Gty2GGCgRXTF", + "outputId": "5c2109a2-1043-4242-bd7e-ac65946e85a3" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#4 Operators\n", + "YouTubeVideo('https://www.youtube.com/watch?v=kj-UnITecRE&list=PLsR_0x6BuM-HJZT6Xzj-088N4hN3KsDME&index=10',width=600,height=300)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "GrGEajK2Onmz", + "outputId": "e1cfe06c-730d-481c-d6a8-3a49e9ef03da" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a = 24, b = 3\n" + ] + } + ], + "source": [ + "# declare two variables, a = 24, b = 3\n", + "\n", + "a = 24 # your code here\n", + "b = 3 # your code here\n", + "print('a = {}, b = {}'.format(a,b))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "diniCQx5Onm0", + "outputId": "1500287b-7a45-438b-8168-74d26870f21d" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a+b = 27\n" + ] + } + ], + "source": [ + "print('a+b = {}'.format(a+b))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "N_GYfccYOnm0", + "outputId": "369cb090-8f5e-4fce-a632-0728660cc076" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a+b = 27\n", + "a-b = 21\n", + "a*b = 72\n", + "a/b = 8.0\n", + "a%b = 0\n", + "a//b = 8\n", + "a^b = 27\n" + ] + } + ], + "source": [ + "# calculate and print all the possible numerical operations on a and b (There are total 7 operations)\n", + "# You can use string formatting to get the exact output like ours.\n", + "# hint: print(\"a + b = {}\".format(a+b))\n", + "print('a+b = {}'.format(a+b))\n", + "print('a-b = {}'.format(a-b))\n", + "print('a*b = {}'.format(a*b))\n", + "print('a/b = {}'.format(a/b))\n", + "print('a%b = {}'.format(a%b))\n", + "print('a//b = {}'.format(a//b))\n", + "print('a^b = {}'.format(a^b))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "SnON_Kw9Onm1" + }, + "source": [ + "## Math Functions" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1hTzZGrsOnm2" + }, + "source": [ + "Lets do some simple mathematical operations by using math module. Math module contains various mathematical functions. So here we go!\n", + "\n", + "Additional Reference:- https://youtu.be/gktjNyV0xks\n", + "\n", + "Reference document: https://docs.python.org/3/library/math.html\n", + "

10 points

\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "id": "Y3odgoqgOnm2" + }, + "outputs": [], + "source": [ + "#import math\n", + "import math" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "id": "vVALGHwCOnm3" + }, + "outputs": [], + "source": [ + "# declare a variable x = 2 and y=5.32167\n", + "x = 2 \n", + "y=5.32167" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "h9xFqnF7Onm3", + "outputId": "3cfa7c1c-e47e-4b4f-92b8-d604b0e7ca0b" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5.32167\n" + ] + } + ], + "source": [ + "# Print the maximum value between x and y\n", + "print(max(x,y))" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Ek-Wrhb6Onm3", + "outputId": "d990846a-df27-4078-8bee-271286294b76" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n" + ] + } + ], + "source": [ + "# Print the minimum value between x and y\n", + "print(min(x,y))" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "NHK3kCGAOnm4", + "outputId": "abde16f9-2ff6-4142-fb24-58bf9671419e" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4\n", + "8\n" + ] + } + ], + "source": [ + "# Print square and cube of x and store in a and b variable\n", + "a=pow(x,2)\n", + "b=pow(x,3)\n", + "print(a)\n", + "print(b)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ARYINv9AOnm4", + "outputId": "686a724b-c071-4bee-839d-1ec0fa93e8b2" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.6931471805599453\n" + ] + } + ], + "source": [ + "#print log of x and store it in variable c\n", + "c=math.log(x)\n", + "print(c)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "xGbjPCVfOnm5", + "outputId": "52aa32fc-44b6-4b9a-ca0a-4f620594f972" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.6931471805599453\n" + ] + } + ], + "source": [ + "#print minimum value between x,y,a, b and c\n", + "print(min(x,y,a,b,c))" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Cr2aOwOYOnm5", + "outputId": "de3cc648-eb3c-4593-a2e5-84e9f875507c" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "8\n" + ] + } + ], + "source": [ + "#print maximum value between x,y,a, b and c\n", + "print(max(x,y,a,b,c))" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "cdTE9jHJOnm5", + "outputId": "32bce6d3-5824-4969-c1f4-8308aed5e59b" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n" + ] + } + ], + "source": [ + "#print the largest integer that is smaller than or equal to c. ie.round down\n", + "print(math.floor(c))" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "YuQFq6iTOnm6", + "outputId": "e852e936-5715-4632-d5b5-7a46a6c6aa17", + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n" + ] + } + ], + "source": [ + "#print the smallest integer that is greater than or equal to c ie. round up\n", + "print(math.ceil(c))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7ywGXy77Onm6" + }, + "source": [ + "## Logical operations\n", + "\n", + "You must be aware of some logical operations you did in college, like 'and', 'or', 'not' etc. These operations becomes even more easy to implement when you have friend like python.\n", + "\n", + "

1 + 1 + 1 + 6 = 9 points

\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "qD67cRQJOnm7", + "outputId": "a9b2728d-fc6b-4c06-e031-a6537b7e3007" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n", + "False\n" + ] + } + ], + "source": [ + "# declare two variables, a = True, b = False\n", + "a = True #your code here\n", + "b = False #your code here\n", + "print(a)\n", + "print(b)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "f5Vs8qzjOnm7", + "outputId": "6bd148d7-2af0-4645-9b4f-94f5dcbc962e" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n" + ] + } + ], + "source": [ + "# print type of a and type of b\n", + "print(type(a))\n", + "print(type(b))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "c3_XIcPkOnm7" + }, + "source": [ + "A fun fact for you !\n", + "The Python Boolean type is one of Python's built-in data types. It's used to represent the truth value of an expression" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "lCruZY6_Onm8", + "outputId": "dd3a08e3-ac92-4499-e0f5-875c3d9294e9" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "integer value of a = 1\n", + "integer value of b =0\n" + ] + } + ], + "source": [ + "# print int(a) and int(b)\n", + "print('integer value of a = {}'.format(int(a)))\n", + "print('integer value of b ={}'.format(int(b)))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "y2pKlWHBOnm8" + }, + "source": [ + "We are sure you must have seen that, values for 'True' is 1 and for 'False' is 0." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "IEuVTnsAOnm8", + "outputId": "5d64cdc9-1b50-49b2-beb7-56aad691b0de" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "not a = False\n", + "not b = True\n", + "a and b = False\n", + "a or b = True\n", + "a and not b = True\n" + ] + } + ], + "source": [ + "# Find and print the values of not a, not b, a and b, a or b, a and not b\n", + "# Use not operator for not a and not b\n", + "print('not a = {}'.format(not(a)))\n", + "print('not b = {}'.format(not(b)))\n", + "print('a and b = {}'.format(a and b))\n", + "print('a or b = {}'.format(a or b))\n", + "print('a and not b = {}'.format(a and not(b)))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "TI7-60doOnm9" + }, + "source": [ + "We hope you tried to undertand the above output! " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Ngtt9xc6Onm9" + }, + "source": [ + "## List Comprehensions\n", + "\n", + "Hey buddy! Python has really amazing thing called list comprehension. List comprehension offers a shorter syntax when you want to create a new list based on the values of an existing list. Cool right? Let's dive into this more by doing it. \n", + "\n", + "

10 + 10 + 10= 30 points

\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 321 + }, + "id": "A7MBHOJVSGFV", + "outputId": "a61aa7d1-b708-46b0-afac-4675b3ad286f" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Comprehension\n", + "YouTubeVideo('https://www.youtube.com/watch?v=Cs8wG--s4z4&list=PLsR_0x6BuM-HJZT6Xzj-088N4hN3KsDME&index=17',width=600,height=300)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "EFQZLhkDOnm9", + "outputId": "2f5169f0-387b-44ee-a8cc-a58078062dd9" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]\n" + ] + } + ], + "source": [ + "# Using list comprehension, create a list containing numbers from 1 to 20. \n", + "# Hint: You can use range function of python to do this.\n", + "list_num = [i for i in range(1,20)]\n", + "print(list_num)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "3fZ8aOSyOnm9", + "outputId": "a82613e0-1ef0-4dc7-adef-45e25e7a747b" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2, 4, 6, 8, 10, 12, 14, 16, 18]\n" + ] + } + ], + "source": [ + "# Using list comprehension, create a list containing numbers from 1 to 20 that are even\n", + "list_even = [i for i in range(1,20) if i%2==0]\n", + "print(list_even)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Nom_UZdsOnm-" + }, + "source": [ + "Create a list of all the fruits you like. Using list comprehension, create another list which contains the total number of charachters for each corresponding fruits.\n", + "- Eg. fruits = [‘apple’,’kiwi’,’orange’], then output would be - [5,4,6]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "qgTZeieSOnm-", + "outputId": "dab7c09a-7bdd-4949-8ee8-f11ff3de3d3b" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['mango', 'apple', 'banana', 'vimal', 'orange']\n", + "[5, 5, 6, 5, 6]\n" + ] + } + ], + "source": [ + "fruits = ['mango', 'apple', 'banana', 'vimal', 'orange']# your code here (create a list of your favourite fruits)\n", + "len_fruits = [len(i) for i in fruits] # your code here\n", + "\n", + "print(fruits)\n", + "print(len_fruits)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "EmUChdf-Onm-" + }, + "source": [ + "The above output is shown if fruits = ['apple','kiwi,'orange'], it can vary for different values of fruits\n", + "\n", + "Amazing right?\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "wPzfKH4vOnm_" + }, + "source": [ + "## String value and operators\n", + "\n", + "

1 + 1 + 1 + 1 + 1 = 5 points

\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 321 + }, + "id": "JkGT52I9Onm_", + "outputId": "58b05e98-fbc1-4427-a516-7ee18e2e359e" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# string manipulation\n", + "YouTubeVideo('https://www.youtube.com/watch?v=I6UH_prRboE&list=PLsR_0x6BuM-HJZT6Xzj-088N4hN3KsDME&index=9',width=600,height=300)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Ee_vso2gOnm_" + }, + "source": [ + "### Characters in strings\n", + "\n", + "\n", + "Reference:- https://www.programiz.com/python-programming/string\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "3SeJY_uNOnm_", + "outputId": "1f8d2238-d57c-401c-94c6-a0c19c86549a" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cat\n", + "dog\n" + ] + } + ], + "source": [ + "# declare the variables x = cat and y = dog and print it\n", + "x = \"cat\" #your code here\n", + "y = \"dog\" #your code here\n", + "\n", + "print(x)\n", + "print(y)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "J6WM2PYhOnm_", + "outputId": "514c8a28-4476-467f-d520-077f0aa8ad99" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "First ch of x = c\n", + "First ch of y = d\n" + ] + } + ], + "source": [ + "#Print first character of both x and y. \n", + "print('First ch of x = {}'.format(x[0]))\n", + "print('First ch of y = {}'.format(y[0]))" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "T4cyd2QJOnnA", + "outputId": "12d6e971-5f16-4874-b7a7-b23cf7c82bb1" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Last ch of x = t\n", + "Last ch of y = g\n" + ] + } + ], + "source": [ + "#Print last character of both x and y.\n", + "print('Last ch of x = {}'.format(x[-1]))\n", + "print('Last ch of y = {}'.format(y[-1]))" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "jWHyH2o7OnnA", + "outputId": "1db5da7b-73c6-4836-94db-455a8c69430e" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Length of x is = 3\n", + "Length of y is = 3\n" + ] + } + ], + "source": [ + "#Print len of both x and y\n", + "print('Length of x is = {}'.format(len(x)))\n", + "print('Length of y is = {}'.format(len(y)))" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "wcu4u4ZdOnnA", + "outputId": "93d5653f-3c36-4016-ac0c-3f904043ac16" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "catdog\n" + ] + } + ], + "source": [ + "#concatenate both x and y and store it in variable z and print z\n", + "z = x+y\n", + "print(z)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "gfbQ0ahAOnnA", + "outputId": "f96fc941-8835-4fec-853d-a96967136728" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n" + ] + } + ], + "source": [ + "#check if x is part of z \n", + "print(x in z)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "lVchUi7YOnnB" + }, + "source": [ + "### String slicing\n", + "\n", + "\n", + "\n", + "Hey coder, do you know? Python slicing is about obtaining a sub-string from the given string by slicing it respectively from start to end\n", + "\n", + "So be ready to implement it today!\n", + "

2 points

" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "VPiDEDDTOnnB", + "outputId": "0c3d5fa2-8c5e-4f64-d7e9-45eb819e8081" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "pineapple\n" + ] + } + ], + "source": [ + "#Create variable a = “pineapple”\n", + "a = \"pineapple\" # your code here\n", + "print(a)" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "eCNFSjIROnnB", + "outputId": "d96f36b6-bd60-4d6c-9740-9847b98e6c57" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "pine\n", + "apple\n" + ] + } + ], + "source": [ + "# Using index slicing, print the words ‘pine’ and “apple”.\n", + "# HINT - a[:]\n", + "print(a[0:4])\n", + "print(a[4:9])" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 38 + }, + "id": "Z6881zT0OnnB", + "outputId": "208250a0-1b76-40d7-8bb4-bec4e0e377bb" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PINEAPPLE\n" + ] + } + ], + "source": [ + "#Convert a into upper case\n", + "print(a.upper())" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "mEw9dmM2OnnC" + }, + "source": [ + "## Dealing with Sentences\n", + "\n", + "

1+1+1+1+1+1 = 6 points

\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "O-eulzDKOnnC", + "outputId": "66eb5489-a993-43d9-d5f7-0a2bba537f82" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "I am flying to London\n" + ] + } + ], + "source": [ + "# Declare a sentence of ‘I am flying to London’ and print it\n", + "sentence = '''I am flying to London'''\n", + "print(sentence)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "6YqhY71aOnnC", + "outputId": "6de6d53f-a6c3-4038-d9be-60cf3907f372" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "length of the sentence 21\n" + ] + } + ], + "source": [ + "#Print length of the sentence\n", + "print('length of the sentence {}'.format(len(sentence)))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 38 + }, + "id": "ueh0avBIOnnC", + "outputId": "e5eb183b-67bb-4836-9e6e-4be23aa9e376" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "London is at index 4\n" + ] + } + ], + "source": [ + "#Using list indexing, to print the word London\n", + "words = sentence.split(\" \")\n", + "values= [word for word in words]\n", + "indexLondon = values.index(\"London\")\n", + "print('{} is at index {}'.format(values[indexLondon],indexLondon))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "XxWpC9-pOnnC", + "outputId": "6e4a9f0e-4256-487b-ff53-55d42cf83833" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['I', 'am', 'flying', 'to', 'London']\n" + ] + } + ], + "source": [ + "# Use .split to get list of individual words in the sentence\n", + "words = sentence.split(\" \")\n", + "print(words)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 38 + }, + "id": "cv-iS9BrOnnD", + "outputId": "ad6c2830-5520-4bd9-93e5-d9e1b7b64580" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "i am flying to london\n" + ] + } + ], + "source": [ + "# Convert sentence in lower case \n", + "print(sentence.lower())" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 38 + }, + "id": "Qv4XhFETOnnD", + "outputId": "f1e36b6f-ae52-41c9-e1e6-5c2f36607e93" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "I AM FLYING TO LONDON\n" + ] + } + ], + "source": [ + "# Convert sentence in upper case .\n", + "print(sentence.upper())" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Wz53Tr8YOnnD" + }, + "source": [ + "Great job! Slicing is fun." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "EpMEG_R3OnnE" + }, + "source": [ + "## Functions\n", + "\n", + "Declare a function named square, which takes an input as x, and returns the square of x.\n", + "\n", + "

5 + 3 = 8 points

\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 321 + }, + "id": "xrJ-Nmq7OnnE", + "outputId": "08b3a556-6a58-4ea1-cff6-94bf6af3e707" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Functions-1\n", + "YouTubeVideo('https://www.youtube.com/watch?v=cjtAbp-Ux-w&list=PLsR_0x6BuM-HJZT6Xzj-088N4hN3KsDME&index=15',width=600,height=300)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 321 + }, + "id": "LPGhSZf_S9JU", + "outputId": "e6f29551-c93c-45ed-d39d-1e8a9722aea9" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Function-2\n", + "YouTubeVideo('https://www.youtube.com/watch?v=cjtAbp-Ux-w&list=PLsR_0x6BuM-HJZT6Xzj-088N4hN3KsDME&index=16',width=600,height=300)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "KX4y0IHVOnnE" + }, + "source": [ + "Call the function to find the value of square of 9." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ms2A-A15OnnE", + "outputId": "9ac75f3d-1267-40da-bf6b-067a7e5c8008" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "81.0\n" + ] + } + ], + "source": [ + "# find the square of 9 using the function square you have just created.\n", + "import math\n", + "def square(x):\n", + " x = math.pow(x,2)\n", + " return x\n", + " # find the square of 9 using the function square you have just created.\n", + "print(square(9))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ehBLnbH-OnnE" + }, + "source": [ + "Wohoo! see, defining function was simple" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "h01u89J0OnnF" + }, + "source": [ + "#### Define another function which checks whether a given is number is odd or even for a given input and it should print whether the number is odd or even as an output\n", + "

5 + 3 = 8 points

\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "MNVuqrmgOnnF", + "outputId": "55b6972e-2d94-4915-99d4-75072ebcb7c6" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "11 is Odd\n" + ] + } + ], + "source": [ + "# your code here\n", + "def checkEvenOdd(x):\n", + " if x%2 ==0:\n", + " return 'Even'\n", + " else:\n", + " return 'Odd'\n", + " \n", + "var=11\n", + "evenOdd = checkEvenOdd(var)\n", + "print('{} is {}'.format(var,evenOdd))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PH7VEP8eOnnF" + }, + "source": [ + "Hey smarty! lets use both the functions together to check whether the square of 3,6 and 21 are odd or even.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "lhFMpKfHOnnF", + "outputId": "6fc2329e-7202-4325-c9a3-0048bd047532" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "9.0 is Odd\n", + "36.0 is Even\n", + "441.0 is Odd\n" + ] + } + ], + "source": [ + " # your code here\n", + "varList = [3,6,21]\n", + "for num in varList:\n", + " print('{} is {}'.format(square(num),checkEvenOdd(square(num))))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "aSnw4vEHOnnF" + }, + "source": [ + "hey hey! You did a great code. Did you see the benefit of using functions" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7TThdIkzOnnG" + }, + "source": [ + "# Loops and Iterations" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "MyKf8rF1OnnG" + }, + "source": [ + "## If statement\n", + "\n", + "

1 + 2 + 3 = 6 points

\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 321 + }, + "id": "8jLCzSQ9Tafb", + "outputId": "1ab609ca-b776-458f-8cf7-8f1a4a6ff6a7" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# conditions\n", + "YouTubeVideo('https://www.youtube.com/watch?v=CLqw5KZZ8Dg&list=PLsR_0x6BuM-HJZT6Xzj-088N4hN3KsDME&index=11',width=600,height=300)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "3srU1iT1OnnG", + "outputId": "132576fa-a12a-43d3-c28d-ad3b7c7fcdea" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-9\n" + ] + } + ], + "source": [ + "#Declare a variable x equal to a number of your choice.\n", + "#your code here\n", + "x = -9 # add a number of your choice (mine is 3 :) )\n", + "print(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "qjbO3dNLOnnH", + "outputId": "3a8a02f3-18cb-4607-9970-094ae1075851" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-9 is negative\n" + ] + } + ], + "source": [ + "#Using an if statement, print whether x is zero, positive or negative.\n", + "if x ==0:\n", + " print('{} is zero'.format(x))\n", + "elif x>0:\n", + " print('{} is positive'.format(x))\n", + "else:\n", + " print('{} is negative'.format(x))" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Qje0Z0zLOnnH", + "outputId": "c392c49e-c4b9-4fb1-b54a-8a8ea3f7e9d1" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10 is positive\n", + "-2 is negative\n", + "0 is zero\n" + ] + } + ], + "source": [ + "# Now Define a function, which takes input from the user and prints whether the given input is zero,positive or negative.\n", + "def check_num(x):\n", + " if x ==0:\n", + " print('{} is zero'.format(x))\n", + " elif x>0:\n", + " print('{} is positive'.format(x))\n", + " else:\n", + " print('{} is negative'.format(x))\n", + "\n", + "check_num(10)\n", + "check_num(-2)\n", + "check_num(0)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8QnzejuHOnnH" + }, + "source": [ + "## For loop" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Nh3IHYqNOnnH" + }, + "source": [ + "

2 points

\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 321 + }, + "id": "5iohidqhTzVZ", + "outputId": "ba74b218-b345-472e-becc-65127610f5e7" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Loops\n", + "YouTubeVideo('https://www.youtube.com/watch?v=56-IOucIwAU&list=PLsR_0x6BuM-HJZT6Xzj-088N4hN3KsDME&index=12',width=600,height=300)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "50nOGOuqOnnI", + "outputId": "b7e7b9db-08bd-4379-a831-7f63a77a4ae2" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "['India', 'Israel', 'Canada']\n" + ] + } + ], + "source": [ + "#Create a list x, such that it contains the elements - ‘India’, ‘Israel’,’Canada’.\n", + "x = ['India', 'Israel','Canada']\n", + "print(type(x))\n", + "print(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "VxfS6YKYOnnI", + "outputId": "1e8438c0-9b08-451c-c5b3-5717741caf9a" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "India\n", + "Israel\n", + "Canada\n" + ] + } + ], + "source": [ + "#Using For loop, iterate over the list and print the elements.\n", + "for country in x:\n", + " print(country)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jz61jhLlOnnI" + }, + "source": [ + "

2 points

\n" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "mvqvf7OAOnnI", + "outputId": "9c228334-1c19-46a5-e21f-9fd062ac213d" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2*2 = 4\n", + "2*3 = 6\n", + "2*4 = 8\n", + "2*5 = 10\n", + "2*6 = 12\n", + "2*7 = 14\n", + "2*8 = 16\n", + "2*9 = 18\n" + ] + } + ], + "source": [ + "# Using For loop, print the table of 2.\n", + "for i in range(2,10):\n", + " print('2*{} = {}'.format(i,(2*i)))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "yg4SzR4oOnnI" + }, + "source": [ + "For a given list, x = [21, ‘hello,’cream’, 20,19,’village’], using for loop to iterate over the items and using - if statement print the items that are of type int" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "05SkQO3COnnJ", + "outputId": "c4bbb3e7-b3db-4b58-981a-2776a62d28cb" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "21\n", + "20\n", + "19\n" + ] + } + ], + "source": [ + "#code here\n", + "# hint: use if type(i) == int: condition to print variable which are of int type\n", + "x = [21, 'hello','cream', 20,19,'village']\n", + "for item in x:\n", + " if type(item)==int:\n", + " print(item)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ab7bEu3xOnnJ" + }, + "source": [ + "Using For loop, lets create a pattern. " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2KNZFi5zOnnJ" + }, + "source": [ + "

10 points

\n" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "kOZsmIiLOnnJ", + "outputId": "ce9e2450-eb16-4987-959a-268d9efca100" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "*\n", + "**\n", + "***\n", + "****\n", + "*****\n" + ] + } + ], + "source": [ + "# print the following pattern\n", + "for i in range(1,6):\n", + " print('*'*i)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1WYgQq4AOnnJ" + }, + "source": [ + "## While loop" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jyjME3nPOnnK" + }, + "source": [ + "- Using while loop make a function that prints all the values between 1 to n. " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "xbJ4Cz9gOnnK" + }, + "source": [ + "

10 points

\n" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": { + "id": "2k9Aij8_OnnK" + }, + "outputs": [], + "source": [ + "def counter(n):\n", + "# your code here\n", + " for i in range(1,n):\n", + " print(i)" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "qd1VznT2OnnK", + "outputId": "7cac2bee-0cb0-45c1-9c8a-cf994d083b25" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n", + "7\n", + "8\n", + "9\n" + ] + } + ], + "source": [ + " counter(10) #this should print numbers from 1 to 10" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kKB5qVCxOnnL" + }, + "source": [ + "### Write the code for the following, what is the output obtained?\n", + "- Set a variable flag = True, num = 5\n", + "- Run a while loop till flag = True\n", + "- Inside the while loop - \n", + " - Increment the value of num by 5\n", + " - If value of num is greater then 50, set flag to be False" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "RsCW8__JOnnM", + "outputId": "980de4fb-c5af-4c5e-86de-2b48a3c3ad02" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n", + "10\n", + "15\n", + "20\n", + "25\n", + "30\n", + "35\n", + "40\n", + "45\n", + "50\n" + ] + } + ], + "source": [ + "# your code here\n", + "flag = True\n", + "num = 5\n", + "while flag==True:\n", + " print(num)\n", + " num = num+5\n", + " if num>50:\n", + " flag=False\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "sQxbS2kzOnnM" + }, + "source": [ + "Awsesome! Great job so far. Hope you fell in love with python now." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "zroTaOSLOnnN" + }, + "source": [ + "----------------------------------------------------------------------" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4ibh00DQOnnN" + }, + "source": [ + "# Smile, you completed the first milestone :)!! " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "erddMO8yOnnN" + }, + "source": [ + "# Its Feedback Time!\n", + "\n", + "We hope you’ve enjoyed this course so far. We’re committed to help you use \"AI for All\" course to its full potential, so that you have a great learning experience. And that’s why we need your help in form of a feedback here.\n", + "\n", + "**Please fill this feedback form**\n", + " https://zfrmz.in/MtRG5oWXBdesm6rmSM7N\n", + " \n", + "-------------------------------------\n", + " " + ] + } + ], + "metadata": { + "colab": { + "collapsed_sections": [], + "name": "(Updated)Python_Basics_withLinks_noCode.ipynb", + "provenance": [] + }, + "interpreter": { + "hash": "fb2d3f2a20add04007a107bc483b4e625069f7acb60837d887d77da2f0eec5b6" + }, + "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.8" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/Basic/.DS_Store b/Basic/.DS_Store new file mode 100644 index 0000000..5008ddf Binary files /dev/null and b/Basic/.DS_Store differ diff --git a/Basic/Python Intermediate.ipynb b/Basic/Python Intermediate.ipynb new file mode 100644 index 0000000..add22e1 --- /dev/null +++ b/Basic/Python Intermediate.ipynb @@ -0,0 +1,1508 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#
Python-Intermediate
\n" + ] + }, + { + "attachments": { + "image-2.png": { + "image/png": "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" + }, + "image-3.png": { + "image/png": "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" + }, + "image-4.png": { + "image/png": "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" + }, + "image-5.png": { + "image/png": "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" + }, + "image-6.png": { + "image/png": "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" + }, + "image-7.png": { + "image/png": "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" + }, + "image.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here you can start digging into our intermediate-level programming questions that will teach you new Python concepts. This category is for intermediate Python developers who already know the basics of Python development and want to expand their knowledge.\n", + "\n", + "Below are some flowcharts on various python statements which will be useful to understand their use .\n", + "\n", + "\n", + "**1. BREAK**\n", + "![image-7.png](attachment:image-7.png)\n", + "**2. CONTINUE**\n", + "![image.png](attachment:image.png)\n", + "**3. WHILE LOOP**\n", + "![image-2.png](attachment:image-2.png)\n", + "**4. FOR LOOP**\n", + "![image-3.png](attachment:image-3.png)\n", + "**5. IF STATEMENT**\n", + "![image-4.png](attachment:image-4.png)\n", + "**6. IF ELSE**\n", + "![image-5.png](attachment:image-5.png)\n", + "**7. IF ELSE IF ELSE**\n", + "![image-6.png](attachment:image-6.png)\n", + "\n", + "\n", + "\n", + "Becoming a Python expert takes time, but over time you’ll master this beautiful programming language. It’s worth it! \n", + "\n", + "Reference video: https://youtu.be/HGOBQPFzWKo\n", + "\n", + "So lets get started!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1.Lets remove duplicates from list names=['A','B','C','A','D','E','F','G','H','E','D']\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#code here\n", + "names=['A','B','C','A','D','E','F','G','H','E','D']\n", + "dup_rem = []\n", + "for i in names:\n", + " if i not in dup_rem:\n", + " dup_rem.append(i)\n", + "dup_rem" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2. Good! Shall we try solving above problem in shhorter way using list comprehention? It will be amazing. Here we go!\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#code here\n", + "dup_rem = []\n", + "[dup_rem.append(x) for x in names if x not in dup_rem]\n", + "dup_rem" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "3. define a funtion 'occurence' which takes 2 inputs, one list 'lst' and another one a number 'n' and count the number of occurrences of n in your list lst." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4\n" + ] + } + ], + "source": [ + "#your code\n", + "def occurence(lst,n):\n", + " count = 0\n", + " for elem in lst:\n", + " if elem==n:\n", + " count=count+1\n", + " print(count)\n", + " \n", + "#let use your function\n", + "occurence([2,3,4,8,1,3,5,2,1,3,1,2,2], 2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "4. Calculate factorial of a number ( Here number=3) using while loop" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "6" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "number = 3\n", + "#code here\n", + "def factorial(n):\n", + " ans = 1\n", + " for i in range(1,n+1):\n", + " ans *= i\n", + " return ans \n", + "\n", + "factorial(number)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "5. Reverse a given integer number num = 47594038222 and display the count of total number of digits in your revered number using while loop." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total number of digits in 22283049574 are 11\n" + ] + } + ], + "source": [ + "#code here\n", + "def reverse_count(num):\n", + " count = 0\n", + " reversed_num = 0\n", + " while num>0:\n", + " count += 1\n", + " digit = num %10\n", + " reversed_num = reversed_num*10 + digit\n", + " num //=10\n", + " return count, reversed_num\n", + "\n", + "num_digit, reverse_num = reverse_count(47594038222)\n", + "print(f\"Total number of digits in {reverse_num} are {num_digit}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "6. Can you reverse you given num without using loop in just one line?\n", + "\n", + "Hint: apply some slicing trick to do it." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "22283049574\n" + ] + } + ], + "source": [ + "num = 47594038222\n", + "\n", + "#one line code here\n", + "print(str(num)[::-1])\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "7. Write a function that checks whether a given sequence of number is IP address or not and print all valid possible IP from a given digit. If not an IP then it prints empty list\n", + "\n", + "**Note:** According to Wikipedia, IPv4 addresses are canonically represented in dot-decimal notation, which consists of four decimal numbers, each ranging from 0 to 255, separated by dots, e.g., 172.16.254.1" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['255.255.11.135', '255.255.111.35']\n", + "[]\n", + "[]\n", + "[]\n" + ] + } + ], + "source": [ + "#Code here\n", + "def occurence_dot(s,n):\n", + " count = 0\n", + " for i in range(len(s)):\n", + " if s[i]==n:\n", + " count=count+1\n", + " return count\n", + "\n", + "def check_validIP(strVal):\n", + " dotDecCount = occurence_dot(strVal,'.')\n", + " checkFlg = False;\n", + " if dotDecCount==3:\n", + " ipNum = strVal.split(\".\")\n", + " for elem in ipNum:\n", + " if (len(elem)>3 or (int(elem)<0 or int(elem)>255)):\n", + " checkFlg = False;\n", + " break\n", + " elif(len(elem)>1 and int(elem)==0):\n", + " checkFlg = False;\n", + " break\n", + " elif(len(elem)>1 and int(elem)!=0 and elem[0]=='0'):\n", + " checkFlg = False;\n", + " break\n", + " else:\n", + " checkFlg = True \n", + " return checkFlg\n", + "\n", + "def possible_IP(strVal):\n", + " ipRange = []\n", + " strNew = strVal.replace(\".\", \"\")\n", + " #print(strNew)\n", + " n = len(strNew)\n", + " if(n>12):\n", + " pass\n", + " else:\n", + " flag = False\n", + " for i in range(1,n-2):\n", + " for j in range(i+1,n-1):\n", + " for k in range(j+1,n):\n", + " strNew = strNew[:k]+\".\"+strNew[k:]\n", + " strNew = strNew[:j]+\".\"+strNew[j:]\n", + " strNew = strNew[:i]+\".\"+strNew[i:]\n", + " flag = check_validIP(strNew)\n", + " if flag == True:\n", + " ipRange.append(strNew)\n", + " strNew = strVal.replace(\".\", \"\")\n", + " return(ipRange)\n", + "\n", + "def ip_validation(strVal):\n", + " ipResult = []\n", + " ipList = []\n", + " ipFlag = check_validIP(strVal)\n", + " ipList = possible_IP(strVal)\n", + " if(ipFlag==False): \n", + " pass\n", + " else:\n", + " ipResult.append(strVal)\n", + " print(ipList)\n", + " print(ipResult)\n", + " \n", + "# Check your code with below numbers \n", + "A = \"25525511135\"\n", + "B = \"25505011536\"\n", + "\n", + "ip_validation(A)\n", + "ip_validation(B)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "8. Solve the quadratic equation ax**2 + bx + c = 0 where a =4, b=6, c=2" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The solution are 1.0 and 0.5\n" + ] + } + ], + "source": [ + "#code here \n", + "import cmath\n", + "def quadratic_soln(a,b,c):\n", + " disc = (b**2)-(4*a*c)\n", + " if(disc>0):\n", + " sol1 = (-b-cmath.sqrt(disc))/(2*a)\n", + " sol2 = (-b+cmath.sqrt(disc))/(2*a)\n", + " print(f\"The solution are {float(abs(sol1))} and {float(abs(sol2))}\")\n", + " elif disc == 0:\n", + " print(\"Repeated real number solution\")\n", + " else:\n", + " print(\"No real root possible\")\n", + "\n", + "quadratic_soln(4,6,2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "9. Write a program to Remove Punctuations From a String \n", + "\n", + "s=\"Wow!!!, we are going ahead with our course to learn *machine learning* ---are'nt you excited? :)\"" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Wow we are going ahead with our course to learn machine learning arent you excited \n" + ] + } + ], + "source": [ + "# code here\n", + "import re\n", + "def remove_punc(strval):\n", + " res = re.sub(r'[^\\w\\s]', '', strval)\n", + " return res\n", + "\n", + "s=\"Wow!!!, we are going ahead with our course to learn *machine learning* ---are'nt you excited? :)\"\n", + "print(remove_punc(s))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "10. Write a program which takes 2 digits, X,Y as input and generates a 2-dimensional array. The element value in the i-th row and j-th column of the array should be i*j.\n", + "\n", + "Note: i=0,1.., X-1; j=0,1,i^Y-1." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[0, 0, 0, 0], [0, 1, 2, 3], [0, 2, 4, 6]]\n" + ] + } + ], + "source": [ + "digit1=3\n", + "digit2=4\n", + "#code here\n", + "def twoD_array(dig1, dig2):\n", + " multiArr = []\n", + " for x in range(dig1):\n", + " row = []\n", + " for y in range(dig2):\n", + " row.append(x * y)\n", + " multiArr.append(row)\n", + " return multiArr\n", + "\n", + "print(twoD_array(digit1,digit2))" + ] + }, + { + "attachments": { + "image.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "11. Write a function 'solve_coin_change' which takes list of denominations and amount and checks number of ways you can make change with coins and a total amount.\n", + "\n", + "Note: You have unlimited amount of mentioned denominations\n", + "\n", + "![image.png](attachment:image.png)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "9\n", + "6\n" + ] + } + ], + "source": [ + "#code here\n", + "def solve_coin_change(coins, amount):\n", + " numCoin = len(coins)\n", + " # table[i] will be storing the number of solutions for\n", + " # value i. We need n+1 rows as the table is constructed\n", + " # in bottom up manner using the base case (n = 0)\n", + " # Initialize all table values as 0\n", + " table = [0 for k in range(amount+1)]\n", + " \n", + " # Base case (If given value is 0)\n", + " table[0] = 1\n", + " \n", + " # Pick all coins one by one and update the table[] values\n", + " # after the index greater than or equal to the value of the\n", + " # picked coin\n", + " for i in range(0,numCoin):\n", + " for j in range(coins[i],amount+1):\n", + " table[j] += table[j-coins[i]]\n", + " \n", + " return table[amount]\n", + " \n", + "# Checking your code\n", + "print(solve_coin_change([1, 5, 10],20))\n", + "print(solve_coin_change([1, 2, 5],7))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "12. For given string S and integers P and Q, which denotes the cost of removal of substrings “he” and “lo” respectively from S, the task is to find the maximum cost of removing all occurrences of substrings “he” and “lo”.\n", + "\n", + "example if S = “hellohellohellohellohello”, P = 6, Q = 4, then cost to remove 'he' and 'lo' is 50" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "50\n" + ] + } + ], + "source": [ + "# code here\n", + "# Function to return the maximum cost\n", + "def MaxCollection(S, X, Y):\n", + " N = len(S)\n", + " countP = 0\n", + " countQ = 0\n", + " for i in range(N):\n", + " if S[i:i+2]=='he':\n", + " countP +=1\n", + " elif S[i:i+2]=='lo':\n", + " countQ +=1\n", + " \n", + " res = (countP*X)+(countQ*Y)\n", + " return res\n", + " \n", + "# Check code with \n", + "\n", + "S = \"hellohellohellohellohello\"\n", + "\n", + "# Costs\n", + "P = 6;\n", + "Q = 4;\n", + "\n", + "\n", + "print(MaxCollection(S, P, Q));" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "13. Given a binary string S , the task is to find the smallest string possible by removing all occurrences of substrings “01” and “11”. After removal of any substring, concatenate the remaining parts of the string.\n", + "\n", + "Example\n", + " \n", + " Input: S = “0010110”\n", + " Output: String = 0\n", + " \n", + " Explanation: String can be transformed by the following steps: \n", + " 0010110 → 00110 → 010 → 0. \n", + " Since no occurrence of substrings 01 and 11 are remaining, the string “0” is of minimum possible length 1." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The final string is: 0\n", + "The final string size is: 1\n" + ] + } + ], + "source": [ + "#code here\n", + "from collections import deque\n", + "def shortestString(S) :\n", + " N = len(S)\n", + " stack = deque()\n", + " for i in range(N):\n", + " #if stack is empty push character\n", + " if(len(stack)==0):\n", + " stack.append(S[i])\n", + " elif(S[i]=='1'):\n", + " stack.pop()\n", + " else:\n", + " stack.append(S[i])\n", + " ans = 0\n", + " finalStr=[]\n", + " while(len(stack)>0):\n", + " ans+=1\n", + " finalStr.append(stack[-1])\n", + " stack.pop()\n", + " # If length is not 0\n", + " if (ans == 0):\n", + " print(\"The final string is: EMPTY\")\n", + " \n", + " # Print the string\n", + " else:\n", + " print(\"The final string is: \", *finalStr)\n", + " # Print the final string size\n", + " print(\"The final string size is: \", ans)\n", + "\n", + "\n", + "#check code here\n", + " \n", + "s=\"0010110\"\n", + "\n", + "shortestString(s)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "14. Write a function such that it accepts two integers n, m as arguments Find the sum of all numbers in range from 1 to m(both inclusive) that are not divisible by n. Return difference between sum of integers not divisible by n with sum of numbers divisible by n\n", + "\n", + "Example\n", + "\n", + " Input\n", + " n:4\n", + " m:20\n", + " Output\n", + " 90" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Input\n", + "n:4\n", + "m:20\n", + "Output\n", + "90\n" + ] + } + ], + "source": [ + "#code here\n", + "def diffCalc(n,m):\n", + " sumNonDiv = 0\n", + " sumDiv = 0\n", + " for i in range(1,m+1):\n", + " if(i%n==0):\n", + " sumDiv = sumDiv + i\n", + " else:\n", + " sumNonDiv = sumNonDiv + i\n", + " diff = sumNonDiv - sumDiv\n", + " return diff\n", + "\n", + "print(\"Input\")\n", + "s1 = int(input(\"n:\"))\n", + "s2 = int(input(\"m:\"))\n", + "print(\"Output\")\n", + "print(diffCalc(s1,s2))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "15. Write a function count_code that return the number of times that the string \"code\" appears anywhere in the given string, except we'll accept any letter for the 'd', so \"cope\" and \"cooe\" count.\n", + "\n", + "\n", + " count_code('aaacodebbb') → 1\n", + " count_code('codexxcode') → 2\n", + " count_code('cozexxcope') → 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "2\n", + "2\n" + ] + } + ], + "source": [ + "#code here\n", + "def count_code(strInp):\n", + " findStr1 = 'co'\n", + " findStr2 = 'e'\n", + " count = 0\n", + " strLen = len(strInp)\n", + " for i,x in enumerate(strInp):\n", + " if strInp[i:i+2]==findStr1: \n", + " #for each letter - is that letter and the next equal to start\n", + " if len(strInp[i:strLen]) >=4: #is string long enough?\n", + " if strInp[i+3]==findStr2: # if so is last letter right?\n", + " count+=1\n", + " else:\n", + " count\n", + " return count\n", + "\n", + "#check your code \n", + "print(count_code('aaacodebbb'))\n", + "print(count_code('codexxcode'))\n", + "print(count_code('cozexxcope'))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "16. Lets have one moderate level question for you. \n", + "\n", + "Find the sum of the series 4 +44 + 444 + 4444 + .. n terms\n", + "\n", + "here keep n=5" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sum of the series: 49380\n" + ] + } + ], + "source": [ + "#code here\n", + "def sumSeries(digit,n): \n", + " ones = [ int(\"1\" * i) for i in range(1, n+1)]\n", + " sumSeries = digit * sum(ones)\n", + " return sumSeries\n", + "\n", + "print(f\"Sum of the series: {sumSeries(4,5)}\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "17. Assume s is a string of lower case characters.\n", + "
\n", + "Write a program that counts up the number of vowels contained in the string s. Valid vowels are: 'a', 'e', 'i', 'o', and 'u'. For example, if s = 'azcbobobegghakl', your program should print:
\n", + "```Number of vowels: 5```" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of Vowels : 5\n" + ] + } + ], + "source": [ + "#code here\n", + "def countvowels(string):\n", + " num_vowels=0\n", + " for char in string:\n", + " if char in \"aeiouAEIOU\":\n", + " num_vowels = num_vowels+1\n", + " return num_vowels\n", + "\n", + "print(f\"Number of Vowels : {countvowels('azcbobobegghakl')}\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "18. well done. Now we want you to solve above question in just one line. have faith in your, you can do it. " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of Vowels : 5\n" + ] + } + ], + "source": [ + "# one line code here.\n", + "string = 'azcbobobegghakl'\n", + "numVowel = sum([string.lower().count(x) for x in \"aeiou\"])\n", + "print(f\"Number of Vowels : {numVowel}\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "19. Assume s is a string of lower case characters.\n", + "\n", + "Write a program that prints the number of times the string 'bob' occurs in s. For example, if s = 'azcbobobegghakl', then your program should print\n", + "\n", + "```Number of times bob occurs is: 2```" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of times bob occurs is: 2\n" + ] + } + ], + "source": [ + "#code here\n", + "def countBob(string):\n", + " bobCount = 0\n", + " for x in range(len(string)):\n", + " if string[x:x+3] == 'bob': # From x to three 3 characters ahead.\n", + " bobCount += 1\n", + " return bobCount\n", + "\n", + "print('Number of times bob occurs is: ' + str(countBob('azcbobobegghakl')))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "20. Assume s is a string of lower case characters.\n", + "\n", + "Write a program that prints the longest substring of s in which the letters occur in alphabetical order. For example, if s = 'azcbobobegghakl', then your program should print\n", + "\n", + "```Longest substring in alphabetical order is: beggh```

\n", + "In the case of ties, print the first substring. For example, if s = 'abcbcd', then your program should print\n", + "\n", + "```Longest substring in alphabetical order is: abc```" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Longest substring in alphabetical order is:beggh\n" + ] + } + ], + "source": [ + "#code here\n", + "def alphabetical_order(s):\n", + " first=0\n", + " second=1\n", + " strang1=''\n", + " strang2=''\n", + " while second=len(s):\n", + " break\n", + " elif s[first]<=s[second]:\n", + " strang1+=s[first:second+1]\n", + " while second<=len(s):\n", + " second+=1\n", + " if second>=len(s):\n", + " break\n", + " elif s[second]>=strang1[-1]:\n", + " strang1+=s[second]\n", + " if len(strang1)>len(strang2):\n", + " strang2=strang1\n", + " else:\n", + " if len(strang1)>len(strang2):\n", + " strang2=strang1\n", + " strang1=''\n", + " first=second-1\n", + " break\n", + " else:\n", + " if len(s[first])>len(strang2):\n", + " strang2=s[first]\n", + " first+=1\n", + " second+=1\n", + " print(\"Longest substring in alphabetical order is:\" + strang2)\n", + "\n", + "alphabetical_order('azcbobobegghakl')\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Awsesome! Great job so far. Hope you fell in love with python now.\n", + "\n", + "\n", + "But wait we want to give a treat..:) We have a surprise for you in form of one of the task, in this task you have to create a game in python. You can take up this task as a mini project of your's in python. Hmm.. Sounds good. Isn't it?\n", + "\n", + "So lets gets started.. we have given the instructions below for the task in detail \n", + "\n", + "# Hangman Game\n", + "## In this project we are going to create Hangman Game using python\n", + "\n", + "\n", + "**Q. What is the hangman game?**
\n", + "A:- Hangman is a guessing game. The player will tries to guess a word picked by the computer, by suggesting letters within a certain number of guesses\n", + "\n", + "\n", + "# Task 1\n", + "Create a function **is_word_guessed** that takes in two arguments :-
**secret_word**, **letters_guessed**
**returns True** if all of the letter of secret_word are in letters_guessed, **returns False** if not\n", + "\n", + "\n", + "**Assumptions**
\n", + "**secret_word**: string, the word the user is guessing; assumes all letters are lowercase
\n", + "**letters_guessed**: list (of letters), which letters have been guessed so far; assumes that all letters are lowercase
\n", + "\n", + "**Example**:-
\n", + "secret_word = 'apple'
\n", + "letters_guessed = ['e', 'a', 'k', 'p', 'l', 's']
\n", + "is_word_guessed() will return True.

\n", + "secret_word = 'apple'
\n", + "letters_guessed = ['e', 'i', 'k', 'p', 'r', 's']
\n", + "is_word_guessed() will return False.

\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n", + "False\n" + ] + } + ], + "source": [ + "def is_word_guessed(secret_word, letters_guessed):\n", + " # Code here\n", + " chkFlag = False\n", + " for char in secret_word:\n", + " if char in letters_guessed:\n", + " chkFlag = True\n", + " else:\n", + " chkFlag = False\n", + " break\n", + " return chkFlag\n", + "\n", + "secret_word = 'apple'\n", + "letters_guessed = ['e', 'a', 'k', 'p', 'l', 's']\n", + "\n", + "print(is_word_guessed(secret_word,letters_guessed))\n", + "\n", + "secret_word = 'apple'\n", + "letters_guessed = ['e', 'i', 'k', 'p', 'r', 's']\n", + "\n", + "print(is_word_guessed(secret_word,letters_guessed))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Task 2\n", + "Create a function **get_guessed_word** that takes in two arguments :-
**secret_word**, **letters_guessed**
**returns** string, comprised of known letters, and unknown letters represented by an underscore and a space (_ )
\n", + "\n", + "**Assumptions**
\n", + "**secret_word**: string, the word the user is guessing;
\n", + "**letters_guessed**: list (of letters), which letters have been guessed so far
\n", + "\n", + "**Example**:-
\n", + "secret_word = 'apple'
\n", + "letters_guessed = ['e', 'i', 'k', 'p', 'r', 's']
\n", + "get_guessed_word() will return '_ pp_ e'\n", + "\n", + "```\n", + "You want something like a_ _ _ d_ j and Not a___d_j,\n", + "which might make it hard for the user to know how many characters are there to be guessed, \n", + "that's why you want to use '_ ' instead of '_'\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "_ pp_ e\n" + ] + } + ], + "source": [ + "# importing modules needed for the project\n", + "import random\n", + "import string\n", + "\n", + "def get_guessed_word(secret_word, letters_guessed): \n", + "# code here\n", + " letter_formed = []\n", + " for char in secret_word:\n", + " if char in letters_guessed:\n", + " letter_formed.append(char)\n", + " else:\n", + " letter_formed.append('_ ')\n", + " stringAns = ''.join(letter_formed)\n", + " return stringAns\n", + "\n", + "secret_word = 'apple'\n", + "letters_guessed = ['e', 'i', 'k', 'p', 'r', 's']\n", + "print(get_guessed_word(secret_word,letters_guessed))\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Task 3\n", + "\n", + "Create a function **get_available_letter** that takes in one arguments
**letters_guessed**
**returns** string (of letters), comprised of letters that represents which letters have not yet been guessed.\n", + "\n", + "**Assumptions**
\n", + "**letters_guessed**: list (of letters), which letters have been guessed so far;
\n", + "\n", + "**Example**:-
\n", + "letters_guessed = [’a’, ’l’, ’m’]
\n", + "get_available_letter() will return 'bcdefghijknopqrstuvwxyz'
\n", + "```\n", + "You might want to consider using string.ascii_lowercase :=\n", + "\n", + "import string\n", + "print(string.ascii_lowercase)\n", + "output:- abcdefghijklmnopqrstuvwxyz\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bcdefghijknopqrstuvwxyz\n" + ] + } + ], + "source": [ + "import string\n", + "def get_available_letters(letters_guessed):\n", + " '''\n", + " letters_guessed: list (of letters), which letters have been guessed so far\n", + " returns: string (of letters), comprised of letters that represents which letters have not\n", + " yet been guessed.\n", + " '''\n", + " # FILL IN YOUR CODE HERE \n", + " available_list = list(string.ascii_lowercase)\n", + " letter_notmatch = []\n", + " for char in available_list:\n", + " if char in letters_guessed:\n", + " continue\n", + " else:\n", + " letter_notmatch.append(char)\n", + " \n", + " return ''.join(letter_notmatch)\n", + "\n", + "letters_guessed = ['a', 'l', 'm']\n", + "print(get_available_letters(letters_guessed)) \n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Great, We have created all of the Helper functions, now let's start our work on the actual Hangman Game\n", + "\n", + "# Hangman Game\n", + "\n", + "Create a function **hangman** that takes in one argument
\n", + "**secret_word** :- string, the secret word to guess.
\n", + "\n", + "**The function should do the following**:-
\n", + "Starts up an interactive game of Hangman.\n", + "\n", + "* At the start of the game, let the user know how many letters the secret_word contains and how many guesses s/he starts with.\n", + "\n", + "* The user should start with 6 guesses\n", + "\n", + "* Before each round, you should display to the user how many guesses s/he has left and the letters that the user has not yet guessed.\n", + "\n", + "* Ask the user to supply one guess per round. Remember to make sure that the user puts in a letter!\n", + "\n", + "* The user should receive feedback immediately after each guess about whether their guess appears in the computer's word.\n", + "\n", + "* After each guess, you should display to the user the partially guessed word so far.\n", + "\n", + "* If the user inputs a letter that hasn’t been guessed before and the letter is in the secret word, the user loses no guesses.\n", + "\n", + "* Consonants: If the user inputs a consonant that hasn’t been guessed and the consonant is not in the secret word, the user loses one guess if it’s a consonant.\n", + "* Vowels: If the vowel hasn’t been guessed and the vowel is not in the secret word, the user loses two guesses. Vowels are a, e, i, o, and u. y does not count as a vowel.\n", + "\n", + "* The game should end when the user constructs the full word or runs out of guesses.\n", + "* If the player runs out of guesses before completing the word, tell them they lost and reveal the word to the user when the game ends.\n", + "* If the user wins, print a congratulatory message and tell the user their score.\n", + "* The total score is the number of guesses_remaining once the user has guessed the secret_word times the number of unique letters in secret_word.\n", + "```\n", + "Total score = guesses_remaining * number unique letters in secret_word\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Demo Game 1\n", + "```\n", + "Welcome to the game Hangman!\n", + "I am thinking of a word that is 4 letters long.\n", + "-------------\n", + "You have 6 guesses left.\n", + "Available letters: abcdefghijklmnopqrstuvwxyz\n", + "Please guess a letter: ​a\n", + "Good guess: _ a_ _\n", + "------------\n", + "You have 6 guesses left.\n", + "Available letters: bcdefghijklmnopqrstuvwxyz\n", + "Please guess a letter: ​s\n", + "Oops! That letter is not in my word.\n", + "Please guess a letter: _ a_ _\n", + "------------\n", + "You have 5 guesses left.\n", + "Available letters: bcdefghijklmnopqrtuvwxyz\n", + "Please guess a letter: ​t\n", + "Good guess: ta_ t\n", + "------------\n", + "You have 5 guesses left.\n", + "Available letters: bcdefghijklmnopqrtuvwxyz\n", + "Please guess a letter: ​e\n", + "Oops! That letter is not in my word: ta_ t\n", + "------------\n", + "You have 3 guesses left.\n", + "Available letters: bcdfghijklnopquvwxyz Please guess a letter: ​c\n", + "Good guess: tact\n", + "------------\n", + "Congratulations, you won!\n", + "Your total score for this game is: 6\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Demo Game 2\n", + "```\n", + "Welcome to the game Hangman!\n", + "I am thinking of a word that is 4 letters long\n", + "-----------\n", + "You have 6 guesses left\n", + "Available Letters: abcdefghijklmnopqrstuvwxyz\n", + "Please guess a letter: ​a\n", + "Oops! That letter is not in my word: _ _ _ _\n", + "-----------\n", + "You have 4 guesses left\n", + "Available Letters: bcdefghijklmnopqrstuvwxyz\n", + "Please guess a letter: ​b\n", + "Oops! That letter is not in my word: _ _ _ _\n", + "-----------\n", + "You have 3 guesses left\n", + "Available Letters: cdefghijklmnopqrstuvwxyz\n", + "Please guess a letter: ​c\n", + "Oops! That letter is not in my word: _ _ _ _\n", + "-----------\n", + "You have 2 guesses left\n", + "Available Letters: defghijklmnopqrstuvwxyz\n", + "Please guess a letter: ​d\n", + "Oops! That letter is not in my word: _ _ _ _\n", + "-----------\n", + "You have 1 guesses left\n", + "Available Letters: efghijklmnopqrstuvwxyz\n", + "Please guess a letter: ​e\n", + "Good guess: e_ _ e\n", + "-----------\n", + "You have 1 guesses left\n", + "Available Letters: fghijklmnopqrstuvwxyz\n", + "Please guess a letter: ​f\n", + "Oops! That letter is not in my word: e_ _ e\n", + "-----------\n", + "Sorry, you ran out of guesses. The word was else.\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Hints\n", + "**Try to keep the output as similar to the one's above**
\n", + "**Hints:-**\n", + "```\n", + "1. Consider writing additional helper functions if you need them.\n", + "2. There are four important pieces of information you may wish to store:\n", + "a. secret_word​: The word to guess. This is already used as the parameter name for the ​hangman​ function.\n", + "b. letters_guessed​: The letters that have been guessed so far. If they guess a letter that is already in ​letters_guessed​, you should print a message telling them they've already guessed that but do not penalize them for it.\n", + "c. guesses_remaining​: The number of guesses the user has left. Note that in our example game, the penalty for choosing an incorrect vowel is different than the penalty for choosing an incorrect consonant.\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Welcome to the game Hangman!\n", + "I am thinking of a word that is 5 letters long.\n", + "-----------\n", + "You have 6 guesses left\n", + "Available Letters:abcdefghijklmnopqrstuvwxyz\n", + "Please guess a letter: a\n", + "Good guess: a_ _ _ _ \n", + "-----------\n", + "You have 6 guesses left\n", + "Available Letters:abcdefghijklmnopqrstuvwxyz\n", + "Please guess a letter: p\n", + "Good guess: app_ _ \n", + "-----------\n", + "You have 6 guesses left\n", + "Available Letters:abcdefghijklmnopqrstuvwxyz\n", + "Please guess a letter: p\n", + "You have already guessed this letter, please guess again\n", + "-----------\n", + "You have 6 guesses left\n", + "Available Letters:abcdefghijklmnopqrstuvwxyz\n", + "Please guess a letter: l\n", + "Good guess: appl_ \n", + "-----------\n", + "You have 6 guesses left\n", + "Available Letters:abcdefghijklmnopqrstuvwxyz\n", + "Please guess a letter: e\n", + "Good guess: apple\n", + "Congratulations, you won!\n", + "Your total score for this game is: 24\n" + ] + } + ], + "source": [ + "\n", + "def no_of_unique_words(string):\n", + " #code here\n", + " unique = []\n", + " for char in string[::]:\n", + " if char not in unique:\n", + " unique.append(char)\n", + " return len(unique)\n", + "\n", + "def checkVowelConsonent(letter):\n", + " if letter in \"aeiouAEIOU\":\n", + " return 2\n", + " else:\n", + " return 1\n", + " \n", + "def hangman(secret_word):\n", + " #code here\n", + " guess = 6\n", + " wordLen = len(secret_word)\n", + " guessList = []\n", + " chkFlag = False\n", + " stringForm = ''\n", + " print(\"Welcome to the game Hangman!\")\n", + " print(f\"I am thinking of a word that is {wordLen} letters long.\") \n", + " while guess>0:\n", + " print(\"-----------\")\n", + " print(f\"You have {guess} guesses left\")\n", + " print(f\"Available Letters:{get_available_letters('')}\")\n", + " guessInp = input('Please guess a letter: ')\n", + " if guessInp.isalpha(): \n", + " if guessInp in guessList:\n", + " print(\"You have already guessed this letter, please guess again\")\n", + " else:\n", + " guessList.append(guessInp)\n", + " chkFlag = is_word_guessed(guessList,secret_word)\n", + " if chkFlag == True:\n", + " stringForm = get_guessed_word(secret_word,guessList)\n", + " print(f\"Good guess: {stringForm}\")\n", + " else:\n", + " stringForm = get_guessed_word(secret_word,guessList)\n", + " guessList = guessList[:-1]\n", + " print(f\"Oops! That letter is not in my word: {stringForm}\")\n", + " guess -= checkVowelConsonent(guessInp)\n", + " if stringForm == secret_word:\n", + " print(\"Congratulations, you won!\")\n", + " score = guess * no_of_unique_words(secret_word)\n", + " print(f\"Your total score for this game is: {score}\")\n", + " break\n", + " elif guess <= 0:\n", + " print(f\"Sorry, you ran out of guesses. The word was {secret_word}.\")\n", + " break\n", + " else:\n", + " print(\"Please enter string only\")\n", + " continue\n", + " \n", + "hangman('apple') " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# When you've completed your hangman function, test it out to see it is working fine\n", + "# (hint: you might want to pick your own\n", + "# secret_word while you're doing your own testing by changing 'apple' to any other string)\n", + "hangman('apple')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Congratulations all of your hardwork paid of, you have just created the Hangman Game
\n", + "**now go ahead and play the game you created, run the cell below**\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Welcome to the game Hangman!\n", + "I am thinking of a word that is 3 letters long.\n", + "-----------\n", + "You have 6 guesses left\n", + "Available Letters:abcdefghijklmnopqrstuvwxyz\n", + "Please guess a letter: e\n", + "Oops! That letter is not in my word: _ _ _ \n", + "-----------\n", + "You have 4 guesses left\n", + "Available Letters:abcdefghijklmnopqrstuvwxyz\n", + "Please guess a letter: r\n", + "Good guess: _ _ r\n", + "-----------\n", + "You have 4 guesses left\n", + "Available Letters:abcdefghijklmnopqrstuvwxyz\n", + "Please guess a letter: g\n", + "Oops! That letter is not in my word: _ _ r\n", + "-----------\n", + "You have 3 guesses left\n", + "Available Letters:abcdefghijklmnopqrstuvwxyz\n", + "Please guess a letter: w\n", + "Oops! That letter is not in my word: _ _ r\n", + "-----------\n", + "You have 2 guesses left\n", + "Available Letters:abcdefghijklmnopqrstuvwxyz\n", + "Please guess a letter: f\n", + "Good guess: f_ r\n", + "-----------\n", + "You have 2 guesses left\n", + "Available Letters:abcdefghijklmnopqrstuvwxyz\n", + "Please guess a letter: u\n", + "Good guess: fur\n", + "Congratulations, you won!\n", + "Your total score for this game is: 6\n" + ] + } + ], + "source": [ + "words = ['army', 'beautiful', 'became', 'if', 'actually', 'beside', 'between','come','eye','five','fur','imposter', 'problem' ,'revenge' ,'few' ,'circle' ,'district','trade','quota','stop','depressed','disorder','dentist']\n", + "\n", + "#choose a random word from list using random.choice() function\n", + "random_word = random.choice(words)\n", + "\n", + "#check you function\n", + "hangman(random_word)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "--------------------------------------\n", + "Wohooo! You did a really good job. We hope you enjoyed your first mini python project here. \n", + "\n", + "We understand it was bit challenging and time taking, but it's worth it, coz here you are to achieve your goal and this course will help you in all posible way to make your dreams come true.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "----------------------------------------------------------------------" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Bam!, you completed the second milestone challenge too:)!! " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# FeedBack\n", + "We hope you’ve enjoyed this course so far. We’re committed to help you use \"AI for All\" course to its full potential, so that you have a great learning experience. And that’s why we need your help in form of a feedback here.\n", + "\n", + "Please fill this feedback form https://docs.google.com/forms/d/e/1FAIpQLSfjBmH0yJSSA34IhSVx4h2eDMgOAeG4Dk-yHid__NMTk3Hq5g/viewform" + ] + } + ], + "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.8" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/Basic/python_reloaded_withoutcode.ipynb b/Basic/python_reloaded_withoutcode.ipynb new file mode 100644 index 0000000..28d447e --- /dev/null +++ b/Basic/python_reloaded_withoutcode.ipynb @@ -0,0 +1,11888 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "31TVqzSyrP3-" + }, + "source": [ + "\n", + "


Python Python Everywhere

" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Bc3xJTPCrP4C" + }, + "source": [ + "# `What you can do with Python?`\n", + "

fields where you can use Python with Libraries & Frameworks

\n", + "\n", + "|OpenCV| Web Scrapping | Machine Learning | Automation Testing | Web Development | Game Devlopment |\n", + "| --- | --- | --- | --- | --- | --- | \n", + "|* Sciki-image |* Selenium |* Pandas |* PyUnit |* Flask |* Pand3d\n", + "|* OpenCV |* Beautiful Soup|* Numpy |* PyTest |* Django |* Arcade\n", + "|* Pillow |* Requests|* Matplotlib |* Behave |* Web2Py |* PyGlet \n", + "|* Mahotas |* Lxml|* Seaborn |* Robot |* Cheerypy |* PyOpenGl\n", + "|* SimpleITK|* Scrapy |* Scikit-learn |* Splinter |* Bottle|* PyGame\n", + "|*** |*** |* Scipy |*** |* Pyramid |***\n", + "|*** |*** |* Keras |*** |* CubicWeb |***\n", + "|*** |*** |* TensorFlow |*** |* Dash |***\n", + "|*** |*** |* PyTorch |*** |* Falcon |***\n", + "|*** |*** |* Theano |*** |* TurboGears |***\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kcBChyR-rP4D" + }, + "source": [ + "📌 In above table you can see fields like `OpenCV`, `Web Scrapping`, **`Machine Learning`**, `Automation Testing`, `Web Development`, `Game Development`, these are the all field where you can use Python.
\n", + "Yes application of Python are huge and wide
\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "L2OHN1WrrP4D" + }, + "source": [ + "

Important Libraries for ML and Data Science
" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bwA3tk3PrP4E" + }, + "source": [ + "📌 These are the must know libraryies\n", + "* **`Numpy`** - Efficient n-dimensional arrays, Linear Algebra, Random Number capabilities\n", + "* **`Scipy`** - Scientifiv computing tools like Calculus, Signal Processing\n", + "* **`Pandas`** - Data Reading(multiple formats), manipulation and Cleaning in python\n", + "* **`Seaborn`** - Built on top of Matplotlib, provides a high-level interface for drawing attractive and informative charts\n", + "* **`Matplotlib`** - Fundamental library for Data Visualization \n", + "* **`StatsModel`** - Statistical models, Statical tests, Statical data exploration\n", + "* **`Scikit-learn`** - Basic Data Preprocessing, Machine Learning Library" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7_f6JXk4rP4E" + }, + "source": [ + "To learn quick Python I will suggest you to go through:\n", + "1. [Basic Python in 1 Hour](https://www.youtube.com/watch?v=kqtD5dpn9C8)\n", + "2. [Some more Python](https://www.youtube.com/watch?v=_uQrJ0TkZlc)\n", + "\n", + "As you have gone through above link Lets start learning python basic as your first assignment" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "execution": { + "iopub.execute_input": "2021-12-09T12:39:09.415854Z", + "iopub.status.busy": "2021-12-09T12:39:09.415533Z", + "iopub.status.idle": "2021-12-09T12:39:09.431031Z", + "shell.execute_reply": "2021-12-09T12:39:09.429867Z", + "shell.execute_reply.started": "2021-12-09T12:39:09.415823Z" + }, + "id": "ZI9brqKsrP4E" + }, + "source": [ + "
\n", + "
\n", + "


Quick Python Content!

\n", + " \n", + "

Hi Code[1]

\n", + " \n", + "

Variables(Data Types)[2]

\n", + " \n", + "

Assignment Variables & Data Types[3]

\n", + " \n", + "

Operators[4]

\n", + " \n", + "

Assignment Operators[5]

\n", + " \n", + "

Conditional Statements[6]

\n", + "\n", + "

Assignment Conditional Statements[7]

\n", + " \n", + "

Loops[8]

\n", + "\n", + "

Jump Statements[9]

\n", + " \n", + "

Assignment Loops and Jump Statements[10]

\n", + " \n", + "

Python Data Structures[11]

\n", + " \n", + "

Assignment Python Data Structures List[12]

\n", + " \n", + "

Assignment Python Data Structures List&Set[13]

\n", + " \n", + "

Functions[14]

\n", + "

Lambda Expressions[15]

\n", + "

Comprehensions[16]

\n", + "

Enumerate[17]

" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2021-12-15T09:30:23.27029Z", + "iopub.status.busy": "2021-12-15T09:30:23.269935Z", + "iopub.status.idle": "2021-12-15T09:30:23.275676Z", + "shell.execute_reply": "2021-12-15T09:30:23.27429Z", + "shell.execute_reply.started": "2021-12-15T09:30:23.270256Z" + }, + "id": "j1xn21WwrP4G" + }, + "outputs": [], + "source": [ + "# ignore this code continue please\n", + "from IPython.display import HTML" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "yVE7L7dorP4H" + }, + "source": [ + "


Hi, there

" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 321 + }, + "execution": { + "iopub.execute_input": "2021-12-15T09:45:09.056121Z", + "iopub.status.busy": "2021-12-15T09:45:09.05577Z", + "iopub.status.idle": "2021-12-15T09:45:09.14828Z", + "shell.execute_reply": "2021-12-15T09:45:09.147159Z", + "shell.execute_reply.started": "2021-12-15T09:45:09.056087Z" + }, + "id": "9HMHbQzdrP4I", + "outputId": "95ae4364-8b2f-45ff-ecca-256ccc3d299a" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "YouTubeVideo('https://www.youtube.com/watch?v=izgBmCnp1Oc&list=PLsR_0x6BuM-HJZT6Xzj-088N4hN3KsDME&index=1',width=600,height=300)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T05:20:57.005459Z", + "iopub.status.busy": "2021-12-13T05:20:57.005028Z", + "iopub.status.idle": "2021-12-13T05:20:57.039904Z", + "shell.execute_reply": "2021-12-13T05:20:57.038882Z", + "shell.execute_reply.started": "2021-12-13T05:20:57.005334Z" + }, + "id": "kOtDhbwWrP4I", + "outputId": "9eb6735c-a4aa-4146-93ce-80536a6d77f6" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "What is your name! Want to print your name!Partha Prasad Roy Chowdhury\n", + "Hi [Partha Prasad Roy Chowdhury] welcome...\n" + ] + } + ], + "source": [ + "# What is your name! Want to print your name! \n", + "name = input (\"What is your name! Want to print your name!\")\n", + "print('Hi [{}] welcome...'.format(name))\n", + "print('Hi [{}] welcome...'.format(name))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kJxHTHrVrP4I" + }, + "source": [ + "* `()` <= `Parentheses`\n", + "* `''` <= `Single Quotes`\n", + "* `\"\"` <= `Double Quotes`\n", + "* `\\n` <= `New_line `\n", + "* `#` <= `Used to comment inside code`" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T05:35:13.151658Z", + "iopub.status.busy": "2021-12-13T05:35:13.151084Z", + "iopub.status.idle": "2021-12-13T05:35:13.156858Z", + "shell.execute_reply": "2021-12-13T05:35:13.155917Z", + "shell.execute_reply.started": "2021-12-13T05:35:13.151622Z" + }, + "id": "zzmSYJDLrP4I", + "outputId": "e99145c4-2375-4574-dd93-65bfa74b9f85" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hi [Partha Prasad Roy Chowdhury] welcome...\n", + "Hi [Partha Prasad Roy Chowdhury] welcome...\n" + ] + } + ], + "source": [ + "# Only use one print function\n", + "# \\n <= it will break current line \n", + "print('Hi [{}] welcome...\\nHi [{}] welcome...'.format(name,name))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "W23eDrScrP4I" + }, + "source": [ + "


Variables

" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 321 + }, + "execution": { + "iopub.execute_input": "2021-12-15T09:51:00.736548Z", + "iopub.status.busy": "2021-12-15T09:51:00.736222Z", + "iopub.status.idle": "2021-12-15T09:51:00.827208Z", + "shell.execute_reply": "2021-12-15T09:51:00.826553Z", + "shell.execute_reply.started": "2021-12-15T09:51:00.736516Z" + }, + "id": "NCNBX8-JrP4J", + "outputId": "b982ff6f-9fc9-4aa0-9fe3-02a89aefddde" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# variable-1\n", + "YouTubeVideo('https://www.youtube.com/watch?v=YdDfEbaUPJs&list=PLsR_0x6BuM-HJZT6Xzj-088N4hN3KsDME&index=2',width=600,height=300)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 321 + }, + "execution": { + "iopub.execute_input": "2021-12-15T09:53:24.171386Z", + "iopub.status.busy": "2021-12-15T09:53:24.170957Z", + "iopub.status.idle": "2021-12-15T09:53:24.262105Z", + "shell.execute_reply": "2021-12-15T09:53:24.261429Z", + "shell.execute_reply.started": "2021-12-15T09:53:24.171349Z" + }, + "id": "0MVVoi-drP4J", + "outputId": "49f4c001-64f4-49e6-b84b-2ea6d47b9945" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# variable-2\n", + "YouTubeVideo('https://www.youtube.com/watch?v=gOcRxdGovhc&list=PLsR_0x6BuM-HJZT6Xzj-088N4hN3KsDME&index=3',width=600,height=300)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "execution": { + "iopub.execute_input": "2021-12-13T05:40:01.121499Z", + "iopub.status.busy": "2021-12-13T05:40:01.12116Z", + "iopub.status.idle": "2021-12-13T05:40:01.126402Z", + "shell.execute_reply": "2021-12-13T05:40:01.125708Z", + "shell.execute_reply.started": "2021-12-13T05:40:01.121464Z" + }, + "id": "hqiWhz6srP4K" + }, + "outputs": [], + "source": [ + "# define variables named as with values: mukesh 7, z 6, rohan 5, longitude 4,\n", + "mukesh = 7\n", + "z = 6\n", + "rohan = 5\n", + "longitude = 4" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T05:40:18.616711Z", + "iopub.status.busy": "2021-12-13T05:40:18.615837Z", + "iopub.status.idle": "2021-12-13T05:40:18.625081Z", + "shell.execute_reply": "2021-12-13T05:40:18.624216Z", + "shell.execute_reply.started": "2021-12-13T05:40:18.616672Z" + }, + "id": "W77FFVIqrP4K", + "outputId": "cf4ab741-3257-4600-b001-640f62879305" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n" + ] + } + ], + "source": [ + "# print required variable\n", + "print(rohan)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "89kwQhu5rP4K" + }, + "source": [ + "Variable Assignment:\n", + "**`Variable_Name = Value`**\n", + "\n", + "Variables Naming Rules:\n", + "* `Python is case-senstive` => x=5 is different from X=5 (one is lowe and other is upper case)\n", + "* `var name can't start with special character except underscore(_)` => _X = 7 is `valid`, @X = 7 is `invalid`\n", + "* `var name can't start with number` => 9X = 7 is `invalid`, X9 = 7 is `valid`\n", + "* can't use `keywords` as a variable name\n", + " * " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hiYt4qiJrP4K" + }, + "source": [ + "# * **`Declaring a Variable`**
\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "execution": { + "iopub.execute_input": "2021-12-13T05:47:55.408175Z", + "iopub.status.busy": "2021-12-13T05:47:55.407825Z", + "iopub.status.idle": "2021-12-13T05:47:55.413447Z", + "shell.execute_reply": "2021-12-13T05:47:55.412668Z", + "shell.execute_reply.started": "2021-12-13T05:47:55.40814Z" + }, + "id": "5pomjoc_rP4L" + }, + "outputs": [], + "source": [ + "# declare 4 variables with values as: ur_age 21,ur_weight 50.6, ur_first_name = 'Mukesh',ur_last_name = \"Manral\", TrueOrFalse compare if ur_last_name == ur_first_name\n", + "ur_age=21\n", + "ur_weight=50.6\n", + "ur_first_name = 'Mukesh'\n", + "ur_last_name = \"Manral\"\n", + "def compare(x,y):\n", + " if x == y:\n", + " return True\n", + " else:\n", + " return False\n", + "TrueorFalse = compare(ur_last_name,ur_first_name)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "aD6_WvkKrP4L" + }, + "source": [ + "# * **`Data Type(Type of variable)`**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "snzoPkD3rP4L" + }, + "source": [ + "| Name | Type | Description |\n", + "| ---- | ---- | ----| \n", + "|Integers | int | Integer number, like 34,-56 ...|\n", + "|Float | float | Decimal number, like 3.4,-5.6 ...|\n", + "|String| str | Ordered sequence of characters, like 'your name' |\n", + "|Boolean |bool |Logical values indicating True or False only |" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T05:48:10.44207Z", + "iopub.status.busy": "2021-12-13T05:48:10.441594Z", + "iopub.status.idle": "2021-12-13T05:48:10.449074Z", + "shell.execute_reply": "2021-12-13T05:48:10.448114Z", + "shell.execute_reply.started": "2021-12-13T05:48:10.442018Z" + }, + "id": "Bb_fmhaOrP4L", + "outputId": "6bca97e1-0501-4cc3-fde2-7753f1ccbb1e" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n" + ] + } + ], + "source": [ + "# print type of ur_age,ur_weight,ur_first_name,ur_last_name variables\n", + "print(type(ur_age))\n", + "print(type(ur_weight))\n", + "print(type(ur_first_name))\n", + "print(type(ur_last_name))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T05:49:37.869716Z", + "iopub.status.busy": "2021-12-13T05:49:37.86939Z", + "iopub.status.idle": "2021-12-13T05:49:37.875995Z", + "shell.execute_reply": "2021-12-13T05:49:37.875066Z", + "shell.execute_reply.started": "2021-12-13T05:49:37.869681Z" + }, + "id": "iaADKqUwrP4L", + "outputId": "b9ad6169-2218-45a0-aa88-dd710eafda97" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "21\n", + "50.6\n", + "Mukesh\n", + "Manral\n", + "False\n" + ] + } + ], + "source": [ + "# print values of ur_age,ur_weight,ur_first_name,ur_last_name variables\n", + "print(ur_age)\n", + "print(ur_weight)\n", + "print(ur_first_name)\n", + "print(ur_last_name)\n", + "print(TrueorFalse)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T05:50:49.32591Z", + "iopub.status.busy": "2021-12-13T05:50:49.325048Z", + "iopub.status.idle": "2021-12-13T05:50:49.332343Z", + "shell.execute_reply": "2021-12-13T05:50:49.331287Z", + "shell.execute_reply.started": "2021-12-13T05:50:49.325858Z" + }, + "id": "Hde3D2uQrP4L", + "outputId": "c1a16b4e-14d9-402d-c994-a26d2bde4a50" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n" + ] + } + ], + "source": [ + "# make 2 variables with values as: ur_first_name 'Mukesh',ur_last_name'Mukesh' \n", + "ur_first_name = 'Mukesh'\n", + "ur_last_name = 'Mukesh'\n", + "# make a variable TrueOrFalse which will have comparison of variables ur_last_name == ur_first_name \n", + "TrueOrFalse = compare(ur_first_name,ur_last_name)\n", + "print(TrueOrFalse)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T05:51:34.885949Z", + "iopub.status.busy": "2021-12-13T05:51:34.885484Z", + "iopub.status.idle": "2021-12-13T05:51:34.891761Z", + "shell.execute_reply": "2021-12-13T05:51:34.890717Z", + "shell.execute_reply.started": "2021-12-13T05:51:34.885913Z" + }, + "id": "XvFvwpEQrP4L", + "outputId": "b5852d9d-3f96-4094-9c3f-f0eaa5563a31" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Name is: Mukesh and age is: 21\n" + ] + } + ], + "source": [ + "# print variables named as (your name and your age)\n", + "print('Name is: {} and age is: {}'.format(ur_first_name,ur_age))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "SLTS9twurP4L" + }, + "source": [ + "# *How Variables works in Python\n", + "[To see how python code is being executed internally](https://pythontutor.com/visualize.html#mode=display)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T06:26:21.636531Z", + "iopub.status.busy": "2021-12-13T06:26:21.636233Z", + "iopub.status.idle": "2021-12-13T06:26:21.642175Z", + "shell.execute_reply": "2021-12-13T06:26:21.641262Z", + "shell.execute_reply.started": "2021-12-13T06:26:21.636499Z" + }, + "id": "2XCoERjmrP4L", + "outputId": "6aff9785-0cd2-4904-c682-ecbee81b01b4" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3\n", + "10\n" + ] + } + ], + "source": [ + "# quick variables swap\n", + "# define 3 variables with values as :x 10, y = x,x 3 \n", + "x = 10\n", + "y = x\n", + "x = 3\n", + "# print x,y\n", + "print(x)\n", + "print(y)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kpSfcblGrP4M" + }, + "source": [ + "\n", + "


Assignment Variables & Data Types

" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 321 + }, + "execution": { + "iopub.execute_input": "2021-12-15T09:54:41.557518Z", + "iopub.status.busy": "2021-12-15T09:54:41.556979Z", + "iopub.status.idle": "2021-12-15T09:54:41.649828Z", + "shell.execute_reply": "2021-12-15T09:54:41.64911Z", + "shell.execute_reply.started": "2021-12-15T09:54:41.557474Z" + }, + "id": "XVCrFABorP4M", + "outputId": "1938188f-6542-4046-de6b-898f6eb73659" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Data Structures\n", + "YouTubeVideo('https://www.youtube.com/watch?v=R0yDN07Jw_c&list=PLsR_0x6BuM-HJZT6Xzj-088N4hN3KsDME&index=4',width=600,height=300)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "mrQh_aU8rP4M" + }, + "source": [ + "📌 `When you create a variable you keep some space in memory. These memory locations are then used to store values`" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "execution": { + "iopub.execute_input": "2021-12-13T06:51:26.536827Z", + "iopub.status.busy": "2021-12-13T06:51:26.536555Z", + "iopub.status.idle": "2021-12-13T06:51:26.540484Z", + "shell.execute_reply": "2021-12-13T06:51:26.539662Z", + "shell.execute_reply.started": "2021-12-13T06:51:26.536795Z" + }, + "id": "39JWxM7KrP4M" + }, + "outputs": [], + "source": [ + "# define a variable name \"x\" and assign value 777 to it\n", + "x = 777" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "QXnovK7lrP4M" + }, + "source": [ + "* To view some data on screen, python have `print` function\n", + " * Using `print` function we can control view on output screen\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T06:51:37.038441Z", + "iopub.status.busy": "2021-12-13T06:51:37.038136Z", + "iopub.status.idle": "2021-12-13T06:51:37.043423Z", + "shell.execute_reply": "2021-12-13T06:51:37.04243Z", + "shell.execute_reply.started": "2021-12-13T06:51:37.038407Z" + }, + "id": "vhpXKHMkrP4M", + "outputId": "a336a908-1fb6-4cf8-ba49-ee9eb01d43d3" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "777\n" + ] + } + ], + "source": [ + "# print value of variable x\n", + "print(x)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "slh282AprP4M" + }, + "source": [ + "# *Identifiers in Python\n", + "* Like Variables, we have to define `Functions`, `Classes` etc in python\n", + " * Naming them helps to differentiate one entity from another\n", + "* All these names given to these entities are known as `Identifiers`. \n", + "* Python have some rules to define Identifiers\n", + "\n", + "\n", + "***Rules of Writing Identifiers***\n", + "\n", + "* Python is case sensitive language.\n", + "* Identifiers can be a combination of letters in lowercase (a to z) or uppercase (A to Z) or digits (0 to 9) or an underscore _. \n", + " * Names like myVariable, var_1 and print_this, all are valid example.\n", + "* An identifier cannot start with a digit\n", + "* `1variable` is invalid, but `variable1` is perfectly fine\n", + "* We cannot use special symbols like !, @, #, $, % etc. in our identifier. `_` is allowed\n", + "* ***`Keywords` cannot be used as identifiers => `Keywords` are the reserved words in Python***\n", + "\n", + "---\n", + "***Keywords in Python***\n", + "\n", + "---\n", + "\n", + "* `False`\n", + "* `class`\n", + "* `finally`\n", + "* `is`\n", + "* `return`\n", + "* `None`\n", + "* `continue`\n", + "* `for`\n", + "* `lambda`\n", + "* `try`\n", + "* `True`.. etc\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "SrryZ3enrP4N" + }, + "source": [ + "# 📌 Type Conversion\n", + "\n", + "\n", + "***Python defines type conversion functions to directly convert one data type to another.***" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T06:53:09.525961Z", + "iopub.status.busy": "2021-12-13T06:53:09.525149Z", + "iopub.status.idle": "2021-12-13T06:53:09.531427Z", + "shell.execute_reply": "2021-12-13T06:53:09.530796Z", + "shell.execute_reply.started": "2021-12-13T06:53:09.525923Z" + }, + "id": "yeQ9bxJtrP4N", + "outputId": "1a996f30-5420-4328-9dbb-7b26801b3e7e" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "26.33333\n", + "26\n" + ] + } + ], + "source": [ + "#convert float to integer\n", + "\n", + "#1. make a variable named as my_weight_float with datatype float and value 26.33333\n", + "#2. make another var named as my_weight_int change above variable datatype to int \n", + "#3. print data type of my_weight_float and my_weight_int\n", + "#4. print my_weight_float and my_weight_int\n", + "my_weight_float=26.33333\n", + "my_weight_int = int(my_weight_float)\n", + "print(type(my_weight_float))\n", + "print(type(my_weight_int))\n", + "print(my_weight_float)\n", + "print(my_weight_int)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "cx_jl2V9rP4N" + }, + "source": [ + " ➕ if we try to add string and integer number, it will give an error" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 166 + }, + "execution": { + "iopub.execute_input": "2021-12-13T06:54:05.196633Z", + "iopub.status.busy": "2021-12-13T06:54:05.196028Z", + "iopub.status.idle": "2021-12-13T06:54:05.210193Z", + "shell.execute_reply": "2021-12-13T06:54:05.209093Z", + "shell.execute_reply.started": "2021-12-13T06:54:05.196593Z" + }, + "id": "uap3_C2JrP4N", + "outputId": "c9591833-94df-4411-9eff-c0e370c26a97" + }, + "outputs": [ + { + "ename": "TypeError", + "evalue": "can only concatenate str (not \"int\") to str", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# make a variable name with value as: adding_string_and_number '3' + 7\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0madding_string_and_number\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'3'\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m7\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str" + ] + } + ], + "source": [ + "# make a variable name with value as: adding_string_and_number '3' + 7\n", + "adding_string_and_number = '3'+7" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T06:54:35.120497Z", + "iopub.status.busy": "2021-12-13T06:54:35.120169Z", + "iopub.status.idle": "2021-12-13T06:54:35.128054Z", + "shell.execute_reply": "2021-12-13T06:54:35.127418Z", + "shell.execute_reply.started": "2021-12-13T06:54:35.120468Z" + }, + "id": "cJoissQsrP4N", + "outputId": "69dc47c4-d251-447f-a632-a976c32f792d" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10\n" + ] + } + ], + "source": [ + "# convert above string '3' to integer and then add both '3' and 7 and save in variable named as adding_string_and_number\n", + "# called type conversion: string to int\n", + "adding_string_and_number = int('3')+7\n", + "\n", + "# print variable adding_string_and_number\n", + "print(adding_string_and_number)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T06:55:34.559173Z", + "iopub.status.busy": "2021-12-13T06:55:34.558333Z", + "iopub.status.idle": "2021-12-13T06:55:34.564574Z", + "shell.execute_reply": "2021-12-13T06:55:34.563731Z", + "shell.execute_reply.started": "2021-12-13T06:55:34.559128Z" + }, + "id": "a4Wu-bO8rP4N", + "outputId": "06078d3f-60e1-4f35-a6bf-4221ba05f65f" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "This is friend's money: 21\n", + "This is your money: 18\n" + ] + } + ], + "source": [ + "# make two variables with values as: ur_money 18 and frnd_money 21 \n", + "ur_money=18\n", + "frnd_money=21\n", + "# now use f string in print to see how much mony you and your friend have\n", + "print(f\"This is friend's money: {frnd_money}\")\n", + "print(f\"This is your money: {ur_money}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T06:56:35.5304Z", + "iopub.status.busy": "2021-12-13T06:56:35.530114Z", + "iopub.status.idle": "2021-12-13T06:56:35.535706Z", + "shell.execute_reply": "2021-12-13T06:56:35.534886Z", + "shell.execute_reply.started": "2021-12-13T06:56:35.530371Z" + }, + "id": "oQqq8x-MrP4N", + "outputId": "94f46305-be67-4ada-a00a-0d28f611402a" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "This is friend's money: 18\n", + "This is your money: 21\n" + ] + } + ], + "source": [ + "# swap your money with friend money values\n", + "temp_var = frnd_money\n", + "frnd_money = ur_money\n", + "ur_money = temp_var\n", + "\n", + "# now use f string in print to see how much mony you and your friend have now after swap\n", + "print(f\"This is friend's money: {frnd_money}\")\n", + "print(f\"This is your money: {ur_money}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "HhJfWRpjrP4N" + }, + "source": [ + "# *Python Data Structures" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "O5yhDZLmrP4O" + }, + "source": [ + "| Name | Type | Description |\n", + "| ---- | ---- | ----| \n", + "|List | list | Ordered sequence of various data types, like [34,'name',3.4]|\n", + "|Dictionary | dict | Unordered sequence of `key-values pair`, like {'age':34,'age1:56'}|\n", + "|Tuples | tup | Non-mutable sequence of data type, like (34,56,'name')|\n", + "|Set |set | Collection of unique elements, like ('id','last_name')|" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bhaTCL9trP4O" + }, + "source": [ + "|Type|Mutability|Comments|\n", + "|----|----|----|\n", + "int |immutable|\n", + "float|immutable|\n", + "string|immutable|\n", + "bool |immutable|\n", + "frozenset|immutable|immutable version of set\n", + "tuple|immutable|immutable version of list\n", + "list|mutable|\n", + "set |mutable|\n", + "dict|mutable|\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5zCDIkJJrP4O" + }, + "source": [ + "💫 `immutable` => `can't be changed`
\n", + "💫 `mutable` => `can be changed`" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hABElii_rP4O" + }, + "source": [ + "---\n", + "### Proff that string is immutable" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 218 + }, + "execution": { + "iopub.execute_input": "2021-12-14T06:23:01.639893Z", + "iopub.status.busy": "2021-12-14T06:23:01.639413Z", + "iopub.status.idle": "2021-12-14T06:23:01.715374Z", + "shell.execute_reply": "2021-12-14T06:23:01.71365Z", + "shell.execute_reply.started": "2021-12-14T06:23:01.63985Z" + }, + "id": "Bh7K7FPCrP4O", + "outputId": "81af0d23-dd7d-4330-a7d2-283821447e61" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "M\n" + ] + }, + { + "ename": "TypeError", + "evalue": "'str' object does not support item assignment", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0;31m# acess Letter M\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwhere_to_learn_MLandDL\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m \u001b[0mwhere_to_learn_MLandDL\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"M\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment" + ] + } + ], + "source": [ + "# can't reassign \n", + "\n", + "# make a varible with value as: where_to_learn_MLandDL 'CloudyML'\n", + "where_to_learn_MLandDL = 'CloudyML'\n", + "# print type of variable\n", + "print(type(where_to_learn_MLandDL))\n", + "# acess Letter M\n", + "print(where_to_learn_MLandDL[-2])\n", + "where_to_learn_MLandDL[-1] = \"M\"" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-14T06:25:18.517274Z", + "iopub.status.busy": "2021-12-14T06:25:18.516942Z", + "iopub.status.idle": "2021-12-14T06:25:18.527458Z", + "shell.execute_reply": "2021-12-14T06:25:18.52641Z", + "shell.execute_reply.started": "2021-12-14T06:25:18.517237Z" + }, + "id": "b3IB3yQbrP4O", + "outputId": "424448b4-2c62-4825-8688-a5ad018eb409" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "C = 140303241649456\n", + "l = 140303241617328\n", + "o = 140303207845552\n", + "u = 140303239837424\n", + "d = 140303207845232\n", + "y = 140303243015664\n", + "M = 140303241940016\n", + "L = 140303240053104\n", + "D = 140303241740528\n", + "L = 140303240053104\n" + ] + } + ], + "source": [ + "# make a variable with value as: where_to_learn_MLandDL 'CloudyMLDL'\n", + "where_to_learn_MLandDL = 'CloudyMLDL'\n", + "\n", + "# try to loop in range of (0,10) and try to see memory location of letter-L of string-'CloudyMLDL' is same\n", + "for i in range(0,10):\n", + " print(f\"{where_to_learn_MLandDL[i]} = {id(where_to_learn_MLandDL[i])}\")\n", + "# If you dont know loop go throug videos first then do this" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1Yau-6lcrP4O" + }, + "source": [ + "---" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 321 + }, + "execution": { + "iopub.execute_input": "2021-12-15T09:56:47.878958Z", + "iopub.status.busy": "2021-12-15T09:56:47.878659Z", + "iopub.status.idle": "2021-12-15T09:56:47.971989Z", + "shell.execute_reply": "2021-12-15T09:56:47.97099Z", + "shell.execute_reply.started": "2021-12-15T09:56:47.87893Z" + }, + "id": "p2oBYj1KrP4O", + "outputId": "afc68dab-0538-4834-c4d0-1f666fa22725" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# list\n", + "YouTubeVideo('https://www.youtube.com/watch?v=VGqMziKr9wM&list=PLsR_0x6BuM-HJZT6Xzj-088N4hN3KsDME&index=5',width=600,height=300)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7NhOTXbMrP4P" + }, + "source": [ + "**`List`** (ordered datastructure)\n", + "* Ordered collection of values, each element is seprated by a comma, use of square bracket for denotion of list\n", + "Ordered property is the most important aspect of list, lets see how:\n", + "* Python remembers the order of elements of a list\n", + "Data type connot store different kind of values in it, but list can" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "execution": { + "iopub.execute_input": "2021-12-13T06:35:13.990546Z", + "iopub.status.busy": "2021-12-13T06:35:13.990207Z", + "iopub.status.idle": "2021-12-13T06:35:13.995431Z", + "shell.execute_reply": "2021-12-13T06:35:13.994825Z", + "shell.execute_reply.started": "2021-12-13T06:35:13.990514Z" + }, + "id": "h8DvPJKUrP4P" + }, + "outputs": [], + "source": [ + "# declare a list named as ur_data_Lis having variables age,weight,name with values as 21,50.6,'Mukesh Manral'\n", + "ur_data_List = [21,50.6,'Mukesh Manral']\n", + "\n", + "# declare a dictionary named as ur_data_dictionary having keys as age,weight, first_name values as 21, 50, Mukesh\n", + "ur_data_dictionary = {'age': 21, 'weight': 50, 'first_name': 'Mukesh'}\n", + "\n", + "# declare a tuple named as ur_data_tuples having values 21,50.6,'first_name'\n", + "ur_data_tuples = (21,50.6,'first_name')\n", + "\n", + "# declare a set named as ur_data_set having value as Mukesh\n", + "ur_data_set = {'Mukesh'}" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "BjybhpkprP4P", + "outputId": "eee9e585-9a88-48d0-8f63-9e94c137f9c7" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n" + ] + } + ], + "source": [ + "# see datatype of ur_data_List, ur_data_dictionary, ur_data_tuples , ur_data_set variables\n", + "print(type(ur_data_List))\n", + "print(type(ur_data_dictionary))\n", + "print(type(ur_data_tuples))\n", + "print(type(ur_data_set))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "DONZzh6OrP4P" + }, + "source": [ + "


Operators

" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 321 + }, + "execution": { + "iopub.execute_input": "2021-12-15T10:22:15.619599Z", + "iopub.status.busy": "2021-12-15T10:22:15.619265Z", + "iopub.status.idle": "2021-12-15T10:22:15.731778Z", + "shell.execute_reply": "2021-12-15T10:22:15.731015Z", + "shell.execute_reply.started": "2021-12-15T10:22:15.619568Z" + }, + "id": "ZuJ5zqkYrP4P", + "outputId": "8d520df5-e2ca-4225-fad8-4da82f471e79" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Operators\n", + "YouTubeVideo('https://www.youtube.com/watch?v=CLqw5KZZ8Dg&list=PLsR_0x6BuM-HJZT6Xzj-088N4hN3KsDME&index=10',width=600,height=300)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4Wfm35b4rP4P" + }, + "source": [ + "`Operators`: Symbols that represent mathematical or logical tasks \n", + "\n", + "Example:
\n", + "`700` `+` `77`
\n", + "* `+` <= Operator\n", + "* `700` & `77` <= Operands\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "execution": { + "iopub.execute_input": "2021-12-10T06:38:34.676668Z", + "iopub.status.busy": "2021-12-10T06:38:34.676365Z", + "iopub.status.idle": "2021-12-10T06:38:34.749862Z", + "shell.execute_reply": "2021-12-10T06:38:34.748973Z", + "shell.execute_reply.started": "2021-12-10T06:38:34.676636Z" + }, + "id": "W-7tOm5CrP4P" + }, + "source": [ + "# Types of Operators\n", + "1. `Arithmetic Operators`\n", + "2. `Comparison Operators`\n", + "3. `Logical Operators`" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7OAVQ6EsrP4P" + }, + "source": [ + "# **1. `Arithmetic Operators`**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_QNg2gk7rP4Q" + }, + "source": [ + "|Task | Symbol|Example|\n", + "|---|---|----|\n", + "|Addition | + | 700 + 77 = 777|\n", + "|Substraction | - | 778 - 1 = 777|\n", + "|Multiplication | * | 1 * 777 = 777|\n", + "|Division | / | 13 / 2 = 6.5|\n", + "|Floor Division(ignores decimal \\ gives quotient) | // | 13 // 2 = 6|\n", + "|Modulo(gives remainder)| % | 13 % 2 = 1|\n", + "|Exponent(raise to the power) | ** | 13**2 = 169 |" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "FyxOlaQmrP4Q" + }, + "source": [ + "# **2. `Comparison Operators`**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8V4gqwnBrP4Q" + }, + "source": [ + "|Task | Symbol|\n", + "|---|---|\n", + "|Less than | < |\n", + "|Less than or equall to | <= | \n", + "|Equall to | == | \n", + "|Greater than | > | \n", + "|Greater than or equall to | >=|\n", + "|Not equall to | != | \n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "m7-BVTnhrP4Q" + }, + "source": [ + "# **3. `Logical Operators`**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "pHm4Yt2NrP4Q" + }, + "source": [ + "|Task | Symbol|Description|\n", + "|---|---|---|\n", + "|and | 1 < 2 and 2 < 3 => True |True only if both comparison are true |\n", + "|or | 1 < 2 or 2 > 3 => True|True if either of the comparison are true |\n", + "|not | not 1 > 2 => True|(flips results)True if comparison is False and so on.. |\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "IEkQ9PGArP4Q" + }, + "source": [ + "


Assignment Operators

" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "execution": { + "iopub.execute_input": "2021-12-13T11:16:12.878107Z", + "iopub.status.busy": "2021-12-13T11:16:12.87742Z", + "iopub.status.idle": "2021-12-13T11:16:12.88218Z", + "shell.execute_reply": "2021-12-13T11:16:12.881502Z", + "shell.execute_reply.started": "2021-12-13T11:16:12.878061Z" + }, + "id": "9eHULNrarP4Q" + }, + "outputs": [], + "source": [ + "# Initialize variables [x,y,z,zz] with values \n", + "## x as 7 =>int ,\n", + "## y as 77 =>int, \n", + "## z as 77.7 => float, \n", + "## zz as 'Hi' => string\n", + "x = 7\n", + "y = 77\n", + "z = 77.7\n", + "zz = 'Hi'" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kMGlbyturP4Q" + }, + "source": [ + "# **1. `Arithmetic Operators`**" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:16:16.831632Z", + "iopub.status.busy": "2021-12-13T11:16:16.831361Z", + "iopub.status.idle": "2021-12-13T11:16:16.837568Z", + "shell.execute_reply": "2021-12-13T11:16:16.836727Z", + "shell.execute_reply.started": "2021-12-13T11:16:16.831606Z" + }, + "id": "_7X7ChdtrP4Q", + "outputId": "1dbd8902-3386-49a7-b7ab-77cab5607148" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "84.7\n" + ] + } + ], + "source": [ + "# add x and z\n", + "print(x+z)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:16:30.203003Z", + "iopub.status.busy": "2021-12-13T11:16:30.20271Z", + "iopub.status.idle": "2021-12-13T11:16:30.208385Z", + "shell.execute_reply": "2021-12-13T11:16:30.207581Z", + "shell.execute_reply.started": "2021-12-13T11:16:30.20297Z" + }, + "id": "VWA9vqXbrP4R", + "outputId": "745699ba-9525-4db1-e9bf-73270a08ec54" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.7000000000000028\n" + ] + } + ], + "source": [ + "# subtract z and y\n", + "print(z-y)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:16:33.722854Z", + "iopub.status.busy": "2021-12-13T11:16:33.722346Z", + "iopub.status.idle": "2021-12-13T11:16:33.727832Z", + "shell.execute_reply": "2021-12-13T11:16:33.726714Z", + "shell.execute_reply.started": "2021-12-13T11:16:33.722819Z" + }, + "id": "Xs-S0MhCrP4R", + "outputId": "ee8c602f-13fd-4a63-d9b4-d93fe416f6b7" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "543.9\n" + ] + } + ], + "source": [ + "# Multiply x and z\n", + "print(x*z)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.status.busy": "2021-12-11T05:18:03.351545Z", + "iopub.status.idle": "2021-12-11T05:18:03.351958Z", + "shell.execute_reply": "2021-12-11T05:18:03.351816Z", + "shell.execute_reply.started": "2021-12-11T05:18:03.3518Z" + }, + "id": "QTAL9jikrP4R", + "outputId": "27632a7c-1571-4fc3-fb53-40b5804319b6" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4.614426248242042e+65\n" + ] + } + ], + "source": [ + "# Exponent (raise the power or times) x times z\n", + "print(x**z)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:16:54.593185Z", + "iopub.status.busy": "2021-12-13T11:16:54.592323Z", + "iopub.status.idle": "2021-12-13T11:16:54.599677Z", + "shell.execute_reply": "2021-12-13T11:16:54.598843Z", + "shell.execute_reply.started": "2021-12-13T11:16:54.593129Z" + }, + "id": "veuOn9YcrP4R", + "outputId": "1bf677bd-5b4a-49e0-f0a6-f93ea487ccf6" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.09009009009009009\n" + ] + } + ], + "source": [ + "# division on x and z\n", + "print(x/z)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "lPSllBVYrP4R" + }, + "source": [ + "`//` => divides and returns integer value of quotient\n", + "* It will dump digits after decimal" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:17:43.712052Z", + "iopub.status.busy": "2021-12-13T11:17:43.711764Z", + "iopub.status.idle": "2021-12-13T11:17:43.717685Z", + "shell.execute_reply": "2021-12-13T11:17:43.716923Z", + "shell.execute_reply.started": "2021-12-13T11:17:43.712021Z" + }, + "id": "LjvFNdDHrP4R", + "outputId": "74247edc-70c0-4860-d3ec-fd38c9fc6ff1" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0\n" + ] + } + ], + "source": [ + "# floor division(ignores decimal) on x and z (gives quotient)\n", + "print(x//z)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:18:23.768814Z", + "iopub.status.busy": "2021-12-13T11:18:23.768469Z", + "iopub.status.idle": "2021-12-13T11:18:23.774541Z", + "shell.execute_reply": "2021-12-13T11:18:23.773825Z", + "shell.execute_reply.started": "2021-12-13T11:18:23.768775Z" + }, + "id": "prGaXfI2rP4R", + "outputId": "ffdfa431-8d36-40b1-a2d6-3a428e3b1e2d" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "7.0\n" + ] + } + ], + "source": [ + "# Modulo(gives remainder) on x and z\n", + "print(x%z)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BqiZFRnxrP4R" + }, + "source": [ + "# **2. `Comparison Operators`**" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:18:53.671899Z", + "iopub.status.busy": "2021-12-13T11:18:53.671588Z", + "iopub.status.idle": "2021-12-13T11:18:53.677758Z", + "shell.execute_reply": "2021-12-13T11:18:53.676944Z", + "shell.execute_reply.started": "2021-12-13T11:18:53.671852Z" + }, + "id": "cZTjTlksrP4S", + "outputId": "338815ee-53ee-42f3-80b6-59933758768b" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n" + ] + } + ], + "source": [ + "# comapre and see if x is less then z \n", + "# can use '<' symbol\n", + "\n", + "print(x\n" + ] + } + ], + "source": [ + "# check the type of above comaprison where it says comapre and see if x is less then z \n", + "compare = x takes two values, either `True` or `False`" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:20:21.121906Z", + "iopub.status.busy": "2021-12-13T11:20:21.121593Z", + "iopub.status.idle": "2021-12-13T11:20:21.128235Z", + "shell.execute_reply": "2021-12-13T11:20:21.127415Z", + "shell.execute_reply.started": "2021-12-13T11:20:21.121858Z" + }, + "id": "qrLXc7h8rP4S", + "outputId": "1106e876-fae9-461d-f44d-605e0be52441" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n" + ] + } + ], + "source": [ + "# compare and see if x is less then or equall to z\n", + "# can use '<=' symbol\n", + "print(x<=z)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:21:03.964669Z", + "iopub.status.busy": "2021-12-13T11:21:03.964122Z", + "iopub.status.idle": "2021-12-13T11:21:03.970529Z", + "shell.execute_reply": "2021-12-13T11:21:03.969911Z", + "shell.execute_reply.started": "2021-12-13T11:21:03.964617Z" + }, + "id": "QITa8mAorP4S", + "outputId": "ec6dc405-eb0e-46a3-c167-da700179af34" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "False\n" + ] + } + ], + "source": [ + "# comapre and see if x equall to z\n", + "# can use '==' symbol\n", + "print(x==z)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:21:17.56085Z", + "iopub.status.busy": "2021-12-13T11:21:17.560326Z", + "iopub.status.idle": "2021-12-13T11:21:17.566991Z", + "shell.execute_reply": "2021-12-13T11:21:17.566308Z", + "shell.execute_reply.started": "2021-12-13T11:21:17.560801Z" + }, + "id": "to09wf4lrP4S", + "outputId": "592d9cad-2331-44fe-b199-92bd286aef93" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "False\n" + ] + } + ], + "source": [ + "# comapre and see if x is greater than z\n", + "# can use '>' symbol\n", + "print(x>z)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.status.busy": "2021-12-11T05:18:03.366407Z", + "iopub.status.idle": "2021-12-11T05:18:03.366829Z", + "shell.execute_reply": "2021-12-11T05:18:03.366687Z", + "shell.execute_reply.started": "2021-12-11T05:18:03.36667Z" + }, + "id": "3XjJEvQmrP4S", + "outputId": "2ec0ecc4-ca4e-4aab-e8a0-565cc4ffcf9d" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "False\n" + ] + } + ], + "source": [ + "# comapre and see if x is greater than or equall to z\n", + "# can use '>=' symbol\n", + "print(x>=z)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:21:27.087849Z", + "iopub.status.busy": "2021-12-13T11:21:27.087572Z", + "iopub.status.idle": "2021-12-13T11:21:27.094348Z", + "shell.execute_reply": "2021-12-13T11:21:27.093707Z", + "shell.execute_reply.started": "2021-12-13T11:21:27.087821Z" + }, + "id": "U3R4NtLUrP4S", + "outputId": "8139031e-7e45-4a66-96f6-ebcf85df150b" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n" + ] + } + ], + "source": [ + "# comapre and see if x is Not equall to z\n", + "# can use '!=' symbol\n", + "\n", + "print(x!=z)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "i1cSXmgbrP4T" + }, + "source": [ + "# **3. `Logical Operators`**" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:22:13.637837Z", + "iopub.status.busy": "2021-12-13T11:22:13.637267Z", + "iopub.status.idle": "2021-12-13T11:22:13.644724Z", + "shell.execute_reply": "2021-12-13T11:22:13.643893Z", + "shell.execute_reply.started": "2021-12-13T11:22:13.637786Z" + }, + "id": "qrf5nOLerP4T", + "outputId": "5b5bad4d-6568-4e8a-f606-fa5850986071" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n" + ] + } + ], + "source": [ + "# compare if 108 is equall to 108, 21 is equall to 21 using logical and \n", + "# equall to => '=='\n", + "# logical and => and\n", + "\n", + " # in and both condition must be True to get a True\n", + "print(108==108 and 21==21)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:22:24.56808Z", + "iopub.status.busy": "2021-12-13T11:22:24.567356Z", + "iopub.status.idle": "2021-12-13T11:22:24.576075Z", + "shell.execute_reply": "2021-12-13T11:22:24.574969Z", + "shell.execute_reply.started": "2021-12-13T11:22:24.56804Z" + }, + "id": "Zp51tX7NrP4T", + "outputId": "613342d8-4d42-4d16-b44e-c1751f71b01a" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "False\n", + "False\n", + "False\n", + "False\n", + "False\n", + "False\n" + ] + } + ], + "source": [ + "# how above condition can give False as output show all thouse conditions\n", + " # in and both condition must be True to get a True\n", + "print(108!=108 and 21==21)\n", + "print(108==108 and 21!=21)\n", + "print(not 108==108 and 21==21)\n", + "print(108!=108 and 21!=21)\n", + "print(108!=108 or 21!=21)\n", + "print(108==108 and not 21==21)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:22:39.576213Z", + "iopub.status.busy": "2021-12-13T11:22:39.575636Z", + "iopub.status.idle": "2021-12-13T11:22:39.58328Z", + "shell.execute_reply": "2021-12-13T11:22:39.582673Z", + "shell.execute_reply.started": "2021-12-13T11:22:39.576179Z" + }, + "id": "TRMHLAHkrP4T", + "outputId": "f6e7a8a2-395e-405c-9669-b6c7238ad97a" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n" + ] + } + ], + "source": [ + "# compare if 108 is equall to 108, 21 is equall to 11 using logical or\n", + "# equall to => '=='\n", + "# logical or => or\n", + "\n", + " # in or Only one condition need to be True to get a True\n", + "print(108==108 or 21==11)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:22:58.998022Z", + "iopub.status.busy": "2021-12-13T11:22:58.997422Z", + "iopub.status.idle": "2021-12-13T11:22:59.004662Z", + "shell.execute_reply": "2021-12-13T11:22:59.003884Z", + "shell.execute_reply.started": "2021-12-13T11:22:58.997978Z" + }, + "id": "QQRfWOkzrP4T", + "outputId": "69a82d41-b61d-4183-ca01-c3550b5553f0" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# this is for you understand it\n", + "(108 == 108) or (21 == 11) or (108 <= 11)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "FYchA77BrP4T" + }, + "source": [ + "\n", + "


Conditional Statements

" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 321 + }, + "execution": { + "iopub.execute_input": "2021-12-15T10:17:35.012552Z", + "iopub.status.busy": "2021-12-15T10:17:35.01223Z", + "iopub.status.idle": "2021-12-15T10:17:35.104434Z", + "shell.execute_reply": "2021-12-15T10:17:35.103709Z", + "shell.execute_reply.started": "2021-12-15T10:17:35.012521Z" + }, + "id": "MTmNGeJbrP4T", + "outputId": "0ef6c752-b7aa-4135-e298-74389fb4f07d" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 66, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Conditions\n", + "YouTubeVideo('https://www.youtube.com/watch?v=CLqw5KZZ8Dg&list=PLsR_0x6BuM-HJZT6Xzj-088N4hN3KsDME&index=11',width=600,height=300)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "r5LWKR-irP4T" + }, + "source": [ + "# 1. **`if`--- `else`** => to handle single condition
\n", + "# 2. **`if`--- `elif`--- `else`** => to handle Multiple condition" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4l8YdB1orP4T" + }, + "source": [ + "`Why do we need conditional Statements?`
\n", + "Say you want to buy a ML course and to decided you buy it or not to by it based on some condition,=> if you have more then 2k buy, if you dont have more then 2k dont buy!! \n", + "\n", + "* Two Variable you will use `ML course` and `money` \n", + "* One comparison `money > 2k`\n", + "For ML course if `money > 2k` => you have more money then 2k => condition is True => buy course => if condition is False i.e. you have less money then 2k then dont buy the course\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "FWFgSro3rP4U" + }, + "source": [ + "|Pseudo Code for above will be| Python Code for Pseudo code|\n", + "|----|----|\n", + "Check if money > 2k | if money > 2000:\n", + "then ML course = 'buy' |.... ML course = 'buy'\n", + "else Ml course = 'dont buy'| else:\n", + " -- | ....ML course = 'dont buy'" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 38 + }, + "id": "eD6N8d4JrP4U", + "outputId": "df998f96-081a-41e8-a7ba-eb5bb24b96cc" + }, + "outputs": [ + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + }, + "text/plain": [ + "'\\nif condition:\\n statement\\nelse:\\n statement'" + ] + }, + "execution_count": 67, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"\n", + "if condition:\n", + " statement\n", + "else:\n", + " statement\"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_7lo_XpYrP4U" + }, + "source": [ + "`Observe in Python code:` \n", + "* `if` => statement in python\n", + "* `else` => statement in python\n", + "* `:` => colon => denotes start of if block i.e. any line written after colon belong to if condition\n", + "* `....` => see then as indentation i.e. 4 spaces => indentation indicates all code belong to only if and then another indentation indicates code for only else block " + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T12:04:09.255152Z", + "iopub.status.busy": "2021-12-13T12:04:09.254359Z", + "iopub.status.idle": "2021-12-13T12:04:09.301228Z", + "shell.execute_reply": "2021-12-13T12:04:09.300137Z", + "shell.execute_reply.started": "2021-12-13T12:04:09.254985Z" + }, + "id": "e2SpODuorP4U", + "outputId": "c32da32f-2a21-4e62-dc8a-ac11e9d307f7" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n" + ] + } + ], + "source": [ + "# make variable with value as : money 100000\n", + "money = 100000\n", + "# see output of money > 2000 \n", + "print(money>2000)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T12:04:41.020917Z", + "iopub.status.busy": "2021-12-13T12:04:41.020562Z", + "iopub.status.idle": "2021-12-13T12:04:41.027788Z", + "shell.execute_reply": "2021-12-13T12:04:41.026428Z", + "shell.execute_reply.started": "2021-12-13T12:04:41.020881Z" + }, + "id": "8rLKbxCqrP4U", + "outputId": "51aa49a6-d403-4292-8190-e23354ccda3b" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "buy ML course\n" + ] + } + ], + "source": [ + "# see above Python code for Pseudo code and write that into python code\n", + "\n", + "# assign money variable value of 100000 \n", + "##### say you have this much ammount in your account\n", + "\n", + "# start of if condition\n", + "if money>2000:# if money is greater then 2000 which is ML course free \n", + " print('buy ML course')\n", + "else: # if money > 2000 is false i.e. you have less money then 2000 in your account then else will work for now only if is working\n", + " print('dont buy ML course')" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T12:05:41.659409Z", + "iopub.status.busy": "2021-12-13T12:05:41.659081Z", + "iopub.status.idle": "2021-12-13T12:05:41.667758Z", + "shell.execute_reply": "2021-12-13T12:05:41.66659Z", + "shell.execute_reply.started": "2021-12-13T12:05:41.659376Z" + }, + "id": "-J44V8LNrP4U", + "outputId": "f4726e0f-875b-439f-a5ef-907dad4f5e8d" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "False\n" + ] + } + ], + "source": [ + "# make variable with value as : money 100\n", + "money = 100\n", + "# see output of money > 2000\n", + "print(money>2000)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T12:05:59.423116Z", + "iopub.status.busy": "2021-12-13T12:05:59.422112Z", + "iopub.status.idle": "2021-12-13T12:05:59.42974Z", + "shell.execute_reply": "2021-12-13T12:05:59.428841Z", + "shell.execute_reply.started": "2021-12-13T12:05:59.423062Z" + }, + "id": "eQGaPvuRrP4U", + "outputId": "e895aadb-0b33-4e24-ac42-bd47cd763810" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dont buy ML course\n" + ] + } + ], + "source": [ + "# assign money variable value of 100\n", + "#### say you have this much ammount in your account\n", + "\n", + "# start of if condition\n", + "if money > 2000:# if money is greater then 2000 which is ML course free \n", + " print('buy ML course')\n", + "else: # if money > 2000 is false i.e. you have less money then 2000 in your account then else will work for now only if is working\n", + " print('dont buy ML course')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "nVugaqcErP4U" + }, + "source": [ + "# 2. `Multiple Condition` i.e. use of **`if`--- `elif`--- `else`**\n", + "Say you have bought ML course, but now you want certification and internship here includes more then 1 condition maybe 2 or 3, lets see for conditions:\n", + "* if your test score more then 80 then you will get certification of A grade\n", + "* if your test score more then 60 then you will get certification of B grade\n", + "* for rest not get anything" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "KLJjdItrrP4U" + }, + "source": [ + "|Pseudo Code for above will be\n", + "|----|\n", + "Check if score > 80\n", + "if yes print('A grade')\n", + "Otherwise check if score > 60\n", + "if yes print('B grade')\n", + "For every other situation print('not getting anything')" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T12:12:40.145964Z", + "iopub.status.busy": "2021-12-13T12:12:40.145355Z", + "iopub.status.idle": "2021-12-13T12:12:45.469908Z", + "shell.execute_reply": "2021-12-13T12:12:45.469259Z", + "shell.execute_reply.started": "2021-12-13T12:12:40.145915Z" + }, + "id": "UkSB0BDKrP4V", + "outputId": "95379bf8-12f8-49a8-abbe-412385fa278c" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "What is your test score(check for 10, 70, 90):10\n", + "Nothing for you\n" + ] + } + ], + "source": [ + "# python code for above Pseudo Code will be\n", + "your_test_score = input('What is your test score(check for 10, 70, 90):') #taking input from you use of input()\n", + "your_test_score = int(your_test_score) #as input is in string changing it to int as to make comparison possible\n", + "\n", + "if your_test_score>80: # if your_test_score greater then 80\n", + " print('A grade')\n", + "elif your_test_score> 60 and your_test_score<=80: # elif your_test_score greater then 60 and your_test_score leass then 80\n", + " print('B grade')\n", + "else:\n", + " print('Nothing for you')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5fSzijCErP4V" + }, + "source": [ + "`Understand above Flow`:\n", + "* check for if statement if true close, if not true\n", + "* check for elif, if elif condition is true go close, if not true\n", + "* go ot else any way\n", + "* [See how this code is being executed internally](https://pythontutor.com/visualize.html#mode=display)\n", + "* copy above code there " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "f-c4s81KrP4V" + }, + "source": [ + "\n", + "


Assignment Conditional Statements

" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "qutzAWNFrP4V" + }, + "source": [ + "# 📌📌 Indentation in Python\n", + "\n", + "***Before we start Conditional Statements, let's have a look at `indentation` in Python.***\n", + "\n", + "## `INDENTATION`\n", + "* Indentation means `(spaces and tabs)` that are used at beginning of any statement\n", + "* Statements with same indentation belong to same group also called as `suite`. \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 131 + }, + "execution": { + "iopub.status.busy": "2021-12-11T05:18:03.376487Z", + "iopub.status.idle": "2021-12-11T05:18:03.376791Z", + "shell.execute_reply": "2021-12-11T05:18:03.376652Z", + "shell.execute_reply.started": "2021-12-11T05:18:03.376636Z" + }, + "id": "CK1s7-BxrP4V", + "outputId": "2a017631-9a02-4e8d-e965-a66b10bf2a57" + }, + "outputs": [ + { + "ename": "IndentationError", + "evalue": "ignored", + "output_type": "error", + "traceback": [ + "\u001b[0;36m File \u001b[0;32m\"\"\u001b[0;36m, line \u001b[0;32m3\u001b[0m\n\u001b[0;31m print('True Statement') # IndentationError\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m expected an indented block\n" + ] + } + ], + "source": [ + "# this is how wrong indentation gives you error (commet can be written by using => #)\n", + "if (2 == 2):\n", + "print('True Statement') # IndentationError" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "pT2IKbixrP4V" + }, + "source": [ + "**`Take an input from a user in variable input_ and print \"Even\" if number is divisible by 2, otherwise print \"Odd\"`**" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 253 + }, + "execution": { + "iopub.status.busy": "2021-12-11T05:18:03.377643Z", + "iopub.status.idle": "2021-12-11T05:18:03.377926Z", + "shell.execute_reply": "2021-12-11T05:18:03.377792Z", + "shell.execute_reply.started": "2021-12-11T05:18:03.377777Z" + }, + "id": "zF-6vc9HrP4V", + "outputId": "1b3e6bb4-3538-4129-a70f-eb94c3d5b760" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "User input : 24\n", + "Even\n" + ] + } + ], + "source": [ + "# take input from user by using input function in variable named as input_\n", + "input_ = input('User input : ')\n", + "\n", + "# by default type is string, so we need to convert type first into int\n", + "input_ = int(input_)\n", + "\n", + "if input_%2==0: # if input_ modulo 2 compared to 0 id true \n", + " print(\"Even\")\n", + "else:\n", + " print(\"Odd\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Wm_-Ao43rP4W" + }, + "source": [ + "**`Take input from user in variable x and print \"`Grade A`\" if y is greater than 90, \"`Grade B`\" if y is greater than 60 but less than or equal to 90 and \"`Grade F`\" Otherwise`**" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T05:18:03.382211Z", + "iopub.status.busy": "2021-12-11T05:18:03.381965Z", + "iopub.status.idle": "2021-12-11T05:18:11.226671Z", + "shell.execute_reply": "2021-12-11T05:18:11.224518Z", + "shell.execute_reply.started": "2021-12-11T05:18:03.382183Z" + }, + "id": "iY9UVHpOrP4W", + "outputId": "2b0afc0b-9b40-4540-b7eb-29cc32fb6e53" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Score input : 67\n", + "Grade B\n" + ] + } + ], + "source": [ + "# take input from user by using input function\n", + "x = input('Score input : ')\n", + "\n", + "# by default type is string, so we need to convert type first\n", + "x = int(x)\n", + "\n", + "if x>90: # if x is greater then 90\n", + " print(\"Grade A\")\n", + "\n", + "elif x>60 and x<=90:# elif x is greater then 60\n", + " print(\"Grade B\")\n", + "\n", + "else:\n", + " print(\"Grade F\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Ifzx69_srP4W" + }, + "source": [ + "\n", + "


Loops

" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 321 + }, + "execution": { + "iopub.execute_input": "2021-12-15T10:15:22.668882Z", + "iopub.status.busy": "2021-12-15T10:15:22.667917Z", + "iopub.status.idle": "2021-12-15T10:15:22.761246Z", + "shell.execute_reply": "2021-12-15T10:15:22.760576Z", + "shell.execute_reply.started": "2021-12-15T10:15:22.668826Z" + }, + "id": "Q_9p_o-nrP4W", + "outputId": "5837851f-9067-463b-bfc2-835e0350e5f6" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 76, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Loops\n", + "YouTubeVideo('https://www.youtube.com/watch?v=56-IOucIwAU&list=PLsR_0x6BuM-HJZT6Xzj-088N4hN3KsDME&index=12',width=600,height=300)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 38 + }, + "id": "Jeln_5cCrP4W", + "outputId": "b7686a87-77ac-4fc8-91f2-62f80c89b098" + }, + "outputs": [ + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + }, + "text/plain": [ + "'\\nfor iterating_variable in sequence:\\n statement(s)\\n'" + ] + }, + "execution_count": 77, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"\n", + "for iterating_variable in sequence:\n", + " statement(s)\n", + "\"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "zKF8RVOJrP4W" + }, + "source": [ + "|Loop Type|Description|\n", + "|----|-----|\n", + "|`for in` loop | repeats a statement or group of statements finite number of time |\n", + "|`while` loop | tests condition before executing loop body, repeats a statement or group of statements while a given condition is true |\n", + "|`nested` loop | loop inside a loop |" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7Mo7XNVNrP4W" + }, + "source": [ + "# **When to use `while` or `for` loops??**
\n", + "Say your Girlfriend or Boyfriend is mad at you and they asked you to say sorry, but there are two more condition here given by them:\n", + "* say sorry 1000 times, now you know end point i.e. 1000 => `use for loop`\n", + "* say sorry untill I say I love you, now you dont know end point, maybe she/he will never say I love you. => `use while loop` it will stop saying sorry untill condition is not met\n", + "\n", + "1. `We use for loop when we want to run a block of code certain number of times`\n", + "2. `Code in while clause will be executed as long as while statement’s condition is True`" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "LQwybYuNrP4X" + }, + "source": [ + "# `Why we need Loops?`
\n", + "Say your Girfriend/Boyfriend is Mad at you and she want you to write sorry 1000 times. What to do now????? Write a `for loop`" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "yGTJuxZarP4X" + }, + "source": [ + "|Pseudo Code for above will be\n", + "|----|\n", + "print 'Sorry My love' (repeat 1000 times)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 38 + }, + "id": "UsOavUkNrP4X", + "outputId": "6a576f4b-5655-4091-e59b-722ecdd3f3fb" + }, + "outputs": [ + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + }, + "text/plain": [ + "'\\nfor iterating_variable in sequence:\\n statement(s)\\n'" + ] + }, + "execution_count": 78, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"\n", + "for iterating_variable in sequence:\n", + " statement(s)\n", + "\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-14T05:27:42.974824Z", + "iopub.status.busy": "2021-12-14T05:27:42.973933Z", + "iopub.status.idle": "2021-12-14T05:27:42.981157Z", + "shell.execute_reply": "2021-12-14T05:27:42.980185Z", + "shell.execute_reply.started": "2021-12-14T05:27:42.97478Z" + }, + "id": "v3DtstO3rP4X", + "outputId": "3138dfad-be46-49d8-a0aa-8e74c8855a9d" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n", + "7\n", + "8\n", + "9\n" + ] + } + ], + "source": [ + "for iterating_variable in range(10):\n", + " print(iterating_variable)" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-14T05:29:31.818786Z", + "iopub.status.busy": "2021-12-14T05:29:31.818325Z", + "iopub.status.idle": "2021-12-14T05:29:31.825965Z", + "shell.execute_reply": "2021-12-14T05:29:31.82532Z", + "shell.execute_reply.started": "2021-12-14T05:29:31.818752Z" + }, + "id": "nD9f1mMwrP4X", + "outputId": "a087b7d8-d4b9-4f11-8d45-f3c460ea562e" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🔥 Sorry My Love🔥\n", + "🔥 Sorry My Love🔥\n", + "🔥 Sorry My Love🔥\n", + "🔥 Sorry My Love🔥\n", + "🔥 Sorry My Love🔥\n", + "🔥 Sorry My Love🔥\n", + "🔥 Sorry My Love🔥\n", + "🔥 Sorry My Love🔥\n", + "🔥 Sorry My Love🔥\n", + "🔥 Sorry My Love🔥\n" + ] + } + ], + "source": [ + "# print '🔥 Sorry My Love🔥' 10 times using for loop\n", + "var = '🔥 Sorry My Love🔥'\n", + "# for now i am giving range of 10 you can give any number you want\n", + "for i in range(1,11):\n", + " print(var) " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "F10cQq2RrP4X" + }, + "source": [ + "`10` => `stoping criteria` of, for loop" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 38 + }, + "execution": { + "iopub.status.busy": "2021-12-11T05:18:11.228902Z", + "iopub.status.idle": "2021-12-11T05:18:11.229189Z", + "shell.execute_reply": "2021-12-11T05:18:11.229034Z", + "shell.execute_reply.started": "2021-12-11T05:18:11.229019Z" + }, + "id": "uCzvC6tnrP4X", + "outputId": "b5be09b0-02ef-4dbb-e886-590c7cf1a265" + }, + "outputs": [ + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + }, + "text/plain": [ + "'# Syntax of for loop\\n\\nfor iterating_variable in sequence:\\n statements(s)\\n'" + ] + }, + "execution_count": 303, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Syntax of for loop\n", + "\"\"\"\n", + "for iterating_variable in sequence:\n", + " statements(s)\n", + "\"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "sYmBZqXkrP4X" + }, + "source": [ + "* `in` => keyword\n", + "* `sequence` => on which to itterate\n", + "* `:` => colon , start of for loop" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kKybOmM2rP4X" + }, + "source": [ + "|Pseudo Code `while` loop|\n", + "|---|\n", + "while reply != 'I love you':\n", + "....keep repeating until\n", + "....caparison gives False " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "nR0WJpXwrP4X" + }, + "source": [ + "`!=` = not equall to => `behaves as a stoping criteria`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 38 + }, + "execution": { + "iopub.status.busy": "2021-12-11T05:18:11.230229Z", + "iopub.status.idle": "2021-12-11T05:18:11.230505Z", + "shell.execute_reply": "2021-12-11T05:18:11.230373Z", + "shell.execute_reply.started": "2021-12-11T05:18:11.230358Z" + }, + "id": "vYJsdLnerP4Y", + "outputId": "44686682-2f3a-4522-bdf4-84215e4a8f17" + }, + "outputs": [ + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + }, + "text/plain": [ + "'\\nwhile comparison:\\n statements(s)\\n'" + ] + }, + "execution_count": 82, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Syntax of while loop\n", + "\"\"\"\n", + "while comparison:\n", + " statements(s)\n", + "\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-14T05:32:44.799916Z", + "iopub.status.busy": "2021-12-14T05:32:44.799592Z", + "iopub.status.idle": "2021-12-14T05:32:44.807523Z", + "shell.execute_reply": "2021-12-14T05:32:44.806458Z", + "shell.execute_reply.started": "2021-12-14T05:32:44.799882Z" + }, + "id": "No1lV66XrP4Y", + "outputId": "6d6d01cd-2c11-499b-e593-ac9fa8dcc629" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n" + ] + } + ], + "source": [ + "# while loop\n", + "\n", + "# save 0 in variable number\n", + "number = 0\n", + "\n", + "# print bellow result using while loop\n", + "while number <=6:\n", + " print(number)\n", + " number +=1" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "9oFT7qEjrP4Y" + }, + "source": [ + "* Initialized variable `number = 0` and then increment it's value in each iteration\n", + "* Loop will only continue to run only if value is less than 7" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "execution": { + "iopub.execute_input": "2021-12-10T09:38:54.720729Z", + "iopub.status.busy": "2021-12-10T09:38:54.720379Z", + "iopub.status.idle": "2021-12-10T09:38:54.729647Z", + "shell.execute_reply": "2021-12-10T09:38:54.728479Z", + "shell.execute_reply.started": "2021-12-10T09:38:54.720691Z" + }, + "id": "8510bIUSrP4Y" + }, + "source": [ + "# 3. **`Nested loop`**" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-14T05:43:57.128724Z", + "iopub.status.busy": "2021-12-14T05:43:57.12841Z", + "iopub.status.idle": "2021-12-14T05:43:57.134926Z", + "shell.execute_reply": "2021-12-14T05:43:57.1341Z", + "shell.execute_reply.started": "2021-12-14T05:43:57.128693Z" + }, + "id": "SaYaNtm_rP4Y", + "outputId": "18eef661-2153-48f3-ed3a-095e21a895a5" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "2\n" + ] + } + ], + "source": [ + "# run it see the output\n", + "for outer_loop_number in range(1,3):\n", + " print(outer_loop_number)" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-14T05:44:39.129675Z", + "iopub.status.busy": "2021-12-14T05:44:39.12929Z", + "iopub.status.idle": "2021-12-14T05:44:39.137127Z", + "shell.execute_reply": "2021-12-14T05:44:39.135798Z", + "shell.execute_reply.started": "2021-12-14T05:44:39.129641Z" + }, + "id": "8E_8V-_3rP4Y", + "outputId": "ee0d38ac-821c-4e05-97ca-2227e68a3ed5" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "C\n", + "l\n", + "o\n", + "u\n", + "d\n", + "y\n", + "M\n", + "L\n" + ] + } + ], + "source": [ + "# run it see the output\n", + "for inner_loop_character in \"CloudyML\":\n", + " print(inner_loop_character)" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-14T05:45:07.376594Z", + "iopub.status.busy": "2021-12-14T05:45:07.376268Z", + "iopub.status.idle": "2021-12-14T05:45:07.387369Z", + "shell.execute_reply": "2021-12-14T05:45:07.385704Z", + "shell.execute_reply.started": "2021-12-14T05:45:07.376561Z" + }, + "id": "VYeJ7UT3rP4Y", + "outputId": "6d1b417c-24fc-4c47-b53e-8f1f853c8f70" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 C\n", + "1 l\n", + "1 o\n", + "1 u\n", + "1 d\n", + "1 y\n", + "1 M\n", + "1 L\n", + "2 C\n", + "2 l\n", + "2 o\n", + "2 u\n", + "2 d\n", + "2 y\n", + "2 M\n", + "2 L\n" + ] + } + ], + "source": [ + "# print this patern using outer and inner loop \n", + "for outer_loop_number in range(1,3):\n", + " for inner_loop_character in \"CloudyML\":\n", + " print(f\"{outer_loop_number} {inner_loop_character}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "VDXKoxndrP4Y" + }, + "source": [ + "`See For each step in outer loop, inner loop exectues completely`" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.status.busy": "2021-12-11T05:18:11.234623Z", + "iopub.status.idle": "2021-12-11T05:18:11.234923Z", + "shell.execute_reply": "2021-12-11T05:18:11.234789Z", + "shell.execute_reply.started": "2021-12-11T05:18:11.234773Z" + }, + "id": "wY98D_7BrP4Y", + "outputId": "02a22cbd-de75-44b1-8f4d-80bdea7b5421" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "m lxm uxdxyxmxlx" + ] + } + ], + "source": [ + "# think what will be the output of this code and then run it\n", + "# comment why this out is the way it is \n", + "\n", + "for letter in 'cloudyml':\n", + " if (letter == 'c') or (letter == 'o'): # checks if letter is c or o\n", + " print('m', end= ' ')# prints m and appends space character at the end\n", + " else:\n", + " print(letter,end= 'x')# if condition do not satisfy print the letter and appens x at end\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "AiELZ4y9jaYG" + }, + "source": [ + "Your Comment: => -------\n", + "for first letter 'c', satisfies condition, so prints 'm' and appends ' ' at end.\n", + "for next letter 'l', do not satisfy , so prints 'l' and appends 'x' at end.\n", + "for next letter 'o', satisfies condition, so prints 'm' and appends ' ' at end.\n", + "for next 5 letters 'u','d','y','m','l', do not satisfy, so prints the letter followed by x\n", + ",i.e., uxdxyxmxlx" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.status.busy": "2021-12-11T05:18:11.235984Z", + "iopub.status.idle": "2021-12-11T05:18:11.236307Z", + "shell.execute_reply": "2021-12-11T05:18:11.236156Z", + "shell.execute_reply.started": "2021-12-11T05:18:11.23614Z" + }, + "id": "n8YN-ajLrP4Z", + "outputId": "036e75fa-0a47-4f90-95eb-d1036cc9f2c3" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10 9 " + ] + } + ], + "source": [ + "# think what will be the output of this code and then run it\n", + "# comment why this out is the way it is \n", + "\n", + "num = 10\n", + "\n", + "while num > 5:\n", + " print(num,end= ' ')\n", + " \n", + " num = num - 1#decrement by 1\n", + " if num == 8: # if number becomes 8, replace its value as 2, which will break the loop\n", + " num = 2\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tpJnrvlnjwHf" + }, + "source": [ + "Your Comment: => -------\n", + "first value is 10, which is greater than 5, so goes into loop, prints value appended by space, \n", + "next value is 10-1 =9, do not satisfy next condition\n", + "next value 9 satisfies value greater than 5, goes into loop and prints value appended by space,\n", + "next value is 9-1 =8, it satisfies condition and updates value to 2, \n", + "2<5, so do not go into loop" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CsIxN6mUrP4Z" + }, + "source": [ + "


Jump Statements

" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 321 + }, + "execution": { + "iopub.execute_input": "2021-12-15T10:12:13.499283Z", + "iopub.status.busy": "2021-12-15T10:12:13.499024Z", + "iopub.status.idle": "2021-12-15T10:12:13.585163Z", + "shell.execute_reply": "2021-12-15T10:12:13.58456Z", + "shell.execute_reply.started": "2021-12-15T10:12:13.499256Z" + }, + "id": "hPvTWkmArP4Z", + "outputId": "f03f0291-a849-48bf-fb7e-580fc230f8b8" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 89, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Statements-1\n", + "YouTubeVideo('https://www.youtube.com/watch?v=znhhfYiFrzI&list=PLsR_0x6BuM-HJZT6Xzj-088N4hN3KsDME&index=13',width=600,height=300)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 321 + }, + "execution": { + "iopub.execute_input": "2021-12-15T10:12:26.792703Z", + "iopub.status.busy": "2021-12-15T10:12:26.791972Z", + "iopub.status.idle": "2021-12-15T10:12:26.88312Z", + "shell.execute_reply": "2021-12-15T10:12:26.882488Z", + "shell.execute_reply.started": "2021-12-15T10:12:26.792662Z" + }, + "id": "pnF2om1TrP4Z", + "outputId": "d8561384-689d-4b79-fa3f-7f23c65ed123" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 90, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Statements-2\n", + "YouTubeVideo('https://www.youtube.com/watch?v=znhhfYiFrzI&list=PLsR_0x6BuM-HJZT6Xzj-088N4hN3KsDME&index=14',width=600,height=300)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ZFHHxSeqrP4Z" + }, + "source": [ + "# **`Type of Jump Statements`**
\n", + "1. `Break Statement`\n", + "2. `Continue Statement`\n", + "3. `Pass Statement`" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Mai0WKJ7rP4Z" + }, + "source": [ + "Using for loops and while loops in Python allow you to automate and repeat tasks in an efficient manner.\n", + "\n", + "* But sometimes, an external factor may influence the way your program runs. When this occurs, you may want your program to `exit a loop completely`, `skip part of a loop before continuing`, or `ignore that external factor` \n", + "\n", + "`You can do these actions with **Break** and **Continue** Statements`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 38 + }, + "id": "0bu4vLAJrP4Z", + "outputId": "7e0aa30e-916c-436a-f7e1-d24a5e586564" + }, + "outputs": [ + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + }, + "text/plain": [ + "'\\npass\\n\\nbreak\\n\\ncontinue\\n'" + ] + }, + "execution_count": 91, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "'''\n", + "pass\n", + "\n", + "break\n", + "\n", + "continue\n", + "'''" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2TlMjfJVrP4a" + }, + "source": [ + "# 1. **`Break Statement`**\n" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-14T08:27:20.070741Z", + "iopub.status.busy": "2021-12-14T08:27:20.070203Z", + "iopub.status.idle": "2021-12-14T08:27:20.077102Z", + "shell.execute_reply": "2021-12-14T08:27:20.076404Z", + "shell.execute_reply.started": "2021-12-14T08:27:20.070699Z" + }, + "id": "MYsORtlrrP4a", + "outputId": "c7a67df0-dec4-44b6-de0d-23fc744e861f" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n", + "7\n", + "8\n", + "9\n" + ] + } + ], + "source": [ + "# observe the output\n", + "for num in range(10):\n", + " print(num)" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-14T09:25:34.60943Z", + "iopub.status.busy": "2021-12-14T09:25:34.609121Z", + "iopub.status.idle": "2021-12-14T09:25:34.617876Z", + "shell.execute_reply": "2021-12-14T09:25:34.616894Z", + "shell.execute_reply.started": "2021-12-14T09:25:34.609398Z" + }, + "id": "9E-BFzqUrP4a", + "outputId": "785d296c-e195-4af8-ce70-784cc9bd2447" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The number is0\n", + "The number is1\n", + "The number is2\n", + "The number is3\n", + "The number is4\n", + "Out of loop\n" + ] + } + ], + "source": [ + "# example that uses break statement in a for loop\n", + "\n", + "num = 0\n", + "for num in range(10):\n", + " if num == 5:\n", + " break#break when num == 5\n", + " print('The number is' + str(num))\n", + "\n", + "print('Out of loop')\n", + "\n", + "\n", + "# Explain Why the output is the way it is " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-OvOEgwGkGh1" + }, + "source": [ + "Your Comment: => -------\n", + "from 0 to 9 print all number based on for loop. The break statement in Python terminates the current loop and resumes execution at the next statement. That's why once it reaches value 5, it breaks the loop and it prints upto 4" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "oPN-KW8ErP4a" + }, + "source": [ + "# 2. **`Continue Statement`**\n" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-14T06:14:44.160916Z", + "iopub.status.busy": "2021-12-14T06:14:44.160579Z", + "iopub.status.idle": "2021-12-14T06:14:44.169578Z", + "shell.execute_reply": "2021-12-14T06:14:44.168622Z", + "shell.execute_reply.started": "2021-12-14T06:14:44.160884Z" + }, + "id": "I7RGHGcDrP4a", + "outputId": "1623dadf-25b1-4d43-e696-0b7afb26703b" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The number is0\n", + "The number is1\n", + "The number is2\n", + "The number is3\n", + "The number is4\n", + "The number is6\n", + "The number is7\n", + "The number is8\n", + "The number is9\n", + "Out of loop\n" + ] + } + ], + "source": [ + "# Using same `for loop program` as in Break Statement section above, we’ll use a continue statement rather than a break statement\n", + "num = 0\n", + "\n", + "for num in range(10):\n", + " if num == 5:\n", + " continue #keep running if num == 5\n", + " print('The number is' + str(num))\n", + "\n", + "print('Out of loop')\n", + "\n", + "\n", + "# Explain Why the output is the way it is " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "FqKoSmjUkfSc" + }, + "source": [ + "Your Comment: => -------\n", + "The continue statement in Python returns the control to the beginning of the while loop. The continue statement rejects all the remaining statements in the current iteration of the loop and moves the control back to the top of the loop. That's why when number reaches 5, it puts control back to start of loop and do not print 5 , since the print occurs after if condition check occurs" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-14T08:11:16.489676Z", + "iopub.status.busy": "2021-12-14T08:11:16.489389Z", + "iopub.status.idle": "2021-12-14T08:11:16.496652Z", + "shell.execute_reply": "2021-12-14T08:11:16.495911Z", + "shell.execute_reply.started": "2021-12-14T08:11:16.489646Z" + }, + "id": "QOW1z0udrP4b", + "outputId": "b0cda0f0-55fb-4d3d-91b8-52150bad9f6b" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number is 0\n", + "Number is 1\n", + "Number is 2\n", + "Number is 3\n", + "Number is 4\n", + "Number is 5\n", + "Number is 6\n", + "Number is 7\n", + "Number is 8\n", + "Number is 9\n", + "Out of loop\n" + ] + } + ], + "source": [ + "# Using same code block as above, let’s replace break or continue statement with a pass statement\n", + "num = 0\n", + "\n", + "for num in range(10):\n", + " if num == 5:\n", + " pass # pass then\n", + " print('Number is ' + str(num))\n", + "print('Out of loop')\n", + "\n", + "\n", + "# Explain Why the output is the way it is" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tAreE2KtrP4b" + }, + "source": [ + "Your Comment: => -------\n", + "pass is a null statement. The interpreter does not ignore a pass statement, but nothing happens and the statement results into no operation. So when value reaches 5, it passes to next and goes outside if and prints the value.\n", + "To break instead of pass break need to be used" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "z7Mr7CDerP4b" + }, + "source": [ + "


Assignment Loops and Jump Statements

\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0nJZ8yTqrP4b" + }, + "source": [ + "# 💬 ***Problem Statement-1:***\n", + "\n", + "* User will enter password which is set to be `qwert`\n", + "* If password matches, print ***`Welcome to CloudyML Course!!`*** else print ***`Wrong Password!!`*** and user will re-enter password\n", + "* In `fourth` trial, it will print ***`One Last Trial left!!!`***\n", + "\n", + "Hint: `Break Statement` can be used" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.status.busy": "2021-12-11T05:18:11.242989Z", + "iopub.status.idle": "2021-12-11T05:18:11.243372Z", + "shell.execute_reply": "2021-12-11T05:18:11.243211Z", + "shell.execute_reply.started": "2021-12-11T05:18:11.243182Z" + }, + "id": "3TfEntL3rP4b", + "outputId": "5724ab37-47ab-4614-e503-2edbaf662ec5" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Enter Password: qert\n", + "Wrong Password!!\n", + "Enter Password: ert\n", + "Wrong Password!!\n", + "Enter Password: wewr\n", + "Wrong Password!!\n", + "Enter Password: wewew\n", + "One Last Trial left!!!\n", + "Enter Password: ewewew\n", + "No more try left! Please contact your administrator!\n" + ] + } + ], + "source": [ + "password = \"qwert\"\n", + "tryCount = 0\n", + "while tryCount <=4:\n", + " pwdInp = input('Enter Password: ')\n", + " if pwdInp == password:\n", + " print('Welcome to CloudyML Course!!')\n", + " break\n", + " else: \n", + " tryCount += 1\n", + " if tryCount<4:\n", + " print('Wrong Password!!')\n", + " continue\n", + " elif tryCount == 4:\n", + " print('One Last Trial left!!!')\n", + " continue\n", + " else:\n", + " print('No more try left! Please contact your administrator!')\n", + " break" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "D7sqvuiNrP4b" + }, + "source": [ + "....." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hNE2e0YBrP4b" + }, + "source": [ + "# 💬 ***Problem Statement-2:***\n", + "\n", + "* Enter password which is an OTP set to be `1008`\n", + "* If OTP matches, It will ask user to provide details like ***`Enter Your Name:`*** and ***`Enter Your City:`*** and user will re-enter OTP\n", + "* In `fourth` trial, it will print ***`One Last Trial left!!!`***\n", + "\n", + "`Hint:` Continue Statement can be used" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.status.busy": "2021-12-11T05:18:11.245219Z", + "iopub.status.idle": "2021-12-11T05:18:11.245617Z", + "shell.execute_reply": "2021-12-11T05:18:11.245478Z", + "shell.execute_reply.started": "2021-12-11T05:18:11.245461Z" + }, + "id": "PI9ZTGG6rP4b", + "outputId": "ab4df7fb-a632-4788-88a6-4913800b62ae" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Enter OTP: 1008\n", + "Enter Your Name: Partha\n", + "Enter Your City: Kolkata\n", + "Enter OTP: 1008\n", + "Welcome to CloudyML Course!!\n" + ] + } + ], + "source": [ + "OTP = \"1008\"\n", + "tryCount = 0\n", + "while tryCount <=4:\n", + " otpInp = input('Enter OTP: ')\n", + " if otpInp == OTP:\n", + " tryCount += 1\n", + " if tryCount ==1:\n", + " name = input('Enter Your Name: ')\n", + " city = input('Enter Your City: ')\n", + " continue\n", + " else:\n", + " print('Welcome to CloudyML Course!!')\n", + " break\n", + " else: \n", + " tryCount += 1\n", + " if tryCount<4:\n", + " print('Wrong OTP!!')\n", + " continue\n", + " elif tryCount == 4:\n", + " print('One Last Trial left!!!')\n", + " continue\n", + " else:\n", + " print('No more try left! Please contact your administrator!')\n", + " break" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "mepQLZjcrP4b" + }, + "source": [ + "


Python Data Structures

\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 321 + }, + "execution": { + "iopub.execute_input": "2021-12-15T10:23:50.024709Z", + "iopub.status.busy": "2021-12-15T10:23:50.024254Z", + "iopub.status.idle": "2021-12-15T10:23:50.118042Z", + "shell.execute_reply": "2021-12-15T10:23:50.116991Z", + "shell.execute_reply.started": "2021-12-15T10:23:50.024675Z" + }, + "id": "KVl9bMx_rP4b", + "outputId": "efe2fbbe-3873-4bc4-af7a-5baa8cb8bcaa" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 100, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Data Structures\n", + "YouTubeVideo('https://www.youtube.com/watch?v=R0yDN07Jw_c&list=PLsR_0x6BuM-HJZT6Xzj-088N4hN3KsDME&index=4',width=600,height=300)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1A84HNVLrP4c" + }, + "source": [ + "Existing Data Type: int, float, bool, str\n", + "\n", + "Problem with Existing Data Type:\n", + "* Only single data type can be stored in a variable i.e. either int or decimal or str\n", + "* To store more data we need more variables\n", + " * Eg: You have 100 name and age then you have to make 200 variables, valid for condition if you are not using DataStructure\n", + " \n", + " \n", + "`Data Structure Solves` above problem\n", + "\n", + "# **`Properties of Data Structure:`**\n", + "* Efficient Storage for large data\n", + "* Should allow Manipulation/Operations on data\n", + "* Should mantain underlying relationship of data\n", + "If these three properties are available then you can call it a Data Structure\n", + "\n", + "\n", + "# `Types of Data Structures:`\n", + "* `List` => ordered => elements seprated by comma => enclosed with square brackets-[]\n", + "* `Tuple`\n", + "* `Set`\n", + "* `Dictionary`" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2mYBzcjXrP4c" + }, + "source": [ + "|Data Structures type|Mutable|Comments|Indexing|Ordered|Duplicacy|\n", + "|----|----|----|----|----|----|\n", + "frozenset|immutable|immutable version of set|- |- |- |\n", + "tuple ()|immutable|immutable version of list| possible|yes |allowed |\n", + "list []|mutable|-|possible |yes | allowed |\n", + "set {}|mutable| -|not |no |not |\n", + "dict {key:value}|mutable|-|possible |no |not |" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "XbJv8WOprP4c" + }, + "source": [ + "💫 `immutable` => `can't be changed`
\n", + "💫 `mutable` => `can be changed`" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hxNFx7omrP4c" + }, + "source": [ + "---" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 321 + }, + "execution": { + "iopub.execute_input": "2021-12-15T10:00:04.496944Z", + "iopub.status.busy": "2021-12-15T10:00:04.495833Z", + "iopub.status.idle": "2021-12-15T10:00:04.587067Z", + "shell.execute_reply": "2021-12-15T10:00:04.586137Z", + "shell.execute_reply.started": "2021-12-15T10:00:04.496888Z" + }, + "id": "MSGQfzfQrP4c", + "outputId": "61e4f9dc-2afe-4f56-97da-fd07f73c0229" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 101, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# List\n", + "YouTubeVideo('https://www.youtube.com/watch?v=VGqMziKr9wM&list=PLsR_0x6BuM-HJZT6Xzj-088N4hN3KsDME&index=5',width=600,height=300)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1WlRcrHGrP4c" + }, + "source": [ + "\n", + "# **`List`**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2021-12-13T08:21:05.502988Z", + "iopub.status.busy": "2021-12-13T08:21:05.502536Z", + "iopub.status.idle": "2021-12-13T08:21:05.510594Z", + "shell.execute_reply": "2021-12-13T08:21:05.50956Z", + "shell.execute_reply.started": "2021-12-13T08:21:05.502944Z" + }, + "id": "7SFfVkH0rP4c" + }, + "outputs": [], + "source": [ + "# make a list, name it as names with values ram','ohm','da','ada','asdasd'\n", + "names = ['ram','ohm','da','ada','asdasd']\n", + "# make a list, name it as roll_no with values 21,23,435,65,565,656\n", + "roll_no = [21,23,435,65,565,656]\n", + "# make a list, name it as scores with values 23,2323,2323,234324,3423\n", + "scores = [23,2323,2323,234324,3423]" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T12:31:37.80606Z", + "iopub.status.busy": "2021-12-11T12:31:37.805778Z", + "iopub.status.idle": "2021-12-11T12:31:37.812504Z", + "shell.execute_reply": "2021-12-11T12:31:37.811545Z", + "shell.execute_reply.started": "2021-12-11T12:31:37.806032Z" + }, + "id": "dyF1sb1jrP4c", + "outputId": "abfbec96-e246-4e23-baf0-49d9f536bc5a" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "# make a list with Single data type - str\n", + "# name of list names_list with values as 'krishna','mahadev','surya'\n", + "names_list = ['krishna','mahadev','surya']\n", + "# print type of names_list\n", + "print(type(names_list))" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T08:23:29.204419Z", + "iopub.status.busy": "2021-12-13T08:23:29.204091Z", + "iopub.status.idle": "2021-12-13T08:23:29.211906Z", + "shell.execute_reply": "2021-12-13T08:23:29.211239Z", + "shell.execute_reply.started": "2021-12-13T08:23:29.20439Z" + }, + "id": "1psLdZcUrP4d", + "outputId": "529f473b-ddbf-4577-ccc1-1fd5cd266955" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "# make a list with Mixed data type - str and int\n", + "# name of list names_list with values as 'krishna','mahadev','surya',108,11,21\n", + "names_list = ['krishna','mahadev','surya',108,11,21]\n", + "# print type of names_list\n", + "print(type(names_list))" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 38 + }, + "execution": { + "iopub.execute_input": "2021-12-13T08:26:53.759352Z", + "iopub.status.busy": "2021-12-13T08:26:53.758993Z", + "iopub.status.idle": "2021-12-13T08:26:53.76578Z", + "shell.execute_reply": "2021-12-13T08:26:53.764799Z", + "shell.execute_reply.started": "2021-12-13T08:26:53.759315Z" + }, + "id": "m5_fowfPrP4d", + "outputId": "3435e29e-4633-4d1b-e899-fcc0594fb77b" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mahadev\n" + ] + } + ], + "source": [ + "# access output element \n", + "print(names_list[1])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "J1ipDEgCrP4d" + }, + "source": [ + "`List Indexing:`\n", + "\n", + "\n", + "|`Values`|1|2|3|4|5|6|7|8|9|10|\n", + "|---|---|---|---|---|---|---|---|---|---|---|\n", + "|`Indexing` |0 |1 |2 |3 |4 |5 |6 |7 |8|9|\n", + "|`Negative Indexing`| -10 |-9 |-8 |-7 |-6 |-5 |-4 |-3 |-2 |-1|" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T08:27:25.217447Z", + "iopub.status.busy": "2021-12-13T08:27:25.21688Z", + "iopub.status.idle": "2021-12-13T08:27:25.223883Z", + "shell.execute_reply": "2021-12-13T08:27:25.22327Z", + "shell.execute_reply.started": "2021-12-13T08:27:25.21741Z" + }, + "id": "TStBmS8jrP4d", + "outputId": "e7134ac8-4cd7-4063-9e22-a3d7da34bae2" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "21\n" + ] + } + ], + "source": [ + "# extract single element i.e. last one using Negative Index (first element)\n", + "print(names_list[-1])" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 38 + }, + "execution": { + "iopub.execute_input": "2021-12-13T08:27:33.441996Z", + "iopub.status.busy": "2021-12-13T08:27:33.441702Z", + "iopub.status.idle": "2021-12-13T08:27:33.448369Z", + "shell.execute_reply": "2021-12-13T08:27:33.44729Z", + "shell.execute_reply.started": "2021-12-13T08:27:33.441956Z" + }, + "id": "wJIKlcwkrP4d", + "outputId": "671390ab-a554-42ff-8f16-e462f0b5a947" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "krishna\n" + ] + } + ], + "source": [ + "# extract single element using Index (first element)\n", + "print(names_list[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T08:27:55.214857Z", + "iopub.status.busy": "2021-12-13T08:27:55.214558Z", + "iopub.status.idle": "2021-12-13T08:27:55.22238Z", + "shell.execute_reply": "2021-12-13T08:27:55.221262Z", + "shell.execute_reply.started": "2021-12-13T08:27:55.214827Z" + }, + "id": "w-9l5PkXrP4d", + "outputId": "093767e8-8e37-4454-81fd-19a192eb261d" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['krishna', 'mahadev', 'surya']\n" + ] + } + ], + "source": [ + "# extract sequence of elements using Index (first 3 elements)\n", + "print(names_list[0:3])\n", + " #=> [start index:end index] => exclude end index" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "COPpT8hQrP4d" + }, + "source": [ + "## Membership Operators\n", + "To check if particular element is present in list or not\n", + "* Using `in` or `not in` to get answers of these type of queries " + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T08:30:00.341103Z", + "iopub.status.busy": "2021-12-13T08:30:00.340688Z", + "iopub.status.idle": "2021-12-13T08:30:00.347279Z", + "shell.execute_reply": "2021-12-13T08:30:00.346359Z", + "shell.execute_reply.started": "2021-12-13T08:30:00.341069Z" + }, + "id": "Y_8SDN1SrP4d", + "outputId": "98b3f42c-bd35-4068-9030-f605da939fa5" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['krishna', 'mahadev', 'surya', 108, 11, 21]\n" + ] + } + ], + "source": [ + "# see names_list data\n", + "print(names_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T08:30:23.983164Z", + "iopub.status.busy": "2021-12-13T08:30:23.982521Z", + "iopub.status.idle": "2021-12-13T08:30:23.988855Z", + "shell.execute_reply": "2021-12-13T08:30:23.987976Z", + "shell.execute_reply.started": "2021-12-13T08:30:23.983128Z" + }, + "id": "zAhq9WqsrP4d", + "outputId": "5ecbe90b-6da0-471a-9060-6712e8d85ea5" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "False\n" + ] + } + ], + "source": [ + "# see if 'mukesh' is in names_list\n", + "nameFlag = False\n", + "if 'mukesh' in names_list:\n", + " nameFlag = True\n", + "print(nameFlag)" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T08:30:33.933979Z", + "iopub.status.busy": "2021-12-13T08:30:33.933573Z", + "iopub.status.idle": "2021-12-13T08:30:33.93938Z", + "shell.execute_reply": "2021-12-13T08:30:33.938604Z", + "shell.execute_reply.started": "2021-12-13T08:30:33.933949Z" + }, + "id": "0LjgT08NrP4d", + "outputId": "365b85e0-06dd-4956-e2e6-ce0b69a56b99" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n" + ] + } + ], + "source": [ + "# see if 'rawan' is notin names_list\n", + "nameFlag = False\n", + "if 'rawan' not in names_list:\n", + " nameFlag = True\n", + "print(nameFlag)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_jF5-7_PrP4e" + }, + "source": [ + "## Adding to List\n", + "* Adding a single element: `append()` => add at the end of the list\n", + "* Adding multiple elements (adding list in list): `extend()`" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Onk48j8xrP4e" + }, + "source": [ + "# Use of .append()" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T08:31:08.016806Z", + "iopub.status.busy": "2021-12-13T08:31:08.016526Z", + "iopub.status.idle": "2021-12-13T08:31:08.023252Z", + "shell.execute_reply": "2021-12-13T08:31:08.022472Z", + "shell.execute_reply.started": "2021-12-13T08:31:08.016776Z" + }, + "id": "ZEo63rVKrP4e", + "outputId": "f022080d-c809-4910-e801-c9944cfc2814" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['krishna', 'mahadev', 'surya', 108, 11, 21]\n" + ] + } + ], + "source": [ + "#see again names_list elements\n", + "print(names_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T08:31:48.35115Z", + "iopub.status.busy": "2021-12-13T08:31:48.35089Z", + "iopub.status.idle": "2021-12-13T08:31:48.35939Z", + "shell.execute_reply": "2021-12-13T08:31:48.358505Z", + "shell.execute_reply.started": "2021-12-13T08:31:48.351123Z" + }, + "id": "JWztwD_PrP4e", + "outputId": "ba1d0ec2-a270-4efc-dc94-602f8a71e1ac" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['krishna', 'mahadev', 'surya', 108, 11, 21]\n", + "['krishna', 'mahadev', 'surya', 108, 11, 21, 'bhagwan']\n", + "['krishna', 'mahadev', 'surya', 108, 11, 21, 'bhagwan', [3, 'ok']]\n" + ] + } + ], + "source": [ + "# #see again names_list list elements\n", + "\n", + "print(names_list)\n", + "#appending 'bhagwan' to list names_list\n", + "#using append()\n", + "names_list.append('bhagwan')\n", + "\n", + "# print list after appending\n", + "print(names_list)\n", + "\n", + "# append 3,'ok' values as a list of list\n", + " #<= it will append a list inside a list\n", + "names_list.append([3,'ok'])\n", + "# print names_list\n", + "print(names_list)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "L6_5O9xcrP4e" + }, + "source": [ + "# Use of .extend()" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T08:32:56.378121Z", + "iopub.status.busy": "2021-12-13T08:32:56.377806Z", + "iopub.status.idle": "2021-12-13T08:32:56.384032Z", + "shell.execute_reply": "2021-12-13T08:32:56.38291Z", + "shell.execute_reply.started": "2021-12-13T08:32:56.378087Z" + }, + "id": "chB2CoWqrP4e", + "outputId": "dbcb4f45-5fdc-492d-b3e5-34d5c1409300" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['krishna', 'mahadev', 'surya', 108, 11, 21, 'bhagwan', [3, 'ok'], 6, 'one more']\n" + ] + } + ], + "source": [ + "\n", + "# extend names_list with values 6,'one more'\n", + "names_list.extend([6,'one more'])\n", + "# print list after .extend()\n", + "print(names_list)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "fI6TbJ9IrP4e" + }, + "source": [ + "## Deleting from list\n", + "* `.remove()` => delete element by its value\n", + "* `del` => delete element by index : indexing start from 0" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "iwcbBZfrrP4e" + }, + "source": [ + "# Use of .remove()" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T08:35:24.870142Z", + "iopub.status.busy": "2021-12-13T08:35:24.869868Z", + "iopub.status.idle": "2021-12-13T08:35:24.876688Z", + "shell.execute_reply": "2021-12-13T08:35:24.875739Z", + "shell.execute_reply.started": "2021-12-13T08:35:24.870115Z" + }, + "id": "xYy-KNKxrP4e", + "outputId": "d8ca16db-82f0-4e75-8b28-a0df2a817409" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['krishna', 'mahadev', 'surya', 108, 11, 21, 'bhagwan', [3, 'ok'], 6, 'one more']\n" + ] + } + ], + "source": [ + "# see names_list\n", + "print(names_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T08:35:35.977782Z", + "iopub.status.busy": "2021-12-13T08:35:35.976582Z", + "iopub.status.idle": "2021-12-13T08:35:35.982445Z", + "shell.execute_reply": "2021-12-13T08:35:35.981775Z", + "shell.execute_reply.started": "2021-12-13T08:35:35.977713Z" + }, + "id": "8UfKI7MYrP4e", + "outputId": "bb230368-2dad-415a-fbbc-6751f7ccf5d7" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['krishna', 'mahadev', 'surya', 108, 11, 21, 'bhagwan', [3, 'ok'], 6]\n" + ] + } + ], + "source": [ + "# remove one more from names_list\n", + "names_list.remove('one more')\n", + "# print names_list\n", + "print(names_list)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "P7mXoDiprP4f" + }, + "source": [ + "# Use of del" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T08:35:52.107924Z", + "iopub.status.busy": "2021-12-13T08:35:52.10741Z", + "iopub.status.idle": "2021-12-13T08:35:52.114855Z", + "shell.execute_reply": "2021-12-13T08:35:52.11401Z", + "shell.execute_reply.started": "2021-12-13T08:35:52.107873Z" + }, + "id": "AvQDPc_hrP4f", + "outputId": "c9892133-d330-4123-90a8-8862bddd3976" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['krishna', 'mahadev', 'surya', 108, 11, 21, 'bhagwan', [3, 'ok'], 6]\n" + ] + } + ], + "source": [ + "# see names_list\n", + "print(names_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T08:35:57.308409Z", + "iopub.status.busy": "2021-12-13T08:35:57.307742Z", + "iopub.status.idle": "2021-12-13T08:35:57.312802Z", + "shell.execute_reply": "2021-12-13T08:35:57.311834Z", + "shell.execute_reply.started": "2021-12-13T08:35:57.308377Z" + }, + "id": "oOyXUP0HrP4f", + "outputId": "578b5043-895d-4b54-8ea3-86d0cc245df7" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['krishna', 'mahadev', 'surya', 108, 11, 21, 'bhagwan', 6]\n" + ] + } + ], + "source": [ + "# del 7 from names_list\n", + "del names_list[7]\n", + "# print names_list\n", + "print(names_list)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "EPu0UxWCrP4f" + }, + "source": [ + "## Iterate through list" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T08:37:14.63231Z", + "iopub.status.busy": "2021-12-13T08:37:14.631538Z", + "iopub.status.idle": "2021-12-13T08:37:14.638126Z", + "shell.execute_reply": "2021-12-13T08:37:14.637474Z", + "shell.execute_reply.started": "2021-12-13T08:37:14.632274Z" + }, + "id": "R8Xgr9-BrP4f", + "outputId": "88a452c1-5a7f-4f7e-977c-340c0758c79d" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "krishna\n", + "mahadev\n", + "surya\n", + "108\n", + "11\n", + "21\n", + "bhagwan\n", + "6\n" + ] + } + ], + "source": [ + "# interate through list elements \n", + "for item in names_list:\n", + " # print element\n", + " print(item)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "q7tmRtqYrP4f" + }, + "source": [ + "## Some pre-defined method on List\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T08:37:49.527524Z", + "iopub.status.busy": "2021-12-13T08:37:49.527228Z", + "iopub.status.idle": "2021-12-13T08:37:49.533884Z", + "shell.execute_reply": "2021-12-13T08:37:49.532894Z", + "shell.execute_reply.started": "2021-12-13T08:37:49.527488Z" + }, + "id": "7xHmcCStrP4f", + "outputId": "4c1c71ad-56c7-4b97-f8db-7f5ac3cccbbc" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "['krishna', 'mahadev', 'surya', 108, 11, 21, 'bhagwan', 6]" + ] + }, + "execution_count": 120, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# see names_list\n", + "print(names_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T08:37:37.260228Z", + "iopub.status.busy": "2021-12-13T08:37:37.259131Z", + "iopub.status.idle": "2021-12-13T08:37:37.265686Z", + "shell.execute_reply": "2021-12-13T08:37:37.2651Z", + "shell.execute_reply.started": "2021-12-13T08:37:37.260147Z" + }, + "id": "hfmxSI0yrP4f", + "outputId": "87beb8b3-ea6e-4151-ce23-6ae62e20d308" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "8\n" + ] + } + ], + "source": [ + "# find length of list names_list\n", + "print(len(names_list))" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T08:38:29.087211Z", + "iopub.status.busy": "2021-12-13T08:38:29.086638Z", + "iopub.status.idle": "2021-12-13T08:38:29.093655Z", + "shell.execute_reply": "2021-12-13T08:38:29.092331Z", + "shell.execute_reply.started": "2021-12-13T08:38:29.087163Z" + }, + "id": "6u--oITYrP4f", + "outputId": "6907cbe0-0376-465f-ed1a-d435442b925c" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[6, 'bhagwan', 21, 11, 108, 'surya', 'mahadev', 'krishna']\n" + ] + } + ], + "source": [ + "# reverse a list names_list\n", + "names_list_rev = names_list[::-1]\n", + "# see names_list\n", + "print(names_list_rev)" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 201 + }, + "execution": { + "iopub.execute_input": "2021-12-13T08:38:36.562239Z", + "iopub.status.busy": "2021-12-13T08:38:36.561875Z", + "iopub.status.idle": "2021-12-13T08:38:36.578288Z", + "shell.execute_reply": "2021-12-13T08:38:36.577247Z", + "shell.execute_reply.started": "2021-12-13T08:38:36.562208Z" + }, + "id": "JnGHTVmBrP4f", + "outputId": "1d305b31-497e-492f-d79b-c483d15aa0a6" + }, + "outputs": [ + { + "ename": "TypeError", + "evalue": "'<' not supported between instances of 'int' and 'str'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# sort a list see condition when it is not possible\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mnames_list\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msort\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3\u001b[0m \u001b[0mnames_list\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mTypeError\u001b[0m: '<' not supported between instances of 'int' and 'str'" + ] + } + ], + "source": [ + "# sort a list see condition when it is not possible\n", + "names_list.sort()\n", + "names_list" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "metadata": { + "execution": { + "iopub.execute_input": "2021-12-13T08:39:03.298835Z", + "iopub.status.busy": "2021-12-13T08:39:03.298535Z", + "iopub.status.idle": "2021-12-13T08:39:03.305099Z", + "shell.execute_reply": "2021-12-13T08:39:03.304468Z", + "shell.execute_reply.started": "2021-12-13T08:39:03.298805Z" + }, + "id": "pkHLORxmrP4g" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[11, 21, 51, 101]\n" + ] + } + ], + "source": [ + "# make a list named as numbers_list with values as [51,101,11,21]\n", + "numbers_list = [51,101,11,21]\n", + "# sort list numbers_list\n", + "numbers_list.sort()\n", + "# see numbers_list output\n", + "print(numbers_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T08:39:19.768779Z", + "iopub.status.busy": "2021-12-13T08:39:19.768469Z", + "iopub.status.idle": "2021-12-13T08:39:19.774375Z", + "shell.execute_reply": "2021-12-13T08:39:19.773639Z", + "shell.execute_reply.started": "2021-12-13T08:39:19.768743Z" + }, + "id": "SrfzuBccrP4g", + "outputId": "5ed807b6-35a5-44af-a0d3-1d3ca01baccc" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[11, 21, 51, 101]\n" + ] + } + ], + "source": [ + "# another way of sorting list\n", + "def sortedList(listToSort):\n", + " sortedList = []\n", + " while listToSort:\n", + " minVal = listToSort[0]\n", + " for item in listToSort:\n", + " if item


Assignment Python Data Structures List

" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "E8-7E8mTrP4h" + }, + "source": [ + "# 💬 **List Problem Statement:**\n", + "\n", + "Say CloudyML conducted an assessment test to hire a Data Scientist
\n", + "Candidates were evaluated on 5 different subject `Statistics`, `Python`, `SQL`, `ML`, and `DeepLearning`
\n", + "`Help CloudyML team to find out answers of following questions`
\n", + "\n", + "💡 `Find out Who scored highest marks in Python?`\n", + "* Step1: Select name of student and marks in Python\n", + "* Step2: Store filtered name and marks in another list\n", + "* Step3: Sort list. (Kept marks as first index)\n", + "* Step4: Get final index of sorted list" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "execution": { + "iopub.execute_input": "2021-12-11T05:18:24.8457Z", + "iopub.status.busy": "2021-12-11T05:18:24.845176Z", + "iopub.status.idle": "2021-12-11T05:18:24.852835Z", + "shell.execute_reply": "2021-12-11T05:18:24.852031Z", + "shell.execute_reply.started": "2021-12-11T05:18:24.845665Z" + }, + "id": "vwDSOqA7rP4h" + }, + "outputs": [], + "source": [ + "#### Marks of 5 different subjects out of 100 are as ####\n", + "subject_list = ['Name', ['Statistics', 'Python', 'SQL', 'ML', 'DeepLearning']]\n", + "# make student marks nested list\n", + "student_marks = [subject_list,\n", + " ['Ananya', [41, 34, 45, 55, 63]],\n", + " ['Akash', [42, 23, 34, 44, 53]],\n", + " ['Rahul', [32, 23, 13, 54, 67]],\n", + " ['Mukesh', [23, 82, 23, 63, 34]],\n", + " ['Pranav', [21, 23, 25, 56, 56]]]" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T05:18:25.304684Z", + "iopub.status.busy": "2021-12-11T05:18:25.303946Z", + "iopub.status.idle": "2021-12-11T05:18:25.313298Z", + "shell.execute_reply": "2021-12-11T05:18:25.312419Z", + "shell.execute_reply.started": "2021-12-11T05:18:25.304637Z" + }, + "id": "Q7ZkPsYtrP4h", + "outputId": "ca0f15ff-82f2-48da-9191-a0c8885bdb60" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[['Name', ['Statistics', 'Python', 'SQL', 'ML', 'DeepLearning']], ['Ananya', [41, 34, 45, 55, 63]], ['Akash', [42, 23, 34, 44, 53]], ['Rahul', [32, 23, 13, 54, 67]], ['Mukesh', [23, 82, 23, 63, 34]], ['Pranav', [21, 23, 25, 56, 56]]]\n" + ] + } + ], + "source": [ + "# print student_marks\n", + "print(student_marks)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T05:18:25.944893Z", + "iopub.status.busy": "2021-12-11T05:18:25.944133Z", + "iopub.status.idle": "2021-12-11T05:18:25.950026Z", + "shell.execute_reply": "2021-12-11T05:18:25.949155Z", + "shell.execute_reply.started": "2021-12-11T05:18:25.944856Z" + }, + "id": "VT7znIVKrP4h", + "outputId": "210f49d9-2c5f-4fbe-f37a-e35edf2fcf7b" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Name', ['Statistics', 'Python', 'SQL', 'ML', 'DeepLearning']]\n" + ] + } + ], + "source": [ + "# access first index of list student_marks\n", + "print(student_marks[0])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3u3-dfkVrP4h" + }, + "source": [ + "* Slice list from second element" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T05:18:28.949697Z", + "iopub.status.busy": "2021-12-11T05:18:28.949117Z", + "iopub.status.idle": "2021-12-11T05:18:28.95532Z", + "shell.execute_reply": "2021-12-11T05:18:28.95457Z", + "shell.execute_reply.started": "2021-12-11T05:18:28.94966Z" + }, + "id": "LPRZOoR6rP4h", + "outputId": "448d015c-dda2-4156-d481-b03b2cd03270" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Ananya', [41, 34, 45, 55, 63]]\n" + ] + } + ], + "source": [ + "# access first index of list student_marks[1]\n", + "print(student_marks[1])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PitdZQvErP4h" + }, + "source": [ + "See, each element in list from Index-1 contains 2 elements\n", + "* first is `Name` \n", + "* second is `list of marks`" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 38 + }, + "execution": { + "iopub.execute_input": "2021-12-11T05:18:54.137742Z", + "iopub.status.busy": "2021-12-11T05:18:54.137328Z", + "iopub.status.idle": "2021-12-11T05:18:54.142584Z", + "shell.execute_reply": "2021-12-11T05:18:54.142014Z", + "shell.execute_reply.started": "2021-12-11T05:18:54.137713Z" + }, + "id": "NoA0T3VRrP4h", + "outputId": "8c0b8c94-7347-402a-8517-38c6d929bfa7" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ananya\n" + ] + } + ], + "source": [ + "# acess first student name\n", + "print(student_marks[1][0])" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T05:19:31.890553Z", + "iopub.status.busy": "2021-12-11T05:19:31.890129Z", + "iopub.status.idle": "2021-12-11T05:19:31.895735Z", + "shell.execute_reply": "2021-12-11T05:19:31.894943Z", + "shell.execute_reply.started": "2021-12-11T05:19:31.890522Z" + }, + "id": "WII68GgKrP4h", + "outputId": "c0a15850-bead-4a5c-9f58-5ce75a7bf6e6" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[41, 34, 45, 55, 63]\n" + ] + } + ], + "source": [ + "# acess ananya marks\n", + "print(student_marks[1][1])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "vDPny7O1rP4h" + }, + "source": [ + "Now, student marks are in order **`Statistics`**, **`Python`**, **`SQL`**, **`ML`** and **`DeepLearning`**. and we need to access value at Index-1 to get marks in subject => **`Python`** " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T05:21:26.548879Z", + "iopub.status.busy": "2021-12-11T05:21:26.548134Z", + "iopub.status.idle": "2021-12-11T05:21:26.554956Z", + "shell.execute_reply": "2021-12-11T05:21:26.553864Z", + "shell.execute_reply.started": "2021-12-11T05:21:26.548833Z" + }, + "id": "5H7QGuDxrP4i", + "outputId": "b88beecf-b586-4b51-9960-eb31c8792807" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "34" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# observe the output commend why this is the way it is\n", + "student_marks[1][1][1]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7rsQ1IkmrP4i" + }, + "source": [ + "See above `Ananya` Python marks" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "TTBeJoDarP4i" + }, + "source": [ + "***Now Solving Problem step after step***\n", + "* `Who scored highest marks in subject Python? ` \n", + "\n", + "\n", + "***Step1: Select name of student and marks in subject Python***" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T05:25:24.612102Z", + "iopub.status.busy": "2021-12-11T05:25:24.611262Z", + "iopub.status.idle": "2021-12-11T05:25:24.620706Z", + "shell.execute_reply": "2021-12-11T05:25:24.619653Z", + "shell.execute_reply.started": "2021-12-11T05:25:24.612019Z" + }, + "id": "gs5ozIK6rP4i", + "outputId": "edb1b321-8e88-4f3e-dd6a-34de84153d35" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ananya 34\n", + "Akash 23\n", + "Rahul 23\n", + "Mukesh 82\n", + "Pranav 23\n" + ] + } + ], + "source": [ + "student_marksitr = iter(student_marks)\n", + "next(student_marksitr)\n", + "for items in student_marksitr:\n", + " print(f\"{items[0]} {items[1][1]}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bVk9RoafrP4i" + }, + "source": [ + "***Step2: Store filtered Name and Marks in another list***" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T05:27:02.350541Z", + "iopub.status.busy": "2021-12-11T05:27:02.35026Z", + "iopub.status.idle": "2021-12-11T05:27:02.357152Z", + "shell.execute_reply": "2021-12-11T05:27:02.356437Z", + "shell.execute_reply.started": "2021-12-11T05:27:02.350512Z" + }, + "id": "syCySARFrP4i", + "outputId": "a2bb411d-0ef6-4fc8-b220-bcbc5a0ae3b3" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[34, 'Ananya'], [23, 'Akash'], [23, 'Rahul'], [82, 'Mukesh'], [23, 'Pranav']]\n" + ] + } + ], + "source": [ + "student_marksitr = iter(student_marks)\n", + "next(student_marksitr)\n", + "filterlist_python = []\n", + "for items in student_marksitr:\n", + " filterlist_python.append([items[1][1],items[0]])\n", + "print(filterlist_python)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "EK2lofCarP4i" + }, + "source": [ + "***Step3: Sort list (Keep marks as first index)***" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T05:27:57.054536Z", + "iopub.status.busy": "2021-12-11T05:27:57.053964Z", + "iopub.status.idle": "2021-12-11T05:27:57.059563Z", + "shell.execute_reply": "2021-12-11T05:27:57.058936Z", + "shell.execute_reply.started": "2021-12-11T05:27:57.054501Z" + }, + "id": "76Ld6yVxrP4i", + "outputId": "70626986-15f8-481f-f01b-880f581d067e" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[23, 'Akash'], [23, 'Rahul'], [23, 'Pranav'], [34, 'Ananya'], [82, 'Mukesh']]\n" + ] + } + ], + "source": [ + "sort_pythonList = sorted(filterlist_python, key=lambda x: x[0])\n", + "print(sort_pythonList)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "W8QJHOwarP4i" + }, + "source": [ + "***Step4: Get final index of sorted list with student name having max marks in Python subject***" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 38 + }, + "execution": { + "iopub.execute_input": "2021-12-11T05:28:38.167787Z", + "iopub.status.busy": "2021-12-11T05:28:38.167215Z", + "iopub.status.idle": "2021-12-11T05:28:38.172981Z", + "shell.execute_reply": "2021-12-11T05:28:38.172162Z", + "shell.execute_reply.started": "2021-12-11T05:28:38.167744Z" + }, + "id": "Zha0IrK5rP4i", + "outputId": "8a1ebfff-061d-448f-be8e-1c0b1414174b" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mukesh\n" + ] + } + ], + "source": [ + "max_pythonMarks = max(sort_pythonList, key=lambda x: x[0])\n", + "print(max_pythonMarks[1])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_zTy7qCPrP4i" + }, + "source": [ + "Got answer of first question. Mukesh has scored highest marks in subject Python\n", + "* You can also do it using loop do it if you want to" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "qOrSdhg0rP4j" + }, + "source": [ + "-----" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 321 + }, + "execution": { + "iopub.execute_input": "2021-12-15T10:02:09.422635Z", + "iopub.status.busy": "2021-12-15T10:02:09.422331Z", + "iopub.status.idle": "2021-12-15T10:02:09.517013Z", + "shell.execute_reply": "2021-12-15T10:02:09.516373Z", + "shell.execute_reply.started": "2021-12-15T10:02:09.422606Z" + }, + "id": "eD3Y_C4LrP4j", + "outputId": "c5a5a88e-028d-4586-af13-b961afecfb73" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 140, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Tuples\n", + "YouTubeVideo('https://www.youtube.com/watch?v=I6UH_prRboE&list=PLsR_0x6BuM-HJZT6Xzj-088N4hN3KsDME&index=6',width=600,height=300)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "OemzDS2WrP4j" + }, + "source": [ + "# **`Tuple`**
\n", + "\n", + "Benefit of using tuples:
\n", + "* Faster then list\n", + "* Provide security over updation => once created cannot be modefyied like list\n", + "* Can be used as key for dictionarie\n", + "* We generally use tuple for heterogeneous(different) datatypes and list for homogeneous (similar) datatypes\n", + "* Since tuples are immutable, iterating through tuple is faster than with list. So there is a slight performance boost\n", + "* Tuples that contain immutable elements can be used as a key for a dictionary. With lists, this is not possible\n", + "* If you have data that doesn't change, implementing it as tuple will guarantee that it remains write-protected\n", + "* We cannot edit/update or delete elements from the tuple" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T09:25:57.996935Z", + "iopub.status.busy": "2021-12-13T09:25:57.996637Z", + "iopub.status.idle": "2021-12-13T09:25:58.003016Z", + "shell.execute_reply": "2021-12-13T09:25:58.002305Z", + "shell.execute_reply.started": "2021-12-13T09:25:57.996901Z" + }, + "id": "Xpd2kVRirP4j", + "outputId": "6158cd3d-d3d1-4def-edc0-c939e418aeb6" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "('krishna', 'mahadev', 'surya', 108, 11, 21, 'bhagwan', 6)\n", + "\n" + ] + } + ], + "source": [ + "# make a variable names as data_tuple with values 'krishna', 'mahadev', 'surya', 108, 11, 21, 'bhagwan', 6\n", + "data_tuple = ('krishna', 'mahadev', 'surya', 108, 11, 21, 'bhagwan', 6)\n", + "# print data_tuple\n", + "print(data_tuple)\n", + "# print type of data_tuple\n", + "print(type(data_tuple))" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T09:27:06.135979Z", + "iopub.status.busy": "2021-12-13T09:27:06.135652Z", + "iopub.status.idle": "2021-12-13T09:27:06.141415Z", + "shell.execute_reply": "2021-12-13T09:27:06.140855Z", + "shell.execute_reply.started": "2021-12-13T09:27:06.13594Z" + }, + "id": "qFKzjV8DrP4j", + "outputId": "9def8315-b12a-4ecd-eef0-8e3ef6530725" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3\n" + ] + } + ], + "source": [ + "# make a variable named as data_tuple with values as 1,2,3,4,5\n", + "data_tuple = (1,2,3,4,5)\n", + "# Acess element at 2nd Index of data_tuple #<= indexing work same as list as tuple is ordered data structure\n", + "print(data_tuple[2])" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T09:28:08.921542Z", + "iopub.status.busy": "2021-12-13T09:28:08.921138Z", + "iopub.status.idle": "2021-12-13T09:28:08.927847Z", + "shell.execute_reply": "2021-12-13T09:28:08.926915Z", + "shell.execute_reply.started": "2021-12-13T09:28:08.921511Z" + }, + "id": "jdK6gHwprP4j", + "outputId": "5ff5a454-32b0-4f82-9c27-7faab9babb5c" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(8, 9)\n" + ] + } + ], + "source": [ + "# think what will be the output of this code then run it\n", + "data_tuple = ( (1,2,3,4,5),\n", + " (4,5,3,4,5),\n", + " (3,7,8,9,6) )\n", + "\n", + "data_tuple[2][2:4]\n", + "print(data_tuple[2][2:4])\n", + "\n", + "# Views on why the output is the way it is\n", + "#data_tuple[2] will give the 3rd list element (3,7,8,9,6). data_tuple[2][2:4] will slice\n", + "#3rd and 4th element from that list. Hence output is (8,9)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T09:30:54.043384Z", + "iopub.status.busy": "2021-12-13T09:30:54.043064Z", + "iopub.status.idle": "2021-12-13T09:30:54.049414Z", + "shell.execute_reply": "2021-12-13T09:30:54.048781Z", + "shell.execute_reply.started": "2021-12-13T09:30:54.043336Z" + }, + "id": "AClKJufdrP4j", + "outputId": "939adcfd-9c5b-47d8-a433-e2693071a52f" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n" + ] + } + ], + "source": [ + "# find Index of any element, here index of 3 \n", + "data_tuple = (1,2,3,4,5)\n", + " # <= 3 is at 2nd index as indexing start at one\n", + "print(data_tuple.index(3))" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T09:31:11.760542Z", + "iopub.status.busy": "2021-12-13T09:31:11.759923Z", + "iopub.status.idle": "2021-12-13T09:31:11.767097Z", + "shell.execute_reply": "2021-12-13T09:31:11.766314Z", + "shell.execute_reply.started": "2021-12-13T09:31:11.760505Z" + }, + "id": "xCtcvhjIrP4j", + "outputId": "6ebfc2b1-2b73-4acf-9032-77c23ffa4b10" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "3\n" + ] + } + ], + "source": [ + "# count of an element \n", + "data_tuple = (1,2,3,4,5)\n", + "# print how many time 4 have come \n", + "print(data_tuple.count(4))\n", + "\n", + "data_tuple = (7,2,7,4,7)\n", + "# print how many time 7 have come\n", + "print(data_tuple.count(7))" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T09:32:03.156908Z", + "iopub.status.busy": "2021-12-13T09:32:03.156111Z", + "iopub.status.idle": "2021-12-13T09:32:03.162462Z", + "shell.execute_reply": "2021-12-13T09:32:03.161615Z", + "shell.execute_reply.started": "2021-12-13T09:32:03.156827Z" + }, + "id": "4xAMDPSnrP4j", + "outputId": "fcfb1003-c973-4a3d-e126-18fac7721483" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "7\n", + "2\n", + "7\n", + "4\n", + "7\n" + ] + } + ], + "source": [ + "# iterate through elements of tuple similar to list using for \n", + "data_tuple = (7,2,7,4,7)\n", + "for element in data_tuple:\n", + " print(element)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T09:32:27.691011Z", + "iopub.status.busy": "2021-12-13T09:32:27.690197Z", + "iopub.status.idle": "2021-12-13T09:32:27.698429Z", + "shell.execute_reply": "2021-12-13T09:32:27.697623Z", + "shell.execute_reply.started": "2021-12-13T09:32:27.690955Z" + }, + "id": "90Fc9IK3rP4k", + "outputId": "1c24c8f7-198c-40dd-e5a8-994769b88a2f" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(5, 2)\n", + "(7, 4)\n", + "0\n", + "0\n" + ] + } + ], + "source": [ + "# slicing in tuple\n", + "data_tuple = (5,2,7,4,6)\n", + "\n", + "# slice and print first 2 element\n", + "#<= exclude 2nd Index\n", + "print(data_tuple[0:2])\n", + "\n", + "# defining start pont as 2 and end poin as 4 to slice\n", + "print(data_tuple[2:4])\n", + "\n", + "# by using count method on slice see how many time 2 comes\n", + "#<= count of 2 if present\n", + "print(data_tuple[2:4].count(2))\n", + "\n", + "# index method on slice\n", + "print( data_tuple[1:4].index(2) ) #<= index of 2" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 201 + }, + "execution": { + "iopub.execute_input": "2021-12-13T09:34:00.566648Z", + "iopub.status.busy": "2021-12-13T09:34:00.565926Z", + "iopub.status.idle": "2021-12-13T09:34:00.58237Z", + "shell.execute_reply": "2021-12-13T09:34:00.58128Z", + "shell.execute_reply.started": "2021-12-13T09:34:00.566613Z" + }, + "id": "SYHssmIhrP4k", + "outputId": "ec2bfafe-3601-474b-cc7f-9a205f62bdfd" + }, + "outputs": [ + { + "ename": "TypeError", + "evalue": "'tuple' object does not support item assignment", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# Tuple immutable (cant update or delete elements from tuples)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;31m## this is one of the reasons it is fast in comparison to list\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mdata_tuple\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1\u001b[0m \u001b[0;31m#<= update at index-2 with 1, it will give error\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment" + ] + } + ], + "source": [ + "# Tuple immutable (cant update or delete elements from tuples)\n", + "## this is one of the reasons it is fast in comparison to list\n", + "data_tuple[2] = 1 #<= update at index-2 with 1, it will give error" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T09:34:18.357129Z", + "iopub.status.busy": "2021-12-13T09:34:18.356785Z", + "iopub.status.idle": "2021-12-13T09:34:18.363026Z", + "shell.execute_reply": "2021-12-13T09:34:18.361949Z", + "shell.execute_reply.started": "2021-12-13T09:34:18.357068Z" + }, + "id": "Z2biiRsirP4k", + "outputId": "8b0aace0-b409-4008-c015-17ae40689e82" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(5, 2, 7, 4, 6)" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data_tuple" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 166 + }, + "execution": { + "iopub.execute_input": "2021-12-13T09:34:27.001712Z", + "iopub.status.busy": "2021-12-13T09:34:27.000985Z", + "iopub.status.idle": "2021-12-13T09:34:27.016464Z", + "shell.execute_reply": "2021-12-13T09:34:27.015451Z", + "shell.execute_reply.started": "2021-12-13T09:34:27.001669Z" + }, + "id": "KGFbjOiWrP4k", + "outputId": "d17e373b-0866-40e3-acff-79f964c56816" + }, + "outputs": [ + { + "ename": "TypeError", + "evalue": "'tuple' object doesn't support item deletion", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mdel\u001b[0m \u001b[0mdata_tuple\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;31m#<= del at index-0, again error\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m: 'tuple' object doesn't support item deletion" + ] + } + ], + "source": [ + "del data_tuple[0] #<= del at index-0, again error\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Mx7xKlWErP4k" + }, + "source": [ + "


Assignment Python Data Structures List&Set

" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "WvTU5e5QrP4k" + }, + "source": [ + "# 💬 **List Problem Statement:**\n", + "\n", + "Say CloudyML conducted an assessment test to hire a Data Scientist
\n", + "Candidates were evaluated on 5 different subject `Statistics`, `Python`, `SQL`, `ML`, and `DeepLearning`
\n", + "`Help CloudyML team to find out answers of following questions`
\n", + "\n", + "💡 `Find out Who scored highest marks in Python?`
\n", + "💡 `Find out average marks scored in subject SQL?`
\n", + "💡 `Find out scored highest percentage of marks?`
\n", + "💡 `If considered only top-4 subjects of a candidate, then who scored highest percentage of marks?`
\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T07:48:04.967742Z", + "iopub.status.busy": "2021-12-11T07:48:04.967414Z", + "iopub.status.idle": "2021-12-11T07:48:04.979905Z", + "shell.execute_reply": "2021-12-11T07:48:04.979017Z", + "shell.execute_reply.started": "2021-12-11T07:48:04.96771Z" + }, + "id": "Dz8vLyD8rP4k", + "outputId": "6ac3fb21-cf12-434f-920d-0b6b41edeeca" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[82, 'Gyan']\n" + ] + } + ], + "source": [ + "### Find out Who scored highest marks in Python? ###\n", + "# student marks nested list\n", + "student_marks = [['Name',['Statistics','Python','SQL','ML','DeepLearning']],\n", + " ['Ananya',[41, 34, 45, 55, 63]],\n", + " ['Akash',[42, 23, 34, 44, 53]],\n", + " ['Rahul',[32, 23, 13, 54, 67]],\n", + " ['Gyan',[23, 82, 23, 63, 34]],\n", + " ['Pranav',[21, 23, 25, 56, 56]] ]\n", + "#print(student_marks)\n", + "filterlist_python = []\n", + "#sum = 0\n", + "for items in student_marks[1:]:\n", + " filterlist_python.append([items[1][1],items[0]])\n", + "# sum = sum +items[1][1]\n", + " \n", + "#print(filterlist_python)\n", + "\n", + "# Find out Who scored highest marks in Python? using for loop, soorted and slicing\n", + "sort_pythonList = sorted(filterlist_python, key=lambda x: x[0])\n", + "#print(sort_pythonList)\n", + "max_pythonMarks = max(sort_pythonList, key=lambda x: x[0])\n", + "print(max_pythonMarks)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T07:50:08.48356Z", + "iopub.status.busy": "2021-12-11T07:50:08.483261Z", + "iopub.status.idle": "2021-12-11T07:50:08.490736Z", + "shell.execute_reply": "2021-12-11T07:50:08.490115Z", + "shell.execute_reply.started": "2021-12-11T07:50:08.483531Z" + }, + "id": "4RNm9UT0rP4k", + "outputId": "a9d9bb23-35bf-4973-e9f9-6036f547c6b0" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "avg_of_SQL_marks: 28.0\n" + ] + } + ], + "source": [ + "### Find out average marks scored in subject SQL? ###\n", + "all_SQL_marks = []\n", + "# Extracted col= name with SQL_data=marks\n", + "\n", + "# Extracted only SQL_data=marks\n", + "for items in student_marks[1:]:\n", + " all_SQL_marks.append(items[1][2])\n", + "#print(all_SQL_marks)\n", + "total_element_in_SQL = len(all_SQL_marks)\n", + "# mathematical operation\n", + "avg_of_SQL_marks = sum(all_SQL_marks)/total_element_in_SQL\n", + "\n", + "print('avg_of_SQL_marks:',avg_of_SQL_marks)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T07:51:33.252381Z", + "iopub.status.busy": "2021-12-11T07:51:33.25188Z", + "iopub.status.idle": "2021-12-11T07:55:09.52883Z", + "shell.execute_reply": "2021-12-11T07:55:09.527987Z", + "shell.execute_reply.started": "2021-12-11T07:51:33.252342Z" + }, + "id": "wz8BshX9rP4k", + "outputId": "be1bd259-2dbd-4c83-e5a5-5ea1deb5b8f8" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Maximum marks for each subject:70\n", + "Number of Subjects:5\n", + "Topper percentage is: 48 % Name is: Ananya\n" + ] + } + ], + "source": [ + "### Find out scored highest percentage of marks? ###\n", + "#print(student_marks)\n", + "import math\n", + "student_avg = []\n", + "for items in student_marks[1:]:\n", + " avg_marks = sum(items[1])/len(items[1])\n", + " student_avg.append([items[0], avg_marks])\n", + "#print(student_avg)\n", + "max_avg = max(student_avg, key=lambda x: x[1])\n", + "#print(max_avg)\n", + "#number of subjects\n", + "print(\"Maximum marks for each subject:70\")\n", + "subject_list = student_marks[0][1]\n", + "print(f\"Number of Subjects:{len(subject_list)}\")\n", + "print(f\"Topper percentage is: {math.ceil(max_avg[1])} % Name is: {max_avg[0]}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T07:58:52.945655Z", + "iopub.status.busy": "2021-12-11T07:58:52.945371Z", + "iopub.status.idle": "2021-12-11T07:58:58.969944Z", + "shell.execute_reply": "2021-12-11T07:58:58.96934Z", + "shell.execute_reply.started": "2021-12-11T07:58:52.945623Z" + }, + "id": "5iPh1wnDrP4k", + "outputId": "9452fbcd-bd86-4538-b78e-89b7f14240c0" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Maximum marks for each subject:67\n", + "Number of Subjects considered:4\n", + "Topper percentage is: 51 % Name is: Ananya\n" + ] + } + ], + "source": [ + "### solv for `If considered only top-4 subjects of a candidate, then who scored the highest percentage of marks?` ###\n", + "student_avg4 = []\n", + "for items in student_marks[1:]:\n", + " items[1].sort(reverse=True)\n", + " avg_marks = sum(items[1][:4])/len(items[1][:4])\n", + " student_avg4.append([items[0],avg_marks])\n", + "#print(student_avg4)\n", + "max_avg = max(student_avg4, key=lambda x: x[1])\n", + "print(\"Maximum marks for each subject:67\")\n", + "subject_list = student_marks[0][1]\n", + "print(f\"Number of Subjects considered:{len(subject_list)-1}\")\n", + "print(f\"Topper percentage is: {math.ceil(max_avg[1])} % Name is: {max_avg[0]}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BM93iUT5rP4l" + }, + "source": [ + "----" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 321 + }, + "execution": { + "iopub.execute_input": "2021-12-15T10:05:12.841186Z", + "iopub.status.busy": "2021-12-15T10:05:12.8409Z", + "iopub.status.idle": "2021-12-15T10:05:12.933645Z", + "shell.execute_reply": "2021-12-15T10:05:12.932612Z", + "shell.execute_reply.started": "2021-12-15T10:05:12.841156Z" + }, + "id": "hd_ENTFmrP4l", + "outputId": "1e55157b-de2f-4d95-b770-ba68b60973d8" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 156, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Sets\n", + "YouTubeVideo('https://www.youtube.com/watch?v=I6UH_prRboE&list=PLsR_0x6BuM-HJZT6Xzj-088N4hN3KsDME&index=8',width=600,height=300)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "XsNXA8nhrP4l" + }, + "source": [ + "# **`Sets`**\n", + "* Unordered collection of elements (if you put some data in order inside set it will discard order)\n", + " * It shorts elements by itself (see below example)\n", + "* No duplicates only unique values\n", + " * Put duplicates in set it will auto remove them\n", + "* Mutable can add, remove values\n", + "* Set Theory operations are possible like Union,Intersection etc...\n", + " * `intersection` of 2 sets => set_1.intersection(set_2)\n", + " * `union` of 2 sets => set_1.union(set_2) .." + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T10:35:08.133731Z", + "iopub.status.busy": "2021-12-13T10:35:08.133473Z", + "iopub.status.idle": "2021-12-13T10:35:08.139556Z", + "shell.execute_reply": "2021-12-13T10:35:08.138794Z", + "shell.execute_reply.started": "2021-12-13T10:35:08.133703Z" + }, + "id": "DLSJiWUSrP4l", + "outputId": "0136d5e4-5f98-43c3-e1b4-975c91fb5ac1" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'a', 'b', 'c', 'z'}" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# define set named as set_ with values 'b','c','a','z'\n", + "set_ ={'b','c','a','z'}\n", + "# print set\n", + "set_\n", + "#print(sorted(set_))" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T10:34:31.33395Z", + "iopub.status.busy": "2021-12-13T10:34:31.333664Z", + "iopub.status.idle": "2021-12-13T10:34:31.340853Z", + "shell.execute_reply": "2021-12-13T10:34:31.339951Z", + "shell.execute_reply.started": "2021-12-13T10:34:31.333921Z" + }, + "id": "ifReR9qIrP4l", + "outputId": "75726f08-f495-4f5d-fea9-c6ae74acade2" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'banana', 'mango'}\n" + ] + } + ], + "source": [ + "# define list namead as frt with elements as 'mango','banana','mango','banana'\n", + "frt = ['mango','banana','mango','banana']\n", + "# define a set named as set_ with elements as 'mango','banana','mango','banana'\n", + "set_ = {'mango','banana','mango','banana'}\n", + "# print set\n", + "print(set_)" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T10:35:53.059133Z", + "iopub.status.busy": "2021-12-13T10:35:53.058813Z", + "iopub.status.idle": "2021-12-13T10:35:53.065121Z", + "shell.execute_reply": "2021-12-13T10:35:53.064528Z", + "shell.execute_reply.started": "2021-12-13T10:35:53.0591Z" + }, + "id": "14_MnlmYrP4l", + "outputId": "d642e7ad-615c-41b4-eb12-3dbe22867f5f" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{1, 4, 5, 'A', 'L', 'V'}" + ] + }, + "execution_count": 59, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# make a set named as set_data and values as 4,'A',5,1,'V','L'\n", + "set_data = {4,'A',5,1,'V','L'}\n", + "# print set_data #<= results are shorted\n", + "set_data" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T10:36:04.201965Z", + "iopub.status.busy": "2021-12-13T10:36:04.201399Z", + "iopub.status.idle": "2021-12-13T10:36:04.207641Z", + "shell.execute_reply": "2021-12-13T10:36:04.206918Z", + "shell.execute_reply.started": "2021-12-13T10:36:04.201927Z" + }, + "id": "HxKlhWFIrP4l", + "outputId": "d9a6d066-e841-4632-907a-93f2f47c57c7" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{1, 4, 5, 'V'}" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# No duplicates only unique values\n", + "# make a set named as set_data and values as 4,4,5,1,'V','V'\n", + "set_data = {4,4,5,1,'V','V'}\n", + "# print set_data\n", + "set_data" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T10:37:15.539051Z", + "iopub.status.busy": "2021-12-13T10:37:15.538461Z", + "iopub.status.idle": "2021-12-13T10:37:15.544971Z", + "shell.execute_reply": "2021-12-13T10:37:15.544206Z", + "shell.execute_reply.started": "2021-12-13T10:37:15.539016Z" + }, + "id": "EMm2IUSSrP4l", + "outputId": "7f92c4ab-8923-434e-b3aa-61fbf06dc962" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{1, 2, 'A', 'B'}" + ] + }, + "execution_count": 62, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# make tuple named as tuple_data with values as 'A', 'B', 1, 2, 'B', 'A'\n", + "tuple_data = ('A', 'B', 1, 2, 'B', 'A')\n", + "# make a variable names as var_1 and convert it into set \n", + "var_1 = set(tuple_data)\n", + "# peint var_1\n", + "var_1" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T10:36:12.493797Z", + "iopub.status.busy": "2021-12-13T10:36:12.493525Z", + "iopub.status.idle": "2021-12-13T10:36:12.500748Z", + "shell.execute_reply": "2021-12-13T10:36:12.499845Z", + "shell.execute_reply.started": "2021-12-13T10:36:12.493769Z" + }, + "id": "Qs0Fw69SrP4l", + "outputId": "560d36ec-21af-4d64-9f86-4b9771c1fb3a" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{1, 2, 'A', 'B'}" + ] + }, + "execution_count": 71, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Defining a set using a List \n", + "# define a list named as list_data with values as 'A', 'B', 1, 2, 'B', 'A'] # this is a list with duplicate data\n", + "list_data = ['A', 'B', 1, 2, 'B', 'A']\n", + "# change set_from_list to set # set will remove duplicates\n", + "set_from_list =set(list_data)\n", + "# print set_from_list)\n", + "set_from_list\n", + "# Defining a set using a Tuple named as tuple_data with values as 'A', 'B', 1, 2, 'B', 'A'\n", + "tuple_data =('A', 'B', 1, 2, 'B', 'A')\n", + "# make variable named as set_from_tuple, change tuple_data into set\n", + "set_from_tuple =set(tuple_data)\n", + "# print set_from_tuple)\n", + "set_from_tuple" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T10:37:33.379859Z", + "iopub.status.busy": "2021-12-13T10:37:33.379214Z", + "iopub.status.idle": "2021-12-13T10:37:33.385068Z", + "shell.execute_reply": "2021-12-13T10:37:33.383741Z", + "shell.execute_reply.started": "2021-12-13T10:37:33.379825Z" + }, + "id": "-zK2B4EVrP4m", + "outputId": "845c35ce-84fc-498b-d910-4e41d20cc367" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{1, 2, 'A', 'B'}" + ] + }, + "execution_count": 72, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# see set_from_tuple output\n", + "set_from_tuple" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T10:37:50.051518Z", + "iopub.status.busy": "2021-12-13T10:37:50.051093Z", + "iopub.status.idle": "2021-12-13T10:37:50.056057Z", + "shell.execute_reply": "2021-12-13T10:37:50.055307Z", + "shell.execute_reply.started": "2021-12-13T10:37:50.051475Z" + }, + "id": "IbTLUsjZrP4m", + "outputId": "45fbfb13-06f8-4c88-d01a-f41b52a4fd8e" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{0, 1, 2, 'A', 'B'}" + ] + }, + "execution_count": 73, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# add 0 to set_from_tuple\n", + "set_from_tuple.add(0)\n", + "# print set_from_tuple\n", + "set_from_tuple" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T10:38:42.235906Z", + "iopub.status.busy": "2021-12-13T10:38:42.235458Z", + "iopub.status.idle": "2021-12-13T10:38:42.241784Z", + "shell.execute_reply": "2021-12-13T10:38:42.241004Z", + "shell.execute_reply.started": "2021-12-13T10:38:42.235854Z" + }, + "id": "1UvNVglBrP4m", + "outputId": "a72e6407-7431-4b02-cafb-161a1446b78c" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'a', 'b', 'c', 'z'}" + ] + }, + "execution_count": 66, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# make variable named as set_ with values as 'b','c','a','z'\n", + "set_ = {'b','c','a','z'}\n", + "# print set_\n", + "set_" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T10:39:16.170247Z", + "iopub.status.busy": "2021-12-13T10:39:16.169691Z", + "iopub.status.idle": "2021-12-13T10:39:16.176298Z", + "shell.execute_reply": "2021-12-13T10:39:16.175352Z", + "shell.execute_reply.started": "2021-12-13T10:39:16.170208Z" + }, + "id": "AtqlCQhwrP4m", + "outputId": "1036c20c-4060-4194-f7de-4114cda62551" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'a', 'b', 'c', 'x', 'z'}" + ] + }, + "execution_count": 67, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# add x to set_\n", + "set_.add('x')\n", + "# print set_\n", + "set_" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T06:15:31.956351Z", + "iopub.status.busy": "2021-12-11T06:15:31.956065Z", + "iopub.status.idle": "2021-12-11T06:15:31.960879Z", + "shell.execute_reply": "2021-12-11T06:15:31.960304Z", + "shell.execute_reply.started": "2021-12-11T06:15:31.956323Z" + }, + "id": "cDyIT-tlrP4m", + "outputId": "b99b1590-9219-4a98-9f51-47203f70495b" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{0, 1, 2, 'A', 'B', 'C'}" + ] + }, + "execution_count": 75, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Add 0 to set set_from_tuple\n", + "set_from_tuple.add(0)\n", + "# print set_from_tuple # 0 is added at the starting of set, as set orders by itself\n", + "set_from_tuple\n", + "# adding C to set set_from_tuple\n", + "set_from_tuple.add('C')\n", + "# print set_from_tuple # c is added at the last of set, as set orders by itself\n", + "set_from_tuple" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "EDd-kK1ZrP4m" + }, + "source": [ + "# delete element from set" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T10:39:44.118756Z", + "iopub.status.busy": "2021-12-13T10:39:44.118476Z", + "iopub.status.idle": "2021-12-13T10:39:44.124827Z", + "shell.execute_reply": "2021-12-13T10:39:44.123926Z", + "shell.execute_reply.started": "2021-12-13T10:39:44.118721Z" + }, + "id": "aN2nrR1arP4m", + "outputId": "1dfd07e5-1941-45cd-b171-364727c5fa3f" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{0, 1, 2, 'A', 'B', 'C'}" + ] + }, + "execution_count": 76, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# see output of set_from_tuple\n", + "set_from_tuple" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T10:40:23.456723Z", + "iopub.status.busy": "2021-12-13T10:40:23.456412Z", + "iopub.status.idle": "2021-12-13T10:40:23.464155Z", + "shell.execute_reply": "2021-12-13T10:40:23.46307Z", + "shell.execute_reply.started": "2021-12-13T10:40:23.456685Z" + }, + "id": "j6igfM8nrP4m", + "outputId": "c5783257-7d36-4155-f7cf-a9f757ff0507" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{1, 2, 'A', 'B', 'C'}" + ] + }, + "execution_count": 77, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# use discard to remove 0 from set_from_tuple\n", + "set_from_tuple.discard(0)\n", + "# see output of set_from_tuple\n", + "set_from_tuple" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T10:40:39.372555Z", + "iopub.status.busy": "2021-12-13T10:40:39.372293Z", + "iopub.status.idle": "2021-12-13T10:40:39.378787Z", + "shell.execute_reply": "2021-12-13T10:40:39.377808Z", + "shell.execute_reply.started": "2021-12-13T10:40:39.372528Z" + }, + "id": "1nehzTjkrP4m", + "outputId": "0542ef03-6150-4646-dc1d-eb3eab997987" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{1, 2, 'A', 'B', 'C'}" + ] + }, + "execution_count": 78, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# from set_from_tuple discard 9 \n", + "set_from_tuple.discard(9)\n", + "# print set_from_tuple\n", + "set_from_tuple" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": { + "execution": { + "iopub.execute_input": "2021-12-11T06:18:45.979547Z", + "iopub.status.busy": "2021-12-11T06:18:45.978965Z", + "iopub.status.idle": "2021-12-11T06:18:45.983234Z", + "shell.execute_reply": "2021-12-11T06:18:45.982497Z", + "shell.execute_reply.started": "2021-12-11T06:18:45.979512Z" + }, + "id": "aMvJSw36rP4m" + }, + "outputs": [ + { + "ename": "KeyError", + "evalue": "0.0", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mset_from_tuple\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdiscard\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0.0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mset_from_tuple\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mset_from_tuple\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mremove\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0.0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 7\u001b[0m \u001b[0mset_from_tuple\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyError\u001b[0m: 0.0" + ] + } + ], + "source": [ + "# delete element from set (two methods are as)\n", + "## discard() : if element not in set, it will not show error\n", + "## remove() : if element not in set, it will show error\n", + "set_from_tuple.discard(0.0)\n", + "set_from_tuple\n", + "set_from_tuple.remove(0.0)\n", + "set_from_tuple" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "GzSBD7aarP4n" + }, + "source": [ + "# Difference b/w two set (set_1 - set_2)" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T10:43:00.404461Z", + "iopub.status.busy": "2021-12-13T10:43:00.403679Z", + "iopub.status.idle": "2021-12-13T10:43:00.411534Z", + "shell.execute_reply": "2021-12-13T10:43:00.410581Z", + "shell.execute_reply.started": "2021-12-13T10:43:00.404418Z" + }, + "id": "yUJSP6ggrP4n", + "outputId": "cd3f6dd6-9bbb-4667-c4a9-cc24d43b9e58" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{1, 2, 3, 'A', 'B'}" + ] + }, + "execution_count": 82, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# set_1 - set_2 => states that, collect every element of set_1 after removing thouse element which are common in set_1 and set_2 \n", + "\n", + "# define a set named as set_1 with elements as 1,2,3,'A','B'\n", + "set_1 = {1,2,3,'A','B'}\n", + "# define a set named as set_2 with elements as 3,'A'\n", + "set_2 = {3,'A'}\n", + "# difference of set_1 and set_2\n", + "set_1 - set_2\n", + "# see difference between set_1 and set_2)\n", + "# print set_1\n", + "set_1" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T10:43:13.854716Z", + "iopub.status.busy": "2021-12-13T10:43:13.85441Z", + "iopub.status.idle": "2021-12-13T10:43:13.860912Z", + "shell.execute_reply": "2021-12-13T10:43:13.860085Z", + "shell.execute_reply.started": "2021-12-13T10:43:13.85468Z" + }, + "id": "2iJJJttErP4n", + "outputId": "68c59dab-7466-40d2-e3ba-bffeeda61c12" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{1, 2, 'B'}" + ] + }, + "execution_count": 86, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# if you want ot update set_1 by difference\n", + "difference_update = set_1-set_2\n", + "# using difference_update update set_1 and set_2\n", + "set_1= difference_update\n", + "# print set_1\n", + "set_1" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "M-ocEPqmrP4n" + }, + "source": [ + "# Intersection b/w two set (set_1 - set_2)" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T10:43:58.377355Z", + "iopub.status.busy": "2021-12-13T10:43:58.377047Z", + "iopub.status.idle": "2021-12-13T10:43:58.384648Z", + "shell.execute_reply": "2021-12-13T10:43:58.383813Z", + "shell.execute_reply.started": "2021-12-13T10:43:58.377316Z" + }, + "id": "o25pTFa5rP4n", + "outputId": "738f078d-c476-457b-eedd-4b26f58680dd" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{1, 2, 3, 'A', 'B'}" + ] + }, + "execution_count": 87, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# collect only elements which are common b/w both sets\n", + "set_1 = {1,2,3,'A','B'}\n", + "set_2 = {3,'A'}\n", + "set_1.intersection(set_2)\n", + "set_1" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T10:44:04.443196Z", + "iopub.status.busy": "2021-12-13T10:44:04.442569Z", + "iopub.status.idle": "2021-12-13T10:44:04.449452Z", + "shell.execute_reply": "2021-12-13T10:44:04.448782Z", + "shell.execute_reply.started": "2021-12-13T10:44:04.44314Z" + }, + "id": "ONav5Mx6rP4n", + "outputId": "8fbbf265-60be-4515-bd3e-e5ffe4841622" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{3, 'A'}" + ] + }, + "execution_count": 88, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# if you want ot update set_1 by intersection\n", + "set_1.intersection_update(set_2)\n", + "set_1" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1F9jH1x7rP4n" + }, + "source": [ + "----" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 321 + }, + "execution": { + "iopub.execute_input": "2021-12-15T10:06:22.37147Z", + "iopub.status.busy": "2021-12-15T10:06:22.371133Z", + "iopub.status.idle": "2021-12-15T10:06:22.464735Z", + "shell.execute_reply": "2021-12-15T10:06:22.463983Z", + "shell.execute_reply.started": "2021-12-15T10:06:22.371432Z" + }, + "id": "WktbQcX8rP4n", + "outputId": "eb3de7ff-5f7c-47b3-a06c-33bfba961ba1" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 179, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Dict\n", + "YouTubeVideo('https://www.youtube.com/watch?v=I6UH_prRboE&list=PLsR_0x6BuM-HJZT6Xzj-088N4hN3KsDME&index=7',width=600,height=300)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1jNZ_aKnrP4n" + }, + "source": [ + "# **`Dictionary`** => `key:value`\n", + "* Unordered data structure\n", + "* Collection of multiple lists can say, looks like set{} but have {key:value} pairs for storing elements\n", + " * student_information is a dictionay and it have name,age,email,adress etc store in form of list how see bellow example\n", + "* `Element of dictionary can only be acessed by using key not Index`\n", + "* Every key must be unique\n", + "\n", + "`{} -> curly brac`" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": { + "execution": { + "iopub.execute_input": "2021-12-13T09:55:55.008155Z", + "iopub.status.busy": "2021-12-13T09:55:55.007857Z", + "iopub.status.idle": "2021-12-13T09:55:55.016151Z", + "shell.execute_reply": "2021-12-13T09:55:55.015078Z", + "shell.execute_reply.started": "2021-12-13T09:55:55.008123Z" + }, + "id": "vhdeUMEarP4n" + }, + "outputs": [], + "source": [ + "# student details\n", + "names = ['Viranda','Sandhu','Rama','Yoga']\n", + "height = [120,130,140,150]\n", + "weight = [56,60,45,90]\n", + "age = [23,34,56,55]\n", + "\n", + "\"\"\"\n", + "dict = { key:values }\n", + "\"\"\"\n", + "\n", + "### storing all these 4 lists in a dict using key:value # once data structure inside other\n", + "student_details_dict = {\n", + " 'names' : ['Viranda','Sandhu','Rama','Yoga'],\n", + " 'height' : [120,130,140,150],\n", + " 'weight' : [56,60,45,90],\n", + " 'age' : [23,34,56,55]\n", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "FFiDiI_PrP4o" + }, + "source": [ + "* Above name,height are the `key` and list's data are the `value pair` associated with the key\n", + " * can say each key is mapped to multiple values\n", + "* Above is the representation of advanced data structure as you can see list inside a dictionary" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 201 + }, + "execution": { + "iopub.execute_input": "2021-12-13T09:57:01.9233Z", + "iopub.status.busy": "2021-12-13T09:57:01.923008Z", + "iopub.status.idle": "2021-12-13T09:57:01.940278Z", + "shell.execute_reply": "2021-12-13T09:57:01.939181Z", + "shell.execute_reply.started": "2021-12-13T09:57:01.92327Z" + }, + "id": "E-Fr1AeJrP4o", + "outputId": "0eb07a28-f5f0-4c34-f6ac-9e4ca82b6483" + }, + "outputs": [ + { + "ename": "KeyError", + "evalue": "0", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0;31m# trying to acess using index will give error\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m \u001b[0mstudent_details_dict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m: 0" + ] + } + ], + "source": [ + "### Acessing elements of dict ###\n", + "student_details_dict = {\n", + " 'names' : ['Ohm','Sandhu','Rama','Yoga'],\n", + " 'height' : [120,130,140,150],\n", + " 'weight' : [56,60,45,90],\n", + " 'age' : [23,34,56,55]\n", + "}\n", + "\n", + "# trying to acess using index will give error\n", + "student_details_dict[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "metadata": { + "execution": { + "iopub.execute_input": "2021-12-13T09:58:13.100392Z", + "iopub.status.busy": "2021-12-13T09:58:13.100091Z", + "iopub.status.idle": "2021-12-13T09:58:13.106757Z", + "shell.execute_reply": "2021-12-13T09:58:13.105836Z", + "shell.execute_reply.started": "2021-12-13T09:58:13.100356Z" + }, + "id": "yBZ4q0E2rP4o" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[23, 34, 56, 55]" + ] + }, + "execution_count": 91, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "student_details_dict['age']" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T09:58:55.922743Z", + "iopub.status.busy": "2021-12-13T09:58:55.922327Z", + "iopub.status.idle": "2021-12-13T09:58:55.928051Z", + "shell.execute_reply": "2021-12-13T09:58:55.927326Z", + "shell.execute_reply.started": "2021-12-13T09:58:55.92271Z" + }, + "id": "82I92AVerP4o", + "outputId": "58507641-5d10-47ff-da0e-0cdc6d82c878" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'names': ['Ohm', 'Sandhu', 'Rama', 'Yoga'],\n", + " 'height': [120, 130, 140, 150],\n", + " 'weight': [56, 60, 45, 90],\n", + " 'age': [23, 34, 56, 55]}" + ] + }, + "execution_count": 92, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "student_details_dict" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 38 + }, + "execution": { + "iopub.execute_input": "2021-12-13T10:00:03.888355Z", + "iopub.status.busy": "2021-12-13T10:00:03.888062Z", + "iopub.status.idle": "2021-12-13T10:00:03.894125Z", + "shell.execute_reply": "2021-12-13T10:00:03.8932Z", + "shell.execute_reply.started": "2021-12-13T10:00:03.888323Z" + }, + "id": "fTkrcNdCrP4o", + "outputId": "09a165bf-1647-4fe3-e52e-8b372950749f" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'Yoga'" + ] + }, + "execution_count": 93, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "student_details_dict['names'][-1]" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T09:57:39.804977Z", + "iopub.status.busy": "2021-12-13T09:57:39.804262Z", + "iopub.status.idle": "2021-12-13T09:57:39.810231Z", + "shell.execute_reply": "2021-12-13T09:57:39.809595Z", + "shell.execute_reply.started": "2021-12-13T09:57:39.804939Z" + }, + "id": "5HnJNpSVrP4o", + "outputId": "c7e94aaa-6340-48ad-f9f5-26e6d63717ab" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Ohm', 'Sandhu', 'Rama', 'Yoga'] \n", + "\n", + "['Sandhu', 'Rama', 'Yoga']\n" + ] + } + ], + "source": [ + "# trying to acess using key will give error\n", + "\n", + "print(student_details_dict['names'],'\\n')\n", + "\n", + "#getting into name key values\n", + "print(student_details_dict['names'][1:])" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T10:00:32.522566Z", + "iopub.status.busy": "2021-12-13T10:00:32.522274Z", + "iopub.status.idle": "2021-12-13T10:00:32.528149Z", + "shell.execute_reply": "2021-12-13T10:00:32.527394Z", + "shell.execute_reply.started": "2021-12-13T10:00:32.522535Z" + }, + "id": "MkV-hbCLrP4o", + "outputId": "9fbee366-f38e-49f6-8744-74000eda9b2c" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "dict_keys(['names', 'height', 'weight', 'age'])" + ] + }, + "execution_count": 96, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "### Acessing keys ###\n", + "student_details_dict.keys()" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T10:00:42.766841Z", + "iopub.status.busy": "2021-12-13T10:00:42.766539Z", + "iopub.status.idle": "2021-12-13T10:00:42.772659Z", + "shell.execute_reply": "2021-12-13T10:00:42.771701Z", + "shell.execute_reply.started": "2021-12-13T10:00:42.766808Z" + }, + "id": "sxApYLKkrP4o", + "outputId": "c74d25b5-0491-4b9e-e633-109805f35d32" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "dict_values([['Ohm', 'Sandhu', 'Rama', 'Yoga'], [120, 130, 140, 150], [56, 60, 45, 90], [23, 34, 56, 55]])" + ] + }, + "execution_count": 97, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "### Acessing values ###\n", + "student_details_dict.values()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PpsBjTaVrP4o" + }, + "source": [ + "# Adding single element to dictionary" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T10:01:17.756917Z", + "iopub.status.busy": "2021-12-13T10:01:17.756443Z", + "iopub.status.idle": "2021-12-13T10:01:17.762487Z", + "shell.execute_reply": "2021-12-13T10:01:17.761665Z", + "shell.execute_reply.started": "2021-12-13T10:01:17.756852Z" + }, + "id": "_FBTPjTZrP4p", + "outputId": "62c79263-6a1c-492a-cb37-d2307ae1cf9b" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'names': ['Ohm', 'Sandhu', 'Rama', 'Yoga'],\n", + " 'height': [120, 130, 140, 150],\n", + " 'weight': [56, 60, 45, 90],\n", + " 'age': [23, 34, 56, 55]}" + ] + }, + "execution_count": 98, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "student_details_dict" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T10:01:41.411494Z", + "iopub.status.busy": "2021-12-13T10:01:41.410772Z", + "iopub.status.idle": "2021-12-13T10:01:41.417072Z", + "shell.execute_reply": "2021-12-13T10:01:41.416524Z", + "shell.execute_reply.started": "2021-12-13T10:01:41.411448Z" + }, + "id": "0wKUkHGFrP4p", + "outputId": "8e9a65b4-dfcb-40f5-bbb3-8403075f407b" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'names': ['Ohm', 'Sandhu', 'Rama', 'Yoga'],\n", + " 'height': [120, 130, 140, 150],\n", + " 'weight': [56, 60, 45, 90],\n", + " 'age': [23, 34, 56, 55],\n", + " 'emails': ['as@gmail.com', 'asd@gmail.com', 'd@gmail.com', 'sd@gmail.com']}" + ] + }, + "execution_count": 99, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# dict_name['key_name'] = [values to update]\n", + "student_details_dict['emails'] = ['as@gmail.com','asd@gmail.com','d@gmail.com','sd@gmail.com']\n", + "\n", + "student_details_dict" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "WmJ6exLbrP4p" + }, + "source": [ + "# Adding multiple element to dictionary " + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T10:02:34.603596Z", + "iopub.status.busy": "2021-12-13T10:02:34.602964Z", + "iopub.status.idle": "2021-12-13T10:02:34.609421Z", + "shell.execute_reply": "2021-12-13T10:02:34.608851Z", + "shell.execute_reply.started": "2021-12-13T10:02:34.603556Z" + }, + "id": "EA49XnzsrP4p", + "outputId": "007b3a9b-1b3e-4818-891a-103c5e77bae0" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'names': ['Ohm', 'Sandhu', 'Rama', 'Yoga'],\n", + " 'height': [120, 130, 140, 150],\n", + " 'weight': [56, 60, 45, 90],\n", + " 'age': [23, 34, 56, 55],\n", + " 'emails': ['as@gmail.com', 'asd@gmail.com', 'd@gmail.com', 'sd@gmail.com']}" + ] + }, + "execution_count": 100, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "student_details_dict" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T10:02:45.620076Z", + "iopub.status.busy": "2021-12-13T10:02:45.619188Z", + "iopub.status.idle": "2021-12-13T10:02:45.627322Z", + "shell.execute_reply": "2021-12-13T10:02:45.626391Z", + "shell.execute_reply.started": "2021-12-13T10:02:45.620025Z" + }, + "id": "VO6IrvskrP4p", + "outputId": "53952eb7-29dd-45d8-cdb9-2c97957fc670" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'names': ['Ohm', 'Sandhu', 'Rama', 'Yoga'],\n", + " 'height': [120, 130, 140, 150],\n", + " 'weight': [56, 60, 45, 90],\n", + " 'age': [23, 34, 56, 55],\n", + " 'emails': ['as@gmail.com', 'asd@gmail.com', 'd@gmail.com', 'sd@gmail.com'],\n", + " 'adress': ['ana', 'dasd', 'asdad', 'adasd'],\n", + " 'sex': ['m', 'm', 'm', 'm']}" + ] + }, + "execution_count": 101, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# use of .update({'key':[value],'key1':[value1]})\n", + "\n", + "student_details_dict.update({'adress':['ana','dasd','asdad','adasd'],'sex':['m','m','m','m']})\n", + "student_details_dict" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "pPXUz271rP4p" + }, + "source": [ + "# Deleting element of dictionary" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T10:03:17.732961Z", + "iopub.status.busy": "2021-12-13T10:03:17.732651Z", + "iopub.status.idle": "2021-12-13T10:03:17.739801Z", + "shell.execute_reply": "2021-12-13T10:03:17.738946Z", + "shell.execute_reply.started": "2021-12-13T10:03:17.732932Z" + }, + "id": "tdOxfYdCrP4p", + "outputId": "0be3c5df-13a2-4525-a6d1-414193202285" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'adress': ['ana', 'dasd', 'asdad', 'adasd'],\n", + " 'age': [23, 34, 56, 55],\n", + " 'emails': ['as@gmail.com', 'asd@gmail.com', 'd@gmail.com', 'sd@gmail.com'],\n", + " 'height': [120, 130, 140, 150],\n", + " 'names': ['Ohm', 'Sandhu', 'Rama', 'Yoga'],\n", + " 'sex': ['m', 'm', 'm', 'm'],\n", + " 'weight': [56, 60, 45, 90]}" + ] + }, + "execution_count": 191, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "student_details_dict" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T10:03:34.612505Z", + "iopub.status.busy": "2021-12-13T10:03:34.61224Z", + "iopub.status.idle": "2021-12-13T10:03:34.619065Z", + "shell.execute_reply": "2021-12-13T10:03:34.618374Z", + "shell.execute_reply.started": "2021-12-13T10:03:34.612477Z" + }, + "id": "Iu1l27PNrP4p", + "outputId": "0e180056-5f67-4d5c-e56c-80ae69f5eacf" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'names': ['Ohm', 'Sandhu', 'Rama', 'Yoga'],\n", + " 'height': [120, 130, 140, 150],\n", + " 'weight': [56, 60, 45, 90],\n", + " 'age': [23, 34, 56, 55],\n", + " 'emails': ['as@gmail.com', 'asd@gmail.com', 'd@gmail.com', 'sd@gmail.com'],\n", + " 'adress': ['ana', 'dasd', 'asdad', 'adasd']}" + ] + }, + "execution_count": 102, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# use of del\n", + "del student_details_dict['sex'] #<= removing sex key totaly from key\n", + "student_details_dict" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "VrRk_bhJrP4p" + }, + "source": [ + "# Updating dict with dicts" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T10:04:32.718812Z", + "iopub.status.busy": "2021-12-13T10:04:32.718516Z", + "iopub.status.idle": "2021-12-13T10:04:32.726459Z", + "shell.execute_reply": "2021-12-13T10:04:32.725624Z", + "shell.execute_reply.started": "2021-12-13T10:04:32.718775Z" + }, + "id": "1v2BgiPUrP4p", + "outputId": "024fb376-bf65-4927-c49f-aea9d069c6b6" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'age': 21,\n", + " 'attendance': 74,\n", + " 'city': 'Gurugram',\n", + " 'country': 'India',\n", + " 'name': 'Vany',\n", + " 'percentage': 85,\n", + " 'roll_no': 'CSE100'}" + ] + }, + "execution_count": 103, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Make a dict named as student_data_dictionary with value which are given bellow as output\n", + "student_data_dictionary = {'age': 21,\n", + " 'attendance': 74,\n", + " 'city': 'Gurugram',\n", + " 'country': 'India',\n", + " 'name': 'Vany',\n", + " 'percentage': 85,\n", + " 'roll_no': 'CSE100'}\n", + "\n", + "# print student_data_dictionary\n", + "student_data_dictionary" + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T10:04:55.19956Z", + "iopub.status.busy": "2021-12-13T10:04:55.199263Z", + "iopub.status.idle": "2021-12-13T10:04:55.205958Z", + "shell.execute_reply": "2021-12-13T10:04:55.205314Z", + "shell.execute_reply.started": "2021-12-13T10:04:55.199526Z" + }, + "id": "2GhXVhlFrP4q", + "outputId": "11da83c6-c6eb-44f7-b4a0-b7d794a5fa09" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'age': 21,\n", + " 'attendance': 74,\n", + " 'city': 'Gurugram',\n", + " 'country': 'India',\n", + " 'name': 'Vany',\n", + " 'percentage': 85,\n", + " 'roll_no': 'CSE100',\n", + " 'last_name': 'Unicorn',\n", + " 'pincode': 345467}" + ] + }, + "execution_count": 104, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# update student_data_dictionary by observing output \n", + "student_data_dictionary.update({'last_name': 'Unicorn','pincode': 345467})\n", + "# print student_data_dictionary\n", + "student_data_dictionary" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "w7yMNpcArP4q" + }, + "source": [ + "# Updating dict with list of tuples" + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T10:05:27.964104Z", + "iopub.status.busy": "2021-12-13T10:05:27.96382Z", + "iopub.status.idle": "2021-12-13T10:05:27.969942Z", + "shell.execute_reply": "2021-12-13T10:05:27.96922Z", + "shell.execute_reply.started": "2021-12-13T10:05:27.964075Z" + }, + "id": "z9a5hByPrP4q", + "outputId": "6df79425-ed84-4d35-ee4b-0dd9f0b86841" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'age': 21,\n", + " 'attendance': 74,\n", + " 'city': 'Gurugram',\n", + " 'country': 'India',\n", + " 'name': 'Vany',\n", + " 'percentage': 85,\n", + " 'roll_no': 'CSE100',\n", + " 'last_name': 'Unicorn',\n", + " 'pincode': 345467}" + ] + }, + "execution_count": 106, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# print student_data_dictionary\n", + "student_data_dictionary" + ] + }, + { + "cell_type": "code", + "execution_count": 107, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T10:05:55.922063Z", + "iopub.status.busy": "2021-12-13T10:05:55.921547Z", + "iopub.status.idle": "2021-12-13T10:05:55.929415Z", + "shell.execute_reply": "2021-12-13T10:05:55.928555Z", + "shell.execute_reply.started": "2021-12-13T10:05:55.922011Z" + }, + "id": "VTT_BZycrP4q", + "outputId": "133a33e5-a4d5-44b0-af54-93927f8e0adc" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'age': 21,\n", + " 'attendance': 74,\n", + " 'city': 'Gurugram',\n", + " 'country': 'India',\n", + " 'name': 'Vany',\n", + " 'percentage': 85,\n", + " 'roll_no': 'CSE100',\n", + " 'last_name': 'Unicorn_777',\n", + " 'pincode': 423423}" + ] + }, + "execution_count": 107, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# update student_data_dictionary by observing output \n", + "student_data_dictionary.update({'last_name': 'Unicorn_777','pincode': 423423})\n", + "# print student_data_dictionary\n", + "student_data_dictionary" + ] + }, + { + "cell_type": "code", + "execution_count": 108, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T10:06:27.959221Z", + "iopub.status.busy": "2021-12-13T10:06:27.958345Z", + "iopub.status.idle": "2021-12-13T10:06:27.965493Z", + "shell.execute_reply": "2021-12-13T10:06:27.964809Z", + "shell.execute_reply.started": "2021-12-13T10:06:27.959177Z" + }, + "id": "6YtALcserP4q", + "outputId": "14eb3cd9-fa81-4148-f669-ed32aef13347" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "dict_keys(['string', 777, 777.77, False])" + ] + }, + "execution_count": 108, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# observe this code\n", + "### dictionary key can be anything string,integer,float,boolean ###\n", + "dict_sample = {\n", + " 'string' : 'string can be used as key',\n", + " 777 : 'interger can be used as key',\n", + " 777.77 : 'float can be used as key',\n", + " False : 'boolean can be used as key'\n", + "}\n", + "\n", + "dict_sample.keys()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "fb2iby4NrP4q" + }, + "source": [ + "Mostly String and Integer are used as key" + ] + }, + { + "cell_type": "code", + "execution_count": 109, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 38 + }, + "execution": { + "iopub.execute_input": "2021-12-13T10:06:55.138726Z", + "iopub.status.busy": "2021-12-13T10:06:55.138268Z", + "iopub.status.idle": "2021-12-13T10:06:55.145072Z", + "shell.execute_reply": "2021-12-13T10:06:55.144269Z", + "shell.execute_reply.started": "2021-12-13T10:06:55.138678Z" + }, + "id": "RKwzFxeyrP4q", + "outputId": "95f47ee5-a20a-4b34-c275-b4037df86adc" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'float can be used as key'" + ] + }, + "execution_count": 109, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dict_sample[777.77]" + ] + }, + { + "cell_type": "code", + "execution_count": 110, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T10:07:55.651142Z", + "iopub.status.busy": "2021-12-13T10:07:55.65068Z", + "iopub.status.idle": "2021-12-13T10:07:55.658826Z", + "shell.execute_reply": "2021-12-13T10:07:55.65794Z", + "shell.execute_reply.started": "2021-12-13T10:07:55.651108Z" + }, + "id": "l532yInzrP4q", + "outputId": "df174d22-43d7-42bf-ba7b-9516e3f1eca7" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'a': 23, 'b': 2, 'c': 3}" + ] + }, + "execution_count": 110, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# observe this code\n", + "### Duplicate keys ###\n", + "# every key must be unique\n", + "dict_sample = {\n", + " 'a':1,\n", + " 'b':2,\n", + " 'c':3,\n", + " 'a':23\n", + "}\n", + "\n", + "dict_sample" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "xI9wusR1rP4q" + }, + "source": [ + "`If we add duplicate keys, it will not throw an error instead it will overwrite value which is added at last`" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bmvif_zLrP4q" + }, + "source": [ + "# Iterating through key:value pair" + ] + }, + { + "cell_type": "code", + "execution_count": 111, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T10:09:28.180905Z", + "iopub.status.busy": "2021-12-13T10:09:28.18039Z", + "iopub.status.idle": "2021-12-13T10:09:28.186513Z", + "shell.execute_reply": "2021-12-13T10:09:28.185948Z", + "shell.execute_reply.started": "2021-12-13T10:09:28.180849Z" + }, + "id": "pOOp6yYGrP4q", + "outputId": "c16812a6-eabb-499e-b3f0-cbbdf26d330a" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "dict_items([('a', 23), ('b', 2), ('c', 3)])" + ] + }, + "execution_count": 111, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dict_sample.items()" + ] + }, + { + "cell_type": "code", + "execution_count": 112, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T10:09:14.520808Z", + "iopub.status.busy": "2021-12-13T10:09:14.519994Z", + "iopub.status.idle": "2021-12-13T10:09:14.52646Z", + "shell.execute_reply": "2021-12-13T10:09:14.525536Z", + "shell.execute_reply.started": "2021-12-13T10:09:14.520766Z" + }, + "id": "5UvSJz_3rP4r", + "outputId": "6774b5e2-fa17-45fe-f37c-78f81aedfbfa" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a 23\n", + "b 2\n", + "c 3\n" + ] + } + ], + "source": [ + "for key,value in dict_sample.items():\n", + " print(key,value)" + ] + }, + { + "cell_type": "code", + "execution_count": 113, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 184 + }, + "execution": { + "iopub.execute_input": "2021-12-13T10:09:51.898107Z", + "iopub.status.busy": "2021-12-13T10:09:51.897343Z", + "iopub.status.idle": "2021-12-13T10:09:51.916454Z", + "shell.execute_reply": "2021-12-13T10:09:51.915316Z", + "shell.execute_reply.started": "2021-12-13T10:09:51.898047Z" + }, + "id": "Oml0jnO3rP4r", + "outputId": "b62c9fdc-37d7-4e52-eacc-e2c865b0779d" + }, + "outputs": [ + { + "ename": "ValueError", + "evalue": "not enough values to unpack (expected 2, got 1)", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mfor\u001b[0m \u001b[0mkey\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mvalue\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mdict_sample\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: not enough values to unpack (expected 2, got 1)" + ] + } + ], + "source": [ + "for key,value in dict_sample:\n", + " print(key,value)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ew5FtqDsrP4r" + }, + "source": [ + "# sorting a dictionary based on keys" + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T10:10:06.684854Z", + "iopub.status.busy": "2021-12-13T10:10:06.684311Z", + "iopub.status.idle": "2021-12-13T10:10:06.69042Z", + "shell.execute_reply": "2021-12-13T10:10:06.689667Z", + "shell.execute_reply.started": "2021-12-13T10:10:06.684817Z" + }, + "id": "qwC2NSGYrP4r", + "outputId": "38f660c5-5751-4a96-c98c-307cc7682719" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[('a', 23), ('b', 2), ('c', 3)]" + ] + }, + "execution_count": 114, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sorted(dict_sample.items())" + ] + }, + { + "cell_type": "code", + "execution_count": 115, + "metadata": { + "execution": { + "iopub.execute_input": "2021-12-11T13:32:34.935219Z", + "iopub.status.busy": "2021-12-11T13:32:34.934905Z", + "iopub.status.idle": "2021-12-11T13:32:34.938482Z", + "shell.execute_reply": "2021-12-11T13:32:34.937905Z", + "shell.execute_reply.started": "2021-12-11T13:32:34.935186Z" + }, + "id": "DGpnyumDrP4r" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[('b', 2), ('c', 3), ('a', 23)]\n" + ] + } + ], + "source": [ + "# sorting a dictionary based on values\n", + "# it requires concept of lambda expresiion \n", + "print(sorted(dict_sample.items(), key =lambda kv:(kv[1], kv[0])))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "be3IXjFNrP4r" + }, + "source": [ + "---" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 321 + }, + "execution": { + "iopub.execute_input": "2021-12-15T10:08:37.981597Z", + "iopub.status.busy": "2021-12-15T10:08:37.981257Z", + "iopub.status.idle": "2021-12-15T10:08:38.077039Z", + "shell.execute_reply": "2021-12-15T10:08:38.076464Z", + "shell.execute_reply.started": "2021-12-15T10:08:37.981565Z" + }, + "id": "yZTQjp1grP4r", + "outputId": "77061b72-e4f6-4b7b-e945-5ddab7a06ecf" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 205, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# String Manipulation\n", + "YouTubeVideo('https://www.youtube.com/watch?v=I6UH_prRboE&list=PLsR_0x6BuM-HJZT6Xzj-088N4hN3KsDME&index=9',width=600,height=300)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PMmen0JyrP4r" + }, + "source": [ + "# **`String Manipulation`** [More Resources](https://docs.python.org/3.7/library/stdtypes.html#text-sequence-type-str)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kXsEjLZ03YnR" + }, + "source": [ + "# observe bellow code" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "8J1dpy6rrP4r" + }, + "outputs": [], + "source": [ + "string_ = '' or \"\" or \"\"\" \"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 116, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 38 + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:01:34.238451Z", + "iopub.status.busy": "2021-12-13T11:01:34.238169Z", + "iopub.status.idle": "2021-12-13T11:01:34.244158Z", + "shell.execute_reply": "2021-12-13T11:01:34.243186Z", + "shell.execute_reply.started": "2021-12-13T11:01:34.238418Z" + }, + "id": "P4TiJEQCrP4s", + "outputId": "bae75f24-20d2-4366-8444-4613f8d1a8b5" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'We are creating next generation data science eco-system at CloudyML'" + ] + }, + "execution_count": 116, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# defining a string\n", + "string = \"We are creating next generation data science eco-system at CloudyML\"\n", + "string" + ] + }, + { + "cell_type": "code", + "execution_count": 117, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:01:34.958307Z", + "iopub.status.busy": "2021-12-13T11:01:34.957656Z", + "iopub.status.idle": "2021-12-13T11:01:34.963401Z", + "shell.execute_reply": "2021-12-13T11:01:34.96252Z", + "shell.execute_reply.started": "2021-12-13T11:01:34.958266Z" + }, + "id": "Ujfo-CHZrP4s", + "outputId": "5f2290e3-5b15-440b-f412-61a6dd5dbccb" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "67" + ] + }, + "execution_count": 117, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# length of string including spaces\n", + "len(string)" + ] + }, + { + "cell_type": "code", + "execution_count": 121, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 38 + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:01:42.029037Z", + "iopub.status.busy": "2021-12-13T11:01:42.028477Z", + "iopub.status.idle": "2021-12-13T11:01:42.035886Z", + "shell.execute_reply": "2021-12-13T11:01:42.035025Z", + "shell.execute_reply.started": "2021-12-13T11:01:42.02899Z" + }, + "id": "huRY2kW4rP4s", + "outputId": "ea32d5f3-a346-4215-bf42-717e42861884" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'W'" + ] + }, + "execution_count": 121, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Accessing characters in a string\n", + "string[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 122, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 38 + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:01:54.758166Z", + "iopub.status.busy": "2021-12-13T11:01:54.757886Z", + "iopub.status.idle": "2021-12-13T11:01:54.76332Z", + "shell.execute_reply": "2021-12-13T11:01:54.762662Z", + "shell.execute_reply.started": "2021-12-13T11:01:54.758136Z" + }, + "id": "ynPqdSYdrP4s", + "outputId": "11749250-e549-4b7f-b1c2-0c99b592e87d" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'L'" + ] + }, + "execution_count": 122, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Accessing characters with negative indexing\n", + "string[-1]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "O9VaefTGrP4s" + }, + "source": [ + "# String Slicing" + ] + }, + { + "cell_type": "code", + "execution_count": 119, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 38 + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:02:05.078251Z", + "iopub.status.busy": "2021-12-13T11:02:05.077467Z", + "iopub.status.idle": "2021-12-13T11:02:05.08393Z", + "shell.execute_reply": "2021-12-13T11:02:05.083137Z", + "shell.execute_reply.started": "2021-12-13T11:02:05.078214Z" + }, + "id": "ry8spVYHrP4s", + "outputId": "02cd607c-eeb6-4add-fac5-4b9ffcfb5f65" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'We are'" + ] + }, + "execution_count": 119, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "string[:6]" + ] + }, + { + "cell_type": "code", + "execution_count": 120, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 38 + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:02:17.092026Z", + "iopub.status.busy": "2021-12-13T11:02:17.091514Z", + "iopub.status.idle": "2021-12-13T11:02:17.098478Z", + "shell.execute_reply": "2021-12-13T11:02:17.097041Z", + "shell.execute_reply.started": "2021-12-13T11:02:17.091993Z" + }, + "id": "9yyS6grLrP4s", + "outputId": "6f90465e-e6b4-4d86-e6bf-a7ffbe2f515c" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'creating next generation data science eco-system a'" + ] + }, + "execution_count": 120, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "string[7:-10]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "IE-m76lwrP4s" + }, + "source": [ + "# Count of a particular `character` in a string" + ] + }, + { + "cell_type": "code", + "execution_count": 123, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:02:32.813513Z", + "iopub.status.busy": "2021-12-13T11:02:32.813226Z", + "iopub.status.idle": "2021-12-13T11:02:32.820308Z", + "shell.execute_reply": "2021-12-13T11:02:32.819443Z", + "shell.execute_reply.started": "2021-12-13T11:02:32.813481Z" + }, + "id": "036-jd2TrP4s", + "outputId": "87deaa1f-d531-4a3c-924f-d6c520bda3fb" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "We are creating next generation data science eco-system at CloudyML\n" + ] + }, + { + "data": { + "text/plain": [ + "10" + ] + }, + "execution_count": 123, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(string)\n", + "\n", + "string.count('e')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "6BhlvAFmrP4s" + }, + "source": [ + "# Count of a particular `sub-string` in a string " + ] + }, + { + "cell_type": "code", + "execution_count": 124, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:02:46.68983Z", + "iopub.status.busy": "2021-12-13T11:02:46.689548Z", + "iopub.status.idle": "2021-12-13T11:02:46.696782Z", + "shell.execute_reply": "2021-12-13T11:02:46.69582Z", + "shell.execute_reply.started": "2021-12-13T11:02:46.6898Z" + }, + "id": "pzaxuLCarP4s", + "outputId": "ac1e0ef0-348c-4787-9dc5-1b8bf6ba6bac" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "creating next generation data science eco-system a\n" + ] + }, + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 124, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(string[7:-10])\n", + "string.count('ea')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gbyWCeAwrP4s" + }, + "source": [ + "# Find a substring in string using `find` and `index` function" + ] + }, + { + "cell_type": "code", + "execution_count": 125, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 38 + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:03:20.049531Z", + "iopub.status.busy": "2021-12-13T11:03:20.048474Z", + "iopub.status.idle": "2021-12-13T11:03:20.055836Z", + "shell.execute_reply": "2021-12-13T11:03:20.055006Z", + "shell.execute_reply.started": "2021-12-13T11:03:20.049443Z" + }, + "id": "08PNFmYPrP4s", + "outputId": "86004d09-b596-4887-f6cd-77b3a8a894e2" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'We are creating next generation data science eco-system at CloudyML'" + ] + }, + "execution_count": 125, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "string" + ] + }, + { + "cell_type": "code", + "execution_count": 126, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:03:44.010815Z", + "iopub.status.busy": "2021-12-13T11:03:44.010507Z", + "iopub.status.idle": "2021-12-13T11:03:44.017299Z", + "shell.execute_reply": "2021-12-13T11:03:44.016185Z", + "shell.execute_reply.started": "2021-12-13T11:03:44.010781Z" + }, + "id": "tfFcaCXxrP4t", + "outputId": "d9ca9ec0-fc58-4a22-d3ef-59323a72349a" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "-1" + ] + }, + "execution_count": 126, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# .find() => if present it will return starting index, not found then it will return -1\n", + "# .index() => if present it will return starting index, not found then it will give error\n", + "\n", + "\n", + "string.find('eaq') " + ] + }, + { + "cell_type": "code", + "execution_count": 127, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 166 + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:03:59.412482Z", + "iopub.status.busy": "2021-12-13T11:03:59.411717Z", + "iopub.status.idle": "2021-12-13T11:03:59.428379Z", + "shell.execute_reply": "2021-12-13T11:03:59.427526Z", + "shell.execute_reply.started": "2021-12-13T11:03:59.412439Z" + }, + "id": "tZd5IH_DrP4t", + "outputId": "c7c1a03f-95ef-4a5e-accb-8eb8378d1286" + }, + "outputs": [ + { + "ename": "ValueError", + "evalue": "substring not found", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mstring\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'eaq'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mValueError\u001b[0m: substring not found" + ] + } + ], + "source": [ + "string.index('eaq')" + ] + }, + { + "cell_type": "code", + "execution_count": 128, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 38 + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:04:25.2175Z", + "iopub.status.busy": "2021-12-13T11:04:25.216906Z", + "iopub.status.idle": "2021-12-13T11:04:25.223138Z", + "shell.execute_reply": "2021-12-13T11:04:25.222063Z", + "shell.execute_reply.started": "2021-12-13T11:04:25.217463Z" + }, + "id": "foaVXpRQrP4t", + "outputId": "81d94317-3d8b-468e-c32b-6d996c70a8fe" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'We are creating next generation data science eco-system at CloudyML'" + ] + }, + "execution_count": 128, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "string" + ] + }, + { + "cell_type": "code", + "execution_count": 129, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:04:48.605999Z", + "iopub.status.busy": "2021-12-13T11:04:48.605575Z", + "iopub.status.idle": "2021-12-13T11:04:48.611854Z", + "shell.execute_reply": "2021-12-13T11:04:48.611143Z", + "shell.execute_reply.started": "2021-12-13T11:04:48.605962Z" + }, + "id": "QK6TfpWyrP4t", + "outputId": "d4d21a10-c677-425a-e880-95126ef89695" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 129, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "### Checking whether string `startswith` or `endswith` a particular substring or not ###\n", + "string.endswith('CloudyML')" + ] + }, + { + "cell_type": "code", + "execution_count": 130, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:05:06.532097Z", + "iopub.status.busy": "2021-12-13T11:05:06.531667Z", + "iopub.status.idle": "2021-12-13T11:05:06.53704Z", + "shell.execute_reply": "2021-12-13T11:05:06.536136Z", + "shell.execute_reply.started": "2021-12-13T11:05:06.532065Z" + }, + "id": "KEUqKWYqrP4t", + "outputId": "77bf32e4-0c32-4bd2-b01c-e1995ff51a11" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 130, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "string.startswith('We')" + ] + }, + { + "cell_type": "code", + "execution_count": 131, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 38 + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:05:27.880521Z", + "iopub.status.busy": "2021-12-13T11:05:27.880252Z", + "iopub.status.idle": "2021-12-13T11:05:27.88631Z", + "shell.execute_reply": "2021-12-13T11:05:27.885395Z", + "shell.execute_reply.started": "2021-12-13T11:05:27.880493Z" + }, + "id": "Rh26zLoUrP4t", + "outputId": "12b16f82-cd6e-4a52-fb7b-7d38fd4f958f" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'We are creating next generation data science eco-system at CloudyML'" + ] + }, + "execution_count": 131, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "string" + ] + }, + { + "cell_type": "code", + "execution_count": 132, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 38 + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:05:29.695055Z", + "iopub.status.busy": "2021-12-13T11:05:29.694529Z", + "iopub.status.idle": "2021-12-13T11:05:29.700213Z", + "shell.execute_reply": "2021-12-13T11:05:29.699432Z", + "shell.execute_reply.started": "2021-12-13T11:05:29.695023Z" + }, + "id": "LpEf2Vi_rP4t", + "outputId": "885d6b8b-acc3-4b51-ea88-9244f2885a2e" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'WE ARE CREATING NEXT GENERATION DATA SCIENCE ECO-SYSTEM AT CLOUDYML'" + ] + }, + "execution_count": 132, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "### Converting string to upper case ###\n", + "string.upper()" + ] + }, + { + "cell_type": "code", + "execution_count": 133, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 38 + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:05:43.600499Z", + "iopub.status.busy": "2021-12-13T11:05:43.599994Z", + "iopub.status.idle": "2021-12-13T11:05:43.605902Z", + "shell.execute_reply": "2021-12-13T11:05:43.604859Z", + "shell.execute_reply.started": "2021-12-13T11:05:43.600462Z" + }, + "id": "C-lc1BM5rP4t", + "outputId": "9bab07c7-6456-4d62-b004-ba3ddc6df27d" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'We are creating next generation data science eco-system at cloudyml'" + ] + }, + "execution_count": 133, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "### Converting only first character of string to upper case ###\n", + "string.capitalize()" + ] + }, + { + "cell_type": "code", + "execution_count": 134, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 38 + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:06:42.096011Z", + "iopub.status.busy": "2021-12-13T11:06:42.095694Z", + "iopub.status.idle": "2021-12-13T11:06:42.101516Z", + "shell.execute_reply": "2021-12-13T11:06:42.100946Z", + "shell.execute_reply.started": "2021-12-13T11:06:42.095976Z" + }, + "id": "nzVmwn0nrP4t", + "outputId": "392854a5-4334-4a29-f221-58bbfbfa9de0" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'We are creating next generation data science eco-system at CloudyML'" + ] + }, + "execution_count": 134, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "string" + ] + }, + { + "cell_type": "code", + "execution_count": 135, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:06:19.800912Z", + "iopub.status.busy": "2021-12-13T11:06:19.800396Z", + "iopub.status.idle": "2021-12-13T11:06:19.806627Z", + "shell.execute_reply": "2021-12-13T11:06:19.805745Z", + "shell.execute_reply.started": "2021-12-13T11:06:19.800858Z" + }, + "id": "eUfso5gHrP4t", + "outputId": "1886034d-ab70-49d6-d45f-6e516d623412" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 135, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "### Checking if string is in lower case or upper case ###\n", + "string.islower()" + ] + }, + { + "cell_type": "code", + "execution_count": 136, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:07:00.135958Z", + "iopub.status.busy": "2021-12-13T11:07:00.135595Z", + "iopub.status.idle": "2021-12-13T11:07:00.141703Z", + "shell.execute_reply": "2021-12-13T11:07:00.140776Z", + "shell.execute_reply.started": "2021-12-13T11:07:00.135922Z" + }, + "id": "oQKoh8lZrP4t", + "outputId": "912353fd-46be-4fef-dfd1-94f97930ff4f" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 136, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "string.isupper()" + ] + }, + { + "cell_type": "code", + "execution_count": 137, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:07:14.639468Z", + "iopub.status.busy": "2021-12-13T11:07:14.639007Z", + "iopub.status.idle": "2021-12-13T11:07:14.645717Z", + "shell.execute_reply": "2021-12-13T11:07:14.644712Z", + "shell.execute_reply.started": "2021-12-13T11:07:14.639422Z" + }, + "id": "4KJ8oYacrP4t", + "outputId": "e4675c2e-e4ce-4e7b-94c4-9b4ae7f6f46b" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 137, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "### Checking if string is digit, alpabetic, alpha-numeric ###\n", + "\"1\".isnumeric()" + ] + }, + { + "cell_type": "code", + "execution_count": 138, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:07:27.40006Z", + "iopub.status.busy": "2021-12-13T11:07:27.399606Z", + "iopub.status.idle": "2021-12-13T11:07:27.406609Z", + "shell.execute_reply": "2021-12-13T11:07:27.405918Z", + "shell.execute_reply.started": "2021-12-13T11:07:27.400026Z" + }, + "id": "MQf-h42zrP4u", + "outputId": "b4df789e-2be7-4ade-bb7f-2803000c3a50" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 138, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"1s\".isnumeric()" + ] + }, + { + "cell_type": "code", + "execution_count": 139, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:07:35.333175Z", + "iopub.status.busy": "2021-12-13T11:07:35.332841Z", + "iopub.status.idle": "2021-12-13T11:07:35.33955Z", + "shell.execute_reply": "2021-12-13T11:07:35.338458Z", + "shell.execute_reply.started": "2021-12-13T11:07:35.333132Z" + }, + "id": "eDfyzQXRrP4u", + "outputId": "0d2e70b6-9759-40b5-d567-ea55e497e29c" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 139, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"name\".isalpha()" + ] + }, + { + "cell_type": "code", + "execution_count": 140, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:07:41.412261Z", + "iopub.status.busy": "2021-12-13T11:07:41.411144Z", + "iopub.status.idle": "2021-12-13T11:07:41.417409Z", + "shell.execute_reply": "2021-12-13T11:07:41.416764Z", + "shell.execute_reply.started": "2021-12-13T11:07:41.412215Z" + }, + "id": "mfQwti3VrP4u", + "outputId": "69f0d860-b638-452a-c0fd-bc94f1b33ae1" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 140, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"name777\".isalpha()" + ] + }, + { + "cell_type": "code", + "execution_count": 141, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:07:53.778573Z", + "iopub.status.busy": "2021-12-13T11:07:53.77645Z", + "iopub.status.idle": "2021-12-13T11:07:53.785577Z", + "shell.execute_reply": "2021-12-13T11:07:53.784799Z", + "shell.execute_reply.started": "2021-12-13T11:07:53.77853Z" + }, + "id": "ib584RVBrP4u", + "outputId": "06a58277-03a1-40fe-a24b-ff1c97ecb811" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 141, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"name777\".isalnum()" + ] + }, + { + "cell_type": "code", + "execution_count": 142, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:08:16.523252Z", + "iopub.status.busy": "2021-12-13T11:08:16.522815Z", + "iopub.status.idle": "2021-12-13T11:08:16.528809Z", + "shell.execute_reply": "2021-12-13T11:08:16.527918Z", + "shell.execute_reply.started": "2021-12-13T11:08:16.523221Z" + }, + "id": "nYARRCJ7rP4u", + "outputId": "6635e05e-1712-4739-d361-5ab9e6c54784" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 142, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "string = 'Cloudy ML'\n", + "string.isalpha()" + ] + }, + { + "cell_type": "code", + "execution_count": 143, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:08:23.657281Z", + "iopub.status.busy": "2021-12-13T11:08:23.656846Z", + "iopub.status.idle": "2021-12-13T11:08:23.662296Z", + "shell.execute_reply": "2021-12-13T11:08:23.661419Z", + "shell.execute_reply.started": "2021-12-13T11:08:23.657249Z" + }, + "id": "YsjZDgA8rP4u", + "outputId": "29da6d4b-6cf4-4093-9539-3db3469a5bd4" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 143, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "string = 'CloudyML'\n", + "string.isalpha()" + ] + }, + { + "cell_type": "code", + "execution_count": 144, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 38 + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:08:59.303427Z", + "iopub.status.busy": "2021-12-13T11:08:59.302982Z", + "iopub.status.idle": "2021-12-13T11:08:59.310259Z", + "shell.execute_reply": "2021-12-13T11:08:59.309168Z", + "shell.execute_reply.started": "2021-12-13T11:08:59.303392Z" + }, + "id": "SGBdMJeurP4u", + "outputId": "53684928-4589-4c57-c4d1-8e5a5fdee906" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'C++ is easy to learn'" + ] + }, + "execution_count": 144, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "str_ = \"C++ is easy to learn\"\n", + "str_" + ] + }, + { + "cell_type": "code", + "execution_count": 145, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 38 + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:09:12.005822Z", + "iopub.status.busy": "2021-12-13T11:09:12.005323Z", + "iopub.status.idle": "2021-12-13T11:09:12.012082Z", + "shell.execute_reply": "2021-12-13T11:09:12.011148Z", + "shell.execute_reply.started": "2021-12-13T11:09:12.005782Z" + }, + "id": "o3IMBWfqrP4u", + "outputId": "d8ee05d3-46f4-4ace-ba07-1d373042c797" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'Python is easy to learn'" + ] + }, + "execution_count": 145, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "### Replacing substrings ###\n", + "str_.replace('C++', 'Python')" + ] + }, + { + "cell_type": "code", + "execution_count": 146, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:09:37.127736Z", + "iopub.status.busy": "2021-12-13T11:09:37.127294Z", + "iopub.status.idle": "2021-12-13T11:09:37.133848Z", + "shell.execute_reply": "2021-12-13T11:09:37.133093Z", + "shell.execute_reply.started": "2021-12-13T11:09:37.127695Z" + }, + "id": "himKDrvcrP4u", + "outputId": "16f98642-acfc-4073-d09e-8fbd71125740" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "['Python', 'is', 'easy', 'to', 'learn']" + ] + }, + "execution_count": 146, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "### using Split function ###\n", + "'Python is easy to learn'.split()" + ] + }, + { + "cell_type": "code", + "execution_count": 147, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-13T11:09:45.285163Z", + "iopub.status.busy": "2021-12-13T11:09:45.284668Z", + "iopub.status.idle": "2021-12-13T11:09:45.291474Z", + "shell.execute_reply": "2021-12-13T11:09:45.290548Z", + "shell.execute_reply.started": "2021-12-13T11:09:45.285128Z" + }, + "id": "cCDcaUzHrP4u", + "outputId": "26c9046b-e3f3-41c5-ab4a-051bbf4bf5f5" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "['Python is ', ' to learn']" + ] + }, + "execution_count": 147, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "'Python is easy to learn'.split('easy')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1RMWovf4rP4u" + }, + "source": [ + "


Functions

" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 321 + }, + "execution": { + "iopub.execute_input": "2021-12-15T10:25:33.595715Z", + "iopub.status.busy": "2021-12-15T10:25:33.595436Z", + "iopub.status.idle": "2021-12-15T10:25:33.690963Z", + "shell.execute_reply": "2021-12-15T10:25:33.690082Z", + "shell.execute_reply.started": "2021-12-15T10:25:33.595687Z" + }, + "id": "XRyddGCYrP4u", + "outputId": "35f01650-6687-4dc4-8f62-69b364f0dd56" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 240, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Funntion-1\n", + "YouTubeVideo('https://www.youtube.com/watch?v=cjtAbp-Ux-w&list=PLsR_0x6BuM-HJZT6Xzj-088N4hN3KsDME&index=15',width=600,height=300)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 321 + }, + "execution": { + "iopub.execute_input": "2021-12-15T10:25:53.848738Z", + "iopub.status.busy": "2021-12-15T10:25:53.84842Z", + "iopub.status.idle": "2021-12-15T10:25:53.938206Z", + "shell.execute_reply": "2021-12-15T10:25:53.937387Z", + "shell.execute_reply.started": "2021-12-15T10:25:53.848707Z" + }, + "id": "ScPHLQ7-rP4v", + "outputId": "0d024f2f-be5f-4ba4-b7fe-747ed53044ea" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 241, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Funntion-2\n", + "YouTubeVideo('https://www.youtube.com/watch?v=cjtAbp-Ux-w&list=PLsR_0x6BuM-HJZT6Xzj-088N4hN3KsDME&index=16',width=600,height=300)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7w6F0GNErP4v" + }, + "source": [ + "* `Purpose of functions is to group some particular lines of code that needs to be executed multiple times`\n", + " * keyword `def` introduces a function definition and it must be followed by function name\n", + "* Function is Reusable piece of code\n", + "* We create function to solve specific problem" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 38 + }, + "execution": { + "iopub.execute_input": "2021-12-14T10:18:36.097257Z", + "iopub.status.busy": "2021-12-14T10:18:36.096956Z", + "iopub.status.idle": "2021-12-14T10:18:36.102958Z", + "shell.execute_reply": "2021-12-14T10:18:36.102283Z", + "shell.execute_reply.started": "2021-12-14T10:18:36.097225Z" + }, + "id": "4jqkxfNdrP4z", + "outputId": "a232eae4-3829-4a38-cb4f-bc0e36d3ecf2" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'\\ndef function_name():\\n stetement(s)\\n'" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"\n", + "def function_name():\n", + " stetement(s)\n", + "\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "execution": { + "iopub.execute_input": "2021-12-14T10:41:22.778938Z", + "iopub.status.busy": "2021-12-14T10:41:22.778217Z", + "iopub.status.idle": "2021-12-14T10:41:22.783295Z", + "shell.execute_reply": "2021-12-14T10:41:22.782386Z", + "shell.execute_reply.started": "2021-12-14T10:41:22.778903Z" + }, + "id": "L8OCfOyPrP4z" + }, + "outputs": [], + "source": [ + "# define a function\n", + "def welcome_message(name):\n", + " \"\"\"\n", + " This is to represent docstring, \n", + " optionsl documentation is a good \n", + " programming practice\n", + " \"\"\"\n", + " print(f\"{name} Welcome to Python Funcions!!\")\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-14T10:41:28.898798Z", + "iopub.status.busy": "2021-12-14T10:41:28.89826Z", + "iopub.status.idle": "2021-12-14T10:41:28.902844Z", + "shell.execute_reply": "2021-12-14T10:41:28.902223Z", + "shell.execute_reply.started": "2021-12-14T10:41:28.898763Z" + }, + "id": "asBr2ewErP4z", + "outputId": "b9c9380d-f45e-4d68-8099-a0c72f40f180" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mukesh Welcome to Python Funcions!!\n" + ] + } + ], + "source": [ + "# call a function with Mukesh and input\n", + "welcome_message('Mukesh')" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-14T10:42:10.098566Z", + "iopub.status.busy": "2021-12-14T10:42:10.098273Z", + "iopub.status.idle": "2021-12-14T10:42:10.103854Z", + "shell.execute_reply": "2021-12-14T10:42:10.103098Z", + "shell.execute_reply.started": "2021-12-14T10:42:10.098536Z" + }, + "id": "EaWRKsE6rP4z", + "outputId": "fba1ff87-2ea8-4baa-bb3a-d6d42cbfe1cc" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " This is to represent docstring, \n", + " optionsl documentation is a good \n", + " programming practice\n", + " \n" + ] + } + ], + "source": [ + "#obseve the output\n", + "print(welcome_message.__doc__)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-14T10:43:46.234449Z", + "iopub.status.busy": "2021-12-14T10:43:46.233989Z", + "iopub.status.idle": "2021-12-14T10:43:46.238798Z", + "shell.execute_reply": "2021-12-14T10:43:46.237995Z", + "shell.execute_reply.started": "2021-12-14T10:43:46.234401Z" + }, + "id": "Ht8XXDzfrP4z", + "outputId": "422f09c7-a4e7-4e79-969a-7e0c67c5e725" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)\n", + "\n", + "Prints the values to a stream, or to sys.stdout by default.\n", + "Optional keyword arguments:\n", + "file: a file-like object (stream); defaults to the current sys.stdout.\n", + "sep: string inserted between values, default a space.\n", + "end: string appended after the last value, default a newline.\n", + "flush: whether to forcibly flush the stream.\n" + ] + } + ], + "source": [ + "#obseve the output\n", + "print(print.__doc__)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "YKfp2X2irP4z" + }, + "source": [ + "* `def` Keyword marking start of function\n", + "* `function name` to uniquely identify function\n", + " * `function naming` follows same `rules of writing identifiers`\n", + "* `parameters`(arguments) to pass values to a function => totally optional\n", + "* `()` paranthesis\n", + "* `colon (:)` start of function\n", + "* `documentation string`(docstring) describe's what function does => totally optional\n", + "* `return statement` returns a value from function => totally optional\n", + "* inside colon is `function definition` it should always be present before function call or get an error" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hpC8Bl5arP4z" + }, + "source": [ + "# `Type of Functions`\n", + "|Built-in|User-Defined|Lambda Functions|Recursion Function\n", + "|----|----|---|---|\n", + "|`print()` | `add_two_number(defined by user i.e. you)`|``|``|\n", + "|`range()` | ``|``|``|\n", + "| `append()`|`` |``|``|\n", + "| `extend()`|`` |``|``|" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "execution": { + "iopub.execute_input": "2021-12-14T10:46:10.134296Z", + "iopub.status.busy": "2021-12-14T10:46:10.133283Z", + "iopub.status.idle": "2021-12-14T10:46:10.138594Z", + "shell.execute_reply": "2021-12-14T10:46:10.137987Z", + "shell.execute_reply.started": "2021-12-14T10:46:10.134236Z" + }, + "id": "TbWL-gm-rP4z" + }, + "outputs": [], + "source": [ + "### using print ###\n", + "# function to add two number which are as 3 and 4\n", + "def two_number_addition():\n", + " # in total variable store adition of 3 + 4\n", + " total = 3+4\n", + " # print total variable \n", + " print(total)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "execution": { + "iopub.execute_input": "2021-12-14T10:46:07.389537Z", + "iopub.status.busy": "2021-12-14T10:46:07.38924Z", + "iopub.status.idle": "2021-12-14T10:46:07.394356Z", + "shell.execute_reply": "2021-12-14T10:46:07.393771Z", + "shell.execute_reply.started": "2021-12-14T10:46:07.389508Z" + }, + "id": "4a3G3_cDrP40" + }, + "outputs": [], + "source": [ + "### using return ###\n", + "def two_number_addition_with_return():\n", + " total = 3 + 4\n", + " return (total) #returning value of total\n", + "\n", + "\n", + "# observe output" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-14T10:46:33.509914Z", + "iopub.status.busy": "2021-12-14T10:46:33.509633Z", + "iopub.status.idle": "2021-12-14T10:46:33.515225Z", + "shell.execute_reply": "2021-12-14T10:46:33.514366Z", + "shell.execute_reply.started": "2021-12-14T10:46:33.509886Z" + }, + "id": "hrVwYigOrP40", + "outputId": "420d99cf-0b09-4197-b300-43bf9c7551a4" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "7\n" + ] + } + ], + "source": [ + "print_output = two_number_addition()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "execution": { + "iopub.execute_input": "2021-12-14T10:46:48.459242Z", + "iopub.status.busy": "2021-12-14T10:46:48.458961Z", + "iopub.status.idle": "2021-12-14T10:46:48.463459Z", + "shell.execute_reply": "2021-12-14T10:46:48.462708Z", + "shell.execute_reply.started": "2021-12-14T10:46:48.459212Z" + }, + "id": "1I6kqwXcrP40" + }, + "outputs": [], + "source": [ + "# see this variable cannot store above value as value was not saved\n", + "print_output" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "SHvIgCE6rP40" + }, + "source": [ + "See above variable cannot store above value as return was not used in fucntion, so every calculation is being done inside the function two_number_addition() and if you come out of function thouse value do not exist, to solv this problem we use `return`, after using return we can store output of function for other use in our program" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "execution": { + "iopub.execute_input": "2021-12-14T10:47:38.817507Z", + "iopub.status.busy": "2021-12-14T10:47:38.817248Z", + "iopub.status.idle": "2021-12-14T10:47:38.82225Z", + "shell.execute_reply": "2021-12-14T10:47:38.821109Z", + "shell.execute_reply.started": "2021-12-14T10:47:38.817481Z" + }, + "id": "-fBWnS8-rP40" + }, + "outputs": [], + "source": [ + "return_output = two_number_addition_with_return()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-14T10:47:43.959868Z", + "iopub.status.busy": "2021-12-14T10:47:43.959551Z", + "iopub.status.idle": "2021-12-14T10:47:43.966393Z", + "shell.execute_reply": "2021-12-14T10:47:43.965352Z", + "shell.execute_reply.started": "2021-12-14T10:47:43.959839Z" + }, + "id": "LbZu9vBprP40", + "outputId": "0c5605be-c1de-4729-d138-06f88e793834" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "7" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# as return was used in two_number_addition_with_return() function so we can take out value \n", + "return_output" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "qy_mlgUorP40" + }, + "source": [ + "Here in above code value to funtion is being returned and we are saving that returned value to a variable return_output for maybee any other further use. " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "06kIfiPsrP40" + }, + "source": [ + "# **`Passing Parameters to function`**" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 38 + }, + "execution": { + "iopub.execute_input": "2021-12-11T10:14:43.448529Z", + "iopub.status.busy": "2021-12-11T10:14:43.448272Z", + "iopub.status.idle": "2021-12-11T10:14:43.453987Z", + "shell.execute_reply": "2021-12-11T10:14:43.453125Z", + "shell.execute_reply.started": "2021-12-11T10:14:43.448498Z" + }, + "id": "5AnZuBkLrP40", + "outputId": "1430d666-8e22-41b1-d60b-3a260daaf0b9" + }, + "outputs": [], + "source": [ + "# defining a function\n", + "def welcome_message(name):\n", + " return 'Welcome to Python Funcions!! ' + name\n", + " \n", + "# calling function in python with name Akash\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 38 + }, + "execution": { + "iopub.execute_input": "2021-12-11T10:15:25.291791Z", + "iopub.status.busy": "2021-12-11T10:15:25.291359Z", + "iopub.status.idle": "2021-12-11T10:15:25.297224Z", + "shell.execute_reply": "2021-12-11T10:15:25.296648Z", + "shell.execute_reply.started": "2021-12-11T10:15:25.291745Z" + }, + "id": "QWOG3EOBrP40", + "outputId": "2e2f0810-6e54-4886-d0ae-575ba128c156" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'Welcome to Python Funcions!! Krishna'" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# reusing above function (see it as a login windo of a website)\n", + "welcome_message('Krishna')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "TI0CMNN3rP41" + }, + "source": [ + "# ***`Passing Default Parameter value to function`***
\n", + "Works in case you dont provide any value to the required parameter\n", + "* This is good practice to provide default value to a parameter\n", + " * As it reduces many errors" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 38 + }, + "execution": { + "iopub.execute_input": "2021-12-11T10:18:28.863195Z", + "iopub.status.busy": "2021-12-11T10:18:28.862638Z", + "iopub.status.idle": "2021-12-11T10:18:28.869209Z", + "shell.execute_reply": "2021-12-11T10:18:28.868493Z", + "shell.execute_reply.started": "2021-12-11T10:18:28.863152Z" + }, + "id": "nSw9ggNCrP41", + "outputId": "b169d7cc-12b9-4baf-d844-f56e1891068c" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'Welcome to Python Funcions!! Akash'" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def welcome_message(name='Learner'):\n", + " return 'Welcome to Python Funcions!! ' + name\n", + " \n", + "# calling function in python\n", + "welcome_message('Akash')" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 38 + }, + "execution": { + "iopub.execute_input": "2021-12-11T10:19:14.334172Z", + "iopub.status.busy": "2021-12-11T10:19:14.333861Z", + "iopub.status.idle": "2021-12-11T10:19:14.34035Z", + "shell.execute_reply": "2021-12-11T10:19:14.339723Z", + "shell.execute_reply.started": "2021-12-11T10:19:14.334138Z" + }, + "id": "JPOpKKy5rP41", + "outputId": "53e0ae06-5bad-4782-decb-98f0a6b3018c" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'Welcome to Python Funcions!! Learner'" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# not providing parameter value, now it will take default one i.e. Learner\n", + "welcome_message()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "JzTJaFZirP41" + }, + "source": [ + "# ***`Positional Arguments`*** \n", + "Most arguments are identified by their position in function call\n", + "* Say `print(x,y)` will give different results from `print(y,x)`\n", + "\n", + "What ever sequence is given while defining a function values must be taken in that sequence only\n", + "* Otherwise use argument name **`(keyword arguments)`** to take values\n", + "* We first define `positional argument` and then `keyword arguments`\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "execution": { + "iopub.execute_input": "2021-12-11T10:24:26.570469Z", + "iopub.status.busy": "2021-12-11T10:24:26.570183Z", + "iopub.status.idle": "2021-12-11T10:24:26.574882Z", + "shell.execute_reply": "2021-12-11T10:24:26.574072Z", + "shell.execute_reply.started": "2021-12-11T10:24:26.570434Z" + }, + "id": "LpgDIWcYrP41" + }, + "outputs": [], + "source": [ + "#### Observe every output from here onwords #####\n", + "\n", + "def substraction_function(small_number,large_number):\n", + " difference = large_number - small_number\n", + " return difference" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T10:26:55.88569Z", + "iopub.status.busy": "2021-12-11T10:26:55.88516Z", + "iopub.status.idle": "2021-12-11T10:26:55.890293Z", + "shell.execute_reply": "2021-12-11T10:26:55.889589Z", + "shell.execute_reply.started": "2021-12-11T10:26:55.885652Z" + }, + "id": "AX6Ku1j9rP41", + "outputId": "06533fff-deb9-4d44-b464-7b5969d061af" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "77" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# passing arguments in right order\n", + "substraction_function(7,84)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T10:27:15.453063Z", + "iopub.status.busy": "2021-12-11T10:27:15.452368Z", + "iopub.status.idle": "2021-12-11T10:27:15.458033Z", + "shell.execute_reply": "2021-12-11T10:27:15.457478Z", + "shell.execute_reply.started": "2021-12-11T10:27:15.453022Z" + }, + "id": "9Vzlfk4frP41", + "outputId": "00c56386-15a8-404e-e643-e2aa6e1f2aa8" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "-77" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# passing arguments in wrong order (produces negative result)\n", + "substraction_function(84,7)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T10:27:51.964287Z", + "iopub.status.busy": "2021-12-11T10:27:51.963803Z", + "iopub.status.idle": "2021-12-11T10:27:51.969195Z", + "shell.execute_reply": "2021-12-11T10:27:51.968619Z", + "shell.execute_reply.started": "2021-12-11T10:27:51.964251Z" + }, + "id": "zSWT96GurP41", + "outputId": "a3f76fb0-3f28-416a-dc4a-394e58e18c6d" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "77" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# always pass arguments using there name(keyword arguments) then order does not matter\n", + "substraction_function(large_number=84,small_number=7)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T10:39:36.008176Z", + "iopub.status.busy": "2021-12-11T10:39:36.00778Z", + "iopub.status.idle": "2021-12-11T10:39:36.01423Z", + "shell.execute_reply": "2021-12-11T10:39:36.013192Z", + "shell.execute_reply.started": "2021-12-11T10:39:36.008129Z" + }, + "id": "fkwtjVwGrP41", + "outputId": "b56a9cc8-b9f1-4155-be07-a9e1f6add51c" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "77" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# defining positional argument and then keyword arguments => valid in python\n", + "substraction_function(7,large_number=84)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 131 + }, + "execution": { + "iopub.execute_input": "2021-12-11T10:40:23.885814Z", + "iopub.status.busy": "2021-12-11T10:40:23.884999Z", + "iopub.status.idle": "2021-12-11T10:40:23.891881Z", + "shell.execute_reply": "2021-12-11T10:40:23.890735Z", + "shell.execute_reply.started": "2021-12-11T10:40:23.885757Z" + }, + "id": "Or_Jf_6KrP41", + "outputId": "b96cb9e9-4bfe-4542-e6c1-a8b50a568126" + }, + "outputs": [ + { + "ename": "SyntaxError", + "evalue": "positional argument follows keyword argument (, line 2)", + "output_type": "error", + "traceback": [ + "\u001b[0;36m File \u001b[0;32m\"\"\u001b[0;36m, line \u001b[0;32m2\u001b[0m\n\u001b[0;31m substraction_function(large_number=84,7)\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m positional argument follows keyword argument\n" + ] + } + ], + "source": [ + "# defining keyword arguments and then positional argument => not vaid in python\n", + "substraction_function(large_number=84,7)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Y5UrdLZlrP41" + }, + "source": [ + "# ***`Variable Length Arguments`***\n", + "Used when we need more flexibility while defining functions like we don't know in advance fixed number of arguments\n", + "* Python allows us to make function calls with variable length arguments\n", + "* In argument use an **(*)** astrick sign before argument" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "execution": { + "iopub.execute_input": "2021-12-11T10:54:19.850114Z", + "iopub.status.busy": "2021-12-11T10:54:19.849737Z", + "iopub.status.idle": "2021-12-11T10:54:19.853423Z", + "shell.execute_reply": "2021-12-11T10:54:19.852892Z", + "shell.execute_reply.started": "2021-12-11T10:54:19.850085Z" + }, + "id": "6-Sm8XtorP42" + }, + "outputs": [], + "source": [ + "##### Observe code from here ######\n", + "\n", + "# defining a randome function using (*args)\n", + "def arguments_function(*args): # => used for positional arguments will variable lengths\n", + " for i in args:\n", + " print(i)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T10:54:20.094689Z", + "iopub.status.busy": "2021-12-11T10:54:20.094285Z", + "iopub.status.idle": "2021-12-11T10:54:20.099439Z", + "shell.execute_reply": "2021-12-11T10:54:20.098625Z", + "shell.execute_reply.started": "2021-12-11T10:54:20.094658Z" + }, + "id": "aGg6U4SCrP42", + "outputId": "c2e76a77-6f7b-4c4a-ca72-82a7abe09a6d" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "2\n", + "3\n", + "4\n", + "5\n" + ] + } + ], + "source": [ + "# passing n-number of positional arguments to fucntion as we are using (*args)\n", + "arguments_function(1,2,3,4,5)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "yKxx6-FIrP42" + }, + "source": [ + "* Everything given to function if it is using *args, arguments will be saved as `tuples`" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "execution": { + "iopub.execute_input": "2021-12-11T10:52:56.976171Z", + "iopub.status.busy": "2021-12-11T10:52:56.975291Z", + "iopub.status.idle": "2021-12-11T10:52:56.980446Z", + "shell.execute_reply": "2021-12-11T10:52:56.979797Z", + "shell.execute_reply.started": "2021-12-11T10:52:56.976118Z" + }, + "id": "qE5Zn3ZnrP42" + }, + "outputs": [], + "source": [ + "#### Observe every output from here onwords #####\n", + "# defining a randome function using (**kwargs)\n", + "\n", + "def keyword_arguments_function(**kwargs): # => used for keyword arguments will variable lengths\n", + " for key,value in kwargs.items():\n", + " print(key,value)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T10:54:10.89681Z", + "iopub.status.busy": "2021-12-11T10:54:10.896266Z", + "iopub.status.idle": "2021-12-11T10:54:10.902543Z", + "shell.execute_reply": "2021-12-11T10:54:10.90162Z", + "shell.execute_reply.started": "2021-12-11T10:54:10.896756Z" + }, + "id": "m-EYKFbvrP42", + "outputId": "d5f41f1b-c7f3-45aa-8fab-cc4586a88c1e" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a 1\n", + "b 2\n", + "c 3\n", + "d 4\n", + "e 5\n" + ] + } + ], + "source": [ + "# passing n-number of keyword arguments to fucntion as we are using (*args)\n", + "keyword_arguments_function(a=1,b=2,c=3,d=4,e=5)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ACo85WuXrP42" + }, + "source": [ + "* Everything given to function if it is using *kwargs, arguments will be saved as `dict`" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_NUdf1OsrP42" + }, + "source": [ + "# ***`Scope of Variables`*** means that part of program where we can access particular variable\n", + "* `Local Variable` => variables defined inside a function and can be only accessed from inside of that particular function\n", + "* `Global Variable` => variables defined outside a function and can be accessed throughout program\n", + "\n", + "Let's define a global variable, `\"global_variable\"` outside function\n", + "* We will return its value using a function `\"randome_function\"` and see that we would be able to access its value using that function also" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "execution": { + "iopub.execute_input": "2021-12-11T11:00:38.758741Z", + "iopub.status.busy": "2021-12-11T11:00:38.758474Z", + "iopub.status.idle": "2021-12-11T11:00:38.762182Z", + "shell.execute_reply": "2021-12-11T11:00:38.761618Z", + "shell.execute_reply.started": "2021-12-11T11:00:38.758716Z" + }, + "id": "e0BDQ-ccrP42" + }, + "outputs": [], + "source": [ + "#### Observe every output from here onwords #####\n", + "# defining a global variable\n", + "global_variable = 'variable outside of function'\n", + "\n", + "# defining function\n", + "def random_function():\n", + " # accessing variable which is outside of this function\n", + " return global_variable" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 38 + }, + "execution": { + "iopub.execute_input": "2021-12-11T11:00:58.33357Z", + "iopub.status.busy": "2021-12-11T11:00:58.33313Z", + "iopub.status.idle": "2021-12-11T11:00:58.337597Z", + "shell.execute_reply": "2021-12-11T11:00:58.337038Z", + "shell.execute_reply.started": "2021-12-11T11:00:58.333513Z" + }, + "id": "2hYmUr5BrP42", + "outputId": "409967fa-7156-418e-c19d-4b9eec029fd9" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'variable outside of function'" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "random_function()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "w7AB55isrP42" + }, + "source": [ + "`See we can acess the data of golbal variable from Inside of the Function`\n", + "\n", + "# **`=> Let's see what will happen if we try to change value of global variable from Inside of the Function`**" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "execution": { + "iopub.execute_input": "2021-12-11T11:08:27.657115Z", + "iopub.status.busy": "2021-12-11T11:08:27.656836Z", + "iopub.status.idle": "2021-12-11T11:08:27.661916Z", + "shell.execute_reply": "2021-12-11T11:08:27.661004Z", + "shell.execute_reply.started": "2021-12-11T11:08:27.657086Z" + }, + "id": "1cOFox6FrP43" + }, + "outputs": [], + "source": [ + "#### Observe every output from here onwords #####\n", + "# defining a global variable\n", + "global_variable = 'variable outside of function'\n", + "\n", + "# defining function\n", + "def random_function():\n", + " # changing value of global variable from inside of the function\n", + " global_variable = 'changing variable outside of function from inside of function'\n", + " # accessing variable which is outside of this function\n", + " return global_variable" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T11:32:36.29647Z", + "iopub.status.busy": "2021-12-11T11:32:36.296167Z", + "iopub.status.idle": "2021-12-11T11:32:36.300653Z", + "shell.execute_reply": "2021-12-11T11:32:36.30002Z", + "shell.execute_reply.started": "2021-12-11T11:32:36.29644Z" + }, + "id": "8ScwL6OUrP43", + "outputId": "e26b52e1-1627-493b-b808-64c656e91562" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "changing variable outside of function from inside of function\n", + "variable outside of function\n" + ] + } + ], + "source": [ + "print(random_function())\n", + "print(global_variable)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ePWwQg-ErP43" + }, + "source": [ + "It does not mean that we can change global variable from inside the function but this is somthing different story going on here:\n", + "* function named as random_function()'s, global_variable have limited scope which is only of inside its function, that is why when we print function it returns the local variable value not the changed global variable value \n", + "* variable defined locally is taking precedence over variable defined globally as there name are same\n", + "\n", + "The only shortcomming with local variable is it stayes inside the function, the minute you come out of function you dont get the updated value
\n", + "So in above code we are not abble to change global variable locally, but we have made a new variable which is only working inside of the function.
\n", + "Approach we shoudl follow is given bellow:" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ySj5UsYdrP43" + }, + "source": [ + "# **`Updating value of global variable from inside of any user_defined function using Global Keyword`**
\n", + "`global` keyword tells program that there is no need to make a new variable locally but the variable we are using locally is a global variable, which has benn defined" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "execution": { + "iopub.execute_input": "2021-12-11T11:44:42.576513Z", + "iopub.status.busy": "2021-12-11T11:44:42.576243Z", + "iopub.status.idle": "2021-12-11T11:44:42.58185Z", + "shell.execute_reply": "2021-12-11T11:44:42.580668Z", + "shell.execute_reply.started": "2021-12-11T11:44:42.57648Z" + }, + "id": "mGro89w7rP43" + }, + "outputs": [], + "source": [ + "#### Observe every output from here onwords #####\n", + "# defining a global variable\n", + "global_variable = 'variable outside of function'\n", + "\n", + "# defining function\n", + "def random_function():\n", + " # telling function which variables is/are global\n", + " global global_variable\n", + " # changing value of global variable from inside of the function\n", + " global_variable = 'changing variable outside of function from inside of function'\n", + " # accessing variable which is outside of this function\n", + " return global_variable" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T11:44:50.853721Z", + "iopub.status.busy": "2021-12-11T11:44:50.853448Z", + "iopub.status.idle": "2021-12-11T11:44:50.858786Z", + "shell.execute_reply": "2021-12-11T11:44:50.857754Z", + "shell.execute_reply.started": "2021-12-11T11:44:50.853693Z" + }, + "id": "kE3EOtIfrP43", + "outputId": "858886a5-5952-4abd-9a1b-3393a8b927fb" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "changing variable outside of function from inside of function\n", + "changing variable outside of function from inside of function\n" + ] + } + ], + "source": [ + "print(random_function())\n", + "print(global_variable)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rcFgfqTwrP43" + }, + "source": [ + "


Lambda Expressions

" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "WEq89rm1rP43" + }, + "source": [ + "`Lambda function can have any number of arguments but only one expression, which is evaluated and returned`\n", + "* `Lambda Functions` are syntactically restricted to a single expression\n", + "* More efficient than function when task of function is small\n", + "* Do not use Lambda functions when task is complex\n", + "* It works best when you have to call a function more of times but execution task is simple\n", + "\n", + "`Write a regular function instead of a lambda when function is to be used multiple times`\n", + "* `Key`= Lambda must be used once\n", + "* Lambdas are supposed to be used for just once and thus there is no reason to assign a lambda to a variable.\n", + "* Major reason for avoiding assigning a lambda to a variable is for debugging/maintainability purposes, especially in a production/teamwork environment\n", + "\n", + "\n", + "* Use of function is good choice when assignment of variable is compulsary \n", + "* While debugging if any error accurs it will point out to the function creating error\n", + "* In case of lambda function it will throw `lambda error` and ther can be many lambda in out code which makes is difficult to debug error " + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T12:00:22.685235Z", + "iopub.status.busy": "2021-12-11T12:00:22.684948Z", + "iopub.status.idle": "2021-12-11T12:00:22.690396Z", + "shell.execute_reply": "2021-12-11T12:00:22.689805Z", + "shell.execute_reply.started": "2021-12-11T12:00:22.685204Z" + }, + "id": "VXxZTJZirP43", + "outputId": "1604684d-4380-42ce-c37b-13a05b50b79f" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "101" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# define a function that adds 100 to number that is passed as an argument\n", + "def add_num(num):\n", + " num = num +100\n", + " return num\n", + "\n", + "add_num(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T12:05:30.28859Z", + "iopub.status.busy": "2021-12-11T12:05:30.288288Z", + "iopub.status.idle": "2021-12-11T12:05:30.294691Z", + "shell.execute_reply": "2021-12-11T12:05:30.293705Z", + "shell.execute_reply.started": "2021-12-11T12:05:30.288548Z" + }, + "id": "U5_RDfAirP43", + "outputId": "54808285-18eb-421e-f76d-4246d1962985" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Value of 1: 101\n", + "Value of 22: 122\n" + ] + } + ], + "source": [ + "# lambda function named as increaseBy_100 that adds 100 to number that is passed as an argument\n", + "increaseBy_100 = lambda a: a+100\n", + "# print value for increaseBy_100(1), using f string\n", + "print(f\"Value of 1: {increaseBy_100(1)}\")\n", + "# print value for increaseBy_100(22), using f string\n", + "print(f\"Value of 22: {increaseBy_100(22)}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2nDrVMrorP44" + }, + "source": [ + "# **`Lambda function with two arguments`**" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T12:03:26.870492Z", + "iopub.status.busy": "2021-12-11T12:03:26.870187Z", + "iopub.status.idle": "2021-12-11T12:03:26.876301Z", + "shell.execute_reply": "2021-12-11T12:03:26.8755Z", + "shell.execute_reply.started": "2021-12-11T12:03:26.870463Z" + }, + "id": "3hb3McqDrP44", + "outputId": "96998ef8-d427-463e-ebf0-fbb1682fb1b3" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1\n" + ] + } + ], + "source": [ + "# write a lambda fucntion named as subtract_two_number which can take any two number as input and subtract thouse two number\n", + "subtract_two_number = lambda a,b: a-b\n", + "print(subtract_two_number(2,3))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "i5Q_GCA1rP44" + }, + "source": [ + "# ***`filter() function`*** takes in a function and a list as arguments
\n", + "`It filters out all elements of a sequence, for which function returns True`" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "execution": { + "iopub.execute_input": "2021-12-11T12:16:47.959928Z", + "iopub.status.busy": "2021-12-11T12:16:47.959669Z", + "iopub.status.idle": "2021-12-11T12:16:47.964627Z", + "shell.execute_reply": "2021-12-11T12:16:47.963957Z", + "shell.execute_reply.started": "2021-12-11T12:16:47.959902Z" + }, + "id": "s8waRBHerP44" + }, + "outputs": [], + "source": [ + "#### Observe every output from here onwords #####\n", + "# function to check if given number is even \n", + "def divisible_two(x):\n", + " if x%2 == 0:\n", + " return True #odd \n", + " else:\n", + " return False #not odd\n", + " \n", + "# given list to filter for odd number\n", + "check_list = [4,8,0,11,456,777,999,777]" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T12:16:49.025528Z", + "iopub.status.busy": "2021-12-11T12:16:49.025265Z", + "iopub.status.idle": "2021-12-11T12:16:49.032015Z", + "shell.execute_reply": "2021-12-11T12:16:49.030928Z", + "shell.execute_reply.started": "2021-12-11T12:16:49.025499Z" + }, + "id": "OSf2QniarP44", + "outputId": "0cc05eed-b8b1-49e3-b281-56c074aa2e59" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[4, 8, 0, 456]" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#### Observe every output from here onwords #####\n", + "odd_number_filtered_list = list(filter(divisible_two,check_list))\n", + "odd_number_filtered_list" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T12:16:49.726825Z", + "iopub.status.busy": "2021-12-11T12:16:49.72659Z", + "iopub.status.idle": "2021-12-11T12:16:49.731947Z", + "shell.execute_reply": "2021-12-11T12:16:49.731354Z", + "shell.execute_reply.started": "2021-12-11T12:16:49.7268Z" + }, + "id": "0kta1jnvrP44", + "outputId": "334f4dfb-2980-46a1-dee6-b660095a3388" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[4, 8, 0, 456]" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# writing lambda function for above code (we need not to define function sepratly)\n", + "odd_number_filtered_list_using_lambda = list(filter(lambda x:(x%2==0),check_list))\n", + "odd_number_filtered_list_using_lambda" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "mx2z069urP44" + }, + "source": [ + "How easy lamda can make our task now understand\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Vv_hbB-arP45" + }, + "source": [ + "# ***`map() function`*** takes in a function and a list as argument\n", + "* Function is called with a lambda function and a list\n", + "* A new list is returned which contains all lambda modified items returned by that function for each item" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T12:21:37.036641Z", + "iopub.status.busy": "2021-12-11T12:21:37.036314Z", + "iopub.status.idle": "2021-12-11T12:21:37.043569Z", + "shell.execute_reply": "2021-12-11T12:21:37.042921Z", + "shell.execute_reply.started": "2021-12-11T12:21:37.036606Z" + }, + "id": "pTnlcYcirP45", + "outputId": "a27a85c1-ab8c-4854-f6dd-6ff79c322b1a" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[16, 32, 0, 44, 1824, 3108, 3996, 3108]" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#### Observe every output from here onwords #####\n", + "check_list = [4,8,0,11,456,777,999,777]\n", + "\n", + "#increse every element of check_list by 4\n", + "mapped_check_list = list(map(lambda x:x*4,check_list ))\n", + "mapped_check_list" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T12:23:30.07096Z", + "iopub.status.busy": "2021-12-11T12:23:30.070668Z", + "iopub.status.idle": "2021-12-11T12:23:30.078246Z", + "shell.execute_reply": "2021-12-11T12:23:30.077438Z", + "shell.execute_reply.started": "2021-12-11T12:23:30.07093Z" + }, + "id": "UjkGFcOurP45", + "outputId": "ad861f98-1ea9-4595-b4a2-fe30bd830484" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "['North', 'See', 'King', 'Himalayas', 'East']" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#### Observe every output from here onwords #####\n", + "check_list = ['north','see','king','himalayas','east']\n", + "# capatilize first letter of each word in the original list\n", + "mapped_check_list = list(map(lambda x: x[0].upper()+x[1:],check_list)) \n", + "mapped_check_list" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "DNAZjcndrP45" + }, + "source": [ + "# **`reduce() Function`** takes in a function and a list as argument\n", + "* The function is called with a lambda function and a list\n", + "* A new reduced result is returned\n", + "* This performs a repetitive operation over pairs of list\n", + "\n", + "`Reduce Function will always take two parameters`" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T12:26:20.942969Z", + "iopub.status.busy": "2021-12-11T12:26:20.94267Z", + "iopub.status.idle": "2021-12-11T12:26:20.949205Z", + "shell.execute_reply": "2021-12-11T12:26:20.948607Z", + "shell.execute_reply.started": "2021-12-11T12:26:20.942936Z" + }, + "id": "C2cKnRQRrP45", + "outputId": "73641b21-32c6-44ba-9578-474675361bdb" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "3032" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#### Observe every output from here onwords #####\n", + "#importing reduce using functools\n", + "from functools import reduce\n", + "\n", + "\n", + "check_list = [4,8,0,11,456,777,999,777]\n", + "#using reduce function to find sum of numbers in check_list\n", + "sum_of_list = reduce((lambda x, y : x + y),check_list) \n", + "sum_of_list" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T12:27:05.948578Z", + "iopub.status.busy": "2021-12-11T12:27:05.947988Z", + "iopub.status.idle": "2021-12-11T12:27:05.954115Z", + "shell.execute_reply": "2021-12-11T12:27:05.953544Z", + "shell.execute_reply.started": "2021-12-11T12:27:05.948527Z" + }, + "id": "AxB-1xvYrP45", + "outputId": "58429bd3-e6c7-4b0a-d17a-59165464b6ff" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "999" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#### Observe every output from here onwords #####\n", + "check_list = [4,8,0,11,456,777,999,777]\n", + "#using reduce function to find largest number in check_list\n", + "largest_number = reduce((lambda x, y: x if (x > y) else y ),check_list) \n", + "largest_number" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hZ15dPrLrP45" + }, + "source": [ + "


Comprehensions

" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 321 + }, + "id": "ldOWRpFurP45", + "outputId": "6ddbdb97-d0ab-4279-cf99-564fe9e34ef8" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 283, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Comprehensions\n", + "YouTubeVideo('https://www.youtube.com/watch?v=Cs8wG--s4z4&list=PLsR_0x6BuM-HJZT6Xzj-088N4hN3KsDME&index=17',width=600,height=300)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Q50giP1JSRht" + }, + "source": [ + "## **BELOW CODE IS GIVEN FOR YOU TO OBSERVE HOW COMPREHENSIONS WORK.**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "execution": { + "iopub.execute_input": "2021-12-11T12:40:13.51405Z", + "iopub.status.busy": "2021-12-11T12:40:13.513306Z", + "iopub.status.idle": "2021-12-11T12:40:13.516965Z", + "shell.execute_reply": "2021-12-11T12:40:13.516398Z", + "shell.execute_reply.started": "2021-12-11T12:40:13.51401Z" + }, + "id": "kPw6N8X_rP45" + }, + "source": [ + "# **`Type of Comprehensions`**:\n", + "1. `List Comprehension`\n", + "2. `Set Comprehension` \n", + "3. `Dict Comprehension`" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BmN5iDJyrP45" + }, + "source": [ + "# 1. List Comprehension\n", + "`Syntex:`\n", + "\n", + "**[expression for item in iterable]**\n", + "\n", + "\n", + "**Expanded Form**
\n", + "for item in iterable:
\n", + "....expression" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "DF7cNPLerP45" + }, + "source": [ + "**`Converet all element of below tuple in upper case and change datatype into list`**" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T12:44:52.832229Z", + "iopub.status.busy": "2021-12-11T12:44:52.831783Z", + "iopub.status.idle": "2021-12-11T12:44:52.839423Z", + "shell.execute_reply": "2021-12-11T12:44:52.838508Z", + "shell.execute_reply.started": "2021-12-11T12:44:52.832175Z" + }, + "id": "v9pd74p_rP45", + "outputId": "ee16b512-60fa-42ea-8f99-4b5ae9a43486" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "tuple" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "animals = ('bird', 'snake', 'dog', 'turtle', 'cat', 'hamster')\n", + "type(animals)" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T12:46:10.788709Z", + "iopub.status.busy": "2021-12-11T12:46:10.788116Z", + "iopub.status.idle": "2021-12-11T12:46:10.795836Z", + "shell.execute_reply": "2021-12-11T12:46:10.794758Z", + "shell.execute_reply.started": "2021-12-11T12:46:10.788656Z" + }, + "id": "_8Vxa7vbrP46", + "outputId": "5d3aa9e5-b014-4953-fd68-11a00457c69a" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "['BIRD', 'SNAKE', 'DOG', 'TURTLE', 'CAT', 'HAMSTER']" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# good => way using list comprehension\n", + "\n", + "[x.upper()for x in animals]" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T12:47:45.247201Z", + "iopub.status.busy": "2021-12-11T12:47:45.24633Z", + "iopub.status.idle": "2021-12-11T12:47:45.255041Z", + "shell.execute_reply": "2021-12-11T12:47:45.254315Z", + "shell.execute_reply.started": "2021-12-11T12:47:45.247159Z" + }, + "id": "cWkErTE-rP46", + "outputId": "059d67a6-d79f-4444-9ce1-5259acbdfdad" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "['BIRD', 'SNAKE', 'DOG', 'TURTLE', 'CAT', 'HAMSTER']" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Not Good way => using list comprehension\n", + "animalss = []\n", + "for x in animals:\n", + " animalss.append(x.upper())\n", + "animalss" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "qODAY6rvrP46" + }, + "source": [ + "# List Comprehension for Conditional statement or For Filtering\n", + "\n", + "`Syntex:`\n", + "\n", + "**[expression `for` item in iterable `if` some_condition]**\n", + "\n", + "`Expended Form:`\n", + "\n", + "`for` item in iterable:\n", + "
___ `if` some_condition:\n", + "
________ expression " + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": { + "execution": { + "iopub.execute_input": "2021-12-11T12:49:28.837034Z", + "iopub.status.busy": "2021-12-11T12:49:28.836631Z", + "iopub.status.idle": "2021-12-11T12:49:28.841127Z", + "shell.execute_reply": "2021-12-11T12:49:28.840118Z", + "shell.execute_reply.started": "2021-12-11T12:49:28.837003Z" + }, + "id": "aiz3zeKzrP46" + }, + "outputs": [], + "source": [ + "#find the prime number and square them\n", + "\n", + "primes = [2,3,4,5,6,8,7,9]" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T12:49:34.511914Z", + "iopub.status.busy": "2021-12-11T12:49:34.511204Z", + "iopub.status.idle": "2021-12-11T12:49:34.520236Z", + "shell.execute_reply": "2021-12-11T12:49:34.518769Z", + "shell.execute_reply.started": "2021-12-11T12:49:34.511869Z" + }, + "id": "wzASeS9erP46", + "outputId": "b05efac0-4191-4124-e90b-d0f09c54a892" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[4, 16, 36, 64]" + ] + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# good\n", + "[x*x for x in primes if x%2 == 0]" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T12:49:59.636937Z", + "iopub.status.busy": "2021-12-11T12:49:59.636651Z", + "iopub.status.idle": "2021-12-11T12:49:59.643965Z", + "shell.execute_reply": "2021-12-11T12:49:59.642794Z", + "shell.execute_reply.started": "2021-12-11T12:49:59.636901Z" + }, + "id": "3j3aW1LLrP46", + "outputId": "b6d9b65c-0637-4154-ec93-8d0d0a73300a" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[4, 16, 36, 64]" + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# not good\n", + "ls = []\n", + "for x in primes:\n", + " if x % 2 == 0:\n", + " ls.append(x*x)\n", + "ls" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "W9XTKbOyrP46" + }, + "source": [ + "**`For more complex conditions we can use function along with`**" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": { + "execution": { + "iopub.execute_input": "2021-12-11T12:52:17.507335Z", + "iopub.status.busy": "2021-12-11T12:52:17.506505Z", + "iopub.status.idle": "2021-12-11T12:52:17.513214Z", + "shell.execute_reply": "2021-12-11T12:52:17.512673Z", + "shell.execute_reply.started": "2021-12-11T12:52:17.507296Z" + }, + "id": "XKdSFtStrP46" + }, + "outputs": [], + "source": [ + "#find from below given animal which have 4 leags \n", + "\n", + "animals = ('bird','snake','dog','turtle','cat','hamster')" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T12:53:07.832355Z", + "iopub.status.busy": "2021-12-11T12:53:07.831737Z", + "iopub.status.idle": "2021-12-11T12:53:07.838511Z", + "shell.execute_reply": "2021-12-11T12:53:07.837769Z", + "shell.execute_reply.started": "2021-12-11T12:53:07.832313Z" + }, + "id": "s-A0LhR4rP46", + "outputId": "484c0748-56b9-4ff0-8a25-43f40a712084" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "['dog', 'turtle', 'cat']" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# good\n", + "def has_4_legs(animal):\n", + " return animal in ('dog','turtle','cat')\n", + "\n", + "[x for x in animals if has_4_legs(x)]" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T12:52:40.234732Z", + "iopub.status.busy": "2021-12-11T12:52:40.234165Z", + "iopub.status.idle": "2021-12-11T12:52:40.241024Z", + "shell.execute_reply": "2021-12-11T12:52:40.240303Z", + "shell.execute_reply.started": "2021-12-11T12:52:40.234691Z" + }, + "id": "Rvku5z7XrP46", + "outputId": "da12e58b-e598-4d9c-d965-75992d64b29c" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "['dog', 'turtle', 'cat']" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# not good\n", + "l = []\n", + "for x in animals:\n", + " if has_4_legs(x):\n", + " l.append(x)\n", + "l" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "VcEa0wckrP47" + }, + "source": [ + "# 2. Set Comprehension\n", + "* Set have unique element\n", + "* Only use curly bracket then that of square bracket\n", + "\n", + "`Syntax:`\n", + "\n", + "**{expression `for` item in iterable}**" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T12:54:59.598315Z", + "iopub.status.busy": "2021-12-11T12:54:59.597912Z", + "iopub.status.idle": "2021-12-11T12:54:59.605267Z", + "shell.execute_reply": "2021-12-11T12:54:59.604646Z", + "shell.execute_reply.started": "2021-12-11T12:54:59.598279Z" + }, + "id": "ZbjZrX_mrP47", + "outputId": "bf303442-956e-49ce-a362-6ed8dc60a766" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{8, 10, 12, 34, 70, 90}" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# find odds\n", + "numbers_set = (1, 34, 5, 8, 10, 12, 3, 90, 70, 70, 90)\n", + "\n", + "unique_even_numbers = {number for number in numbers_set if number%2 == 0}\n", + "unique_even_numbers" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "vGX5yVFwrP47" + }, + "source": [ + "# 3. Dict Comprehension\n", + "`Syntax:`\n", + "\n", + "**{key_expression : value_expression `for` item in iterable}**" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T12:56:55.240073Z", + "iopub.status.busy": "2021-12-11T12:56:55.239796Z", + "iopub.status.idle": "2021-12-11T12:56:55.246199Z", + "shell.execute_reply": "2021-12-11T12:56:55.245205Z", + "shell.execute_reply.started": "2021-12-11T12:56:55.24004Z" + }, + "id": "80TTyMXwrP47", + "outputId": "ed068011-b448-47d9-e1de-0449e1bb34e1" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'python': 6, 'is': 2, 'a': 1, 'big': 3, 'snake': 5}" + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "words = ('python', 'is', 'a', 'big', 'snake')\n", + "\n", + "len_words = {word : len(word) for word in words}\n", + "len_words" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T12:57:09.958085Z", + "iopub.status.busy": "2021-12-11T12:57:09.957799Z", + "iopub.status.idle": "2021-12-11T12:57:09.96422Z", + "shell.execute_reply": "2021-12-11T12:57:09.96331Z", + "shell.execute_reply.started": "2021-12-11T12:57:09.958056Z" + }, + "id": "0zjPld8qrP47", + "outputId": "26960ac5-ece2-4fc3-f43d-f0b8b9813802" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'python': 6}" + ] + }, + "execution_count": 59, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# acessing key which start with p letter\n", + "len_words_p = {word : len(word) for word in words if word.startswith('p')}\n", + "len_words_p" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7bhKjiMBrP47" + }, + "source": [ + "


Enumerate

" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ct5JcFIYrP47" + }, + "source": [ + "Used for efficient looping\n", + "* Use enumerate function when `needed an index` while looping\n", + "* Often used in list comprehensions or for loops and does not spit out tuples itself\n", + "* Enumerate is an `iterator`, this means ``nothing gets stored``\n", + "* Processes only one item at a time\n", + "* This can be useful when you have large datasets/files.\n", + "\n", + "`Syntax:`
\n", + "**enumerate(iterable, start)**\n", + "**
_____start = starting index**\n", + "* `Returns a tuple of type (index,values)`\n", + "\n", + "Whenever you see within your code `range(len(..))` there is a better way to loop than through using an index\n", + "* This is where built-in function `Enumerate` can help" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "dJSxHP0-rP47" + }, + "source": [ + "# Enumerate Working\n", + "* Enumerate built-in function assigns an index to every item in an itterable object\n", + "* This could be a set, list, string anything that can be iterated over" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T13:06:43.886422Z", + "iopub.status.busy": "2021-12-11T13:06:43.886137Z", + "iopub.status.idle": "2021-12-11T13:06:43.891775Z", + "shell.execute_reply": "2021-12-11T13:06:43.890646Z", + "shell.execute_reply.started": "2021-12-11T13:06:43.886391Z" + }, + "id": "5i1oBdIcrP47", + "outputId": "30b60448-ece6-49cd-b8e9-927b98599f2e" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "colors = ['red','green','blue','purple']\n", + "print(enumerate(colors))" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T13:07:21.237003Z", + "iopub.status.busy": "2021-12-11T13:07:21.236285Z", + "iopub.status.idle": "2021-12-11T13:07:21.242931Z", + "shell.execute_reply": "2021-12-11T13:07:21.241939Z", + "shell.execute_reply.started": "2021-12-11T13:07:21.236946Z" + }, + "id": "WGutH8TCrP47", + "outputId": "466cda40-7df4-4a90-a8fe-f372d9170aca" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 red\n", + "1 green\n", + "2 blue\n", + "3 purple\n" + ] + } + ], + "source": [ + "#enumerate gives us index which starts from 0\n", + "for index,start in enumerate(colors):\n", + " print(index,start)" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T13:07:59.98795Z", + "iopub.status.busy": "2021-12-11T13:07:59.98731Z", + "iopub.status.idle": "2021-12-11T13:07:59.993868Z", + "shell.execute_reply": "2021-12-11T13:07:59.992926Z", + "shell.execute_reply.started": "2021-12-11T13:07:59.987901Z" + }, + "id": "6bdVzFdmrP48", + "outputId": "d2bb6b84-1834-4299-f73a-5f025000ba30" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 red\n", + "2 green\n", + "3 blue\n", + "4 purple\n" + ] + } + ], + "source": [ + "# index starting from 1 maybee\n", + "for index,start in enumerate(colors,start=1):\n", + " print(index,start)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0j32rPMorP48" + }, + "source": [ + "In above code we define variables index and item and they get assigned to first and second items of each tuple \n", + "* This is called `sequence unpacking`\n", + "* We then print index and item of items object" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2021-12-11T13:10:46.872664Z", + "iopub.status.busy": "2021-12-11T13:10:46.872378Z", + "iopub.status.idle": "2021-12-11T13:10:46.877838Z", + "shell.execute_reply": "2021-12-11T13:10:46.877244Z", + "shell.execute_reply.started": "2021-12-11T13:10:46.872632Z" + }, + "id": "JbaxHHKLrP48", + "outputId": "533affe7-b6bb-4c61-9d48-52e6e851b025" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 red\n", + "2 green\n", + "4 purple\n" + ] + } + ], + "source": [ + "# using Enumerate to skip over one index\n", + "for index,start in enumerate(colors,start=1):\n", + " if index == 3: # skipping index 3 \n", + " continue\n", + " print(index,start)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "EDv-UM4CFJN9" + }, + "source": [ + "\n", + "# FeedBack\n", + "We hope you’ve enjoyed this course so far. We’re committed to help you use \"AI for All\" course to its full potential, so that you have a great learning experience. And that’s why we need your help in form of a feedback here.\n", + "\n", + "Please fill this feedback form https://docs.google.com/forms/d/e/1FAIpQLSfjBmH0yJSSA34IhSVx4h2eDMgOAeG4Dk-yHid__NMTk3Hq5g/viewform" + ] + } + ], + "metadata": { + "colab": { + "collapsed_sections": [ + "slh282AprP4M", + "W-7tOm5CrP4P", + "7Mo7XNVNrP4W", + "_jF5-7_PrP4e", + "fI6TbJ9IrP4e", + "kPw6N8X_rP45" + ], + "name": "(Updated)quick_python_withNoCode.ipynb", + "provenance": [] + }, + "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.8" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/Numpy/Numpy Learn.ipynb b/Numpy/Numpy Learn.ipynb new file mode 100644 index 0000000..e926f21 --- /dev/null +++ b/Numpy/Numpy Learn.ipynb @@ -0,0 +1,500 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "93dd0a7e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n" + ] + } + ], + "source": [ + "#import numpy and create 1 D numpy array\n", + "import numpy as np\n", + "oneDArray = np.array([1,2,3,4,5])\n", + "print(oneDArray.ndim)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4cf053cf", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1 2 3]\n", + " [4 5 6]]\n", + "2\n" + ] + } + ], + "source": [ + "# create 2d array\n", + "twoDArray = np.array([[1,2,3],[4,5,6]])\n", + "print(twoDArray)\n", + "#find dimension using ndim\n", + "print(twoDArray.ndim)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "6882e8a8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[ 1 2 3]\n", + " [ 4 5 6]]\n", + "\n", + " [[-1 -2 -3]\n", + " [-4 -5 -6]]]\n", + "3\n" + ] + } + ], + "source": [ + "#create 3d array\n", + "threeDArray = np.array([[[1,2,3],[4,5,6]],[[-1,-2,-3],[-4,-5,-6]]])\n", + "print(threeDArray)\n", + "print(threeDArray.ndim)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "715c32d4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[4 5 6]\n", + "[[-1 -2 -3]\n", + " [-4 -5 -6]]\n" + ] + } + ], + "source": [ + "#index of numpy array\n", + "#if we provide only one index it will find out the whole list in that position for \n", + "#2d and whole array in that position for 3d array\n", + "print(twoDArray[1])\n", + "print(threeDArray[1])" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "c64f8eee", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6\n", + "[-4 -5 -6]\n", + "-6\n" + ] + } + ], + "source": [ + "#if we provide the second index it will find out the specific element in that position for \n", + "#2d and the list in that position for 3d array\n", + "print(twoDArray[1,2])\n", + "print(threeDArray[1,1])\n", + "#to get specific element in that position for 3d array use all 3 index\n", + "print(threeDArray[1,1,2])" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "22710a0e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(2, 3)\n", + "(2, 2, 3)\n" + ] + } + ], + "source": [ + "#find shape of array using shape\n", + "print(twoDArray.shape)\n", + "print(threeDArray.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "86756a43", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "2\n", + "3\n", + "4\n", + "5\n" + ] + } + ], + "source": [ + "#iterate over array\n", + "# if it is 1D array, iterate similar to a list\n", + "for i in oneDArray:\n", + " print(i)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "524819e6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1 2 3]\n", + "1\n", + "2\n", + "3\n", + "[4 5 6]\n", + "4\n", + "5\n", + "6\n" + ] + } + ], + "source": [ + "#if it is 2D array, you require nested loop\n", + "#outer loop is for outer array, inner loop is for inner array, if you iterate only once\n", + "#it will only 1D array element, you need to iterate again over these array elements to get specific\n", + "#elements\n", + "for i in twoDArray:\n", + " print(i)\n", + " for j in i:\n", + " print(j)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "066e0ec0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1 2 3]\n", + " [4 5 6]]\n", + "[1 2 3]\n", + "1\n", + "2\n", + "3\n", + "[4 5 6]\n", + "4\n", + "5\n", + "6\n", + "[[-1 -2 -3]\n", + " [-4 -5 -6]]\n", + "[-1 -2 -3]\n", + "-1\n", + "-2\n", + "-3\n", + "[-4 -5 -6]\n", + "-4\n", + "-5\n", + "-6\n" + ] + } + ], + "source": [ + "# iterating over 3d array is similar to 2D array,iterate only once you will get the 2 D array\n", + "#elements, if you iterate inside that , you will get 1D array elements, you need to iterate\n", + "#once more to get specific elements\n", + "for i in threeDArray:\n", + " print(i)\n", + " for j in i:\n", + " print(j)\n", + " for k in j:\n", + " print(k)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "bd9e13e0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 0. 5. 10. 15. 20.]\n", + "[20. 15. 10. 5. 0.]\n" + ] + } + ], + "source": [ + "#linear spaced vector\n", + "# linspace() can be used to create linear space vector, where 1st argument gives starting \n", + "#element, 2nd arg gives end element and 3rd arg gives step of change . Start and end element \n", + "#gives direction of change whether it will increase or decrease\n", + "#example, start with 0, increment by 5, end by 20\n", + "vector = np.linspace(0,20,5)\n", + "print(vector)\n", + "#example, start with 20, decrease by 5, end by 0\n", + "vector2 = np.linspace(20,0,5)\n", + "print(vector2)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "9fa8879e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0. 0. 0. 0. 0. 0. 0. 0.]\n", + "[0 0 0 0 0 0 0 0]\n", + "[[[0 0]\n", + " [0 0]]\n", + "\n", + " [[0 0]\n", + " [0 0]]]\n" + ] + } + ], + "source": [ + "#reshape\n", + "# you can use reshape() to change linear array to a 3D array\n", + "# numpy allow creating array with element value 0, need to mention number of elements in\n", + "#argument\n", + "zeroLinearArray = np.zeros(8) \n", + "print(zeroLinearArray)\n", + "#you can also mention shape, element type and order in argument\n", + "zeroLinearArray = np.zeros(8, dtype=int, order='C')\n", + "print(zeroLinearArray)\n", + "# based on which type of array you want to reshape into, mention the dimension\n", + "#keep in mind the element and dimension should match, for example here we are creating\n", + "#2 x 2 x 2 array, we need to have 8 elements\n", + "arr3D = zeroLinearArray.reshape((2,2,2))\n", + "print(arr3D)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "d62b21cc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0 0 0 0 0 0 0 0]\n" + ] + } + ], + "source": [ + "#ravel\n", + "# you can use ravel to flatten 3D array to linear array\n", + "arrFlat = arr3D.ravel()\n", + "print(arrFlat)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "564adb02", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19]\n", + "[ 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19]\n", + "[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14]\n" + ] + } + ], + "source": [ + "#slicing\n", + "#if you mention the first index, it will get element from that index upto last\n", + "#if you mention ending index, it will get element from first upto that index\n", + "arr = np.arange(20) # this will create an array from 0 to 20,\n", + "print(arr)\n", + "print(arr[2:]) #print all elements starting from index 2\n", + "print(arr[:15])#print all elements till index less than 15" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "c6ad6755", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1 2 3]\n", + " [3 4 5]\n", + " [4 5 6]]\n", + "[[3 4 5]\n", + " [4 5 6]]\n", + "[2 4 5]\n", + "[3 4 5]\n", + "[[2 3]\n", + " [4 5]\n", + " [5 6]]\n" + ] + } + ], + "source": [ + "# extract specific rows and columns\n", + "arr = np.array([[1,2,3],[3,4,5],[4,5,6]])\n", + "print(arr)\n", + "# slice items starting from index\n", + "print (arr[1:])\n", + "# this returns array of items in the second column \n", + "print (arr[:,1])\n", + "# Now we will slice all items from the second row \n", + "print (arr[1,:]) \n", + "# Now we will slice all items from column 1 onwards \n", + "print (arr[:,1:])" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "b3e08134", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1 2 3]\n", + " [3 4 5]\n", + " [1 4 5]]\n" + ] + } + ], + "source": [ + "#sort\n", + "# use np.sort() to sort array\n", + "arr = np.array([[1,3,2],[4,3,5],[4,5,1]])\n", + "print(np.sort(arr))" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "f736e5c8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1 3 1]\n", + " [4 3 2]\n", + " [4 5 5]]\n", + "[[1 2 3]\n", + " [3 4 5]\n", + " [1 4 5]]\n" + ] + } + ], + "source": [ + "# if you need to sort on axis 0\n", + "arr = np.array([[1,3,2],[4,3,5],[4,5,1]])\n", + "print (np.sort(arr, axis = 0))\n", + "# if you need to sort on axis 1\n", + "arr = np.array([[1,3,2],[4,3,5],[4,5,1]])\n", + "print (np.sort(arr, axis = 1))" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "4eae24a4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[10 11 12 13 14 15 16 17 18]\n", + "[10 11 13 14 16 17 18]\n" + ] + } + ], + "source": [ + "#delete\n", + "arr= np.arange(10,19)\n", + "print (arr)\n", + "#delete array based on index\n", + "arr= np.delete (arr, [2,5])\n", + "print (arr)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ffbb5661", + "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.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/README.md b/README.md index 100493d..07b95f4 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,21 @@ # BeginMachineLearning Machine Learning through Python + +### Install + +This project requires **Python** and the following Python libraries installed: + +- [NumPy](http://www.numpy.org/) +- [Pandas](http://pandas.pydata.org/) +- [matplotlib](http://matplotlib.org/) +- [scikit-learn](http://scikit-learn.org/stable/) + +You will also need to have software installed to run and execute a [Jupyter Notebook](http://jupyter.org/install.html). + +If you do not have Python installed yet, it is highly recommended that you install the [Anaconda](https://www.anaconda.com/download/) distribution of Python, which already has the above packages and more included. + +Module wise exercise files are kept. Just open the ipynb files in your Jupyter notebook + +### +This is my first attempt to create required exercise module to learn all the components. Feel free to contribute. +Create a fork, do the changes, add new files if you feel it is relevant and raise a pull request