diff --git a/001_Python_Functions.ipynb b/001_Python_Functions.ipynb index 3066e9a..c0d783c 100644 --- a/001_Python_Functions.ipynb +++ b/001_Python_Functions.ipynb @@ -5,7 +5,7 @@ "metadata": {}, "source": [ "\n", - "All the IPython Notebooks in this lecture series by Dr. Milan Parmar are available @ **[GitHub](https://github.com/milaan9/04_Python_Functions)**\n", + "All the IPython Notebooks in **Python Functions** lecture series by Dr. Milaan Parmar are available @ **[GitHub](https://github.com/milaan9/04_Python_Functions)**\n", "" ] }, @@ -121,7 +121,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Defining a function without any parameters" + "## Defining a function without any parameters\n", + "\n", + "Function can be declared without parameters." ] }, { @@ -129,8 +131,8 @@ "execution_count": 1, "metadata": { "ExecuteTime": { - "end_time": "2021-06-13T16:00:05.220839Z", - "start_time": "2021-06-13T16:00:05.201310Z" + "end_time": "2021-10-08T17:47:57.838353Z", + "start_time": "2021-10-08T17:47:57.814918Z" }, "scrolled": true }, @@ -139,7 +141,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Welcome to Data Science\n" + "Welcome to Python for Data Science\n" ] } ], @@ -147,47 +149,39 @@ "# Example 1: \n", " \n", "def greet():\n", - " print(\"Welcome to Data Science\")\n", + " print(\"Welcome to Python for Data Science\")\n", "\n", "# call function using its name\n", "greet()" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Defining a function with parameters" - ] - }, { "cell_type": "code", "execution_count": 2, "metadata": { "ExecuteTime": { - "end_time": "2021-06-13T16:00:05.682263Z", - "start_time": "2021-06-13T16:00:05.659804Z" - }, - "scrolled": false + "end_time": "2021-10-08T17:47:57.946753Z", + "start_time": "2021-10-08T17:47:57.840309Z" + } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Hello Arthur Welcome to Data Science\n", - "Your course name is Python\n" + "9\n" ] } ], "source": [ - "# Example 1: \n", - "\n", - "def course(name, course_name):\n", - " print(\"Hello\", name, \"Welcome to Data Science\")\n", - " print(\"Your course name is\", course_name)\n", + "# Example 2: \n", "\n", - "course('Arthur', 'Python') # call function" + "def add_two_numbers ():\n", + " num_one = 3\n", + " num_two = 6\n", + " total = num_one + num_two\n", + " print(total)\n", + "add_two_numbers() # calling a function" ] }, { @@ -195,26 +189,39 @@ "execution_count": 3, "metadata": { "ExecuteTime": { - "end_time": "2021-06-13T16:00:05.898573Z", - "start_time": "2021-06-13T16:00:05.878064Z" - } + "end_time": "2021-10-08T17:47:58.053200Z", + "start_time": "2021-10-08T17:47:57.950659Z" + }, + "scrolled": true }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Milaan Parmar\n" + ] + } + ], "source": [ - "# Example 2: Gereeting\n", + "# Example 3: \n", "\n", - "def greet(name):\n", - " \"\"\"\n", - " This function greets to the person passed in as a parameter\n", - " \"\"\"\n", - " print(\"Hello, \" + name + \". Good morning!\") # No output!" + "def generate_full_name ():\n", + " first_name = 'Milaan'\n", + " last_name = 'Parmar'\n", + " space = ' '\n", + " full_name = first_name + space + last_name\n", + " print(full_name)\n", + "generate_full_name () # calling a function" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Defining a function with parameters and `return` value" + "## Defining a function without parameters and `return` value\n", + "\n", + "Function can also return values, if a function does not have a **`return`** statement, the value of the function is None. Let us rewrite the above functions using **`return`**. From now on, we get a value from a function when we call the function and print it." ] }, { @@ -222,8 +229,8 @@ "execution_count": 4, "metadata": { "ExecuteTime": { - "end_time": "2021-06-13T16:00:06.545535Z", - "start_time": "2021-06-13T16:00:06.531378Z" + "end_time": "2021-10-08T17:47:58.176733Z", + "start_time": "2021-10-08T17:47:58.057106Z" } }, "outputs": [ @@ -231,32 +238,19 @@ "name": "stdout", "output_type": "stream", "text": [ - "Addition : 36\n" + "9\n" ] } ], "source": [ "# Example 1: \n", "\n", - "def calculator(a, b):\n", - " add = a + b \n", - " return add # return the addition\n", - "\n", - "result = calculator(30, 6) # call function & take return value in variable\n", - "print(\"Addition :\", result) # Output Addition : 36" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## How to call a function in python?\n", - "\n", - "Once we have defined a function, we can call it from another function, program or even the Python prompt. To call a function we simply type the function name with appropriate parameters.\n", - "\n", - "
\n", - "\n", - "
" + "def add_two_numbers ():\n", + " num_one = 3\n", + " num_two = 6\n", + " total = num_one + num_two\n", + " return total\n", + "print(add_two_numbers())" ] }, { @@ -264,28 +258,48 @@ "execution_count": 5, "metadata": { "ExecuteTime": { - "end_time": "2021-06-13T16:00:08.206658Z", - "start_time": "2021-06-13T16:00:08.192987Z" - } + "end_time": "2021-10-08T17:47:58.298319Z", + "start_time": "2021-10-08T17:47:58.185523Z" + }, + "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Hello, Alan. Good morning!\n" + "Milaan Parmar\n" ] } ], "source": [ - "greet('Alan')" + "# Example 2: \n", + "\n", + "def generate_full_name ():\n", + " first_name = 'Milaan'\n", + " last_name = 'Parmar'\n", + " space = ' '\n", + " full_name = first_name + space + last_name\n", + " return full_name\n", + "print(generate_full_name())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - ">**Note:** Try running the above code in the Python program with the function definition to see the output." + "## Defining a function with parameters\n", + "\n", + "In a function we can pass different data types(number, string, boolean, list, tuple, dictionary or set) as a parameter." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Single Parameter: \n", + "\n", + "If our function takes a parameter we should call our function with an argument" ] }, { @@ -293,29 +307,19 @@ "execution_count": 6, "metadata": { "ExecuteTime": { - "end_time": "2021-06-13T16:00:09.270122Z", - "start_time": "2021-06-13T16:00:09.248641Z" + "end_time": "2021-10-08T17:47:58.422343Z", + "start_time": "2021-10-08T17:47:58.301246Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Happy birthday, Bill. Hope you have a wonderful day!\n" - ] - } - ], + "outputs": [], "source": [ - "# Example 1: \n", + "# Example 1: Gereeting\n", "\n", - "def wish(name):\n", + "def greet(name):\n", " \"\"\"\n", - " This function wishes to the person passed in as a parameter\n", + " This function greets to the person passed in as a parameter\n", " \"\"\"\n", - " print(\"Happy birthday, \" + name + \". Hope you have a wonderful day!\")\n", - "\n", - "wish('Bill')" + " print(\"Hello, \" + name + \". Good morning!\") # No output!" ] }, { @@ -323,37 +327,42 @@ "execution_count": 7, "metadata": { "ExecuteTime": { - "end_time": "2021-06-13T16:00:09.499124Z", - "start_time": "2021-06-13T16:00:09.479595Z" - } + "end_time": "2021-10-08T17:47:58.545876Z", + "start_time": "2021-10-08T17:47:58.430154Z" + }, + "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "value of x is: 9\n", - "value of y is: 6\n" + "55\n", + "None\n", + "5050\n", + "None\n" ] } ], "source": [ "# Example 2: \n", "\n", - "def swap(x, y):\n", - " \"\"\"\n", - " This function swaps the value of two variables\n", - " \"\"\"\n", - " temp = x; # value of x will go inside temp\n", - " x = y; # value of y will go inside x\n", - " y = temp; # value of temp will go inside y\n", - " print(\"value of x is:\", x)\n", - " print(\"value of y is:\", y)\n", - " return # \"return\" is optional\n", + "def sum_of_numbers(n):\n", + " total = 0\n", + " for i in range(n+1):\n", + " total+=i\n", + " print(total)\n", + "print(sum_of_numbers(10)) # 55\n", + "print(sum_of_numbers(100)) # 5050" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Two Parameter: \n", "\n", - "x = 6\n", - "y = 9\n", - "swap(x, y) #call function" + "A function may or may not have a parameter or parameters. A function may also have two or more parameters. If our function takes parameters we should call it with arguments." ] }, { @@ -361,47 +370,36 @@ "execution_count": 8, "metadata": { "ExecuteTime": { - "end_time": "2021-06-13T16:00:09.683206Z", - "start_time": "2021-06-13T16:00:09.662702Z" - } + "end_time": "2021-10-08T17:47:58.652810Z", + "start_time": "2021-10-08T17:47:58.552712Z" + }, + "scrolled": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "9 is a Odd Number\n" + "Hello Arthur Welcome to Python for Data Science\n", + "Your course name is Python\n" ] } ], "source": [ - "# Example 3: \n", + "# Example 1: \n", "\n", - "def even_odd(n): \n", - " if n % 2 == 0: # check number is even or odd\n", - " print(n, 'is a Even number')\n", - " else:\n", - " print(n, 'is a Odd Number')\n", + "def course(name, course_name):\n", + " print(\"Hello\", name, \"Welcome to Python for Data Science\")\n", + " print(\"Your course name is\", course_name)\n", "\n", - "even_odd(9) # calling function by its name" + "course('Arthur', 'Python') # call function" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "\n", - "## Docstrings\n", - "\n", - "The first string after the function header is called the **docstring** and is short for documentation string. It is a descriptive text (like a comment) written by a programmer to let others know what block of code does.\n", - "\n", - "Although **optional**, documentation is a good programming practice. Unless you can remember what you had for dinner last week, always document your code.\n", - "\n", - "It is being declared using triple single quotes **`''' '''`** or triple-double quote **`\"\"\" \"\"\"`** so that docstring can extend up to multiple lines.\n", - "\n", - "We can access docstring using doc attribute **`__doc__`** for any object like list, tuple, dict, and user-defined function, etc.\n", - "\n", - "In the above example, we have a docstring immediately below the function header." + "## Defining a function with parameters and `return` value" ] }, { @@ -409,66 +407,27 @@ "execution_count": 9, "metadata": { "ExecuteTime": { - "end_time": "2021-06-13T16:00:10.052344Z", - "start_time": "2021-06-13T16:00:10.042580Z" - }, - "scrolled": true + "end_time": "2021-10-08T17:47:58.761206Z", + "start_time": "2021-10-08T17:47:58.657692Z" + } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\n", - " This function greets to the person passed in as a parameter\n", - " \n" + "Milaan, welcome to Python for Data Science\n" ] } ], "source": [ - "print(greet.__doc__)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "To learn more about docstrings in Python, visit **[Python Docstrings](https://github.com/milaan9/04_Python_Functions/blob/main/Python_Docstrings.ipynb)**." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Function `return` Statement\n", - "\n", - "In Python, to return value from the function, a **`return`** statement is used. It returns the value of the expression following the returns keyword.\n", - "\n", - "**Syntax:**\n", - "\n", - "```python\n", - "def fun():\n", - " statement-1\n", - " statement-2\n", - " statement-3\n", - " . \n", - " . \n", - " return [expression]\n", - "```\n", + "# Example 1: \n", "\n", - "The **`return`** value is nothing but a outcome of function.\n", + "def greetings (name): # single parameter\n", + " message = name + ', welcome to Python for Data Science'\n", + " return message\n", "\n", - "* The **`return`** statement ends the function execution.\n", - "* For a function, it is not mandatory to return a value.\n", - "* If a **`return`** statement is used without any expression, then the **`None`** is returned.\n", - "* The **`return`** statement should be inside of the function block." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Return Single Value" + "print(greetings('Milaan'))" ] }, { @@ -476,8 +435,8 @@ "execution_count": 10, "metadata": { "ExecuteTime": { - "end_time": "2021-06-13T16:00:10.975677Z", - "start_time": "2021-06-13T16:00:10.969818Z" + "end_time": "2021-10-08T17:47:58.853005Z", + "start_time": "2021-10-08T17:47:58.764137Z" } }, "outputs": [ @@ -485,20 +444,17 @@ "name": "stdout", "output_type": "stream", "text": [ - "Hello, Cory. Good morning!\n", - "None\n" + "100\n" ] } ], "source": [ - "print(greet(\"Cory\"))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Here, **`None`** is the returned value since **`greet()`** directly prints the name and no **`return`** statement is used." + "# Example 2: \n", + "\n", + "def add_ten(num): # single parameter\n", + " ten = 10\n", + " return num + ten\n", + "print(add_ten(90))" ] }, { @@ -506,8 +462,8 @@ "execution_count": 11, "metadata": { "ExecuteTime": { - "end_time": "2021-06-13T16:00:11.393151Z", - "start_time": "2021-06-13T16:00:11.374603Z" + "end_time": "2021-10-08T17:47:58.976051Z", + "start_time": "2021-10-08T17:47:58.855934Z" } }, "outputs": [ @@ -515,27 +471,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "2\n", - "4\n" + "9\n" ] } ], "source": [ - "# Example 1:\n", - "\n", - "def absolute_value(num):\n", - " \"\"\"This function returns the absolute\n", - " value of the entered number\"\"\"\n", - "\n", - " if num >= 0:\n", - " return num\n", - " else:\n", - " return -num\n", - "\n", - "\n", - "print(absolute_value(2))\n", + "# Example 3: \n", "\n", - "print(absolute_value(-4))" + "def square_number(x): # single parameter\n", + " return x * x\n", + "print(square_number(3))" ] }, { @@ -543,42 +488,27 @@ "execution_count": 12, "metadata": { "ExecuteTime": { - "end_time": "2021-06-13T16:00:12.436114Z", - "start_time": "2021-06-13T16:00:12.426349Z" - }, - "scrolled": true + "end_time": "2021-10-08T17:47:59.084452Z", + "start_time": "2021-10-08T17:47:58.978980Z" + } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Adding the two values\n", - "Printing within Function\n", - "30\n", - "total : 30\n", - "Hello\n", - "Rest of code\n" + "314.0\n" ] } ], "source": [ - "# Example 2:\n", - "\n", - "def sum(a,b): # Function 1\n", - " print(\"Adding the two values\")\n", - " print(\"Printing within Function\")\n", - " print(a+b)\n", - " return a+b\n", - "\n", - "def msg(): # Function 2\n", - " print(\"Hello\")\n", - " return\n", + "# Example 4: \n", "\n", - "total=sum(10,20)\n", - "print('total : ',total)\n", - "msg()\n", - "print(\"Rest of code\")" + "def area_of_circle (r): # single parameter\n", + " PI = 3.14\n", + " area = PI * r ** 2\n", + " return area\n", + "print(area_of_circle(10))" ] }, { @@ -586,8 +516,8 @@ "execution_count": 13, "metadata": { "ExecuteTime": { - "end_time": "2021-06-13T16:00:13.204660Z", - "start_time": "2021-06-13T16:00:13.184155Z" + "end_time": "2021-10-08T17:47:59.192846Z", + "start_time": "2021-10-08T17:47:59.087380Z" } }, "outputs": [ @@ -595,42 +525,582 @@ "name": "stdout", "output_type": "stream", "text": [ - "Even numbers are: [2, 46, 72, 90]\n" + "Addition : 36\n" ] } ], "source": [ - "# Example 3:\n", + "# Example 5: \n", "\n", - "def is_even(list1):\n", - " even_num = []\n", - " for n in list1:\n", - " if n % 2 == 0:\n", - " even_num.append(n)\n", - " # return a list\n", - " return even_num\n", + "def calculator(a, b): # two parameter\n", + " add = a + b \n", + " return add # return the addition\n", + "\n", + "result = calculator(30, 6) # call function & take return value in variable\n", + "print(\"Addition :\", result) # Output Addition : 36" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "ExecuteTime": { + "end_time": "2021-10-08T17:47:59.299295Z", + "start_time": "2021-10-08T17:47:59.199687Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Full Name: Milaan Parmar\n" + ] + } + ], + "source": [ + "# Example 6: \n", + "\n", + "def generate_full_name (first_name, last_name): # two parameter\n", + " space = ' '\n", + " full_name = first_name + space + last_name\n", + " return full_name\n", + "print('Full Name: ', generate_full_name('Milaan','Parmar'))" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "ExecuteTime": { + "end_time": "2021-10-08T17:47:59.422342Z", + "start_time": "2021-10-08T17:47:59.302224Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sum of two numbers: 10\n" + ] + } + ], + "source": [ + "# Example 7: \n", + "\n", + "def sum_two_numbers (num_one, num_two): # two parameter\n", + " sum = num_one + num_two\n", + " return sum\n", + "print('Sum of two numbers: ', sum_two_numbers(1, 9))" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "ExecuteTime": { + "end_time": "2021-10-08T17:47:59.530738Z", + "start_time": "2021-10-08T17:47:59.425271Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Age: 202\n" + ] + } + ], + "source": [ + "# Example 8: \n", + "\n", + "def calculate_age (current_year, birth_year): # two parameter\n", + " age = current_year - birth_year\n", + " return age;\n", + "\n", + "print('Age: ', calculate_age(2021, 1819))" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "ExecuteTime": { + "end_time": "2021-10-08T17:47:59.623513Z", + "start_time": "2021-10-08T17:47:59.533669Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Weight of an object in Newtons: 981.0 N\n" + ] + } + ], + "source": [ + "# Example 9: \n", + "\n", + "def weight_of_object (mass, gravity): # two parameter\n", + " weight = str(mass * gravity)+ ' N' # the value has to be changed to a string first\n", + " return weight\n", + "print('Weight of an object in Newtons: ', weight_of_object(100, 9.81))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Function `return` Statement\n", + "\n", + "In Python, to return value from the function, a **`return`** statement is used. It returns the value of the expression following the returns keyword.\n", + "\n", + "**Syntax:**\n", + "\n", + "```python\n", + "def fun():\n", + " statement-1\n", + " statement-2\n", + " statement-3\n", + " . \n", + " . \n", + " return [expression]\n", + "```\n", + "\n", + "The **`return`** value is nothing but a outcome of function.\n", + "\n", + "* The **`return`** statement ends the function execution.\n", + "* For a function, it is not mandatory to return a value.\n", + "* If a **`return`** statement is used without any expression, then the **`None`** is returned.\n", + "* The **`return`** statement should be inside of the function block." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Return Single Value" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "ExecuteTime": { + "end_time": "2021-10-08T17:47:59.718728Z", + "start_time": "2021-10-08T17:47:59.626442Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello, Cory. Good morning!\n", + "None\n" + ] + } + ], + "source": [ + "print(greet(\"Cory\"))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here, **`None`** is the returned value since **`greet()`** directly prints the name and no **`return`** statement is used." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Passing Arguments with Key and Value\n", + "\n", + "If we pass the arguments with key and value, the order of the arguments does not matter." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "ExecuteTime": { + "end_time": "2021-10-08T17:47:59.854957Z", + "start_time": "2021-10-08T17:47:59.727520Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Milaan Parmar\n", + "None\n" + ] + } + ], + "source": [ + "# Example 1: \n", + "\n", + "def print_fullname(firstname, lastname):\n", + " space = ' '\n", + " full_name = firstname + space + lastname\n", + " print(full_name)\n", + "print(print_fullname(firstname = 'Milaan', lastname = 'Parmar'))" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "ExecuteTime": { + "end_time": "2021-10-08T17:47:59.978006Z", + "start_time": "2021-10-08T17:47:59.860817Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n", + "None\n" + ] + } + ], + "source": [ + "# Example 2:\n", + "\n", + "def add_two_numbers (num1, num2):\n", + " total = num1 + num2\n", + " print(total)\n", + "print(add_two_numbers(num2 = 3, num1 = 2)) # Order does not matter" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If we do not **`return`** a value with a function, then our function is returning **`None`** by default. To return a value with a function we use the keyword **`return`** followed by the variable we are returning. We can return any kind of data types from a function." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "ExecuteTime": { + "end_time": "2021-10-08T17:48:00.178202Z", + "start_time": "2021-10-08T17:47:59.981912Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Milaan Parmar\n" + ] + } + ], + "source": [ + "# Example 1: with return statement\n", + "\n", + "def print_fullname(firstname, lastname):\n", + " space = ' '\n", + " full_name = firstname + space + lastname\n", + " return full_name\n", + "print(print_fullname(firstname = 'Milaan', lastname = 'Parmar'))" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "ExecuteTime": { + "end_time": "2021-10-08T17:48:00.286600Z", + "start_time": "2021-10-08T17:48:00.182107Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n" + ] + } + ], + "source": [ + "# Example 2: with return statement\n", + "\n", + "def add_two_numbers (num1, num2):\n", + " total = num1 + num2\n", + " return total\n", + "print(add_two_numbers(num2 = 3, num1 = 2)) # Order does not matter" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "ExecuteTime": { + "end_time": "2021-10-08T17:48:00.394507Z", + "start_time": "2021-10-08T17:48:00.300275Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n", + "4\n" + ] + } + ], + "source": [ + "# Example 3:\n", + "\n", + "def absolute_value(num):\n", + " \"\"\"This function returns the absolute\n", + " value of the entered number\"\"\"\n", + "\n", + " if num >= 0:\n", + " return num\n", + " else:\n", + " return -num\n", + "\n", + "print(absolute_value(2))\n", + "print(absolute_value(-4))" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "ExecuteTime": { + "end_time": "2021-10-08T17:48:00.529768Z", + "start_time": "2021-10-08T17:48:00.400370Z" + }, + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Adding the two values\n", + "Printing within Function\n", + "30\n", + "total : 30\n", + "Hello\n", + "Rest of code\n" + ] + } + ], + "source": [ + "# Example 4:\n", + "\n", + "def sum(a,b): # Function 1\n", + " print(\"Adding the two values\")\n", + " print(\"Printing within Function\")\n", + " print(a+b)\n", + " return a+b\n", + "\n", + "def msg(): # Function 2\n", + " print(\"Hello\")\n", + " return\n", + "\n", + "total=sum(10,20)\n", + "print('total : ',total)\n", + "msg()\n", + "print(\"Rest of code\")" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "ExecuteTime": { + "end_time": "2021-10-08T17:48:00.672343Z", + "start_time": "2021-10-08T17:48:00.537579Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Even numbers are: [2, 46, 72, 90]\n" + ] + } + ], + "source": [ + "# Example 5:\n", + "\n", + "def is_even(list1):\n", + " even_num = []\n", + " for n in list1:\n", + " if n % 2 == 0:\n", + " even_num.append(n)\n", + " # return a list\n", + " return even_num\n", + "\n", + "# Pass list to the function\n", + "even_num = is_even([2, 3, 46, 63, 72, 83, 90, 19])\n", + "print(\"Even numbers are:\", even_num)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Return Multiple Values\n", + "\n", + "You can also return multiple values from a function. Use the return statement by separating each expression by a comma." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "ExecuteTime": { + "end_time": "2021-10-08T17:48:00.795876Z", + "start_time": "2021-10-08T17:48:00.677226Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Addition: 12\n", + "Subtraction: 8\n", + "Multiplication: 20\n", + "Division: 5.0\n" + ] + } + ], + "source": [ + "# Example 1:\n", + "\n", + "def arithmetic(num1, num2):\n", + " add = num1 + num2\n", + " sub = num1 - num2\n", + " multiply = num1 * num2\n", + " division = num1 / num2\n", + " # return four values\n", + " return add, sub, multiply, division\n", + "\n", + "a, b, c, d = arithmetic(10, 2) # read four return values in four variables\n", + "\n", + "print(\"Addition: \", a)\n", + "print(\"Subtraction: \", b)\n", + "print(\"Multiplication: \", c)\n", + "print(\"Division: \", d)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Return Boolean Values" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "ExecuteTime": { + "end_time": "2021-10-08T17:48:00.903786Z", + "start_time": "2021-10-08T17:48:00.803691Z" + }, + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "even\n", + "True\n", + "False\n" + ] + } + ], + "source": [ + "# Example 1:\n", + "\n", + "def is_even (n):\n", + " if n % 2 == 0:\n", + " print('even')\n", + " return True # return stops further execution of the function, similar to break \n", + " return False\n", + "print(is_even(10)) # True\n", + "print(is_even(7)) # False" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Return a List" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "ExecuteTime": { + "end_time": "2021-10-08T17:48:01.028789Z", + "start_time": "2021-10-08T17:48:00.906718Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0, 2, 4, 6, 8, 10]\n" + ] + } + ], + "source": [ + "# Example 1:\n", "\n", - "# Pass list to the function\n", - "even_num = is_even([2, 3, 46, 63, 72, 83, 90, 19])\n", - "print(\"Even numbers are:\", even_num)" + "def find_even_numbers(n):\n", + " evens = []\n", + " for i in range(n + 1):\n", + " if i % 2 == 0:\n", + " evens.append(i)\n", + " return evens\n", + "print(find_even_numbers(10))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Return Multiple Values\n", + "## How to call a function in python?\n", "\n", - "You can also return multiple values from a function. Use the return statement by separating each expression by a comma." + "Once we have defined a function, we can call it from another function, program or even the Python prompt. To call a function we simply type the function name with appropriate parameters.\n", + "\n", + "
\n", + "\n", + "
" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 29, "metadata": { "ExecuteTime": { - "end_time": "2021-06-13T16:00:14.680235Z", - "start_time": "2021-06-13T16:00:14.656801Z" + "end_time": "2021-10-08T17:48:01.135232Z", + "start_time": "2021-10-08T17:48:01.031717Z" } }, "outputs": [ @@ -638,30 +1108,282 @@ "name": "stdout", "output_type": "stream", "text": [ - "Addition: 12\n", - "Subtraction: 8\n", - "Multiplication: 20\n", - "Division: 5.0\n" + "Hello, Alan. Good morning!\n" ] } ], "source": [ - "# Example 1:\n", + "greet('Alan')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + ">**Note:** Try running the above code in the Python program with the function definition to see the output." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "ExecuteTime": { + "end_time": "2021-10-08T17:48:01.243633Z", + "start_time": "2021-10-08T17:48:01.140118Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Happy birthday, Bill. Hope you have a wonderful day!\n" + ] + } + ], + "source": [ + "# Example 1: \n", "\n", - "def arithmetic(num1, num2):\n", - " add = num1 + num2\n", - " sub = num1 - num2\n", - " multiply = num1 * num2\n", - " division = num1 / num2\n", - " # return four values\n", - " return add, sub, multiply, division\n", + "def wish(name):\n", + " \"\"\"\n", + " This function wishes to the person passed in as a parameter\n", + " \"\"\"\n", + " print(\"Happy birthday, \" + name + \". Hope you have a wonderful day!\")\n", "\n", - "a, b, c, d = arithmetic(10, 2) # read four return values in four variables\n", + "wish('Bill')" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "ExecuteTime": { + "end_time": "2021-10-08T17:48:01.446289Z", + "start_time": "2021-10-08T17:48:01.251445Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Clark, welcome to Python for Data Science\n", + "Milaan, welcome to Python for Data Science\n" + ] + } + ], + "source": [ + "# Example 2: \n", "\n", - "print(\"Addition: \", a)\n", - "print(\"Subtraction: \", b)\n", - "print(\"Multiplication: \", c)\n", - "print(\"Division: \", d)" + "def greetings (name = 'Clark'):\n", + " message = name + ', welcome to Python for Data Science'\n", + " return message\n", + "print(greetings())\n", + "print(greetings('Milaan'))" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "ExecuteTime": { + "end_time": "2021-10-08T17:48:01.699688Z", + "start_time": "2021-10-08T17:48:01.454570Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Milaan Parmar\n", + "Ethan Hunt\n" + ] + } + ], + "source": [ + "# Example 3: \n", + "\n", + "def generate_full_name (first_name = 'Milaan', last_name = 'Parmar'):\n", + " space = ' '\n", + " full_name = first_name + space + last_name\n", + " return full_name\n", + "print(generate_full_name())\n", + "print(generate_full_name('Ethan','Hunt'))" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "ExecuteTime": { + "end_time": "2021-10-08T17:48:01.793476Z", + "start_time": "2021-10-08T17:48:01.702617Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Age: 200\n" + ] + } + ], + "source": [ + "# Example 4: \n", + "\n", + "def calculate_age (birth_year,current_year = 2021):\n", + " age = current_year - birth_year\n", + " return age;\n", + "print('Age: ', calculate_age(1821))" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "ExecuteTime": { + "end_time": "2021-10-08T17:48:01.900373Z", + "start_time": "2021-10-08T17:48:01.797831Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "value of x is: 9\n", + "value of y is: 6\n" + ] + } + ], + "source": [ + "# Example 5: \n", + "\n", + "def swap(x, y):\n", + " \"\"\"\n", + " This function swaps the value of two variables\n", + " \"\"\"\n", + " temp = x; # value of x will go inside temp\n", + " x = y; # value of y will go inside x\n", + " y = temp; # value of temp will go inside y\n", + " print(\"value of x is:\", x)\n", + " print(\"value of y is:\", y)\n", + " return # \"return\" is optional\n", + "\n", + "x = 6\n", + "y = 9\n", + "swap(x, y) #call function" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "ExecuteTime": { + "end_time": "2021-10-08T17:48:02.023908Z", + "start_time": "2021-10-08T17:48:01.903301Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "9 is a Odd Number\n" + ] + } + ], + "source": [ + "# Example 6: \n", + "\n", + "def even_odd(n): \n", + " if n % 2 == 0: # check number is even or odd\n", + " print(n, 'is a Even number')\n", + " else:\n", + " print(n, 'is a Odd Number')\n", + "\n", + "even_odd(9) # calling function by its name" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": { + "ExecuteTime": { + "end_time": "2021-10-08T17:48:02.147933Z", + "start_time": "2021-10-08T17:48:02.026837Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Weight of an object in Newtons: 981.0 N\n", + "Weight of an object in Newtons: 162.0 N\n" + ] + } + ], + "source": [ + "# Example 7: \n", + "\n", + "def weight_of_object (mass, gravity = 9.81):\n", + " weight = str(mass * gravity)+ ' N' # the value has to be changed to string first\n", + " return weight\n", + "print('Weight of an object in Newtons: ', weight_of_object(100)) # 9.81 - average gravity on Earth's surface\n", + "print('Weight of an object in Newtons: ', weight_of_object(100, 1.62)) # gravity on the surface of the Moon" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## Docstrings\n", + "\n", + "The first string after the function header is called the **docstring** and is short for documentation string. It is a descriptive text (like a comment) written by a programmer to let others know what block of code does.\n", + "\n", + "Although **optional**, documentation is a good programming practice. Unless you can remember what you had for dinner last week, always document your code.\n", + "\n", + "It is being declared using triple single quotes **`''' '''`** or triple-double quote **`\"\"\" \"\"\"`** so that docstring can extend up to multiple lines.\n", + "\n", + "We can access docstring using doc attribute **`__doc__`** for any object like list, tuple, dict, and user-defined function, etc.\n", + "\n", + "In the above example, we have a docstring immediately below the function header." + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": { + "ExecuteTime": { + "end_time": "2021-10-08T17:48:02.284654Z", + "start_time": "2021-10-08T17:48:02.154767Z" + }, + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " This function greets to the person passed in as a parameter\n", + " \n" + ] + } + ], + "source": [ + "print(greet.__doc__)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To learn more about docstrings in Python, visit **[Python Docstrings](https://github.com/milaan9/04_Python_Functions/blob/main/Python_Docstrings.ipynb)**." ] }, { @@ -677,11 +1399,11 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 38, "metadata": { "ExecuteTime": { - "end_time": "2021-06-13T16:00:16.710491Z", - "start_time": "2021-06-13T16:00:16.704636Z" + "end_time": "2021-10-08T17:48:02.420395Z", + "start_time": "2021-10-08T17:48:02.294414Z" } }, "outputs": [], @@ -696,6 +1418,86 @@ "addition(10, 2)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 💻 Exercises ➞ Functions\n", + "\n", + "### Exercises ➞ Level 1\n", + "\n", + "1. Area of a circle is calculated as follows: **area = π x r x r** and **perimeter = 2 x π x r**. Write a function that calculates **`area_of_circle`** and **`perimeter_of_circle`**.\n", + "2. Write a function called **`add_all_nums`** which takes arbitrary number of arguments and sums all the arguments. Check if all the list items are number types. If not do give a reasonable feedback.\n", + "3. Temperature in **°C** can be converted to **°F** using this formula: **°F = (°C x 9/5) + 32**. Write a function which converts **°C to °F**, **`convert_celsius_2_fahrenheit`**.\n", + "4. Write a function called **`check_season`**, it takes a month parameter and returns the season: Autumn, Winter, Spring or Summer.\n", + "5. Write a function called **`calculate_slope`** which return the slope of a linear equation\n", + "6. Quadratic equation is calculated as follows: **ax² + bx + c = 0**. Write a function which calculates solution set of a quadratic equation, **`solve_quadratic_eqn`**.\n", + "7. Declare a function named **`print_list`**. It takes a list as a parameter and it prints out each element of the list.\n", + "8. Declare a function named **`reverse_list`**. It takes an array as a parameter and it returns the reverse of the array (use loops).\n", + "\n", + " - ```py\n", + "print(reverse_list([1, 2, 3, 4, 5]))\n", + "#[5, 4, 3, 2, 1]\n", + "print(reverse_list1([\"A\", \"B\", \"C\"]))\n", + "#[\"C\", \"B\", \"A\"]\n", + " ```\n", + "\n", + "9. Declare a function named **`capitalize_list_items`**. It takes a list as a parameter and it returns a capitalized list of items\n", + "10. Declare a function named **`add_item`**. It takes a list and an item parameters. It returns a list with the item added at the end.\n", + "\n", + " - ```py\n", + "food_staff = ['Potato', 'Tomato', 'Mango', 'Milk']\n", + "print(add_item(food_staff, 'Fungi')) #['Potato', 'Tomato', 'Mango', 'Milk', 'Fungi']\n", + "numbers = [2, 3, 7, 9]\n", + "print(add_item(numbers, 5)) #[2, 3, 7, 9, 5]\n", + " ```\n", + "\n", + "11. Declare a function named **`remove_item`**. It takes a list and an item parameters. It returns a list with the item removed from it.\n", + "\n", + " - ```py\n", + "food_staff = ['Potato', 'Tomato', 'Mango', 'Milk']\n", + "print(remove_item(food_staff, 'Mango')) # ['Potato', 'Tomato', 'Milk']\n", + "numbers = [2, 3, 7, 9]\n", + "print(remove_item(numbers, 3)) # [2, 7, 9]\n", + " ```\n", + "\n", + "12. Declare a function named **`sum_of_numbers`**. It takes a number parameter and it adds all the numbers in that range.\n", + "\n", + " - ```py\n", + "print(sum_of_numbers(5)) # 15\n", + "print(sum_all_numbers(10)) # 55\n", + "print(sum_all_numbers(100)) # 5050\n", + " ```\n", + "\n", + "13. Declare a function named **`sum_of_odds`**. It takes a number parameter and it adds all the odd numbers in that range.\n", + "14. Declare a function named **`sum_of_even`**. It takes a number parameter and it adds all the even numbers in that - range.\n", + "\n", + "### Exercises ➞ Level 2\n", + "\n", + "1. Declare a function named **`evens_and_odds`**. It takes a positive integer as parameter and it counts number of evens and odds in the number.\n", + "\n", + " - ```py\n", + " print(evens_and_odds(100))\n", + " #The number of odds are 50.\n", + " #The number of evens are 51.\n", + " ```\n", + "\n", + "2. Call your function **`factorial`**, it takes a whole number as a parameter and it return a factorial of the number\n", + "3. Call your function **`is_empty`**, it takes a parameter and it checks if it is empty or not\n", + "4. Write different functions which take lists. They should **`calculate_mean`**, **`calculate_median`**, **`calculate_mode`**, **`calculate_range`**, **`calculate_variance`**, **`calculate_std`** (standard deviation).\n", + "\n", + "### Exercises ➞ Level 3\n", + "\n", + "1. Write a function called **`is_prime`**, which checks if a number is prime.\n", + "2. Write a functions which checks if all items are unique in the list.\n", + "3. Write a function which checks if all the items of the list are of the same data type.\n", + "4. Write a function which check if provided variable is a valid python variable\n", + "5. Go to the data folder and access the **[countries-data.py](https://github.com/milaan9/03_Python_Flow_Control/blob/main/countries_details_data.py)** file.\n", + "\n", + "- Create a function called the **`most_spoken_languages`** in the world. It should return 10 or 20 most spoken languages in the world in descending order\n", + "- Create a function called the **`most_populated_countries`**. It should return 10 or 20 most populated countries in descending order." + ] + }, { "cell_type": "code", "execution_count": null, diff --git a/002_Python_Function_Global_Local_Nonlocal.ipynb b/002_Python_Function_Global_Local_Nonlocal.ipynb index 619b25e..39bdbfe 100644 --- a/002_Python_Function_Global_Local_Nonlocal.ipynb +++ b/002_Python_Function_Global_Local_Nonlocal.ipynb @@ -5,7 +5,7 @@ "metadata": {}, "source": [ "\n", - "All the IPython Notebooks in this lecture series by Dr. Milan Parmar are available @ **[GitHub](https://github.com/milaan9/04_Python_Functions)**\n", + "All the IPython Notebooks in **Python Functions** lecture series by Dr. Milaan Parmar are available @ **[GitHub](https://github.com/milaan9/04_Python_Functions)**\n", "" ] }, diff --git a/002_Python_Functions_Built_in/002_Seaborn_Controlling_Aesthetics.ipynb b/002_Python_Functions_Built_in/002_Seaborn_Controlling_Aesthetics.ipynb new file mode 100644 index 0000000..a678980 --- /dev/null +++ b/002_Python_Functions_Built_in/002_Seaborn_Controlling_Aesthetics.ipynb @@ -0,0 +1,581 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "All the IPython Notebooks in **[Python Seaborn Module](https://github.com/milaan9/12_Python_Seaborn_Module)** lecture series by **[Dr. Milaan Parmar](https://www.linkedin.com/in/milaanparmar/)** are available @ **[GitHub](https://github.com/milaan9)**\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Controlling Aesthetics of Seaborn Plots" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One of the biggest advantages of Seaborn over Matplotlib is that its default aesthetics are visually far more appealing. Undoubtedly Matplotlib is highly customizable, but sometimes it may get difficult to know exact settings to tweak in order to achieve an attractive plot. Whereas, Seaborn comes with a number of customized themes and a high-level interface for controlling the look of same matplotlib figures.\n", + "\n", + "Seaborn splits Matplotlib parameters into two independent groups: *First* group sets the aesthetic style of the plot; and *second* scales various elements of the figure to get easily incorporated into different contexts." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Seaborn doesn’t take away any of Matplotlib credits, but rather adds some nice default aesthetics and built-in plots that complement and sometimes replace the complicated Matplotlib code professionals needed to write. *Facet plots* and *Regression plots* are an example of that. In this lecture I shall show how easy it is to build a *Regression plot* using Seaborn and then let us compare it by building something similar in Matplotlib." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + ">**Note** (for non-native English speakers): The term *Aesthetics* just refers to the appearance of the figure/plot." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2021-07-16T14:23:04.768850Z", + "start_time": "2021-07-16T14:23:02.634110Z" + } + }, + "outputs": [], + "source": [ + "# Importing intrinsic libraries:\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, once we have imported necessary libraries, let us begin talking about aesthetics with those 2 special lines of code we had added in our previous lecture. Our first line of code was:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "ExecuteTime": { + "end_time": "2021-07-16T14:23:11.678443Z", + "start_time": "2021-07-16T14:23:11.656963Z" + } + }, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**`%matplotlib`** is one of the *magic function* of Jupyter Notebook that along with **`inline`** **[sets the backend of matplotlib](http://ipython.readthedocs.io/en/stable/interactive/plotting.html)** to the *inline* backend within Jupyter notebook. If we look into relevant documentation, it says:\n", + "\n", + "IPython has a set of predefined **‘magic functions’** that you can call with a command line style syntax. There are two kinds of magics: line-oriented and cell-oriented. \n", + "\n", + "1. Line magics are prefixed with the **`%`** character and work much like OS command-line calls: they get as an argument the rest of the line, where arguments are passed without parentheses or quotes. Lines magics can return results and can be used in the right hand side of an assignment. \n", + "\n", + "2. Cell magics are prefixed with a double **`%%`**, and they are functions that get as an argument not only the rest of the line, but also the lines below it in a separate argument.\n", + "\n", + "With this backend, the output of plotting commands is displayed inline within frontends like the Jupyter notebook, directly below the code cell that produced it. The resulting plots will then also be stored in the notebook document.\n", + "\n", + "Furthermore, if we want interactivity as well, we can use **`nbagg`** backend with **`%matplotlib`** notebook (in IPython 3.x). Though we won't be getting into that extremely advanced level of Matplotlib specific presentation here, but if that interest you, please check **[here](https://matplotlib.org/users/whats_new.html#the-nbagg-backend)**.\n", + "\n", + "Let us now move on to our second line of code:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2021-07-16T14:25:25.755122Z", + "start_time": "2021-07-16T14:25:25.737547Z" + } + }, + "outputs": [], + "source": [ + "sns.set()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Seaborn runs on top of Matplotlib and with that as a default comes a *White* background for each of our plot, that looks pretty dull. With this line of code, we switch our plot to Seaborn default using **`.set()`** function. Let us look into what it yields, using one of the built-in dataset:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2021-07-16T14:25:37.203243Z", + "start_time": "2021-07-16T14:25:36.597297Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "tips = sns.load_dataset(\"tips\")\n", + "\n", + "sns.barplot(x = \"day\", y = \"total_bill\", data = tips)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + ">**Note:** **`sns.set()`** needs to be explicitly called ONLY in Seaborn v0.8 and above." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With both the lines of code explained, let us now look into what else can we do to vary appearance of our plot. Earlier we spoke about Seaborn segregating Matplotlib parameters into 2 independent groups: *Styling* and *Scaling* of figures.\n", + "\n", + "Let us begin by delving into *Styling* aspect, that is controlled by using **`sns.axes_style()`** and **`sns.set_style()`** functions." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "ExecuteTime": { + "end_time": "2021-07-16T14:26:06.035458Z", + "start_time": "2021-07-16T14:26:05.676092Z" + }, + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAEJCAYAAACdePCvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAb8klEQVR4nO3dfXAU9eHH8c+RI0EEJRkTQYlMorQ+MChlANMBAuHBA40gQTxniiO1KSgNM6iVQH2oor9EamWgYhkZq606jZACYgavBgJUxIcxKExQRAxJoGiIzQNJkCO53O+PmCup5AjJbvbu9v36Ry7J7X6yE++zu9/d7zr8fr9fAADb6WV1AACANSgAALApCgAAbIoCAACbogAAwKacVgforJaWFjU2Nqp3795yOBxWxwGAsOD3+9XU1KSLL75YvXq13+cPmwJobGzUoUOHrI4BAGHpJz/5ifr379/ua2FTAL1795bU+ktER0dbnAYAwsOZM2d06NChwGfo2cKmANpO+0RHRysmJsbiNAAQXs516pxBYACwKQoAAGyKAgAAm6IAAJuorq5Wdna2ampqrI6CEEEBADaRl5enzz//XHl5eVZHQYigAAAbqK6u1vbt2+X3+7Vt2zaOAiDJ5MtA586dq+rqajmdrat56qmn1NjYqJycHHm9Xk2bNk2LFy82MwIAte79t7S0SGq9qz4vL0/333+/xalgNdMKwO/3q6ysTDt27AgUwOnTp+VyufTaa69p0KBBmj9/vnbt2qXU1FSzYgCQtHPnTjU3N0uSmpubtWPHDgoA5p0CKi0tlST98pe/1O23367XX39d+/fv15AhQ5SYmCin06n09HR5PB6zIgD4wYQJEwI7Yk6nUxMnTrQ4EUKBaQVw8uRJpaSkaM2aNXr11VeVl5en48ePKz4+PvAzCQkJqqysNCsCgB+43e7ARGC9evWS2+22OBFCgWmngEaMGKERI0YEXs+ePVurV6/WyJEjA1/z+/0XPLNnSUmJYRkBOxk+fLiKi4s1fPjwwBE67M20Avjkk0/U1NSklJQUSa0f9ldeeaWqqqoCP1NVVaWEhIQLWu6wYcOYCwjogqSkJK1YsUKLFi1SbGys1XHQQ7xeb4c7zqadAqqvr9eKFSvk9XrV0NCgTZs26cEHH9SRI0dUXl4un8+ngoICjR8/3qwIAM4SFxen3NxcPvwRYFoBTJw4UampqZo5c6YyMjKUkZGhESNGKDc3V1lZWZo+fbqSk5PlcrnMigDgLKWlpbrrrrt05MgRq6MgRDj8fr/f6hCd0XYYwykgoGseeOABHT16VFdddZXWrFljdZywV11drRUrVmjJkiUhfVQV7LOTO4EBGygtLdXRo0clSRUVFRwFGCASptagAAAbeO6554K+xoWJlKk1KADABtr2/ttUVFRYlCQynGtqjXBEAQA2kJiY2O71VVddZVGSyHCuqTXCEQUA2MDDDz8c9DUuTKRMrUEBADaQnJwcOAq46qqrlJSUZHGi8BYpU2tQAIBNPPzww+rbty97/waIi4vTpEmT5HA4NHny5JC+DDQYU58HACB0JCcn680337Q6RsRwu92qqKgI271/iQIAgC5pm1ojnHEKCABsigIAgC6orq5WdnZ22N4EJlEAANAlTAUBADbEVBAAYFNMBQEANsVUEADCSiQMWoYKpoIAEFYiYdAyVDAVBICwESmDlqEiUqaCoAAAG4iUQctQ4na7df3114ft3r9EAQC2ECmDlqGkbSqIcN37lygAwzHQhlAUKYOWMBYFYDAG2hCKImXQEsaiAAzEQBtCVaQMWsJYFICBGGhDKIuEQUsYiwIwEANtCGWRMGgJY1EABmKgDUA4oQAMxEAbgHBCARiIgTYA4YQCMJjL5dJFF10kl8tldRQACIoCMJjH49H3338vj8djdRQACIoCMBD3AQAIJxSAgbgPAEA4oQAMxH0AxmNuJcA8TrNX8Oyzz6qmpka5ubnas2ePcnJy5PV6NW3aNC1evNjs1feoCRMmqLCwUM3NzdwHYJCz51a6//77rY6DCFFUVKTCwsJuLaO2tlaSNGDAgG4tZ8qUKUpLS+vWMrrK1COADz74QJs2bZIknT59WsuWLdOLL76orVu3qqSkRLt27TJz9T2O+wCMxZgKQll1dbWqq6utjtEtph0B1NbWauXKlVqwYIEOHjyo/fv3a8iQIUpMTJQkpaeny+PxKDU11awIPa7tPgCPx8N9AAY415gKRwEwQlpaWrf3upcuXSpJysnJMSKSJUw7Anj88ce1ePFiXXLJJZKkEydOKD4+PvD9hIQEVVZWmrV6yzDhlnEYUwHMZcoRwIYNGzRo0CClpKRo48aNklr34BwOR+Bn/H5/u9edVVJSYlhOs9x5550qLS21OkbYu+GGG/Tpp5/K5/MpKipKN9xwg4qLi62OBUiS6uvrJSms/yZNKYCtW7eqqqpKM2bMUF1dnU6dOqV///vfioqKCvxMVVWVEhISLnjZw4YNU0xMjJFxEaKSkpKUmZkZKIBFixbZ9rQag5ahJz8/X5I0cuRIi5ME5/V6O9xxNqUAXnnllcC/N27cqI8//lhPPvmkpk6dqvLycg0ePFgFBQXKyMgwY/WIEIypGKttwLK7BYDIYfploG1iYmKUm5urrKwseb1epaamMl8OzsvtdquiosL2YyoMWsIMphfArFmzNGvWLElSSkqKtmzZYvYqEUHaHmICwHjcCQwANkUBAIBNUQAAYFMUAADYFAUAADZFAQCATVEAAGBTFAAA2BQFAAA2RQEAgE1RAABgUxQAANgUBWCw6upqZWdn8/xaACGPAjBYXl6ePv/8c+Xl5VkdBQCCogAMVF1drW3btsnv96uwsJCjAAAhjQIwUF5eXruHmHMUACCUUQAG2rFjh/x+v6TWh94XFRVZnAgAOkYBGCg+Pr7d66489B4AegoFYKCqqqqgrwEglFAABpo4caIcDockyeFwaOLEiRYnAoCOUQAGcrvdcjqdkiSn0ym3221xIgDoGAVgoLi4OI0bN06SNH78eMXGxlqcCAA6RgEYrO0qIAAIdRSAgaqrq/X+++9Lkt577z1uBAMQ0igAA+Xl5amlpUWS1NLSwo1gAEIaBWCgnTt3trsTeMeOHRYnAoCOUQAGmjBhQrurgLgMFEAoowAM5Ha71atX6ybt1asXl4ECCGkUgIHi4uI0adIkORwOTZ48mctAAYQ0p9UBIo3b7VZFRQV7/wBCXtACGDFiRGBqg7P5/X45HA7t3bvXtGDhKi4uTrm5uVbHAIDzCloABQUFPZUDANDDghbAgQMHgr75yiuvDPr9VatW6Z///KccDodmz56tefPmac+ePcrJyZHX69W0adO0ePHiC08NAOi2oAXw2muvdfg9h8OhqVOndvj9jz/+WB9++KG2bNmi5uZmTZ8+XSkpKVq2bJlee+01DRo0SPPnz9euXbuUmpra9d8AANAlXS6A8xk9erT+9re/yel0qrKyUj6fTydPntSQIUOUmJgoSUpPT5fH46EAAMACQQvgmWee0e9+9zstWLDgnN9fu3Zt0IX37t1bq1ev1l/+8he5XC6dOHGi3VOzEhISVFlZ2YXYAIDuCloAKSkpkqRbbrmlyytYtGiRMjMztWDBApWVlbW7qqjtaqILUVJS0uUs5/PZZ5/p008/7dYyGhoaJEn9+vXr1nJGjBihm266qVvLAM5WX18vSSouLrY4SWSIhO0ZtADS0tIkSXfccYdqamr02Wefyel06sYbb9Qll1wSdMFff/21zpw5o+uuu04XXXSRpk6dKo/Ho6ioqMDPVFVVXfBzc4cNG6aYmJgLek9n1dXV6fDhw91aRttjIAcNGtSt5SQlJWnkyJHdWgZwtvz8fEni78og4bI9vV5vhzvOnboRbOfOnVqyZImGDh0qn8+no0ePauXKlRo1alSH7zl27JhWr16tv//975Kk7du3y+12a8WKFSovL9fgwYNVUFCgjIyMLvxK5khLSwuUXlctXbpUkpSTk2NEJAAwTacKYNWqVXr99dc1dOhQSa2Xhz722GPauHFjh+9JTU3V/v37NXPmTEVFRWnq1Km69dZbFRcXp6ysLHm9XqWmpsrlchnzmyDkFBUVqbCwsFvLqK2tlSQNGDCgy8uYMmVKt4sdiESdKgCHwxH48JekG264oVNPvsrKylJWVla7r6WkpGjLli0XGBN2VV1dLal7BQDg3IIWQNve17Bhw/Tyyy8HZrvcuHGjbr755p7IhzDGKTUgtAUtgJtvvlkOhyOwt/+HP/wh8NrhcGjJkiU9EhIAYLygBXDw4MHzLqCgoEC33XabYYEAAD2j288DePnll43IAQDoYd0ugM4MBgMAQk+3C+BC7+QFAIQGHgkJADZFAQCATTEGAAA21e0CSE9PNyIHAKCHBb0P4Hwf7m+//bbuu+8+QwMBAHpG0AJ47LHHeioHAKCHBS2A0aNHB/5dW1ur77//Xn6/Xz6fTxUVFaaHA4D/tW7dOpWWllodI5Chbb4qqyQnJyszM7NL7+30dNAvvfSSJCkqKkpNTU265ppr9Pbbb3dppQDQVaWlpTp04IAuO+vhUlaIbmmRJFV3Ysocs3zn83Xr/Z0qgLfeeks7duxQbm6uHnnkEX344YfatWtXt1YMAF11WVSUZvQfYHUMy71VX9ut93fqKqC4uDglJCQoOTlZBw8e1MyZM3Xo0KFurRgAYK1OHQE4nU5VVFQoOTlZn3zyicaOHSuv12t2NiBihMJ561A5Zy1177w1jNOpApg/f74ee+wx/fnPf9aqVau0efNmTZgwweRoQOQoLS3VgS8/V9Sl0ZZlaOnVer744LeHLcsgSb66M5auH//VqQK4/vrr9de//lWStHnzZpWXl6tXL2aRAC5E1KXRunT8FVbHsFzdv45bHQE/CPopXltbq9raWmVmZqqurk61tbXyer267LLLtGjRop7KCAAwQdAjgIceekjvv/++JGnMmDH/fZPTqVtuucXcZAAAUwUtgLanfS1dupSHcgNAhOnUGEBOTo727dun9957T01NTRo7dqxGjRpldjYAgIk6NZK7efNmLVq0SHV1dWpsbNSDDz6o9evXm50NAGCiTh0BvPrqq9qwYYMSEhIkSZmZmbrvvvs0Z84cU8MBAMzTqSOAlpaWwIe/JF1++eVcBgoAYa5Tn+IDBgzQtm3bAq+3bdumSy+91LRQAADzdeoUUFZWlpYtW6bly5dLknr37q01a9aYGgwAYK6gBVBbWytJWr58uTZs2KDDhw/L4XDoyiuv1L333iuPx9MTGWGBUJi7Rgqd+WuYuwaRqNM3gqWkpEhqfQg8N4JFvtLSUn31xQEN7Nepg0TTXORvnXO9/uiXlmX4tqHZsnUDZuJGMHRoYD+n5g2PszqG5V7ZX211BMAUnRoE5sMfACIP13ICgE2ZWgAvvPCCbr31Vt16661asWKFJGnPnj1KT0/X1KlTtXLlSjNXDwAIwrQC2LNnj3bv3q1NmzZp8+bNOnDggAoKCrRs2TK9+OKL2rp1q0pKSni2MABYxLRLPOLj45Wdna3o6NYnIF199dUqKyvTkCFDlJiYKElKT0+Xx+NRampqt9fHZYvtcdkigPMxrQCGDh0a+HdZWZneeecd/eIXv1B8fHzg6wkJCaqsrLyg5ZaUlJzz6/v27VP50eOK6jOgS3mN0tIcJUn6ovTCfi8j+U7Xqr6+XsXFxV1eRn19vYGJwh/b01jd2Z5sy/a6sy1Nv8j7q6++0vz58/XII48oKipKZWVlge/5/X45HI4LWt6wYcMUExPzo6/n5+crqs8A9R0yqbuRw96p8u3q37+/Ro4c2eVl5Ofnq77WuEzhzojtqUbrdgpCTXe257p16/Rdc7Pe4g9U3zU3K765Oei29Hq9He44mzoIXFxcrHvvvVcPPfSQ7rjjDg0cOFBVVVWB71dVVbWbZA4A0HNMOwL45ptvtHDhQq1cuTJwF/GNN96oI0eOqLy8XIMHD1ZBQYEyMjLMigAgAsXGxspfWakZ/QdYHcVyb9XXKjY2tsvvN60AXn75ZXm9XuXm5ga+5na7lZubq6ysLHm9XqWmpsrlcpkVAQAQhGkF8Oijj+rRRx895/e2bNli1moBAJ3EncAAYFPWTvUI2ERNTY2aa72q+9dxq6NYrrnWq5qYGqtjQBwBAIBtcQQA9IDY2FhVev+jS8dfYXUUy9X963i3rlyBcTgCAACbogAAwKYoAACwKQoAAGyKAgAAm4qYq4BqamrkO12rU+XbrY5iOd/pWtXURFsdA0CI4wgAAGwqYo4AYmNj9W3NGZ4HoNbnAXCdNYDziZgCgLFqamr0XUOzXtlfbXUUy33b0KzmGqYuQOThFBAA2BRHADin2NhYORtOaN7wOKujWO6V/dXqzym1kPKdz2f5IyFPtbRIkvr2sm4/+jufT935P5QCABBWkpOTrY4gSaotLZUkDbYwT5y6tz0oAABhJTMz0+oIkqSlS5dKknJycixO0nWMAQCATVEAAGBTnAICeoiv7oylTwRrOe2TJPXqE2VZBql1O2igpRHwAwoA6AGhMHBZ+sOgZfJAi7MMDI3tAQoA6BGhMHAZCYOWMBZjAABgUxQAANgUBQAANhVRYwCh8DyAlubTkqRezj6WZfCdrpV0uWXrBxAeIqYAQuWqgsCVFslWfgBfbsj2+DYEZgNtONM630q/aOsOVr9taFZ/y9YOmCdiCiAUrrKQIudKi1Ap1KofCnVQonV5+it0tgdgpIgpABiLQgUiH4PAAGBTFAAA2BQFAAA2ZWoBNDQ06LbbbtOxY8ckSXv27FF6erqmTp2qlStXmrlqAMB5mFYA+/bt0913362ysjJJ0unTp7Vs2TK9+OKL2rp1q0pKSrRr1y6zVg8AOA/TCmD9+vV64oknlJCQIEnav3+/hgwZosTERDmdTqWnp8vj8Zi1egDAeZh2GegzzzzT7vWJEycUHx8feJ2QkKDKykqzVg8AOI8euw+gpaVFDocj8Nrv97d73VklJSVGxjJcfX29JKm4uNjiJJGB7WkctqWxImF79lgBDBw4UFVVVYHXVVVVgdNDF2LYsGGKiYkxMpqh8vPzJUkjR460OElkYHsah21prHDZnl6vt8Md5x67DPTGG2/UkSNHVF5eLp/Pp4KCAo0fP76nVg8A+B89dgQQExOj3NxcZWVlyev1KjU1VS6Xq6dWDwD4H6YXQFFRUeDfKSkp2rJli9mrBAB0AncCA4BNUQAAYFMUAADYFAUAADbFA2HOUlRUpMLCwm4to+2RkG0PMumqKVOmKC0trVvLAIBgKACDxcXFWR0BwHmws9eKAjhLWloae90AOiUSdvYoAAC2w85eKwaBAcCmKAAAsCkKAABsijEAmCZUrrTgklrg3CgAhLRIuNICCFUUAEzDlRZAaGMMAABsigIAAJuiAADApigAALApCgAAbIoCAACbogAAwKYoAACwKW4EA8JAqEyrITG1RiShAACbYFoN/C8KAAgDTKsBMzAGAAA2RQEAgE1RAABgUxQAANgUBQAANkUBAIBNUQAAYFNhcx+A3++XJJ05c8biJAAQPto+M9s+Q88WNgXQ1NQkSTp06JDFSQAg/DQ1NalPnz7tvubwn6sWQlBLS4saGxvVu3dvORwOq+MAQFjw+/1qamrSxRdfrF692p/1D5sCAAAYi0FgALApCgAAbIoCAACbogAAwKYoAACwKQoAAGyKAgAAmwqbO4Gt9uSTT2rv3r1qampSRUWFrr76aknSyZMnNWvWLGVlZVmcMPwdO3ZMLpcrsG3brF27VoMGDQq8zszM1NNPP63LL7+8pyOGBY/Ho5deeknNzc3y+/2aMWOGfvWrX3X48+vXr1ffvn1122239WDK8HCh2zLcUACd9MQTT0hq/ZC655579NZbb0mS/vSnP1kZK+IkJCQEtm1H1q1b10Npwk9lZaWeffZZbdy4UbGxsWpsbNTcuXOVlJSkSZMmnfM9e/fu1ejRo3s4aejryrYMN5wCMsD+/fvldrs1ceLEQCFs3LhR2dnZgZ+ZO3euPvroI3300UeaPXu2Zs2apSVLllgVOaxkZ2drwYIFmjZtmoqKipSWlqZjx45ZHSsk1dTUqKmpSadPn5YkXXzxxcrNzdU111yjd955R3PmzNHtt98ul8ulvXv3as+ePSoqKtLq1av13nvvWZw+tATblmf/DX700UeaO3eupNb/z1esWKG77rpLU6ZM0a5duyzL3xkcARjgP//5j/Ly8tTQ0KC0tDTNmzcv6M+XlZVpx44d6t+/fw8lDB8nTpzQjBkzAq/T09MlSQMGDNDatWslSU8//bQl2cLBtddeq0mTJmny5Mm67rrrNGbMGKWnpysxMVGPP/641q5dq7i4OOXn5+ull17S2rVrlZaWptGjR2vcuHFWxw8pHW3LIUOGBH1fU1OT3nzzTRUVFWnVqlVKTU3tocQXjgIwwLhx4xQdHa24uDjFxsaqrq4u6M8nJSXx4d+Bc50Cys7O1vDhwy1KFH6efPJJPfDAA9q9e7d2796tOXPm6LnnntOaNWtUVFSkI0eO6OOPP/7RxGD4sY62ZTBtRTp06FDV1tb2QMquowAM4HT+dzM6HA75/f7Af9u0TWct6UdTsuL82Gads3PnTp06dUrTp09XRkaGMjIytH79er3xxht6/vnndfvtt2vUqFH66U9/qjfeeMPquCGto22Zn58v6b/z6zc3N7d7X0xMjCSFxazF7AKYJDY2Vl9//bX8fr+OHj2qL7/80upIsIE+ffroj3/8Y+D8tN/v1xdffKHo6Gg5HA4tWLBAY8aMUWFhoXw+nyQpKioq8G/8V0fb8rrrrlNsbKwOHz4sSdq+fbuVMbuFIwCT/PznP9c//vEPuVwuJSUlaeTIkVZHgg3cfPPN+s1vfqMFCxYEjjrHjRunNWvWKDs7W9OmTZPD4dDYsWNVXFwsqfVv9fnnn1f//v3lcrmsjB9SOtqWCxcu1M9+9jMtX75cL7zwgsaOHWtx0q7jeQAAYFOcAgIAm6IAAMCmKAAAsCkKAABsigIAAJuiAIAL5PF4AnO/AOGMAgAAm6IAgE5YtWqVJk+erNmzZ6uwsFCSdOTIEc2bN09z5szRxIkTdf/998vr9WrLli1yu92B9x4/flxjx47VmTNnrIoPnBMFAJzHtm3b9O6772rz5s2BWV+l1gepzJw5U+vXr9e7776rY8eOaefOnXK5XKqoqNBXX30lSdqwYYPuuOMORUdHW/lrAD9CAQDn8cEHH2jKlCnq16+fnE6nMjIyJEm//e1vFRcXp3Xr1un3v/+9Tpw4oVOnTik6Olp33nmnNmzYIJ/Pp02bNmnOnDkW/xbAjzEXENAJZ8+YEhUVJUl68MEH5fP5NG3aNE2YMEHffPNN4Ofcbrdmz56t0aNHa+jQoUpMTLQkNxAMRwDAeYwfP14ej0cnT55US0tL4HkFu3fv1sKFCzV9+nRJ0r59+wKzag4aNEg33XST/u///k933323ZdmBYDgCAM4jNTVVX375pTIyMnTJJZfo2muvVU1NjRYvXqyFCxeqb9++6tevn0aNGqWKiorA+2bNmqXly5eH9BOhYG/MBgqYoKWlRU899ZSuuOIK/frXv7Y6DnBOnAICDNbQ0KAxY8bom2++0T333GN1HKBDHAEAgE1xBAAANkUBAIBNUQAAYFMUAADYFAUAADZFAQCATf0/iiDqr74iWgIAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.set_style(\"whitegrid\")\n", + "sns.boxplot(x = \"day\", y = \"total_bill\", data = tips)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Few common background options include: **`whitegrid`** (as shown above), **`dark`** (for solid grey color), **`white`** (this is default) and **`ticks`**. Let us explore an example with **`ticks`** as background and then try to remove top and right axes spines:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "ExecuteTime": { + "end_time": "2021-07-16T14:26:35.532704Z", + "start_time": "2021-07-16T14:26:35.216303Z" + }, + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.set_style(\"ticks\")\n", + "sns.boxplot(x=\"day\", y=\"total_bill\", data=tips)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the above plot we observe 2 changes:\n", + "\n", + "- There are no horizontal line/grid in the background, that we had in previous figure.\n", + "- There are **`ticks`** on X and Y axes, representing the axis interval.\n", + "\n", + "We still have top and right axes spine so let's get rid of that now:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "ExecuteTime": { + "end_time": "2021-07-16T14:26:43.971574Z", + "start_time": "2021-07-16T14:26:43.688376Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.set_style(\"ticks\")\n", + "sns.boxplot(x=\"day\", y=\"total_bill\", data=tips)\n", + "sns.despine()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If we also want to despine left axis, we just need to alter our last line of code by adding a parameter: **`(left=True)`**, and it shall fetch:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "ExecuteTime": { + "end_time": "2021-07-16T14:26:53.458287Z", + "start_time": "2021-07-16T14:26:53.175091Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.set_style(\"ticks\")\n", + "sns.boxplot(x=\"day\", y=\"total_bill\", data=tips)\n", + "sns.despine(left=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let us try to temporarily visualize two types of background in a single plot. For this, we shall use **`.axes_style()`** as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "ExecuteTime": { + "end_time": "2021-07-16T14:27:02.062201Z", + "start_time": "2021-07-16T14:27:01.492871Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# This function shall help us plot some offset sine waves:\n", + "def sinplot(flip=1):\n", + " x = np.linspace(0, 14, 100)\n", + " for i in range(1, 7):\n", + " plt.plot(x, np.sin(x + i * .5) * (7 - i) * flip)\n", + "\n", + "with sns.axes_style(\"darkgrid\"):\n", + " plt.subplot(211)\n", + " sinplot()\n", + "plt.subplot(212)\n", + "sinplot(-1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let us now look into other independent group of Matplotlib parameters created by Seaborn, i.e. *Scaling* of plot elements; that is controlled using **`.plotting_context()`** and **`.set_context()`** functions.\n", + "\n", + "The four preset contexts, in order of relative size, are **`paper`**, **`notebook`**, **`talk`**, and **`poster`**. The **`notebook`** style is default, and was used in the plots above. At first let’s reset the default parameters by calling **`sns.set()`** & then play around with other contexts for scaling, starting with **`paper`**:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "ExecuteTime": { + "end_time": "2021-07-16T14:27:30.496950Z", + "start_time": "2021-07-16T14:27:30.488161Z" + } + }, + "outputs": [], + "source": [ + "sns.set()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "ExecuteTime": { + "end_time": "2021-07-16T14:27:32.324076Z", + "start_time": "2021-07-16T14:27:31.793812Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.set_context(\"paper\")\n", + "sns.set_style(\"whitegrid\")\n", + "\n", + "sns.boxplot(x = \"day\", y = \"total_bill\", data = tips)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "I am pretty sure you must be thinking that this figure/plot in no ways is scaled as it looks similar to our previous plot outputs. So, I shall clarify that right away:\n", + "\n", + "Jupyter Notebook scales down large images in the notebook cell output. This is generally done because past a certain size, we get automatic figure scaling. For exploratory analysis, we prefer iterating quickly over a number of different analyses and it's more useful to have **[facets](https://dictionary.cambridge.org/dictionary/english/facet)** that are of similar size; than to have overall figures that are same size in a particular context.\n", + "\n", + "When we're in a situation where we need to have something that's exactly a certain size overall; ideally we:\n", + "- know precisely what you want and\n", + "- can afford to take off some time and work through the calculations.\n", + "\n", + "With all that being said, if we plot the same figure in an Editor like *Anaconda Spyder* or *JetBrains' PyCharm* or *IntelliJ*, we shall be able to visualize them in their original size. Hence what needs to be our take-away from scaling segment, is that an addition of a line of code can fetch the size of image as per our requirement and we may experiment accordingly." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In practical world, we also add a dictionary of parameters using **`rc`** to have a finer control over the aesthetics. Let me show you an example with the same **`_sinplot_`** function we defined earlier:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "ExecuteTime": { + "end_time": "2021-07-16T14:28:00.840869Z", + "start_time": "2021-07-16T14:28:00.567438Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAasAAAEpCAYAAAAtaQ2+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAC/QElEQVR4nOx9Z2Ac1bn2M7N9V2XVe+/NkiW5yr0DBtsUG9NJQiAEvuQScnNzk5CEm9zc9AQCJITejI0B9457tyVLsmX13vuutL3MfD+ELM2es6uVq4T3+QM+O7M6Wu2ctz3v8zI8z/PwwAMPPPDAgwkM9lZvwAMPPPDAAw/GgsdYeeCBBx54MOHhMVYeeOCBBx5MeHiMlQceeOCBBxMeHmPlgQceeODBhIf4Vm/gm4bLly/DbDZDJBJBJpPd6u144IEHHkwKmM1m2O12yGQypKenE697jNV1htlsBsdx4DgOVqv1Vm/HAw888GBSwWw2U9c9xuo6QyQSgeM4sCwLpVI57vt1Oh0AwMvL63pvzQMPPIDnGZuoMBgM4DgOIpGI+rrHWF1nyGQyWK1WKJVKpKSkjPv+wsJCALiqez3wwIOx4XnGJiYqKyuh0+mclk88BAsPPPDAAw8mPDzGygMPPPDAgwkPj7HywAMPPPBgwsNjrDzwwAMPPJjw8BAsvuGwczzK63tR1aSByWKD0WyDl0KCvNQQJEapb/X2PJgA4DgeFY19OHWxHY3tA4gM8cbMzFBkxAVAJPL4sx4Aje0DOFfeCa3ODLlUDLlUhPgIX0xJDLxp35FJa6waGhqwfPny6/Z+Tz31FF588cXr9n4TAc2dg/jLJ4WoadESr320pwLzciLw5N0ZCFQrbsHuPLjVMJlt+OxgNQ6cbUTfwEhvy4Wqbmw/VgdvpRQL8yKxflkKvJTSW7hTD24VtDozPthVjv1nG0EbJhUV4oX/WJ+LpCi/G76XSWusysvLb/UWJiw4jse2Y3X4YNdlWG2c0+uOFrfi7OUOPLQ8FavnJ4BhmJu4Sw9uJQYNFrz05inUNGtcXrPtWB0KK7rwm2dme5ya2wz7zzTine1l0Bmdixs0d+rw4ivHsG5JMtYuSYb4BkZZkzbGr6iouNVbmJCw2zn83wfn8Pa2Sy4N1TBMFjve2V6G93Zcvgm782AioH/QhP9+/YRLQzUard06/Ndrx9HRq7+xG/NgwuCLQzV4ZVOxS0M1DI7jsWFfJV761ymYrfYbtqdJa6wuX/YcrjR8vLcCpy62j/u+Lw7X4OD55huwIw8mEnq1Rvz0teNoaB8Y132dfQb812vH0dI1eIN25sFEwfnyTry3s2zc912s7cG/t1y8ATsawqQ1Vp40IInz5Z347Ktq6msRQSqsW5KMdUuT4etFrz/847NiVDX138gtenALYbNz+M07Z9DaTUZIYhGD/LQQPLkyA7OywiAVk0dDr9aEX791Giaz7WZs14NbgJauQfzpo/PU+pRSLsb9i5Lw4NIUxIf7Uu/fe7oRB8833ZC9TcqaVW9vL7q7uwVr8+fPx5tvvnmLdnTr0dVvwF8+KaS+tnJOHB6/Kx1y6dCfe/X8RLy3owx7TzcKrrPaOPz23TP4yw/nI8DXU5/4pmHrkVoq2UYhE+Glb89EZkLglbXaFg1eevMUBvQWwbUdvQZ8vLcC374n84bv14ObC73Rit+8cxZ6E+mMFGSH4+k1WfDzlgMA1i5JxsYDlfjsq2pwnNCyvba5FPERasSG+VzX/U3KyIqWAszKyroFO5kYsNk5/OGD8xg0kPnlh1ek4uk1U64YKgDwUkjw/fuzMW9qBHF934AZ//is5Ibu14Obj/YePT7ZV0msqxQS/M/TswWGCgASItX43bMF8Pchddq2Ha11u97lweTBW1svobVbR6xPTQ7Cjx/Ou2KoAEAiZvHIijQ8c+8U4nqL1Y7/e/8sLNe5fjUpjRUtBXg7G6u9pxtRSUnf5aYEY+3iZOo9DMPg+bU5SIwkw/nz5Z0oqe6m3OXBZATP83h9cwlxeLAM8KvvzERKjD/1vuhQH/zmmQJIHFKCHA+8+lkx7PaxCTweTA7Ut2nxFSV9Fxaown8+mu+0l2rFzBgsyIsk1lu79ThR2nZd9zgpjRWNCXi7GiuTxYZNB0iPOdBXjhceygXLOqejy6Vi/OzJGVB7k97zezvKiPDeg8mJQ4XNKKY4HyvnxiM1lm6ohhEV4o31y0h18rpWLbYerbtue/Tg1uK9nZeJOpVCJsYvvjXDZY8dwzD4/n3ZiA71Jl7TUTI914JJaawc04Dh4eEICAi4Rbu5tdh1ol7Q0DmMHz+aD1+vsScVB6oV+PbdGcR6TYsWx4pbr8sePbh1MJpteHsbyewK8lPgkRVpbr3HmgWJ1PrDx3sr0D9ouuY9enBrUVLVjaKKLmL94RWpiAohjZAj5DIx/uuxafBSSK6sqRQSTM8Iva77nHTGymg0orFRSAy4XaMqvdGKzQdJ9l9BdjjS49w33vOmRiI+gkwHfrC7HFbbjeub8ODGY/+ZRoIkAQDP3pcNhcw9fpVYxOL5tTlw7Bm3WO3YfswTXU1mcByPdyk09WB/Je6cHev2+0SFeONvLyzAmgWJuHtuPH7/3ByE+I9/+KwrTDpjVVlZCY4T5sozM29PZtKWI7UEqYJlgIeXp47rfViWwbdWktFVV58BO0/UX9MePbh1sNk5bDlaS6wXZIcjPy1kXO+VHO2HuwriiPVdJxtgMF3fdI8HNw9Hi1tRS2GIPnZHGiRi+sReZwjxV+Jbd2fgu6uzEBN6fZmAwCQ0Vh4m4BC0OjO2Hq0h1hflR7sVujsiOzkIeanBxPrnh2rcUsLwYOLhWHEruvuNxPp4nZlhPLCYlNPRG61EC4QHkwM8z2PjfrLenRjpi7k5JFP4VmPS9Vk5kisYhrkSWbW1tWHnzp0oLCxEVVUV+vv7wXEcAgICEBISghkzZmDBggXIycm5BTu/vth1sgFGszBFJxYx1GK4u3hiZQaKKrsEhVbNoBknS9swP5dk/HgwccHzPL44RDozMzJCr8qZAQB/HzkWT4sijNPWo7VYOSeeYA16MLFRWt2Dli6Sqv7EygyXxKxbhUlnrBxp67GxsWhtbcXf/vY3HDlyhEgRAkBraytaW1tRVFSEN954Azk5OXjxxRcxbdq0m7Xt6wq7ncO+0w3E+opZsQi+hjxxbJgP5mRHEMSKnSfqPcZqkqGwoosqqXTfwqRret81CxKx74xQgbtXa8KRohYsmR59Te/twc3FzpNkij8rIRDZSUG3YDdjY1K5Qna7HVVVVYK1rq4urFmzBocOHaIaKhqKi4vxyCOP4P/+7//cvmci4Xx5J3q0JrDgEC7qR7ioDxLGfs0HEQBqXaK8oQ/1bWRe24OJi6Goioc3Y4SKMUHBmJEZ64u0ONdU9bEQEeSFmZlh5M87TCoZeDBx0d1vxJlLQxqiPowBkaJeeDNG3DWHfP4nCiZVZFVfXw+TSUiV1evpStASiQQ2mw08TeTqa7z77ruor6/Hq6++Cql0cszr4axmVB/agW95XUaKpB1yZqi4bWMksO66BE1sFrxzlkCkvLpUT3qcP2LDfAivfOeJejz3QM61bt+Dm4C6+jZEt+3HOnU1vNmR54XXidH+6XH4z3sQsvDEq37/+xYmEmLJzZ06lFR3Y2oKWff0YGKB5+w4v2sbnlCdRrSoB34iw5XXpOcvQKObCVV6ASTqifW3ZHhXp/kEw/bt250OSJRKpbjnnntw5513IisrCz4+PrDZbOjt7cW5c+ewY8cOHDp0iHrvAw88gN/85jfXZY+VlZXQ6cg88PWASNsGZdHnEJtdK19zEgX0U+6BLSjhqn7O+WoddpzTCNYkIgYvrAmDQjqpgvHbC3Yr5PVnIKo9DSlP0tVHwxKWDmPSAnBK9VX9qHcPdKGxS/gzsmKVuG/2tUVuHtxYMGYdlCXbIO1rcHkdz7AwJcyBKaEARM/CDYaXlxdSUsja+6Q6eZyNBUlPT8fWrVvx29/+FgUFBfDxGaJNisVihISEYOXKlfjnP/+Jjz/+GMHBpLfw2Wef4fPPP7+he79WSNsuwfvMh2MaKgBgrUZ4FW6EvOYYqPLJYyArVgmZRPgFtdp5lNR55hlNVDBWI7zPfAhFzdExDRUASNsvw+fEvyHuJqnt7mBGshexVt5shMk6+dLqtwvEvfXwOfH2mIYKABieg6LmKFSlWwH7xFDZn1RpQJrM0pw5c/DGG2+4lcbLz8/H5s2bsXbtWnR0dAhe+/vf/46VK1dCJhtb9cEdOPMOxkJh4ZByel5eHoAhVlffoY+gLd02rvdhAChqjiGAMSLk3hfBiCVj3jMaF9tLseO4sAB7sdmOZx/K9UwUnmDgzAa0f/IyzAMdY188CozdCp+SLxG6/hdQRKeP694p2XbsKtwrGM5ns/MwMMEoyIsZ13vdbDg+Y7cDBi4cQM+5TwGMz3mVtl+GN2tH6AM/gUhFHwtyvTBWVmpSRVYvvPACfv/73+P555/H6tWrsXjxYvztb38bV70pJCQEr7zyClhW+Kt3dnbis88+u95bvmZoTn4B7aktTl838hIwctLLHYah+jx69r0z7p9752yy0NraraM2EHpw68BZTOjY+L8wt9HnmNl4FmZWAUZCd8J4mwUdm34Hc/v4lCgkYhFVtf8rzwDPCQdjYxl6dv8LzgyVnWfAKf2c3m9urUT7Jy+Ds5KybjcTkyqyysrKui4NwNnZ2Vi2bBn27NkjWN+/fz8eeeSRa37/6wVjYxn6j3xKfa3JFoAthnyEpU3Bfz4+HZauJvQd/ADGOnK8x+CFfZBHJsN7ykK3f3ZUiDeyEgJxsbZHsH60uBWJUepx/R4e3BjwnB2dn/8BpmZyCoGdZ3DanIS9xiz8v28tQmpKIAaLD6Dv6EZwBiF5hjcb0P7p/yD8sd9CGhDu9s9fPC0au042CNbK6nrR0atHaIDqqn4nD64vbAO96PryzwBPpmcHOTk26Wdi0C8Zf//hMlj72jBQuBcD53YS11q6GtB74D0E3fH0zdg2FZMqsrqeePDBB4m1wsJCGAwGytU3H3a9Fl1b/kr9khWaY/HKwHLU2kKwbFY8GIaFLCQWoet+BnXB/dT369n9JsydDePaA81zPlbc6qEoTxBoz+6kOicWXoTXB5dik2EmoPJDbkowGJEYPnkrEP29f0AWRjIBOcMAur78C3jOfS3IpCg1IoPJqP5QYcv4fhEPbgh4mxWdn/8Rdj2ZDamyhuIP2pUotUajIDcWDMNAGhCBwGXfQtDdzwMsGccMFu2DrvzUzdg6FbetscrNzSXSh1arFQ0NDbdmQ6PBc+ja+nfYdeSMqkOmNHygnwsrxFB7yTAlcWRoHsOK4L9gPQKWP0W+pc0y9MU1uU+SmJUVBpFDJ3uPxoiKxr5x/DIe3AhY+9rRf2QDsW7jWbytW4Aa25Di9fzcSIFEEitXIfTBn0ESSDZ5WzrroT2z3e09MAyDRflRxPqh880uW0Y8uDno2f8ONT1cYw3GG4NLMMAPCQg4Sit5T1mAsIdeAiMi69w9O1+HVUMqtN8M3LbGSiaTISyMbG7s7e29BbsRQtZ4HsZ60mOusQZjmyEPQ/SJr40JZSiaT95yeGXNJ9Zt/R3oP/yJ2/vw9ZIhJ5nsZj92wTM65FaC53l073oDvE3I+uN44H3dPFRYRw6fxfmkqoRI6YOw9S9B7EsyY/uPboS1332ixsK8KILZ3N6rR3mDx6G5lTC1VmGwaB+xruEUeE83H9zXR39CpC/Cg8joWBGTgYClTxDrnNmAri1/HVcEfr1w2xorAFCr1cSaRqO56fsYDcZihLzmOLGu42T4QDfvypcMAObk0OsLDMMg8I6nIQ0mD6qBon2w9LifpqEJWh4vbYPdkwq8ZRgsPgBTIznW4Zg5FaXWkb95bJgP4sLp6tdinwAEr3kBw47PMHibBT2733Q7MgpUK5CdSDo0J0vbKVd7cDPA8zx6979LrNvB4p3BBRjkFVfW5rkQrPXOXQ5lygxi3dxaBd2lo9dns+PAbW2sbDayf0CpvL4zWMYLee0JsDahSgcPBh/q50DLj+xN7SVDRnyg4+1XwEpkCLnvx2CkcuELPIe+rz5wez8zM8MIpW3NoBmXHIgXHtwc2HT96KX8/QYYb+wwTBWszc+NdNlmII9Igs+0O4l1Y30JdJeOuL0nmm7k6UvtnlTgLYK+7DjMrVXE+lZ9HhrtQsdiTrZzY8UwDILuehZiH/Kc6TvyKTjb2P181xO3tbHSasnCIy3aulmw9ndA1nSeWK9VZAlSOwAwewpZT3KExD8c6tn3EeuGmkIY60vd2pNKIUF+Gpku8kwRvjXQnPwCvJkkAX2knQELhDWGWVlkmtsR/vPXQ0Q7jL760G2q8vSMUDh+FTv7DFQhXQ9uLDirGb0HPyTW9fIQHDML+z5TY/zGFL4WKbwQdM/zxLp9oAcD53df22bHiUljrLZt24aXXnoJzz33HNavX4/ly5fj448/vur30+v1RGMwAERFkQXjm4W+Qx+DcWT/iWX4qJOcP+TKIxoN3+l3UT2j3gPvu513npdDes4nS9tgs3vUCm4mbIP9GLxwgFjXhuaj0iZMCUeFeCGCUotwBCtTIGjFd4l1u16DweKv3NqXj0pKjfJPXxpfk7IH1w7t6a2wD5J1923m6YISAgDMpbB9aVDEZEKZlE+sa058AbvxxkjL0TBpjFV5eTk2btyI/fv3o6ioCA0NDTh79uxVv19RURGRBoyJiaHKMd0MmFqroC8/SaxrYhag3yZM5am9ZUiPd29sPSuRwX8h2Ttm6WqA7qJ7qZ5p6SGQSYVTQwcNVpTXe4roNxOa01sIUgUjkWOXhRx1Q1NGdwZlUh61NqE59SV4m3tTgGdmhRJrpy966lY3E3bDADQUAQEmOgene4VNvwwDFExxv6fOf+EjACM0F5xJB83JL65qr1eDSWOsUlPJ6OL48eOECru72Lx5M7E2a9asq3qv64GBwr3EmkilxgEDKYNTMCV8zBTgaKgyCiALJ8eHaE5+AZ7Sx+UIuUyM/FRyDPrZyx7P+WbBpuunsrsUOctwro5MC47HWAGA/7x1xJp9sA+DpXTxZ+LnZZA/r65Ni86+idG3eDtgoHAPeMfULStGmf8S4tr0uAAE+CqIdWeQBkVRRQUGzu2CbeDmMKgnjbGaO3cuJBJhTl6n02HLli3jfq+qqirs37+fWF+/fv3Vbu+aYdN0Ems+cx7A+RoNsT4ejwgAGIZFwJIniHVrXzsM1YVuvce0dNJYnbtM7tmDGwPtKXpUVe09g2BmBvjKkRipHtf7S4Nj6NHVyS/BuyFkGuyvRHwEqR03PDPJgxsLzmqGllJD8slbjuMNZLp/Whr5PI8Fv3nrwIiFvam83YqBwj1O7ri+mDTGyt/fH/PmzSPWX3nlFfT1uZ+OMhqNeOGFF2C3C/+ABQUF1OjtZkGVNgvVCgm2BHrh0xAffBYbgVf76mH1rwIjNY5cp5Ag/SoG6MmjUqGIm0Ksu9sEmpcaQvTTtHbr0NZz83LWtytsOg20RfvQIRXhnLcc2wK98Fa4Gu8nRuOzusNgfXoAdsSgzMwMu6qx5H4U9RObtsttmjKN0HHKY6xuCnQXj8BuGECjXIztgV54P9QXG0J98amcQ5XlNFjvPozWBqQ5n2NB7BMA3+l3EesDF/bdFN3ASWOsAODZZ58lBGh7e3vxve99D4ODY4/OGBgYwHe+8x1UVwu7umUyGX7+859f172OF5eCg/F2hB9Oq5Uo9pajUGzFpf5SSKKqIcs+AmliEVjvXkxNCaI2ArsD3xn3EGumpjKY28ceE6H2liE5ihS7PO+Jrm44Lp36DG+EKPG36AB8HuKDk2olapRSXLZq0CEugSz1POS5X0ESWwaIrJiZSdaP3IEsLB7KRFKJvP/E526li2mpx8t1vdDqbq0A6jcdBosBn5dsxZ+i/fFGpD9OqJUo95KhxEuGo+2FEIfXQpZ2FrL002B9uxDsr0BUyNUNZ/WZthIQCaWYOKPO7fr3tWBSGavMzEw89NBDxHpxcTHuvfdeHDlC/8B4nse+ffuwevVqnD9PUsNfeOEFxMfHX/f9jgcH60lyxTAYBhD5d0GWdg4av1MwX2V/gyI+hyqz42505UkF3lwYLEa8W/gpftdbiEaF68kCDMtDHNwMRdYJWJVXX0tUz6FEV/0dVA1CR8SEeiM0QEiF5njPd+RGoknTiv/c+SvsVnLolbrWJWe9tJClFIFJOoFOXfdV/TyxlxpeGXOIde25nTe8r25SGSsA+MlPfoLZs2cT601NTfjud7+L5cuX46WXXsLrr7+OV155BT/96U8xb948PP/882htJXuDHnjgATzxxBM3YeeuoZK614xcqy/HLw/+GX1Gzbh/BsMw8J1xN7Guu3wCtoGxm3ynpZMe+6W6HhhM7jHGPHAfHbpu/Hjfb7G75gj48cwPk5rwxxNv4F/nPobtKiRx5BHJ1HTxwAWyxusIhmGo0VVR5a3Rkvum43jjOfzswB/QZRk7qzQaA3wXfv7VH1HX13hVP9d3GpkKtPa0uN27ebWYdMZKKpXiH//4B+bMIa07ADQ0NGDjxo34+9//jtdeew1ffPEFurroD8tjjz2Gl19++UZu123cm3YHvKTujVWo62/Cf+//PRr6xz87yCtzHjlEjeegPbdrzHvjwn0Q4Cuk0dvsPC5UXZ2X5gEdXboe/PrQX9Gtv3qW1Vd1x/HamffAuZG+c4RP3h3EmqHqHGyDY9eG8ymF++KqLo8813XGpxe34pXT78Bsv7osy4BZh18d+itKO8jxMmNBFhoPOWVYp/bsjqvai7uYdMYKAFQqFd566y28+OKLkMvlY9/ggODgYLzyyiv42c9+RtTAbhVi/SLx6l0v496wpVgZMh/hxjmwtiSCM9N/vz6jBr8+9Fd0DI7Pa2XFUuphNFh6aEzWF8Mw1MPonIfCft3Qo+/Drw//Db0GUnEfAIIsNtwdnosnsx6FpT4Dtp5w8HYR9doTTefxTtHGcadnlEl5EHk7kHh4zq0m4fQ4f2pPXm2LZlx78MA59lQfxheX6Qw8hueRZGPx3byHkC1bCktjKjg9vT5lspnxu6P/wLnWsVO8jvCdtpJYM9YWwdLbNu73chcT46S+CjAMg6eeegqHDh3Cc889h+hoUrTV8fqMjAz84he/wP79+7F8+fKbtFP3oZIqkaSKQZIiAU3lPrC1JcJcMg+WukzwHPmn0luN+OPxf8JoHV+vmU/eckL+nzMMwFAzNo19OiUVWFje5ZlxdR2gMQ3g14f/Ro2oJByPO3p0eFEnwyNzvgNGGw57dxSsdVNgvjgHdi29SXxfzVFsujQ+j5dhRfDOIXtzBooPjKl6IhGLkJVAqllc8KQCrwuK2y/j3QubqK+FmG34j6Y+/CRtFZYkzkVbtRr2zliYy2bDXJlLdXztPIdXT7+L1oHxOZzK5Hyqav9giXuqJ1eDSTUpmAZ/f388//zzeP7559HZ2YmLFy+it7cXWq0WHMfB29sbkZGRyMzMRECAe6oPtxr1nWZYbcPpGxb2nkioGD8oU0ugNQv11poH2vHa2ffxo9nfdSlaOhoipQ+UKdOhv3xCsD5YcggqSq/NaExJCoRUzMJiG0kvaXRm1LZqkERhC3rgHjiew2tn3qcWvr1tdjzVqkGw1Q6/JWvBMIygDsRbFLBU5iNvrgGXzceI+z+/vAuhXkGYHzfT7f345CyB5vhmwfBP+0APDLUXoKJI74xGbkowzpcLSRVFlV1YtzTFyR0euIOWgXb89dS/qZHylEET7usahFwkgVfGHHT1G9DUMVzLYsBpg2G+7IPEeZVoHRS2E5hsZvz5xJv43yX/CbnEvUwVw4rgk38H+r56X7Cuu3gU/gseAsPSo/1rwaSNrGgICQnBkiVLsG7dOnz3u9/FM888g4cffhjz58+fNIYKAKrbyEhpWmwqfrf0JwhRkV7r2ZZifFk+vsY8Wje6oaYQNp3G5X1yqRhZieQeSqo9KuzXgj3Vh1HScZlYV9k4fOdrQ8WIpfCesgB2O4fSakejxuCBKcvx8JQ11Pd/58JG9Ojd70cU+wRQaew0FQ1H5KaSHndFYz/0Rg8R52phsBrx+2NvULMo07VGrO8cgIznoUqbBVamRAmljpwQEoLfLHkRaUGkmk3LQDvePP/JuFLG3lnzAQejZNf13TCixTfKWH1TUNtOfiHz00IQqPLHj+c8A5lYRry+8eJ2VPaM3S81DEXcFIi8HQw4z7nVAEobyEh7ODxwD02aVnxc8iWxrrRzeKqtHyHWodSbKn02RApvVDb1Q28S1hcVMjFSYvywKm0ZVqeRKW6j1YTXz34wLsKFT+5SYs1QUzSmvE54oIpQ8+Y4HqU1nu/I1WJD6VZq1J1osGBV9+CVqWTe2YsA0J3HqcnBUEmV+Mnc7yHMm3Qojjedw/5a9+dUiVS+UCbkEus3qufKY6wmGDR6G/p1wroAywA5SUMGIlodge9Pf4y4jwePf5/f4DZdmWFFQ56RAwZLD47pXWUnkcaqrL4XZuvNnx462WGxW/HK6Xdh5Uhyy9rOAYRaRj5Tn6nLANCp4FMSA6/MHVuftQpzoklx20tdldhb7f5BoojPgdjX8W/NQ1d+gnr9MBiGwVSKQ1NU6TFWV4OqnjrsqyGNSKDFhoc6tBiObcTqEMij08HzPEqIyHvkDFFKFPjR7O9CJiJ79z4s+RI9BvcjcO8pC4g1feUZcJQxNtcKj7GaYKjrILv9EyLV8FKOfLFmRuVSvecmbSt2VR10+2d5UVKB1u7mMRUtYkJ9oPYSRndWG4cKjwr7uPHF5V1o0pL9f7M0BqQaRmjJYr9QyCKSAdDJCqNTbwzD4Nt5DyJAQdYQPy79Em2D7jXpMqwIXlkLiHXdJXKSNbGfFNJzL6rs8gxkHCdsdhv+de4j8BB+bhIeeLxdC+UoYpN39iIwDIvGjkFoHFRDJGIWqaNk2qLVEXgqnxRYMNvM+KD4c7f3p0zMA6sQjqLhbRboKBMkrhUeYzXBUN9BpgBpkcyDmfcg3o9kQH5WttPt2oQ0IByySFIPUVfi2uCxLIMpSWTdqpjizXngHN36XmyvIOdThdhZ3Nkr1Fz0ypgDhmEwaLCgullD3ONoHFRSJb43/VHiOovdineLNrq9R5pagaWjFpZe18M3s5OCCH3Crj4D2nr0bv9sD4BtlfvRPEDqKy7rGUSQIJPBXIlyiikp+fQ4f8gkwvrSvNgZWBxP/n1PNxe53X/FiCXwSiffQ1d62K37xwOPsZpA4Hke9Z1kZJVNMQwsy+K7+Q8RDECzzeyU2kqDdzYZXenKT4zZc5VDMaAeYzU+fFK6hUj/iRgW61p7IHEIQLwy5gIYOogcg5OwQBVCA8iG8imhaViWSIo/l3SUu30YSQMjIQ0lpch0Za6jK5VCgpRoMrIrqvBQ2N1Fx2AXPi8jm/WjRUrM1hoFa4r47CtDVmkpQJrDCwCPZK+Br4zsw3q3aBNsbqjtA/QMjam5HNb+69t/6TFWEwjNnYPQmYQFcLGIRVocnckY7x+D5Ylk3elcawmK28vc+pleaQWE7D9n1MHYeMnlfdmUmkRtiwaDhqvrqL/dUNVThxNNpE7lEmUEwi3CQ0IaGg/p15qOpTVk4ZyWchvGI9n3IlhFfn8+LPnCbbLFsKEcDX3Z8TFTejRW4MVaD2vUXWy8tJ1wZliGxb0dGjgSw70yh5wSq43DJcpnTCNFAUMR+MPZJIO0dbADu6rdKynIwhKomqPu6EmOBx5jNYFAY/CkxZLh+2g8mHkP/OTkHKGNF7e7VR9gZQoqRVlffsrlfcF+SoQHCr15ngcuUg5TD4TgeZ5aF/CReWFucwux7pU5YiwuUhh1tMh7GHKxDA9R6OyNmhYcbzzn1n690gsACCN4a18bLB11Lu+jRd+Xans8DeRuoFHTgpNNZJP+itApCNVqBGuMSAJV8hChpqqpHyaLkOjkpZAgPkLt9GfNi52BlAAyet5ctguD5rFHADEMQ22FcUepfzzwGKsJBHr47vwgAgClVIHHp5JK2bX9jShsc6/fQZVOCgPrK0+PmQqkpRY8qcCxcaq5CFW9Iwe92MYjpMeKB/gE8M2dsBqBEVInA6+0AgBAr9aI1m5hzYdhgEyKYsRozIrKRYJ/DLG+4eJWWNxQ8Bf7BFC14HRlZAPyaCRGqSGnSC81dgw4ucODYWy8uH2EVMHzkFo4RBtlKKjohnkAGB1wKRKmgpUNtQrQzpApSYEuJ4uzDItv5z1IlBRMNjN2VrmnSOGTtwIS/5GhsCLvAGpEfi2Y9AoW3xTY7fTw3VmueTRmReVhe8UB1PYLVZQ3XtqB3PAssIxrn0SZkAtGLBVMoh1OBSrjc5zel50chN2nGgRrnn4r1+A4DpsubYfSaEdSkxmxbRZEdlog5gBgP658AxhA5gv4pEaCkQ2xrS7Wkv1NcWG+8FaOMT6EYfBo9n341aG/CNZ7Df3YXX0Yq9KWjblvr4w5MDUJU8u6shPwX/SoU7UCsYhFelwAQbUvrelBXDiZDfBgCNW99TjfVgo/rQ3ZVUYkNZmgNA8Zri6MiFeL5IDUC1BOibqyRiNXuHOGxPpFYWn8XOxz6LPaXXUYK5OXwEvmWmSblcoR8a0/DDkwPAdV+hyIHFiC1wpPZDVBUNuqpTZ6JkWpx7yXYRiszSKFJRs1LW6JVLJS+VWlAqckBhLTg9t69Ojqu/49Ft8UnKk/h6iTdXhyay8WFOoQ2z5sqBzAA2YN0H26Gece/zZaNn+BS9UkOSEz0T1llvTgJOSHk6M/tlXud2s+mip1FsAKfVu7rg+mlgqX92UmkPvzpIpdY/eeD7HmYD8e29mH7GrjFUPlCLsJMPYAtW99jrJfvoyey5WoaiIFkGnpWBruTb8DYoe/sdFmwg43oytWpoBP7jL45K247oYK8BirCQNa+J6ZEOD2VOCc0AwkBcQR65su7XCrkH41qUBvpRQJkWpi3VNEp6PvXCEGf/U3zLyopxsoJ7AbjWj88GNEbX0TgWbhYTRljBTgaDyUvZpI9QyadTjkYvDnMERKbyjjs4l1Q+VZl/dNoUhzXarr9YwMoYC321H4r1eRu6kE0R3jk6bSFJeg8qf/jTvaj0HCjdwb5KdAWKB7o4f8lWosji8g1ndXH4LOfOtbDjzGaoKgrI5M8bgTvg+DYRisyyQHKzZr23Cm5cKY9w+nAkfDHVYg7bCk/S63M3ieR+OHH6P8N/8L1cDVsyUD9d14snknpmmGNAQZBsgYh7GK9AnD3OjpxPr2ygOwu6F8okolhXD1lWddEnkSItVQyIRpQr3Rivo2rRs7vn1g7u7Gxf/+BUy7DsN5dWlsZA7W4ZGWPfCxDhEjshIC3Ra4BoDVacvJ6Mpqws5xiA3cKHiM1QSBzWLDjP5LeKRlN+7qPA4vm8Ht8H0YWSGpSA1MINa3VxwYkxnISuVQJo0/FUhL81yi1FZuV/B2O2r+8TpaNn/h8jpWykKiAsRKItsmgAgcFvecx9zeC4gP94GXQuL8YgruSSX1/rr1vTjVXDTmvcqkaYBD/dOm7YKls8HpPcN1K0fQ6rO3K3R1dSj+jx9jsKLS6TWMiIVIBki8APEYwughln481rIL4aZuZFGeT1cIUPphURyZZdlVfRAGi5Fyx82Dx1hNECyx1WBhbxEiTd3IGqzDdzr2IlRMNgi7AsMwWJtJ1q5q+hpQ3Vs/5v2qNFoq8IzLGUbpcQFE3aq9V49e7a39Yk8E2M1mlP/u9+g6QPdK7QzALpqB9JdeRHA2h8AMICgTCJ4K+KcCgXNnA06Ggxb0X8Ti3sJxyxdFqyOQG5ZJrG+t2Dfme4mU3pBHpxHr+qrxpwJp/WK3I/QNjSh76WXYBumj6Qd8pIj99pNIeHwhgrOBwHQgaAoQkguEzEmEPIycLwcAXnYTHmrdi3jT+BtzV6cvh8iBNGO0mtxKF99IeIzVBEFAl9CYyE2DKPvly7AOjI/mmxGcgji/KGLdnSKpMiEXjESo+ccZB2FurXJ6j0ohoTK7bvfoirfbUfnHP6P/HH2gZXOIBF+tTcGM//ciGHO7wOAzDOCTmoSUF3+EKf/3WygiyYZLAPC/dAp1/3pr3AaLxv5r1LRQR5Q4gjbvzFB5xuU9NGp9maduBUNLC8pe+jXVUHEMcHKKCvjZdxB+910wNQmJUqwYCL1zJab+4++If/opQEJG2GKeQ9frr0JXN7ajOhqBSn8spERXe6oPg+Oub+/UeOAxVhMEirAwYs3Y2obLL/8WNoP7UQrDMLgreTGxfqblAnUC7WiwUjkUcWQRXV/lunmUlgq83etWDe9/6NRQnclQ4otFaiyevQosw0JfQR72w/Uh75RkhL/0axT5JFPfq2P3HrRt2TauvaUGJlKbQLdWjD2rSpVM1rwsXY0upXUSInyhlAtzmwaTDXWtmrE3+w2FqasLl37+K1i1ZO1uUMni88VqXJ4aiIUJBbB0NsA+4BCJsiIoEnLBisUIu3MF2lY9hUGRgngvu9GIyy//Fqau8clc3ZW8iFjr1PegqN11DftGwmOsJgiiHlwLiZ+aWNdV16DyD38Cb3d//MbsqDxC1YLneeypPjzmvcOd8KNhqB7DWMVTahJ1t2+ap2PffrRt3U6s8wAO5XvhdLYXAlUBKIjOh22gF+b2GuJaVcqIUbjcPIB9QTNwWp1B/XkNH3wETbH70jYMw1Cjq7KuKrRoSdHU0RD7BlG1Al2lAkVO6la3K4Wds1hQ8X9/grWfpJlrvFhsXOaHtmApliTMhVwipz5/iuh0iOQjLL+iQRnej7oL7TLyc7b29+Pyr38Lq5NUIw0RPqHIDiUbwXe7KcF0I+AxVhMEssAAZPzqF4CMHKyouVCMli+2uP1eYpEYy5NIzcCv6k7ARJk0OhpD/VYO0jq9bbD0tjm9h3YQNXfqoBkcX83tmwBN6UXU/fPfxDoPYM9sH5QmDykNLEucBxErgp6SQpMERQnUAC7V9gIMg8MBuTjuR/ZKgeNQ+ce/wNThfn0iNzwLEd5kvcOxKZQGeirw6ijstyPq334X+lpyDM+AksUXi/2gV4ogYljckTQkYaSvIjUklaMiXKvNjsrGfujESnwavgTdUjItb2xpQfXfXx1XyvjOZFJC6WJnJZq1zs+CGwmPsZpAUMXGQvrgA4CYpIM1ffIpBspdN2COxpKEuZCIhHlsg9WIww2nXd4nUvlemZskuLeafGCG4eslQ0woqdxcVn97HUZWrRZVf/4bNQo+kaNCVewQjUvCirHo634WmtesShYag8vDnyPD4HhADs76kiQHm06H8v/9Pewm187IMFiGpSqyH2k4PaZDMzrqG4apuQI2ncbpPbRUcXl9322nE9h1+Ag69pDpVp2CxReL1RhUDREbZkfnw1+phm2gF5YO0rApk/Kv/H9VkwZW21AtySyS4bOwxdBLlMQ9/ecK0bF7r9t7zQ5Np04U3l11yO33uJ7wGKsJBjYmGpL7VpMvcByq/vxXt0N5H5kX5sWQHvD+2mNjelejH4RhjJUKzKCkAm+nuhXP86h941+wajTEa2XxchSmjRwes6Lz4CPzAmc2wthIkhpGRy6aQTOhB3g4KA9eGWRK0NDYhMYPPnZ7z/NjZxLTYo1WE443uf5bSwKjIPZzjMp4GGud09/jw30JnUCd0YrmLvdTU5MdhqZm1L7+L2LdzgI75vpC6z3ipK5MWTJ0D+W5kwbHQKIeMSKOKfcBiRcq566DSEHWsBrefR+Gpia39suOiu5G42jjmVvSJOwxVhMQopRkRNxHKmWbu3tQ84833A7laUXSZm3bmDR2VTJprEzNFbAbnB8sNMbX7dRL033oCHpPkSm9lmAJDk7zxmi634rEBQAAY32JUJEUgMjbH9LQESWSy5ToNDpMjfT/ehGyYNLrbd+5C9pL7o2HUUoVmBNDRkn7ao66/I4xDEONrgw1zo2VSMQiNcafWL98mzg0vN2O6r+/Cs5MpsaP5nqhM3AkC5LkH3uF0UtNASYJ68o05m1cXjqS/uP/EeucxYLKP/0VnMW95vT5sTOhkAgbuyx2K442umaA3gh4jNUERfRDD8I7JYVY7zt9Br0n3Ot3iPQNozYJH6hzPThPEhgFsTpEuMhzMNTS2W0AnWTR0D4A3W0w38rc3Y26f79NrNvkEuwu8AEnGjFUCX4xSAyIBQAYasjPU5mQK1AcuFxPTn1Oi/OHxMcHaf/9E7BSUsS25tXX3E4HLqekAhs0LWM6NDQtSUN9iUt5rvQ4irGi/H7fRLTt2AldDZnOq45VojRJGAEtThhSKx+KvC8S9yhHkaBsdg4VDeRnmBEfgIAZ0xG6giTSGBqb0PjRJ27tWyGRU2nsB+tOjrtl4lrhMVYTFKxYjOQf/RAiFanrVffWO7Dp3AvDaWOrTzUVwmB1TodnGIaeCqR4ecPw85EjIoicb/VNP4x4nkf1K6/BbiDFe7+a5gWDQpj6Gia+8DxPjUQcjQCt7pfxNaFFFReL6EceIl43dXS6nQ6M9YuiakrurTni8j55ZCoYmbAuwpsNLoVtaUSc26GuaeroQNNHG4h1LsgP+6cpBVG3QiLH7Oih74ChvhhwMP4iLz/IwkbYmHWtWur8qphQHwBA7LeeoPbptW3f6Xb/1ZIE8gxp0raitq+RcvWNg8dYTWDIQ4KR+P3vEevWfg0aP3LvMJoZlQulROi5me2WMQfvUSnsdRfA250LbNJSgbQ01jcJPcdPQltKer+2qSmoiBISXLykKsyOGjqILB31sOs1wptEYijisq7802i2oa6V7MMZfeiHr7wT3mmpxDXtO3dBWzZ2ky8A6rTp081F0FmcO0SMSAwlpSePFi0OIyXGD6zDXKXufiO6+r+5Kv08z6Pm9X+RaTeGwfG5QbBKhEfw3JjpkIuHGMGGaoozk5QPZpTkFe35yogPuPI5i2QypLz4H2AcSVsch7p/vgnejSbfSJ8wal/ewboTY957PeExVhMcgQWz4D+DNBwde/ZhsNK5ssQwZGIp5lLqEl+NkQqUR6VdGeg2DN5igqnZueecFkumecopKYpvCuxGIxrefe/Kv3kAeokvWsPzcUiZiujKfMSXzUbixXmIrZiBzI4CnDvahMbaXuiryUNdEZ0BVjriWFQ19hNsuWA/BYL8Rq5hRCIkPf99ajqw/t9vu9WfNzMqF95SYVRs5WzUSbWjoUzMJdZc1a3kMjESIkha9Tc5+u46eAjakpEhqFZWim5lFFryVqK7JRbxZQVIuFSAuPKZiKmcBq+KWJRdaINuwARjHSlA7Rh50z47x3SrKi4W0evXEdcNVlah84B74z8WUdTYjzedG5M5ej3hMVaTAPFPfQes3EG9kudR89ob4Gyup/kC9FRgfX8z6lyE8YxIDAVtJERdsdN70ig1iepmDaw29xuaJxOaP/sclt4+GMUqVAdMw6mY+3A65l5UKLPAdvrDRxsCpd4PcqM3vAYCoauR4KudFXj/9VN4ZyeL8/pp6LONfGaOhz8tRUZLpSkiwqnpQH19Azr3j30YSUUSqkNzuN61iLEiYSqxZu1pgVXjXC2Bxhr9pkbfNoMRje9/BB5AryIcl0Lm4XjsOpSGL0GlJhDqvggo9WooDGqoBgPgrQ1GVVEvPv+oCH/59QFsbZ2HSlMqbPzXqWSRGIrYkcib53mqM5gWS37G4avupqYDG9//iKqi4YhZUblQOCjommxmtwSQrxc8xmoSQBYUiJiH1xPrhsYmdO4/MOb9sX6R1LHmX40RxisTSM/ZFT05LEAFtZewqdlq41DT/M0bB2FsbUPtzoMoD5qNUzH3ockvE0aJj9v3G2wyVJgzsWtgFQ4PLoLW7kPxminGinLYA0PpQK9EkkzT+NEnsOl0Y+5nAaWIXtPX4FLRQuzlB1kY+TNdRVc0kkX5NzSyatn8BdqsPjgdfS+KI5aj0zsBnCtJfQdo7P44Z5iFLzVrUWrMhigiE6x0xGB09BqIxnuJmEViFBm9shIJEp55ili36XRoeP+jMfcil8hREE3WsW9mKtBjrCYJwu66A6oEMm/cvGGTW9qBtOjqZHMhrC5qUArKSHtLVxNsA3RPmGEYanRV3vDN8pztdg7b/7ELJyNWoc03BTxDH+vuLlqsMdihXYP9h3pg/Jo9abNzqGgk5Xhohz0wlA6M+863iHXb4CCaPv1szD3E+kUiVk163mM1kStorEAXdSua19/Y8c1jjbaWN2LnaR1Kw5fAQFGUGA/MvBylxlxsrshBZVnnlXXac5UYqYZETP8++mZlImgBWZ/sOngI+vqGMfdBSwVW9tahZcC1RNf1gsdYTRIwIhESnvkusW7VatH65ZYx7y+IzicaQPUWg0thSrG3P6TBscS6gZJLH8Y3nZ7c3TmIf//fflRYQq/ZSI0GDxbnTzbizb8cQ0tjP+patTA7sLy8lRJEBZNKIcPwSUtF0HySit6xazcMzS1j7mFB3Cxi7WjDaZeDGWnRt6nxEjgrXWpL7S1DRJBw5DnPf3NqmzzP48yxerz7Vil6FRHX9b31JgYb3zmHLz+5AKPB4la9yhGxTz5GMox5Hg0fjB1dJfjHIMaX/J2ONtycniuPsZpE8E5OQuA8MkJq27IN5l7X0YtCIse0yBxi/cgYXzRlIlmXMNY6N1Y0kkVFY99N78m4ESg63YR//+UYuvpcjRznoffqQ2dkBRoTz6Mu7SSUi3qw9ok8LFmZhqS0IDBwzsDS9hvx3j9O4vD+auK1tNgAgk3niJjHHgHroC/J2+1odOMwmhMznZhjpDENoKSj3Ok9svAEsEph+pO3WWByMWGadqB+E9ROLGYbvvjoAvZuKQPnYt6vTWxBX1AT2qLLUJ96GrXpxzFnXQTufywXM+bGIdDftRN0sbAV//rTUVRVkU33tOdvNKRqNaIfXEusa4ouQDOKCEIDwzBYGE+mi481ngXH3/jRIR5jNckQ88jDBA2Vs1jQ9PGnY947P5aUX7rQfgkDZuc1DUU8aawM9aVOmz/jI9SQioVfK63Ograemy/Pcr3Aczy+2lmOHZ+VwmajP5RSCYOZi2JQlfsV6tNPoTu8FoP+nTB492NJ7nSkZoVh9sIErLnDD/erN2C68iSUDP0z4TgeHZe7kABWcOSN5TUDQ4LIkfffS6z3nT03JnvUR+aFvLAsYv1wg3OiBcOw1OjKFRGHRrKY7JFVX48eb/39OMqKnYu8RsWqEbdEisqcA2iLu4i+0AbofXqhDGaxYFo20rPDsXx1Bh7IrsddPlsQJ61x6tgMaE3w6zPCMcGYOoaxAoDQO5ZT1U8a3v9wTCp7QXQ+WIdp0b2GfpR3k5MDrjc8xmqSQR4SjLCVdxLrXQcPQd/gukkvKziVGB1i5+w42eS82VcemUJv/nQykFEiZpEU7Uesl09SxpfNZseXn1zAiYOk+gAAMDyHJL4JP3hpKbjkXlgcpjv7K9SYEjLSB2WsK4aMtSBZXol71J8jR1EICUtPs/mDQTLYKw8prR5IQ/iquyENJHveGj8mG1MdsSBuJrF2vrXUZc+VksIKNI6TNVrTPCLGOtnQ2T6Ad/9xEj2ddKdPbh3EkiliPPFcAS6y58CzwizDvJgZVwwAz/Mw1F2An7gfBV7HsMr3c4RL6ClcERgkgUXI1y5NZLAXfL3IqQ2OYCUSxDxKYY/W1qHnuGvChK/chzo65NhNSAV6jNUkRNQD90HsJcz7g+fR/Okml/exLIuCGLJny9UXjXGgyw7DVSrwm1K3slrs+OTfZ3HpAt1bVlq0yGvZiTseK4BCKaU2Ws+JmQ521Gj60RGHmLEjU1GKR+4UIyJaTf0ZPmCQChZylkViJP0aR4hkMkQ/+ACxri0phYbSwDwaOWGZ8JUJ62I2zoYzzc7/3oq4KaCNlbFq6RT2sAAVfL2E9VOLjUN92+RjjbY1a/DB66egdzIOJ1JTjkX8Ocx6ZCmatK1o0JCGZ3TGw9LVCPvgyLPiJdJhoc8h3H1fGmRykknIgEE0WISBGTMFOBqBcwqgSqCzR8dqh6G1OZxqKYLFdmNJMh5jNQkh9vJC5Nr7ifXeU6fHZPXQUoHVfQ1oG+ykXD0EmudsGGfdarIZK5vNjk3vnUdDDT0iDB2owfTmrYhOCYM6Jxudum5U9dYR180d5RzYTXqYW8laVGj2VDzx/dmYOZ9kewKACgzSRSLYLO73qwUvWgh5ODl9uumjDS7rh2JWRKUou1JiFyl9BBJAwzDW0QdCMgxDFbWdbKnApvo+fPDGaRgNZA2T5azI6DiClJ7TiHtoHRiRiFofTvKPRbjPiII9zQlUxKRh6uwEPP2jeQiijOIBgEiw8DW7//1gWBaxjz9CrJs7u9B92LXU1rSI7CsqG1f2bTXhfJtrR+ha4TFWkxRhdyyHNIB84JvGiK5i1JHjZvTQahKWznrYdCS1GqAbq9ZuHbS6yTGM0W7n8PmHRait7Ka+Htd7AeldxyDi7Yh5bOiBp0VVUb7hiBlFBzc2lAIOhWixOhhivzCIxCyW3ZOONQ/lUH+myMrhk7fOwmIeuwkcGGKPRq9/kFgfrKxE/3nXyhQ0JfbLXdXoM2ic3qOgSC+5TAVOcrWTzrYBbHDy95BZdZjWsgOhujqoEuLhP3M6OI7DCYrBnxcrTLsa6kkDP+wsqv2VePK52YhLJlO8ANBY0oHTR0iHyRnU2VOgnppDrLd89rnL6EomlmJGJOnAHrvBSuweYzVJwUqliLyPUkg/fWZMgcq5lOjqROM5px632CcAkqBoYt1YT2cPeSmliKZ4gDR16IkGnuOxdUMxKi+RkSbDc0jrPIb4/mIwAAJmzYB3UiJ4nqcaK8d0ibG2mLhGEZ8jUFnPyovEQIAcHMi/RVuTBpveOw+bm4oggXNmQxlLNoM3bdjkMrpK8I9BiFeQYI0Hj5PNzmubioQcYs3YcBG8E9o7jQhQXj85WKOaPgM+/vcZmE3kga6wDCCvdRe8LBoAQ9MTGIZBeU8N+o3CNKeIFV0RrQUAzmqGqZlkXipH9TvKFRLkL0tClxPixb5tl1F8ttnt34Umw2Tq6ET3EdcTo+dRzpDi9jIMmG7cfDKPsZrECFm2BNIAykj5MaKrOTHTBAckAHTqe1yqKCsp0kvOjBUweT3ng3sq6TUqnkNGx2GED46wnqK+jlzq+5vROkiOlB+dTuN5fmh+lQOUDo3XRrMN1X16VIKDjWKw6qp6sOWTYvBuTNhlWJaqfKKvrYXmQrHz+xhGkL4chivxY3lEChipUI6HM+lhbqOzxBKj1BA50PD7Bkzo1ozd4H4rodeZ8fGbZ6AbILMEKnM/8lp3QWEbIqN4JSfBL28oK3GC8tllh6bDWzZSezY1XSZV1lVqwlGsbNKgEbxTg7Xjs1LUV7s3S847JRnqXDJKatn0uUtdyYygZPgpHMhaPIeTza6j9muBx1hNIDTW9uJy0QAaq/Xg7GMzo1iJBJEPUKKrM2ehq3OeDvBXqJERRI6uP+GCFUhN89SXOPWE6f1W9LThREHJuWac+IpyuPI80juPIUQ/YswDZs2AKmboEDneeJa4JS0oEUGqEUfC2tcGm9YhrciwUMRkCpaqm/vB8YAOQDU4aoR1uaQdh/eNLWIMAH7T8uGVlEisN2/a7DKKKYgmjVVdfxPaBkijDHxNxImhEHGc1K1kEhESIkllh8qGifsdsdns2PjOefR2k8xIpUWD3NbdkNlHjG3Mw+vBMAxsdhtOt5C1qDkOtUFa2tQx8gaG+hYBoBE8uikGi+N4bHrvPLo73YtyaH1Xpo4Ol9EVy7J0ooXHWH3zUV7ajvdfP4X6Cj0unRvAhrfPwe6GwQpZsphKU27Z/IXL+2hF9JPN550298mj0wGRkI1k1/XD2k1POdDSPNXNGtjc+J1uBRrrerH9M3qkmNp9EmE6ofGPXDvEtuM4Dico6bE50Q4pQMpBJI9MASsXqgmMjj51AGqdeM/H9lfjconznp5hMAyDyAfuI9YHyysw4GKESIRP6JVptaPhimhBk+dy1W9FTQU2Tszom+d57P78ElooDpccZkxt2wcpNxJt+aSnwTd7CgCgtLOcoP5LRRLkh08RrBkomYohpqUQlaO+Iw3g0Uv5jphNNmx466xTluJoeKckU2tXzZs2u4yu5lAcmvLuGvQabozD4TFWEwSFp5oE/66t7MZXO52P4xgGK5FQm0B7T56GsdX5YTYjcipEDs19/UYtKpw097ESGeRRacS6ob6Yen14oAreSgd6stWOhrYBp3u6VdD0GbDp3fPg7GSkkWyuQsSAMIrxm5YPr/ihgYXOahGzooSkFIOTepUjKhwiCw2A2Lxw6r63bChGe8vYdG//aflQxpA1x+ZNm13e52hwgaFUoLOITEmpW5nbqmE30vuPJlOquPBUIy5QakEyKYPspl2Q24TGKHLt/VciouOUjEV++BTIR42Ltw32wdrdRFznaKx6NEb0aIVjOZoYICqO7G3U9Bnx+UdFbmVpomjRVXsHek8514aMUUci3DuEWL9RSuweYzVBIJGSf4rTR+pcdsQPI2TJIkj9HR58nkfLF1uc3uMlU1Gb+1ylApUUL89YR49GGIZBSgz5AFVMMM/ZZrNj8weFVPpxUoQEkc0nwDGAWcJArxBB4yWGNT8N1aVnUVtWiONn90Bp5MCOMnQ5oenwko1ETLzdClNTGfH+jsaK43gqCaVgXjzmLUsi927lsPHdczDoXPe3MCyLyAfIVgdtSalLVYuC6HwwDv1THbpu1PWThyoASPxCIVY7HF48B2MDndJMo6/XtWphcpPxeLPQWNuLPV+Sfz9WxGAGUw4viwZ2BjDKWAyoRDAlRaKbNaPywilUlZ1HeWUh5GYOzKg6o2O/I62eKQ2OgdhL+AzRnp+4SF+se3Ia/APJqeINNb04uLtyzN/RJzUF6hwy1d/y+ZdOnROGYTCblqFxcYZcC9zXq5/gqK+vx86dO1FUVIS6ujpoNBrYbDZ4eXkhOjoa2dnZWLp0KaZPJ73FiYDZCxNRVdYJx+/Fto0lCAr1RrCT/gpgKLoKX3U3Gt59X7DeffgIoh9aBxmFhAEM1SUchWxPt1zAk7nrIGZJfTJFXA5wSDih2NRUBs5mASsmh/+lxvrhfLmQVVfe0IeVc+j9RLcC+7ddRpvDCBMWgwgKHATbXoSKeBVMMlYwerz+yFbB9cOPq0UM6BQsEsRAS+1lhEYnQiyRwtRSBd5B2JVVeEEWKhwn39qtg84oNJpyqQixYT6ID/dFV/sgKi4Ka0YDGhO2bLiA9d+eDsaFbmDg7JloCg+HqU3o/DR/9jnSf/5T6j3+SjXSg5NQ1iU0aKeaC6kjZ4AhwshA0V7BmrG+FF5ppEhuoHpokGR3/0idh+N4VLdokEWZOn0roBswYfOHRQ5DMO0QM71IjjahsbIExmQv2AQSYwMo//SfV/6V8fV/OQYwyBiYVRKIGzqhlXfBN2BI9ohGVqLNk6NFnqmx/lCqpHjoqel4++/HCcfr5KFaRMb4ITUrlLh3NCIfuA+aYqHR1NfVQ1NcAj9KmhAAZkfnYXPZTsFaTV8DOnXdBKP0WjHpI6u2tjZ873vfwx133IFXX30VJ06cQHt7O4xGI6xWK/r7+1FSUoIPPvgAjz76KFatWoUzZ26OSvB4EBXrh8V3kWk2q8WOz947P2Z/TciypYSqBW+zoW3rdqf35EdMgUQkHL0+aNbhUic9/SgNjaWKlppb6J4bzXOeSCSLSxdace7EEGlCxPRDKSqBr2Qv1NJ9sA6cQrfYDJNcJDBUriC1Af6DHDrOn8OWt/6It3/z/7B3wxuoPLUPNgcnRBGbBcbBIaAdRMnRfhCJWDAsg9XrcxASRjotNRXdOHmYLgc1DEYkQuT9a4j1/nPnXSqyz44iPedTTYVOvW1nRBxnoH5HJkgqkON4fPlJ8dd1HxskTAtUotPwk2yHj+QYOlrPYdBL7GConIPlAS8Tj4BeC07s2IAP//QTfPTnn+LYzg3oqComrlfE5RBrNAJK6tcZDP9AFe57NI/6dd36aTF6u13PNfPJSId3Ckm8av38S6f3RPqECXoJhzHWlOmrwaQ2VocOHcLKlStx8OBBt/szKioq8Pjjj+OVV165wbsbP2YtiEdolJxY7+3WY88WMg0xGmKlAqF3riDWO/buh3WAzgpSSORU4VJnRXSGYanSS86K6MnRfnB09rv6DOgfuHmjsJ2ht1uH7ZsKIWNr4SM+AF/JQchFNRAxYw8qdBdWixnVpWdxvKQUB/XeuGyWQccNPXK0Q512SI8mIUhlYqz71jQolBLiuoO7K9E0hkpI0Px5kAWT3m7rlm1O75kRmUMIl3Yb+lDT10C9Xh6bCThcb9N0wtpPZxGmxlJ0JCeIsTpxsAaN1XVQii7AT7IT3pIzkIlawTDXb/K1pqcDJcf34WgfcNygQoNFAhsPMCIJ5FGpgmstVjtqWzXEe4w2+PHJgVh4Rypxjdk0pAhvd6G/yDAMIu5dTaxrL17CYBWpvDIMKlnrBqQCJ62x2r9/P5577jno9XSBTYZhBJpso8HzPF577TX84Q9/uJFbHDcYhkH2TF+ofMgUXPHZZly60Ory/vCVd4KVCtNxnMmEjt17nN5TEEN+0c61ljgdykj3nOl1K4VMjNgwkp58q+tWOq0Wm/75FlT8DqjExRCzN16TzgYGDVYZjhq8cNaohJYyVZgWdaY61P3U/kqsWp9DXMdzPL74sAgGvfP6FSsWI/yelcR69+EjsPTRI14fuTcyg1OIdWees0iuok4Pdla3opEsKhv7b3lzcNGJszi//22opfshF9WBYW58HW2AE+GyRYFDem/UysJgNgtTx7UtWtgcSED+PjIE+SkEawULE5CcThIf2lu0OLjbNWnLf/o0KCJJhZvWL5xHV45kIgBo1LZe96GMk9JY1dTU4D//8z9hc5AEUavV+MEPfoDdu3ejtLQUpaWl2LdvH1544QUEBZEe5dtvv42dO3cS67cSYgmLvLl+kEhJg7Vz80X09xqc3ivx9UXIsiXEevvO3eAs9ENsamgGFGJhNGe0mlDqJBVIaw62dNTBrqcf+CkUz9mR8XazYDLqcWLXRrz/hxdhN5SAZVzNpRJCwjEICo9BdHIWkqbMQEBiMnp8WGhUDEwSULqhnKPHLsbWj/+Jre/8CR1NQ+k7ndGKZkpfTAolTZacHoJZC8i634DWhJ2bS10e9CFLFtPTxTucPwejVRaGcbq5yGmbw3hSgXHhvsRImQG9Be29t2akTEdTLb548w84ueMNSFjnepkEeB5KmRIR8amIS8tBYtY02MID0OfNYlDBwDIOdoAVDCq6NHj/Dz/Gyd2bYDYOPfM0Jy8lxp/ow2JYBqsfyoFfgJK4/tThOqcyYkP3sohYs5pY7z191im7OMQrCIn+scR6Wad7vYDuYtIZK57n8dOf/hQGg/DQzs7Oxvbt2/Hss88iPj4eUqkUEokEMTExePrpp7Ft2zYUFJBjmV9++WVoNJqbtHv34O0rwYrVGcS62WTDFx+7pqJGrL4HcIgorVotug7TG/ykYinyIkiW3yknnrPYJxCSANLzMjoZtkevW93cyMpus6H4+D58+Mef4MKxPeC5MbxknofSYENolwkJjXpkVg5i9dKHse75X+GeJ1/A8vXPoDczDJfjpShNkuFshhzHs2WwzcvG/HseRVL2DMjk5EHhiObqMmx+4zfY88nruHiZbOKOCFLBR0USVwBg0Z2piKSwLctLO1B63nkNSqRQIPSO5cR6x569sBno6hHTI3KINodeYz+qeuiyXrTeIGPDRfAU4yYWsUiMUhPrN9uhGejvwa6P/oHNb/wGbfXOh00OQ2TjoNZaEdluRGqtDnnNPB7/yZ+w5qmf4K7HfoB5DzyJs6FmXEqQ4kKKDKcz5TiVIUP2vQ9i+uJVCImKH7MWarNaUHR0Nz78009QcmIfKhpII+NMaV2ukODeR3Kpwzq3biiG3oVOZ9D8uaTuKM+jbZvz+vcciuKJm6VetzHpjNW2bdtQWipMO8XGxuLNN99EMGWg2DD8/f3xxhtvYOpUobSIRqPBm2++eUP2ei3ImR6F9GxSNbu1UYPjTmYrAYAsKAiBc8hpnm1btzsdrDabEsafa7s+qUBaTaL6Js4uaq65jE/+9nMc37kBZqNrbz0kKgGZAQnIrNIhpcGAsB4LfPR2qHz9BOPirXYrzrUKIwWeYTA7awGyZi3C8gefwbd+9nfc/eQLiFaJIRoj7qq5eA6FX/wJCaJysBiph9CiqmGIRCzuezQXcgVZv9r95SX0u4hMwlbeCUYivM+uN6Bz/37q9V4yFaaEkuQfZ2oF8ohkMBKhKjdn1MHSQTduNIem8iY5NFaLGWf2f4mP//LfqCtzTQoQS2VIzZmF5C4OWVU6xLUaEdRvhcLMIXzFMogUI+m4862lsDk4RUpvXxTkLcX0JavxwLO/wLd/9ncUzF0CXyfzzIZhMuhwbMcGiKs+hR8jNFi0z24YEdFqLLyDTOHqBs3Yvsl5BM5KJAi/525ivevgYVgH6H2SSxLmIsp3pB8wWBVAFUS+Fkw6Y/XOO+8Qa7/+9a+hVqvHvFcmk+HVV1+Fl0MaZMOGDRgcvHECjFcDhmGw8oEp8HXIRwPA0X1VLptBI1bdQ6wZW1rQX0Qf6zElNJ2aCnQ2zpzqOTsxVmEBZHRgvQmziwy6Aezf+Ca2vv1HaHudp3N4nkVAxFSs/8H/YPWjP4Ds7GVIHOoCYXffBXbU4V7SUQ6jVUgSUYjlyAkbiYZFYjHCQ0KQyfRhkWoQaVITlIwLA83ZkCiqxGzJwSsHkmO9yhG+fgqsfIAkvFjMdmz5pNhpBC5VqxG8aAGx3rZtp1O17VlRTlKBFAeIEUuGFE8c4Ow7Qu/Hu/GRVXPNZWz42y9w7uA22G3OU8IcvJC/6H48+dO/IF0ZAVWPTtB9xojFCLtLOBCVZshnRk4V1NEVKm/EKIACpR5zFTpEiS1gXDg2Cn4A0yUnkCkqhBRmiEUMVbJqNGYvSEBsItm6UlXWiZJzziPwkKWLBcYXGJpI3rF7L/V6qUiC3y35Cb4//XF8b9qj+NPyn0MpIc+ua8GkMlbFxcWoqBDWUnJycjBzJjnd1BmCgoLw0EPCKZkGgwG7du26Lnu8npArJLj34alEOM1xPLZ8cgE2K90j80pMgE8mmUZsc8L6kookyKelAp14zorodJLxpe2iMr6czS66UfRknudRVXwaH//lv1FZ7HwcO8+LYLQnwSt8PdY9+zwCQiPRuXc/OIeiNiuXI3T5UsHaaUqHfn7EFEgd2gCGD2cJA8RJLZin1CEvxBu+/s4zACpGj+mSE8gQXUBCGMkMdUR6djim5JPU4eaGfpw87FwfMmLVPUSextLTg95T9LaOaRHZEDlQ7ftNWlT00KN8ukNDr1vRZJca2gduWHOwzWJCzfmvsPXtP2Kg33n9xs57QWebhgX3/ydmLr0LUokMbdt2ENcFLZgPqf+IwdVbDFRHj2bwh78j3iIOWXITFip1SE9OhUhMRszDiBA1o0DyFbL8+yGVkLXt0WBYBmsemkplkO7dWgZtPz31K1apxl3/loqlmB83EwvjZwvUOa4XJpWxOnDgALF2zz1kFDEW7r2XlCeaiMYKAKLi/FGwiBQi7e7UuexMj1iziljTXrwEXS39AKMxes63lsJCSQWychVk4aSiwnhSgZU3wHM26gaw55PXsW/jv5ym/HgeMNtjoLEuBy/Nw72PFoBlGXBWK9p2kN+BkKVLIFaNKANY7VacayMPXdrn5/h5sAyQkj0DD7/wv1h47xNQepGMwGFEihpxcuOf0FLrXL9vGCtWZ1Aj8CN7q9DVTk/bKCLC4T+drDO0bd1GTQ+ppEqq4gnNcAOAkpIqNjVXgLOStRJ/HzmCHfY/3Bx8vdFUXYbifRvQ3eC8LsXxcuhsedBalyJpykxk5Q45A72nz8LcRU4/jlglTJnRUoBquQ9SA4UsSbtRB3O70NjLWR5z730Sj/zod0iZOttp4UfKWBCsPYw9n7wOo951VsjbV46VD5DOg9lkw9ZPnSv4h999F7X+Pdb4kBuFSWWsjh8/TqzNmzePcqVrxMXFISpKKNJZWFgIne769dhcT8xfloyQcPJgO320Do219Em2frlT6RRUJ9HVlNB0KBy8IaPNhNIO+mGpiKMobDc4MVa0yKrp+hqrhooSfPL3X6D2kvP+DisXgAHbYujt+eChwB33Zl455HuOnYC132FPLDv0wI5CaWcFNQU4xeEg553IDCnipoAViZAxbT4e+dH/YercFUSUOgydtg9b3vojju3YAJvVOSVdrpBg9UM5jpPlYbdz2LKh2Kkgcvgqsi6hq67BYAXdCZoVSRrkMy0XqKxASVA0RCphioq3W2FqobNMafW56xl926wWHN3+Mba98ydYTc4cGQZGezI01mWwcLHw9lXizvsyr7DtaAQDv/w8KKOFZwk9BZhLtNKYGsvgyCMV+4VC4hsMb3UAlq59Cuue+yVCo8lWgGHUXDyHDX/7ORorXU/pTZsShil55HnQUNOLcycaqPc4q3+3bt1+S1oLJo2xMhqNqKwUPkRBQUGE0XEXOTk5gn9brVZcvHhjxzJfLURiFqsfyoFI5PDn4ofkmGjqFgzLIpxSu+o9cRLmXtLASUUSTAsnveGTTjzn8TC+EqPUN6w52Ga14ui2j7Hj/b/BqKNHERwvgc6Wi0HbfNh5NQAgbUooMqcOFYR5J0yngFkzIA8RpuxoB1EeJQVo6WwEZxDuhxFLIYscKXhL5QoU3LkOSHsY/ZzzQnnJiX3Y9NrL6O103mcXEx+AWfNJOntH6wCOH6CLE/ukp0GVQB6EbVvpDk1+xBRqKrCqh4zWGYaBItb92iatPne9ou+ejmZs+sevUXqSzMwMw8oFQmtdCqM9C8DQ3/KeddlQfC3GPFhZRTXijgZfbzGgpJOSAoymRN4U587xuQoKj8Hd3/oJyrkcWHl6atCgG8D29/6CY9s/gc3qvPa2Yk0mfHzJ9NyBneXo66EbcGr9u7kFGif17xuJSWOsqquriWJuSgrJdHEXSUlkGquszLVKxK1ESJgPldnT32tw2ugXvGAeJL4O8kh2O9p37qZeP5OSyip0kgp0zvhqIK513hx8bYdRX2crPnv9ZZSecn4I2RAFrXUZLFwchkMPlZcUd96XdcVj1pZehL6e3Lfjg2q1W3G+lTxgqClASlQlj06jaihWdjI4a5uLy7YpsPH0hpy+zlZs+sevcenMIade7cIVKQgM8SLWjx2ophJyGIYhUlgA0HvmHEwdZP1RJVUiO4TGChyHQ1NPdwhpJItrbQ7meR4XTx/EZ6/9D/q66D1CrEgKvW0qBm3zwGFEyip/dgwSUkZ6M2m1KmVsDHyzhPPICtsuwu4wHdlP7ouUQEqjtJsjQerbB9Fki8Vx62J0ciRDeBglJ/fjs9f/B/1d9GZcuUKCu9eRDqnNymHbxhJqOtBp/ZvyedxoTBpjVVtLFnLj4uIoV7qHmBjKuO8mupr0zQJnt8Ok08Juo6d8Zs6PRySl/nP2WAM1HchKpQhdQfbUdO7dD7uJjGqyQ9PcTgUOycFQGF9OUoH0w+jq0zzlhceHoo0OOqNJplDBK2QpBizTwUP4O911/xSovEYMLe3B805NIXTSLnZWwGAVFqTlYhm1lkM9iCiRhsFkRWPHAAAGzVw8TlgXoo+jCw/bbVYc3vIB9nzyOswmsjlcLBFh1YM5hKAtx/HY9mkxVWonoGAW2VPDcdT6HUB3aE630BuEaQevpaMOdiNZY4mPUEPi0Bys0ZnR2ee8Cd4VzEYD9nzyOo5s/dAp0y8kKhla61KYuXiMzqGq/ZVYsnLEKJu7u9FzkiTrRKy6m2jIpUXeMyKnEpJVNm03rH2OBpQhhnECI06dBXIU26ajxJYPnpUR1wFAb0czNr32a1QUnaS+npAShPzZlLOvrs9pOpBGY9cUl8Bwk8/LSWOsOjtJ+nFICCkp4i5oihatra7ljG4kBvq68ekrL+HCng9xfse7OH94B9EXxbIMVj2YDTFFONNZOjD0zhVgxEJv3abToevQYeJaiZNU4OlmeshPTwW6T7K4msjKYjZh/6Z/46vNbzut40QnZyFn4ffR1EzW+bLyIgTq04aWVvSfJw8YWj2HFkHkhWcRKUDeboWpmTTwNGNV3aQRKO2boEKLz3IU3LkOrIgeZdVeOo+Nr/4KXa0NxGsR0WoULCK9+M72QRynTEFmxWKErbyLvH7/V7DpyNQQlRVo1FIbhMU+gZD4O87i4qkN5BIxi4SI6xN9dzbXYeOrv3Jav2RYEWKmzMGgbS6sNjItds+D2ZDKRj77th27AIdnUaJWI3DuHMGawWKksgBpBp4WecvC4iFSkELFwiZ6Bh1cJELnPo2oJDLiAYZ6xw589m8c2Pw2rBaS0LJkZRrU/iQh56tdFdR0oP+0PMjDSMX2tm03V/1n0hirnp4eYo1mcNxFIGW6bl/frdOsO/vV1iupCs5mxem9n2P7+38jmD4BQV5YeCcpVNnfa8AhCjtQqlYjaN5cYr1t205qk/DMqKnEmrMGYZqxMjWVg6NEhrQCenWzxq1pyMPo7WzFZ6//Dyov0L1GViTG3JXrsWDNMzi0l/T6vLxlhDJIOyWCkAUHI2CGsKHRZrfhfCuNBUjSkU2t9JEg0tBY4lqqhE6sP6bOXYG1z70Ev2D64MWBvm5sfuO3KD31FZEqm780GcEUdfZjB6rRQRl+GbpsCVi58NDmTCZ0HviKuFYlVWIKJRV42lmbwzh68mgU9spxkCx4nkfJyQP4/F//65SS7h8SgSmL18LMJaGlUUO8Pn1uLGITRiJbu9GIzv1kmjnszhWC3jtgKAXoyAL0pbAAAfdTgAC9dpeeHI17nngBBXc+6NSpqSg8js9eJ1OgUpkYd68lnVKrxU5NBzIUohEAdB0+Aqv2xutqDmPSGCuaIXFs7h0PVKPoyMPQ3sQP3hE6Lfn7NVVdxMZXf4n2RqHi8Yy5cYiiRCpnjtejqY58H5p4qamtjdok7KxB+CJFK1AaHO32yJChycEOJASrHQ1OqNWOqCg6gc9eexn9TmoPfkFhWPv9X2DK7KXY9XkZTEbSuN51f9aVgjkAWAcH0XXwEHFd2Mo7wYiE0cPFrgroKSnAHLdTgFlgKKw/V+K1gaFRWPv9l5A+bT5xDQBwdhuObvsIeze8AYtpZG8iMes6HejgIIi9vBCyeCHx/u07dlLHms+MJB2aMy3F9FQgRaXfOcni6qW5zKahtN+x7R+DczKKPWP6Ajzw7C/As76oKCG/d34BSixyUCzv/OoQ7HphKnIovb6MuP9UCxl5z4jMIViAPM/Ta5qUz6pXa0SPRvi9E7FDzcAMy2Lq3OV44NlfwDeAnmXq62zFZ6+9jMoLwjRmXFKg03Tg+ZONxHrwooUQOZyZvNWKjj37qD/3RmDSGCsTpcZCMzjuQqkktdsc9QZvJuLTyVQBAOi0/fjyzd+j6OjuKx40yzK4h5YO/JodaLUIH1ZVXCx8p5APAm3WlVQkQV44eS0tBeZsZAjtMBqaHDz++VZWixkHP38HBz57y2naLzW3AGuf+yUCw6JxqagVVZfJlHFWbgRSMoWpjM59B6hNwCFLFhH3037/3PAsSCmECSplnZIC5Hme6jWP/pwkUhkW3fsElq//HiQyeqNlzcVz2PiPX6OnfSSaDIv0RcFC0qPvaB3ACYpcV9jKO4meHnN3D3pPk03C0yKyqVqBNb0NxLXymEw4cupt/R2wasl+JVpds75tAGYnze/D6G5rxKZXf+007SeVKbDioWexcM3jEIulKD2jBUd5y7vXThGk/3i7He3byVRX0IJ5kPgKU5ZGqwkl7SRBayaF7m/tboZdrxGsMSIJ5JFkxoT2fMSF+0AuHdlnUHg01j3/SyTn0MURrBYz9m96E4e+fE/wDDlLBx7YWU4IZosUCoTSmoR37QHngoF4PTFpJgVbKF3TEonzLu+xIBaTv7qjivu1QKfTobDQ/QFkvFSNiJQ8tFaS93CcHSd3b0J58VkkTFsCiXTo0ErKUqH8gjBN2Nejx6fvH0V6rjDisaenAaXCQ1RbehHndu0G60DPDrKQtYPTTUWYJkqDiBFGHFLWF44uQ0/ZadT7kA+et5jslj9ZVINQOd17Ng72o/LUbhgH6K+zIjHips6HX2waSi9egslox9GdZPpHJmcRGmcT/D14ux3mLVuJa5nsLJQ4qKTYeQ6nG0ljFWzxJf/GNjPUrVWOLU+o1bPgHK7tHbBi0CD8XotFDPo6alDY5fgOImQsvB/Vp/dCryF/R21vJzb+42XE5cxFcFwGGIaBVyAPL18xdFrh9/rIvkpwbC+81cLnh01KBOcwt6jqk0/RKCeL+dGKcNQbhOSWLed3Y3EQeWB6+4ZCrBUy1CoO74AlkkxF+ShFGDCMWBI7x2PngTOICSb3wPM8OuvK0FByDDzN+gBQ+QUhecYKaC0sCgsL0VClR18XeZbEJCnRq21Eb+FIVGGvrIKVworsT4gj/u6XB2thddQCFMlhbB5AYYvwWlnDWTi6yhZ1BC6UkrW8oxc0xJqfwkY9W/wT8pAgUqK++Cg4O3mWlZ09gvrKMiTPXAGFtxoAkJKjwJmDwufSarHjk7ePY8YioaI7Hx015NCMSjtbNRqc//AjiLLpKczriUkTWVkp1lskci014go0Q3c9jdV4wTAMorNmIbVgJcRSOtOnv70BpQc2YrB36MGPS1FBHUD+HvWVevR3Cx9INikBjCPrC4D9DDloMU4ZCSkjfF8zZ0GDgUzB2SijAUTadjBWMhKODCSjkJZeerTU3VSJ0gObnBoqhbcfshY9gODYofoJz/O4dE4Lq4Wk32ZO84VUJvyqc+UVAGUopWg6Od+r0dAGEyeMwCSMGPFKssdP0tcExqGGZJf7glOoiWtpv3u4vwQiJ+PpFV5qZC68DyHxJGMMAHjOjrqiw6g+uw92qwUi0dB8NEfLyXNAyWmtw6h2QDSDVLTgW1rBtZDEo1Qvkolbqa+nUs2tlO+ImBKFAUBkgHvfEZvVguoz+1B/4bBTQxWakIXMBfdD7jXkfBl0NlQUk39zhUqE1Byyxmc/fZZYYxPiwVJq5ZU6kmCSrIolWIAA/Xe3BsTSfgU095C/e1Qg/XxgGAbBcenIXHQ/5F8bI0cYtD24+NVG9DQNje8IDJUhOpHMMvV2WtBUI4yuGF8fsOmkE2o7ffamNAlPmsjKkSIK4Jo+IDslr+1sWOPVwMvL66r6wAoLgSlLHkTrxePobCbTNRbDIMqOfImZy+5F3tw7EBOtx5t/OSakJfNAZbEJ3/3RdEhGaYe1P9CDun/+W/B+XNllZP3HDyBVC6Op07ZLxLTPXvkg1uaRhIKmi1/ANkoXkAGPFD8xVCnCa1ONVnx0eJeA/dY3aENiSiZ8v6aSW8wmHN3+MWoKSbWSYaTkzML81Y9BOiotVnahDZ0tpBeckROOu1YLUzE8z6N0wyY4uj/+M6YjbQmZ6jh3lmT25UdmY+a0GcR6z74SOFZD1Cn5SMonjeCZhhIAwjTPtMxo5OXRWV5Xrpk+A1UlZ3Doi/dgtZBOQW9zNWyGASxf/wzy8mLBW8px8pDwu6Tts8I8oMacxSNSXnxuLkqOnyR6znyqa5Di0HOWbE7B3q0nBHWqQZsevnEBSAoQGjKjvwTt9cKaiXKgBam5ucRz3TRYg8vNwnSa3q5E3qjvXVdrA/ZueAPaXjKVCAASmRyL7/sWErNGjC/P8fjwX6dht5Fnxn2P5CM+WWiAdHX1KGkkSTqpjzwEv1xhzc5kNeEv9e8T196duxxZIcLDnbfb0HDwL4RcbWLBHZCHC2XVrDYOnZvINOSKBbkIC3RdAplZMA+Hv/wAVSWnidfsNiuqz+6DmDNi3t0PIzODxRt/PIIBjfC7VFWqx6Jl+VD7jxizQS9vlP7nT4W/U2cXEqUyqCmlhvGgsrLSpYrQpImsaJEQzeC4C9q9Uinp1d0KyJTeuPe7/4WcOWSPFADwHIdTezZj27t/gUJhw/xlycQ1vd16HN4jJDoEL1xADt6zWtGxh1RSphXRz7YWw0bxYt1VKlApJIgKIT3Yqq+ll7rbmoZ6RJwYKpFYgoVrnsCStU8JDJVu0IxdX5B1IqWXFCvWkAf/YEUldNUkjTt8FUlEsXF2nKWyAOk1RndUCYZBr1e5VlofRnL2DKx97iUEhJIitsBQWnDzG7/BhWN7MH9pIgKDSTLSkb1V6O4YiTQYhkEYhfXVc+IUzN3C1KO3zAtZIaQzRqvtyaJSwTjU9ux6LazdFGNAlV0aag7mOQ5FR3dj8xu/cWqoAsOisO65XwoMFQAUnm5CQw3Zi5g3K5owVAC9904RGQn11Bxivaj9EsGW9ZZ5IT2IFB4wt9WAd3AwWLkKslAyUm1o18Li0Bvno5IilDJU0RFSmQJL130XC1Y/BhGl5AEA5eePYdNrL2Owv52qHWgx24lRIt4pyfCmOOE3o0l40hgrmYwMfR3HPo8HtHsnirEChkZMzLnrQdz56PNOB/k115Th07+/hNBgDcKjKHWmI3VoGXUgiuRyqpJyx649hJLy1LBMyETCz0NvMeBSJ8n0G49OYEo0ZWBgQy+Kju7GZ6+/DE03GR0BgDowFA88+wtkTJ8vzKPzPHZ9fhFGA5kmvmNNpqD5dxg0YokqIR4+6SSz73JXFXQWYe+JVCQRjAMZhk3XD2t3M7FOI6GYzDYqE9LVDCtH+AWF4f7v/Rzp0+j6mJzdjhO7NmL3x69g6d2xhCaq3c5h66fCUSJB8+ZC4jhuh+Ooqic08sCZ5iIi48GKpZBHkgecgeLQJET6QiwSbrRvwISm5g5se/cvOLl7kwu233zc/72fQx0oJNJo+gw4sIOMjn39FILm32FY+vvRc4x0mMLvuYua4aEZ6OkROUQ/GkB34uQxmWAo19IGUKZSJgM7A8MwyJyxEPd/7+fwDaAr/fd3tWHTa/+Dwe4LyJlGOj711T0oOi10KmhOXf/5Qhjb6Ezd64VJY6x8fcnDWK+/+tHXtHu9vUmv/1YjPj0X6/7fr4cmi1JgMuiw55PXEBZYDpFI+BDzPLDt0xJYR7Gpwu4iadlWrRbdR4UPp0wsRS6FFUjrp1FQGF/W3jbYBkhP1rGXRg4Dus9+7PIQSvo6iggMI2tEZRfaUHGRNHCpWaHU4ZWmzk70niFrEeH3kGoEgBMWYFgW5GLSCNIOImkwKegKANUtGqJmFOyngL/P+EYrDLEFn8TStU9B4qTW2VR9CYc3/wnp6WT9o61ZixOjUoSsREKfJLxvPzFJeFpkDlGT6Tb0obaPpD5Te/IorEmpRIR4QXMwjzC2GbveehnNNXQ5NIlUjmUPPoOFa56AWCJ0sHiO/7phnvxurXxgCmRyMmPTvnM3eIf6tdjbG0ELyBYCk82MC+0kMWJckTclMwHQafvJMWrqta4QFB6Dtc/9EklT6MMQObsNJ3Z9CtvAXvh4k5/T/u2XoRmlJBIwcwZkwQ7RKM+jjcKcvJ6YNMbKz4/0yK+lL4p2L61ReCLAxy8Q9z79U0ydd4fTa+rLTiFQeRBiRkjb7unSCZqFZYEBCCiYRdzfto1UUqY9cGdbS4hUoEjpAykljUF7MEfSXDyi2HoUSA5CZqZrmYklUiy670ksW/c0pDKSYqsbMGH3l+RBoVRJcdco7b/RaNtOqhFI/f0RSPlM7JwdZ1uLiXVa4zTgLAVIMt4AuqK4q6mvYyFl6uwr9H0azEY92qu3w19VCAbCNNSRfVXoHNUsHHbHcuok4a6vDgrWfGReyAgmU9CnKf1G1FRxYxl4CmttOLqUwoxs8TlMERfCTiHsAEMH8brnf4nkbLJ+CADnTjRQ039RCQqB9t8w7GYzNS0eumIZRJTsTlHbJUI701uqon4unMUIU2sVsT6eNPHVfkdkcuWQQb+XNOjDaKuvgIzbDRlbh9Fq8BazsFmYEYmIYZMA0PXVIdhu4OSKSWOswsJIL7m7m96l7g5o905UYwUAIpEYBXesxd1PvOB0DpLVPAAfyXGoROfBYCTNefpoHRpGaQfStL4MjU3QFAtrM7RUoM6id5IKdK9uFRXsjQCZEdPEx5EuLoGYoTMwA0KjsPa5XyI9f55Tcs2OzfT03533ZULlTR4sNr0eXRRVhrC77iDUCADgcnc1Bs3Ch08ikiA3jGTj8Tzvth4gcG31KmfwCwrDA8/+HNkFZMPqFVgb4CvZDynbiOEDibPz2LphRDtQ4uuL4IVkFEFrEqY5NKcpqUBpaBxYuWO91ARzm5AqDwDJUWpEsI2YIzmAUNZ5ailn7nLc/72fEWm/YfR263BgJyl/JFeySJtKf4a6Dh6CbVD4N2fEYoTdSXcUafO8pkXSU4CmpstwbPAS+QRC4k+ebf2DJkIXkWWAZEoa3V0wDIOMafPxwPdfgn8IOS4EAOxWM1TiC/AWHwOLkXqm4yiRkKWLSdUTs/mGNglPGmNFGwXSdg05UpoOYHQ03SudSIhJycKDP/gfxKbSPXYAkIka4SvZBxlbD4Afahb+tBhm09DB7p2UCJ90MlfvOElYJpZiajh5MFNTgbTm4IaLgkPLajHjzP4vkMfvhz9Ln8MFYEhq6Pu/gL8TqSEAKD7bjKoysvk3PTsM6dn0+zoPfAW7UZjKYmUyhDhMAh7GqSby95wamkGdgmrtbYV90CFaYsXU8e48z6OSMs+LJjc0XojEEsxduR4rH/+hU6eGZSzwEp+Ht/gYRMxQhqGjbQBH948YjvC7KaonHZ3oOytkiE6LyCaciS59L+r7hXUOhhVBEUt+lwx1Qgept6MFnWc+RKb4AiQMvdlU6eWDu598AXPufNDpRF2O47FlQzFsVlJVI3umGhIpefTxHEefBDxvjmAS8DBMNjOK2slUptMUoFNlE9IZo9WrYsJ8oJBdO4E7ICQCa7//S5dOjYTthq/kABSiMgBDDuWBHeXo6Rwy5GKVito837Zj1w1rEp40xoo20qO+nuxtcBcNDQ1u/YyJCKWXD+567AdYsPoxp3UKlrFAJS6Cj/gQxEwXNH1G7Ns6UmSmCbVqikugbxDWG9xNBcqj0gAHjTK7rh/WnmbwHIfKC6fw8V9+isLDO8CArgfo5euH1d/5MQruXOdyrHdfjx57tpD1C6WXFHfcS+9B4mw2qvBm8KIFkFBqlXbOjjMtpBwVTZQUcFI4j0wBKyUNW2efAZpBh74tMYu4cLK2dbWITc3G+h/+BgmZJGX+ys9ku+EjPgCl6AIYmHH8q2o01w8ZXGV0FPzyyHRnq8OsK1+5DzKCyJQXbQ4aNRX4derUoBvAoS/fx6evvITuZjLaGkZi1jSs/+FvEZPsmiZ94mANWinaf9MKYhAY6qSP8XwhTG1kSpr2rADAhXYyBeglVSEjmN6yMj6m6PVNEztCLBlyau751otQ+aip1zAMB4Wo4utIvAk2mx1bNly4ItdFnSTshJxyPTBpjFVYWBiRpisvLydmXLkL2qDF1FSy4W2iYpjps/4H/4OIeOf7FrP98JEcg5f4OErPlaLy0hAZwX9aPl1J2YEpNzUsk1AV11n0KOsSpgJZiYyQi+F5oOrkHnz66i+xf9Ob0GmdSyv1SRKx/oe/QWQCGYmMxrDH7CgpBQAr78+isv8AoPfEKVgcxZAZhhpBAEBZVxUGHViAEpEE+RTSCXDtlPXESHJExrVCofLGioeexdK134VMQe/LYRhALqqDr2QP5GwZvvz4DMymIU+ali4eLK/AYKWw7kIz4KeaC4lUoCKezAYMtlTj9O5N+OhP/4Wys4ed9k5aeAkCstdgxUPPQqFyrQna2tSPI3vJ2pBfgBKL7yIzClfuo7BEfbOnQBUbS72ezgLMhpiSArTp+mHpIqn6ihj694kms3StaWIaopMy8NAPf4u0fFLsehgixgAv8Tn4iL9Cd0sFju4f+mzloaEImEnWClu3bLshTcKTxlgBEDQGAkNafpcukQX2sWA0GgljFRoaivh4OuNuIsPHPwirv/1jLFj9GJWEMAwp2wlfyUHs+eRvqCy+MDSynXIYdR89BkvfyIMiF8uorEBaimw4FWjngRarBCeMKhw+fcrpzCkAMPBKnLPOxjl9Jizc2CmOEwdr0EJJkeRMi0JqFn0wHc/zaP2SlFbyn54PRQQ9ZXiSkurMDcukpgB5zg5jIxnpOTNWVKX1G3AQAV9rMk6dhYdf+F8kOSEhAADL2KAQVYDRfYGNb7yJQU0vfLOnQBlDpsYdP8sZkTlEKqtb30uwAsXqEIh9hyjURo5BhVmGQzoVzh/dDYuZlOIaRps9EiesS9BsdZ4WHobFbMOXH18gmJZggFXrcwTaf6Ohq6nFwCXyb0gbTgl8zQJso7AAo8mmeYCuFykJiobYm/y72+wcqps1xPr1SBPTIFMosfi+b+GeJ38EbzV9lhoAiFktvCUnUXL4Xzi5dx/sNhsiVpOThGn17+uBSWWsFixYQKzt379/3O9z5MgRos9qzpw5Tq6e+GBYFpkzFuLhH/0OKTkkq200RHwn9m98BZ/89WdolVnAqR2K3jYb2ncKx2a4kwrkeR4G7zBUmGU4bPBCqVmBAc65HBYHFrX2ZJywLkIfP3SAjTXGvLm+D4cpHrPaX4nlq52rPgxNAiZTxhFrVlOvt3F2nG0pJtZp40AAwNxeC97sIE0jU0IWRgrJAjfPax4NpZcPlj/4DO5+4j/g4+98tA7D2DDQdQ7v/+HH2PXhK8DsqeAcSiq9p8/A2D6SLvOV+yCTkvpyNPic3YY+nyicMypwyOCFOqsMdkJFcQQGXonz1tm4aM+HBTK3FNj3bilDXw8pSF2wMAHRcc4P+5YvthBriqhIqHPpzM+itksw24WtAC5TgPXk4a104sw0tA3A4iDe662UInwM1YprRXRyJh76j98ib8FKsC6k7MSMBkWHN+D937+Ii/UlYNPI77lj/ft6YNLILQHA4sWLIZPJBIZm8+bNeOaZZ8alwP7++6Q0ypo1a67LHm8lVN6+WLruu0ibNg8ndm5Ad5vzSZ793e04feBLIJyFSq2Et84GH70dCqMdHXv2IeK+eyFWDkVqw6nA0fl5nUWP4uZSBJlEaK2rQENlKfo6WwHQ03CjEZOSjTomGzWlwqbYisY+5KfRRx0YDRZ88fEFcvQ2A6xenwOZ3PlXuZXy4HinJMM7lX6wXOqspDYC51LIJoCTwnlMBrXR02y1o76VbJu4nvUIV4hJmYKH/+O3KDmxH+cObYfVTKeEg+dRX16MegBsig98Bq3w1dmgMtggtfJo27INCd97+srls6LyiDEyp5rOY2XEbHQ116OhohiNVRe//nmuBailMgVy5t2F/91tgZ0f8ae7+43o1RoR4EvPIFwuacOFs2RTdniULxYsdy59ZmzvQO8pUpbIWe8dAJxsJhXenaUAeZ6HsW4cbQ1OIm93m4GvBRKpDLOW34fU3AIc3/EJGqvIiHAYBp0WRUd2AQwgj1fBR2eDt94GlcF+pf6tiiXHkFwtJpWx8vX1xZ133okvv/zyylpfXx/++Mc/4le/+pVb77Fp0yYUFQlzzcnJycinaLdNVkTGp2Lt93+JqtIzOLX3C+g05ODK0dArxdArxegAAJ6H3Myh7bXfIiA1DTKFCjK5Avl6P7T2t0JsB+QWHkoTj9PFr4xrX6ExiZi57D5Exqdi7+kGHCgVepuVlPTe0JZ4bN9UCm0/mSoqWJSI6HjnB72+oREaytyuiDWrnD78tNHkueH0RmDA/RH2AFDTrIHdweAG+soRqHaewr3eEIklyJ1/J1JyC3Duq60oO3sUPO9cuoxjAY2vBBrfISMjsnGoqTyJ6o9s8A0KgVSmgNJuQVSXHSIbB5mVh8wKqIwd+OTUf7u9L1YkQsa0+Zi2eBWUXj6ILTmM2hahYa9o7EfBFPKz6uvRY/sm8u8gkYqw5uGpELmoB7Zt3UZOAvZTI3gBXRnEYDVSU4Czo+lniLWnBXade0xRwFl/1Y2NvB3hFxSKu598AS11FTi15zN0Nte5vN4kF8EkF6ErUAaG4xHaY4b2Utnta6wA4JlnnsH27dsFCukbNmxAVFQUvv3tb7u899ixY3j55ZeJ9R/+8IfXe5u3HAzLIiVnFhIzp+Hort0oPbkPIsaNhj2GgUkuQmtfK1pPjtD7xQCu9mvnL5dg9rrvIyZlyhUDQZMVqmzqh53jCdXx8ycaqSoVETFqLFhOMtFGg1arkoeGwn86qTAODGsBFhPrs52kADmLCSbKsEkamQAAymnNwDeoFjEWVN6+WLD6MeTOvwufvfkeDP2XwTBjE5bsYhY6MVBTJowuyLZw98CCR3JyGmbe+xS8fEc+i7QYf9JYNfShYIqwdmW12vHZ+4VXiCGjsXxVBgKCnBMyLBotur4iB3CG370SrBP5tfOtpcQ4EGcN0gCdfOOMKQrQI6ubFXk7IjI+Ffd/7+e4ePY0Dm35HCI4bzkZBs8yaA+Wo9esxdhVRvcxqWpWABAbG4snnniCWP/DH/6A//qv/6JOFDabzXjjjTfwzDPPEKNG5s2bh8WLF9+o7d5yiMRiLLznbqTNfhqD1pmwcjen8ZkBjzCxFbMVesyU9CMqNlEQyUSFeBM9I0azDS2dwhEOTfV92LuNLHzLFRLc90guRCLnX2FTZxe6jx4j1sNX3U1ITg3jYmc59BZhzUMmkmIqpREYAExNZYDDwSXy9ofEn/6YUpUrbpGxGoaPXwAeev55cMo1MNjSYedvTpQnZzgkS01YqNRhir9cYKgAIIXyudA+v71bygQKHMNIzQrF1Blkf+ZotO/cRehiihQKhC533oNEI9/MjMylNgIDgLGOrFc5I99oBs3o6CWbgZOi1U73c6PBMAymzJiFJWtfwIB1ASxcBHh+7JSk1Z/e53e1mHSRFQD84Ac/QFFREZHO+/LLL7Fz507Mnz8f8fHxkEgkaG5uxuHDh6nySmFhYfj9739/s7Z9S7H4znQ01fWjrTkCLHSQsk2QiZogYq5eX5GG0JhEBGkbEWzpg4z9Ot3FA6aGS1CljrDRRCyDlGg/FFcLlUQqGvsQEzb0JR/UmrD5/UJwdpIGe/faKYLRBTS0frmVSO+IfXwQTBnhPowTjWQtIi88CzLKRGCAbGoFAEUcyY4DhtKZdK/55qZ4aFAopbjv8QK89xoDkzUFEqYDUrYFErYDrJPm3KuBVK5AZEQU/FuLESSyXRHXNdYPqXuP/tzSKMaqpkULq80OiXjIMBSfbSaEVoEhmvo968iG5dGwG43o2LWHWA9dsQxiL3oNXGfRo6SDFMWd7YQFyNttMDbRmKLu16uiQ32gpGgY3mxkTA1HXVUOLpwNAAMTpGwLZGwzxCyd+BKecH1bgSalsZJKpfj3v/+Np556ijBYFovFLYZgWFgY3n33Xfj731qv9mZBJGZx/2N5+Pdfj8Fo8IKJS4eJSwMLHSRsFyJDtBjsqIVNMr5g2yRlkJUxEzGJGYiIT4W3OgDdu/6FwQtC2RVjfYnAWAFDRWPCWDX0Y/nMWNhsdmx6/zx0Ds2zAJA/OwZpU+g09WFY+vrRSZFWCr9nJVXjDQAsNgs9BeikFgE4YXk5SQF29Bqg1Qm9eImYRXyE2un730xExvhhyco07Nt6GVY+HFZ7OGDnIGa64a3sg5pvwoBlELyT4ZA02FlA7K9GdtoMxCRPQXhcMhjOjsY/P47RZTK7XgNLVyNkIbFX1oL9FPDzlqF/1HfAZudQ26JFaqw/mur6sGMzmWITiVk88Hge5ArXB3zH3v2Elh0jFlPHpAzjbEsJ7A4N8X5yX6QGJlKvN7VW0UeChNHbZGiR441mio4HK9ZkorVZg652wMwlwswlgoEBErYbEeEmsHwvGJZF7rw7ERpNZ8NeLSalsQKGhhu+9dZb+OMf/4iNGzeOqzl49uzZ+N3vfofQULqm2DcVan8l7n0kFx//+8zXsnAMOHjDzHmjsYfFHKkCfMUZmGQszFIWdpYBG+QPvzmzIZJIIBKLsaX6AAZZG4wyBkYZA7uIweyZeUgd5Vkq4qcQxspAOdRp6a/yhr6vx35coioQRMSosWyV68Zh4GthXoeUr0ipRNgdK5zeU9R+CSab0DgqJHLqOBAAsA30wNrj2EPGjKu/6kY0A18LZsyNQ2NtLyovDUtZsbDxIejXh8ArchqyjrwGixSwSFhYxQysEhY+U7Ohio8DeB6thm4c7yqBWcLALGFgkDPwlovx9IoHRphyoiFygaOhN9YVC4wVwzBIjfXHqYtCVYnyhj6EeMuw6b3z1Kj7jjUZCBUot5PgrVZqPTNowTzIApz3Gp2isABnRuU6Hdw6npEgAL2t4VbVq2iQSEVY+0Q+3vrbcZiMQ88XDyUsXAzqW4DVD+VgSh59xtq1YuI8JVcBlUqFX/3qV9i8eTNWrlzpcsQHwzCYPn06XnnlFbz77ru3naEaRkJKEBauIGm8NiuHM0wGrIwKXgY7AjRWBPdZEFjZgayINBTcsRYzl96L2PxZ6PYTQadkYf967pDjRGFFTBbgMDrC1t8Bq0Y4MI+W/mrt1mHfjnIUUyjIXt4yrH08H2Kx8x4QALAODqJ9N6mcHXbnCqfpHQA43niOWJsRMZVQ8BgGLQUoDY2HSEnP1dPIFbRU160EwzBY9WAOAkNIUkJziw6NmasgN3Pw1dkQqLEirNsM/+J6zFp6LwruXIeVq76N3mAF+n1EMChYgGEwaNbhYqdQUJZGQKFFqbSDuryuB5++fQ4GPTnyZEp+JKbOGFvj015UDKtGI1xkGKe9dwAwYBrERYqIc4HLyJs0VkonKUCrjUM1RTMy3UV/2K2Af6AKax7OcZwKBADYtrEE9dWu2cdXi0kbWY1GRkYG/vznP8NqtaKkpATt7e3o6emBxWKBj48PwsPDMXXqVPj4XN+C32TFnEWJaGvSoNJBCNZo4lAacydy67dAwo0cBE2fboI6dyoYhsHs6HwcrD8puO9C+yUYLEYopUOFeZHCC7KwBEJR21hfAsnUEdFYL6UUUSHeaB5FqggCgzOHSZosK2LwwON58PYde95T+87d4EwOqRepFGFOpJUAwGAxUucSzYmhswaB8aUAATo1PzV24qR4hiFXSPDgt6YJvOdh1BvV4P1zkdA3kn43d3Wj5+gxBC9aCKVEgbzwLEKN/ETjeQFJhVazMTWVg7OawUpG0rSOnw8LYLCiBzYK0z4y1g8r76cLw44Gb7PBdpLsqwqcMxvKSLoaOTBErOB4YQYnUOmPpAA6D9Ju1FFV5Z1F3vVt9MnAY42wvxVISgvB/GXJhKwVZ+ex6b3zeOK52QgJu77n7aSOrBwhkUiQn5+Pu+++G08++SSefvpprF+/HvPnz/cYqlFgWAZrHp6K0AjyM9ExKhSHL4ONHYkmdFXV0FwoBgBkBCfDRyb0uq2cjRB9pY4MqSsm1kZHFmoAMU4UDe5Yk4koNzxMm06Htm2kxlvI0iWQqp2nhs62FhN0ZF+Zt1M6Ms/ZqcbK2UFkMFnR0H7rmoHHC/9AFe5/LA8MpT7V4J+NRrWQHdn82RdXxofMiSYN/NnWYphtIw6QNDgGIpVacA1vtw6N0RiFxEj1lcnBDIAEsFBQDJWvnwLrnsiHWOI66gYAe3EpMDhIrEc+cL/L+441kkM7Z0fnOTWOxoZSwMG4idUhEPvRszrOIu+b0Qx8NZi3JIk64NRssmHDW2dhMdPH/1wtvlHGygP3IZWJsf7b0+GjJiOVAXkQLoQvg40ZMVjNn24Cz/MQsSKq7JDjg6yIzyGuMdSXEsP2ho2VH4YOIoZirAoWJyJvlntdXq1bt8Oud5A+EokQsYbUMBsNWgpwVlSeUzqyuaMenNGhOE8R8x1GdbMGjuIbIf5K+I1zMvDNRHxyIFasotfragKnodVnxJCb2trQ/bXa9tSwDCglQvq7yWZGYduIGgLDMNTviKNDI5WIkPA1ASUeLNSU74dUJsKD355GnWHmCM5qhe3ESWI9YNZMqCg6iMPo0HWjupeU7JobQ5++CwDG2mJiTRlPZ4oCQHn9xGtrcAWGZbB6fQ7ViRzQmHCxiBzDdC3wGKvbGN6+cqz/znSquOeAPBgXIkYirMHKqivilLQHtKyrCr2GUQK4EclgZEJqOW82EGmRtDh/+INBAliwlIMoOz8Si+5wLpUzGtaBAeo8ouAliyALcq6HpzEN4GJXBbFeEOOiFkGJEuXRGWCcjDa53pOBbxamzYnFnMV0pltFcIEgwmresBGczQaJSIIZkaSm3vEmoUNAq1vRiDgpUWokgIU/5fvBihjc92ie2ymnroOHAC3ZkxW51nVUdZwSVUX7RiBGTScT8DwPA+U7okigaw3yPD8papqOEEtEePBb+QgMJmucNPLLtcBjrG5zhIT5YN2T+RBTGGkD8mCcj7gLRvHQF7F5w0bwPI+kgDiEeAkPfx48Tow6jBiRmDqQ0eDgbbZX9yDeSUSVkBqElWunuJ0Gaf1yK1GrYsRiRI2R3jnVRI6zCFIFIDnAuQr/eOtVNJZX2gSsV9Gw8I4U5M+mR7Y1gdNQHTANPIaGM3YdOAiAXuu70H5JoLlIk6SydjfDNjCikmDQW2Co6qUaKoYB7n14KpLSgt36PexmM5o//YxY958+DV7xzvU3eJ6npgBd1TOtPc2wDzqoPbAiKGLozeXd/Ub0DQi/u2IRg8QotdOfMVGgUErx0FPT4es3Ek17ecuQmXs99Ss8xsoDAHFJgVj3rWlU/TS9zA/nIldCIw/GYGUV+s6cBcMw1OjqWIPwgVZS0zxDtS2bzY4dn5Vi1+eXqFUqVYACDzyW51KhYjQsGg3ad+4m1kOXL4UsyLVqx5EGstheEJ3v1EhyZqMTiaUc+vUcT++fmeBe8zAYhsEdazKROZV++DT5ZeJSyALYGAmaN30Gu9mMjKBkqOXCaMfO2XG6eaS2KfZSQxpCGolhR6CvR4/3/nES2m564/od92U5nQpNQ/vO3bBQFG7Giqrq+pvQPthFrLsyVrSoSh6ZCtbJGJ/LlO9HQoQaMjdqcBMBan8lnv7RPCxfnYGl96TjmR/Ph0JJb6S/WniMlQcAhijt657Mpxosq1iBoogVaFRnoOGDj8Db7VRj1ahtRaNmpO9IkZBDXGNur0Nfayfee+0UVXkAALTgYQn3djp7iIaWzV+Acxj7wkqliLz/Ppf3NWvbUNdP7oNGEhiGseEi4NAYKvIOgCSAziRr7hqEzoFVJ5OKEHed2VI3EgzLYNX6HGTk0I1Dl3cczkbfgx4di449e8GyLLWZ+qiDY0BLBepri3HhTBP+9eej6Omi61k2gIMk0LWCyWjYdDq0bP6CWA+YNRPeSfQ05zCONZwh1tKDkhCodO5s0NLESsrzMAyaM5M2wSjrY0GukGDG3DjMmh8Pper6GirAY6w8GIXE1GCsezIfEillzAEjQk3gdBxjclH+5X6EeQcjyT+WuO7YKKKCxDdYcIDbeRZlxkz865VzaGvSUPfQDx7V4FDR2O/2tFFjWxs6KH1VoXcsh9TfdaqNFlXF+UUhWu2cwmyoJSfEKuOdS/tcphXOY/zcjhonCkQiFvc+PBXTCmKprxslPjgfeRcO766Avn8A8ygOTUVPLTpGRSmO0bfersKeQiW2byqlToPmwKMWHLpBr/E4Q+uXW2HXO0RoLIvoR9a7vM/O2XGCogXoiljBWc0wNZKSTM4ib2BiCRxPVEyup8WDG47E1GA8+XwBlSUIDDEFPz9pwZaPCpHnTXrOxxvPCnpRFPE5sPMi1JvjsVO7CheM+bA6YbR2g0MtOPAA+gZM6NY4nx47Gg3vfQjeJnxTViZDxL2uZ5RxHEekLgFgfuxMp/fwPA9DLTlyRJFIDqgcRnk9qVSdFutcJWEig2EZrFiTgQUrnFD6GRa1qnS89n+H0XOZQ5SKjMQOj3IQ5JGpYCRyGDgFzupnYqv2PjSZ6KQFG3hUgUPfkPwKLteNrQAODElv0Yg3IYsXQRnpWm2htLMcWpOQkCFmxZhJGUg6DFPTZfB2B/UUlRrSUeoco2E029DQRmtrmBw1zZuFb0RTsAfXF6HhPvjOD+Zg43vnqZJHPMOi9EI7cAGI856JQd9uGLz7YFIMol8/gIvtFYiURKOzbQC1bXEo06yDhXdOK2ZFDPQ+MjT0Cz3f8vo+BPu5TvVoL15C3xnS4ETcu9plXxUAlHZWoN8kPCREDOsyBWjtboZ9wKFDnxVB6WR+FUCPrCaaKsF4wDAM5i1Nhl+ACjs3l8JiJiMgk43Fni/L4CeZCt47GAP+HTDLdbDKjDhSfxp3xSyFXmdFY20vLpnuRptWCd6F7+zlK8dprR6j3ZeKxj7Y7dyYEWrjhx8RyuoQiRD14Noxf9dDdaeItdywTKikzr+XVBZgfDYYhr7PqsZ+oq0h2F/pdMjk7QqPsfKACi8fOR7/3iwc2FmOs8fqQdVWAaAaDIBqUBglbD1fB2C0CoVzQ+XtK8cDj+dhT3ErLh2tFbxW3tCH+bnOPV/ebkf9O+8R61J/f0Ssdt1XBQBHGsiDaGp4FnzkzmW7aClAeVQqWDldZaBXa0RnHznyYSKJk14tsnIjEB7li83vnkVnJzlKHgA4K6Dui4C6byStyoPHX4+MFhl2Pm8KAHKmR2HJ3ek4+9t9wKiZVUazHQ3tA0iIVDu9d6C8Al0HDxProun5kAW6jm4HTIM410ayPhfEzXJ5n5EWebtKAVI0I9M9KUACnjSgB04hloiwYnUm1q9PhdJCpimuBQx4TCuIxTMvzkNkjB+1mExrkhyNrsNHoK8jGzVjHn0YIrnrZluDxYizrZSDyEUKEHBSr0pwnhKiRVVxEb4TYuTD9UBAkBe+/cJ8ZIaYwbiYNjwatDYFGhQKMR54PA/3rMuGUilxKnzsDLzdjro33yJfkMshLnBtcIChRndHhXW13AdTnQgbA4C1vwPWXrIZ1pkeIEBPZ3rqVSQ8xsqDMZGUn4RVmSbE9xZBYjeNfcMYCBJ3YFVSCe64N/MKvZXmSda3a6E30mcpWQcG0fj+h8S6KiEBQU7GkY/GqeZCWB3qCt5SFXKdDFkEAM5sgKmZbB52Zaxoh2l63OSsVzmDWCzCqv93F+YNHETIYO3YN4wBCSzIkl/AE6skglEwNIeG5gwMo2PfAaozI140H4zSdXqZ53kcqicj73mxM52qmgCAoYZ0ZmRhiRCp6Clpu52jqvFP5jTxjYLHWHngFuIefhDJfCMKGjYhpeskFBZSBcAVRLAhXlqNZd67sMx7N7x6i2E3jLyHn4+cEOzkeeeec/3b78JKUSKI+/YTYJyMaxiNA3XHibWC6GkQi5xnxo31pXTKepDzabSXqeSKb95BJJLLkf7o/cjsPIrpTVsRNlAFsZ2cReYKSlaPTHkJVqs3I1tZDK5JmE6jGfnL9b1U1qh1YABNH31CrKvi4iDKpatIjEZdfxOatGSEtHCMFKChhhwhokyiD2YEgPq2ARgdan4quRjRoZOnreFmwVOz8sAtiL1UiH3ycVT/9e+IHKhExEAldFJ/9CtCoY/PRqOZB2sXg+FYsLwIdpEVYRFqxEYHISxKDdXpP4HVjh77wcNQWwTvrAVXVjLiAtDeIyRZlNX1Ij8tRLDWX3QB3YePEHsMKJgF34yxZ13V9zejtq+RWF8QN1YKkKxFKBNznVLWDSYr6lvJ9Ok31WsOnDcH7bt2AxWVSO86AQ6n0KcMR493DHqjojFg4CCxyMGAhV1kBSPjEB8ejpiEAMT46WDf+1uM/igN9SXg7TYwXzsQSVFDora2UTI+vVoTuvuNCHaYGl3373eIwYoAEP/0d1BtGHs69qE6Uj8wJSAeET7ORwtxFiOMjeRUYGWic9muMpozExcA0TgGXN4u8BgrD9xG0Py56DrwFbQXh1QnvC198Lb0gblYhd77UlEo+rp/hgfAAFEJ87Aif2iEfG9/NrQOM6oM1YVCYxXvjwPnhA26ZQ75fLvRiNrX/0nsTaRSIf6pb7v1e+yvPUasxflFId7fuVguz/PUFI/SidYbAFRSWF4h32CWF8MwiH/q2yj58X8BHAcWHAINLQg0tECsaMJfZprAMwwYngXPDrU3PLb0p4j3jwZvt6HhiBK8eYSowZsNMLVUQhEzVCOSS8VIiFSj0kG66nJ9r8BY9Rw/gZ6j5N84aOEC+KSlAoVk39RoWGwWQscQABbGz3Z5n7G+FHAQahZ5+UEa6lzKyfH7DXxznZlrhScN6IHbYBgG8c88BUYs9HF4mw2zD7ZCbPv6ZP7aKTzWdPbKWAhlEuldGuqKBSrs6fFkmqe6WQOLdSRN0vDBRzB3k8Pd4p58DFK/sRl2RquJKkq6NMF1ncvS1Qi7ziElyYqp+nbD+KZR1t2BV2IClYlpa2jGknoJwOCKoQKAfbVHAQxpSdJICI6EFloKdfTnbO7tQ+0/3ySuEamUiH38Ebd+h5PNhTBYhT1+MpGUOm1AsNdq0ggqE52PEOF5npomzox3LQ92u8JjrDwYF5SRkYhYs4pYZ7v7sahISF82Wk1XxG3lUalUFXZT88gE2bAAFfx9hDR3m51D1dfTU3tOnETHrj3Ez/adkoXgJYvd2v+JpnPk6HqxHHNcTHsFAEMV6WnLo9Ocar0BQHkDPcXzTUf0+nVQUIYYpp3vRFCfkNRyovEcDJYhw6CkNFYbqoU1IFrdariuyfM8al97HbZBSvrvqW+75czwPI891YeJ9ZlRuVBInDNMeZ6jM0VdNIu3dOmg1Qn7v6RidlKI194KeIyVB+NG1LoHoKKoVKfV6JHYJGQL7q4+DJ7nwYgkVFVyQ82IN8owDPUwKqvvhaGlFdWvvEa8xkqlSHj2GbeU2Xmex/4aMj00J2Ya5C4OIgDQV5HRmIoSLQ7DZueIdBXwzY+sgKG/SdL/ew5wILowdjvuPjYAuWkksjLbLTjaOKS9p4gnU6rWnhZY+9qv/Jv2+TV2DGDQYEHbth3oLyTrigGzZiJowXy39l7T10DVilyWOEbk3VEPu87h7y0SOx3GCdDJN8kxfpBQ9Dk98BgrD64CrESC5B/9EKyUFKtccmYQAZqR1F6jpgUVPTUA6IVmx9RJBiUVWFnVgco//IkY/wEAMY89DEWY86L3aNT2NaJe00ysL02Y6/I+20APLB11xLoy2bnSRU2LBiYHbTsvhQRRwc4bjr9J8E5JRsSqu8l1vR13ntCCGVXM21dzFDzPQ+ztB1l4EnGPflRU6+slQ0SQsImY54FLu46g4b0PiHslajUSnn3a7TEztKgqwS8GiRQdzNGgpQAVMZlgpc4jb1q9KuM2iLyvFh5j5cFVQRkZibjvPEmsy6w8Vh3SwMswclDvrjo8dE/CVDgqYVj72mDpbbvyb0djxfAcok5th6GR9HYDZs1A2Mq73N7z3hqSQZjoH4tYP+fUc0B4WA5DGhwNiTqEcvUQLtaQdbWM+ACwtxHLK2r9OihjSdJKVKcVc4pHUnUtA+0jDg3FATA4RLWZCcLvSJC5H9YN7wCccIQ8ACQ+/ywkPu7RwDWmAZxqJlN5y5Pmj2nsRmcIhqFMdF3jopIrKM6aB0PwGCsPrhohy5bCf+YMYt3byGHVIQ2klqHD42xrMXr0fRCpfCGLIAVQR/emRIf6QCX/msDB87iz6xSSB8jGTnlYKBKf/77bHnOfUUNleC0ZI6oC6PUqZZJz1W0AuEQ5iLISb6/CuUgmQ9pP/xNiL1JOKbfCiLzLIxTyYYdGlUx+rqaWStj1Iy0AWQkjn6PKZsD97QchslmI+8JW3gn/fNcGYzQO1p2AjROy+bylKuqok9GwDfTC3F5DrLuqV3X3G9HVLyRxsIxHvNYVPMbKg6sGwzBIfO57UESQytqBWjtWHdFCbubA8dwV1hetQdJQOeI5i1hmiITA81jRfRpZFEUEVipF6n/9GGIVXY+Phj3VhwnpHG+pCgVjHEScSU/tnVG5SAHa7RxVaT3zNvSa5aGhSPnxC0T9CgDmFOsx46Ie4Hmcab2AjsEuSAIjIfZzSOvyHPSjiBbDkZWfZQCPtuyBr43sm1JPzUHct55we592zk6tZy5OmAOpyLU0lr6SnHclCYyExPH3GAVaf1X8N0iG60bAY6w8uCZIvL2R/sufQ6JWE6+Fd1uxbm8//LQ2HKg9DovNQj3kTc0VsI0qTmdEqLCy6wRyBqqpPzPhe09DFRvr9h6NVhP21xwl1pclzodM7HpInKH2AuDgbYu8/SENS3B6T22rllQlUEgQG+5aBf6bCnVONmIefZj62syLehQU6wE7hx2VX4FhGKhSyOhqdHQb4KtAplyPR1t2Q20jmX+KqEik/PgFMCL3p+yebilCr1FIkGAYZsx6JkA3VqoU1w3mND3ADA9l3SU8xsqDa4Y8JATpL/0MLEU8Vq2zY92+foTU9uFQ3UlIAqMg8XeMxHgYvn7gdXV1iPj8DWQOkoQGAIj7zrcQvGjBuPZ3qP4k9A59MxJWjOVJYzPE6CzAaS7Tj9R61W2uShCxZpXT9oL8cgPu/0qDotKj0JoGqKlAY30JOIsJvN2Otu07cEf5Nig5Us5J7OOD9F/897iibo7n8OVlcnhnfvgUBKlcR8N2vRamJnLQoirVtbG6WEuraX7zmaLXAo+x8uC6wCshHqk/eZHqzcqsPFYe08Lwp7egKSujPsj9Zw6j9p//RumPfwquu5P6M3zWPIDwu90nVABD6Z2dlV8R6/NiZ0Itd1145+1WusQSxfMfDXq96vZLAY4GwzBI/P4zCFm+jPp6eLcV63Z04cS//g5I/cEqhX8bzmrB/2/vzuOjKu/9gX/ObJlJJpN9gyQkZCOEbCQSQAxRQBABgQoFi0VQr70CKspVa61Va2sLvfb3q/V6XcBaVBRoxAXLJhhUVglJCJCQECAJCdn3SWYyc+b+ERFmnjNrZsIM+b7/48mcJ88rzDnf82zfp2HXDhStXYcL774HsZ5NcKyRyjH2hd9AHmZ+4YuQwrpTgnkA7068w+q1PRXHAYPxwg6Jf6jZgxaBgWNjahvZHuHNluDY2SjdEnGagPGZGPu751H257+wR4gDCG3oxZnf/A5Sfz+IOUDsBei1gF4D9PdUABAe9gOAg4EZSI69Bal2tulo7Uk0qdlMEnOSrG8i7r102ij9DwBwXt4/pf8Rotfzgqu8KCsBwIlEiPvP/4BIJkX9FzuZn0v0gN/+IpzY/ygUYX6AHuBEA2diaToBw/FtZutulyixbcR05ESaT5klxGAwIP8Mu9E8KTgOySHsMnpTPWUCQ4BjJlrueZ9nvx+xI1TwU5o/941Qz4o4mX96GtLWvwr5iAizn+lv70BfG9BzBehrBfot5BXVchLsDJ2MQ4FpgsNrlvA8j+2nv2LKs0akWkxIelXPme+ZMu+4THAWJtyr6jrQqzGe4/KWSxA7cnjOV5niOA6xD65A1M8XWfxcb0MHepsBdSPQ1wZYOiqrQRaAzZGz0CJVWTzfSsiphjJUtl5kyheOnWV1pSnf1zOQD9CEtfmqkoompiwtPsRyQwkFK+J83pEjkbb+VchSkgZVT4MsAP+IuhunVPEAgNKqZuj17F4acw5eOoraznqmfG7SDKvXGvT9whPn1uYiKoUSkw7v+SpTHMch+r4lGPfHl6Hxt3yulCUGAEWqBHwYORM9koF67H2hyT/zb6YsNiAKGeHme89XqSsL2cU3ykB4jbTcIysRaGNaAvW8raFgRVxC6uuL7D/8AaX3pKLFz/ZVWQAgkssxYuF8bI+fi1bZtR6Juk+H8wJHbgjp1/djW+mXTHlySDySQ+KtXq+uKgbfZ9zl46Ryqxs9S6vYB9H1+4LINX4pKYjf8HsUJSrA2xnLlfFx6H9wLXaFToJWdG1Fp9Df35wzjedwpokdel449i6b9u/1lB9hynySJoDjzD9WG1rVaGg1HloWibhhua3BXhSsiMtwHIfb5/0SH94ViD0TfVEfJIHewjNALAdGzsnDLe+9g9jl9yM5nh2qKxYYQhGy7/x3gnNVS1Pn2/YgEhoCTMyGSGp+XkHPGwSXJJtmXCDXRIfGQLfwdrw/NwiH0nzQqjL/YsOJAHmgCAlPrEba+leRMoXddFtZ2wF1n/Dp0tfjDTzeP7mdKY9UReCWkeaPoP/pem2f4OIb6z1v9vsbH0n7q2xBCyyISyUGj0baiLEoFp3F2dEKiHUGhLbpEN0pwkzeD2iugkgKSLwGgpXcrxuSH48cT0sIxrEzV4zqO1XZjEXT2CwY1+vr7xMc3hkfMQ5jQszvj7qK79cILllXJt9q8brKmjb09BkPCym8JIij+SqLlqTOw5Hakzg+TozjKd4IbtcjsEOHjMAEjDlTAoOuHxJvQKYEOBEP73A5OLEYoYHeCA30RuN1PRWeN6D0fAsmpFiekyztqhTMEzk/eSZEFnpGV/WUH4Wh33jpvEjhC3m05cM/i4WGAGm+yibUsyIud2/KteXmegmH+hApjsaJceS20fAOAeT+gEQBcNzAJtyrqXXSBNITnb7Qin6d5XmrL899jQ5NF1O+JJU92kRI7/mTMGiNk+aKvLwtHrQIAEXn2LfmcXFBEIvpNrMkTBmCO6+eJ8ZxaA6Q4FyMHP/yuwwubwJ8wgEv1UDPCgB6znz307XpAt+Rk+caLf4+Da/FwRY2hVasfxSmjDKfmeR63aXsJnOfpBxwIvM9Q4PBIDinJvQ9Jyy6i4jLJQXHCeZX29dQiiZ/k42QvB7dPw7BjQpXwdfbOMOEtl//0/lWQi53XhFcinxrdDZiAiJtam/3dQ/Dq7yTJoCTWB6qOSkQrDITQ236ncPdz8beBYXEeFO53sBjh5cGJoctQ11ZCP7HLQVCf9+T5ZaHio+0FaNH38uUL89cZFOvStfdJrgKUJlqeZN5XXMPWjqMX4IkYg7Jw+DYGGegYEWGxP3pC+ElNg48vIHHlxFBzMPo6lurSMQJvnUKraa6Wt//Hv+ASUYq5kT4+Tj2uArBOrS9gsc9KMdOsXiduq8fZQLLpjMSaYjHFiq5L+aOYVdpFndUoyjI36jMoNP+lAk/LSEYplOQl5u60dTGBiMAuNLViOPtpUz5xMjxGBtqfV8V8ON8pulGYL9QyKPGWLxOaMl60qhAyGU0G2MLClZkSAR5B2DB2FlMeXl/B074Gr9Ra+oqoG0ZyCgglKnc3CKLPZUHUd7MJr69O2kawn1t6+H0nDsOg0kGb5HCF4oYy9uRS6taoOeNw26wnxyRoWzGcSJsTtI0BMjZ+b3PAxToNBlK7T490Pv1U3oJzgkWCQwF6ng9/nbkPehNNm1JRRIsS19gczu7TrFDgMpxt1lcBQiYm6+iIUBbUbAiQ2ZO0nSE+bA35+ehKjRIjcf6u398IAjdzGUXW5kVX809rfioZAfz2XBlCBalzLG5jV1FbGomn6QccGLLb78ny9mHY2ZSqM1HmBBALvHCg1lLmPJe6JEf6mvUA++tKoKua2A4OENoKFBgSHZr6ReCG4DvTpqGUKVtQUPbXAvtFfaFSDnO8knCej2PYoE2UbCyHQUrMmRkYimWZ7KZC7Qc8GG4H7TXPde7Sw/CYOARGapEsJ/JXAZvQHHFtbdUrU6Lvx5+F306NrHpI7css5pZ/ar+1nr0XWKHiJSplh9EgPDiChoCtN+EyAxMiWYXOZT5eOGY6rrvgYFHV8kBAMJ/5+KKJvDX9XRLG8rw2dk9zOdCfIKwIJnt8ZvTfYo9wFMWHgdZsOX50IqadnT3Gr9gKbzESBpF81W2omBFhlT2yDTkjmIPbGz0kmBHyLUj33UdjeirKQPHcchKZhOTnigbSHbLG3j8/ej7qGhhD2icPnoKUkItL3O/XlfxfqZMGjgC8ijLy5Gb2oQTk6YnULByxIrxi+EnkGT4sxBflF+34KaraB8MBh5jYwMhM+mZd/ZoUVU3sKq0tbcdrx/5Bwwms6MiToTHJ66EQsqeFiDEYODRfZo988rXhpeZH8rY5Mxp8SGQSugRbCv6S5Eh91DWEoz0ZffBFKoU2BXk89Mjpat44M05aww7zHOirBEGgwEflXyGI7XsUeQBCj8sS19oc5sMvF4wWPlmTLM6lCc0PzJ6pB8lJnWQr5cS/5F9H1POcxw+CPdDtdfAkKyuvQF9F0shlYgFN14XnWtCi7oNL+5/DW19bOaTxePmIDF4tM3t6q0qhq7DpAfNieBjZfENMPB9NSX0vSbmUbAiQ04ulWPt5IcET2D9JsAHO0KU4DGwn0av7kJ6QgiTW6+5XY13jmzH52Xs0I5EJMHaSQ/DW6awuU3qykLoe9qNC0ViKFPzrF4rNASYSUOAg3LLyHTkxU5iyvtFHP4xwh+XfwxYnUX7AAj/vY9VXMCLB/6KK93s/0+0IgLzx8y0q02dJ9gtEYrYdEiU/hava+/SoLKmnSkfP8a+o0yGOwpW5IaI9h+JB8ezk+kAcNTPG1vCVegw6NBV/DW85VLjvSgSDWRJx7Gvmu0JAcCjE35pU6aK63X9+NC7nk/iLVYfRDxvQJHA6kTaXzV4D2ctRWoYmwxZLRbhfyID8I2/N7rKj0Kv7jT5exsg8m/EBcW/0SAQqBQiL9wdlgeRyPbHX397g+CWBtV44fO5rie0STkyVImwQMeT+A5HFKzIDXP76MmYbeaAu1NKOdaPCsKHZbtxtvEcEuNlECnbII0+C3nqdxD7CR8FsSR1ns1ZCK7SdbYMZNA24Zsx3eq1lbXt6OwxXuouk4hoo6cTSMVSPHXrI4j1j2J+puc47ApW4s0IX3z2/fuQeKvhH6yBKKABsqQf4JVYCM6rj7nOR+aNxSPugkpi+0nCANBZuAcwmfOSqILhnWA5sTEAnDgrNARIvSp7eeRuNI1Gg8zMTOj1Fg65scPs2bPx17/+1Sl1Efssz7gXcolMMOuETsShwBsoODDwf+NleZ0Dbo+dbNfKrqs6T+5hNnmKVcFQxKZZvfbY6StM2bj4YGbCnzjGW6rAr3NX4fmvN6Cxh00SXCOX4uPWM/h410vAaMDSLKFS5oPf5j2O1irL6ZhM8f0awS0NqqyZFtMrAQMrVwsFtjWMp/kqu3lkz6q8vNxpgYrcWBzHYUnqPbg//WeO1wEOi1LuxiPZv7B7XxOv7UXnD2yg9E2/w+qDCACOCgSrHCtJVIl9/BV+eCHvCUT7jXS4Dl+ZD17IewKxAWwvzZqeM9+D7zXJNSmWwDfd+mnT52vb0aU26XlLxXQkiAM8MliVlZXd6CYQJ5s7ZjpW5zwAuci+oxKkUOA3U9dg0bg5ds1BXNV5ch/4PpNl5yIJVDYMATa0qnGxvpMpnzCWgpWzhSqD8eqMZzA3aTo40/xcVoxWjcYfpj9tc25IU0ILK5Rjp0DsYz2bvtAqwDTqeTvEI4PVmTNnbnQTiAvkxuTg73Nfwe29HKS85SeSgeegawmH7EIeUsMs52QzW4e+Hx1HP2fKfVOnQqKy/uYrNAQYF+mHYH/bVyES20nFUtyf8TM8nTQHwVqd1c/zfQpozmUixXC3zem2TPVePAVNPZuxQpVl23DzibPs/ipasu4Yj5yzop7VzUslV+G+lLsx+et/4KhKjlq5FN1iEbokIsBbhbYmBXQt4dC3hQJ6GZphQNXlDsRF+tv9u7pLv4W+y3ShBge/SbYdJSIUrHKoV+Vy4zNmI+TEflQ11OKctwwV3jI0yCTwEkmgkEeittoAvjsA+tZwwCDCsTMNuH+2lQlPAQaDAa0FW5hyr4g4yK0cXQ8Aze29KBc4IYDmqxzjccGK53mUl5cblcXHx2Pnzp03qEXE2XzTboeq4GNMbzM+/luZlor/rx+PkmbjhKCHTtXbHawMBh7th3cw5d5JEyALsj430tPbj1Pn2cSk1g79I4PHcRwCb/0ZdPn/jWiNzuh74rPoUTz0baXR5y/Wd6KhVW33UvHe8yehqS1nyv0m2vYyc/hUPVMWFeaLEcGU3NgRHjcMePHiRajVxg+x1FTLGbGJZxF5ecM/hz3So/vUQeSNZr+yh0rq7P4dPWVH0f9jZvfr+U+yLft2YVmjYJb10XQq8JDwScqBNHAEU24o2Ym4SPb/QKgXbMlAr+pjplwWGg2fZHazspBDp9jv5eS0CLvaQa7xuGAlNARIwerm4zdhLkTeJvnhDDyS2thEorWN3ai+wi50MIfv16D16/eZcvmocTYN7wDCqwAnpIRTlvUhwonEgsO16vKjmB7FnmVlb7BSnzsmmF09IHeJ1aNAgIGsFWeq2KX2t6axAZbYxuOC1dmzZ5kyClY3H5GXQrCXozt/HLdF9TPlhwSGXMxpP/Qpm+MNgP9k23pVOj0vmJg0J4XemoeSb+pUiH3ZzdfJDV9BBON9c6fON6Onl/3eCDHwerQdFOhVhcfBO3GCTXUcKa2H6RqhiCAfxESwCXqJbTwuWJmuBJRKpRgzxrHVYMS9qbJmQqxkH0Z3ib5nHka2DgX2t11Bh8BclSI2HYrYdJvqKKlgH3wKLzFS42nvzFDixFIETGGPnOHa6zDb33jeSs8bcPS0bS80HUe/gLaxmikPzFtqc89Z6Ps4KTWCet6D4HHBynQYMDExETKZbecVEc8iknoh4Db2YeTTVY1p8tNGZRfqOlHf3GO1zpa978GgN3nDFkkQNPNBmx8k3xTWMGXjx4RBKqG9M0PNN2MavEawQ7e3i0/AjzP+PnxzotZqfdqmauEVgJFJUIzOsKlN3WotSgROBab5qsHxqGDV1NSEZpOVYDQEeHPzTb8DkgB2hd1d3sWIFBvPCVjrXXWf+R7qih+Ycr+cOTatAASAPo1OcJXX1EzHsysQx3EiMYJnPQzA+EVDYujHz3yO4/p8fsUVTWjrZPMFXmXQ69D4+euA3nQPF4egO35p88vM0dNXBBffJEQF2HQ9EeZRwUpoMzAFq5sbJ5YgZM4qmD6MxOBxv/I7SHHtwSK0+uoqTV0lmr74O1Mu9g1EwJR7bW7P0dNX0Kc1TvXlo5AiW+CASDI0vCLioMpij/tIl1Vjlrzkp3/zBuDbInYF6FVt3/8L2itVTLlfzhzIo2yfajhUwr7MTEobAZGIhgAHw6P2WVlaCdja2oqvvvoKx44dQ1lZGVpaWqDVahEUFISQkBBkZ2cjNzcXEyZMgFhMwzWeRBE9Fv6T56P90KdG5eHiDvxC+T02d0+BHmKcq25HbWMXIkN9jT6n62zGla2vwqAzztEGAEHTH4DIjnOvvilkh5JuTRtBQ4A3WMDUpegpOwx9j/Ehi3d5F6OFV+K4duDImG8Ka/GL29h9Tl3F+9H+7TamXBociYCpS21uR0e3BoXl7OKbyak0BDhYHhWsTFcCKhQKyOVyrFu3Drt27UJ/P7vap76+HvX19SgpKcGmTZsQHx+PtWvXYvp067nfiPsIyP051JUnoW28aFSeKbsEubIfm7qnQgsp9h2rxgNzUn76ua6rFVe2/ok9WBGAd1IOfJIn29yGjm4NTgpk0M4b71jOOeI8YoUSQTNWonEHe3rCUp9D6DLIUdY/EhU17Wju9EKw6loOyo4fdqFl9ztspZwIIXPXQCS1/cTnAydqoNMbDwEG+HohOZYW3wyWRw0DmgYrg8GAOXPm4IsvvhAMVEIqKyuxatUqPPXUU9BoNK5oJnEBTixF6D2PgxM4XThZVodHVXsRLW7G1z9UQ6fnYTAY0FXyDWrffgLahgvMNbKwWITOe8yu1VnfFdcJzkWkUAZtt6BMmQL/yQuZcjFnwH/6fo3F3keg4LQ4dXEgqYCuuw0tX78vHKgA+N+6EPIR8Tb/foPBgD1H2VWEd2RHMSddE/t5TM9KrVajutr4i9DXJzxZKpVKodfrwfO84M8B4Msvv8SlS5ewadMmqFS098ETyEKjETTrITTvfJP5WaykGU/5fYUaXSAqNh2CT38rdG3CG0HFygCEL/41RDK5Xb//mxPsKsDczEiai3AjAXlL0d/egJ4z3zM/u1V+Dhmyi2iqDYCP1gfVe6oBXjghrnd8luCyeEvKq9tQ09DFlE+fEG1XPUSYzcFqqA4nXLt2rWB5WVmZ2eAjEolw5513Yt68ecjMzERgYCB4nkdrayuKioqwa9cu7Ny5k7n+1KlTePLJJ/HWW2/RPJaHUGVMB8eJ0LTzTebARACIkrQCja0wl5Obk8gQvuhZm7KqX6+uuRtll9ikpHlZNAToTjhOhNC5a1Df1Yq+GjaBgI9ICx80AOzK8mufGTMRofOfACe2711+r0CvKmV0EDOHShzDGQwGm06HSUpKcnVbAIBJUnvVhx9+iJdffpkpj4yMxGuvvYb0dMsbOisqKvD444/j/Hk2hcqqVavw2GOPOdZgE+Xl5eju7rb+QTIo0oZy+BTtAGew/RBOXuaNnvR7oAuKtfv3/fuHdhw9Z/z/GuInwaOzw2ijpxvitL3wObkN0jbre6uup4lIgTp1LmDn2Wiafh7//Wk9tDrjx+n8iQHIGO1jV13DnVKpFIw3HjNnJZRmKTk5GTt27LAaqAAgISEBn3zyCZKTk5mfbdq0idm/Rdxbf1gSurN/Dt7LtgzWmogUdE75D4cCVZ+Wx8kqdsNxRqwPBSo3ZZAp0D1hGdRjZkDHWT/Q08CJ0Bs7Ceo0+wMVAJyp7mUClUzCYWw0nW3mLB4zZ7V8+XLk5OSgtrYWNTU1aGxsxMsvvwxfX9u72L6+vnj99dcxb948o8ztvb292LhxI5555hmntdfc24E1J06cAABkZWU5rS03ryzweXdj39btkJz/FjES9oVDFjoKAbk/h09SjsO/ZUfBeWh1xnu4vGRirPzZZCi9KXuKW8u+Bb2tC7D3jb9gDHcREs546FjkrYIq806osmZCIpBn0FafHPqWKbs9OxqTcjIcrnO4sTYq5THBKiEhAQkJtmXEtiQqKgpLly7Fxo0bjcr37t3r1GBFhoZIJkfaXQvw8B99ESFuwwhxG/QGEZp5X9y/6DZMyo4fVO9HzxvwxXfsRtFp2VEUqDyEIjAM6okP4bldJQgU90DF9cJX1Aet1BfPP34fFEr7zrkyVXq+GWcvmh7iCdyZM2pQ9RJjNgcrc3NJnkgoWNXU1ODSpUsYNYq+YJ4mPMgHGQkhKKoA6vXXUtpsKajFxKx4DGak7mhpPRpb1Uz5vNw4xyslQ27WxBhs3XcO9ToZ6vHjd0QLfFPSgLsm2z80fL1P9p5jymIiVEiI8h9UvcSYx8xZOVNUVBRGjGDPlTl3jv3SEc9w7x1sr/tifafguVP2+OwguyAnOzkMI0PotFdP4u/rJbh5+7ODVeBNz/Kww9kLrSiqYI+bufeOBJrPdLJhGawAICYmhilraWEPSyOeIS0hGMkx7JzDJ/vKYeOCV8bpqhacucAO78ynXpVHEuoNX27qFkxMbKuP97EjTiNDfDAlgxIbO9uwDVb+/v5MWXt7+5C3gzgHx3FYMoNd0HK+tgM/nGVztVmj5w14+9NTTHlMhAppCcEOtZHcWDERKqQL/N9t+qIUmn7bt0Bcda66DYVlbPqtxdMTKWOFCwzbYKXXs19Ob+/BTbSSGyszKQSJ0f5M+Ud7ypk0SdbsOXIRVXUdTPn8qXE0vOPBFuSx6ZMa23qRv7/CrnoMBgM+2s0m1g4P8sbUTNoo7grDNlgJ9aKEelvEc3Ach58L9K4qa9rxWUGlwBXCOnu02Pxvdl9fXKQf8rKiBtVGcmONTwpFfASbmHb7/grBhTTmHDhRixNCvappiRCLh+1j1aU84q9aUFCAF198EY899hiWLVuG2bNn47XXXhtUnVVV7HLkqCh6EHm6W5LDMHqkH1O++d9luCDQUxLy4a6z6FKziZEfmZ9GwzsejuM4zMryh+l/o1bHY9MXp4UvMtHYpsZbn5Yw5aEBCtyeTc8QV/GIYFVbW4stW7Zg9+7dOH78OM6fP49Dhw45XF9VVRWamoxX8CgUCowbN26wTSU3GMdxeOge9v9Rp+fx2keF6NdZnps4dvoKdh2+yJTfnhWJ5FjHN40S9xGskmLiGHY15/clddh37JLFa3negP+35STUfWz2yRVzUyChXpXLeMRfVigTxOnTp1Ff79gqnu3btzNl2dnZkEqtp2Uh7i81Lhjzp7Irvy7Wd2LTF6fNrg48XdWCP//zOEyntxReEqMzsojnyx2nQoAvOxz4+rZiHC01/1zZtv8cTp1nM6XkjY/ElHRaAehKHhGs0tPTERho/FbL8zw++ugju+tqamrCJ598wpTfd999DrePuJ/770pGdDibiuvL7y5gwwcn0Kc1fjO+UNeB3288Aq2OzeS+ZEYiAlX2HSdC3JtcKsIDc8Yy5TxvwPrNP6DUJCDp9Dz+51/F+ODf7KKKYD85HlmY5rK2kgEekW5JKpVizpw5+Oc//2lU/v7772PhwoWIjbVtBzrP8/iv//ovJv9UbGws8vLynNVc4gZkUjGeXDoe6/52kDm59duiy6hr7sbsybEIC/RGQWEtDpyohU7PBqqMhBDcQ/uqbkq3Z0XhRFkjDp68bFSu1fH4zf8ewpS0EZg2IRptnX3Ye6wap6uE92E+sWQ8lAoalXE1jwhWAPDggw9i+/btRgloNRoNHnnkEWzevBlhYWEWr9dqtVi3bh0OHz5sVM5xHF566SWIHMi0TNxbXKQ/7ps5Bv/8il3Zd762A69vLbJ4fUKUP55bMYFWd92kOI7DE0vGo6tHi5PnjOewed6Ag0WXcbDospmrB9yTG4f0xBBXNpP8yGPuwvDwcKxZs4Ypv3TpEubPn48vv/zS7OGMR44cwb333ovdu3czP7v//vuRk+N4Rm7i3u69IwGLptmfAHlkiBK/e2giFF4e8z5HHCCViPDrByYI7s+z5s6cUVghMJRIXMOj7sQVK1agvLwcO3bsMCpvbW3FU089hQ0bNmDy5MkYOXJgorOhoQGHDx9GTQ17HDkA3HbbbZRp/SbHcRx+OXssosN88betRegXmJMyFRbojZcfmQQ/JTsBT24+Ci8JXnhwIp7/30O4WN9p9fMiEYeH5o3DnCmxtEF8CHlUsOI4Dn/4wx8AgAlYAHDlyhXk5+fbVNesWbOwYcMGSCQe9ScgDsrLisKIECX+vPkHs5s/lQop7pocg4W3J9AcxDDjp/TChsduwxffVuHzb6vQ3qUR/Jy/0gvrfpFFQ383gMc9qSUSCf785z9j4sSJ+OMf/4jOTutvQtdTqVRYu3Ytrf4bhhKjA/DWs9Nw/EwDKmvbcaGuA/XNPQjwlWPiuHDMyBlFw37DmFwmwaJpibgnNw4HTtTgu6I6NHf0IjTQG7ERKsSN9MeEceHwkopvdFOHJY+9MxcsWIAZM2Zg27ZtyM/PR0VFhcXs2rGxsViwYAGWLFkCPz82wwEZHiRiESalRmBSasSNbgpxUzKpGDMnxmDmxJgb3RRyHY8NVsDA0fErVqzAihUr0NbWhuLiYjQ1NaG9vR06nQ4+Pj4YOXIkxo4di4gIejgRQoin8uhgdb2AgADaK0UIITcpj1m6TgghZPiiYEUIIcTtUbAihBDi9m6aOSt3odEM7M9Qq9UoLy93uJ7BXEsIsY7uMfdyNZXe1WeoKQpWTqbXD5yXxPM8kzDXHoO5lhBiHd1j7unqM9QUBSsn8/LygkajgVgshpcXpeshhBBbaDQa6PV6s89NzmBpJy0hhBDiBmiBBSGEELdHwYoQQojbo2BFCCHE7VGwIoQQ4vYoWBFCCHF7FKwIIYS4PQpWhBBC3B4FK0IIIW6PghUhhBC3R8GKEEKI26NgRQghxO1RsCKEEOL2KFgRQghxexSsCCGEuD06z+oGu3DhAnbu3InCwkJUVVWhvb0dOp0OSqUS0dHRSE9Px4wZMzBhwoQb3VRC3I5arcasWbPQ0NAAAFi9ejXWrFnjlLp5nkdBQQEKCgpQXFyMhoYGdHZ2QiKRICAgAHFxcZg0aRJmz56NiIgIp/xOYh6dZ3WD1NXV4fe//z0OHDgAW/4LxowZg+eeew45OTlD0DpCPMMrr7yCzZs3//RvZwWrffv24dVXX0Vtba3Vz0okEsybNw/r1q1DUFDQoH83EUbDgDfAgQMHMGfOHOzfv9+mQAUAZWVlWL58Of72t7+5uHWEeIZdu3YZBSpn0Ov1eP7557Fq1SqbAhUA6HQ65Ofn45577sHJkyed2h5yDQWrIbZ3716sXr0aPT09gj/nOA4ikfB/i8FgwBtvvIH169e7somEuL3jx4/j6aefdmqdBoMBTz75JLZt22b2MxKJ+ZmTpqYmrFy5EsXFxU5tFxlAc1ZDqLKyEk8//TR0Op1Rub+/P5YvX45Zs2YhMjISHMehrq7upzfHpqYmo89v3LgRKSkpuPvuu4ey+YS4hUOHDmHVqlXQaDROrfeNN97Arl27mPLMzEwsW7YMkyZNQmBgIHp6elBWVoZt27bh888/B8/zP31WrVZjzZo1+OyzzxAQEODU9g13NGc1RAwGAxYvXoySkhKj8vT0dPz9739HaGio4HWtra1Yt24dvv/+e6Nyf39/7N69G/7+/q5qMiFuZ8eOHfjtb38LrVYr+HNH56zKysqwYMECo8ADAGvWrMGjjz5qdrTj8OHDWLt2Ldra2ozKFy5ciFdffdXudhDzaBhwiHz++edMoIqJicHbb79tNlABQGBgIN58801kZmYalbe3t+Ptt992SVsJcTdarRavvPIKnnnmGbOBajD+9Kc/MYFq5cqVWL16tdlABQCTJk3CW2+9BblcblT+6aef4ty5c05v53BGwWqIbNq0iSl76aWXbOoZeXl54fXXX4dSqTQq37JlC7q6upzVRELcUmlpKRYuXOj0xRRXnT17FocPHzYqGzVqFNauXWvT9enp6XjmmWeMygwGA959912ntZFQsBoSRUVFKCsrMyrLyMjAxIkTba4jJCQE9913n1GZWq3GV1995ZQ2EuJuWltb8cILL2DRokWoqKhgfu6sZeJbtmxhylauXAmZTGZzHYsXL2b2Wu3evZteJp2IgtUQ2LdvH1M2b948u+tZuHAhU0bBitxsdDod/vKXv2DatGn45JNPmOE5AFi+fLnNPR9r9u/fb/RvqVSK2bNn21XH1b1W1+vr68PXX3896PaRARSshsB3333HlOXm5tpdT2xsLKKioozKTpw4ge7ubofbRoi7UavVeOedd6BWq5mfBQUF4Y033sBzzz0HsVg86N9VVlbGrLbNyMiASqWyuy6he7qgoMDhthFjFKxcrLe3F+Xl5UZlISEhTNCxVUZGhtG/+/v7cerUKUebR4hHEIlEWLRoEXbu3Inp06c7rd7CwkKmbPz48Q7VNW7cOGYfFm0Sdh4KVi5WUVHBDGMkJSU5XF9CQgJTdvr0aYfrI8Td5ebm4tNPP8Urr7zi9L1LQnNhjt6fcrkckZGRRmX19fVoaWlxqD5ijDYFu9j58+eZstjYWIfrGzVqFFNWXV3tcH2EuCORSIS8vDw8+OCDyM7OdtnvqaysZMpiYmIcri8mJgYXL140KquurqacgU5AwcrFrmaDvl5YWJjD9YWEhDBlly9fdrg+QtyNQqHAnj17HB4qt0djYyNTFh4e7nB95u5P032SxH40DOhizc3NTJnQF9pWwcHBTFlra6vD9RHibqRS6ZAEKgDM4gqRSITAwECH6xPqQdH96RwUrFxM6ItqurnXHj4+PkxZR0eHw/URMlxptVomobRSqQTHcQ7XKXR/dnZ2OlwfuYaClYv19fUxZUJfaFt5e3szZUJLfAkhljn73jR3vbkTFoh9KFi5mFAeM6lU6nB9QkcUmGZxJ4RYJ3RvWjoCxBZ0f7oOBSsX6+/vZ8oGs5lRKNDRzUCI/Zx9bwIUrFyJgpWLCY1/D+ZUFr1ez5RZygpNCBE2mLkpc4RSQzkj0wahYOVyQj0hoYBjK6Fr7Um4SQgZ4IpRCqHrBzPsT66hYOViXl5eTNlgTjgVupaCFSH2c/a9ae56uj+dg4KVi/n5+TFlg1kdJHStr6+vw/URMlwplUpmjmmwK/fo/nQdClYuJpTLbDD7ooSuFdooTAixzvTwU7VaPaiTiOn+dB0KVi5meiAbwO6at4fQtXQzEOIYodRKg0k8K5Sxhu5P56Bg5WJCaWPq6uocrk8oD2B0dLTD9REynAndO4PJtSl0rVDyaWI/ClYuJnSkx4ULFxyuzzSjs7nfQQixLj4+nilz5v3p7e3NHBtCHEPBysUiIiKYYYCzZ88K7sewhdBBi2PGjHGoLkKGu9TUVKbM0fPhampq0N7eblSWmJjokv1cwxEFqyGQlZVl9G+1Wo3S0lK76+nt7WWCVXh4OEaPHj2o9hEyXGVmZjIrAo8fP+5QXceOHWPKJk2a5FBdhEXBagjk5eUxZXv37rW7noKCAmYfx5QpUxxtFiHDnq+vL3OMfWVlpeChqdbs2bOHKaP703koWA2BadOmMRsQt2/fbveejvfff58pW7BgwaDaRshwN3v2bKZs8+bNdtVRVVWFgwcPGpVFR0czoyrEcRSshoCfnx9zQ7S2tmLDhg0217F161YUFhYalSUmJrr0yG9ChoO5c+cyR3sI3W/m9Pf343e/+x0zD7106VKar3IiClZD5Fe/+hUzNr5lyxZs3LjR6rXffvstXn75Zab8iSeecFbzCBm2lEolVqxYYVSm1+vx6KOPWh0O5HkeL7zwAjNfFRYWhqVLlzq9rcMZBashEhMTgwceeIApX79+PZ599lnBE4U1Gg3efPNN/OpXv2KOM8jNzcW0adNc1VxChpWVK1cyeyLb2tqwePFi7NixQzCBdE1NDR544AHk5+czP3v22WehUChc1t7hiDMM5rwKYhetVovly5cLDi/IZDJMnToVo0ePhlQqRU1NDb755hvB9C0RERHIz89HYGDgUDSbELeUn5+PX//610Zlq1evxpo1axyqr6SkBMuXLxc8eTs8PBy5ubkIDw9Hd3c3ysvLcfjwYcEtKEuXLsWLL77oUBuIeYM7FpPYRSaT4Z133sHDDz/MBCytVmvTCsGIiAi89957FKgIcbK0tLSf7k/TgHXlyhVs3brVah1z587F888/76omDms0DDjElEol3n33XSxdutTuQxMnT56Mjz/+GLGxsS5qHSHDW3Z2Nj744AOkpKTYdZ1UKsXjjz+O9evXC54WTAaP/qo3gI+PD1588UUsWrQImzZtQkFBAbq6ugQ/y3EcbrnlFixbtgwzZ84c4pYSMvykpKRg+/bt+Ne//oX8/HwUFRWZzTjj4+ODuXPnYvny5bQ538VozsoN9Pf3o7i4GPX19WhuboZWq4VKpcKIESOQmZkJlUp1o5tIyLDV3NyM0tJSNDU1obW1FVKpFP7+/khISEBycjL1pIYIBStCCCFuj+asCCGEuD0KVoQQQtweBStCCCFuj4IVIYQQt0fBihBCiNujYEUIIcTtUbAihBDi9ihYEUIIcXsUrAghhLg9ClaEEELcHgUrQgghbo+CFSGEELdHwYoQQojbo2BFCCHE7VGwIoQQ4vb+DxtbTuZWMwH4AAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.set(style='whitegrid', rc={\"grid.linewidth\": 1.5})\n", + "sns.set_context(\"poster\", font_scale=2.5, rc={\"lines.linewidth\": 5.0})\n", + "sinplot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Though our Notebook didn't display enlarged (scaled) plot, we may notice how in the backend (in memory) it has created the figure as per our instructions. We have *thick lines* now in our plot because I set **`linewidth`** to **`5`**, *font size* on axes have thickened because of **`font_scale`**. Generally we don't use anything more than that during data analysis although exceptional scenarios may demand few more parameters as per requirement. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + ">**Note:** **`%matplotlib inline`** just needs to be called once in a kernel unless we refresh/restart the kernel. This is a function that works only in Jupyter Notebook. In other IDE, you will have to explicitly mention either **`sns.plt.show()`** or just **`plt.show()`** at the end of your code for plot/figure to be displayed.\n", + "Also, style and context once set remains defined unless we explicitly call for a change. If never called in a kernel, Seaborn will work with it's defaults: Matplotlib 'white' background without grids, and 'notebook' scale size." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the next lecture, we shall see the difference in coding between **[Matplotlib and Seaborn](https://github.com/milaan9/12_Python_Seaborn_Module/blob/main/003_Matplotlib_vs_Seaborn.ipynb)** to achieve a certain goal (Regression plot illustration)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "hide_input": false, + "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" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/002_Python_Functions_Built_in/067_Python___import__().ipynb b/002_Python_Functions_Built_in/067_Python___import__().ipynb deleted file mode 100644 index b8189ca..0000000 --- a/002_Python_Functions_Built_in/067_Python___import__().ipynb +++ /dev/null @@ -1,164 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "All the IPython Notebooks in this lecture series by Dr. Milan Parmar are available @ **[GitHub](https://github.com/milaan9/04_Python_Functions/tree/main/002_Python_Functions_Built_in)**\n", - "" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Python `__import__()`\n", - "\n", - "The **`__import__()`** is a function that is called by the import statement.\n", - "\n", - "**Syntax**:\n", - "\n", - "```python\n", - "__import__(name, globals=None, locals=None, fromlist=(), level=0)\n", - "```" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## `__import__()` Parameter\n", - "\n", - "* **name** - the name of the module you want to import\n", - "* **globals** and **locals** - determines how to interpret **`name`**\n", - "* **fromlist** - objects or submodules that should be imported by name\n", - "* **level** - specifies whether to use absolute or relative imports" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Use of `__import__()` is Discouraged\n", - "\n", - "This **`__import__()`** function is not necessary for everyday Python program. It is rarely used and often discouraged.\n", - "\n", - "This function can be used to change the semantics of the **[import statement](https://github.com/milaan9/04_Python_Functions/blob/main/007_Python_Function_Module.ipynb)** as the statement calls this function. Instead, it is better to use import hooks.\n", - "\n", - "And, if you want to import a module by name, use **[importlib.import_module()](https://docs.python.org/3/library/importlib.html#importlib.import_module)**." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2.5\n" - ] - } - ], - "source": [ - "# Example: How __import()__ works?\n", - "\n", - "mathematics = __import__('math', globals(), locals(), [], 0)\n", - "print(mathematics.fabs(-2.5))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The **`fabs()`** method is defined in the **`math`** module. You can call this function using the following syntax:\n", - "\n", - "```python\n", - "import math\n", - "math.fabs(x)\n", - "```\n", - "\n", - "However, in the above program, we changed the way **`fabs()`** works. Now, we can also access **`fabs()`** using the following syntax:\n", - "\n", - "```python\n", - "mathematics.fabs(x)\n", - "```" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "hide_input": false, - "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" - }, - "toc": { - "base_numbering": 1, - "nav_menu": {}, - "number_sections": true, - "sideBar": true, - "skip_h1_title": false, - "title_cell": "Table of Contents", - "title_sidebar": "Contents", - "toc_cell": false, - "toc_position": {}, - "toc_section_display": true, - "toc_window_display": false - }, - "varInspector": { - "cols": { - "lenName": 16, - "lenType": 16, - "lenVar": 40 - }, - "kernels_config": { - "python": { - "delete_cmd_postfix": "", - "delete_cmd_prefix": "del ", - "library": "var_list.py", - "varRefreshCmd": "print(var_dic_list())" - }, - "r": { - "delete_cmd_postfix": ") ", - "delete_cmd_prefix": "rm(", - "library": "var_list.r", - "varRefreshCmd": "cat(var_dic_list()) " - } - }, - "types_to_exclude": [ - "module", - "function", - "builtin_function_or_method", - "instance", - "_Feature" - ], - "window_display": false - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/002_Python_Functions_Built_in/README.md b/002_Python_Functions_Built_in/README.md new file mode 100644 index 0000000..1a346bf --- /dev/null +++ b/002_Python_Functions_Built_in/README.md @@ -0,0 +1,10 @@ +

