01_Intro_Python.ipynb

{"cells":[{"cell_type":"markdown","metadata":{"id":"qe-iERjMs46Y"},"source":["# Python\n","\n","Python is a high-level, interpreted programming language that is known for its simplicity and readability. Created by Guido van Rossum and first released in 1991, Python's design philosophy emphasizes code readability and simplicity, making it an excellent choice for beginners and experienced programmers alike.\n","\n","Python supports multiple programming paradigms, including procedural, object-oriented, and functional programming. It has a large standard library and an active community, which makes it a powerful tool for a wide variety of applications, from web development to data analysis and scientific computing.\n","\n","In this notebook, we will cover the basics of Python programming to get you started on your coding journey.\n","\n","What we want to achieve today:\n","\n","\n","1.   General Introduction to Python\n","\n"]},{"cell_type":"markdown","metadata":{"id":"-pJnhAi4t_RV"},"source":["# Introduction to Python\n","## Downloading and Installing Python\n","\n","To start using Python on your local machine, you'll need to download and install it. Here are the steps to do so:\n","\n","1. **Visit the Python website:**\n","   Go to the official Python website at [python.org](https://www.python.org/).\n","\n","2. **Download the installer:**\n","   On the Python homepage, you will see a \"Download Python\" button. Click on it to download the latest version of Python. The website should automatically suggest the best version for your operating system (Windows, macOS, or Linux).\n","\n","3. **Run the installer:**\n","   Once the download is complete, run the installer. During the installation process, make sure to check the box that says \"Add Python to PATH.\" This will make it easier to run Python from the command line.\n","\n","4. **Complete the installation:**\n","   Follow the prompts to complete the installation. After the installation is finished, you can verify that Python is installed correctly by opening a command prompt (or terminal) and typing `python --version`. You should see the version of Python that you installed.\n","\n","That's it! You now have Python installed on your computer.\n","\n","## Using Google Colab\n","\n","While it's useful to have Python installed on your local machine, for this course, we recommend using Google Colab. Google Colab is a free, cloud-based Jupyter notebook environment that allows you to write and execute Python code in your web browser. Here are some benefits of using Google Colab:\n","\n","- **No installation required:** You can start coding immediately without having to install any software.\n","- **Access from anywhere:** Since your notebooks are stored in Google Drive, you can access them from any device with an internet connection.\n","- **Free access to GPUs:** Google Colab provides free access to GPUs, which can be beneficial for more computationally intensive tasks like machine learning.\n","- **Easy collaboration:** You can easily share your notebooks with others and collaborate in real-time.\n","\n","To get started with Google Colab, follow these steps:\n","\n","1. **Open Google Colab:**\n","   Go to [Google Colab](https://colab.research.google.com/) in your web browser.\n","\n","2. **Sign in with your Google account:**\n","   If you aren't already signed in, you will need to sign in with your Google account.\n","\n","3. **Create a new notebook:**\n","   Click on \"File\" -> \"New Notebook\" to create a new Jupyter notebook.\n","\n","4. **Start coding:**\n","   You can now start writing and executing Python code in the cells of your notebook. To run a cell, click the \"Run\" button or press `Shift + Enter`.\n","\n","Throughout this course, we'll be providing code snippets and examples that you can run directly in Google Colab. This will make it easier for you to follow along and practice coding in Python.\n","\n","Let's get started with the basics of Python programming!"]},{"cell_type":"markdown","metadata":{"id":"iJqC5E8HveJe"},"source":[]},{"cell_type":"markdown","metadata":{"id":"HC431fUbvjWv"},"source":["# 1. General Introduction to Python\n","## Let's start\n","\n","### Hello World!\n","\n","Python is a simple and straightforward language with clear syntax. It allows programmers to write code without the need for boilerplate (pre-prepared) code. The most basic command in Python is the \"print\" statement, which outputs a line of text and includes a newline character, unlike in C.\n","\n","There are two main versions of Python: Python 2 and Python 3. These versions are significantly different from each other. This tutorial uses Python 3 because it is more semantically correct and supports newer features.\n","\n","For instance, one key difference between Python 2 and Python 3 is how the print statement is used. In Python 2, \"print\" is not a function and is used without parentheses. In Python 3, however, \"print\" is a function and requires parentheses.\n","\n","To print a string in Python 3, simply write:"]},{"cell_type":"code","execution_count":2,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":263,"status":"ok","timestamp":1716894268121,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"EATVz4MP3xwZ","outputId":"4346718e-c937-448e-da78-1ec95d0b81cb"},"outputs":[{"name":"stdout","output_type":"stream","text":["Hello, World!\n"]}],"source":["print(\"Hello, World!\")"]},{"cell_type":"markdown","metadata":{"id":"I1fi0Gh8FXY4"},"source":["### Indentation\n","Python uses indentation to define code blocks instead of curly braces. Both tabs and spaces can be used for indentation, but the standard practice is to use four spaces for each level of indentation. For example:"]},{"cell_type":"code","execution_count":3,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":274,"status":"ok","timestamp":1716897876809,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"th2Dk9ZdFY3T","outputId":"1529defa-5bf3-4a96-aa7a-4faa917e0d21"},"outputs":[{"name":"stdout","output_type":"stream","text":["This is an indented block\n"]}],"source":["if True:\n","    # indented four spaces\n","    print(\"This is an indented block\")"]},{"cell_type":"markdown","metadata":{"id":"-LUuyQ53F-qT"},"source":["## Variables and Types\n","Python is fully object-oriented and dynamically typed, meaning you don't need to declare variables or their types before using them. Every variable in Python is an object.\n","\n","This tutorial will cover a few basic types of variables.\n","### Numbers\n","Python supports two types of numbers: integers (whole numbers) and floating-point numbers (decimals). (It also supports complex numbers, but these will not be covered in this tutorial).\n","\n","To define an integer, use the following syntax:"]},{"cell_type":"code","execution_count":4,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":250,"status":"ok","timestamp":1716898108893,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"Vy0YboOCGf5j","outputId":"2e495024-3d5f-431e-b668-ae9c9a6c11cd"},"outputs":[{"name":"stdout","output_type":"stream","text":["3\n"]}],"source":["myint = 3\n","print(myint)"]},{"cell_type":"markdown","metadata":{"id":"Hm1V_T_yGw4P"},"source":["To define a floating-point number, you can use one of the following notations:"]},{"cell_type":"code","execution_count":5,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":302,"status":"ok","timestamp":1716898197759,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"Rt4l3O3yGyAs","outputId":"60ee5939-81ae-416d-b662-7623bf8de74d"},"outputs":[{"name":"stdout","output_type":"stream","text":["3.0\n","3.0\n"]}],"source":["myfloat = 3.0\n","print(myfloat)\n","myfloat = float(3)\n","print(myfloat)"]},{"cell_type":"markdown","metadata":{"id":"3G0P4xpeG8vW"},"source":["### Strings\n","Strings can be defined using either single quotes or double quotes."]},{"cell_type":"code","execution_count":6,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":275,"status":"ok","timestamp":1716898319735,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"avsWqoVBHTdI","outputId":"6afb4220-abc9-4939-fce9-68e44bc60bd3"},"outputs":[{"name":"stdout","output_type":"stream","text":["hello\n","hello\n"]}],"source":["mystring = 'hello'\n","print(mystring)\n","mystring = \"hello\"\n","print(mystring)"]},{"cell_type":"markdown","metadata":{"id":"XDkpkLUAHjAw"},"source":["The difference between the two is that using double quotes allows you to include apostrophes within the string without terminating it."]},{"cell_type":"code","execution_count":7,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":299,"status":"ok","timestamp":1716898402274,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"Pc2vAYWgHkWO","outputId":"c1fea95e-b169-48d6-8770-bc8a29e41b15"},"outputs":[{"name":"stdout","output_type":"stream","text":["Don't worry about apostrophes\n"]}],"source":["mystring = \"Don't worry about apostrophes\"\n","print(mystring)"]},{"cell_type":"markdown","metadata":{"id":"55INi8jwH314"},"source":["There are other ways to define strings that facilitate the inclusion of features like carriage returns, backslashes, and Unicode characters. However, these are not covered in this tutorial but are explained in the Python [documentation](https://docs.python.org/3/).\n","\n","Basic operators can be applied to both numbers and strings:"]},{"cell_type":"code","execution_count":8,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":256,"status":"ok","timestamp":1716898535093,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"WIO0T6BMIDd0","outputId":"e9224724-9519-4737-8ed8-824641415658"},"outputs":[{"name":"stdout","output_type":"stream","text":["3\n","hello world\n"]}],"source":["one = 1\n","two = 2\n","three = one + two\n","print(three)\n","\n","hello = \"hello\"\n","world = \"world\"\n","helloworld = hello + \" \" + world\n","print(helloworld)"]},{"cell_type":"markdown","metadata":{"id":"A00B6ahpIVY3"},"source":["Multiple variables can be assigned values simultaneously on the same line like this:"]},{"cell_type":"code","execution_count":9,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":243,"status":"ok","timestamp":1716898606497,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"Sxl5xBKtIWT-","outputId":"c8708363-baa6-4a10-f89e-8ed39500f635"},"outputs":[{"name":"stdout","output_type":"stream","text":["3 4\n"]}],"source":["a, b = 3, 4\n","print(a, b)"]},{"cell_type":"markdown","metadata":{"id":"YPsce0i8IcGT"},"source":["Python does not support mixing operators between numbers and strings."]},{"cell_type":"code","execution_count":10,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":176},"executionInfo":{"elapsed":283,"status":"error","timestamp":1716898661022,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"luZBY5YVIjZn","outputId":"c149eece-5ad2-40e9-fa74-4dbd5059d415"},"outputs":[{"ename":"TypeError","evalue":"unsupported operand type(s) for +: 'int' and 'str'","output_type":"error","traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)","\u001b[0;32m<ipython-input-10-fa035bb013ee>\u001b[0m in \u001b[0;36m<cell line: 6>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mhello\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"hello\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mone\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mtwo\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mhello\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m","\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"]}],"source":["# This will not work!\n","one = 1\n","two = 2\n","hello = \"hello\"\n","\n","print(one + two + hello)"]},{"cell_type":"markdown","metadata":{"id":"0eEr74esIwAS"},"source":["## Lists\n","Lists in Python are akin to arrays. They can accommodate variables of any type and any number of variables. Lists can also be iterated over in a straightforward manner. Here's an example demonstrating how to construct a list."]},{"cell_type":"code","execution_count":11,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":291,"status":"ok","timestamp":1716898748858,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"3gTOzzT1I6MT","outputId":"c1a29d3c-8be8-4948-8f2b-79273121e1a3"},"outputs":[{"name":"stdout","output_type":"stream","text":["1\n","2\n","3\n","1\n","2\n","3\n"]}],"source":["mylist = []\n","mylist.append(1)\n","mylist.append(2)\n","mylist.append(3)\n","print(mylist[0]) # prints 1\n","print(mylist[1]) # prints 2\n","print(mylist[2]) # prints 3\n","\n","# prints out 1,2,3\n","for x in mylist:\n","    print(x)"]},{"cell_type":"markdown","metadata":{"id":"T3aRC0t9JI3h"},"source":["Attempting to access an index that doesn't exist will result in an exception (error)."]},{"cell_type":"code","execution_count":12,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":159},"executionInfo":{"elapsed":268,"status":"error","timestamp":1716898810603,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"cWF7HxRdJJwU","outputId":"18c64670-b77f-4336-e333-088addfc7fa3"},"outputs":[{"ename":"IndexError","evalue":"list index out of range","output_type":"error","traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)","\u001b[0;32m<ipython-input-12-ac9eeac6db06>\u001b[0m in \u001b[0;36m<cell line: 2>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mmylist\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmylist\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m","\u001b[0;31mIndexError\u001b[0m: list index out of range"]}],"source":["mylist = [1,2,3]\n","print(mylist[10])"]},{"cell_type":"markdown","metadata":{"id":"EKfcIQQmy_7K"},"source":["In Python, lists, tuples, and sets are common data structures that have distinct characteristics and use cases.\n","\n","A list is an ordered collection of items that is mutable, meaning you can modify its contents after it is created. Lists are defined using square brackets, for example, my_list = [1, 2, 3]. They allow duplicate elements and support indexing and slicing, making them versatile for various operations where order and mutability are important.\n","\n","A tuple, on the other hand, is also an ordered collection of items but is immutable. Once a tuple is created, its elements cannot be changed, added, or removed. Tuples are defined using parentheses, for example, my_tuple = (1, 2, 3). Like lists, they allow duplicates and support indexing and slicing. Tuples are useful for storing a sequence of values that should not change throughout the program.\n","\n","A set is an unordered collection of unique items. Unlike lists and tuples, sets are mutable but do not allow duplicate elements. Sets are defined using curly braces, for example, my_set = {1, 2, 3}. Since sets are unordered, they do not support indexing or slicing. Sets are particularly useful for membership testing and eliminating duplicate entries from a collection.\n","\n","In summary, while lists and tuples maintain order, lists are mutable, and tuples are immutable. Sets, however, are unordered collections that only store unique elements."]},{"cell_type":"markdown","metadata":{"id":"4C9agstaJdoT"},"source":["## Basic Operators\n","This section provides an overview of using basic operators in Python.\n","\n","### Arithmetic Operators\n","Similar to other programming languages, Python allows the use of addition, subtraction, multiplication, and division operators with numbers."]},{"cell_type":"code","execution_count":13,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":239,"status":"ok","timestamp":1716898968351,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"7-YDUZHkJvcH","outputId":"0c257e96-1fa8-4fa7-e6f8-b57bd81c2c42"},"outputs":[{"name":"stdout","output_type":"stream","text":["2.5\n"]}],"source":["number = 1 + 2 * 3 / 4.0\n","print(number)"]},{"cell_type":"markdown","metadata":{"id":"XaQcsCOxKeDo"},"source":["Attempt to anticipate the result. Does Python adhere to the order of operations?\n","\n","Another operator at your disposal is the modulo (%) operator, which yields the integer remainder of a division. dividend % divisor equals remainder."]},{"cell_type":"code","execution_count":14,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":249,"status":"ok","timestamp":1716899170115,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"CnNQkye3KgiY","outputId":"ad7ecb5f-ec78-4450-aaeb-6a61ce340335"},"outputs":[{"name":"stdout","output_type":"stream","text":["2\n"]}],"source":["remainder = 14 % 3\n","print(remainder)"]},{"cell_type":"markdown","metadata":{"id":"FLg6XctAKtKT"},"source":["Using two asterisks denotes a power relationship."]},{"cell_type":"code","execution_count":16,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":261,"status":"ok","timestamp":1716899269545,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"7YgX5KJDKvc8","outputId":"ebc637df-d9b7-4f04-d61c-7ea749944671"},"outputs":[{"name":"stdout","output_type":"stream","text":["25\n","8\n"]}],"source":["squared = 5 ** 2\n","cubed = 2 ** 3\n","print(squared)\n","print(cubed)"]},{"cell_type":"markdown","metadata":{"id":"xK4WgWO4LDgh"},"source":["### Using Operators with Strings\n","Python allows strings to be concatenated using the addition operator."]},{"cell_type":"code","execution_count":17,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":360,"status":"ok","timestamp":1716899347271,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"yIEYny9hLO0-","outputId":"3fa5870f-d280-4b07-a63d-a5bc274a70dd"},"outputs":[{"name":"stdout","output_type":"stream","text":["hello world\n"]}],"source":["helloworld = \"hello\" + \" \" + \"world\"\n","print(helloworld)"]},{"cell_type":"markdown","metadata":{"id":"9hc67h51LQ10"},"source":["Python also supports multiplying strings to create a string with a repeating sequence."]},{"cell_type":"code","execution_count":18,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":258,"status":"ok","timestamp":1716899401519,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"5xsOeaZELYeu","outputId":"d26281ee-906a-4c0b-9bd9-52f134796722"},"outputs":[{"name":"stdout","output_type":"stream","text":["hellohellohellohellohellohellohellohellohellohello\n"]}],"source":["lotsofhellos = \"hello\" * 10\n","print(lotsofhellos)"]},{"cell_type":"markdown","metadata":{"id":"rVR2PBODLdld"},"source":["### Using Operators with Lists\n","Lists can be combined using the addition operator."]},{"cell_type":"code","execution_count":19,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":366,"status":"ok","timestamp":1716899471839,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"SeCnKMDsLqwE","outputId":"2ca4f4a1-8f09-4558-87d1-40a14a8be8d2"},"outputs":[{"name":"stdout","output_type":"stream","text":["[1, 3, 5, 7, 2, 4, 6, 8]\n"]}],"source":["even_numbers = [2,4,6,8]\n","odd_numbers = [1,3,5,7]\n","all_numbers = odd_numbers + even_numbers\n","print(all_numbers)"]},{"cell_type":"markdown","metadata":{"id":"jXW8ghmsL3eo"},"source":["Similar to strings, Python allows the creation of new lists with a repeating sequence using the multiplication operator."]},{"cell_type":"code","execution_count":20,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":263,"status":"ok","timestamp":1716899524779,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"jcnoHa8lL4Ph","outputId":"f1ffacce-85af-48c4-c526-c324a1798495"},"outputs":[{"name":"stdout","output_type":"stream","text":["[1, 2, 3, 1, 2, 3, 1, 2, 3]\n"]}],"source":["print([1,2,3] * 3)"]},{"cell_type":"markdown","metadata":{"id":"8XMHFDB3NEuD"},"source":["## String Formatting with f-strings\n","Python offers a more intuitive approach to string formatting through f-strings. With f-strings, you can easily embed variables and expressions directly into strings, making your code cleaner and more readable.\n","\n","Instead of using the cumbersome \"%\" operator and format specifiers, f-strings allow you to directly insert variables into string literals by prefixing the string with 'f' or 'F'. Inside the string, you can then use curly braces {} to indicate where variables or expressions should be substituted.\n","\n","Here's a quick example:"]},{"cell_type":"code","execution_count":21,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":293,"status":"ok","timestamp":1716899916315,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"smRg-T6CNRII","outputId":"e80f3669-b14c-416b-98df-1eb787aa3590"},"outputs":[{"name":"stdout","output_type":"stream","text":["Hello, John!\n","John is 23 years old.\n","The result is 50.\n"]}],"source":["# Using f-strings for string formatting\n","name = \"John\"\n","age = 23\n","\n","# This prints out \"Hello, John!\"\n","print(f\"Hello, {name}!\")\n","\n","# This prints out \"John is 23 years old.\"\n","print(f\"{name} is {age} years old.\")\n","\n","# You can even embed expressions\n","result = 10 * 5\n","print(f\"The result is {result}.\")"]},{"cell_type":"markdown","metadata":{"id":"Bf2Lp4kkNheC"},"source":["With f-strings, you have the full power of Python expressions at your disposal within strings, making complex formatting tasks much simpler and more expressive. Plus, the resulting code is easier to read and maintain compared to traditional formatting methods."]},{"cell_type":"markdown","metadata":{"id":"PvtjJeQWN2gF"},"source":["## Basic String Operations\n","Strings are sequences of characters. They can be defined by enclosing text within either single or double quotation marks:"]},{"cell_type":"code","execution_count":22,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":266,"status":"ok","timestamp":1716900106136,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"Ounyn5VeODcP","outputId":"a0285c56-712a-45e9-c9ff-d5a76339e022"},"outputs":[{"name":"stdout","output_type":"stream","text":["single quotes are ' '\n","12\n"]}],"source":["astring = \"Hello world!\"\n","print(\"single quotes are ' '\")\n","\n","print(len(astring))"]},{"cell_type":"markdown","metadata":{"id":"mO-NiwMXOa1a"},"source":["This code snippet prints out the number 12 because the string \"Hello world!\" consists of 12 characters, including punctuation and spaces."]},{"cell_type":"code","execution_count":23,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":269,"status":"ok","timestamp":1716900199565,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"J6CEzLyqOcgI","outputId":"bc77893f-8338-4805-97d0-cfad3a36be40"},"outputs":[{"name":"stdout","output_type":"stream","text":["4\n"]}],"source":["astring = \"Hello world!\"\n","print(astring.index(\"o\"))"]},{"cell_type":"markdown","metadata":{"id":"heIz0FoEOihR"},"source":["This code snippet prints out the number 4 because it indicates the position of the first occurrence of the letter \"o\" in the string \"Hello world!\". It's important to note that this method only identifies the first occurrence of the letter \"o\".\n","\n","You might wonder why it didn't print out 5. Isn't \"o\" the fifth character in the string? Well, in Python (and many other programming languages), indexing starts at 0 instead of 1. So, the index of the first \"o\" is actually 4."]},{"cell_type":"code","execution_count":24,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":4,"status":"ok","timestamp":1716900282858,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"yg9zhCwBOw9Y","outputId":"50c9e370-63be-4d80-91c6-f77d255b0581"},"outputs":[{"name":"stdout","output_type":"stream","text":["3\n"]}],"source":["astring = \"Hello world!\"\n","print(astring.count(\"l\"))"]},{"cell_type":"markdown","metadata":{"id":"6QBt_moJO1dU"},"source":["For those of you using unique fonts, please note that the character used here is a lowercase \"L,\" not the number one. This code snippet counts the number of occurrences of the letter \"l\" in the string. Therefore, it should print 3."]},{"cell_type":"code","execution_count":25,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":306,"status":"ok","timestamp":1716900344779,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"p-idRRUOO_5L","outputId":"b958ef3a-9005-4cc4-e356-dea2c8615b82"},"outputs":[{"name":"stdout","output_type":"stream","text":["lo w\n"]}],"source":["astring = \"Hello world!\"\n","print(astring[3:7])"]},{"cell_type":"markdown","metadata":{"id":"fwEDABASPM5I"},"source":["This code snippet prints a slice of the string, starting at index 3 and ending at index 6. But why does it end at index 6 and not 7? Well, this convention is common in most programming languages as it simplifies calculations within the brackets.\n","\n","If you include just one number inside the brackets, it will return the single character at that index. If you omit the first number but keep the colon, it will return a slice from the beginning of the string to the specified index. If you leave out the second number, it will return a slice from the specified index to the end of the string.\n","\n","Additionally, you can use negative numbers inside the brackets. They provide a convenient way to start counting from the end of the string instead of the beginning. For instance, -3 indicates the \"3rd character from the end.\""]},{"cell_type":"code","execution_count":26,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":260,"status":"ok","timestamp":1716900410434,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"N35vCe_lPOvH","outputId":"02c19674-2d38-4e0c-fe5c-a23554c484f7"},"outputs":[{"name":"stdout","output_type":"stream","text":["l \n"]}],"source":["astring = \"Hello world!\"\n","print(astring[3:7:2])"]},{"cell_type":"markdown","metadata":{"id":"l3uplTYzPao0"},"source":["This code snippet prints the characters of the string from index 3 to 7, skipping one character in between. This utilizes extended slice syntax, where the general form is [start:stop:step]."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"l_96NCdpPb2h"},"outputs":[],"source":["astring = \"Hello world!\"\n","print(astring[3:7])\n","print(astring[3:7:1])"]},{"cell_type":"markdown","metadata":{"id":"yX1ltO-nQU9a"},"source":["It's worth noting that both methods produce the same output.\n","\n","Unlike C, Python does not have a built-in function like strrev to reverse a string. However, with the slice syntax mentioned above, you can effortlessly reverse a string like this:"]},{"cell_type":"code","execution_count":27,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":286,"status":"ok","timestamp":1716900777000,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"3fv7UiNmQnns","outputId":"1430bc46-e20b-44e0-d520-8b1a4844273e"},"outputs":[{"name":"stdout","output_type":"stream","text":["!dlrow olleH\n"]}],"source":["astring = \"Hello world!\"\n","print(astring[::-1])"]},{"cell_type":"markdown","metadata":{"id":"ZgStwePvQodf"},"source":["This"]},{"cell_type":"code","execution_count":28,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":250,"status":"ok","timestamp":1716900779476,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"4c61tWjCQrgG","outputId":"265a01cc-928e-41bf-f561-ebeb518fa8b0"},"outputs":[{"name":"stdout","output_type":"stream","text":["HELLO WORLD!\n","hello world!\n"]}],"source":["astring = \"Hello world!\"\n","print(astring.upper())\n","print(astring.lower())"]},{"cell_type":"markdown","metadata":{"id":"FJuWNXPoQ4vW"},"source":["These expressions create new strings where all letters are converted to uppercase and lowercase, respectively."]},{"cell_type":"code","execution_count":29,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":259,"status":"ok","timestamp":1716900841216,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"qLn3iv9WQ5tx","outputId":"ee0f5619-8894-4ada-f947-74620c44d0bb"},"outputs":[{"name":"stdout","output_type":"stream","text":["True\n","False\n"]}],"source":["astring = \"Hello world!\"\n","print(astring.startswith(\"Hello\"))\n","print(astring.endswith(\"asdfasdfasdf\"))"]},{"cell_type":"markdown","metadata":{"id":"gKpxS4HXQ9d6"},"source":["These expressions are used to check whether the string starts with a particular substring or ends with it, respectively. The first expression will print True since the string starts with \"Hello\". The second expression will print False because the string does not end with \"asdfasdfasdf\"."]},{"cell_type":"code","execution_count":32,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":352,"status":"ok","timestamp":1716900959550,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"W-EcctLMRFb4","outputId":"efa56558-cbda-43ba-a4ea-9dc3fa5064a8"},"outputs":[{"name":"stdout","output_type":"stream","text":["['Hello', 'world!']\n"]}],"source":["astring = \"Hello world!\"\n","afewwords = astring.split(\" \")\n","print(afewwords)"]},{"cell_type":"markdown","metadata":{"id":"y5iCJB2vRTnH"},"source":["This code snippet splits the string into multiple substrings grouped together in a list. In this example, since the split occurs at a space, the first item in the list will be \"Hello\", and the second will be \"world!\"."]},{"cell_type":"markdown","metadata":{"id":"JnbIHinARovz"},"source":["## Conditions"]},{"cell_type":"markdown","metadata":{"id":"hn_tFL7mnWYQ"},"source":["Python uses boolean logic to evaluate conditions. The boolean values True and False are returned when an expression is compared or evaluated. For example:"]},{"cell_type":"code","execution_count":33,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":6,"status":"ok","timestamp":1716906743107,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"VsebJ3dmncUg","outputId":"21c72735-30ee-4a2d-c0ea-a502ca77a281"},"outputs":[{"name":"stdout","output_type":"stream","text":["True\n","False\n","True\n"]}],"source":["x = 2\n","print(x == 2) # prints out True\n","print(x == 3) # prints out False\n","print(x < 3) # prints out True"]},{"cell_type":"markdown","metadata":{"id":"51kIvGf6oEN4"},"source":["In Python, assigning a value to a variable is done with a single equals sign \"=\". To compare two variables for equality, we use the double equals sign \"==\". If we want to check if two variables are not equal, we use the \"!=\" operator.\n","\n","### Boolean operators\n","The \"and\" and \"or\" boolean operators enable the creation of complex boolean expressions. For example:"]},{"cell_type":"code","execution_count":34,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":365,"status":"ok","timestamp":1716906984055,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"DkvivXTGoF-P","outputId":"149db861-93c0-4f5c-b606-c08b00f8c36f"},"outputs":[{"name":"stdout","output_type":"stream","text":["Your name is John, and you are also 23 years old.\n","Your name is either John or Rick.\n"]}],"source":["name = \"John\"\n","age = 23\n","if name == \"John\" and age == 23:\n","    print(\"Your name is John, and you are also 23 years old.\")\n","\n","if name == \"John\" or name == \"Rick\":\n","    print(\"Your name is either John or Rick.\")"]},{"cell_type":"markdown","metadata":{"id":"yGZ95N8fogf1"},"source":["### The \"in\" operator\n","The \"in\" operator can be used to check if a specific object is present within an iterable container, such as a list:"]},{"cell_type":"code","execution_count":35,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":345,"status":"ok","timestamp":1716907066358,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"4mz4_dSeopfI","outputId":"43497696-de64-49a6-a4ae-2a8340291bf1"},"outputs":[{"name":"stdout","output_type":"stream","text":["Your name is either John or Rick.\n"]}],"source":["name = \"John\"\n","if name in [\"John\", \"Rick\"]:\n","    print(\"Your name is either John or Rick.\")"]},{"cell_type":"markdown","metadata":{"id":"IWCoWtKro8sP"},"source":["In Python, indentation is used to define code blocks instead of brackets. The standard indentation is 4 spaces, though tabs or any other consistent space size will also work. Note that code blocks do not require any termination.\n","\n","Here is an example of using Python's \"if\" statement with code blocks:"]},{"cell_type":"code","execution_count":36,"metadata":{"executionInfo":{"elapsed":284,"status":"ok","timestamp":1716907153305,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"DMiwRBohpAsm"},"outputs":[],"source":["statement = False\n","another_statement = True\n","if statement is True:\n","    # do something\n","    pass\n","elif another_statement is True: # else if\n","    # do something else\n","    pass\n","else:\n","    # do another thing\n","    pass"]},{"cell_type":"markdown","metadata":{"id":"tKeXzzyOpKX5"},"source":["e.g.,"]},{"cell_type":"code","execution_count":37,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":405,"status":"ok","timestamp":1716907221231,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"E2iMq6ScpL9I","outputId":"f2de849c-ca2d-4295-8142-9bdbedaf16b2"},"outputs":[{"name":"stdout","output_type":"stream","text":["x equals three!\n"]}],"source":["x = 3\n","if x == 3:\n","    print(\"x equals three!\")\n","else:\n","    print(\"x does not equal to three.\")"]},{"cell_type":"markdown","metadata":{"id":"FUDoEssQpdeU"},"source":["A statement is evaluated as true if one of the following conditions is met: 1. The boolean value \"True\" is provided, or it is the result of an expression, such as an arithmetic comparison. 2. An object that is not considered \"empty\" is passed.\n","\n","Here are some examples of objects that are considered empty: 1. An empty string: \"\" 2. An empty list: [] 3. The number zero: 0 4. The boolean value \"False\"\n","\n","### The 'is' operator\n","Unlike the double equals operator \"==\", the \"is\" operator does not compare the values of the variables, but rather their instances. For example:"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"TOSWo-tLplx0"},"outputs":[],"source":["x = [1,2,3]\n","y = [1,2,3]\n","print(x == y) # Prints out True\n","print(x is y) # Prints out False"]},{"cell_type":"markdown","metadata":{"id":"cOsIOFncp6RK"},"source":["### The \"not\" operator\n","Using \"not\" before a boolean expression inverts it:"]},{"cell_type":"code","execution_count":38,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":328,"status":"ok","timestamp":1716907420399,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"z6AL1qNlqBw6","outputId":"e5f22d58-14d1-4a5b-dc3b-be7b01c44c5a"},"outputs":[{"name":"stdout","output_type":"stream","text":["True\n","False\n"]}],"source":["print(not False) # Prints out True\n","print((not False) == (False)) # Prints out False"]},{"cell_type":"markdown","metadata":{"id":"W0z9drkRqHu5"},"source":["## Loops\n","Python has two types of loops: \"for\" and \"while\".\n","### The \"for\" loop\n","For loops iterate over a specified sequence. Here is an example:"]},{"cell_type":"code","execution_count":39,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":321,"status":"ok","timestamp":1716907529496,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"LINxefMWqZzy","outputId":"8281bffd-bfdb-4487-c979-e259d4f32680"},"outputs":[{"name":"stdout","output_type":"stream","text":["2\n","3\n","5\n","7\n"]}],"source":["primes = [2, 3, 5, 7]\n","for prime in primes:\n","    print(prime)"]},{"cell_type":"markdown","metadata":{"id":"Ofk6p8EmqfMR"},"source":["For loops can iterate over a sequence of numbers using the \"range\" function. In Python 2, there is also an \"xrange\" function. The difference is that \"range\" returns a new list with numbers in the specified range, while \"xrange\" returns an iterator, making it more efficient. In Python 3, \"range\" functions like \"xrange\" in Python 2. Note that the \"range\" function is zero-based."]},{"cell_type":"code","execution_count":40,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":255,"status":"ok","timestamp":1716907599316,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"pqaUgorEqnJb","outputId":"62eca5d1-439b-4fe8-ecfa-5c64728bed4c"},"outputs":[{"name":"stdout","output_type":"stream","text":["0\n","1\n","2\n","3\n","4\n","3\n","4\n","5\n","3\n","5\n","7\n"]}],"source":["# Prints out the numbers 0,1,2,3,4\n","for x in range(5):\n","    print(x)\n","\n","# Prints out 3,4,5\n","for x in range(3, 6):\n","    print(x)\n","\n","# Prints out 3,5,7\n","for x in range(3, 8, 2):\n","    print(x)"]},{"cell_type":"markdown","metadata":{"id":"LUG13Rw7q0wS"},"source":["### \"while\" loops\n","While loops continue to execute as long as a specified boolean condition is true. For example:"]},{"cell_type":"code","execution_count":41,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":247,"status":"ok","timestamp":1716907671789,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"IeGEGxDXq9HQ","outputId":"567aed73-0ae9-4688-e7e3-257cd2bab309"},"outputs":[{"name":"stdout","output_type":"stream","text":["0\n","1\n","2\n","3\n","4\n"]}],"source":["# Prints out 0,1,2,3,4\n","count = 0\n","while count < 5:\n","    print(count)\n","    count += 1  # This is the same as count = count + 1"]},{"cell_type":"markdown","metadata":{"id":"IBFVrMyXrFvP"},"source":["### \"break\" and \"continue\" statements\n","The **break** statement is used to exit a \"for\" or \"while\" loop, while the **continue** statement is used to skip the current iteration and return to the \"for\" or \"while\" statement. Here are a few examples:"]},{"cell_type":"code","execution_count":42,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":341,"status":"ok","timestamp":1716907799467,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"mAKxq604rZU0","outputId":"0423b4b0-c1dd-4cc3-8d93-d37d8b83b883"},"outputs":[{"name":"stdout","output_type":"stream","text":["0\n","1\n","2\n","3\n","4\n","1\n","3\n","5\n","7\n","9\n"]}],"source":["# Prints out 0,1,2,3,4\n","count = 0\n","while True:\n","    print(count)\n","    count += 1\n","    if count >= 5:\n","        break\n","\n","# Prints out only odd numbers - 1,3,5,7,9\n","for x in range(10):\n","    # Check if x is even\n","    if x % 2 == 0:\n","        continue\n","    print(x)"]},{"cell_type":"markdown","metadata":{"id":"TOgo07--rlED"},"source":["### Can we use \"else\" clause for loops?\n","Unlike languages like C or C++, Python allows the use of \"else\" with loops. When the loop condition of a \"for\" or \"while\" statement fails, the code in the \"else\" block is executed. If a \"break\" statement is executed inside the loop, the \"else\" part is skipped. Note that the \"else\" part is executed even if there is a \"continue\" statement within the loop.\n","\n","Here are a few examples:"]},{"cell_type":"code","execution_count":43,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":289,"status":"ok","timestamp":1716907883271,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"bCbXzAtErypz","outputId":"b2ca82ad-59e2-4f46-ab29-98cfc47be81a"},"outputs":[{"name":"stdout","output_type":"stream","text":["0\n","1\n","2\n","3\n","4\n","count value reached 5\n","1\n","2\n","3\n","4\n"]}],"source":["# Prints out 0,1,2,3,4 and then it prints \"count value reached 5\"\n","count=0\n","while(count<5):\n","    print(count)\n","    count +=1\n","else:\n","    print(\"count value reached %d\" %(count))\n","\n","# Prints out 1,2,3,4\n","for i in range(1, 10):\n","    if(i%5==0):\n","        break\n","    print(i)\n","else:\n","    print(\"this is not printed because for loop is terminated because of break but not due to fail in condition\")"]},{"cell_type":"markdown","metadata":{"id":"jBA8UZVlsFND"},"source":["## Functions\n","### What are Functions?\n","Functions are a convenient way to divide your code into manageable blocks, making it more organized, readable, and reusable, which saves time. Additionally, functions are essential for defining interfaces, enabling programmers to share their code easily.\n","### How do you write functions in Python?\n","As we have seen in previous tutorials, Python utilizes blocks of code.\n","\n","A block is a section of code written in the following format:"]},{"cell_type":"code","execution_count":44,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":106},"executionInfo":{"elapsed":372,"status":"error","timestamp":1716908080019,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"V4WvUzuTsSKR","outputId":"e4073294-3b81-4239-df63-5d946306088e"},"outputs":[{"ename":"SyntaxError","evalue":"invalid decimal literal (<ipython-input-44-fcb210295852>, line 2)","output_type":"error","traceback":["\u001b[0;36m  File \u001b[0;32m\"<ipython-input-44-fcb210295852>\"\u001b[0;36m, line \u001b[0;32m2\u001b[0m\n\u001b[0;31m    1st block line\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid decimal literal\n"]}],"source":["block_head:\n","    1st block line\n","    2nd block line\n","    ..."]},{"cell_type":"markdown","metadata":{"id":"-XYl_vXLsuFg"},"source":["A block line contains more Python code (which can include another block), and the block head follows this format: block_keyword block_name(argument1, argument2, ...). Block keywords you are already familiar with include \"if\", \"for\", and \"while\".\n","\n","Functions in Python are defined using the block keyword \"def\", followed by the function's name as the block's name. For example:"]},{"cell_type":"code","execution_count":48,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":254,"status":"ok","timestamp":1716908321530,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"VR7OHro9sv0f","outputId":"7c5b5d96-06be-4cec-a16c-e26626a73957"},"outputs":[{"name":"stdout","output_type":"stream","text":["Hello From My Function!\n"]}],"source":["def my_function():\n","    print(\"Hello From My Function!\")"]},{"cell_type":"markdown","metadata":{"id":"ZLZ-Gh8Ks-LE"},"source":["Functions can also accept arguments (variables passed from the caller to the function). For example:"]},{"cell_type":"code","execution_count":51,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":250,"status":"ok","timestamp":1716908363740,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"Ea7HkSZps_Vk","outputId":"bca4b7a9-9d92-415d-cae6-4227179798f7"},"outputs":[{"name":"stdout","output_type":"stream","text":["Hello, John, From My Function!, I wish you a good day!)\n"]}],"source":["def my_function_with_args(username, greeting):\n","    print(f\"Hello, {username}, From My Function!, I wish you {greeting})\")"]},{"cell_type":"markdown","metadata":{"id":"RwKtGskHtyk-"},"source":["Functions can return a value to the caller using the \"return\" keyword. For example:"]},{"cell_type":"code","execution_count":52,"metadata":{"executionInfo":{"elapsed":255,"status":"ok","timestamp":1716908428617,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"541N6i1Wtzfh"},"outputs":[],"source":["def sum_two_numbers(a, b):\n","    return a + b"]},{"cell_type":"markdown","metadata":{"id":"kfWMT98TuM75"},"source":["### How do you call functions in Python?\n","Simply write the function's name followed by parentheses (), placing any required arguments within them. For example, let's call the functions written above (in the previous example):"]},{"cell_type":"code","execution_count":56,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":584,"status":"ok","timestamp":1716908658143,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"ywxG2DcAuW-Q","outputId":"d52d06ed-96e9-428b-820a-806c7449e958"},"outputs":[{"name":"stdout","output_type":"stream","text":["Hello From My Function!\n","Hello, John Doe, From My Function!, I wish you a great year!\n","3\n"]}],"source":["# Define our 3 functions\n","def my_function():\n","    print(\"Hello From My Function!\")\n","\n","def my_function_with_args(username, greeting):\n","    print(f\"Hello, {username}, From My Function!, I wish you {greeting}\")\n","\n","def sum_two_numbers(a, b):\n","    return a + b\n","\n","# print(a simple greeting)\n","my_function()\n","\n","#prints - \"Hello, John Doe, From My Function!, I wish you a great year!\"\n","my_function_with_args(\"John Doe\", \"a great year!\")\n","\n","# after this line x will hold the value 3!\n","x = sum_two_numbers(1,2)\n","print(x)"]},{"cell_type":"markdown","metadata":{"id":"ObZOUFxJwI7H"},"source":["## Classes and Objects\n","Objects encapsulate variables and functions into a single entity. They derive their variables and functions from classes, which serve as templates for creating objects.\n","\n","A very basic class looks something like this:"]},{"cell_type":"code","execution_count":57,"metadata":{"executionInfo":{"elapsed":287,"status":"ok","timestamp":1716909071475,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"fCXblwN0wSoT"},"outputs":[],"source":["class MyClass:\n","    variable = \"blah\"\n","\n","    def function(self):\n","        print(\"This is a message inside the class.\")"]},{"cell_type":"markdown","metadata":{"id":"_SvBUIIdwdUi"},"source":["We will explain the purpose of including \"self\" as a parameter shortly. First, to assign the above class (template) to an object, you would do the following:"]},{"cell_type":"code","execution_count":58,"metadata":{"executionInfo":{"elapsed":306,"status":"ok","timestamp":1716909120325,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"Ula8Grw4we6L"},"outputs":[],"source":["class MyClass:\n","    variable = \"blah\"\n","\n","    def function(self):\n","        print(\"This is a message inside the class.\")\n","\n","myobjectx = MyClass()"]},{"cell_type":"markdown","metadata":{"id":"kwSCI2-5wpr9"},"source":["Now the variable \"myobjectx\" holds an instance of the class \"MyClass\", which contains the variable and function defined within \"MyClass\".\n","### Accessing Object Variables\n","To access the variable inside the newly created object \"myobjectx\", you would do the following:"]},{"cell_type":"code","execution_count":59,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":35},"executionInfo":{"elapsed":292,"status":"ok","timestamp":1716909221948,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"eGNfM-sqw3bI","outputId":"487c87ca-7eb1-441f-8a96-99038be15b1f"},"outputs":[{"data":{"application/vnd.google.colaboratory.intrinsic+json":{"type":"string"},"text/plain":["'blah'"]},"execution_count":59,"metadata":{},"output_type":"execute_result"}],"source":["class MyClass:\n","    variable = \"blah\"\n","\n","    def function(self):\n","        print(\"This is a message inside the class.\")\n","\n","myobjectx = MyClass()\n","\n","myobjectx.variable"]},{"cell_type":"markdown","metadata":{"id":"k6o7GzD7xDBx"},"source":["For instance, the following code would output the string \"blah\":"]},{"cell_type":"code","execution_count":60,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":285,"status":"ok","timestamp":1716909320164,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"zXul8TalxEd-","outputId":"6b382317-6f3b-4448-8924-4661ea469495"},"outputs":[{"name":"stdout","output_type":"stream","text":["blah\n"]}],"source":["class MyClass:\n","    variable = \"blah\"\n","\n","    def function(self):\n","        print(\"This is a message inside the class.\")\n","\n","myobjectx = MyClass()\n","\n","print(myobjectx.variable)"]},{"cell_type":"markdown","metadata":{"id":"bRtJISP-xazg"},"source":["You can create multiple objects from the same class, meaning they share the same defined variables and functions. However, each object contains its own independent copies of the class variables. For instance, if we define another object with the \"MyClass\" class and then change the string in the variable above:"]},{"cell_type":"code","execution_count":61,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":8,"status":"ok","timestamp":1716909369100,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"0Fn5cwMbxbpb","outputId":"6f3e3fdc-f02e-492c-8116-00eb553608b1"},"outputs":[{"name":"stdout","output_type":"stream","text":["blah\n","yackity\n"]}],"source":["class MyClass:\n","    variable = \"blah\"\n","\n","    def function(self):\n","        print(\"This is a message inside the class.\")\n","\n","myobjectx = MyClass()\n","myobjecty = MyClass()\n","\n","myobjecty.variable = \"yackity\"\n","\n","# Then print out both values\n","print(myobjectx.variable)\n","print(myobjecty.variable)"]},{"cell_type":"markdown","metadata":{"id":"fZfD3OGrxhfu"},"source":["### Accessing Object Functions\n","To access a function inside an object, use a notation similar to accessing a variable:"]},{"cell_type":"code","execution_count":62,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":8,"status":"ok","timestamp":1716909431798,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"Dj47Ngjqxq8j","outputId":"3919630f-4766-453a-8b49-925161203bd0"},"outputs":[{"name":"stdout","output_type":"stream","text":["This is a message inside the class.\n"]}],"source":["class MyClass:\n","    variable = \"blah\"\n","\n","    def function(self):\n","        print(\"This is a message inside the class.\")\n","\n","myobjectx = MyClass()\n","\n","myobjectx.function()"]},{"cell_type":"markdown","metadata":{"id":"yiChLAfax7-A"},"source":["The above code would print the message, \"This is a message inside the class.\""]},{"cell_type":"markdown","metadata":{"id":"xqlORBzdyB7-"},"source":["### init()\n","The **__init__()** function is a special method that is called when a class is instantiated. It is used for initializing the values of a class."]},{"cell_type":"code","execution_count":63,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":291,"status":"ok","timestamp":1716909582592,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"1uu9WR5IyM0r","outputId":"8a370c40-b544-4e2e-830b-08844ff5cf88"},"outputs":[{"name":"stdout","output_type":"stream","text":["3\n"]}],"source":["class NumberHolder:\n","\n","   def __init__(self, number):\n","       self.number = number\n","\n","   def returnNumber(self):\n","       return self.number\n","\n","var = NumberHolder(3)\n","print(var.returnNumber()) #Prints '3'"]},{"cell_type":"markdown","metadata":{"id":"RJChHzQuyhVf"},"source":["## Dictionaries\n","A dictionary is a data type similar to arrays, but it uses keys and values instead of indexes. Each value in a dictionary can be accessed using a key, which can be any type of object (such as a string, number, or list), rather than using an index.\n","\n","For example, a database of phone numbers could be stored using a dictionary like this:"]},{"cell_type":"code","execution_count":64,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":261,"status":"ok","timestamp":1716909695138,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"jPyyGM6CyqRf","outputId":"28968fea-2a73-4320-817c-215209b0bff6"},"outputs":[{"name":"stdout","output_type":"stream","text":["{'John': 938477566, 'Jack': 938377264, 'Jill': 947662781}\n"]}],"source":["phonebook = {}\n","phonebook[\"John\"] = 938477566\n","phonebook[\"Jack\"] = 938377264\n","phonebook[\"Jill\"] = 947662781\n","print(phonebook)"]},{"cell_type":"markdown","metadata":{"id":"dznTGy9OzvWq"},"source":["Alternatively, a dictionary can be initialized with the same values using the following notation:"]},{"cell_type":"code","execution_count":65,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":346,"status":"ok","timestamp":1716909978082,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"irWqHAL_zv8c","outputId":"f05fe7ea-d626-4fca-d273-a685baa648ae"},"outputs":[{"name":"stdout","output_type":"stream","text":["{'John': 938477566, 'Jack': 938377264, 'Jill': 947662781}\n"]}],"source":["phonebook = {\n","    \"John\" : 938477566,\n","    \"Jack\" : 938377264,\n","    \"Jill\" : 947662781\n","}\n","print(phonebook)"]},{"cell_type":"markdown","metadata":{"id":"wA9swUgXzzqE"},"source":["### Iterating over dictionaries\n","Dictionaries can be iterated over just like lists. However, unlike lists, dictionaries do not maintain the order of the values stored in them. To iterate over key-value pairs, use the following syntax:"]},{"cell_type":"code","execution_count":69,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":260,"status":"ok","timestamp":1716910111893,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"iBYX6bXdz-lX","outputId":"6ba00b2e-aa18-4482-a8ef-223a23619585"},"outputs":[{"name":"stdout","output_type":"stream","text":["Phone number of John is 938477566\n","Phone number of Jack is 938377264\n","Phone number of Jill is 947662781\n"]}],"source":["phonebook = {\"John\" : 938477566,\"Jack\" : 938377264,\"Jill\" : 947662781}\n","for name, number in phonebook.items():\n","    print(f\"Phone number of {name} is {number}\")"]},{"cell_type":"markdown","metadata":{"id":"mYFKYwD90YSx"},"source":["### Removing a value\n","To remove a specified key from a dictionary, use one of the following methods:"]},{"cell_type":"code","execution_count":70,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":412,"status":"ok","timestamp":1716910186158,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"hSGfNM490iGC","outputId":"33896846-f91b-434a-8a7c-9e40a0a3f263"},"outputs":[{"name":"stdout","output_type":"stream","text":["{'Jack': 938377264, 'Jill': 947662781}\n"]}],"source":["phonebook = {\n","   \"John\" : 938477566,\n","   \"Jack\" : 938377264,\n","   \"Jill\" : 947662781\n","}\n","del phonebook[\"John\"]\n","print(phonebook)"]},{"cell_type":"markdown","metadata":{"id":"cJD1SeeE0n4i"},"source":["or:"]},{"cell_type":"code","execution_count":71,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":287,"status":"ok","timestamp":1716910212332,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"iToe0Qnh0pf_","outputId":"cc48e6a6-4b41-433b-c6a3-1a94edcd115e"},"outputs":[{"name":"stdout","output_type":"stream","text":["{'Jack': 938377264, 'Jill': 947662781}\n"]}],"source":["phonebook = {\n","   \"John\" : 938477566,\n","   \"Jack\" : 938377264,\n","   \"Jill\" : 947662781\n","}\n","phonebook.pop(\"John\")\n","print(phonebook)"]},{"cell_type":"markdown","metadata":{"id":"igudOuXP8pjQ"},"source":["## Modules and Packages\n","In programming, a module is a piece of software designed to perform a specific function. For example, in a ping pong game, one module might handle the game logic, while another module manages the graphics. Each module is contained in a separate file, which can be edited independently.\n","### Writing modules\n","Modules in Python are simply Python files with a .py extension. The name of the module is the same as the file name. A Python module can contain a set of functions, classes, or variables. The example below includes two files:\n","\n","> mygame/\n","*   mygame/game.py\n","*   mygame/draw.py\n","\n","The Python script `game.py` implements the game and uses the `draw_game` function from the `draw.py` file, also known as the draw module, which handles the logic for drawing the game on the screen.\n","\n","Modules are imported into other modules using the `import` command. In this example, the `game.py` script might look something like this:\n","\n","--> another good website explaining this and more (packages) can be found [here](https://www.tutorialsteacher.com/python/python-package)"]},{"cell_type":"code","execution_count":72,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":384},"executionInfo":{"elapsed":284,"status":"error","timestamp":1716912737623,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"gdnN1O0O-REg","outputId":"cb1820a7-3f70-48f4-f650-d731d44b6c9c"},"outputs":[{"ename":"ModuleNotFoundError","evalue":"No module named 'draw'","output_type":"error","traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)","\u001b[0;32m<ipython-input-72-ff59ebdcd83c>\u001b[0m in \u001b[0;36m<cell line: 3>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# game.py\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;31m# import the draw module\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0;32mimport\u001b[0m \u001b[0mdraw\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mplay_game\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'draw'","","\u001b[0;31m---------------------------------------------------------------------------\u001b[0;32m\nNOTE: If your import is failing due to a missing package, you can\nmanually install dependencies using either !pip or !apt.\n\nTo view examples of installing some common dependencies, click the\n\"Open Examples\" button below.\n\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n"]}],"source":["# game.py\n","# import the draw module\n","import draw\n","\n","def play_game():\n","    ...\n","\n","def main():\n","    result = play_game()\n","    draw.draw_game(result)\n","\n","# this means that if this script is executed, then\n","# main() will be executed\n","if __name__ == '__main__':\n","    main()"]},{"cell_type":"markdown","metadata":{"id":"Xnhhscv3-jn3"},"source":["The `draw` module might look something like this:"]},{"cell_type":"code","execution_count":73,"metadata":{"executionInfo":{"elapsed":322,"status":"ok","timestamp":1716912871484,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"eG_rSIkx-khi"},"outputs":[],"source":["# draw.py\n","\n","def draw_game():\n","    ...\n","\n","def clear_screen(screen):\n","    ..."]},{"cell_type":"markdown","metadata":{"id":"L0y4v3bW-2-T"},"source":["\n","In this example, the `game` module imports the `draw` module, allowing it to use the functions implemented in that module. The main function uses the local function `play_game` to run the game, and then draws the result using a function from the `draw` module called `draw_game`. To use the `draw_game` function from the `draw` module, we need to specify which module the function is in by using the dot operator. To reference the `draw_game` function from the `game` module, we import the `draw` module and then call `draw.draw_game()`.\n","\n","When the `import draw` directive runs, the Python interpreter looks for a file named `draw.py` in the directory where the script was executed. If found, it will be imported; if not, the interpreter will look for built-in modules.\n","\n","You may have noticed that when importing a module, a `.pyc` file is created. This is a compiled Python file. Python compiles files into bytecode to avoid parsing the files each time modules are loaded. If a `.pyc` file exists, it gets loaded instead of the `.py` file. This process is transparent to the user.\n","### Importing module objects to the current namespace\n","A namespace is a system in Python where every object is named and can be accessed. We can import the `draw_game` function into the main script's namespace using the `from` command."]},{"cell_type":"code","execution_count":74,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":384},"executionInfo":{"elapsed":298,"status":"error","timestamp":1716913147831,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"0lAhVcVB_1lB","outputId":"b4ca92be-66ea-406a-95c8-27fec5e1d2bc"},"outputs":[{"ename":"ModuleNotFoundError","evalue":"No module named 'draw'","output_type":"error","traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)","\u001b[0;32m<ipython-input-74-dacd89c9a186>\u001b[0m in \u001b[0;36m<cell line: 3>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# game.py\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;31m# import the draw module\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0;32mfrom\u001b[0m \u001b[0mdraw\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mdraw_game\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'draw'","","\u001b[0;31m---------------------------------------------------------------------------\u001b[0;32m\nNOTE: If your import is failing due to a missing package, you can\nmanually install dependencies using either !pip or !apt.\n\nTo view examples of installing some common dependencies, click the\n\"Open Examples\" button below.\n\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n"]}],"source":["# game.py\n","# import the draw module\n","from draw import draw_game\n","\n","def main():\n","    result = play_game()\n","    draw_game(result)"]},{"cell_type":"markdown","metadata":{"id":"-ihboUxL_5qR"},"source":["You may have noticed that in this example, the module name does not precede `draw_game`, because we've specified the module name using the `import` command.\n","\n","The advantage of this notation is that you don't have to repeatedly reference the module. However, a namespace cannot have two objects with the same name, so the `import` command may replace an existing object in the namespace.\n","\n","### Importing all objects from a module\n","You can use the `import *` command to import all objects from a module like this:"]},{"cell_type":"code","execution_count":75,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":384},"executionInfo":{"elapsed":294,"status":"error","timestamp":1716913284409,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"PfGfc06-AGLH","outputId":"62b52535-d229-4b52-bb2a-1d5016201b45"},"outputs":[{"ename":"ModuleNotFoundError","evalue":"No module named 'draw'","output_type":"error","traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)","\u001b[0;32m<ipython-input-75-4cf6d8f2aa4d>\u001b[0m in \u001b[0;36m<cell line: 3>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# game.py\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;31m# import the draw module\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0;32mfrom\u001b[0m \u001b[0mdraw\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'draw'","","\u001b[0;31m---------------------------------------------------------------------------\u001b[0;32m\nNOTE: If your import is failing due to a missing package, you can\nmanually install dependencies using either !pip or !apt.\n\nTo view examples of installing some common dependencies, click the\n\"Open Examples\" button below.\n\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n"]}],"source":["# game.py\n","# import the draw module\n","from draw import *\n","\n","def main():\n","    result = play_game()\n","    draw_game(result)"]},{"cell_type":"markdown","metadata":{"id":"CI3fSTywAbDF"},"source":["This approach can be risky because changes in the imported module may affect the importing module. However, it is shorter and doesn't require specifying each object you want to import from the module.\n","### Custom import name\n","Modules can be loaded under any name you choose. This is useful when importing a module conditionally, allowing you to use the same name throughout the rest of the code.\n","\n","For example, if you have two `draw` modules with slightly different names, you could do the following:"]},{"cell_type":"code","execution_count":76,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":211},"executionInfo":{"elapsed":281,"status":"error","timestamp":1716913397768,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"PzYg2vwMA1V4","outputId":"74137fce-a197-4314-d6bf-245c999396ec"},"outputs":[{"ename":"NameError","evalue":"name 'visual_mode' is not defined","output_type":"error","traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)","\u001b[0;32m<ipython-input-76-cf1b86d82900>\u001b[0m in \u001b[0;36m<cell line: 3>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# game.py\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;31m# import the draw module\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0;32mif\u001b[0m \u001b[0mvisual_mode\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m     \u001b[0;31m# in visual mode, we draw using graphics\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0;32mimport\u001b[0m \u001b[0mdraw_visual\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mdraw\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;31mNameError\u001b[0m: name 'visual_mode' is not defined"]}],"source":["# game.py\n","# import the draw module\n","if visual_mode:\n","    # in visual mode, we draw using graphics\n","    import draw_visual as draw\n","else:\n","    # in textual mode, we print out text\n","    import draw_textual as draw\n","\n","def main():\n","    result = play_game()\n","    # this can either be visual or textual depending on visual_mode\n","    draw.draw_game(result)"]},{"cell_type":"markdown","metadata":{"id":"I6zsnwp0BDAE"},"source":["### Module initialization\n","The first time a module is loaded into a running Python script, it is initialized by executing its code once. If another module imports the same module again, it will not be reloaded; thus, local variables inside the module act as a \"singleton,\" meaning they are initialized only once.\n","\n","You can use this to initialize objects. For example:"]},{"cell_type":"code","execution_count":77,"metadata":{"executionInfo":{"elapsed":284,"status":"ok","timestamp":1716913509339,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"TuYl2mkABQT9"},"outputs":[],"source":["# draw.py\n","\n","def draw_game():\n","    # when clearing the screen we can use the main screen object initialized in this module\n","    clear_screen(main_screen)\n","    ...\n","\n","def clear_screen(screen):\n","    ...\n","\n","class Screen():\n","    ...\n","\n","# initialize main_screen as a singleton\n","main_screen = Screen()"]},{"cell_type":"markdown","metadata":{"id":"jQ8FTkemBSQv"},"source":["### Extending module load path\n","There are several ways to tell the Python interpreter where to look for modules, aside from the default local directory and built-in modules. You can use the environment variable `PYTHONPATH` to specify additional directories for module search like this:"]},{"cell_type":"code","execution_count":78,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":106},"executionInfo":{"elapsed":394,"status":"error","timestamp":1716913575319,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"oo_NUBR_BgnW","outputId":"44f8560e-a97b-41d3-a5b1-cd55fce30803"},"outputs":[{"ename":"SyntaxError","evalue":"invalid syntax (<ipython-input-78-6ee4a489db4d>, line 1)","output_type":"error","traceback":["\u001b[0;36m  File \u001b[0;32m\"<ipython-input-78-6ee4a489db4d>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    PYTHONPATH=/foo python game.py\u001b[0m\n\u001b[0m               ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"]}],"source":["PYTHONPATH=/foo python game.py"]},{"cell_type":"markdown","metadata":{"id":"mMmvbxFVBiGS"},"source":["This executes `game.py` and allows the script to load modules from the `foo` directory as well as the local directory.\n","\n","You can also use the `sys.path.append` function. Execute it before running the `import` command:"]},{"cell_type":"code","execution_count":79,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":141},"executionInfo":{"elapsed":370,"status":"error","timestamp":1716913656395,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"y5rfnhj8B0Xz","outputId":"bb9dc869-aae1-4999-e112-197bdd2ed3a9"},"outputs":[{"ename":"NameError","evalue":"name 'sys' is not defined","output_type":"error","traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)","\u001b[0;32m<ipython-input-79-cff76065f6a5>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0msys\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpath\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"/foo\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m","\u001b[0;31mNameError\u001b[0m: name 'sys' is not defined"]}],"source":["sys.path.append(\"/foo\")"]},{"cell_type":"markdown","metadata":{"id":"W1jI1fj1B1-U"},"source":["Now the `foo` directory has been added to the list of paths where modules are searched for.\n","### Exploring built-in modules\n","Check out the full list of built-in modules in the Python standard library [here](https://docs.python.org/3/library/).\n","\n","Two very important functions are useful when exploring modules in Python: `dir` and `help`.\n","\n","To import the `urllib` module, which allows us to read data from URLs, we use the following `import` statement:"]},{"cell_type":"code","execution_count":80,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":176},"executionInfo":{"elapsed":399,"status":"error","timestamp":1716913830532,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"dY-FB34TCevR","outputId":"79e50d4b-8857-429d-800e-4f7227096e55"},"outputs":[{"ename":"AttributeError","evalue":"module 'urllib' has no attribute 'urlopen'","output_type":"error","traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)","\u001b[0;32m<ipython-input-80-c22f2c9452e9>\u001b[0m in \u001b[0;36m<cell line: 5>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;31m# use it\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0murllib\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0murlopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m...\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m","\u001b[0;31mAttributeError\u001b[0m: module 'urllib' has no attribute 'urlopen'"]}],"source":["# import the library\n","import urllib\n","\n","# use it\n","urllib.urlopen(...)"]},{"cell_type":"markdown","metadata":{"id":"vBQbgbtdCqUB"},"source":["We can see which functions are implemented in each module by using the `dir` function:"]},{"cell_type":"code","execution_count":81,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":359,"status":"ok","timestamp":1716913904837,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"k023yZlLCwsC","outputId":"92ef4004-91a4-4ba9-b4a2-1342bf69d7c1"},"outputs":[{"data":{"text/plain":["['__builtins__',\n"," '__cached__',\n"," '__doc__',\n"," '__file__',\n"," '__loader__',\n"," '__name__',\n"," '__package__',\n"," '__path__',\n"," '__spec__',\n"," 'error',\n"," 'parse',\n"," 'request',\n"," 'response']"]},"execution_count":81,"metadata":{},"output_type":"execute_result"}],"source":["import urllib\n","dir(urllib)"]},{"cell_type":"markdown","metadata":{"id":"yAypZL_sC8GJ"},"source":["When we find the function in the module that we want to use, we can learn more about it with the `help` function, using the Python interpreter:"]},{"cell_type":"code","execution_count":82,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":141},"executionInfo":{"elapsed":329,"status":"error","timestamp":1716913966530,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"O62nRGZ8DATP","outputId":"1327349f-e7dc-40fa-829f-17dd20e98786"},"outputs":[{"ename":"AttributeError","evalue":"module 'urllib' has no attribute 'urlopen'","output_type":"error","traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)","\u001b[0;32m<ipython-input-82-398b0e14e51f>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mhelp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0murllib\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0murlopen\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m","\u001b[0;31mAttributeError\u001b[0m: module 'urllib' has no attribute 'urlopen'"]}],"source":["help(urllib.urlopen)"]},{"cell_type":"markdown","metadata":{"id":"NYbnr2_ODHie"},"source":["### Writing packages\n","Packages are namespaces containing multiple packages and modules. They are simply directories but with specific requirements.\n","\n","Each package in Python is a directory that **MUST** contain a special file called `__init__.py`. This file, which can be empty, indicates that the directory is a Python package, allowing it to be imported like a module.\n","\n","If we create a directory called `foo` to serve as the package name, we can then create a module inside that package called `bar`. We also add the `__init__.py` file inside the `foo` directory.\n","\n","To use the `bar` module, we can import it in two ways:"]},{"cell_type":"code","execution_count":83,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":315},"executionInfo":{"elapsed":295,"status":"error","timestamp":1716914125815,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"ktOGp5BODm-_","outputId":"2603d43d-17fb-4bae-d224-48a36b172452"},"outputs":[{"ename":"ModuleNotFoundError","evalue":"No module named 'foo'","output_type":"error","traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)","\u001b[0;32m<ipython-input-83-55da487b42c6>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mimport\u001b[0m \u001b[0mfoo\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbar\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m","\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'foo'","","\u001b[0;31m---------------------------------------------------------------------------\u001b[0;32m\nNOTE: If your import is failing due to a missing package, you can\nmanually install dependencies using either !pip or !apt.\n\nTo view examples of installing some common dependencies, click the\n\"Open Examples\" button below.\n\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n"]}],"source":["import foo.bar"]},{"cell_type":"markdown","metadata":{"id":"lk6mo3q5Do4v"},"source":["or:"]},{"cell_type":"code","execution_count":84,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":315},"executionInfo":{"elapsed":251,"status":"error","timestamp":1716914149306,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"kloZP3pRDqJJ","outputId":"c88bf62f-c4aa-4cdd-a0a7-7cf242f3a012"},"outputs":[{"ename":"ModuleNotFoundError","evalue":"No module named 'foo'","output_type":"error","traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)","\u001b[0;32m<ipython-input-84-17c8219278ab>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mfrom\u001b[0m \u001b[0mfoo\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mbar\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m","\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'foo'","","\u001b[0;31m---------------------------------------------------------------------------\u001b[0;32m\nNOTE: If your import is failing due to a missing package, you can\nmanually install dependencies using either !pip or !apt.\n\nTo view examples of installing some common dependencies, click the\n\"Open Examples\" button below.\n\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n"]}],"source":["from foo import bar"]},{"cell_type":"markdown","metadata":{"id":"lAbg5zMFD16m"},"source":["In the first example above, we need to use the `foo` prefix whenever we access the `bar` module. In the second example, we don't need to, because we've imported the module into our module's namespace.\n","\n","The `__init__.py` file can also determine which modules the package exports as part of its API, while keeping other modules internal. This can be achieved by overriding the `__all__` variable like this:"]},{"cell_type":"code","execution_count":85,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":106},"executionInfo":{"elapsed":450,"status":"error","timestamp":1716914228971,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"5mT34IhMD_64","outputId":"63df0818-7b55-4fc5-8188-ea83b8248891"},"outputs":[{"ename":"SyntaxError","evalue":"invalid syntax (<ipython-input-85-45d8bf1c62c0>, line 1)","output_type":"error","traceback":["\u001b[0;36m  File \u001b[0;32m\"<ipython-input-85-45d8bf1c62c0>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    __init__.py:\u001b[0m\n\u001b[0m                ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"]}],"source":["__init__.py:\n","\n","__all__ = [\"bar\"]"]},{"cell_type":"markdown","metadata":{"id":"S4kFC78wGI2z"},"source":["## Additional topics\n","### Generators\n","Generators are a special type of function that return an iterable set of items, one at a time, in a special way. They use `yield` to return values and pause execution, which resumes from where it left off each time the generator's `__next__()` method is called.\n","\n","Here's a simple example of a generator function that yields 7 random integers:"]},{"cell_type":"code","execution_count":1,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":304,"status":"ok","timestamp":1716931963483,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"Xctb8ROTHnEI","outputId":"cbb063c0-8d33-447a-d337-04967cff9ea0"},"outputs":[{"name":"stdout","output_type":"stream","text":["78\n","64\n","3\n","14\n","23\n","51\n","52\n"]}],"source":["import random\n","\n","def generate_random_numbers(n):\n","    for _ in range(n):\n","        yield random.randint(1, 100)  # Generates a random integer between 1 and 100\n","\n","# Using the generator\n","for number in generate_random_numbers(7):\n","    print(number)"]},{"cell_type":"markdown","metadata":{"id":"rCEZTONQHxOu"},"source":["In this example, `generate_random_numbers(n)` yields `n` random integers. Each time `yield` is called, the generator produces a value and pauses. The `for` loop continues fetching the next value until all 7 numbers are generated. Generators are memory-efficient because they generate values on the fly and do not store the entire sequence in memory."]},{"cell_type":"markdown","metadata":{"id":"SRYe39z6JO4k"},"source":["### List Comprehensions\n","List comprehensions are a powerful tool in Python that allow you to create new lists based on existing lists in a single, readable line of code.\n","\n","For example, let's say we need to create a list of integers representing the length of each word in a given sentence, but only if the word is not \"the\".\n","\n","Using a list comprehension, we can simplify this process with the following code:"]},{"cell_type":"code","execution_count":2,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":270,"status":"ok","timestamp":1716932397728,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"kNauy1NvJRsB","outputId":"65a844ee-7afc-4f27-b898-841e3cb09b83"},"outputs":[{"name":"stdout","output_type":"stream","text":["[5, 5, 3, 5, 4, 4, 3]\n"]}],"source":["sentence = \"The quick brown fox jumps over the lazy dog\"\n","words = sentence.split()\n","\n","# List comprehension to get the length of each word, excluding \"the\"\n","word_lengths = [len(word) for word in words if word.lower() != \"the\"]\n","print(word_lengths)"]},{"cell_type":"markdown","metadata":{"id":"BjaGSlrbJfiv"},"source":["This list comprehension iterates over each word in the `words` list, calculates its length, and includes it in the `word_lengths` list only if the word is not \"the\". This approach is concise and highly readable."]},{"cell_type":"markdown","metadata":{"id":"vVP_L1YrJ9mS"},"source":["### Lambda Functions\n","Normally, we define a function using the def keyword somewhere in the code and call it whenever we need to use it."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"YVXBU1cJKAJv"},"outputs":[],"source":["def add(a, b):\n","    return a + b\n","\n","result = add(3, 5)\n","print(result)  # This prints 8"]},{"cell_type":"markdown","metadata":{"id":"DfSoOP5eKHBE"},"source":["Instead of defining the function somewhere and calling it, we can use Python's lambda functions, which are inline functions defined at the same place we use them. This way, we don't need to declare a function separately for a single-use case.\n","\n","Lambda functions, also known as anonymous functions, don't need a name. We define a lambda function using the `lambda` keyword."]},{"cell_type":"code","execution_count":3,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":513,"status":"ok","timestamp":1716932642628,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"tPSGRrk6KLob","outputId":"7888d121-77df-4b97-f1e4-fd8a321d2195"},"outputs":[{"name":"stdout","output_type":"stream","text":["8\n"]}],"source":["# Lambda function to add two numbers\n","add = lambda a, b: a + b\n","\n","result = add(3, 5)\n","print(result)  # This prints 8"]},{"cell_type":"markdown","metadata":{"id":"FjZgn2S2KXWe"},"source":["In this example, we assign the lambda function to the variable `add`, and upon providing the arguments `a` and `b`, it works like a normal function.\n","\n","Lambda functions are particularly useful for short, throwaway functions or for use in places where a small function is required, such as in sorting or filtering operations."]},{"cell_type":"markdown","metadata":{"id":"3rQQBnZfLNnU"},"source":["### Multiple Function Arguments\n","Every function in Python typically receives a predefined number of arguments, if declared normally, like this:"]},{"cell_type":"code","execution_count":4,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":272,"status":"ok","timestamp":1716932919258,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"saZGyBCjLQFr","outputId":"10bdcbac-2321-4359-9c15-28fb26d6d401"},"outputs":[{"name":"stdout","output_type":"stream","text":["1 2 3\n"]}],"source":["def foo(a, b, c):\n","    print(a, b, c)\n","\n","foo(1, 2, 3)"]},{"cell_type":"markdown","metadata":{"id":"7xGuH2f2LW-J"},"source":["It is possible to declare functions that receive a variable number of arguments using the following syntax:"]},{"cell_type":"code","execution_count":5,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":278,"status":"ok","timestamp":1716932948661,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"z8uFZeEGLX3S","outputId":"8402754a-b150-444c-e428-0e8658f647fc"},"outputs":[{"name":"stdout","output_type":"stream","text":["1 2 3\n","(4, 5)\n"]}],"source":["def foo(a, b, c, *therest):\n","    print(a, b, c)\n","    print(therest)\n","\n","foo(1, 2, 3, 4, 5)"]},{"cell_type":"markdown","metadata":{"id":"4xg4t2KpLiGy"},"source":["The `therest` variable is a tuple that receives all arguments given to the `foo` function after the first three arguments. So calling `foo(1, 2, 3, 4, 5)` will print out:"]},{"cell_type":"code","execution_count":6,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":106},"executionInfo":{"elapsed":384,"status":"error","timestamp":1716933025888,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"kz0kA0ioLs7i","outputId":"3076cb9f-a6b4-4da7-c5f6-3f513f9aa20f"},"outputs":[{"ename":"SyntaxError","evalue":"invalid syntax (<ipython-input-6-42462213330a>, line 1)","output_type":"error","traceback":["\u001b[0;36m  File \u001b[0;32m\"<ipython-input-6-42462213330a>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    1 2 3\u001b[0m\n\u001b[0m      ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"]}],"source":["1 2 3\n","(4, 5)"]},{"cell_type":"markdown","metadata":{"id":"yI2-C9eGLx4C"},"source":["It is also possible to send function arguments by keyword, so that the order of the arguments does not matter, using the following syntax. The following code yields the output: \"The sum is: 6\" and \"Result: 1\"."]},{"cell_type":"code","execution_count":7,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":284,"status":"ok","timestamp":1716933061588,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"nwlBhvCgLzLn","outputId":"bb000947-dd05-4313-cc33-835fcd193059"},"outputs":[{"name":"stdout","output_type":"stream","text":["The sum is: 6\n","Result: 1\n"]}],"source":["def bar(a, b, c, **options):\n","    if options.get(\"action\") == \"sum\":\n","        print(\"The sum is:\", a + b + c)\n","    if options.get(\"number\") == \"first\":\n","        return a\n","\n","result = bar(1, 2, 3, action=\"sum\", number=\"first\")\n","print(\"Result:\", result)"]},{"cell_type":"markdown","metadata":{"id":"VPLJaFklL8cJ"},"source":["The `bar` function receives three positional arguments. If an additional `action` argument is provided, instructing to sum up the numbers, then the sum is printed out. Alternatively, the function also knows it must return the first argument if the value of the `number` parameter, passed into the function, is equal to \"first\"."]},{"cell_type":"markdown","metadata":{"id":"uoaIEcpBM-vu"},"source":["### Regular Expressions\n","Regular Expressions (sometimes shortened to regexp, regex, or re) are tools for matching patterns in text. In Python, we use the `re` module. Regular expressions have widespread applications, but they can be complex. It's often wise to consider alternatives before using regexes.\n","\n","For example, consider the regex `r\"^(From|To|Cc).*?python-list@python.org\"`. Here's an explanation:\n","\n","*   The caret `^` matches text at the beginning of a line.\n","*   The group `(From|To|Cc)` means the line must start with one of these words, separated by the pipe `|`, which acts as an OR operator.\n","*   The `.*?` matches any number of any characters (except newline) in an un-greedy manner. The `.` matches any non-newline character, `*` means to repeat 0 or more times, and `?` makes it un-greedy, matching as few characters as possible.\n","\n","Thus, the regex will match lines like:\n","\n","*   `From: python-list@python.org`\n","*   `To: someone@python-list@python.org`\n","\n","A complete reference for the `re` syntax is available in the Python documentation.\n","\n","Here is an example of using regular expressions in Python:"]},{"cell_type":"code","execution_count":8,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":294,"status":"ok","timestamp":1716933722337,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"dGZxAIzGOWkN","outputId":"f37b5022-b3bb-4ad9-f646-cb9b871b03e6"},"outputs":[{"name":"stdout","output_type":"stream","text":["['To']\n"]}],"source":["import re\n","\n","# Sample text\n","text = \"From: user@example.com\\nTo: python-list@python.org\\nCc: someone@example.com\"\n","\n","# Regex pattern\n","pattern = r\"^(From|To|Cc).*?python-list@python.org\"\n","\n","# Find all matches\n","matches = re.findall(pattern, text, re.MULTILINE)\n","\n","# Print matches\n","print(matches)"]},{"cell_type":"markdown","metadata":{"id":"NcZ_U4_qOcVA"},"source":["This script finds and prints all lines in the text that match the given pattern."]},{"cell_type":"markdown","metadata":{"id":"wIFvO1zSOqUI"},"source":["### Exception Handling\n","When programming, errors happen. It's a fact of life. Perhaps the user provided bad input, a network resource was unavailable, the program ran out of memory, or the programmer made a mistake!\n","\n","Python's solution to errors is exceptions. You might have seen an exception before:"]},{"cell_type":"code","execution_count":9,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":141},"executionInfo":{"elapsed":278,"status":"error","timestamp":1716933820547,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"17wJISXlOtA2","outputId":"d68a84d6-2d34-49ed-ae20-4ba42cfe32c3"},"outputs":[{"ename":"NameError","evalue":"name 'a' is not defined","output_type":"error","traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)","\u001b[0;32m<ipython-input-9-bca0e2660b9f>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m","\u001b[0;31mNameError\u001b[0m: name 'a' is not defined"]}],"source":["print(a)"]},{"cell_type":"markdown","metadata":{"id":"oEgUWeYWO2G-"},"source":["This will raise a `NameError` because the variable `a` is not defined.\n","\n","Sometimes you don't want exceptions to completely stop the program. You might want to do something special when an exception is raised. This is done using a try/except block.\n","\n","Here's a simple example: Suppose you're iterating over a list. You need to iterate over 20 numbers, but the list is created from user input and might not have 20 numbers in it. After you reach the end of the list, you want the rest of the numbers to be interpreted as 0. Here's how you could do that:"]},{"cell_type":"code","execution_count":10,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":258,"status":"ok","timestamp":1716933879513,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"YHxs9q4wO58Q","outputId":"d3242652-c6e8-4caf-f612-0d90bb98a2bc"},"outputs":[{"name":"stdout","output_type":"stream","text":["1\n","2\n","3\n","4\n","5\n","0\n","0\n","0\n","0\n","0\n","0\n","0\n","0\n","0\n","0\n","0\n","0\n","0\n","0\n","0\n"]}],"source":["numbers = [1, 2, 3, 4, 5]  # Example list from user input\n","\n","for i in range(20):\n","    try:\n","        print(numbers[i])\n","    except IndexError:\n","        print(0)"]},{"cell_type":"markdown","metadata":{"id":"tNdQj8jeO_q-"},"source":["In this example, the code prints each number in the `numbers` list. If the list doesn't have enough elements and an `IndexError` is raised, the code prints 0 instead.\n","\n","This approach allows the program to handle exceptions gracefully without stopping execution. You can handle any exception in this manner. For more details on handling exceptions, refer to the [Python documentation](https://docs.python.org/3/tutorial/errors.html)."]},{"cell_type":"markdown","metadata":{"id":"KzzlVuHjPmx5"},"source":["### Sets\n","Sets are collections of unique elements with no duplicate entries. Let's say you want to collect a list of words used in a paragraph:"]},{"cell_type":"code","execution_count":11,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":273,"status":"ok","timestamp":1716934066081,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"Z0C_1jHzPozy","outputId":"bb1f7929-0fdb-4c68-b601-fd1c0ae02850"},"outputs":[{"name":"stdout","output_type":"stream","text":["{'name', 'my', 'and', 'Eric', 'is'}\n"]}],"source":["paragraph = \"my name is Eric and Eric is my name\"\n","words = set(paragraph.split())\n","print(words)"]},{"cell_type":"markdown","metadata":{"id":"AHuEUePQPvG5"},"source":["This will print out a set containing \"my\", \"name\", \"is\", \"Eric\", and \"and\". Since the rest of the sentence uses words that are already in the set, they are not inserted twice.\n","\n","Sets are powerful tools in Python as they can calculate differences and intersections between other sets. For example, say you have lists of participants in events A and B:"]},{"cell_type":"code","execution_count":12,"metadata":{"executionInfo":{"elapsed":284,"status":"ok","timestamp":1716934094395,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"20o-ZR_qPwKr"},"outputs":[],"source":["event_a = {\"John\", \"Paul\", \"George\", \"Ringo\"}\n","event_b = {\"George\", \"Ringo\", \"Mick\", \"Keith\"}"]},{"cell_type":"markdown","metadata":{"id":"QN9SMIGmP2mC"},"source":["To find out which members attended both events, you can use the `intersection` method:"]},{"cell_type":"code","execution_count":13,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":336,"status":"ok","timestamp":1716934135563,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"pusJ2z7EP5DT","outputId":"18d90fda-9f80-4d05-cf59-443f445335b6"},"outputs":[{"name":"stdout","output_type":"stream","text":["{'Ringo', 'George'}\n"]}],"source":["both_events = event_a.intersection(event_b)\n","print(both_events)  # Output: {'George', 'Ringo'}"]},{"cell_type":"markdown","metadata":{"id":"AytC3Y1kQAFt"},"source":["To find out which members attended only one of the events, use the `symmetric_difference` method:"]},{"cell_type":"code","execution_count":14,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":275,"status":"ok","timestamp":1716934168688,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"pW1CZaAmQB3T","outputId":"f2a7df64-1833-4484-be96-377037f72d13"},"outputs":[{"name":"stdout","output_type":"stream","text":["{'Keith', 'Paul', 'Mick', 'John'}\n"]}],"source":["one_event = event_a.symmetric_difference(event_b)\n","print(one_event)  # Output: {'John', 'Paul', 'Mick', 'Keith'}"]},{"cell_type":"markdown","metadata":{"id":"qT84JfevQFtV"},"source":["To find out which members attended only one event and not the other, use the `difference` method:"]},{"cell_type":"code","execution_count":15,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":246,"status":"ok","timestamp":1716934205257,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"N9hX0wavQKwt","outputId":"1f142d19-afda-487f-930c-b6f6a2f49029"},"outputs":[{"name":"stdout","output_type":"stream","text":["{'John', 'Paul'}\n","{'Mick', 'Keith'}\n"]}],"source":["only_a = event_a.difference(event_b)\n","print(only_a)  # Output: {'John', 'Paul'}\n","only_b = event_b.difference(event_a)\n","print(only_b)  # Output: {'Mick', 'Keith'}"]},{"cell_type":"markdown","metadata":{"id":"vuw3E_6xQOqQ"},"source":["To receive a list of all participants, use the `union` method:"]},{"cell_type":"code","execution_count":16,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":250,"status":"ok","timestamp":1716934238491,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"uhaADqtUQTGI","outputId":"2ed72af6-09e6-481d-eab7-12d0ede25901"},"outputs":[{"name":"stdout","output_type":"stream","text":["{'Ringo', 'George', 'Keith', 'Paul', 'Mick', 'John'}\n"]}],"source":["all_participants = event_a.union(event_b)\n","print(all_participants)  # Output: {'John', 'Paul', 'George', 'Ringo', 'Mick', 'Keith'}"]},{"cell_type":"markdown","metadata":{"id":"jegiySxYQWg8"},"source":["In the exercise below, use the given lists to print out a set containing all the participants from event A who did not attend event B:"]},{"cell_type":"code","execution_count":17,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":259,"status":"ok","timestamp":1716934272980,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"_WxB1TQlQdUf","outputId":"8664855e-f4e0-457d-b040-5f042ff23458"},"outputs":[{"name":"stdout","output_type":"stream","text":["{'John', 'Paul'}\n"]}],"source":["event_a = {\"John\", \"Paul\", \"George\", \"Ringo\"}\n","event_b = {\"George\", \"Ringo\", \"Mick\", \"Keith\"}\n","\n","only_a_not_b = event_a.difference(event_b)\n","print(only_a_not_b)  # Output: {'John', 'Paul'}"]},{"cell_type":"markdown","metadata":{"id":"HlLHhRG2Qx9I"},"source":["### Partial Functions\n","You can create partial functions in Python by using the `partial` function from the `functools` library. Partial functions allow you to derive a function with fewer parameters by setting fixed values for some of the original function's parameters.\n","\n","First, you need to import the required module:"]},{"cell_type":"code","execution_count":18,"metadata":{"executionInfo":{"elapsed":267,"status":"ok","timestamp":1716934386955,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"7iMT85a2Q5Gr"},"outputs":[],"source":["from functools import partial"]},{"cell_type":"markdown","metadata":{"id":"-vnVn8uSQ9l7"},"source":["Here's an example of using partial functions:"]},{"cell_type":"code","execution_count":19,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":302,"status":"ok","timestamp":1716934416815,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"SI8xYK8bQ-S8","outputId":"b7d1a2e2-36c4-4113-8dd0-3f654301f800"},"outputs":[{"name":"stdout","output_type":"stream","text":["8\n"]}],"source":["def multiply(x, y):\n","    return x * y\n","\n","dbl = partial(multiply, 2)\n","print(dbl(4))  # Output: 8"]},{"cell_type":"markdown","metadata":{"id":"tGVQKxAGRHhX"},"source":["This code will return 8.\n","\n","An important note: the default values will start replacing variables from the left. In this example, the 2 will replace `x`, so when `dbl(4)` is called, `y` will equal `4`. While this doesn't make a difference in this simple example, it can be significant in more complex scenarios.\n","\n","Consider another example where default values start from the left:"]},{"cell_type":"code","execution_count":20,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":279,"status":"ok","timestamp":1716934479565,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"n2WgG8ZJRNSf","outputId":"ec230876-701c-4d75-be43-fd7124cdeaad"},"outputs":[{"name":"stdout","output_type":"stream","text":["9\n"]}],"source":["def power(base, exponent):\n","    return base ** exponent\n","\n","square = partial(power, exponent=2)\n","print(square(3))  # Output: 9"]},{"cell_type":"markdown","metadata":{"id":"FAf6qZsNRW-l"},"source":["In this case, the partial function `square` sets the `exponent` to 2, so calling square(3) calculates 3^2, which returns 9.\n","\n","Partial functions are a useful tool for creating more specialized functions from general-purpose functions, simplifying code, and improving readability."]},{"cell_type":"markdown","metadata":{"id":"s8aZkKY-SGfI"},"source":["### Decorators\n","Decorators allow you to make simple modifications to callable objects like functions, methods, or classes. We'll focus on functions for this tutorial.\n","\n","The syntax:"]},{"cell_type":"code","execution_count":21,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":106},"executionInfo":{"elapsed":354,"status":"error","timestamp":1716934719591,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"7HGkXGTsSIt6","outputId":"696cd6eb-123c-4207-f1ca-ef8d18f8038f"},"outputs":[{"ename":"SyntaxError","evalue":"incomplete input (<ipython-input-21-c66788a34fa6>, line 3)","output_type":"error","traceback":["\u001b[0;36m  File \u001b[0;32m\"<ipython-input-21-c66788a34fa6>\"\u001b[0;36m, line \u001b[0;32m3\u001b[0m\n\u001b[0;31m    # function body\u001b[0m\n\u001b[0m                   ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m incomplete input\n"]}],"source":["@my_decorator\n","def my_function():\n","    # function body"]},{"cell_type":"markdown","metadata":{"id":"EFtIBpfySM_H"},"source":["Is equivalent to:"]},{"cell_type":"code","execution_count":22,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":106},"executionInfo":{"elapsed":803,"status":"error","timestamp":1716934756628,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"PTKF5gX5SRTy","outputId":"0c8a494a-54d3-4832-a5e9-864648fd2b66"},"outputs":[{"ename":"IndentationError","evalue":"expected an indented block after function definition on line 1 (<ipython-input-22-3f14f4e3c411>, line 4)","output_type":"error","traceback":["\u001b[0;36m  File \u001b[0;32m\"<ipython-input-22-3f14f4e3c411>\"\u001b[0;36m, line \u001b[0;32m4\u001b[0m\n\u001b[0;31m    my_function = my_decorator(my_function)\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m expected an indented block after function definition on line 1\n"]}],"source":["def my_function():\n","    # function body\n","\n","my_function = my_decorator(my_function)"]},{"cell_type":"markdown","metadata":{"id":"myLcT9h4SWMC"},"source":["As you may have seen, a decorator is just another function that takes a function and returns one. For example, you could define a simple decorator like this:"]},{"cell_type":"code","execution_count":23,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":264,"status":"ok","timestamp":1716934793900,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"a3P7SZ_fSaF-","outputId":"8d9800a5-6089-4cfe-9157-488c7c0e65c2"},"outputs":[{"name":"stdout","output_type":"stream","text":["Hello\n","Hello\n"]}],"source":["def repeat_twice(func):\n","    def wrapper():\n","        func()\n","        func()\n","    return wrapper\n","\n","@repeat_twice\n","def say_hello():\n","    print(\"Hello\")\n","\n","say_hello()"]},{"cell_type":"markdown","metadata":{"id":"1zl2x7ydSehX"},"source":["This would make the function `say_hello` repeat twice.\n","\n","You can also make a decorator change the output:"]},{"cell_type":"code","execution_count":24,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":275,"status":"ok","timestamp":1716934828261,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"vA6I2hQ2SjBn","outputId":"12efc119-b5c9-40e8-f5b9-9867020330ea"},"outputs":[{"name":"stdout","output_type":"stream","text":["HELLO\n"]}],"source":["def uppercase(func):\n","    def wrapper():\n","        original_result = func()\n","        modified_result = original_result.upper()\n","        return modified_result\n","    return wrapper\n","\n","@uppercase\n","def greet():\n","    return \"hello\"\n","\n","print(greet())"]},{"cell_type":"markdown","metadata":{"id":"6pqAG3UISm3q"},"source":["Change input:"]},{"cell_type":"code","execution_count":25,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":313,"status":"ok","timestamp":1716934861461,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"fI5svFvsSqoF","outputId":"7f8fd900-b5ee-45ff-8b58-49a0ed8af692"},"outputs":[{"name":"stdout","output_type":"stream","text":["Hello, John, Esq.\n"]}],"source":["def add_suffix(func):\n","    def wrapper(name):\n","        return func(name) + \", Esq.\"\n","    return wrapper\n","\n","@add_suffix\n","def say_hello(name):\n","    return \"Hello, \" + name\n","\n","print(say_hello(\"John\"))"]},{"cell_type":"markdown","metadata":{"id":"TZAK8C5ISvDF"},"source":["And do checking:"]},{"cell_type":"code","execution_count":26,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":315},"executionInfo":{"elapsed":348,"status":"error","timestamp":1716934890065,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"udhw9UKOSyYu","outputId":"54667672-e324-416f-e1f1-d9184cc09a7d"},"outputs":[{"name":"stdout","output_type":"stream","text":["9\n"]},{"ename":"ValueError","evalue":"x must be non-negative","output_type":"error","traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)","\u001b[0;32m<ipython-input-26-0ab4ca4e2354>\u001b[0m in \u001b[0;36m<cell line: 13>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     11\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     12\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msquare\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 13\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msquare\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# This will raise a ValueError\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m","\u001b[0;32m<ipython-input-26-0ab4ca4e2354>\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m      2\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mwrapper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m             \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"x must be non-negative\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mwrapper\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;31mValueError\u001b[0m: x must be non-negative"]}],"source":["def check(func):\n","    def wrapper(x):\n","        if x < 0:\n","            raise ValueError(\"x must be non-negative\")\n","        return func(x)\n","    return wrapper\n","\n","@check\n","def square(x):\n","    return x * x\n","\n","print(square(3))\n","print(square(-2))  # This will raise a ValueError"]},{"cell_type":"markdown","metadata":{"id":"sKx_yqHWS4Jz"},"source":["Let's say you want to multiply the output by a variable amount. You could define the decorator and use it as follows:"]},{"cell_type":"code","execution_count":27,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":262,"status":"ok","timestamp":1716934929503,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"gUA8wdXBS7f4","outputId":"4bab4663-0815-40d8-e196-c7fae3edeb8c"},"outputs":[{"name":"stdout","output_type":"stream","text":["8\n"]}],"source":["def multiply_output(multiplier):\n","    def decorator(func):\n","        def wrapper(*args, **kwargs):\n","            result = func(*args, **kwargs)\n","            return result * multiplier\n","        return wrapper\n","    return decorator\n","\n","@multiply_output(2)\n","def double(x):\n","    return x\n","\n","print(double(4))  # Output: 8"]},{"cell_type":"markdown","metadata":{"id":"bKIbEJkyS_eC"},"source":["You can do anything you want with the old function, even completely ignore it! Advanced decorators can also manipulate the docstring and argument number. For some useful decorators, you can explore the [Python Decorator Library](https://wiki.python.org/moin/PythonDecoratorLibrary)."]},{"cell_type":"markdown","metadata":{"id":"5FOQOvC-Tdsc"},"source":["### Map, Filter, Reduce\n","#### Map:\n","The `map()` function in Python has the following syntax:"]},{"cell_type":"code","execution_count":28,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":141},"executionInfo":{"elapsed":286,"status":"error","timestamp":1716935088697,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"bvPFsf47Ti0c","outputId":"670bdedd-4e91-413e-fabe-317ccfbc76ce"},"outputs":[{"ename":"NameError","evalue":"name 'func' is not defined","output_type":"error","traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)","\u001b[0;32m<ipython-input-28-b5782404f4bf>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0miterables\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m","\u001b[0;31mNameError\u001b[0m: name 'func' is not defined"]}],"source":["map(func, *iterables)"]},{"cell_type":"markdown","metadata":{"id":"4AiMgC19TmjG"},"source":["Where `func` is the function on which each element in the iterables (as many as they are) would be applied. The asterisk (*) on iterables means there can be as many iterables as possible, as long as `func` has that exact number as required input arguments.\n","\n","In Python 2, `map()` returns a list. In Python 3, however, it returns a map object, which is a generator object. To get the result as a list, you can call the built-in `list()` function on the map object.\n","\n","Let's see some examples:"]},{"cell_type":"code","execution_count":29,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":270,"status":"ok","timestamp":1716935157586,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"J6NYQQ2LTyHG","outputId":"8d2183d8-28f1-4054-85be-48fea1982c1e"},"outputs":[{"name":"stdout","output_type":"stream","text":["['ALFRED', 'TABITHA', 'WILLIAM', 'ARLA']\n","['ALFRED', 'TABITHA', 'WILLIAM', 'ARLA']\n"]}],"source":["# Traditional approach\n","my_pets = [\"alfred\", \"tabitha\", \"william\", \"arla\"]\n","uppered_pets = []\n","for pet in my_pets:\n","    uppered_pets.append(pet.upper())\n","print(uppered_pets)\n","\n","# Using map()\n","my_pets = [\"alfred\", \"tabitha\", \"william\", \"arla\"]\n","uppered_pets = list(map(str.upper, my_pets))\n","print(uppered_pets)"]},{"cell_type":"markdown","metadata":{"id":"Jl1tEtKPT3Sd"},"source":["#### Filter:\n","The `filter()` function requires the function to return boolean values (True or False) and then passes each element in the iterable through the function, filtering away those that are False. It has the following syntax:"]},{"cell_type":"code","execution_count":30,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":141},"executionInfo":{"elapsed":279,"status":"error","timestamp":1716935195615,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"taHBEZFST9EY","outputId":"49f15bb9-ef20-456c-db46-0afb1554b62c"},"outputs":[{"ename":"NameError","evalue":"name 'func' is not defined","output_type":"error","traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)","\u001b[0;32m<ipython-input-30-706cb3a52d46>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mfilter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0miterable\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m","\u001b[0;31mNameError\u001b[0m: name 'func' is not defined"]}],"source":["filter(func, iterable)"]},{"cell_type":"markdown","metadata":{"id":"lRfyiA6LUA-2"},"source":["Let's see some examples:"]},{"cell_type":"code","execution_count":31,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":12,"status":"ok","timestamp":1716935224618,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"RAZrusTgUEVr","outputId":"a9256152-9dd7-40e3-c934-150758a2d0d2"},"outputs":[{"name":"stdout","output_type":"stream","text":["[80, 90, 78, 84]\n","['racecar', 'radar', 'madam', 'anutforajaroftuna']\n"]}],"source":["# Filtering students who passed with scores more than 75\n","def passed(score):\n","    return score > 75\n","\n","scores = [67, 80, 90, 43, 60, 78, 84]\n","passed_students = list(filter(passed, scores))\n","print(passed_students)\n","\n","# Filtering palindromes from a list of suspected palindromes\n","def is_palindrome(word):\n","    return word == word[::-1]\n","\n","suspected_palindromes = (\"racecar\", \"radar\", \"apple\", \"madam\", \"anutforajaroftuna\")\n","palindromes = list(filter(is_palindrome, suspected_palindromes))\n","print(palindromes)"]},{"cell_type":"markdown","metadata":{"id":"aZywjtH_UH-F"},"source":["#### Reduce:\n","`reduce()` applies a function of two arguments cumulatively to the elements of an iterable, optionally starting with an initial argument. It has the following syntax:"]},{"cell_type":"code","execution_count":32,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":106},"executionInfo":{"elapsed":280,"status":"error","timestamp":1716935290469,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"A90kdNbrUUJC","outputId":"5beedb52-153a-4188-a1bc-996f119930b7"},"outputs":[{"ename":"SyntaxError","evalue":"invalid syntax (<ipython-input-32-6401af9cf2be>, line 1)","output_type":"error","traceback":["\u001b[0;36m  File \u001b[0;32m\"<ipython-input-32-6401af9cf2be>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    reduce(func, iterable[, initial])\u001b[0m\n\u001b[0m                          ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"]}],"source":["reduce(func, iterable[, initial])"]},{"cell_type":"markdown","metadata":{"id":"dGXcB-dLUXrP"},"source":["Let's create our own version of Python's built-in `sum()` function:"]},{"cell_type":"code","execution_count":33,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":354,"status":"ok","timestamp":1716935324068,"user":{"displayName":"Orhan Konak","userId":"15850942418063134977"},"user_tz":-120},"id":"7WoBt9ueUcTe","outputId":"61fb83bf-e412-42f1-954a-d8b1905ae183"},"outputs":[{"name":"stdout","output_type":"stream","text":["68\n"]}],"source":["from functools import reduce\n","\n","def custom_sum(first, second):\n","    return first + second\n","\n","numbers = [10, 20, 30, 8]\n","result = reduce(custom_sum, numbers)\n","print(result)"]},{"cell_type":"markdown","metadata":{"id":"AtDdDE-qUf6x"},"source":["That's all about Python's Map, Reduce, and Filter. Feel free to try the exercises below to further solidify your understanding of each function."]},{"cell_type":"markdown","metadata":{"id":"dFYYnnWcUwLi"},"source":["## Top 30 Python Tips and Tricks for Smart Coding\n","[Link](https://techbeamers.com/essential-python-tips-tricks-programmers/)"]}],"metadata":{"colab":{"authorship_tag":"ABX9TyPmR8N3MEo4UbZsb9V7ac3b","provenance":[]},"kernelspec":{"display_name":"Python 3","name":"python3"},"language_info":{"name":"python"}},"nbformat":4,"nbformat_minor":0}