+Last Commit + +

+ + + +# Python Built-in Functions + +In this class, you'll learn about python built-in functions. diff --git a/003_Python_Function_global_Keywords.ipynb b/003_Python_Function_global_Keywords.ipynb index 1d9b62c..6db76ab 100644 --- a/003_Python_Function_global_Keywords.ipynb +++ b/003_Python_Function_global_Keywords.ipynb @@ -5,7 +5,7 @@ "metadata": {}, "source": [ "\n", - "All the IPython Notebooks in this lecture series by Dr. Milan Parmar are available @ **[GitHub](https://github.com/milaan9/04_Python_Functions)**\n", + "All the IPython Notebooks in **Python Functions** lecture series by Dr. Milaan Parmar are available @ **[GitHub](https://github.com/milaan9/04_Python_Functions)**\n", "" ] }, diff --git a/004_Python_Function_Arguments.ipynb b/004_Python_Function_Arguments.ipynb index 5602630..e4de16f 100644 --- a/004_Python_Function_Arguments.ipynb +++ b/004_Python_Function_Arguments.ipynb @@ -5,7 +5,7 @@ "metadata": {}, "source": [ "\n", - "All the IPython Notebooks in this lecture series by Dr. Milan Parmar are available @ **[GitHub](https://github.com/milaan9/04_Python_Functions)**\n", + "All the IPython Notebooks in **Python Functions** lecture series by Dr. Milaan Parmar are available @ **[GitHub](https://github.com/milaan9/04_Python_Functions)**\n", "" ] }, @@ -58,8 +58,8 @@ "execution_count": 1, "metadata": { "ExecuteTime": { - "end_time": "2021-06-13T15:56:57.276044Z", - "start_time": "2021-06-13T15:56:57.259443Z" + "end_time": "2021-10-08T17:53:46.249389Z", + "start_time": "2021-10-08T17:53:46.233763Z" } }, "outputs": [ @@ -99,8 +99,8 @@ "execution_count": 2, "metadata": { "ExecuteTime": { - "end_time": "2021-06-13T15:56:58.845367Z", - "start_time": "2021-06-13T15:56:58.523104Z" + "end_time": "2021-10-08T17:53:46.738157Z", + "start_time": "2021-10-08T17:53:46.252318Z" } }, "outputs": [ @@ -125,8 +125,8 @@ "execution_count": 3, "metadata": { "ExecuteTime": { - "end_time": "2021-06-13T15:56:59.522119Z", - "start_time": "2021-06-13T15:56:59.506497Z" + "end_time": "2021-10-08T17:53:58.135141Z", + "start_time": "2021-10-08T17:53:58.121470Z" } }, "outputs": [ @@ -151,8 +151,8 @@ "execution_count": 4, "metadata": { "ExecuteTime": { - "end_time": "2021-06-13T15:57:00.105611Z", - "start_time": "2021-06-13T15:57:00.098777Z" + "end_time": "2021-10-08T17:54:01.795787Z", + "start_time": "2021-10-08T17:54:01.785048Z" } }, "outputs": [ @@ -180,8 +180,8 @@ "execution_count": 5, "metadata": { "ExecuteTime": { - "end_time": "2021-06-13T15:57:00.965469Z", - "start_time": "2021-06-13T15:57:00.945936Z" + "end_time": "2021-10-08T17:54:02.180554Z", + "start_time": "2021-10-08T17:54:02.002333Z" } }, "outputs": [ @@ -217,8 +217,8 @@ "execution_count": 6, "metadata": { "ExecuteTime": { - "end_time": "2021-06-13T15:57:02.119756Z", - "start_time": "2021-06-13T15:57:02.109013Z" + "end_time": "2021-10-08T17:54:02.567760Z", + "start_time": "2021-10-08T17:54:02.553115Z" }, "scrolled": true }, @@ -251,8 +251,8 @@ "execution_count": 7, "metadata": { "ExecuteTime": { - "end_time": "2021-06-13T15:57:02.782346Z", - "start_time": "2021-06-13T15:57:02.762817Z" + "end_time": "2021-10-08T17:54:02.829482Z", + "start_time": "2021-10-08T17:54:02.808974Z" } }, "outputs": [ @@ -307,8 +307,8 @@ "execution_count": 8, "metadata": { "ExecuteTime": { - "end_time": "2021-06-13T15:57:05.164654Z", - "start_time": "2021-06-13T15:57:05.155866Z" + "end_time": "2021-10-08T17:54:03.695692Z", + "start_time": "2021-10-08T17:54:03.679093Z" } }, "outputs": [ @@ -364,8 +364,8 @@ "execution_count": 9, "metadata": { "ExecuteTime": { - "end_time": "2021-06-13T15:57:06.149019Z", - "start_time": "2021-06-13T15:57:06.138278Z" + "end_time": "2021-10-08T17:54:04.298283Z", + "start_time": "2021-10-08T17:54:04.279681Z" } }, "outputs": [ @@ -407,8 +407,8 @@ "execution_count": 10, "metadata": { "ExecuteTime": { - "end_time": "2021-06-13T15:57:07.271081Z", - "start_time": "2021-06-13T15:57:07.259364Z" + "end_time": "2021-10-08T17:54:05.968643Z", + "start_time": "2021-10-08T17:54:05.951068Z" } }, "outputs": [ @@ -459,8 +459,8 @@ "execution_count": 11, "metadata": { "ExecuteTime": { - "end_time": "2021-06-13T15:57:08.348221Z", - "start_time": "2021-06-13T15:57:08.339434Z" + "end_time": "2021-10-08T17:54:06.818254Z", + "start_time": "2021-10-08T17:54:06.799703Z" }, "scrolled": true }, @@ -505,8 +505,8 @@ "execution_count": 12, "metadata": { "ExecuteTime": { - "end_time": "2021-06-13T15:57:09.362862Z", - "start_time": "2021-06-13T15:57:09.354073Z" + "end_time": "2021-10-08T17:54:07.312883Z", + "start_time": "2021-10-08T17:54:07.298727Z" } }, "outputs": [ @@ -527,10 +527,10 @@ "execution_count": 13, "metadata": { "ExecuteTime": { - "end_time": "2021-06-13T15:57:09.732971Z", - "start_time": "2021-06-13T15:57:09.717352Z" + "end_time": "2021-10-08T17:54:07.575577Z", + "start_time": "2021-10-08T17:54:07.569232Z" }, - "scrolled": false + "scrolled": true }, "outputs": [ { @@ -551,8 +551,91 @@ "execution_count": 14, "metadata": { "ExecuteTime": { - "end_time": "2021-06-13T15:57:10.010315Z", - "start_time": "2021-06-13T15:57:10.001529Z" + "end_time": "2021-10-08T17:54:07.837788Z", + "start_time": "2021-10-08T17:54:07.826073Z" + }, + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Milaan Parmar\n" + ] + } + ], + "source": [ + "# Example 2:\n", + "\n", + "def print_fullname(firstname, lastname):\n", + " space = ' '\n", + " full_name = firstname + space + lastname\n", + " return full_name\n", + "print(print_fullname(firstname = 'Milaan', lastname = 'Parmar'))" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "ExecuteTime": { + "end_time": "2021-10-08T17:54:08.116107Z", + "start_time": "2021-10-08T17:54:08.109271Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n" + ] + } + ], + "source": [ + "# Example 3:\n", + "\n", + "def add_two_numbers (num1, num2):\n", + " total = num1 + num2\n", + " return total\n", + "print(add_two_numbers(num2 = 3, num1 = 2)) # Order does not matter" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "ExecuteTime": { + "end_time": "2021-10-08T17:54:08.454973Z", + "start_time": "2021-10-08T17:54:08.439351Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Age: 200\n" + ] + } + ], + "source": [ + "# Example 4:\n", + "\n", + "def calculate_age (current_year, birth_year):\n", + " age = current_year - birth_year\n", + " return age;\n", + "print('Age: ', calculate_age(2019, 1819))" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "ExecuteTime": { + "end_time": "2021-10-08T17:54:08.733298Z", + "start_time": "2021-10-08T17:54:08.724510Z" } }, "outputs": [ @@ -565,7 +648,7 @@ } ], "source": [ - "# Example 2:\n", + "# Example 5:\n", "\n", "def remainder(dividend,divisor):\n", " x=dividend%divisor\n", @@ -578,11 +661,11 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 18, "metadata": { "ExecuteTime": { - "end_time": "2021-06-13T15:57:10.441953Z", - "start_time": "2021-06-13T15:57:10.425353Z" + "end_time": "2021-10-08T17:54:09.011615Z", + "start_time": "2021-10-08T17:54:08.992087Z" } }, "outputs": [ @@ -596,7 +679,7 @@ } ], "source": [ - "# Example 3:\n", + "# Example 6:\n", "\n", "def message(name, surname):\n", " print(\"Hello\", name, surname)\n", @@ -621,25 +704,25 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 19, "metadata": { "ExecuteTime": { - "end_time": "2021-06-13T15:57:15.269065Z", - "start_time": "2021-06-13T15:57:15.251487Z" + "end_time": "2021-10-08T17:54:09.751364Z", + "start_time": "2021-10-08T17:54:09.743554Z" } }, "outputs": [ { "ename": "SyntaxError", - "evalue": "positional argument follows keyword argument (, line 10)", + "evalue": "positional argument follows keyword argument (, line 10)", "output_type": "error", "traceback": [ - "\u001b[1;36m File \u001b[1;32m\"\"\u001b[1;36m, line \u001b[1;32m10\u001b[0m\n\u001b[1;33m message(first_nm=\"Frank\", \"Harper\") # SyntaxError: positional argument follows keyword argument\u001b[0m\n\u001b[1;37m ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m positional argument follows keyword argument\n" + "\u001b[1;36m File \u001b[1;32m\"\"\u001b[1;36m, line \u001b[1;32m10\u001b[0m\n\u001b[1;33m message(first_nm=\"Frank\", \"Harper\") # SyntaxError: positional argument follows keyword argument\u001b[0m\n\u001b[1;37m ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m positional argument follows keyword argument\n" ] } ], "source": [ - "# Example 4:\n", + "# Example 7:\n", "\n", "def message(first_nm, last_nm):\n", " print(\"Hello..!\", first_nm, last_nm)\n", @@ -666,11 +749,11 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 20, "metadata": { "ExecuteTime": { - "end_time": "2021-06-13T15:57:33.873409Z", - "start_time": "2021-06-13T15:57:33.860717Z" + "end_time": "2021-10-08T17:54:10.415429Z", + "start_time": "2021-10-08T17:54:10.407618Z" }, "scrolled": true }, @@ -707,11 +790,81 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 21, "metadata": { "ExecuteTime": { - "end_time": "2021-06-13T15:57:35.397812Z", - "start_time": "2021-06-13T15:57:35.381211Z" + "end_time": "2021-10-08T17:54:11.604882Z", + "start_time": "2021-10-08T17:54:11.592189Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sum is: 0\n", + "Sum is: 33\n", + "Sum is: 176.6\n" + ] + } + ], + "source": [ + "# Example 2: \n", + "\n", + "def addition(*numbers):\n", + " total = 0\n", + " for no in numbers:\n", + " total = total + no\n", + " print(\"Sum is:\", total)\n", + "\n", + "addition() # 0 arguments\n", + "addition(10, 5, 3, 6, 9) # 5 arguments\n", + "addition(96, 77, 3.6) # 3 arguments" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "ExecuteTime": { + "end_time": "2021-10-08T17:54:12.315821Z", + "start_time": "2021-10-08T17:54:12.304103Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10\n" + ] + } + ], + "source": [ + "# Example 3: \n", + "\n", + "def sum_all_nums(*nums):\n", + " total = 0\n", + " for num in nums:\n", + " total += num # same as total = total + num \n", + " return total\n", + "print(sum_all_nums(2, 3, 5)) # 10" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Default and Arbitrary Number of Parameters in Functions" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "ExecuteTime": { + "end_time": "2021-10-08T17:54:13.377345Z", + "start_time": "2021-10-08T17:54:13.359769Z" } }, "outputs": [ @@ -734,7 +887,7 @@ } ], "source": [ - "# Example 2: \n", + "# Example 1: \n", "\n", "def printinfo( arg1, *vartuple ):\n", " \"This prints a variable passed arguments\"\n", @@ -752,11 +905,11 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 24, "metadata": { "ExecuteTime": { - "end_time": "2021-06-13T15:57:36.428079Z", - "start_time": "2021-06-13T15:57:36.411477Z" + "end_time": "2021-10-08T17:54:14.148826Z", + "start_time": "2021-10-08T17:54:14.127348Z" } }, "outputs": [ @@ -764,26 +917,58 @@ "name": "stdout", "output_type": "stream", "text": [ - "Sum is: 0\n", - "Sum is: 33\n", - "Sum is: 176.6\n" + "Team-1\n", + "Milaan\n", + "Arthur\n", + "Clark\n", + "Ethan\n", + "None\n" ] } ], "source": [ - "# Example 3: \n", - "\n", - "def addition(*numbers):\n", - " total = 0\n", - " for no in numbers:\n", - " total = total + no\n", - " print(\"Sum is:\", total)\n", - "\n", - "addition() # 0 arguments\n", + "# Example 2: \n", "\n", - "addition(10, 5, 3, 6, 9) # 5 arguments\n", + "def generate_groups (team,*args):\n", + " print(team)\n", + " for i in args:\n", + " print(i)\n", + "print(generate_groups('Team-1','Milaan','Arthur','Clark','Ethan'))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Function as a Parameter of Another Function" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "ExecuteTime": { + "end_time": "2021-10-08T17:54:15.540920Z", + "start_time": "2021-10-08T17:54:15.520416Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "9\n" + ] + } + ], + "source": [ + "# Example 1: You can pass functions around as parameters\n", "\n", - "addition(96, 77, 3.6) # 3 arguments" + "def square_number (n):\n", + " return n * n\n", + "def do_something(f, x):\n", + " return f(x)\n", + "print(do_something(square_number, 3)) # 27" ] }, { diff --git a/005_Python_Function_Recursion.ipynb b/005_Python_Function_Recursion.ipynb index 4524058..f301911 100644 --- a/005_Python_Function_Recursion.ipynb +++ b/005_Python_Function_Recursion.ipynb @@ -5,7 +5,7 @@ "metadata": {}, "source": [ "\n", - "All the IPython Notebooks in this lecture series by Dr. Milan Parmar are available @ **[GitHub](https://github.com/milaan9/04_Python_Functions)**\n", + "All the IPython Notebooks in **Python Functions** lecture series by Dr. Milaan Parmar are available @ **[GitHub](https://github.com/milaan9/04_Python_Functions)**\n", "" ] }, diff --git a/006_Python_Function_Anonymous.ipynb b/006_Python_Function_Anonymous.ipynb index 93a2c74..b30f520 100644 --- a/006_Python_Function_Anonymous.ipynb +++ b/006_Python_Function_Anonymous.ipynb @@ -5,7 +5,7 @@ "metadata": {}, "source": [ "\n", - "All the IPython Notebooks in this lecture series by Dr. Milan Parmar are available @ **[GitHub](https://github.com/milaan9/04_Python_Functions)**\n", + "All the IPython Notebooks in **Python Functions** lecture series by Dr. Milaan Parmar are available @ **[GitHub](https://github.com/milaan9/04_Python_Functions)**\n", "" ] }, diff --git a/007_Python_Function_Module.ipynb b/007_Python_Function_Module.ipynb index da4f911..b0d7b46 100644 --- a/007_Python_Function_Module.ipynb +++ b/007_Python_Function_Module.ipynb @@ -5,7 +5,7 @@ "metadata": {}, "source": [ "\n", - "All the IPython Notebooks in this lecture series by Dr. Milan Parmar are available @ **[GitHub](https://github.com/milaan9/04_Python_Functions)**\n", + "All the IPython Notebooks in **Python Functions** lecture series by Dr. Milaan Parmar are available @ **[GitHub](https://github.com/milaan9/04_Python_Functions)**\n", "" ] }, @@ -24,7 +24,7 @@ "source": [ "## What are modules in Python?\n", "\n", - "Modules refer to the Python file, which contains Python code like Python statements, classes, functions, variables, etc. A file with Python code is defined with extension**`.py`**\n", + "Module containing a set of codes or a set of functions which can be included to an application. Modules refer to the Python file, which contains Python code like Python statements, classes, functions, variables, etc. A file with Python code is defined with extension**`.py`**\n", "\n", "For example: In **`main.py`**, where the **`main`** is the module name.\n", "\n", @@ -99,9 +99,10 @@ "execution_count": 1, "metadata": { "ExecuteTime": { - "end_time": "2021-06-14T07:46:07.519826Z", - "start_time": "2021-06-14T07:46:07.484668Z" - } + "end_time": "2021-10-12T14:02:26.910409Z", + "start_time": "2021-10-12T14:02:26.835984Z" + }, + "scrolled": true }, "outputs": [ { @@ -322,8 +323,8 @@ "execution_count": 2, "metadata": { "ExecuteTime": { - "end_time": "2021-06-14T07:46:14.308906Z", - "start_time": "2021-06-14T07:46:14.293280Z" + "end_time": "2021-10-12T14:02:27.045065Z", + "start_time": "2021-10-12T14:02:26.913837Z" } }, "outputs": [ @@ -358,8 +359,8 @@ "execution_count": 3, "metadata": { "ExecuteTime": { - "end_time": "2021-06-14T07:46:34.341189Z", - "start_time": "2021-06-14T07:46:34.332403Z" + "end_time": "2021-10-12T14:02:27.248271Z", + "start_time": "2021-10-12T14:02:27.048983Z" } }, "outputs": [ @@ -384,8 +385,8 @@ "execution_count": 4, "metadata": { "ExecuteTime": { - "end_time": "2021-06-14T07:46:35.014041Z", - "start_time": "2021-06-14T07:46:34.996467Z" + "end_time": "2021-10-12T14:02:27.381949Z", + "start_time": "2021-10-12T14:02:27.261984Z" } }, "outputs": [ @@ -420,8 +421,8 @@ "execution_count": 5, "metadata": { "ExecuteTime": { - "end_time": "2021-06-14T07:46:36.160041Z", - "start_time": "2021-06-14T07:46:36.149303Z" + "end_time": "2021-10-12T14:02:27.501912Z", + "start_time": "2021-10-12T14:02:27.389783Z" }, "scrolled": true }, @@ -431,7 +432,7 @@ "output_type": "stream", "text": [ "720\n", - "15\n" + "28\n" ] } ], @@ -458,8 +459,8 @@ "execution_count": 6, "metadata": { "ExecuteTime": { - "end_time": "2021-06-14T07:46:37.423714Z", - "start_time": "2021-06-14T07:46:37.405165Z" + "end_time": "2021-10-12T14:02:27.623348Z", + "start_time": "2021-10-12T14:02:27.505830Z" } }, "outputs": [ @@ -483,8 +484,8 @@ "execution_count": 7, "metadata": { "ExecuteTime": { - "end_time": "2021-06-14T07:46:38.311414Z", - "start_time": "2021-06-14T07:46:38.292861Z" + "end_time": "2021-10-12T14:02:27.772693Z", + "start_time": "2021-10-12T14:02:27.627264Z" } }, "outputs": [ @@ -511,8 +512,8 @@ "execution_count": 8, "metadata": { "ExecuteTime": { - "end_time": "2021-06-14T07:46:38.781631Z", - "start_time": "2021-06-14T07:46:38.767960Z" + "end_time": "2021-10-12T14:02:27.892167Z", + "start_time": "2021-10-12T14:02:27.779549Z" } }, "outputs": [ @@ -546,8 +547,8 @@ "execution_count": 9, "metadata": { "ExecuteTime": { - "end_time": "2021-06-14T07:46:39.456438Z", - "start_time": "2021-06-14T07:46:39.446672Z" + "end_time": "2021-10-12T14:02:28.069912Z", + "start_time": "2021-10-12T14:02:27.898045Z" } }, "outputs": [ @@ -583,8 +584,8 @@ "execution_count": 10, "metadata": { "ExecuteTime": { - "end_time": "2021-06-14T07:46:40.576071Z", - "start_time": "2021-06-14T07:46:40.565331Z" + "end_time": "2021-10-12T14:02:28.190856Z", + "start_time": "2021-10-12T14:02:28.072848Z" } }, "outputs": [ @@ -618,8 +619,8 @@ "execution_count": 11, "metadata": { "ExecuteTime": { - "end_time": "2021-06-14T07:46:41.526267Z", - "start_time": "2021-06-14T07:46:41.517479Z" + "end_time": "2021-10-12T14:02:28.360765Z", + "start_time": "2021-10-12T14:02:28.195755Z" } }, "outputs": [ @@ -627,7 +628,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "16\n" + "12\n" ] } ], @@ -644,8 +645,8 @@ "execution_count": 12, "metadata": { "ExecuteTime": { - "end_time": "2021-06-14T07:46:42.048239Z", - "start_time": "2021-06-14T07:46:42.031641Z" + "end_time": "2021-10-12T14:02:28.435682Z", + "start_time": "2021-10-12T14:02:28.363705Z" } }, "outputs": [ @@ -653,7 +654,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "47\n" + "49\n" ] } ], @@ -681,8 +682,8 @@ "execution_count": 13, "metadata": { "ExecuteTime": { - "end_time": "2021-06-14T07:46:43.349513Z", - "start_time": "2021-06-14T07:46:43.341704Z" + "end_time": "2021-10-12T14:02:28.557118Z", + "start_time": "2021-10-12T14:02:28.438621Z" } }, "outputs": [ @@ -717,8 +718,8 @@ "execution_count": 14, "metadata": { "ExecuteTime": { - "end_time": "2021-06-14T07:46:45.054109Z", - "start_time": "2021-06-14T07:46:45.045322Z" + "end_time": "2021-10-12T14:02:28.666311Z", + "start_time": "2021-10-12T14:02:28.562015Z" } }, "outputs": [ @@ -762,8 +763,8 @@ "execution_count": 15, "metadata": { "ExecuteTime": { - "end_time": "2021-06-14T07:46:46.497469Z", - "start_time": "2021-06-14T07:46:46.478919Z" + "end_time": "2021-10-12T14:02:28.804883Z", + "start_time": "2021-10-12T14:02:28.670228Z" } }, "outputs": [ @@ -833,8 +834,8 @@ "execution_count": 16, "metadata": { "ExecuteTime": { - "end_time": "2021-06-14T07:46:49.371505Z", - "start_time": "2021-06-14T07:46:49.356854Z" + "end_time": "2021-10-12T14:02:28.929252Z", + "start_time": "2021-10-12T14:02:28.807820Z" } }, "outputs": [ @@ -866,8 +867,8 @@ "execution_count": 17, "metadata": { "ExecuteTime": { - "end_time": "2021-06-14T07:46:50.767992Z", - "start_time": "2021-06-14T07:46:50.749439Z" + "end_time": "2021-10-12T14:02:29.020820Z", + "start_time": "2021-10-12T14:02:28.932192Z" } }, "outputs": [], @@ -881,8 +882,8 @@ "execution_count": 18, "metadata": { "ExecuteTime": { - "end_time": "2021-06-14T07:46:51.504810Z", - "start_time": "2021-06-14T07:46:51.484304Z" + "end_time": "2021-10-12T14:02:29.114344Z", + "start_time": "2021-10-12T14:02:29.023756Z" }, "scrolled": true }, @@ -970,8 +971,8 @@ "execution_count": 19, "metadata": { "ExecuteTime": { - "end_time": "2021-06-14T07:46:55.339289Z", - "start_time": "2021-06-14T07:46:55.317811Z" + "end_time": "2021-10-12T14:02:29.223046Z", + "start_time": "2021-10-12T14:02:29.117282Z" } }, "outputs": [ @@ -1014,8 +1015,8 @@ "execution_count": 20, "metadata": { "ExecuteTime": { - "end_time": "2021-06-14T07:46:56.608826Z", - "start_time": "2021-06-14T07:46:56.597109Z" + "end_time": "2021-10-12T14:02:29.332241Z", + "start_time": "2021-10-12T14:02:29.227944Z" } }, "outputs": [ @@ -1049,8 +1050,8 @@ "execution_count": 21, "metadata": { "ExecuteTime": { - "end_time": "2021-06-14T07:46:57.786076Z", - "start_time": "2021-06-14T07:46:57.774360Z" + "end_time": "2021-10-12T14:02:29.473261Z", + "start_time": "2021-10-12T14:02:29.335177Z" } }, "outputs": [ @@ -1080,8 +1081,8 @@ "execution_count": 22, "metadata": { "ExecuteTime": { - "end_time": "2021-06-14T07:46:58.568301Z", - "start_time": "2021-06-14T07:46:58.549753Z" + "end_time": "2021-10-12T14:02:29.566785Z", + "start_time": "2021-10-12T14:02:29.476197Z" } }, "outputs": [ @@ -1124,14 +1125,16 @@ "source": [ "## Python Built-In Modules Examples\n", "\n", - "There are many **built-in** modules in Python. Some of them are as follows: operator, **[random](https://github.com/milaan9/04_Python_Functions/blob/main/008_Python_Function_random_Module.ipynb)** , **[math](https://github.com/milaan9/04_Python_Functions/blob/main/009_Python_Function_math_Module.ipynb.ipynb)**, threading , collections , os , mailbox , string , time , tkinter etc." + "There are many **built-in** modules in Python. Some of the common built-in modules: **`os`**, **[sys](https://docs.python.org/3/library/sys.html)**, **`operator`**, **`string`**, **`decimal`**, **[random](https://github.com/milaan9/04_Python_Functions/blob/main/008_Python_Function_random_Module.ipynb)** , **[math](https://github.com/milaan9/04_Python_Functions/blob/main/009_Python_Function_math_Module.ipynb.ipynb)**, **`statistics`**, **`datetime`**, **`time`**, **`collections`**, **`threading`**, **`mailbox`**, **`tkinter`**, **`json`**, **`re`**, etc." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Example Using Operator Module" + "### Example Using `os` Module\n", + "\n", + "Using python **`os`** module it is possible to automatically perform many operating system tasks. The **`os`** module in Python provides functions for creating, changing current working directory, and removing a directory (folder), fetching its contents, changing and identifying the current directory." ] }, { @@ -1139,8 +1142,163 @@ "execution_count": 23, "metadata": { "ExecuteTime": { - "end_time": "2021-06-14T07:47:01.831496Z", - "start_time": "2021-06-14T07:47:01.822708Z" + "end_time": "2021-10-12T14:02:30.283151Z", + "start_time": "2021-10-12T14:02:29.576580Z" + }, + "scrolled": true + }, + "outputs": [ + { + "ename": "FileExistsError", + "evalue": "[WinError 183] Cannot create a file when that file already exists: 'directory_name'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mFileExistsError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 4\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mos\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 5\u001b[0m \u001b[1;31m# Creating a directory\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 6\u001b[1;33m \u001b[0mos\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmkdir\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'directory_name'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 7\u001b[0m \u001b[1;31m# Changing the current directory\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 8\u001b[0m \u001b[0mos\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mchdir\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'path'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mFileExistsError\u001b[0m: [WinError 183] Cannot create a file when that file already exists: 'directory_name'" + ] + } + ], + "source": [ + "# Example 1:\n", + "\n", + "# import the module\n", + "import os\n", + "# Creating a directory\n", + "os.mkdir('directory_name')\n", + "# Changing the current directory\n", + "os.chdir('path')\n", + "# Getting current working directory\n", + "os.getcwd()\n", + "# Removing directory\n", + "os.rmdir()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Example Using `sys` Module\n", + "\n", + "The **[sys](https://docs.python.org/3/library/sys.html)** module provides functions and variables used to manipulate different parts of the Python runtime environment." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**`sys.argv`** function returns a list of command line arguments passed to a Python script. The item at index 0 in this list is always the name of the script, at index 1 is the argument passed from the command line." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "ExecuteTime": { + "end_time": "2021-10-12T14:02:39.796140Z", + "start_time": "2021-10-12T14:02:39.781456Z" + }, + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "['C:\\\\Users\\\\Deepak\\\\01_Learn_Python4Data\\\\04_Python_Functions',\n", + " 'C:\\\\ProgramData\\\\Anaconda3\\\\python38.zip',\n", + " 'C:\\\\ProgramData\\\\Anaconda3\\\\DLLs',\n", + " 'C:\\\\ProgramData\\\\Anaconda3\\\\lib',\n", + " 'C:\\\\ProgramData\\\\Anaconda3',\n", + " '',\n", + " 'C:\\\\Users\\\\Deepak\\\\AppData\\\\Roaming\\\\Python\\\\Python38\\\\site-packages',\n", + " 'C:\\\\ProgramData\\\\Anaconda3\\\\lib\\\\site-packages',\n", + " 'C:\\\\ProgramData\\\\Anaconda3\\\\lib\\\\site-packages\\\\locket-0.2.1-py3.8.egg',\n", + " 'C:\\\\ProgramData\\\\Anaconda3\\\\lib\\\\site-packages\\\\win32',\n", + " 'C:\\\\ProgramData\\\\Anaconda3\\\\lib\\\\site-packages\\\\win32\\\\lib',\n", + " 'C:\\\\ProgramData\\\\Anaconda3\\\\lib\\\\site-packages\\\\Pythonwin',\n", + " 'C:\\\\ProgramData\\\\Anaconda3\\\\lib\\\\site-packages\\\\IPython\\\\extensions',\n", + " 'C:\\\\Users\\\\Deepak\\\\.ipython']" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import sys\n", + "sys.path" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**First**, create a Python module with the name **`script.py`** and write the below code in that file.\n", + "\n", + "```py\n", + ">>> import sys\n", + ">>> # print(sys.argv[0], argv[1],sys.argv[2]) # this line would print out: filename argument1 argument2\n", + ">>> print('Welcome {}. Enjoy {} for Data Science ^_^'.format(sys.argv[1], sys.argv[2]))\n", + "```\n", + "**Second**, open **`Anaconda Prompt (Anaconda3)`**\n", + "\n", + "**Third**, type system path after **`cd`**\n", + "\n", + "```sy\n", + "cd C:\\\\Users\\\\Deepak\\\\01_Learn_Python4Data\\\\04_Python_Functions\n", + "```\n", + "\n", + "**Forth**, type\n", + "\n", + "```sy\n", + "python script.py Milaan Python\n", + "```\n", + "\n", + "**Output:**\n", + "\n", + "```sy\n", + "Welcome Milaan. Enjoy Python for Data Science ^_^\n", + "```\n", + "\n", + "
\n", + "\n", + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Some useful **`sys`** commands to type in:\n", + "\n", + "```py\n", + "# to exit sys\n", + "sys.exit()\n", + "# To know the largest integer variable it takes\n", + "sys.maxsize\n", + "# To know environment path\n", + "sys.path\n", + "# To know the version of python you are using\n", + "sys.version\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Example Using `operator` Module" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "ExecuteTime": { + "end_time": "2021-10-12T14:02:42.304149Z", + "start_time": "2021-10-12T14:02:42.287505Z" } }, "outputs": [ @@ -1174,16 +1332,81 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Example Using Decimal Module" + "### Example Using `string` Module\n", + "\n", + "A **[string](https://github.com/milaan9/02_Python_Datatypes/blob/main/002_Python_String.ipynb)** module is a useful module for many purposes. The example below shows some use of the string module." ] }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 26, + "metadata": { + "ExecuteTime": { + "end_time": "2021-10-12T14:02:43.381879Z", + "start_time": "2021-10-12T14:02:43.369152Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello World\n", + "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\n" + ] + } + ], + "source": [ + "# Example 1:\n", + "\n", + "from string import *\n", + "print(capwords(\"hello world\")) #capitalizes the first letter of each words\n", + "print(ascii_letters) #prints all lowercase and uppercase letters" + ] + }, + { + "cell_type": "code", + "execution_count": 27, "metadata": { "ExecuteTime": { - "end_time": "2021-06-14T07:47:04.034628Z", - "start_time": "2021-06-14T07:47:03.981892Z" + "end_time": "2021-10-12T14:02:43.805435Z", + "start_time": "2021-10-12T14:02:43.793679Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\n", + "0123456789\n", + "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~\n" + ] + } + ], + "source": [ + "# Example 2:\n", + "\n", + "import string\n", + "print(string.ascii_letters) # abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\n", + "print(string.digits) # 0123456789\n", + "print(string.punctuation) # !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Example Using `decimal` Module" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "ExecuteTime": { + "end_time": "2021-10-12T14:02:45.249910Z", + "start_time": "2021-10-12T14:02:45.199966Z" } }, "outputs": [ @@ -1210,7 +1433,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Example Using Random Module\n", + "### Example Using `random` Module\n", "\n", "The **[random](https://github.com/milaan9/04_Python_Functions/blob/main/008_Python_Function_random_Module.ipynb)** module is used to generate the random numbers. It provides the following two built in functions:\n", "\n", @@ -1224,11 +1447,11 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 29, "metadata": { "ExecuteTime": { - "end_time": "2021-06-14T07:47:05.474084Z", - "start_time": "2021-06-14T07:47:05.462368Z" + "end_time": "2021-10-12T14:02:46.106312Z", + "start_time": "2021-10-12T14:02:46.097503Z" } }, "outputs": [ @@ -1236,9 +1459,9 @@ "name": "stdout", "output_type": "stream", "text": [ + "10\n", "16\n", - "56\n", - "14.946114032122827\n" + "13.03505598723366\n" ] } ], @@ -1256,11 +1479,11 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 30, "metadata": { "ExecuteTime": { - "end_time": "2021-06-14T07:47:06.164515Z", - "start_time": "2021-06-14T07:47:06.157682Z" + "end_time": "2021-10-12T14:02:46.586662Z", + "start_time": "2021-10-12T14:02:46.570998Z" } }, "outputs": [ @@ -1268,8 +1491,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "0.6730248317695879\n", - "3\n" + "0.2946014910624595\n", + "8\n" ] } ], @@ -1284,19 +1507,23 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 31, "metadata": { "ExecuteTime": { - "end_time": "2021-06-14T07:47:07.220182Z", - "start_time": "2021-06-14T07:47:07.214327Z" + "end_time": "2021-10-12T14:02:46.953905Z", + "start_time": "2021-10-12T14:02:46.897105Z" } }, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "16\n" + "ename": "TypeError", + "evalue": "'module' object is not callable", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[1;32mfrom\u001b[0m \u001b[0mrandom\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mrandint\u001b[0m \u001b[1;31m# import randint function\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 4\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrandom\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m# it doesn't take any arguments; it returns a value between 0 and 0.9999\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 6\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 7\u001b[0m \u001b[1;31m# call randint function to get random number\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mTypeError\u001b[0m: 'module' object is not callable" ] } ], @@ -1305,49 +1532,17 @@ "\n", "from random import randint # import randint function\n", "\n", - "# call randint function to get random number\n", - "print(randint(10, 30)) " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Example Using String Module" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": { - "ExecuteTime": { - "end_time": "2021-06-14T07:47:09.181611Z", - "start_time": "2021-06-14T07:47:09.165991Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Hello World\n", - "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\n" - ] - } - ], - "source": [ - "# Example 1:\n", + "print(random()) # it doesn't take any arguments; it returns a value between 0 and 0.9999\n", "\n", - "from string import *\n", - "print(capwords(\"hello world\")) #capitalizes the first letter of each words\n", - "print(ascii_letters) #prints all lowercase and uppercase letters" + "# call randint function to get random number\n", + "print(randint(10, 30)) # it returns a random integer number between [10, 30] inclusive" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Example Using Math Module\n", + "### Example Using `math` Module\n", "\n", "Using **[math](https://github.com/milaan9/04_Python_Functions/blob/main/009_Python_Function_math_Module.ipynb.ipynb)** module, you can use different built in mathematical functions.\n", "\n", @@ -1368,11 +1563,11 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 32, "metadata": { "ExecuteTime": { - "end_time": "2021-06-14T07:47:10.976053Z", - "start_time": "2021-06-14T07:47:10.965311Z" + "end_time": "2021-10-12T14:02:48.223575Z", + "start_time": "2021-10-12T14:02:48.206931Z" } }, "outputs": [ @@ -1389,17 +1584,17 @@ "# Example 1:\n", "\n", "from math import *\n", - "print(sqrt(16)) #prints the square root of the value 16 in the form of a floating-point value\n", - "print(factorial(5)) #prints the factorial of the value 5" + "print(sqrt(16)) # prints the square root of the value 16 in the form of a floating-point value\n", + "print(factorial(5)) # prints the factorial of the value 5" ] }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 33, "metadata": { "ExecuteTime": { - "end_time": "2021-06-14T07:47:11.779765Z", - "start_time": "2021-06-14T07:47:11.767073Z" + "end_time": "2021-10-12T14:02:49.064312Z", + "start_time": "2021-10-12T14:02:49.042770Z" }, "scrolled": true }, @@ -1416,7 +1611,8 @@ "8.0\n", "0.0\n", "1.0\n", - "1.6197751905438615\n" + "1.6197751905438615\n", + "2.0\n" ] } ], @@ -1426,16 +1622,17 @@ "import math\n", "\n", "a=4.6\n", - "print(math.ceil(a))\n", - "print(math.floor(a))\n", + "print(math.ceil(a)) # 5, rounding to the highest\n", + "print(math.floor(a)) # 4, rounding to the lowest\n", "b=9\n", - "print(math.sqrt(b))\n", - "print(math.exp(3.0))\n", - "print(math.log(2.0))\n", - "print(math.pow(2.0,3.0))\n", - "print(math.sin(0))\n", - "print(math.cos(0))\n", - "print (math.tan(45))" + "print(math.sqrt(b)) # 3.0, square root\n", + "print(math.exp(3.0)) # 20.085536923187668\n", + "print(math.log(2.0)) # 0.6931471805599453\n", + "print(math.pow(2.0,3.0)) # 8.0, exponential function\n", + "print(math.sin(0)) # 0.0\n", + "print(math.cos(0)) # 1.0\n", + "print (math.tan(45)) # 1.6197751905438615\n", + "print(math.log10(100)) # 2.0, logarithm with 10 as base " ] }, { @@ -1452,11 +1649,11 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 34, "metadata": { "ExecuteTime": { - "end_time": "2021-06-14T07:47:13.590315Z", - "start_time": "2021-06-14T07:47:13.581529Z" + "end_time": "2021-10-12T14:02:50.965636Z", + "start_time": "2021-10-12T14:02:50.945076Z" } }, "outputs": [ @@ -1472,10 +1669,52 @@ "source": [ "# Example 3:\n", "\n", - "import math\n", + "import math \n", "\n", - "print(\"math.pi : \",math.pi)\n", - "print(\"math.e : \",math.e)" + "print(\"math.pi : \",math.pi) # 3.141592653589793, pi constant\n", + "print(\"math.e : \",math.e) # 2.718281828459045, e constant" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Example Using `statistics` Module\n", + "\n", + "The statistics module provides functions for mathematical statistics of numeric data. The popular statistical functions which are defined in this module: **`mean`**, **`median`**, **`mode`**, **`stdev`** etc." + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "ExecuteTime": { + "end_time": "2021-10-12T14:02:52.744549Z", + "start_time": "2021-10-12T14:02:52.645153Z" + }, + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "21.09090909090909\n", + "22\n", + "20\n", + "6.106628291529549\n" + ] + } + ], + "source": [ + "# Example 1:\n", + "\n", + "from statistics import * # importing all the statistics modules\n", + "ages = [20, 20, 4, 24, 25, 22, 26, 20, 23, 22, 26]\n", + "print(mean(ages)) # ~22.9\n", + "print(median(ages)) # 23\n", + "print(mode(ages)) # 20\n", + "print(stdev(ages)) # ~2.3" ] }, { @@ -1487,6 +1726,66 @@ "Since Python provides a lot of built-in modules, it is advisable to use built-in modules rather than user-created modules to perform basic operations." ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 💻 Exercises ➞ Module\n", + "\n", + "### Exercises ➞ Level 1\n", + "\n", + "1. Writ a function which generates a six digit/character **`random_user_id`**.\n", + " - ```py\n", + " print(random_user_id());\n", + " '1ee33d'\n", + " ```\n", + "2. Modify the previous task. Declare a function named **`user_id_gen_by_user`**. It doesn’t take any parameters but it takes two inputs using **`input()`**. One of the inputs is the number of characters and the second input is the number of IDs which are supposed to be generated.\n", + " \n", + " - ```py\n", + "print(user_id_gen_by_user()) # user input: 5 5\n", + "#output:\n", + "#kcsy2\n", + "#SMFYb\n", + "#bWmeq\n", + "#ZXOYh\n", + "#2Rgxf\n", + " ``` \n", + " \n", + " - ```py\n", + "print(user_id_gen_by_user()) # 16 5\n", + "#1GCSgPLMaBAVQZ26\n", + "#YD7eFwNQKNs7qXaT\n", + "#ycArC5yrRupyG00S\n", + "#UbGxOFI7UXSWAyKN\n", + "#dIV0SSUTgAdKwStr\n", + " ```\n", + "\n", + "3. Write a function named **`rgb_color_gen`**. It will generate rgb colors (3 values ranging from 0 to 255 each).\n", + " \n", + " - ```py\n", + "print(rgb_color_gen()) \n", + "#rgb(125,244,255) - the output should be in this form\n", + " ```\n", + " \n", + "### Exercises ➞ Level 2\n", + "\n", + "1. Write a function **`list_of_hexa_colors`** which returns any number of hexadecimal colors in an array (six hexadecimal numbers written after **`#`**. Hexadecimal numeral system is made out of 16 symbols, 0-9 and first 6 letters of the alphabet, a-f. Check the task 6 for output examples).\n", + "2. Write a function **`list_of_rgb_colors`** which returns any number of RGB colors in an array.\n", + "3. Write a function **`generate_colors`** which can generate any number of hexa or rgb colors.\n", + "\n", + " - ```py\n", + " generate_colors('hexa', 3) # ['#a3e12f','#03ed55','#eb3d2b'] \n", + " generate_colors('hexa', 1) # ['#b334ef']\n", + " generate_colors('rgb', 3) # ['rgb(5, 55, 175','rgb(50, 105, 100','rgb(15, 26, 80'] \n", + " generate_colors('rgb', 1) # ['rgb(33,79, 176)']\n", + " ```\n", + " \n", + "### Exercises ➞ Level 3\n", + "\n", + "1. Call your function **`shuffle_list`**, it takes a list as a parameter and it returns a shuffled list\n", + "2. Write a function which returns an array of seven random numbers in a range of 0-9. All the numbers must be unique." + ] + }, { "cell_type": "code", "execution_count": null, diff --git a/008_Python_Function_random_Module.ipynb b/008_Python_Function_random_Module.ipynb index a6bccb8..807ed21 100644 --- a/008_Python_Function_random_Module.ipynb +++ b/008_Python_Function_random_Module.ipynb @@ -5,7 +5,7 @@ "metadata": {}, "source": [ "\n", - "All the IPython Notebooks in this lecture series by Dr. Milan Parmar are available @ **[GitHub](https://github.com/milaan9/04_Python_Functions)**\n", + "All the IPython Notebooks in **Python Functions** lecture series by Dr. Milaan Parmar are available @ **[GitHub](https://github.com/milaan9/04_Python_Functions)**\n", "" ] }, diff --git a/009_Python_Function_math_Module.ipynb.ipynb b/009_Python_Function_math_Module.ipynb.ipynb index f431b51..42ea443 100644 --- a/009_Python_Function_math_Module.ipynb.ipynb +++ b/009_Python_Function_math_Module.ipynb.ipynb @@ -5,7 +5,7 @@ "metadata": {}, "source": [ "\n", - "All the IPython Notebooks in this lecture series by Dr. Milan Parmar are available @ **[GitHub](https://github.com/milaan9/04_Python_Functions)**\n", + "All the IPython Notebooks in **Python Functions** lecture series by Dr. Milaan Parmar are available @ **[GitHub](https://github.com/milaan9/04_Python_Functions)**\n", "" ] }, diff --git a/010_Python_Function_Package.ipynb b/010_Python_Function_Package.ipynb index 66a3fbb..b8ea88b 100644 --- a/010_Python_Function_Package.ipynb +++ b/010_Python_Function_Package.ipynb @@ -5,7 +5,7 @@ "metadata": {}, "source": [ "\n", - "All the IPython Notebooks in this lecture series by Dr. Milan Parmar are available @ **[GitHub](https://github.com/milaan9/04_Python_Functions)**\n", + "All the IPython Notebooks in **Python Functions** lecture series by Dr. Milaan Parmar are available @ **[GitHub](https://github.com/milaan9/04_Python_Functions)**\n", "" ] }, diff --git a/LICENSE b/LICENSE index 1642570..257d417 100644 --- a/LICENSE +++ b/LICENSE @@ -1,49 +1,21 @@ -The instructions and text in this tutorial (the "software") are licensed -under the zlib License. - - (C) 2019-2021 milaan9 - - This software is provided 'as-is', without any express or implied - warranty. In no event will the authors be held liable for any damages - arising from the use of this software. - - Permission is granted to anyone to use this software for any purpose, - including commercial applications, and to alter it and redistribute it - freely, subject to the following restrictions: - - 1. The origin of this software must not be misrepresented; you must not - claim that you wrote the original software. If you use this software - in a product, an acknowledgment in the product documentation would be - appreciated but is not required. - 2. Altered source versions must be plainly marked as such, and must not be - misrepresented as being the original software. - 3. This notice may not be removed or altered from any source distribution. - - - -The code examples (the "software") are unlicensed: - - This is free and unencumbered software released into the public domain. - - Anyone is free to copy, modify, publish, use, compile, sell, or - distribute this software, either in source code form or as a compiled - binary, for any purpose, commercial or non-commercial, and by any - means. - - In jurisdictions that recognize copyright laws, the author or authors - of this software dedicate any and all copyright interest in the - software to the public domain. We make this dedication for the benefit - of the public at large and to the detriment of our heirs and - successors. We intend this dedication to be an overt act of - relinquishment in perpetuity of all present and future rights to this - software under copyright law. - - THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, - EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF - MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. - IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR - OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, - ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR - OTHER DEALINGS IN THE SOFTWARE. - - For more information, please refer to +MIT License + +Copyright (c) 2021 milaan9 + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/Python_Docstrings.ipynb b/Python_Docstrings.ipynb index bf814bd..acfd122 100644 --- a/Python_Docstrings.ipynb +++ b/Python_Docstrings.ipynb @@ -5,7 +5,7 @@ "metadata": {}, "source": [ "\n", - "All the IPython Notebooks in this lecture series by Dr. Milan Parmar are available @ **[GitHub](https://github.com/milaan9/04_Python_Functions)**\n", + "All the IPython Notebooks in **Python Functions** lecture series by Dr. Milaan Parmar are available @ **[GitHub](https://github.com/milaan9/04_Python_Functions)**\n", "" ] }, diff --git a/Python_User_defined_Functions.ipynb b/Python_User_defined_Functions.ipynb index e871f52..c59922b 100644 --- a/Python_User_defined_Functions.ipynb +++ b/Python_User_defined_Functions.ipynb @@ -5,7 +5,7 @@ "metadata": {}, "source": [ "\n", - "All the IPython Notebooks in this lecture series by Dr. Milan Parmar are available @ **[GitHub](https://github.com/milaan9/04_Python_Functions)**\n", + "All the IPython Notebooks in **Python Functions** lecture series by Dr. Milaan Parmar are available @ **[GitHub](https://github.com/milaan9/04_Python_Functions)**\n", "" ] }, diff --git a/README.md b/README.md index 51208c8..e1c5cef 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,24 @@ +

+Last Commit + + + + +Stars Badge +Forks Badge +Size +Pull Requests Badge +Issues Badge +Language +MIT License +

+ + +

+binder +colab +

+ # 04_Python_Functions ## Introduction 👋 @@ -8,72 +29,58 @@ Python has a DRY principle like other programming languages. DRY stands for Don Function improves efficiency and reduces errors because of the reusability of a code. Once we create a function, we can call it anywhere and anytime. The benefit of using a function is reusability and modularity. +--- ## Table of contents 📋 +| **No.** | **Name** | +| ------- | -------- | +| 01 | **[Python_Functions](https://github.com/milaan9/04_Python_Functions/blob/main/001_Python_Functions.ipynb)** | +| | 1.1 **[Python_Docstrings](https://github.com/milaan9/04_Python_Functions/blob/main/Python_Docstrings.ipynb)** | +| | 1.2 **[Python_Built-In_Functions](https://github.com/milaan9/04_Python_Functions/tree/main/002_Python_Functions_Built_in)** | +| | 1.3 **[Python_User-Defined_Functions](https://github.com/milaan9/04_Python_Functions/blob/main/Python_User_defined_Functions.ipynb)** | +| 02 | **[Python_Function_Global_Local_Nonlocal](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Function_Global_Local_Nonlocal.ipynb)** | +| 03 | **[Python_Function_global_Keywords](https://github.com/milaan9/04_Python_Functions/blob/main/003_Python_Function_global_Keywords.ipynb)** | +| 04 | **[Python_Function_Arguments](https://github.com/milaan9/04_Python_Functions/blob/main/004_Python_Function_Arguments.ipynb)** | +| 05 | **[Python_Function_Recursion](https://github.com/milaan9/04_Python_Functions/blob/main/005_Python_Function_Recursion.ipynb)** | +| 06 | **[Python_Function_Anonymous](https://github.com/milaan9/04_Python_Functions/blob/main/006_Python_Function_Anonymous.ipynb)** | +| 07 | **[Python_Function_Module](https://github.com/milaan9/04_Python_Functions/blob/main/007_Python_Function_Module.ipynb)** | +| 08 | **[Python_Function_random_Module](https://github.com/milaan9/04_Python_Functions/blob/main/008_Python_Function_random_Module.ipynb)** | +| 09 | **[Python_Function_math_Module.ipynb](https://github.com/milaan9/04_Python_Functions/blob/main/009_Python_Function_math_Module.ipynb.ipynb)** | +| 10 | **[Python_Function_Package](https://github.com/milaan9/04_Python_Functions/blob/main/010_Python_Function_Package.ipynb)** | -[001_Python_Functions](https://github.com/milaan9/04_Python_Functions/blob/main/001_Python_Functions.ipynb) +These are online **read-only** versions. However you can **`Run ▶`** all the codes **online** by clicking here ➞ binder -[002_Python_Function_Global_Local_Nonlocal](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Function_Global_Local_Nonlocal.ipynb) - - -[003_Python_Function_global_Keywords](https://github.com/milaan9/04_Python_Functions/blob/main/003_Python_Function_global_Keywords.ipynb) - - -[004_Python_Function_Arguments](https://github.com/milaan9/04_Python_Functions/blob/main/004_Python_Function_Arguments.ipynb) - - -[005_Python_Function_Recursion](https://github.com/milaan9/04_Python_Functions/blob/main/005_Python_Function_Recursion.ipynb) - - -[006_Python_Function_Anonymous](https://github.com/milaan9/04_Python_Functions/blob/main/006_Python_Function_Anonymous.ipynb) - - -[007_Python_Function_Module](https://github.com/milaan9/04_Python_Functions/blob/main/007_Python_Function_Module.ipynb) - - -[008_Python_Function_random_Module](https://github.com/milaan9/04_Python_Functions/blob/main/008_Python_Function_random_Module.ipynb) - - -[009_Python_Function_math_Module.ipynb](https://github.com/milaan9/04_Python_Functions/blob/main/009_Python_Function_math_Module.ipynb.ipynb) - - -[010_Python_Function_Package](https://github.com/milaan9/04_Python_Functions/blob/main/010_Python_Function_Package.ipynb) - - -[Python_Docstrings](https://github.com/milaan9/04_Python_Functions/blob/main/Python_Docstrings.ipynb) - - -These are online read-only versions. - +--- ## Frequently asked questions ❔ ### How can I thank you for writing and sharing this tutorial? 🌷 -You can ⭐ star this tutorial. Starring is free for you, but it tells me and other people that it was helpful and you like this tutorial. +You can Star Badge and Fork Badge Starring and Forking is free for you, but it tells me and other people that it was helpful and you like this tutorial. -Go [here](https://github.com/milaan9/04_Python_Functions) if you aren't here already and click the "⭐ Star" button in the top right corner. You will be asked to create a GitHub account if you don't already have one. +Go [**`here`**](https://github.com/milaan9/04_Python_Functions) if you aren't here already and click ➞ **`✰ Star`** and **`ⵖ Fork`** button in the top right corner. You'll be asked to create a GitHub account if you don't already have one. -### How can I read this tutorial without an Internet connection? 🤔 +--- -1. Go [here](https://github.com/milaan9/04_Python_Functions) if you aren't here already. - -2. Click the big green "Clone or download" button in the top right of the page, then click "[Download ZIP](https://github.com/milaan9/04_Python_Functions/archive/refs/heads/main.zip)". +### How can I read this tutorial without an Internet connection? GIF + +1. Go [**`here`**](https://github.com/milaan9/04_Python_Functions) and click the big green ➞ **`Code`** button in the top right of the page, then click ➞ [**`Download ZIP`**](https://github.com/milaan9/04_Python_Functions/archive/refs/heads/main.zip). ![Download ZIP](img/dnld_rep.png) -3. Extract the ZIP and open it. Unfortunately I don't have any more specific instructions because how exactly this is done depends on which operating system you run. +2. Extract the ZIP and open it. Unfortunately I don't have any more specific instructions because how exactly this is done depends on which operating system you run. -4. Launch ipython notebook from the folder which contains the notebooks. Open each one of them +3. Launch ipython notebook from the folder which contains the notebooks. Open each one of them - `Cell > All Output > Clear` + **`Kernel > Restart & Clear Output`** This will clear all the outputs and now you can understand each statement and learn interactively. If you have git and you know how to use it, you can also clone the repository instead of downloading a zip and extracting it. An advantage with doing it this way is that you don't need to download the whole tutorial again to get the latest version of it, all you need to do is to pull with git and run ipython notebook again. +--- ## Authors ✍️ @@ -85,6 +92,7 @@ If you have trouble with this tutorial please tell me about it by [Create an iss If you like this tutorial, please [give it a ⭐ star](https://github.com/milaan9/04_Python_Functions). +--- ## Licence 📜 diff --git a/img/anaconda_prompt.png b/img/anaconda_prompt.png new file mode 100644 index 0000000..8ba6673 Binary files /dev/null and b/img/anaconda_prompt.png differ diff --git a/script.py b/script.py new file mode 100644 index 0000000..38ebc2b --- /dev/null +++ b/script.py @@ -0,0 +1,7 @@ +import sys +#print(sys.argv[0], argv[1],sys.argv[2]) # this line would print out: filename argument1 argument2 +print('Welcome {}. Enjoy {} for Data Science ^_^'.format(sys.argv[1], sys.argv[2])) + + + +