From 094687cabe54c98bec7e8fe7b8dbc3abb8a4c768 Mon Sep 17 00:00:00 2001 From: Ankit Mahato Date: Mon, 24 Oct 2022 13:59:46 +0530 Subject: [PATCH] initial --- README.md | 7717 +++++++++++++++++++++++++++++++++++++++++++++- images/0201a.png | Bin 0 -> 35271 bytes images/0201b.png | Bin 0 -> 25520 bytes images/0201c.png | Bin 0 -> 87680 bytes images/0201d.png | Bin 0 -> 21131 bytes images/0202a.png | Bin 0 -> 33123 bytes images/0202b.png | Bin 0 -> 23548 bytes images/0202c.png | Bin 0 -> 41312 bytes images/0303a.png | Bin 0 -> 25767 bytes images/0303b.png | Bin 0 -> 12714 bytes images/0303c.png | Bin 0 -> 16519 bytes images/0501a.png | Bin 0 -> 7472 bytes images/0501b.png | Bin 0 -> 7979 bytes images/0501c.png | Bin 0 -> 13036 bytes images/0501d.png | Bin 0 -> 19221 bytes images/0702a.png | Bin 0 -> 48631 bytes images/0702b.png | Bin 0 -> 14421 bytes images/0802a.png | Bin 0 -> 8458 bytes images/0802b.png | Bin 0 -> 7855 bytes images/0803a.png | Bin 0 -> 18410 bytes images/0803b.png | Bin 0 -> 20402 bytes images/0804a.png | Bin 0 -> 14940 bytes images/0805a.png | Bin 0 -> 14406 bytes 23 files changed, 7715 insertions(+), 2 deletions(-) create mode 100755 images/0201a.png create mode 100755 images/0201b.png create mode 100755 images/0201c.png create mode 100755 images/0201d.png create mode 100755 images/0202a.png create mode 100755 images/0202b.png create mode 100755 images/0202c.png create mode 100755 images/0303a.png create mode 100755 images/0303b.png create mode 100755 images/0303c.png create mode 100755 images/0501a.png create mode 100755 images/0501b.png create mode 100755 images/0501c.png create mode 100755 images/0501d.png create mode 100755 images/0702a.png create mode 100755 images/0702b.png create mode 100644 images/0802a.png create mode 100644 images/0802b.png create mode 100644 images/0803a.png create mode 100644 images/0803b.png create mode 100644 images/0804a.png create mode 100644 images/0805a.png diff --git a/README.md b/README.md index a90b3a4..ab95ebe 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,7715 @@ -# 100-days-of-python -Notes for #100daysofpython course by EdPunk. Learn Python in 100 Days. Visit https://edpunk.com for videos. +# Programming Languages + +In today's digital era, we depend on computers, smartphones and the internet to perform a plethora of tasks, like: + +- A mathematical task, such as finding the square root of a number or solving a set of simultaneous equations. +- A text-based task such as reading a document and performing search/replace. +- Streaming and playing multimedia files containing audio and video. +- Using a search engine to find and visit a website. +- Playing an online multiplayer game with friends. +- and many more... + +Softwares play an important role as they translate human activity into corresponding machine instructions which are executed to accomplish these tasks. + +A **software** is a collection of programs where each program provides a sequence of instructions specifying how the computer should act. + +These instructions have to be provided in **machine language** or **low level language** (0s and 1s) that is difficult to read or write for a human being. + +This led to the invention of **high-level programming languages** in which programs can be easily written and managed. The human-readable programs written using high-level languages are converted into computer-readable machine code or bytecode using **compilers** or **interpreters**. + +There are many high-level programming languages that are currently in wide use. + +Some of the popular languages are: + +- Java +- C +- C++ +- C# +- Go +- Swift +- JavaScript +- PHP +- Dart +- Kotlin +- Python + +# Python Programming Language + +Guido van Rossum started the development of Python in December 1989. He released the first version (0.9.9) of Python for general public on **February 20, 1991**. + +The language evolved over the next few decades and so did its definition, the current version of which is stated below: + +**Python is a high-level, interpreted, object-oriented programming language with dynamic semantics.** + +Let us break down and analyze the above definition to gain a better understanding of Python: + +## High-level + +Python is a **high-level programming language** which can be used to write a program in natural language (english) making it readable, writable, shareable and manageable. + +While developing a Python program one is not required to handle the various components of computer architecture like registers, memory addresses and call stacks which have to be handled if an assembly language or a low-level language is used for development. + +Python includes high-level language features like variables, data structures (lists, dictionaries, etc.), objects, expressions, modules, classes, functions, loops, threads, file handling, string handling, error handling and other computer science abstraction concepts. + +## Interpreted + +In traditional programming languages like C or C++, codes are compiled into computer-readable machine code before it can be executed. + +Python is an **interpreted language** where the Python interpreter reads and executes the program line by line. + +The process is more time consuming compared to compiled code execution, but allows faster development as one does not have to go through the entire compilation step during testing and debugging. Also, the code can run on any platform as long as it has a valid Python installation (which includes interpreter) as there is no generation of platform dependent binaries. + +## Object-oriented + +Python does not enforce **Object-oriented programming (OOP)**, but completely supports it. + +A programmer can define Classes specifying the data in the form of attributes (or properties) and some programming logic in the form of member functions (or methods). Once a class is defined, the user can create an instance of that class which is known as an object. + +In Python, everything (`int`, `list`, `dict`, etc.) is an object. We will cover more about objects in detail in the later sections. + +## Dynamic Semantics + +As Python is an interpreted language in which the code is executed line-by-line, a python statement or expression is evaluated during run-time. This allows **dynamic typing** (type of a variable can change over its lifetime) and creation of dynamic objects during run-time, which provides more flexibility, usability and fewer lines of code as compared to statically-typed compiled languages like C/C++. + +# Advantages of Python + +The key advantages of Python are as follows: + +## 1. Easy to Learn + +The Python programming language is easy to learn with low technical and conceptual overhead. This makes it an ideal language for beginners to learn programming. + +## 2. Clear Syntax & Fewer Lines of Code + +Python's simple and easy to learn syntax increases code readability and leads to fewer lines of code. + +A typical task which requires an average of twenty lines of code in C and seven in Java can often be done with just one line in Python. + +Also, due to fewer lines of code the chances of making any error is significantly reduced. + +## 3. Open Source + +Python is an open source programming language, so anyone can view and contribute to its source code. + +## 4. Portable & Platform Independent + +The Python programming language is portable & platform independent as it can work on any Linux, MacOS or Windows device. + +## 5. Standard Library & Python Packages + +Python has a rich and extensive Standard Library, a collection of predefined functions for various tasks. + +Python programmers also have at their disposal the vast ecosystem of more than 250,000 community contributed libraries in the Python Package Index (PyPI), where one can find a solution to every conceivable task. + +## 6. Web Application Development + +Some of the most popular web development frameworks (django, flask, etc.) are written in Python. This coupled with the availablity of packages to connect to any database makes Python a great choice for web application development. + +# Windows + +Let's start with the Python 3 installation process on Windows operating system. + +## Step 1: Download Installer + +Download the latest Windows installer from the [Python Software Foundation website](https://www.python.org/downloads/). + +![Step 1: Download Installer](images/0201a.png) + +## Step 2: Install Python 3 + +Once the download is complete double-click and run it. + +![Step 2: Install Python 3](images/0201b.png) + +Select the checkbox ✅ `Add Python 3.9 to PATH`. This will enable you to install python packages and run python script via command-line. + +Hit 🛡️ `Install Now` and complete the setup. + +## Step 3: Verify Installation + +Once the setup is complete, click on the `Start` menu and open `Python 3.9 -> IDLE (Python 3.9 64 bit)` to launch the Python interpreter. + +![Step 3: Launch Python Interpreter](images/0201c.png) + +Python 3.9 is now successfully installed on your computer. + +![Step 3: Verify Installation](images/0201d.png) +# macOS (Apple) + +Let's start with the Python 3 installation process on macOS operating system. + +## Step 1: Download Installer + +Download the latest macOS installer from the [Python Software Foundation website](https://www.python.org/downloads/). + +![Step 1: Download Installer](images/0202a.png) + +## Step 2: Install Python 3 + +Once the download is complete double-click and run it. + +![Step 2: Install Python 3](images/0202b.png) + +Hit `Continue` and complete the setup. + +## Step 3: Verify Installation + +Once the setup is complete, click on the `Launchpad -> IDLE` to launch the Python interpreter. + +![Step 3: Verify Installation](images/0202c.png) + +Python 3.9 is now successfully installed on your computer. +# Python Execution Modes + +After installing the latest version of the Python interpreter, we can now write and execute some basic Python codes. + +There are two ways to execute a Python program: + +1. **Interactive Mode**: When the IDLE application is launched, the Python interpreter or the Python shell pops up on the screen. User can interact with the Python interpreter and execute statements (single line or multiline code snippets) directly in this Python shell. +2. **Script Mode**: This is the most commonly used method for executing a Python program. The entire Python program is written and saved in a file (`.py` extension) which can be executed using the IDLE application. +# Interactive Mode + +In this section, we will execute some basic Python statements and interact with the Python shell. + +## Launching the Python Shell + +To launch the IDLE application click `[Windows Start Menu Button] -> [Python 3.9 Folder] -> [IDLE (Python 3.9 64 bit)]`. + +![Launch IDLE](images/0201c.png) + +The Python interpreter or the Python shell will pop-up on the screen. + +![Python Shell](images/0201d.png) + +The version (`3.9`) of the Python interpreter is displayed at the top of the window followed by the `>>>` symbol which indicates that the interpreter is ready to take instructions. + +Python commands or statements can be input on this prompt. The input statements are executed instantaneously and any variable assignments are retained as long as the session is not terminated. + +## Basic Arithmetic + +Let us perform some basic arithmetic operations in the interactive mode using an integer number (`2`) and a floating-point number (`3.5`): + +``` python +>>> 2 + 2 +4 +>>> 2 * 3.5 +7.0 +``` + +It can be observed that the results of each of the above computations are displayed immediately in the shell. + +## Storing Values/Results + +Instead of immediately displaying the results, they can also be stored in variables using the assignment symbol (`=`) as shown below: + +``` python +>>> a = 2 + 2 +>>> b = 2 * 3.5 +``` + +The values of `a` and `b` can be accessed later for future calculations as shown below: + +``` python +>>> a +4 +>>> b +7.0 +>>> a * 5 +20 +>>> b / 3 +2.3333333333333335 +``` + +## Basic String Operation + +Interactive mode is not just restricted to basic arithmetic or assignments. Let us join two strings - `"Hello, "` and `"world!"`. + +``` python +>>> "Hello, " + "world!" +'Hello, world!' +``` + +## Conclusion + +The complete functionality of Python is easily accessible to a user via the **Interactive Mode**. + +This makes it convenient for testing and instant execution of small code snippets (single line or few lines of code), a feature not available in compiled languages like C, C++ and Java. + +But, the statements cannot be saved for future use and have to retyped for re-execution. This disadvantage is overcome by the use of Python in **Script Mode** as described in the next section. +# Script Mode + +To write reusable codes, script mode is the most preferred mode of code execution. + +## File Creation + +To create a new file using the IDLE application click `[File] -> [New File]` + +![Create New File](images/0303a.png) + +Write a simple Python program as shown below + +``` python +a = 2 + 2 +a +``` + +and save the script as `example.py` (`.py` file extension for all Python scripts) using `[File] -> [Save As...]` + +![Save File](images/0303b.png) + +## Script Execution + +Now run this script using `[Run] -> [Run Module]`. + +![Execute File](images/0303c.png) + +It can be observed that the code has been executed, but no output is displayed on the console (or the standard output) as all outputs have to be explicitly specified when running a code in the script mode. + +This can be done by using the `print()` function which is used in Python scripts to display output on the output stream. Let us quickly add the `print()` function in the above code and execute it. + +``` python +a = 2 + 2 +print(a) +``` + +Now, when you run the script you will observe that the value of `a`, that is `4`, is now displayed on the console. +# Tokens + +When a Python code is executed, the Python interpreter reads each logical line and breaks it into a sequence of lexical units. + +These lexical units are better known as **tokens** - the smallest individual units of a program. They are the building blocks of a Python code and can be classified into one of the following categories: + +- **Keywords** : Reserved words that convey special meaning when processed by the Python interpreter. +- **Identifiers** : Names defined by the programmer to refer to objects that can represent variables, functions, classes, etc. +- **Literals** : Values specified in the program which belong to exactly one of the Python's built-in data types. +- **Delimiters** : Symbols that denote grouping, punctuation, and assignment/binding. +- **Operators** : Symbols that can operate on data and compute results. +# Character Set + +A set of valid characters that a programming language recognizes is known as its **character set**. + +Python is a new age programming language which supports Unicode encoding standard. The default encoding for Python source code is UTF-8 (Unicode Transformation Format – 8-bit) which enables developers to use Unicode characters not only as literals, but also as identifiers. + +This makes Python one of the very few programming languages that support multiple languages as shown in the example below: + +#### Code + +``` python +message = "हिन्दी में print करे" +print(message) + +क = 1 # Devanagari Letter KA +ক = 2 # Bengali Letter KA +க = 3 # Tamil Letter KA +ક = 4 # Gujarati Letter KA +print(क + ক + க + ક) +``` + +#### Output + +``` +हिन्दी में print करे +10 +``` +# Keywords + +Keywords are reserved words that have special meaning when processed by the Python interpreter. They are case-sensitive and cannot be used for naming identifiers (class, function, variable or structure names). + +The list of keywords in Python are provided below: + +| | | | +|---|---|---| +| `True` | `False` | `import` | +| `from` | `as` | `None` | +| `and` | `or` | `not` | +| `in` | `is` | `try` | +| `except` | `finally` | `raise` | +| `del` | `global` | `nonlocal` | +| `lambda` | `def` | `class` | +| `with` | `if` | `elif` | +| `else` | `pass` | `for` | +| `while` | `continue` | `break` | +| `assert` | `return` | `yield` | +| `async` | `await` | | +# Identifiers + +Identifiers are used for defining the names of Python objects such as variables, functions, classes, modules, etc. The naming convention for identifiers is as follows: + +- Must begin with a lowercase character (`a-z`) or an uppercase character (`A-Z`) or underscore sign (`_`). +- Followed by any number of letters (`a-z`, `A-Z`), digits (`0-9`), or underscores (`_`). +- Should not be a keyword. +- No special symbols are allowed like `!`, `@`, `#`, `$`, `%`, etc. + +Some points to keep in mind while naming identifiers: + +- Identifiers are case-sensitive in nature and any difference in case of any character refers to a different identifier. e.g., `length` and `Length` are different identifiers. +- Identifiers differing by only underscores are different. e.g., `unitlength` and `unit_length` are different identifiers. + +It is also a good practice (although not compulsory) to follow the following procedure while naming identifiers: + +- Identifiers should be named carefully with an emphasis on clarity and readability. For example, in a program that calculates the area of a rectangle, a good choice for identifier names are - `length`, `breadth` and `area`. +- Class names should start with uppercase character. +- Identifiers starting with an underscore have special meaning in a program. +- Variable, function and method names should be in lowercase characters, with underscores separating multiple words like `area_of_square`, `area_of_triangle`, etc. +# Literals + +Literals are tokens in the source code which represent fixed or constant values. They are often used in assignment statements for initializing variables or in comparison expressions. + +The various types of literals available in Python are as follows: + +## 1. Numeric Literals + +Numeric literals are used for representing numeric values in the source code. They can be of three types - integers, float point numbers and imaginary numbers. + +### a) Integer Literals + +Integer literals are numbers without any fractional component. + +In Python, integer literals can be written in four positional (base) numeral systems: + +#### i. Decimal or base-10 Integer + +A decimal integer literal consists of one or more digits (`0-9`) and cannot have any zeros preceding the first non-zero digit, except when the number is `0`. + +Example base-10 integers: + +``` python +34 +3283298 +864 +0 +``` + +`092` is not a valid decimal integer literal as a zero precedes the first non-zero digit `9`. + +#### ii. Binary or base-2 Integer + +A binary integer or base-2 integer begins with `0b` or `0B` followed by binary digits `0-1`. + +For example, `27` can be written as a binary integer literal `0b11011`. + +#### iii. Octal or base-8 Integer + +An octal integer or base-8 integer begins with `0o` or `0O` followed by octal digits `0-7`. + +For example, `27` can be written as an octal integer literal `0o33`. + +#### iv. Hexadecimal or base-16 Integer + +A hexadecimal integer or base-16 integer begins with `0x` or `0X` followed by digits `0-9` or letters `A-F` (case insensitive). + +For example, `27` can be written as a hexadecimal integer literal `0x1B` or `0x1b`. + +Thus, it can be observed that number `27` can be written in the program as `27` (decimal), `0b11011` (binary), `0o33` (octal) or `0x1B` (hexadecimal). + +#### Underscores in Integer Literals + +An optional character `_` (underscore) is also allowed in an integer literal to group digits for enhanced readability. + +One underscore can occur between digits, and after base specifiers like `0o`. + +They are ignored while determining the actual numerical value of the literal. + +Some valid underscore usages are - `10_00_00_000`, `0b_1110_0101`, `0x23_123`. + +### b) Floating Point Literals + +Floating point literals are real numbers present in the source code. They contain fractional component and/or exponential component. + +The fractional component includes the digits after the decimal point (`.`). + +Example floating point literals: + +``` +3.4 +.4 +8. +3.4E2 +3.4e-2 +``` + +In the above example, `.4` is equivalent to `0.4` and `8.` is equivalent to `8.0`. + +The exponential component can be identified by the letter `e` or `E` followed by an optional sign (`+` or `-`) and digits (`0-9`). This exponent is equivalent to multiplying the real number with the power of `10`. + +For example, `3.4E2` is equivalent to `3.4 x 10^2` or `340.0`, whereas `3.4e-2` is equivalent to `3.4 x 10^-2` or `.034`. + +### c) Imaginary Literals + +To specify complex numbers and perform complex number mathematics, Python supports imaginary literals which are given by real or integer number followed by the letter `j` or `J` which represents the unit imaginary number. + +Example imaginary literals: + +``` +3.5j +15.j +12j +.005j +3e100j +3.5e-10j +``` + +#br + +### Points to Note + +In Python, + +- there is no specialized literal such as a complex literal. A complex number is actually represented in the program using an expression comprising a real number (integer/float numeric literal) and an imaginary number (imaginary literal). For example, `1 + 2j` consists of an integer literal (`1`) and a imaginary literal (`2j`). +- numeric literals do not include the minus sign (`-`). `-` is actually a unary operator it combines with a numeric literal to represent negative numbers. For example, in `-3.14` the numeric literal is `3.14` and `-` is an operator. + +#br + +## 2. Boolean Literals + +The reserved words `True` and `False` are also boolean literals which can be used to specify the truth value in a program. + +#br + +## 3. String Literals + +String literals are texts which can be specified in a variety of ways in Python: + +- Single quotes: `'python'` +- Double quotes: `"python"` +- Triple quoted: `'''Triple python'''`, `"""Three python"""`. + +Triple quoted strings can also span multiple lines. + +Example: + +``` python +s = "I am a String" + +s1 = """A +multiline +String""" + +s2 = '''Also a +multiline +String''' +``` + +The backslash (`\`) character can be used in a string literal to escape characters that otherwise have a special meaning, such as newline, linefeed, or the quote character. + +| Escape Sequence | Meaning | +|--|--| +| `\\` | Backslash (`\`) | +| `\'` | Single quote (`'`) | +| `\"` | Double quote (`"`) | +| `\a` | ASCII Bell (BEL) | +| `\b` | ASCII Backspace (BS) | +| `\f` | ASCII Formfeed (FF) | +| `\n` | ASCII Linefeed (LF) | +| `\r` | ASCII Carriage Return (CR) | +| `\t` | ASCII Horizontal Tab (TAB) | +| `\v` | ASCII Vertical Tab (VT) | + +Although `\'` and `\"` can be used to specify quote characters, Python allows embedding double quotes inside a single-quoted string (`'My name is "Python".'`) and single quotes inside a double-quoted string (`"Python's World"`). + +String literals also support unicode characters which can be specified using `\u` escape sequence followed by the 4 letter unicode. + +``` python +>>> print("E = mc\u00B2") +E = mc² +``` + +In the above example, `\u00B2` is the unicode character which represents the 'SUPERSCRIPT TWO'. + +#br + +## 4. Special Literal + +`None` is a special literal which is used to denote the absence of value. + +It should not be confused with `0` as `0` is an integer literal with a defined finite value, whereas `None` implies nothingness. + +``` python +>>> a = None +>>> a +>>> +``` + +In the above example, the Python shell does not display any value of `a` as it is assigned as `None` which has no value. + +#br + +## 5. Collection of Literals + +Python has the provision for specifying a collection of literals in the source code using a special syntax known as **"displays"**. + +One can create specialized containers like list, set and dictionary using this syntax. + +Some example collection of literals (displays) are provided below: + +- **List**: `a = ['a', 'b', 'c']` +- **Set**: `a = {'a', 'b', 'c'}` +- **Dictionary**: `a = {'a':1, 'b':2, 'c':3}` + +List, set and dictionary will be covered in detail in later chapters. +# Operators + +Operators are tokens which can be combined with values and variables to create expressions which evaluate to a single value. Python supports a rich set of operators: + +``` python ++ - * ** +/ // % @ +<< >> +& | ^ ~ +:= < > +<= >= == != +``` + +Each of the above operators are covered in detail in the chapter - Operators. +# Delimiters + +Delimiters are tokens which are useful for organizing a program and are used in statements, expressions, functions, literal collections, and various other code structures. + +They can be classified based on utility as follows: + +## Grouping + +`()`, `[]` and `{}` are delimiters used for: + +- grouping expressions which can be spread across multiple physical lines. +- creating collection of literals like list display, dictionary display, set display. +- creating parenthesized sub-expression having the highest operator precedence (evaluated first) in a complex expression. + +Example: + +``` python +days = ['Sunday', 'Monday', + 'Tuesday', 'Wednesday', + 'Thursday', 'Friday', + 'Saturday'] + +sum_6 = (1 + 2 + + 3 + 4 + + 5 + 6) +``` + +is equivalent to + +``` python +days = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'] + +sum_6 = (1 + 2 + 3 + 4 + 5 + 6) +``` + +#br + +## Punctuation, Decoration and Annotation + +Tokens in Python which are used for punctuation, decoration and annotation are: + +``` python +. , : +; @ -> +``` + +#br + +## Assignment/Binding + +The assignment or binding delimiters are used for binding objects to names via assignment statements. The complete list of tokens are provided below: + +``` python += += -= *= +/= //= %= **= +@= &= |= ^= +<<= >>= +``` + +Except `=`, the rest of the tokens have an operator followed by `=` character. + +These delimiters are also known as augmented assignment operators as they perform an operation in combination with assignment. +# Blocks and Indentation + +In traditional programming languages like C++ or Java, programs are organised in form of code blocks. + +Each code block contains one or more statements which are enclosed between braces - `{` and `}` and are executed sequentially. + +A sample C++/Java code is provided below which checks for an input `x`. + +## C++ + +```c++ +if (x < 10) { + cout << "x is less than 10" << endl; + if (x <= 5) { + cout << "x is less than or equal to 5" << endl; + } + else { + cout << "x is more than 5 but less than 10" << endl; + } +} +else { + cout << "x is not less than 10" << endl; +} +``` + +## Java + +```java +if (x < 10) { + System.out.println("x is less than 10"); + if (x <= 5) { + System.out.println("x is less than or equal to 5"); + } + else { + System.out.println("x is more than 5 but less than 10"); + } +} +else { + System.out.print("x is not less than 10"); +} +``` + +It can be seen how indentations (`tab` at the beginning of line) are added (not required by programming language) to the code to increase readability, which helps in guiding readers through the code. + +## Python + +Code blocks in Python are inspired by this idea as it makes it easier to understand a Python code. + +A block of code is denoted by line indentation, typically **4 spaces** (preferred) or a **tab**. This indentation is used to determine the logical group of statements, with all statements within a group having the same level of indentation. + +The corresponding Python code for the above C++/java examples is provided below. + +Notice how the code blocks are indented according to the logic. + +``` python +if x < 10: + print("x is less than 10") + if x <= 5: + print("x is less than or equal to 5") + else: + print("x is more than 5 but less than 10") +else: + print("x is not less than 10") +``` +# Comments + +Python supports single-line comments and multi-line comments to enhance code readability via adding documentation. + +## Single Line Comments + +A single line comment begins with `#`. Everything between `#` and the end of line is ignored by the Python interpreter. + +``` python +# A single line comment. +a = 1 # assign a +``` + +## Multiline comments + +A multiline comment begins with `'''` or `"""` and ends with the same. + +``` python +""" +I am +a multiline +comment. +""" + +''' +I am +also a multiline +comment. +''' +``` + +As compared to single line comments, multiline comments should begin at the same indentation level corresponding to their code block. + +For example, + +``` python +""" +Begin program +here +""" +if x < 10: + """ + Enter code block when x + is less than 10 + """ + print("x is less than 10") + if x <= 5: + """ + Enter code block when x + is less than or equal to 5 + """ + print("x is less than or equal to 5") + else: + """ + Enter code block when x + is more than 5 but less than 10 + """ + print("x is more than 5 but less than 10") +else: + """ + Enter code block when x + is not less than 10 + """ + print("x is not less than 10") +``` +# Objects and Variables + +A program is a sequence of instructions which often acts on information (data) provided by the user. + +The process of creating, storing and manipulating this data helps in the computation of new data or the end result. + +**Variables are the fundamental building blocks of a program** which provide a way to store, access and modify values during the life-cycle of a program. + +Each variable has: + +- a name (handle), +- a type or data-type (kind of data), and +- a value (actual data). + +In traditional programming languages like Java or C++, the type of the variable is pre-defined. + +For example, if you want to use the value `1` inside the program, you can store it in a variable named `a` of type `int`. + +``` +int a = 1; +``` + +This `a` is synonymous to a box of fixed dimensions (fixed type) holding something (value `1`) inside it. + +![Box 'a'](images/0501a.png) + +In case we want to change the contents of the box, we can replace it with something similar (same type). + +``` +a = 2; +``` + +![Filled box 'a'](images/0501b.png) + +The contents of this box can be replicated and placed in a similar (same type) box: + +``` +int b = a; +``` + +![Copy box 'a' contents](images/0501c.png) + +Multiple boxes can exist, each containing an item having the same value. + +``` +int x = 3; +int y = 3; +int z = 3; +``` + +![Boxes 'x', 'y' & 'z'](images/0501d.png) + +As shown above, the programming languages in which the variables (named boxes) are declared along with their types (size of the boxes) are known as **statically typed** languages. + +The size of these boxes cannot change later in the program until the variable is re-initialized with the same name and different type. + +**Python is a dynamically-typed language**, where every value or data item (of any type like numeric, string, etc.) is an object. + +The variable names are just name-tags pointing to the actual object containing data of any type. + +As there is no need of any variable declaration in Python before usage, there is no concept of default value (an empty box or `null`) which exists in other programming languages. + +Whenever a new object is created in Python, it is assigned a unique identity (ID) which remains the same throughout the lifetime of that object. This ID is the address of the object in memory and the built-in function `id()` returns the value of this address. + +``` python +>>> a = 1 +>>> id(a) +140407745943856 +>>> a = 2 +>>> id(a) +140407745943888 +``` + +In the above example, the ID of `a` changes as it points to a new object (`2`). + +``` python +>>> b = a +>>> id(b) +140407745943888 +``` + +Also, when `a` is assigned to `b`, instead of creating a new copy, `b` points to the same object as `a`. +# Creating a Variable + +A variable is uniquely identified by a name (identifier) and follows the same naming convention: + +- Must begin with a lowercase character (`a-z`) or an uppercase character (`A-Z`) or underscore sign (`_`). +- Followed by any number of letters (`a-z`, `A-Z`), digits (`0-9`), or underscores (`_`). +- Should not be a keyword. +- No special symbols are allowed like `!`, `@`, `#`, `$`, `%`, etc. + +## Assignment + +Variables can be bound to a reference of an object (of any type) using assignment statements. + +You can create an object (data) and bind it's reference to a variable using equal sign (`=`): + +``` python +count = 100 # integer +pi = 3.141 # real number +name = "Python" # string +``` + +Here, L-value refers to the assignable variables (`count`, `pi`, `name`) on the left side of the assignment and R-value refers to the expression on the right side of the assignment operator that has a value (`100`, `3.141`, `"Python"`). + +As variables are just references, you can rebind them to another object of same or different type: + +``` python +a = 100 # integer +a = 3.141 # real number +a = "Python" # string +``` + +## Deletion + +The `del` statement can be used to unbind the reference to an object. + +``` python +>>> a = 10 +>>> del a +>>> a +Traceback (most recent call last): + File "", line 1, in +NameError: name 'a' is not defined +``` + +Accessing `a` results in a `NameError` as the reference (variable) to the object holding value `10` is deleted. + +The object is also automatically cleaned up from the memory if there is no other variable referencing to it (garbage collection). + +## Multiple Assignment + +In Python, multiple assignment can be used to condense variables which are set to the same value: + +``` python +>>> x = y = z = 'foo' +>>> x +'foo' +>>> y +'foo' +>>> z +'foo' +``` + +## Tuple Swapping + +In Python, a temporary variable is not required to swap values of two variables. Values can be directly swapped (tuple swapping) as shown below: + +``` python +>>> a = 'Hello' +>>> b = 'World' +>>> b, a = a, b +>>> a +'World' +>>> b +'Hello' +``` +# Built-in Data Types + +In Python, the `type` of a data (or value) is not linked to the variable, but to the actual object which contains it. This type is also known as the object's data type and is used for identifying the operations that can be performed on the data. + +The following built-in data types are available in Python: + +- **Numeric Types** - `int`, `float`, `complex`, `bool` +- **Sequence Types** - `list`, `tuple`, `str` +- **Set Type** - `set` +- **Mapping Type** - `dict` +- **Special Type** - `None` + +Often sequence, set and mapping types are also collectively known as **iterables** as they are a collection of items on which a user can traverse (iterate). + +## 1. Numeric Types + +Numeric data types are used for storing the following types of numbers: + +### i. Integer Numbers + +Objects holding integer numbers like `-1, 0, 200` are of `int` data type. + +### ii. Real or Floating-point Numbers + +Objects holding real or floating point numbers like `-1.1, 3e2, 20.0` are of `float` data type. + +### iii. Complex Numbers + +Objects storing complex numbers like `2 + 1j, -3j, -1 + 2J` are of type `complex`. + +Each complex number has two parts, the real part which is a numeric integer or floating point literal, and the imaginary part which is an imaginary literal. + +### iv. Boolean + +The boolean data type (`bool`) is a subtype of `int`. It stores the evaluated value of expressions represented as keywords - `True` (integer value `1`) and `False` (integer value `0`). + +#br + +## 2. Sequence Types + +An ordered collection of items where each item can be accessed using an integer index is known as a sequence. The following three sequence data types are available in Python: + +### i. String + +A string (`str` data type) is a sequence of zero or more unicode characters enclosed within a pair of single (`'`) or double (`"`) quotes. + +Some example strings are - `"42", 'hello', "python"`. + +### ii. List + +A `list` is sequence of items of same or different data types which are enclosed within brackets - `[ ]`. + +Some example lists are - `[1, 2, 3]`, `['abc', 23, 3.14]`, `['edpunk', 'python']`. + +### iii. Tuple + +A `tuple` is an immutable sequence of items of same or different data types which are enclosed within parentheses - `( )`. + +Some example tuples are - `(1, 2, 3)`, `('abc', 23, 3.14)`, `('edpunk', 'python')`. + +#br + +## 3. Set Type + +A `set` is an unordered collection of unique items of same of different data types which are enclosed in curly braces - `{ }`. + +Some example sets are - `{1, 2, 3}`, `{'abc', 23, 3.14}`, `{'edpunk', 'python'}`. + +#br + +## 4. Mapping Type + +`dict` is a mapping data type which stores values in the form of key-value pairs. + +It is used for representing data where you can quickly access the value (any data type) corresponding to a key (any data type except `list`, `set` or `dict`), just like a dictionary where you can lookup the meaning of a given word. + +Keys and corresponding values are separated by colon (`:`). + +The key-value pairs are separated by comma (`,`) and enclosed within curly braces - `{ }`. + +Some example dictionaries are - `{1: "a", 2: "b", 3: "c"}`, `{"name": "edpunk", "language": "python"}`. + +#br + +## 5. Special Type + +`None` is a special data type which is used to denote the absence of value in an object. + +It is neither `0` nor `False` as these are defined finite values, whereas `None` implies nothingness. +# Type Checking + +The built-in `type()` function can be used to fetch the data type of an object. + +Examples: + +``` python +>>> count = 100 +>>> type(count) + + +>>> pi = 3.141 +>>> type(pi) + + +>>> name = "Python" +>>> type(name) + +``` + +This function can be used along with the `is` operator in an expression to test whether the object is of the given type. + +``` python +>>> count = 100 +>>> type(count) is int +True +``` + +The `in` operator can be used along with the `type()` function to test if the data type is one of the mentioned types. + +``` python +# count is of type int or float +>>> type(count) in (int, float) +True +``` +# Type Casting + +The process of converting the data type of an object from one type to another is known as **Type Casting** or **Type Conversion**. + +The two kinds of type casting supported in Python are: + +## Implicit Type Casting + +The Python interpreter automatically converts the data type without the need of user intervention when evaluating expressions to determine the final data type. + +In the below example the final type of `c` is automatically determined as `float` by the Python interpreter. + +``` python +>>> a = 1 # int +>>> b = 2.0 # float +>>> c = a + b +>>> c +3.0 +>>> type(c) + +``` + +#br + +## Explicit Type Casting + +When the type conversion is explicitly specified by the user using the various built-in functions available in Python, it is known as explicit type casting. + +The built-in functions which can be used for explicit type casting are as follows: + +### int() + +Creates an `int` from a `bool`, `float` or `str` containing integer characters (with or without sign). + +``` python +>>> int(True) +1 +>>> int(2.3) +2 +>>> int("2") +2 +``` + +### float() + +Creates a `float` from a `bool`, `int` or `str` containing floating point literals (with or without sign). + +``` python +>>> float(True) +1.0 +>>> float(2) +2.0 +>>> float("2.3") +2.3 +``` + +`float()` also accepts the following string inputs - + +- `"Infinity"` +- `"inf"` +- `"nan"` (not a number). + +``` python +>>> float("Infinity") > 1 +True +>>> float("nan") +nan +``` + +Floating point literals can also contain the following characters - + +- `.`, which denotes the fractional part of a number. +- `e` or `E`, which denotes the exponent part of a number. + +``` python +>>> float("3.14") +3.14 +>>> float("10.") +10.0 +>>> float("1e100") +1e+100 +>>> float("3.14e-10") +3.14e-10 +``` + +### str() + +Converts any object into a `str`. + +``` python +>>> str(2) +'2' +>>> str([1, 2, 3, 4]) +'[1, 2, 3, 4]' +``` + +### tuple() + +Creates a `tuple` from an iterable of type `str`, `list`, `set` or `range`. + +``` python +>>> tuple('hello') +('h', 'e', 'l', 'l', 'o') +>>> tuple([1, 2, 3, 4]) +(1, 2, 3, 4) +>>> tuple(range(6)) +(0, 1, 2, 3, 4, 5) +``` + +### list() + +Creates a `list` from an iterable of type `str`, `tuple`, `set` or `range`. + +``` python +>>> list('hello') +['h', 'e', 'l', 'l', 'o'] +>>> list({1, 2, 3, 4}) +[1, 2, 3, 4] +>>> list(range(6)) +[0, 1, 2, 3, 4, 5] +``` + +### set() + +Creates a `set` from an iterable of type `str`, `tuple`, `list` or `range`. + +``` python +>>> set('hello') +{'o', 'e', 'l', 'h'} +>>> set([1, 2, 3, 4]) +{1, 2, 3, 4} +>>> set(range(6)) +{0, 1, 2, 3, 4, 5} +``` +# Mutability & Immutability + +## Immutable Data Types + +A data type is said to be immutable when the value of an object of that type cannot be modified. + +The following data types are immutable: + +- `int` +- `float` +- `complex` +- `bool` +- `tuple` +- `str` +- `None` + +You might be wondering if some of the above types are immutable then how are we able modify the values of variables? + +In case of variable re-assignment, the original objects are not modified, but new objects (with new values) are created in a new memory location and are bound to the variables. The object containing the old value is destroyed if no other variable references it. + +Let us take an example, + +``` python +>>> a = 1 +>>> id_a = id(a) +>>> a = 2 +>>> id_a2 = id(a) +>>> id_a == id_a2 +False +``` + +You can witness in the above example how the object containing the value `1` is different from the object containing the value `2`, and `a` points to the latest object. + +Sequence data types like strings and tuples are also immutable, i.e., no modifications are permitted to any item once it is created and any attempt to do so raises an error. + +``` python +>>> s = "Hello" +>>> s[1] = "P" +Traceback (most recent call last): + File "", line 1, in +TypeError: 'str' object does not support item assignment +>>> t = (1, 2, 3) +>>> t[1] = 0 +Traceback (most recent call last): + File "", line 1, in +TypeError: 'tuple' object does not support item assignment +``` + +Although, similar to numeric types the variables can be re-assigned to new sequences. + +``` python +>>> s = "Hello" +>>> id_s = id(s) +>>> s = "Help" +>>> id_s2 = id(s) +>>> id_s == id_s2 +False + +>>> t = (1, 2, 3) +>>> id_t = id(t) +>>> t = (0, 2, 3) +>>> id_t2 = id(t) +>>> id_t == id_t2 +False +``` + +## Mutable Data Types + +In Python, the following data types are mutable, i.e., any modification does not create a new object but modifies the existing object: + +- `list` +- `set` +- `dict` + +Let us take a list and modify its contents. + +``` python +>>> l = [1, 2, 3] +>>> id_l = id(l) +>>> l[0] = 0 +>>> l +[0, 2, 3] +>>> id_l2 = id(l) +>>> id_l == id_l2 +True +``` + +Let us take an example of a dictionary and add a new `key:value` pair. + +``` python +>>> d = {"a": "apple", "b": "boy"} +>>> id_d = id(d) +>>> d["c"] = "cat" +>>> d +{'a': 'apple', 'b': 'boy', 'c': 'cat'} +>>> id_d2 = id(d) +>>> id_d == id_d2 +True +``` + +Let us take an example of a set and add new item. + +``` python +>>> s = {"apple", "bat"} +>>> id_s = id(s) +>>> s.add("cat") +>>> s +{'cat', 'apple', 'bat'} +>>> id_s2 = id(s) +>>> id_s == id_s2 +True +``` + +In the above examples, the `id` of the objects (`list`, `dict`, `set`) do not change, which implies that no new objects are created and the original objects are modified. +# Standard Input - input() + +`input()` function is used to accept new input data from the user. + +When this function is encountered in the code, the python interpreter waits for the user to type a response which is read as a string and assigned to a variable. + +``` python +>>> name = input() +edpunk +>>> name +'edpunk' +``` + +The function also has an optional string argument which is used as a prompt message for the user. + +``` python +>>> name2 = input("Enter name: ") +Enter name: EdPunk +>>> name2 +'EdPunk' +``` + +User input can be converted into integer or floating point numbers using the type conversion functions `int()` and `float()`. + +``` python +>>> num = int(input("Enter n: ")) +Enter n: 10 +>>> type(num) + +>>> num +10 + +>>> pi = float(input("Enter pi: ")) +Enter pi: 3.14 +>>> type(pi) + +>>> pi +3.14 +``` +# Standard Output - print() + +The built-in `print()` function is used to display an output (value of variables, expressions, etc.) on the standard output. + +Let us go through a program which computes the area of a rectangle and displays it: + +#### Code + +``` python +length = 10 +breadth = 5 +area = length * breadth +print("Area:", area) +``` + +#### Output + +``` +Area: 50 +``` + +`print()` function can also be used to output the value of multiple objects when they are provided as arguments to the function. + +#### Code + +``` python +a = 2 + 2 +b = 2 * 3.5 +print(a, b) +``` + +#### Output + +``` +4 7.0 +``` + +In the above code, the values of `a` and `b` are separated by a blank space (the default value of `sep`). + +This property can be modified by providing any user defined separator using the `sep` option. + +Let us modify the code and provide `","` as the separator. + +#### Code + +``` python +a = 2 + 2 +b = 2 * 3.5 +print(a, b, sep=",") +``` + +#### Output + +``` +4,7.0 +``` + +When expressions are provided as arguments to the `print()` function, output is the evaluated value of those expressions. + +For example, + +#### Code + +``` python +print(2 + 2) +print(2 * 3.5) +print("Hello, " + "world!") +``` + +#### Output + +``` +4 +7.0 +Hello, world! +``` + +In the above code snippet, each `print()` function invocation creates a new line of output. This is because `end` parameter has the newline character (`'\n'`) as the default value in the `print()` function. + +This can be modified by the user as shown below: + +#### Code + +``` python +print(2 + 2, end=",") +print(2 * 3.5, end=";") +print("Hello, " + "world!") +``` + +#### Output + +``` +4,7.0;Hello, world! +``` + +## Summary + +All non-keyword arguments or expressions are converted to strings and written to the output stream by the `print()` function. They are separated by `sep` and followed by `end`. An empty `print()` invocation writes `end` parameter (an empty line as `end` defaults to the newline character `'\n'`). +# Types of Operators + +Operators are symbols that perform a single simple task or operation on one or more values resulting in a single evaluated value. + +The values on which these operators are applied are called **operands**. + +## Unary Operators + +Unary operators are applied on a single operand positioned on right side of the operator. + +Following are some unary operators available in Python: + +- `+` (plus): The unary `+` operator does not change the value of the operand. +- `-` (minus): The unary `-` operator changes the sign of the operand. +- `~` (bitwise `NOT`): The unary `~` results in the bit-wise inversion of the integer operand. The bit-wise inversion of `x` is defined as `-(x+1)`. + +``` python +>>> x = 5 +>>> -x +-5 +>>> +x +5 +>>> ~x +-6 +``` + +#br + +## Binary Operators + +Binary operators are applied on two operands. + +For example, arithmetic operators (`+`, `–`, `*`, `/`) evaluate the result of mathematical computation of two values. + +#br + +## Operators in Python + +A rich set of operators are available in Python which can be categorized as follows: + +- Arithmetic Operators - `+`, `–`, `*`, `/`, `%`, `**`, `//` +- Relational Operators - `==`, `!=`, `>`, `>=`, `<`, `<=` +- Assignment Operators - `+=`, `-=`, `*=`, `/=`, `%=`, `**=`, `//=` +- Logical Operators - `not`, `or`, `and` +- Identity Operators - `is`, `is not` +- Membership Operators - `in`, `not in` +- Bitwise and Shift Operators - `&`, `|`, `^`, `~`, `<<`, `>>` +# Arithmetic Operators + +Arithmetic operations can be performed in Python using the following arithmetic operators: + +## Addition + +The `+` operator adds the values of numeric operands. + +``` python +>>> 2 + 3 +5 +>>> 2 + 3.0 +5.0 +``` + +In case the operands are of type `str`, `list` or `tuple`, the `+` operator concatenates these two sequences or strings. + +``` python +>>> 'edpunk' + 'python' +'edpunkpython' +>>> ["ed", "punk"] + ["python", ] +['ed', 'punk', 'python'] +``` + +#br + +## Subtraction + +The `-` operator subtracts the value of operand on right from the value of operand on left. + +``` python +>>> 2 - 3 +-1 +``` + +#br + +## Multiplication + +The `*` operator multiplies the values of numeric operands. + +``` python +>>> 2 * 3 +6 +``` + +In case the operands are of type `str`, `list` or `tuple`, the `*` operator returns a sequence or string self-concatenated the specified number of times. + +``` python +>>> "python" * 3 +'pythonpythonpython' +>>> ['ed', 'py'] * 3 +['ed', 'py', 'ed', 'py', 'ed', 'py'] +``` + +#br + +## Division + +The `/` operator divides the value of operand on left by the value of operand on right and returns the real number quotient. + +``` python +>>> 6 / 2 +3.0 +>>> 5 / 2 +2.5 +``` + +#br + +## Floor Division + +The `//` operator divides the value of operand on left by the value of operand on right and returns the integer quotient. + +``` python +>>> 5 // 2 +2 +``` + +#br + +## Modulus + +The `%` operator divides the value of operand on left by the value of operand on right and returns the remainder. + +``` python +>>> 5 % 2 +1 +``` + +#br + +## Exponent + +The `**` operator raises the left operand to the power of the right operand. + +``` python +>>> 5 ** 2 +25 +``` +# Relational Operators + +Relational operators are useful for comparing the values of the operands to determine their relationship. Following relational operators are available in Python: + +## Equals to + +The `==` operator returns `True` if the value of operand on left is same as the value of operand on right. + +``` python +>>> 2 == 2 +True +>>> 2 == 3 +False +``` + +In case of sequence operands like `str`, `list` or `tuple`, the result is `True` if both the sequences are exactly the same. + +``` python +>>> "python" == "python" +True +>>> "pypi" == "python" +False +>>> [1, 2, 3] == [1, 2, 3] +True +``` + +As a sequence is an ordered collection of items, so the order in which the items are positioned is very important. + +``` python +>>> [2, 1, 3] == [1, 2, 3] +False +``` + +#br + +## Not equal to + +The `!=` operator returns `True` if the value of operand on left is not equal to the value of operand on right. + +``` python +>>> 2 != 2 +False +>>> 2 != 3 +True +>>> 'py' != 'oy' +True +>>> [2, 1, 3] != [1, 2, 3] +True +>>> [1, 2, 3] != [1, 2, 3] +False +``` + +#br + +## Greater than + +The `>` operator returns `True` if the value of operand on left is greater than the value of operand on right. + +``` python +>>> 3 > 2 +True +>>> 2 > 2 +False +``` + +In case of strings operands, `>` operator perform comparison according to the Unicode code point (integer) of each character one-by-one. + +The Unicode code point of a character can be obtained using the `ord()` function in Python. + +The code point of first character of both operands are compared. In case they are equal, the code point of next character of both operands are compared and the process continues. + +For example, + +``` python +>>> "python" > "Python" +True +``` + +The code point of `"p"` (`112`) is greater than the code point of `"P"` (`80`). As `112` is greater than `80` the expression evaluates to `True`. + +Let us take another example: + +``` python +>>> "pYthon" > "python" +False +``` + +The code point of first character is same (`112`), so the next set of characters are compared. The code point of `"Y"` (`89`) is not greater than the code point of `"y"` (`121`) so the expression evaluates to `False`. + +If two string operands `p` and `q` are of unequal lengths (`len(p) < len(q)`) and `p` is a substring of `q` such that `q = pt` where t is any string of length greater than `0`, then `q > p` returns `True`. + +``` python +>>> "python" > "py" +True +``` + +In case of sequence operands like `list` or `tuple`, the items are compared one-by-one starting from index `0`. + +``` python +>>> ["p","py","PY"] > ["p","Py","PY"] +True +>>> [1, 3] > [1, 2] +True +>>> [1, 3, 4] > [1, 2] +True +``` + +In the above examples, `"py"` is greater than `"Py"` and `3` is greater than `2` respectively. + +If two sequences are of unequal lengths and the smaller sequence is the starting subsequence of the larger one, then the larger sequence is considered greater than the smaller one. + +``` python +>>> [1, 2, 4] > [1, 2] +True +``` + +#br + +## Greater than or equal to + +The `>=` operator returns `True` if the value of operand on left is greater than or equal to the value of operand on right. + +``` python +>>> 3 >= 3 +True +>>> 2 >= 3 +False +``` + +In case of sequence operands (`str`, `list`, `tuple`), the comparison operation performed is along the same lines as the `>` operator discussed above. + +``` python +>>> "python" >= "Python" +True +>>> "python" >= "python" +True +>>> ["py", "py", "PY"] >= ["py", "Py", "PY"] +True +>>> [1, 2] >= [1, 2] +True +>>> [1, 2, 4] >= [1, 2] +True +``` + +#br + +## Less than + +The `<` operator returns `True` if the value of operand on left is less than the value of operand on right. + +``` python +>>> 2 < 3 +True +>>> 3 < 3 +False +``` + +In case of sequence operands (`str`, `list`, `tuple`), the comparison operation performed is along the same lines as the `>` operator discussed above. + +``` python +>>> "file" < "Pile" +False +# f(102) is > P(80) +>>> "py" < "python" +True +>>> ["Py", "PY"] < ["py", "PY"] +True +>>> ['a', 2] < ['a', 3] +True +>>> [1, 2] < [1, 2, 4] +True +``` + +#br + +## Less than or equal to + +The `<=` operator returns `True` if the value of operand on left is lesser than or equal to the value of operand on right. + +``` python +>>> 2 <= 3 +True +>>> 3 <= 3 +True +``` + +In case of sequence operands (`str`, `list`, `tuple`), the comparison operation performed is along the same lines as the `>` operator discussed above. + +``` python +>>> "file" <= "Pile" +False +# f(102) is > P(80) +>>> "py" <= "python" +True +>>> ["Py", "PY"] <= ["py", "PY"] +True +>>> ['a', 3] <= ['b', 2] +True +>>> [1, 2] <= [1, 2, 4] +True +``` +# Assignment Operators + +The assignment symbol (`=`) serves as a delimiter between the name and value in an assignment statement. + +It binds (or rebinds) a value (data, variable, expression) on the right to the target variable on the left. + +``` python +>>> x = 1 +>>> x +1 +>>> y = x +>>> y +1 +>>> y = "python" +>>> y +'python' +``` + +Binary operators can be combined with the assignment symbol to create **Augmented Assignment Operators**. + +These operators perform the binary operation on the two operands and assign the result to the original target (left operand). + +If `` is a binary operator, then the expression `a = b` containing the augmented assignment operator is equivalent to `a = a b`. + +#br + +## += + +The `+=` operator adds a value (right operand) to the variable (left operand) and assigns the result to that variable. + +``` python +>>> a = 2 +>>> a += 3 +>>> a +5 +>>> x = "hello" +>>> y = "world" +>>> x += y +>>> x +'helloworld' +``` + +#br + +## -= + +The `-=` operator subtracts a value (right operand) from the variable (left operand) and assigns the result to that variable. + +``` python +>>> a = 3 +>>> a -= 2 +>>> a +1 +``` + +#br + +## *= + +The `*=` operator multiplies a value (right operand) to the variable (left operand) and assigns the result to that variable. + +``` python +>>> a = 3 +>>> a *= 2 +>>> a +6 +>>> x = "hi" +>>> x *= 3 +>>> x +'hihihi' +``` + +#br + +## /= + +The `/=` operator divides the variable (left operand) by a value (right operand) and assigns the result to that variable. + +``` python +>>> a = 4 +>>> a /= 2 +>>> a +2.0 +``` + +#br + +## //= + +The `//=` operator floor divides the variable (left operand) by a value (right operand) and assigns the result to that variable. + +``` python +>>> a = 5 +>>> a //= 2 +>>> a +2 +``` + +#br + +## **= + +The `**=` operator raises the variable (left operand) to a power (right operand) and assigns the result to that variable. + +``` python +>>> a = 4 +>>> a **= 2 +>>> a +16 +``` + +#br + +## %= + +The `%=` operator computes modulus of the variable (left operand) and a value (right operand) and assigns the result to that variable. + +``` python +>>> a = 4 +>>> a %= 3 +>>> a +1 +``` +# Logical Operators + +Expressions using logical operators evaluate to a boolean value (`True` or `False`) based on the logical state of the operands. + +## Logical State of Operands + +In Python, all values except `0`, `None`, `False`, `""`, `''`, `()`, `[]`, `{}` have their logical state as `True`. + +`bool()` built-in function can be used to determine the logical state of literals, variables or expressions. + +The logical state of the following literals is `False`. + +``` python +>>> bool(False) +False +>>> bool(0) +False +>>> bool([]) +False +>>> bool(None) +False +>>> bool("") +False +>>> bool([]) +False +>>> bool(()) +False +>>> bool({}) +False +``` + +Some example literals having boolean state as `True` are provided below. + +``` python +>>> bool(True) +True +>>> bool(1) +True +>>> bool(2.0) +True +>>> bool(100) +True +>>> bool("python") +True +>>> bool(["py", "thon"]) +True +``` + +#br + +## not + +The logical state of an operand can be reversed (`False` to `True`, and vice versa) using the logical `not` operator. + +``` python +>>> n = 5 +>>> bool(n) +True +>>> bool(not n) +False +``` + +#br + +## or + +The logical `or` operator returns `True` if the logical state of any of the two operands is `True`. + +``` python +>>> True or False +True +>>> bool(1 or 0) +True +>>> False or False +False +``` + +#br + +## and + +The logical `and` operator returns `True` if the logical state of both the operands is `True`. + +``` python +>>> True and True +True +>>> True and False +False +>>> bool(10 and 20) +True +>>> bool(1 and 0) +False +``` +# Identity Operators + +We have already witnessed how Python treats every value or data item as an object. + +The relational operator `==` can be used to test whether the operands contain the same value. + +``` python +>>> n = 1 +>>> n2 = 1 +>>> n == n2 +True +``` + +This operator however does not check if both the operands are referring to the same object or different objects. + +The identity operators `is` and `is not` are used to test whether two objects have the same or different identity (pointing to the same location in memory) respectively. + +`a is b` is equivalent to `id(a) == id(b)`, where `id()` is the built-in function which returns the identity of an object. + +``` python +>>> n = 1 +>>> n2 = 1 +>>> n is n2 +True +``` + +In the above example, both variables `n` and `n2` point to that same memory location (same object). + +``` python +>>> l = [1, 2, 3] +>>> l2 = [1, 2, 3] +>>> l == l2 +True +>>> l is l2 +False +``` + +In the above example, both lists `l` and `l2` although contain items with same values, are actually two different objects occupying different memory locations. +# Membership Operators + +The operators `in` and `not in` test whether a value is present or not present in an iterable (string, list, tuple, set, dictionary). + +``` python +>>> 1 in [1, 2, 3] +True +>>> "ed" in ["ed", "py", "hi"] +True +>>> "ed" in ("ed", "py", "hi") +True +>>> 'ed' in {'ed': 1, 'py': 2} +True + +>>> "pen" not in ["pencil", "ink"] +True +>>> "pen" not in ["pen", "ink"] +False +``` +# Expression + +Literals (constants), identifiers (variables) and operators can be combined to form an expression which always evaluates to a single value. + +For example, `40 + marks` is an expression containing a literal (`40`), a variable (`marks`) and an operator (`+`). + +Some valid expressions are provided below: + +- `10` +- `a` +- `-a` +- `a - 10` +- `a + b` +- `4.0 * 3.5` +- `a == b` +- `c in d` +- `a is T` +- `"Hello" + "World"` +- `15 - a*4` +- `3*num + 9/4 - 10%count**2` + +As shown above, standalone literals (like `10`) and variables (like `a`) are considered as expressions, but standalone operators are not expressions. + +#br + +## Chained Expression + +Comparison operators can be chained together in Python. + +For example, `lower <= age <= upper` is a valid chained expression which is equivalent to the expression - + +`lower <= age and age <= upper`. + +If `a`, `b`, `c`, …, `y`, `z` are expressions and `op1`, `op2`, …, `opN` are comparison operators, then the chained expression `a op1 b op2 c ... y opN z` is equivalent to `a op1 b and b op2 c and ... y opN z`. + +#br + +## Conditional Expression + +Python does not have ternary operators (`?:`) like other programming languages. Hence, the keywords `if` and `else` are used to create conditional expressions which evaluates to a value based on the given condition. + +For example, + +``` python +var = t_val if cond else f_val +``` + +If the above condition `cond` evaluates to `True`, then the variable `var` is assigned `t_val`, else it is assigned `f_val`. + +``` python +>>> value = 1 if 2 > 3 else -1 +>>> value +-1 +``` +# Precedence of Operators + +While studying mathematics in middle school, we came across the **BODMAS** (Bracket, Of, Division, Multiplication, Addition, and Subtraction) rule which helps us in understanding how mathematical expressions are computed in the presence of multiple operators (`of`, `x`, `/`, `+`, `-`). + +In Python, we have a large number of operators and a similar rule to determine the order of evaluation of an expression. This is known as **operator precedence** where the operator with higher precedence is evaluated before the operator with lower precedence in an expression. + +The table below presents the precedence of operators in Python from highest to lowest. Operators in the same row have the same precedence, so in such cases the expression is evaluated from left to right. + +| Operator | Description | +|--|--| +| `(expressions...)` | Parenthesized expression (Group) | +| `**` | Exponentiation | +| `+x`, `-x`, `~x` | Unary positive, Unary negative, Bitwise `NOT` | +| `*`, `@`, `/`, `//`, `%` | Multiplication, Matrix multiplication, Division, Floor division, Remainder | +| `+`, `-` | Addition, Subtraction | +| `<<`, `>>` | Shifts | +| `&` | Bitwise `AND` | +| `^` | Bitwise `XOR` | +| `\|` | Bitwise `OR` | +| `in`, `not in`, `is`, `is not`, `<`, `<=`, `>`, `>=`, `!=`, `==` | Membership, Identity & Comparisons | +| `not x` | Boolean `NOT` | +| `and` | Boolean `AND` | +| `or` | Boolean `OR` | +| `:=` | Assignment expression | + +#br + +## Exercise + +### Example 1 + +Evaluate the expression + +`15 - 2 * 4` + +#### Solution + +Step: `*` has higher precedence over `-` +`15 - 2 * 4` += `15 - 8` += `7` + +#br + +### Example 2 + +Evaluate the expression + +`15 - 2 + 4` + +#### Solution + +Step: `-` and `+` have the same order of precedence so the expression is evaluated left to right +`15 - 2 + 4` += `13 + 4` += `17` + +#br + +### Example 3 + +Evaluate the expression + +`15 - (2 + 4)` + +#### Solution + +Parantesized expression `(...)` has the highest precedence so `+` is evaluated first +`15 - (2 + 4)` += `15 - 6` += `9` + +#br + +### Example 4 + +Evaluate the expression + +`3 * 2 + 9 / 4 - 10 % 2 ** 2` + +#### Step 1 + +`**` takes precedence +`3 * 2 + 9 / 4 - 10 % 2 ** 2` += `3 * 2 + 9 / 4 - 10 % 4` + +#### Step 2 + +`*`, `/` and `%` have the same precedence so they are evaluated left to right. +`3 * 2 + 9 / 4 - 10 % 4` += `6 + 2.25 - 2` + +#### Step 3 + +`+` and `-` evaluation +`6 + 2.25 - 2` += `6.25` + +#br + +### Example 5 + +Evaluate the expression + +`20 / 4 // 2 * 2 - 4 + 20` + +#### Step 1 + +`*`, `/`, `//` and `%` have the same precedence so they are evaluated left to right. +`20 / 4 // 2 * 2 - 4 + 20` += `5 // 2 * 2 - 4 + 20` += `2 * 2 - 4 + 20` += `4 - 4 + 20` + +#### Step 2 + +`+` and `-` evaluation +`4 - 4 + 20` += `20` + +#br + +### Example 6 + +Evaluate the expression + +`not 6 <= 4 and 3 ** 3 > 12 / 3` + +#### Step 1 + +`**` takes precedence +`not 6 <= 4 and 3 ** 3 > 12 / 3` += `not 6 <= 4 and 27 > 12 / 3` + +#### Step 2 + +`/` is next in line of precedence +`not 6 <= 4 and 27 > 12 / 3` += `not 6 <= 4 and 27 > 4` + +#### Step 3 + +Comparison operators are next in line of precedence +`not 6 <= 4 and 27 > 4` += `not False and True` + +#### Step 4 + +Boolean `NOT` is evaluated +`not False and True` += `True and True` + +#### Step 5 + +Boolean `AND` is evaluated +`True and True` += `True` +# Error Types + +A program contains **"bug(s)"** when it is unable to execute or produces an output which is different from what is expected. These bugs are generally introduced by a programmer unknowingly. + +The process of identifying and eliminating these bugs or errors is known as **debugging**. + +The three major types of errors are: + +- Syntax Error +- Runtime Error +- Logical Error +# Syntax Error + +Syntax error occurs when the program contains any statement that does not follow the prescribed Python rules or syntax which makes it difficult for the Python interpreter to parse (understand) and execute it. + +Some common syntax errors are: + +- Missing/Misspelled keyword +- Missing colon or brackets +- Empty block +- Incorrect position of keyword +- Incorrect block indentation + +#br + +## Script Mode + +When a code containing syntactically incorrect statement is executed using script mode via IDLE, an error dialog box is displayed. + +![Syntax Error Dialog](images/0702a.png) + +On closing the dialog box, the incorrect part of the code, the potential cause of error, is highlighted in red. + +![Syntax Error Highlighted](images/0702b.png) + +This error has to be rectified to execute the program correctly. + +#br + +## Interactive Mode + +When a syntactically incorrect statement is executed in the Python console (interactive mode), the Python interpreter displays it and also adds a little arrow (`^`) pointing at the entry point or token where the error was detected. + +### Example + +``` python +>>> while True print('Hi!') + File "", line 1 + while True print('Hi!') + ^ +SyntaxError: invalid syntax +``` + +In the above example there is a syntax error with `^` pointing to `print` function which the parser is unable to understand as there is a missing `:` (colon) after `True`. +# Runtime Error + +A runtime error occurs when the program is terminated prematurely by the Python interpreter as it is unable to execute a statement although it is correct syntactically. + +Some runtime error examples are: + +- **ImportError**: Raised when the `import` statement has trouble loading a module or any definition from a module. +- **IOError**: Raised when the interpreter is not able to open the file specified in the program. +- **ZeroDivisionError**: Raised when a number is divided or mod by zero. +- **NameError**: Raised when an identifier is encountered which has not been defined. +- **ValueError**: Raised when an argument or operand is of required data type, but has undesired value. +- **IndexError**: Raised when the provided index in a sequence (string, list, tuple, etc.) is out of range. +- **KeyError**: Raised when a dictionary key is not found in the set of existing keys. +- **TypeError**: Raised while performing an operation on incompatible types. +- **IndentationError**: Raised when the indentation of a statement or code block is incorrect. + +#br + +## Examples + +### ZeroDivisionError + +``` python +n = 100 +d = 0 +print(n/d) +``` + +``` python +Traceback (most recent call last): + File "/Users/name/Desktop/test.py", line 3, in + print(n/d) +ZeroDivisionError: division by zero +``` + +#br + +### NameError + +``` python +n = 100 +print(d) +``` + +``` python +Traceback (most recent call last): + File "/Users/name/Desktop/test.py", line 2, in + print(d) +NameError: name 'd' is not defined +``` + +#br + +### KeyError + +``` python +d = {1: "1st", 2: "2nd"} +print(d[3]) +``` + +``` python +Traceback (most recent call last): + File "/Users/name/Desktop/test.py", line 2, in + print(d[3]) +KeyError: 3 +``` + +#br + +### TypeError + +``` python +n =1 +s = "a" +tot = n + s +``` + +``` python +Traceback (most recent call last): + File "/Users/name/Desktop/test.py", line 3, in + tot = n + s +TypeError: unsupported operand type(s) for +: 'int' and 'str' +``` +# Logical Error + +Logical error or Semantic error is caused when the issue lies in the underlying meaning of the code which leads to an incorrect output. + +As compared to syntax or runtime error there is no termination of the program. + +Debugging a logical error requires inspection of the entire code as no guiding error message is displayed. + +## Example + +Let us write a program to calculate the average of two numbers + +``` python +n = 10 +m = 20 +avg = n + m / 2 +print("Average:", avg) +``` + +On executing the script the result is + +``` +Average: 20.0 +``` + +This is incorrect as there is a logical error in the code. + +Since `/` has a higher precedence over `+`, `m / 2` is being computed first. + +We can modify the code to get rid of the logical error. + +``` python +n = 10 +m = 20 +avg = (n + m) / 2 +print("Average:", avg) +``` + +On executing the script, we now obtain the correct result + +``` +Average: 15.0 +``` +# Exceptions + +We have witnessed that even if a program is syntactically correct, its execution may lead to a run-time error. + +This error detected during execution is known as an **exception** which is an object created by the Python interpreter containing information regarding the error like type of error, file name and the location of the error (line number, token) in the program. + +Some of the built-in exceptions that are raised by the Python interpreter are - `ImportError`, `ZeroDivisionError`, `NameError`, `ValueError`, `IndexError`, `KeyError`, `TypeError` and `IndentationError`. + +Apart from the Python interpreter, a programmer can also trigger and raise an exception (along with a custom message) in the code using `raise` or `assert` statement. + +## raise + +The `raise` statement can be used to throw an exception in a program. The exception may or may not contain the custom error message (recommended). + +Let us consider a program which accepts two numbers (`a` and `b`) from the user and prints the result `a/b`. + +#### Code + +``` python +a = int(input("Enter a: ")) +b = int(input("Enter b: ")) +print("a/b =", a/b) +``` + +#### Output + +``` +Enter a: 10 +Enter b: 0 +Traceback (most recent call last): + File "/Users/name/test.py", + line 3, in + print("a/b =", a/b) +ZeroDivisionError: division by zero +``` + +It can be observed that the Python interpreter raises a `ZeroDivisionError` when the value of `b` is entered as `0`. + +Now we can modify the above code to raise an exception for such scenarios. + +#### Code + +``` python +a = int(input("Enter a: ")) +b = int(input("Enter b: ")) +if b==0: + raise Exception() +print("a/b =", a/b) +``` + +#### Output + +``` +Enter a: 10 +Enter b: 0 +Traceback (most recent call last): + File "/Users/name/test.py", + line 4, in + raise Exception() +Exception +``` + +An exception is raised, but it is not helpful. + +Let us add some custom error message. + +#### Code + +``` python +a = int(input("Enter a: ")) +b = int(input("Enter b: ")) +if b==0: + raise Exception("b is zero") +print("a/b =", a/b) +``` + +#### Output + +``` +Enter a: 10 +Enter b: 0 +Traceback (most recent call last): + File "/Users/name/test.py", + line 4, in + raise Exception("b is zero") +Exception: b is zero +``` + +We can also raise any specific type of error as per the program logic as shown below: + +#### Code + +``` python +a = int(input("Enter a: ")) +b = int(input("Enter b: ")) +if b==0: + raise ValueError("The value of b cannot be zero") +print("a/b =", a/b) +``` + +#### Output + +``` +Enter a: 10 +Enter b: 0 +Traceback (most recent call last): + File "/Users/name/test.py", + line 4, in + raise ValueError("The value of b cannot be zero") +ValueError: The value of b cannot be zero +``` + +#br + +## assert + +An `assert` statement is often used during code development to act like a safety valve which notifies the programmer in case the test expression is evaluated as `False`. + +If the test expression’s value is `True`, the code execution continues normally. + +An `AssertionError` is raised if the value is `False`. + +#### Code + +``` python +a = 3 +b = 4 +assert a == b +c = 5 +``` + +#### Output + +``` +Traceback (most recent call last): + File "/Users/name/test.py", + line 3, in + assert a == b +AssertionError +``` + +The statement also allows for a message to be attached to the `AssertionError`. + +#### Code + +``` python +a = 3 +b = 4 +assert a == b, "a is not equal to b" +c = 5 +``` + +Output: + +``` +Traceback (most recent call last): + File "/Users/name/test.py", + line 3, in + assert a == b, "a is not equal to b" +AssertionError: a is not equal to b +``` +# Exception Handling + +Exception handling is the process of properly handling an exception which can potentially crash a program during execution. + +When an error occurs, the program throws an exception. + +The runtime system attempts to find an **exception handler**, a block of code that can handle a particular type of error. Once located, the suitable exception handler **catches the exeception** and executes the code block which can attempt to recover from the error. In case the error is unrecoverable, the handler provides a way to gently exit the program. + +The `try` statement in Python specifies the exception handlers and/or cleanup code for a code block. + +The various parts of a try statement are: + +- `try` block: The block of statements within which an exception might be thrown. +- `except` clause(s): One or more exception handlers. Each `except` clause handles a particular type of exception. In case an exception of a particular type occurs in the `try` block, the corresponding `except` clause code block is executed. +- `else` clause: An optional `else` clause can also be included after the last `except` block. In case no exception is raised, none of the `except` blocks are executed. In this case, the `else` code block is executed. +- `finally` clause: An optional `finally` clause can be added at the end of the try statement which includes a block of statements that are executed regardless of whether or not any error occured inside the try block. This block is usually setup for code cleanup and closing all open file objects. + +Here's the general form of these statements: + +``` python +try: + [code block] +except [exception1 [as identifier1]]: + [exception code block 1] +except [exception2 [as identifier2]]: + [exception code block 2] +... +... +else: + [code block executes if no error] +finally: + [code block always executed] +``` +# Control Flow Statements + +A simple Python program can be treated as a block of code where each statement is executed by the Python interpreter in a sequential order from top to bottom. + +But, in real world we would like to have some control over the execution of code such as: + +- skip or execute a block (set of statements) based on certain conditions +- execute a block repeatedly +- redirect execution to another set of statements +- breaking up the execution + +This control over the flow of execution is provided by **Control Flow Statements**. + +They can be categorized as: + +- Sequential +- Selection +- Iteration/Repetition +- Jump +- Procedural Abstraction - A sequence of statements are referenced as a single function or method call +- Recursion - Calling a method/function in the same method/function +- Exception Handling +# Sequential + +By default the code statements in Python are executed in Sequential order. + +The below flow chart demonstrates how 3 statements are executed in a sequential order. + +![Sequential Flow](images/0802a.png) + +For example, + +``` python +a = 2 +b = 3 +c = a*b +print(c) +``` + +The above code will be executed in the following sequential order: + +![Sequential Flow of Code](images/0802b.png) +# Selection: if..else + +Selection statements, also known as Decision making statements, control the flow of a program based on the outcome of one or many test expression(s). If the condition is satisfied (`True`) then the code block is executed. There is also a provision to execute another code block if the condition is not satisfied. + +This process can be demonstrated using the below flowchart: + +![Selection Flow](images/0803a.png) + +Python supports `if` compound statement which provides this control. The `if` statement comprises: + +- `if` keyword followed by the test expression, a colon `:` and an indented block of code which gets executed if the condition is satisfied +- (optional) one or many `elif` clause followed by their test conditions and their corresponding code blocks +- (optional) `else` clause and the corresponding code block which gets executed if none of the above conditions (`if`, `elif`) are satisfied + +An example `if` statement is provided below: + +``` python +''' +age - age of loan applicant +emp - is employed (bool) +cscore - credit scrore of applicant +''' +result = None +if age < 26 and not emp: + result = "Loan rejected" +elif age > 35 and cscore < 600: + result = "Loan rejected" +else: + result = "Loan approved" +print(result) +``` + +The control flow view of the above code is: + +![Selection in Flow of Code](images/0803b.png) + +## Examples + +Let us go through some programming problems which utilize selection statements. + +#br + +### Absolute Value + +Write a program to output the magnitude of difference between two numbers using conditional statement. + +#### Code + +``` python +n1 = int(input("Enter 1st number: ")) +n2 = int(input("Enter 2nd number: ")) + +if n1 > n2: + diff = n1 - n2 +else: + diff = n2 - n1 + +print("The difference of", n1, "and", n2, "is", diff) +``` + +#### Output + +``` +Enter 1st number: 12 +Enter 2nd number: 15 +The difference of 12 and 15 is 3 +``` + +#br + +### Sorting 3 Numbers + +Write a program to accept 3 numbers from the user and print them in ascending order of value. + +#### Code + +``` python +a = int(input("Enter 1st number: ")) +b = int(input("Enter 2nd number: ")) +c = int(input("Enter 3rd number: ")) + +if b < a: + # Swapping the values of a and b + a, b = b, a + +if c < b: + b, c = c, b + if b < a: + a, b = b, a + +print("The numbers in sorted order:", a, ",", b, ",", c) +``` + +#### Output + +``` +Enter 1st number: 9 +Enter 2nd number: 2 +Enter 3rd number: 6 +The numbers in sorted order: 2 , 6 , 9 +``` + +#br + +### Divisibility + +Write a program to accept two numbers and test if the first number is divisible by the second number. + +#### Code + +``` python +a = int(input("Enter 1st number: ")) +b = int(input("Enter 2nd number: ")) + +if a % b == 0: + print(a, "is divisible by", b) +else: + print(a, "is not divisible by", b) +``` + +#### Output + +``` +Enter 1st number: 9 +Enter 2nd number: 2 +9 is not divisible by 2 + +Enter 1st number: 9 +Enter 2nd number: 3 +9 is divisible by 3 +``` +# Iteration: for + +Iteration statements, also known as Looping statements, allow repeated execution of a code block. + +Python provides `for` and `while` statements to perform iteration. + +The `for` statement can be used to iterate over the items of a sequence (`list`, `string`, `tuple`, `range`). It can also be used to iterate over unordered sequences like `set` and `dict`. + +This process can be demonstrated using the below flowchart: + +![Iteration in Flow of Code Python](images/0804a.png) + +Let us go through some code examples to demonstrate how `for` statement can be used to iterate over sequences. + +#br + +## List Iteration + +### Code + +``` python +cars = ["Hyundai", "Honda", + "Ford", "Toyota", + "BMW", "Volkswagen"] +for make in cars: + print(make) +``` + +### Output + +``` +Hyundai +Honda +Ford +Toyota +BMW +Volkswagen +``` + +#br + +## Tuple Iteration + +### Code + +``` python +cars = ("Hyundai", "Honda", + "Ford", "Toyota", + "BMW", "Volkswagen") +for make in cars: + print(make) +``` + +### Output + +``` +Hyundai +Honda +Ford +Toyota +BMW +Volkswagen +``` + +#br + +## String Iteration + +### Code + +``` python +name = "python" +for char in name: + print(char) +``` + +### Output + +``` +p +y +t +h +o +n +``` + +#br + +## Range Iteration + +The `range` type represents an immutable sequence of numbers that is usually used in for loops for looping a certain number of times. `range` object always take the same (small) amount of memory, no matter the size of the range it represents, which is an advantage over a regular `list` or `tuple`. + +**Syntax**: `range(stop)` or +`range(start, stop[, step])` + +``` python +>>> range(10) +range(0, 10) +>>> list(range(10)) +[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] +>>> list(range(1, 10, 2)) +[1, 3, 5, 7, 9] +``` + +`range()` function is widely used in a `for` statement to control the number of iterations and provide the index value (`i`) of each iteration. + +### Example #1 + +Print multiples of 5 starting from 0 to 20. + +#### Code + +``` python +for i in range(5): + print(i*5) +``` + +#### Output + +``` +0 +5 +10 +15 +20 +``` + +#br + +### Example #2 + +Print all integers from 2 to 5 including the boundary values. + +#### Code + +``` python +for i in range(2, 6): + print(i) +``` + +#### Output + +``` +2 +3 +4 +5 +``` + +#br + +### Example #3 + +Print all odd numbers between 2 and 10. + +#### Code + +``` python +for i in range(3, 10, 2): + print(i) +``` + +or + +``` python +for i in range(2, 10): + if i % 2 != 0: + print(i) +``` + +#### Output + +``` +3 +5 +7 +9 +``` + +#br + +### Example #4 + +Print the index of all occurrences of `o` in `python programming`. + +#### Code + +``` python +s = "python programming" +for i in range(len(s)): + if s[i] == "o": + print(i) +``` + +#### Output + +``` +4 +9 +``` + +#br + +## Exercises + +Let us go through some programming problems which utilize the `for` iteration statement. + +#br + +### Compound Interest + +Write a program to calculate the total compound interest payable for given principal, interest rate (compounded annually) and total time (in years). + +#### Code + +``` python +prin = float(input("Enter the principal amount: ")) +rate = float(input("Enter the annual interest rate: ")) +time = int(input("Enter the loan duration (in years): ")) + +amt = prin +for n in range(time): + amt += rate*amt/100 + +print("Total interest payable:", amt - prin) +``` + +#### Output + +``` +Enter the principal amount: 500000 +Enter the annual interest rate: 5 +Enter the loan duration (in years): 3 +Total interest payable: 78812.5 +``` + +#br + +### Factorial + +The factorial of a positive integer `n`, denoted by `n!`, is the product of all positive integers less than or equal to `n`. +`n! = n×(n-1)×(n-2)...3×2×1` +Write a program to calculate `n!` for a given `n` (assume `n` is greater than `0`). + +#### Code + +``` python +n = int(input("Enter n: ")) + +factorial = 1 +for i in range(1, n+1): + factorial *= i + +print("n! :", factorial) +``` + +#### Output + +``` +Enter n: 6 +n! : 720 +``` +# Iteration: while + +`while` statement repeatedly executes a code block as long as the test condition is satisfied. + +Usually there is a statement at the end of the code block which updates the value of the variable being used in the test expression, so the the loop does not execute infinitely. + +A flowchart of the process is provided below: + +![while loop Iteration in Flow of Code](images/0805a.png) + +For example, let us traverse a list and print the position(index) and value of each element until we reach the end of the list. + +#### Code + +``` python +cars = ["Hyundai", "Honda", + "Ford", "Toyota", + "BMW", "Volkswagen"] +i = 0 +while i 0: + amt += rate*amt/100 + time = time - 1 + +print("Total interest payable:", amt - prin) +``` + +#### Output + +``` +Enter the principal amount: 500000 +Enter the annual interest rate: 5 +Enter the loan duration (in years): 3 +Total interest payable: 78812.5 +``` + +#br + +### Factorial + +The factorial of a positive integer `n`, denoted by `n!`, is the product of all positive integers less than or equal to `n`. +`n! = n×(n-1)×(n-2)...3×2×1` +Write a program to calculate `n!` for a given `n` (assume `n` is greater than `0`). + +#### Code + +``` python +n = int(input("Enter n: ")) + +factorial = 1 +while n > 0: + factorial *= n + n = n - 1 + +print("n! :", factorial) +``` + +#### Output + +``` +Enter n: 6 +n! : 720 +``` +# Jump Statements + +Jump statements are used to (abruptly) alter the flow of execution. + +Some of the jump statements available in Python are: + +## pass + +A `pass` statement acts as a placeholder and performs null (no) operation. + +Various reasons for using the keyword `pass` are provided below: + +### 1. Syntactical Requirement + +Using `pass` becomes a syntactical requirement for cases where the Python interpreter can raise a `SyntaxError` due to missing statements. + +The below code will execute successfully without any operation in the loop + +``` python +for i in range(6): + pass +``` + +whereas without `pass` + +``` python +for i in range(6): +``` + +will throw the following `SyntaxError` + +``` +File "", line 1 + for i in range(6): + ^ +SyntaxError: unexpected EOF while parsing +``` + +Similarly, inside an `if` + +``` python +if 2 < 3: + pass +``` + +whereas without `pass` + +``` python +if 2 < 3: +``` + +will throw the following `SyntaxError` + +``` +File "", line 1 + if 2 < 3: + ^ +SyntaxError: unexpected EOF while parsing +``` + +#br + +### 2. Skipping Code Execution + +`pass` can be used to skip code execution for certain cases. + +For example, + +#### Code + +``` python +l = [2, 3, 4, 5, 6] +for i in l: + if i%3 == 0: + pass + else: + print(i, "is not divisible by 3") +``` + +#### Output + +``` +2 is not divisible by 3 +4 is not divisible by 3 +5 is not divisible by 3 +``` + +#br + +### Placeholders + +`pass` can be used to create valid empty functions and classes as placeholders which can be modified in the future versions of code. + +``` python +def emptyFunction(): + pass + +class EmptyClass: + pass +``` + +#br + +## break + +The `break` statement is used to terminate the execution of immediately enclosing `for` or `while` statement. + +The below code will terminate the `for` loop when `i` is equal to `4` + +``` python +for i in range(10): + print(i) + if i == 4: + break +``` + +``` +0 +1 +2 +3 +4 +``` + +In a while statement, + +``` python +i =0 +while i <10: + print(i) + if i == 4: + break + i+=1 +``` + +`break` will terminate the `while` loop when `i` is equal to `4` + +``` +0 +1 +2 +3 +4 +``` + +#br + +## continue + +`continue` statement is used to skip the execution of successive statements and start the next iteration. + +The below code will skip all candidates for an interview who have less than 4 years of work experience. + +``` python +people = [{"name": "ABC", "experience": 6}, + {"name": "EFG", "experience": 2}, + {"name": "JKL", "experience": 5}, + {"name": "XYZ", "experience": 3},] +for candidate in people: + if candidate["experience"]<4: + continue + print(candidate["name"], "is selected for interview") +``` + +Output: + +``` +ABC is selected for interview +JKL is selected for interview +``` +# Nested Loops + +When a loop is present inside another loop, it is known as a nested loop. + +For each iteration of the outer loop, the inner loop undergoes complete iteration. Thus, if the outer loop has to undergo `n` iterations and the inner loop has to undergo `m` iterations, the code block inside the inner loop executes `n x m` times. + +Let us go through a nested loop example: + +## Factorial + +Write a program to print the factorial of all numbers in the range `1` to `10` (inclusive). + +#### Code + +``` python +for n in range(1, 11): + factorial = 1 + for i in range(1, n+1): + factorial *= i + print(n,"! =", factorial) +``` + +#### Output + +``` +1 ! = 1 +2 ! = 2 +3 ! = 6 +4 ! = 24 +5 ! = 120 +6 ! = 720 +7 ! = 5040 +8 ! = 40320 +9 ! = 362880 +10 ! = 3628800 +``` + +#br + +## Nested Loop - break + +A `break` statement inside the inner loop terminates only the inner loop whereas the outer loop is not affected. + +To develop a better understanding, let us write a program to find all prime numbers between 2 and 40. + +#### Code + +``` python +for n in range(2, 40): + i = 2 + while i < n/2: + if n%i == 0: + break + i+=1 + if i>n/2: + print(n,"is prime") +``` + +#### Output + +``` +2 is prime +3 is prime +5 is prime +7 is prime +11 is prime +13 is prime +17 is prime +19 is prime +23 is prime +29 is prime +31 is prime +37 is prime +``` +# Creating a String + +A String (`str`) is an **immutable** sequence of Unicode characters which is used to handle textual data in Python. + +They can be specified by enclosing within: + +- Single quotes: `'embedded "double" quotes are allowed'` +- Double quotes: `"embedded 'single' quotes are allowed"` +- Triple quotes: `'''Three single quotes'''`, `"""Three double quotes"""`. + +Triple quoted strings can also span multiple lines. + +Some examples are provided below: + +``` python +s = "I am a String" + +s1 = """A +multiline +String""" + +s2 = '''Also a +multiline +String''' +``` + +#br + +## Escape Characters + +The backslash (`\`) character can be used in a string to escape characters that otherwise have a special meaning, such as newline, linefeed, or the quote character. + +| Escape Sequence | Meaning | +|--|--| +| `\\` | Backslash (`\`) | +| `\'` | Single quote (`'`) | +| `\"` | Double quote (`"`) | +| `\a` | ASCII Bell (BEL) | +| `\b` | ASCII Backspace (BS) | +| `\f` | ASCII Formfeed (FF) | +| `\n` | ASCII Linefeed (LF) | +| `\r` | ASCII Carriage Return (CR) | +| `\t` | ASCII Horizontal Tab (TAB) | +| `\v` | ASCII Vertical Tab (VT) | + +Although `\'` and `\"` can be used to specify quote characters, Python allows embedding double quotes inside a single-quoted string (`'My name is "Python".'`) and single quotes inside a double-quoted string (`"Python's World"`). + +#br + +## Unicode Support + +Python string objects support Unicode characters. + +A unicode character can be specified as `\u` followed by the 4 letter unicode (`\uXXXX`). + +``` python +>>> print("E = mc\u00B2") +E = mc² +``` + +In the above example, `\u00B2` is the unicode character which represents the 'SUPERSCRIPT TWO'. + +#br + +## Other Types to String + +In case you want to create a string object from other data types, just use the built-in `str()` function as follows: + +``` python +>>> str(9) +'9' + +>>> str(10.0) +'10.0' +``` +# Accessing Characters + +Python strings are "immutable", i.e., the state (value) of the objects cannot be modified after they are created. + +Using the standard `[ ]` syntax and zero-based indexing, characters can be accessed in a string. + +If `s = "hello"`, + +- `s[0]` will result in `h` +- `s[2]` will result in `l` +- `s[5]` will result in `IndexError: string index out of range` as the length of string is `5` (index `0` to `4`) +- `s[2] = 'p'` will result in `TypeError: 'str' object does not support item assignment` as `s` is immutable + +Python also supports negative indexing, i.e., you can access the values of a string from right to left. + +Index of `-1` denotes the last character of the string, `-2` is the second last character and so forth. + +If `s = "hello"`, + +- `s[-1]` will result in `o` +- `s[-4]` will result in `e` +- `s[-6]` will result in `IndexError: string index out of range` as the length of string is `5` (negative index `-1` to `-5`) + +## Length of String + +The built-in function `len()` returns the length of a string which is useful during string traversal or other string operations. + +``` python +>>> len("hello") +5 + +>>> s = "sample text" +>>> len(s) +11 + +>>> p = "python" +>>> l = len(p) +>>> p[l-1] +'n' +``` +# String Operations + +We can perform various operations on a string (sequence of characters) such as slicing, membership, concatenation and repetition. + +#br + +## Slicing + +In Python, a character in a string can be easily accessed using its index. + +``` python +>>> s = "Hello" +>>> s[1] +'e' +``` + +Python also provides a way to access a substring from a string. This substring is known as a **slice** and it can be obtained using the slice operator `[n:m]` which returns the part of the string from the start index (`n`) to the end index (`m`), including the first but excluding the last. + +``` python +>>> s = "Hello" +>>> s[1:3] +'el' +``` + +If the start index (`n`) is omitted, the default value of `n` is set as `0` which denotes the beginning of the string. If the end index (`m`) is omitted, the substring ends at the last character of the string. + +``` python +>>> s = "Hello" +>>> s[:3] +'Hel' +>>> s[3:] +'lo' +>>> s[:] +'Hello' +``` + +Negative indexing is also supported in the slice operator. + +``` python +>>> s = "Hello" +>>> s[-4:-2] +'el' +``` + +In the above example, `-4` is equivalent to `len(s) - 4 = 5 - 4 = 1` and `-2` is equivalent to `5 - 2 = 3`. Thus, `s[-4:-2]` is same as `s[1:3]`. + +The slice operator also allows the usage of a third index which is known as step as it allows a user to step over (skip) characters. + +``` python +>>> s = "Hello" +>>> s[0:5:2] +'Hlo' +``` + +In the above example, the substring begins at the start of the string, takes a step size of `2` skipping `e` and ends at the last character again skipping the 4th character `l`. + +#br + +## Membership + +`in` and `not in` operators can be used to determine whether a substring is present/not present in a string. + +``` python +>>> s = "Hello" +>>> "lo" in s +True +>>> "lp" not in s +True +``` + +#br + +## Concatenation + +The `+` operator can be used to join two strings. + +``` python +>>> s1 = "Hello" +>>> s2 = "Python" +>>> s1 + s2 +'HelloPython' +>>> s1 + "World" +'HelloWorld' +``` + +#br + +## Repetition + +The `*` operator repeats a string the number of times as specified by the integer operand. + +``` python +>>> s = "Hello" +>>> s*3 +'HelloHelloHello' +``` +# String Methods + +Apart from the built-in function `len()` which returns the length of the string, String objects have access to several specialized functions (methods) which are described below: + +## 1. Convert Case + +The following methods are useful in converting the case of the characters in a string: + +### i. lower() + +All cased characters are converted into lowercase. + +``` python +>>> "PYthon".lower() +'python' +``` + +### ii. upper() + +All cased characters are converted into uppercase. + +``` python +>>> "PYthon".upper() +'PYTHON' +``` + +### iii. swapcase() + +Uppercase characters are converted into lowercase and lowercase characters are converted into uppercase. + +``` python +>>> "PYthon".swapcase() +'pyTHON' +``` + +### iv. capitalize() + +First character is capitalized and rest all characters are lowercased. + +``` python +>>> "hello py".capitalize() +'Hello py' +``` + +### v. title() + +For each word present in the string, the first character is uppercased and the remaining characters are lowercased. + +``` python +>>> "hello python".title() +'Hello Python' +``` + +#br + +## 2. Check Characters + +The following methods are used to check the type of characters in a string. + +### i. isalpha() + +Returns `True` if all characters in the string are letters (`A-Z a-z`). + +``` python +>>> "HelloPython".isalpha() +True + +>>> "Hello Python".isalpha() +False # contains whitespace + +>>> "HelloPython2".isalpha() +False # contains digit +``` + +### ii. isdigit() + +Returns `True` if all characters in the string are digits. + +``` python +>>> "Hello24".isdigit() +False # contains alphabets +>>> "24".isdigit() +True +``` + +### iii. isalnum() + +Returns `True` if all characters in the string are alphanumeric (Alphabets or Numeric). + +``` python +>>> "02".isalnum() +True +>>> "HelloPython".isalnum() +True +>>> "Hello Python v2".isalnum() +False # contains whitespace +>>> "HelloPythonv2".isalnum() +True +``` + +### iv. isascii() + +Returns `True` if the string is empty or all characters in the string are ASCII. + +``` python +>>> "".isascii() +True +>>> "HelloPython".isascii() +True +>>> "Hello Py \u00B2".isascii() +False +>>> "पा से python".isascii() +False +``` + +### v. islower() + +Returns `True` if all characters are lowercase. + +``` python +>>> "hello".islower() +True +>>> "Hello".islower() +False +``` + +### vi. isupper() + +Returns `True` if all characters are uppercase. + +``` python +>>> "HELLO".isupper() +True +>>> "Hello".isupper() +False +``` + +### vii. isspace() + +Returns `True` if there are only whitespace characters in the string. Some popular whitespace characters are ` ` (space), `\t` (tab), `\n` (newline), `\r` (carriage return), `\f` (form feed) and `\v` (vertical tab). + +``` python +>>> " ".isspace() +True +``` + +### viii. istitle() + +Returns `True` if the string is title-cased, i.e., the first character of every word in the string is uppercased and the remaining characters are lowercased. + +``` python +>>> "Hello World".istitle() +True +>>> "Hello world".istitle() +False +>>> "hello world".istitle() +False +``` + +#br + +## 3. Split Methods + +Split methods help in splitting/partitioning a string. + +### i. partition() + +`partition(sep)` method splits the string when the separator (`sep`) is encountered for the first time, and returns a tuple with three items `(string before separator, separator, string after separator)`. + +``` python +>>> "Hi|Ed|Punk".partition('|') +('Hi', '|', 'Ed|Punk') +``` + +### ii. split() + +`split(sep=None, maxsplit=-1)` method splits a string into a list based on a string separator (`sep`). + +If `sep` is not specified, it defaults to `None`, where whitespace is regarded as separator, and the string is stripped of all leading and trailing whitespaces after which it is split into words contained in the string. + +``` python +>>> "Hi|Ed|Punk".split('|') +['Hi', 'Ed', 'Punk'] +>>> "Hi Ed Punk".split() +['Hi', 'Ed', 'Punk'] +>>> " Hi Ed Punk ".split() +['Hi', 'Ed', 'Punk'] +``` + +If `maxsplit` is provided, at most `maxsplit` number of splits are performed and the list will contain a maximum of `maxsplit+1` elements. + +`maxsplit` when not specified defaults to `-1`, which implies that there is no limit on the number of splits. + +``` python +>>> "Hi|Ed|Punk|v2".split('|', 2) +['Hi', 'Ed', 'Punk|v2'] +``` + +#br + +## 4. Strip Methods + +Strip methods are useful in removing leading and/or trailing characters in a string. + +They accept an optional argument `chars` which specifies the set of characters which have to be removed. + +If no arguments are provided then `chars` defaults to ASCII whitespace and the method removes all leading and/or trailing spaces from the string. + +### i. lstrip() + +All leading (on the left) characters are removed from the string. + +``` python +>>> " Hello|World ".lstrip() +'Hello|World ' +>>> "www.edpunk.cc".lstrip('w.') +'edpunk.cc' +``` + +### ii. rstrip() + +All trailing (on the right) characters are removed from the string. + +``` python +>>> " Hello|World ".rstrip() +' Hello|World' +>>> "www.edpunk.cc".rstrip('.c') +'www.edpunk' +``` + +### iii. strip() + +All leading and trailing characters are removed from the string. + +``` python +>>> " Hello|World ".strip() +'Hello|World' +>>> "www.edpunk.cc".strip('cw.') +'edpunk' +``` + +#br + +## 5. Check Prefix/Suffix + +`startswith()` and `endswith()` methods are used check whether a string starts or ends with the provided substring (or a tuple of substrings). + +``` python +>>> "Hello Py".startswith("He") +True +>>> "Hello Py".startswith(("He","P")) +True +>>> "Py Hello".startswith(("He","P")) +True +>>> "Hello Py".endswith("y") +True +>>> "Hello Py".endswith(("p","y")) +True +>>> "Py Hello".endswith(("o","n")) +True +``` + +#br + +## 6. Search/Replace Methods + +The following string methods are useful for locating substring in a string. + +### i. count() + +`count(sub[, start[, end]])` returns the number of non-overlapping occurrences of a substring `sub` in the range `[start, end]`. + +`start` and `end` are optional parameters and they default to `0` and `len(string)` respectively. + +``` python +>>> s = "she sells sea shells" +>>> s.count("she") +2 +>>> s.count("she", 5) +1 +>>> s.count("she", 5, 10) +0 +>>> s.count("she", 5, 17) +1 +``` + +It has to be noted that the method counts non-overlapping occurrences, so it does not start a new matching process until the current substring matching is complete. + +``` python +>>> s = "valhala alala" +>>> s.count("al") +4 +>>> s.count("ala") +2 +``` + +In the above example, `ala` is counted twice as the first occurence is in `valh"ala"` and the next occurance is in `"ala"la`. Although `ala` can be located again in `al"ala"`, it overlaps with the occurance `"ala"la`, hence it is not counted. + +### ii. find() + +`find(sub[, start[, end]])` returns the lowest index in the string where substring `sub` is located in the range `[start, end]`. + +`start` and `end` are optional parameters and they default to `0` and `len(string)` respectively. + +The method returns `-1` in case the substring is not present. + +``` python +>>> s = "she sells sea shells" +>>> s.find("she") +0 +>>> s.find("she", 5) +14 +>>> s.find("see") +-1 +>>> s.find("she", 5, 10) +-1 +>>> s.find("she", 5, 17) +14 +``` + +### iii. rfind() + +`rfind(sub[, start[, end]])` returns the highest index in the string where substring `sub` is located in the range `[start, end]`. + +`start` and `end` are optional parameters and they default to `0` and `len(string)` respectively. + +The method returns `-1` in case the substring is not present. + +``` python +>>> s = "she sells sea shells" +>>> s.rfind("she") +14 +>>> s.rfind("she", 0, 12) +0 +>>> s.rfind("see") +-1 +>>> s.rfind("she", 5) +14 +``` + +### iv. index() + +`index(sub[, start[, end]])` is similar to `find(sub[, start[, end]])`, but instead of returning `-1` it raises `ValueError` when the substring is not found. + +``` python +>>> s = "she sells sea shells" +>>> s.index("she") +0 +>>> s.index("she", 5) +14 +>>> s.index("see") +Traceback (most recent call last): + File "", line 1, + in +ValueError: substring not found +>>> s.index("she", 5, 10) +Traceback (most recent call last): + File "", line 1, + in +ValueError: substring not found +>>> s.index("she", 5, 17) +14 +``` + +### v. rindex() + +`s.rindex(sub[, start[, end]])` is similar to `rfind(sub[, start[, end]])`, but instead of returning `-1` it raises `ValueError` when the substring is not found. + +``` python +>>> s = "she sells sea shells" +>>> s.rindex("she") +14 +>>> s.rindex("she", 0, 12) +0 +>>> s.rindex("see") +Traceback (most recent call last): + File "", line 1, + in +ValueError: substring not found +>>> s.rindex("she", 5) +14 +``` + +### vi. replace() + +`replace(oldsub, newsub[, count])` returns a copy of the string with all occurrences of `oldsub` substring replaced by `newsub`. + +`count` is an optional parameter which when provided, only replaces the first `count` occurrences from the string. + +``` python +>>> s = "Oh Python! Oh" +>>> s.replace("Oh", "Hi") +'Hi Python! Hi' +>>> s.replace("Oh", "Hi", 1) +'Hi Python! Oh' +``` +# Traversing a String + +`for` and `while` statements are useful for traversing a string. + +## for + +As a string is a sequence of characters, the `for` statement can be used to iterate over a string as shown below. + +#### Code + +``` python +name = "python" +for char in name: + print(char) +``` + +#### Output + +``` +p +y +t +h +o +n +``` + +## while + +A `while` statement can be used to traverse a string by iterating on the value of index till the last character index. + +#### Code + +``` python +name = "python" +i = 0 +while i < len(name): + print(name[i]) + i += 1 +``` + +#### Output + +``` +p +y +t +h +o +n +``` +# Creating a List + +The most common and widely used collections in Python are **lists** which store an ordered group of objects (of any datatype) which might have some logical relation. This marks a considerable difference from arrays (in traditional languages) and makes Python an ideal language for handling real-life data which is not type-bound. + +Let us create a list of attributes of a particular vehicle available for sale in a car dealership: + +``` python +>>> l = ["BMW", "Z4", 2019, +... 4, "Red", True] +``` + +In this list: + +- `"BMW"` is the make of the vehicle, +- `"Z4"` is the model of the vehicle, +- `2019` is the year when the vehicle was manufactured, +- `4` represents the number of wheels, +- `"Red"` is the color of the vehicle, and +- `True` tells us that the vehicle up for sale is brand new. + +This method of creating a list from a collection of literals is known as **list display**. + +Notice, how this list contains items of multiple data types - `str`, `int` and `bool`. + +## list() + +Apart from the list display shown above, the built-in `list()` function can also be used to create new lists. + +If no arguments are provided to the `list()` function, an empty list is created. + +``` python +>>> l = list() +>>> l +[] +``` + +If a string, tuple or set is passed as an argument, `list()` functions converts them into a list. + +``` python +>>> l = list("abcd") +>>> l +['a', 'b', 'c', 'd'] +>>> l = list({1, 2, 3}) +>>> l +[1, 2, 3] +>>> l = list((1, 2, 3, 4)) +>>> l +[1, 2, 3, 4] +``` +# Accessing Items + +Lists use zero-based indexing, where 0 is the index of the first element and `len(list) - 1` is the index of the last element. + +For example, + +``` python +>>> l = ["BMW", "Z4", 2019, +... 4, "Red", True] +>>> l[0] +'BMW' +>>> l[2] +2019 +``` + +## Length of List + +The built-in `len()` function can be used to return the length of the list. + +``` python +>>> l = ["BMW", "Z4", 2019, +... 4, "Red", True] +>>> len(l) +6 +``` + +## Negative Indexing + +Just like `str`, sequence types like `list` support negative indexing, i.e., you can access the values of list from the end. + +Index of `-1` denotes the last item in the list, `-2` the second last item and so forth. + +``` python +>>> l = ["BMW", "Z4", 2019, +... 4, "Red", True] +>>> l[-1] +True +>>> l[-3] +4 +``` +# Modifying an Item + +As lists are mutable, the assignment operator can be used to modify or replace a single item in the list at a given index. + +``` python +>>> l = ["BMW", "Z4", "Red"] +>>> l[2] = "Black" +>>> l +['BMW', 'Z4', 'Black'] +``` +# Removing an Item + +`del` statement can be used to delete an item at a given index of a list. + +``` python +>>> l = ["BMW", "Z4", "Red"] +>>> del l[1] +>>> l +['BMW', 'Red'] +``` +# List Operations + +We can perform various operations on a list (collection of items) such as membership, concatenation, repetition and slicing. + +## Membership + +`in` and `not in` can be used to detect the membership of an item in a list. + +``` python +>>> l = ["BMW", "Z4", "Red"] +>>> "Red" in l +True +>>> "Gold" in l +False +>>> "Gold" not in l +True +``` + +#br + +## Concatenation + +`+` operator can be used to join two lists to create a new list. + +``` python +>>> l = ["BMW", "Z4"] +>>> k = [2019, "Red"] +>>> l + k +['BMW', 'Z4', 2019, 'Red'] +``` + +`+=` operator joins two lists and assigns it to the target list. + +``` python +>>> l = ["BMW", "Z4"] +>>> l += [2019, "Red"] +>>> l +['BMW', 'Z4', 2019, 'Red'] +``` + +#br + +## Repetition + +The `*` operator repeats the items of a list the number of times as specified by the integer operand. + +``` python +>>> l = [1, 2] +>>> l*3 +[1, 2, 1, 2, 1, 2] +``` + +#br + +## Slicing + +A subset of list `l` can be obtained using the list slice notation given as `l[i:j]`, where the item at start index `i` is included, but the item at end index `j` is excluded. + +For example, the slice notation `[1:4]` refers to items from index `1` to index `3` (i.e. `4-1`). + +``` python +>>> l = ["BMW", "Z4", 2019, +... 4, "Red", True] +>>> l[1:4] +['Z4', 2019, 4] +``` + +The slice notation `l[i:j:k]` can also include a third number known as the stepper. Here, a list is sliced from start index `i` to end index (`j`) - 1 with a step of `k` items. + +``` python +>>> l = ["BMW", "Z4", 2019, +... 4, "Red", True] +>>> l[1:4:2] +['Z4', 4] +``` + +Slice notations also have some useful defaults. 0 is the default for the first number and size of the list is the default for the second number. + +``` python +>>> l = ["BMW", "Z4", 2019, +... 4, "Red", True] +>>> l[2:] +[2019, 4, 'Red', True] +>>> l[:4] +['BMW', 'Z4', 2019, 4] +``` + +Slice notation also supports negative indexing. + +``` python +>>> l = ["BMW", "Z4", 2019, +... 4, "Red", True] +>>> l[-4:] +[2019, 4, 'Red', True] +>>> l[:-2] +['BMW', 'Z4', 2019, 4] +>>> l[-4:-1] +[2019, 4, 'Red'] +``` + +Slice notation can be used to replace multiple items in a list. + +``` python +>>> l = ["BMW", "Z4", 2019, +... 4, "Red", True] +>>> l[:2] = ["Kia", "Sonet"] +>>> l +['Kia', 'Sonet', 2019, 4, 'Red', True] + +>>> l = ["BMW", "Z4", 2019, +... 4, "Red", True] +>>> l[1:5:2] = ["Sonet", 2] +>>> l +['BMW', 'Sonet', 2019, 2, 'Red', True] +``` + +Slice notation can also be used to delete multiple items in a list. + +``` python +>>> l = ["BMW", "Z4", 2019, +... 4, "Red", True] +>>> del l[:2] +>>> l +[2019, 4, 'Red', True] + +>>> l = ["BMW", "Z4", 2019, +... 4, "Red", True] +>>> del l[:5:2] +>>> l +['Z4', 4, True] +``` +# Traversing a List + +List Traversal is the process of visiting every item in a list, usually from the first item to the last item, and executing some instruction on the accessed item. + +Python provides 2 ways to traverse a list: + +## Direct Traversal + +As a list is an ordered collection of items, the `for` statement can be used to directly and sequentially access each item. + +#### Code + +``` python +l = ["BMW", "Z4", 2019, + 4, "Red", True] +for item in l: + print(item) +``` + +#### Output + +``` +BMW +Z4 +2019 +4 +Red +True +``` + +## Location or Index Based Traversal + +In location based or index based traversal the value of index starts at `0` and increments as long as it is lesser than the length of the list. + +This index value can be used to access the item at that index in a list using the index operator `[]`. + +`for` statement can be used to iterate over the index of the list using the `range()` and `len()` functions. + +#### Code + +``` python +l = ["BMW", "Z4", 2019, + 4, "Red", True] +for i in range(len(l)): + print(i, l[i]) +``` + +#### Output + +``` +0 BMW +1 Z4 +2 2019 +3 4 +4 Red +5 True +``` + +#br + +This method is also useful when you need to modify the items of a list (without altering the length of list) during traversal. + +For example, let us convert each item of the list into a string. + +#### Code + +``` python +l = ["BMW", "Z4", 2019, + 4, "Red", True] +for i in range(len(l)): + # modifying item value + l[i] = str(l[i]) +print(l) +``` + +#### Output + +``` +['BMW', 'Z4', '2019', '4', 'Red', 'True'] +``` + +#br + +A `while` statement can be used to traverse a list by iterating on the value of index till the last item index. + +#### Code + +``` python +l = ["BMW", "Z4", 2019, + 4, "Red", True] +i = 0 +while i < len(l): + print(l[i]) + i += 1 +``` + +#### Output + +``` +BMW +Z4 +2019 +4 +Red +True +``` +# List Methods & Functions + +## Simple Aggregations + +Built-in functions `max()`, `min()` and `sum()` are used to calculate the maximum, minimum and sum of items in a list, respectively. + +``` python +>>> l = [4, 8, 2, 1, 3] +>>> min(l) +1 +>>> max(l) +8 +>>> sum(l) +18 +``` + +#br + +## Adding Items + +`append()` method adds an item (passed as an argument) to the end of a list. + +``` python +>>> l = ["T", "C", 2, 4] +>>> l.append(2.5) +>>> l +['T', 'C', 2, 4, 2.5] +``` + +If the item has to be added at a particular index, `insert()` method can be used. + +``` python +>>> l = ["T", "C", 2, 4] +>>> l.insert(3, 2.5) +>>> l +['T', 'C', 2, 2.5, 4] +``` + +`extend()` method appends each item of the argument list at the end of the target list. + +``` python +>>> l = ["T", "C", 2, 4] +>>> l.extend([2.5, "SE"]) +>>> l +['T', 'C', 2, 4, 2.5, 'SE'] +``` + +#br + +## Locating Items + +An item `x` can be located in a list using the `index(x[, i[, j]])` method which returns the first occurrence of the item at or after index `i` and before index `j`. + +In case `i` and `j` are not specified they default to `i=0` and `j=len(l)`. + +``` python +>>> l = [34, 4, 6, 23, 4] +>>> l.index(4) +1 +>>> l.index(4, 3) +4 +>>> l.index(6, 1, 4) +2 +``` + +`count()` method can be used to count the occurrence(s) of an item in a list. + +``` python +>>> l = [34, 4, 6, 23] +>>> l.count(4) +1 +>>> l = ["it", "is", "it", "I"] +>>> l.count("it") +2 +``` + +#br + +## Removing Items + +`clear()` method removes all items from the list. + +``` python +>>> l = ["T", "C", 2, 4, "S"] +>>> l.clear() +>>> l +[] +``` + +`remove()` method removes the first occurrence of an item from the list. + +``` python +>>> l = ["Hi", "Ed", "Py", "Hi"] +>>> l.remove("Hi") +>>> l +['Ed', 'Py', 'Hi'] +``` + +If an index is provided, `pop()` method removes the item at that index, else the last item is removed from the list. + +``` python +>>> l = ["T", "C", 2, 4, "S"] +>>> item = l.pop() +>>> item +'S' +>>> l +['T', 'C', 2, 4] + +>>> l = ["T", "C", 2, 4, "S"] +>>> item = l.pop(2) +>>> item +2 +>>> l +['T', 'C', 4, 'S'] +``` + +#br + +## Reversing Items + +`reverse()` method can be used to reverse a list in-place. + +``` python +>>> l = ["T", "C", 2, 4, "S"] +>>> l.reverse() +>>> l +['S', 4, 2, 'C', 'T'] +``` + +If you do not wish to modify the existing list and create a new list with items in reverse order, use the built-in function `reversed()` nested in the built-in `list()`. + +``` python +>>> l = ["T", "C", 2, 4, "S"] +>>> new_l = list(reversed(l)) +>>> new_l +['S', 4, 2, 'C', 'T'] +>>> l +['T', 'C', 2, 4, 'S'] +``` + +#br + +## Sorting Items + +Python lists have a built-in `sort()` method which sorts the items in-place using `<` comparisons between items. + +The method also accepts 2 keyworded arguments: +- `key` is used to specify a function which is called on each list element prior to making the comparisons. +- `reverse` is a boolean which specifies whether the list is to be sorted in descending order. + +``` python +>>> l = [34, 4, 6, 23] +>>> l.sort() +>>> l +[4, 6, 23, 34] + +>>> l = [34, 4, 6, 23] +>>> l.sort(reverse=True) +>>> l +[34, 23, 6, 4] + +>>> l = ["Oh", "Hi", "Py", "ed"] +>>> l.sort() +>>> l +['Hi', 'Oh', 'Py', 'ed'] + +>>> l = ["Oh", "Hi", "Py", "ed"] +# lowercase the words before sorting +>>> l.sort(key=str.lower) +>>> l +['ed', 'Hi', 'Oh', 'Py'] +``` + +If you do not wish to modify the existing list and create a new list with sorted items in, use the built-in `sorted()` function which returns a new sorted list. + +``` python +>>> l = [34, 4, 6, 23] +>>> new_l = sorted(l) +>>> new_l +[4, 6, 23, 34] +``` +# Nested List + +A list of lists is also known as a nested list. + +Previously, we learnt how to create a list of attributes of a particular vehicle available for sale in a dealership. + +Let us now create a nested list containing some details of vehicles available for sale. + +``` python +# Make Model Year No_of_wheels +l = [["Kia", "Sonnet", 2019, 4], + ["Toyota", "Camry", 2018, 4], + ["BMW", "Z4", 2015, 4], + ["BMW", "S1000", 2016, 2], + ["KTM", "390", 2019, 2], + ] +``` + +Thus, nested list is useful in representing a dataset where each item is a list (datum) containing the attributes of an observation. + +`l[i][j]` is the syntax to fetch the `j+1th` item of the list at index `i` of the nested list `l`. + +``` python +>>> l[2][1] +'Z4' +``` +# Copying a List + +In Python, we can create an object (data) and bind its reference to a variable using the assignment operator (`=`). + +As multiple collections or items in collections can point to the same mutable object, a copy is required so one can change one copy without changing the other. + +Let us take an example: + +``` python +>>> old_l = [1, 2, 3] + +# Copying old list into a new list +>>> new_l = old_l + +# Checking if both lists are +# pointing to the same object +>>> id(new_l)==id(old_l) +True + +# Adding element to new list +>>> new_l.append(4) +>>> new_l +[1, 2, 3, 4] +>>> old_l +[1, 2, 3, 4] +``` + +It can be seen how the assignment operator **does not create a new copy** of the list. + +The `copy()` method can be used to create a new `list` containing the items of the original list. + +``` python +>>> old_l = [1, 2, 3] + +# Copying old list into a new list +>>> new_l = old_l.copy() + +# Checking if both lists are +# pointing to the same object +>>> id(new_l)==id(old_l) +False + +# Adding element to new list +>>> new_l.append(4) +>>> new_l +[1, 2, 3, 4] +>>> old_l +[1, 2, 3] +``` + +Assigning a slice of the entire list (`[:]`) is also equivalent to creating a new copy. + +``` python +>>> old_l = [1, 2, 3] + +# Copying old list into a new list +# using slice notation +>>> new_l = old_l[:] + +# Checking if both lists are +# pointing to the same object +>>> id(new_l)==id(old_l) +False + +# Adding element to new list +>>> new_l.append(4) +>>> new_l +[1, 2, 3, 4] +>>> old_l +[1, 2, 3] +``` +# List Comprehension + +A short and succinct way of creating a new list by transforming an existing list is via list comprehension. + +Also, due to the optimizations present in the Python interpreter, there are performance benefits of using list comprehension. + +## Member-wise Operation + +List comprehension can be used to make a new list where each element is the result of some operations applied to each member of another sequence or iterable. + +For example, to create a new list where each item is squared. + +``` python +>>> l = [2, 3, 4, 5, 6, 8] +>>> l2 = [i**2 for i in l] +>>> l2 +[4, 9, 16, 25, 36, 64] +``` + +## Filtering or Subsequence + +List comprehension can also be used to create a subsequence of those elements that satisfy a certain condition. + +For example, to create a new list where each item is divisible by 2. + +``` python +>>> l = [2, 3, 4, 5, 6, 8] +>>> l2 = [i for i in l if i%2==0] +>>> l2 +[2, 4, 6, 8] +``` +# Sample Programs + +## Min, Max and Mean + +Write a program to find the minimum, maximum and mean of values stored in a list input by user. + +### Without Using Built-in Functions + +#### Code + +``` python +#create an empty list +l = [] + +n = int(input("Enter length of list: ")) +for i in range(n): + val = float(input("Enter item: ")) + #append marks in the list + l.append(val) + +# Set first item as the default min value +minval = l[0] +# Set first item as the default max value +maxval = l[0] +# Store sum of items +s = 0 +for val in l: + # check if item value is smaller than current min val + if val < minval: + minval = val + # check if item value is greater than current max val + if val > maxval: + maxval = val + s += val + +print("Minimum :", minval) +print("Maximum :", maxval) +print("Mean :", s/n) +``` + +#### Output + +``` +Enter length of list: 5 +Enter item: 3 +Enter item: 2 +Enter item: 6 +Enter item: 9 +Enter item: 1 +Minimum : 1.0 +Maximum : 9.0 +Mean : 4.2 +``` + +### Using Built-in Functions + +#### Code + +``` python +#create an empty list +l = [] + +n = int(input("Enter length of list: ")) +for i in range(n): + val = float(input("Enter item: ")) + #append marks in the list + l.append(val) + +print("Minimum :", min(l)) +print("Maximum :", max(l)) +print("Mean :", sum(l)/n) +``` + +#### Output + +``` +Enter length of list: 5 +Enter item: 3 +Enter item: 2 +Enter item: 6 +Enter item: 9 +Enter item: 1 +Minimum : 1.0 +Maximum : 9.0 +Mean : 4.2 +``` + +#br + +## Linear Search + +Write a program to enter a list and then check if the number entered by a user is present in that list. + +#### Code + +``` python +#create an empty list +l = [] + +n = int(input("Enter length of list: ")) +for i in range(n): + val = input("Enter item: ") + #append marks in the list + l.append(val) + +search = input("Enter search value: ") + +found = False +for i in range(n): + if l[i] == search: + found = True + break +if found: + print("Search value located at index", i) +else: + print("Search value not found") +``` + +#### Output + +``` +Enter length of list: 4 +Enter item: 2 +Enter item: 6 +Enter item: 3 +Enter item: 7 +Enter search value: 3 +Search value located at index 2 + +Enter length of list: 4 +Enter item: 2 +Enter item: 6 +Enter item: 3 +Enter item: 7 +Enter search value: 1 +Search value not found +``` + +#br + +## Frequency of Elements + +Write a program to enter a list and then print the frequency of elements present in that list. + +### Without Using Built-in Functions + +#### Code + +``` python +#create an empty list +l = [] + +n = int(input("Enter length of list: ")) +for i in range(n): + val = input("Enter item: ") + #append marks in the list + l.append(val) + +# Let us create two lists +# 1. to store unique items +items = [] +# 2. to store the count of unique items +counts = [] + +for val in l: + if val not in items: + items.append(val) + counts.append(1) + else: + for idx in range(len(items)): + if items[idx] == val: + counts[idx] += 1 + +print("Frequency of Elements") +for idx in range(len(items)): + print(items[idx], "-", counts[idx]) +``` + +#### Output + +``` +Enter length of list: 8 +Enter item: 2 +Enter item: 3 +Enter item: 3 +Enter item: 4 +Enter item: 2 +Enter item: 5 +Enter item: 6 +Enter item: 6 +Frequency of Elements +2 - 2 +3 - 2 +4 - 1 +5 - 1 +6 - 2 +``` + +### Using Built-in Functions + +#### Code + +``` python +l = [] + +n = int(input("Enter length of list: ")) +for i in range(n): + val = input("Enter item: ") + #append marks in the list + l.append(val) + +# List to store unique items +items = [] + +print("Frequency of Elements") +for val in l: + if val not in items: + items.append(val) + print(val, "-", l.count(val)) +``` + +#### Output + +``` +Enter length of list: 8 +Enter item: 2 +Enter item: 3 +Enter item: 3 +Enter item: 4 +Enter item: 2 +Enter item: 5 +Enter item: 6 +Enter item: 6 +Frequency of Elements +2 - 2 +3 - 2 +4 - 1 +5 - 1 +6 - 2 +``` +# Creating a Tuple + +Tuples are like lists, with a difference - they are immutable. This means that once initialized a user cannot modify its value, which makes it a useful feature to ensure the sanctity of data and guarantee that it is not being modified by the program. + +Tuples are declared using parentheses `( )`, with successive items separated by a comma `,`. + +``` python +>>> l = ("Hi", "Ed", "Punk") +>>> type(l) + +``` + +## tuple() + +Apart from the method shown above, the built-in `tuple()` function can also be used to create new tuples. + +If no arguments are provided to the `tuple()` function, an empty tuple is created. + +``` python +>>> t = tuple() +>>> t +() +``` + +If a string, tuple or set is passed as an argument, `tuple()` functions converts them into a tuple. + +``` python +>>> t = tuple("abcd") +>>> t +('a', 'b', 'c', 'd') +>>> t = tuple({1, 2, 3}) +>>> t +(1, 2, 3) +>>> t = tuple([1, 2, 3, 4]) +>>> t +(1, 2, 3, 4) +``` + +## Singleton + +In case a tuple has only 1 item, it is known as a singleton. + +It is a good practice to include a trailing comma to avoid the Python interpreter from treating it as a value inside regular parentheses as shown in the examples below. + +``` python +>>> regular_string = ("Hi") +>>> regular_string +'Hi' +>>> type(regular_string) + + +>>> regular_int = (1) +>>> regular_int +1 +>>> type(regular_int) + + +>>> str_tuple = ("Hi", ) +>>> type(str_tuple) + + +>>> int_tuple = (1, ) +>>> type(int_tuple) + +``` +# Accessing Items + +Tuples use zero-based indexing, where 0 is the index of the first element and `len(tuple) - 1` is the index of the last element. + +``` python +>>> t = ("BMW", "Z4", 2019, +... 4, "Red", True) +>>> t[0] +'BMW' +>>> t[2] +2019 +``` + +## Length of Tuple + +The built-in `len()` function can be used to return the length of the tuple. + +``` python +>>> t = ("BMW", "Z4", 2019, +... 4, "Red", True) +>>> len(t) +6 +``` + +## Negative Indexing + +Just like `list`, `tuple` supports negative indexing, i.e., you can access the values of tuple from the end. Index of -1 denotes the last item in the tuple, -2 is the second last item and so forth. + +``` python +>>> t = ("BMW", "Z4", 2019, +... 4, "Red", True) +>>> t[-1] +True +>>> t[-3] +4 +``` +# Tuples are Immutable + +Tuples are immutable, i.e., no modifications are permitted once it is created and any attempt to do so raises an error. + +``` python +>>> t = ("BMW", "Z4", 2019) +>>> t[1] = "Charger" +Traceback (most recent call last): + File "", line 1, in +TypeError: 'tuple' object does not support item assignment +``` +# Tuple Operations + +We can perform various operations on a tuple such as membership, concatenation, repetition and slicing. + +## Membership + +`in` and `not in` can be used to detect the membership of an item in a tuple. + +``` python +>>> t = ("BMW", "Z4", 2019, +... 4, "Red", True) +>>> "Red" in t +True +>>> "Gold" in t +False +>>> "Gold" not in t +True +``` + +#br + +## Concatenation + +`+` operator can be used to join two tuples to create a new tuple. + +``` python +>>> t = ("BMW", "Z4") +>>> u = (2019, "Red") +>>> t+u +('BMW', 'Z4', 2019, 'Red') +``` + +#br + +## Repetition + +The `*` operator creates a new tuple with items of a tuple repeated the number of times as specified by the integer operand. + +``` python +>>> t = (1, 2) +>>> t*3 +(1, 2, 1, 2, 1, 2) +``` + +#br + +## Tuple Slicing + +A subset of tuple `t` can be obtained using the tuple slice notation given as `t[i:j]`, where the item at index `i` is included, but the item at index `j` is excluded. + +For example, the slice notation `[1:4]` refers to items from index `1` to index `3` (i.e. `4-1`). + +``` python +>>> t = ("BMW", "Z4", 2019, +... 4, "Red", True) +>>> t[1:4] +('Z4', 2019, 4) +``` + +The slice notation `t[i:j:k]` can also include a third number known as the step. Here, a tuple is sliced from start index `i` to end index (`j`) - 1 with a step of `k` items. + +``` python +>>> t = ("BMW", "Z4", 2019, +... 4, "Red", True) +>>> t[1:4:2] +('Z4', 4) +``` + +Slice notations also have some useful defaults. + +`0` is the default for the first number and size of the tuple is the default for the second number. + +``` python +>>> t = ("BMW", "Z4", 2019, +... 4, "Red", True) +>>> t[2:] +(2019, 4, 'Red', True) +>>> t[:4] +('BMW', 'Z4', 2019, 4) +``` + +Slice notation also supports negative indexing. + +``` python +>>> t = ("BMW", "Z4", 2019, +... 4, "Red", True) +>>> t[-4:] +(2019, 4, 'Red', True) +>>> t[:-2] +('BMW', 'Z4', 2019, 4) +>>> t[-4:-1] +(2019, 4, 'Red') +``` +# Traversing a Tuple + +Tuple Traversal is the process of visiting every item in a tuple, usually from the first item to the last item, and executing some instruction on the accessed item. + +Python provides 2 ways to traverse a tuple: + +## Direct Traversal + +As a tuple is an ordered collection of items, the `for` statement can be used to directly and sequentially access each item. + +#### Code + +``` python +t = ("BMW", "Z4", 2019, + 4, "Red", True) +for item in t: + print(item) +``` + +#### Output + +``` +BMW +Z4 +2019 +4 +Red +True +``` + +#br + +## Location or Index Based Traversal + +In location based or index based traversal the value of index starts at `0` and increments as long as it is lesser than the length of the tuple. + +This index value can be used to access the item at that index in a tuple using the index operator `[]`. + +`for` statement can be used to iterate over the index of the tuple using the `range()` and `len()` functions. + +#### Code + +``` python +t = ("BMW", "Z4", 2019, + 4, "Red", True) +for i in range(len(t)): + print(t[i]) +``` + +#### Output + +``` +BMW +Z4 +2019 +4 +Red +True +``` + +#br + +A `while` statement can be used to traverse a tuple by iterating on the value of index. + +#### Code + +``` python +t = ("BMW", "Z4", 2019, + 4, "Red", True) +index = 0 +while index < len(t): + print(t[index]) + index += 1 +``` + +#### Output + +``` +BMW +Z4 +2019 +4 +Red +True +``` +# Tuple Methods & Functions + +`tuple` supports all the features available in a `list`, barring the methods/operations which try to modify it. + +## Simple Aggregations + +Built-in functions `max()`, `min()` and `sum()` can be used to calculate the maximum, minimum and sum of items in a tuple, respectively. + +``` python +>>> t = (4, 8, 2, 1, 3) +>>> min(t) +1 +>>> max(t) +8 +>>> sum(t) +18 +``` + +## Locating Items + +An item `x` can be located in a tuple using the `index(x[, i[, j]])` method which returns the first occurrence of the item at or after index `i` and before index `j`. In case `i` and `j` are not specified they default to `i=0` and `j=len(t)`. + +``` python +>>> t = (34, 4, 6, 23, 4) +>>> t.index(4) +1 +>>> t.index(4, 3) +4 +>>> t.index(6, 1, 4) +2 +``` + +`count()` method can be used to count the occurrence(s) of an item in a tuple. + +``` python +>>> t = (34, 4, 6, 23, 4) +>>> t.count(4) +2 +>>> t = ("it", "is", "it", "I") +>>> t.count("it") +2 +``` + +## Reversing Items + +To create a new tuple with items in reverse order, use the built-in function `reversed()` nested in the built-in `tuple()`. + +``` python +>>> t = ("T", "C", 2, 4, "S") +>>> new_t = tuple(reversed(t)) +>>> new_t +('S', 4, 2, 'C', 'T') +>>> t +('T', 'C', 2, 4, 'S') +``` + +## Sorting Items + +To create a new tuple with sorted items, use the built-in `sorted(x,[key, reverse])` function which returns a new sorted tuple. + +The method optionally accepts 2 keyword (named) arguments: +- `key` which is used to specify a function which is called on each tuple element prior to making the comparisons, and +- `reverse` is a boolean which specifies whether the tuple is to be sorted in descending order. + +``` python +>>> t = (34, 4, 6, 23, 9) +>>> tuple(sorted(t)) +(4, 6, 9, 23, 34) +>>> tuple(sorted(t, reverse=True)) +(34, 23, 9, 6, 4) + +>>> t = ("Oh", "Hi", "Py", "it") +>>> tuple(sorted(t)) +('Hi', 'Oh', 'Py', 'it') +# lowercase the words before sorting +>>> tuple(sorted(t, key=str.lower)) +('Hi', 'it', 'Oh', 'Py') +``` +# Nested Tuple + +A tuple of tuples is also known as a nested tuple. + +Let us create a nested tuple containing the details of all vehicles available for sale. + +``` python +# Make Model Year No_of_wheels +t = ( + ("Kia", "Sonnet", 2019, 4), + ("Toyota", "Camry", 2018, 4), + ("BMW", "Z4", 2015, 4), + ("BMW", "S1000", 2016, 2), + ("KTM", "390", 2019, 2), +) +``` + +`t[i][j]` is the syntax to fetch the `j+1 th` item of the tuple at index `i` of the nested tuple `t`. + +``` python +>>> t[2][1] +'Z4' +``` + +As compared to a nested list, a nested tuple is useful in representing a dataset (such as a table fetched from a database) where it is important to ensure the sanctity of data as the code cannot modify it because tuples are immutable.# Pitfalls of Extending a Tuple + +Just like lists, the `+=` operation works for a tuple and adds new item(s) to it. + +``` python +>>> t = ("Hi", "Ed", "Punk") +>>> t += (1, 2) +>>> t +('Hi', 'Ed', 'Punk', 1, 2) +``` + +But tuples are immutable right? +Then how are we able to modify it. + +## List + +To understand it better, let us revisit what happens when we apply `+=` operator on a list. + +``` python +>>> l = ["Hi", "Ed", "Punk"] +>>> id_l = id(l) +>>> l += [1, 2] +>>> l +['Hi', 'Ed', 'Punk', 1, 2] +>>> id(l) == id_l +True +``` + +In case of a list, the modified list `l` still points at the same object. + +## Tuple + +Now, let us add items to a tuple. + +``` python +>>> t = ("Hi", "Ed", "Punk") +>>> id_t = id(t) +>>> t += (1, 2) +>>> t +('Hi', 'Ed', 'Punk', 1, 2) +>>> id(t) == id_t +False +``` + +In case of a tuple, the modified tuple is actually a completely new tuple with contents of the original tuple and the extension. + +The original tuple is not modified as it is immutable. But, as `t` is no longer pointing to the original tuple, it is freed from memory. + +Thus, it is recommended that instead of `+=`, `append()` and `extend()` methods should be employed to add new items programatically as it will raise an error in case the code is trying to modify a tuple. + +``` python +>>> l = ["Hi", "Ed", "Punk"] +>>> l.extend([1, 2]) +>>> l +['Hi', 'Ed', 'Punk', 1, 2] + +>>> t = ("Hi", "Ed", "Punk") +>>> t.extend((1, 2)) +Traceback (most recent call last): + File "", line 1, in +AttributeError: 'tuple' object has no attribute 'extend' +``` +# What is a Dictionary? + +Python provides a mapping type collection which contains keys, and values corresponding to those keys. + +This collection is known as a `dictionary` (type `dict`) , where each key is unique and can be used to easily store or retrieve values (any data-type including `string`, `int`, `float`, `list`). + +Dictionaries are indexed by keys (any immutable type - numbers, string, tuple) as compared to lists which are indexed by a range of numbers. +# Creating a Dictionary + +An empty dictionary can be created using a pair of braces - `{}` or using the built-in function `dict()` which is also a constructor. + +``` python +>>> d = {} +>>> type(d) + + +>>> d = dict() +>>> d +{} +>>> type(d) + +``` + +To create a new dictionary with some initial values, one can use: + +## Key: Value Pairs + +A sequence of `key: value` pairs separated by commas in braces - `{}`. + +``` python +>>> d = {"yr": 20, "name": "Ed", +... 18: True} +>>> d +{'yr': 20, 'name': 'Ed', 18: True} +``` + +#br + +## Sequence of (key, value) Tuples + +A sequence of (key, value) tuples can be passed as an argument to the `dict()` function. + +``` python +>>> l = [("yr",20), ("name","Ed"), +... (18,True)] +>>> d = dict(l) +>>> d +{'yr': 20, 'name': 'Ed', 18: True} +``` + +#br + +## Keyword/Named Arguments + +Keys and values can be passed as keyword arguments to the `dict()` function. + +``` python +>>> d = dict(yr=20, name="Ed", +... is18=True) +>>> d +{'yr': 20, 'name': 'Ed', 'is18': True} +``` + +One of the limitations of this method is that the keys of the dictionary are only of type string and their names must be within the namespace of an identifier. + +#br + +## Key and Value Lists + +There might cases when there is a need to combine two lists where keys are in one list and the corresponding values are available in another list. + +The built-in `zip()` function is useful for combining two lists into tuple pairs. + +The zipped iterator can be passed as an argument to the `dict()` to create a new mapping collection. + +``` python +>>> m = ["yr", "name", 18] +>>> n = [20, "Ed", True] +>>> list(zip(m, n)) +[('yr', 20), ('name', 'Ed'), (18, True)] +>>> dict(zip(m, n)) +{'yr': 20, 'name': 'Ed', 18: True} +``` + +#br + +## Keys with Default Value + +`dict.fromkeys(iterable[, value])` can be used to create new dictionary with items of an `iterable` as keys with an optional value (default - `None`) corresponding to the keys. + +``` python +>>> l = ["yr", "name", 18] +>>> dict.fromkeys(l) +{'yr': None, 'name': None, 18: None} +>>> dict.fromkeys(l, 0) +{'yr': 0, 'name': 0, 18: 0} +``` +# Accessing Dictionary Items + +## Index Operator [] + +`d[x]` can be used to access the value corresponding to a key `x` in a dictionary `d`. + +``` python +>>> d = {"yr": 20, "name": "Ed", +... 18: True} +>>> d["yr"] +20 +``` + +#br + +## get() + +`get(key[, default])` method can also be used to fetch the value for a key if key is in the dictionary, else a `default` value is returned. + +If `default` is not provided, `None` is the default value returned. + +``` python +>>> d = {"yr": 20, "name": "Ed", +... 18: True} +>>> d.get("name") +'Ed' +>>> d.get("version") is None +True +>>> d.get("version", "1.0") +'1.0' +``` + +This is an elegant method of fetching a value from a dictionary and it should be used in real life software codes as it never raises a `KeyError`. +# Updating/Adding Items + +## Index Operator [] + +`d[x] = y` can be used to add the value `y` corresponding to a key `x` in a dictionary `d`. + +In case key `x` already exists, assignment updates or overwrites the value corresponding to it. + +``` python +>>> d = {"yr": 20, 18: True} +>>> d["name"] = 'Ed' +>>> d +{'yr': 20, 18: True, 'name': 'Ed'} + +>>> d["name"] = 'Py' +>>> d +{'yr': 20, 18: True, 'name': 'Py'} +``` + +#br + +## update() + +`update()` method can be used to add new items or update existing items in a `dict`. + +This method accepts the following: + +### 1. Dictionary + +``` python +>>> d = {"yr": 20, 18: True} +>>> d.update({"name": 'Ed'}) +>>> d +{'yr': 20, 18: True, 'name': 'Ed'} + +>>> d.update({"yr": 15, 18: False}) +>>> d +{'yr': 15, 18: False, 'name': 'Ed'} +``` + +#br + +### 2. Sequence of (key, value) pairs + +``` python +>>> d = {"yr": 20, 18: True} +>>> d.update([("name", 'Ed'), +... ('yr', 15)]) +>>> d +{'yr': 15, 18: True, 'name': 'Ed'} +``` + +#br + +### 3. Keyworded arguments + +``` python +>>> d = {"yr": 20, 18: True} +>>> d.update(name="Ed", yr=15) +>>> d +{'yr': 15, 18: True, 'name': 'Ed'} +``` + +#br + +## setdefault() + +`setdefault(key[, default])` method returns a value corresponding to a key. + +If the key is not present in the dictionary, it is inserted with the provided `default` value. + +If no default value is provided, the value is set as `None`. + +``` python +>>> d = {"yr": 20, 18: True} +>>> d.setdefault("name") +>>> d +{'yr': 20, 18: True, 'name': None} + +>>> d = {"yr": 20, 18: True} +>>> d.setdefault("name", "Ed") +'Ed' +>>> d +{'yr': 20, 18: True, 'name': 'Ed'} +``` +# Removing an Item + +## del + +`del` keyword can be used to remove a `key: value` pair. + +``` python +>>> d = {"yr": 20, "name": "Ed", +... 18: True} +>>> del d["name"] +>>> d +{'yr': 20, 18: True} +``` + +#br + +## clear() + +`clear()` method can be used to clear all values of a dictionary. + +``` python +>>> d = {"yr": 20, "name": "Ed", +... 18: True} +>>> d.clear() +>>> d +{} +``` + +#br + +## pop() + +`pop(key[, default])` method can be used to remove a `key: value` pair. + +In case the key is not present in the dictionary, the method returns the value of argument `default` provided by the user. + +``` python +>>> d = {"yr": 20, "name": "Ed", +... 18: True} +>>> d.pop("name") +'Ed' +>>> d +{'yr': 20, 18: True} + +>>> d.pop("name") +Traceback (most recent call last): + File "", line 1, in +KeyError: 'name' + +>>> d.pop("name", "Punk") +'Punk' +``` + +#br + +## popitem() + +`popitem()` can be used to destructively iterate over a dictionary removing and returning a `(key, value)` pair in LIFO (Last Item First Out) order. + +``` python +>>> d = {"yr": 20, "name": "Ed", +... 18: True} +>>> d.popitem() +(18, True) +>>> d.popitem() +('name', 'Ed') +>>> d.update({"name": "py"}) +>>> d +{'yr': 20, 'name': 'py'} +>>> d.popitem() +('name', 'py') +>>> d.popitem() +('yr', 20) +>>> d +{} +``` +# Dictionary Operations + +## Membership + +`in` keyword can be used to test the presence of a `key` in a dictionary. + +``` python +>>> d = {"yr": 20, 18: True} +>>> "yr" in d +True +``` + +Similarly, `not in` can be used to determine the absence of a `key`. + +``` python +>>> "name" not in d +True +``` + +#br + +## Union + +The `|` (union) operator can be used to merge two dictionaries. + +``` python +>>> d = {"yr": 20, 18: True} +>>> n = {"name": "Ed"} +>>> d | n +{'yr': 20, 18: True, 'name': 'Ed'} +``` + +In case of common keys between the two operands (dictionaries), the values of the operand on the right takes priority. + +``` python +>>> d = {"yr": 20, 18: True} +>>> n = {"yr": 15, "name": "Ed"} +>>> d | n +{'yr': 15, 18: True, 'name': 'Ed'} +``` + +In the above example, both `d` and `n` shared a common key `yr`. The value corresponding to `yr` in `n` gets priority. +# Traversing a Dictionary + +Compared to position based indexing of `list` or `tuple`, dictionaries are indexed based on the key. + +## Direct Traversal + +`for` loop can be used to directly iterate over the keys of a `dict`. + +``` python +d = {"yr": 20, "name": "Ed", + 18: True} +for key in d: + print(key,":", d[key]) +``` + +#### Output + +``` +yr : 20 +name : Ed +18 : True +``` + +#br + +## Traversing Using Dictionary Methods + +Dictionary methods `items()`, `keys()` and `values()` can be used to fetch the items, keys and values in a dictionary, respectively. + +``` python +>>> d = {"yr": 20, "name": "Ed", +... 18: True} +>>> d.keys() +dict_keys(['yr', 'name', 18]) +>>> d.values() +dict_values([20, 'Ed', True]) +>>> d.items() +dict_items([('yr', 20), ('name', 'Ed'), (18, True)]) +``` + +`dict_keys`, `dict_values` and `dict_items` are iterables that can be used in a `for` statement to traverse the dictionary. + +#### Code + +``` python +d = {"yr": 20, "name": "Ed", + 18: True} +for key in d.keys(): + print(key) +``` + +#### Output + +``` +yr +name +18 +``` + +#br + +#### Code + +``` python +d = {"yr": 20, "name": "Ed", + 18: True} +for value in d.values(): + print(value) +``` + +#### Output + +``` +20 +Ed +True +``` + +#br + +#### Code + +``` python +d = {"yr": 20, "name": "Ed", + 18: True} +for key, value in d.items(): + print(key,":", value) +``` + +#### Output + +``` +yr : 20 +name : Ed +18 : True +``` +# Dictionary Methods & Functions + +## Number of Items + +`len()` can be used to fetch the number of items in the dictionary. + +``` python +>>> d = {"yr": 20, "name": "Ed", +... 18: True} +>>> len(d) +3 +``` + +#br + +## Min and Max + +The `min()` and `max()` built-in functions return the minimum and maximum value among the keys of a dictionary. + +In case of string keys, they return the first and last occurring strings alphabetically. + +``` python +>>> d = {"yr": 20, "name": "Ed", +... "is18": True} +>>> min(d) +'is18' +>>> max(d) +'yr' + +>>> d = {2: "b", 3: "c", 1: "a"} +>>> min(d) +1 +>>> max(d) +3 +``` + +#br + +## Copy + +A new copy of a dictionary can be made using `copy()` method: + +``` python +>>> old_d = {"a": 1, "b": 2} +>>> new_d = old_d.copy() + +# Checking if both dicts are +# pointing to the same object +>>> new_d is old_d +False + +>>> new_d["c"] = 3 +>>> new_d["b"] = 4 +>>> new_d +{'a': 1, 'b': 4, 'c': 3} +>>> old_d +{'a': 1, 'b': 2} +``` +# Nested Dictionary + +When the value in a `key:value` pair of a dictionary is of type `dict`, it is known as a nested dictionary. + +In simple terms, it is a dictionary inside a dictionary. + +Records of a table can be represented as a nested dict with primary key as the outer dict keys. + +``` python +d = { 1: {"name": "Amar", "age": 19}, + 2: {"name": "Ria", "age": 20}, + 3: {"name": "Rao", "age": 18}} + +print(d[1]) +print(d[2]["name"]) +``` + +#### Output + +``` python +{'name': 'Amar', 'age': 19} +Ria +``` +# Sample Programs + +## Frequency of Characters + +Write a program to count the number of times a character appears in a given string. + +#### Code + +``` python +d = {} +s = input("Enter string: ") +for c in s: + if c in d: + d[c] += 1 + else: + d[c] = 1 + +print("Frequency of characters") +for key in d: + print(key, "-", d[key]) +``` + +#### Output + +``` +Enter string: pythondata +Frequency of characters +p - 1 +y - 1 +t - 2 +h - 1 +o - 1 +n - 1 +d - 1 +a - 2 +``` + +#br + +## Salary Book + +Write a program to enter employee names and their salaries as input and store them in a dictionary. + +#### Code + +``` python +n = int(input("Enter number of employees: ")) +emp = dict() +for cnt in range(n): + name = input("Enter employee name: ") + salary = int(input("Enter salary: ")) + emp[name] = salary + +print("Employee Name & Salary") +for key in emp: + print(key, '-', emp[key]) +``` + +#### Output + +``` +Enter number of employees: 3 +Enter employee name: Anil Raj +Enter salary: 12000 +Enter employee name: Dinesh Kumar +Enter salary: 15000 +Enter employee name: Sam Singh +Enter salary: 10000 +Employee Name & Salary +Anil Raj - 12000 +Dinesh Kumar - 15000 +Sam Singh - 10000 +``` +# Built-in Functions + +Python has a rich and extensive **Standard Library** which gives it an edge over traditional programming languages. + +**Python Standard Library** contains 69 built-in functions that are commonly used by programmers which saves a lot of time as they can be directly used in a program. + +We have already used some functions in the previous sections like `input()`, `output()`, `len()`, `sum()`, `min()`, `max()`, `list()`, `dict()`, etc. + +Some of the widely used functions can be categorized as follows: + +- Mathematical Functions +- Type Functions +- Input/Output Functions +- Base/Unicode Functions +# Mathematical Functions + +## abs() + +`abs(x)` returns the absolute value or magnitude of `x` of type `int`, `float` or `complex` number. + +``` python +>>> abs(-2.3) +2.3 +>>> abs(-10) +10 +>>> abs(2 + 2j) +2.8284271247461903 +``` + +## round() + +`round(x [,ndigits])` rounds off `x` (`float`) to `ndigits` precision after the decimal point. + +In case `ndigits` is not provided, it rounds off to the nearest integer. + +``` python +>>> round(2.33462398) +2 +>>> round(2.33462398, 3) +2.335 +``` + +## sum() + +`sum(sequence [,start])` returns the sum of items in a `sequence` of type `list`, `tuple`, `range` or `set`. + +If a second argument `start` is provided, it is added to the sum. + +``` python +>>> sum([1, 2, -1]) +2 +>>> sum((1, 2, -1)) +2 +>>> sum([1, 2, -1], 10) +12 +``` + +## min() + +`min(sequence)` returns the minimum value of items in a `sequence` of type `list`, `tuple`, `range`, `str` or `set`. + +Apart from iterables, `min(arg1, arg2, ..)` also accepts multiple arguments `arg1`, `arg2` .. of numeric type and returns the smallest among these arguments. + +``` python +>>> min([1, 2, -1]) +-1 +>>> min(1, 2, -1) +-1 + +# character with minimum +# ASCII value in a String +>>> min("hello") +'e' +``` + +## max() + +`max(sequence)` returns the maximum value of items in a `sequence` of type `list`, `tuple`, `range`, `str` or `set`. + +Apart from iterables, `max(arg1, arg2, ..)` also accepts multiple arguments `arg1`, `arg2` .. of numeric type and returns the largest among these arguments. + +``` python +>>> max([1, 2, -1]) +2 +>>> max(1, 2, -1) +2 + +# character with maximum +# ASCII value in a String +>>> max("hello") +'o' +``` + +## pow() + +`pow(base, exp [,mod])` raises a `base` (`int`, `float`) to the power `exp` (`int`, `float`), i.e. `base**exp`. + +If `mod` (`int`) is provided `(base**exp) % mod` is returned. + +``` python +>>> pow(3, 2, 7) +2 +>>> pow(1.4141, 2) +1.9996788099999998 +``` + +## divmod() + +`divmod(a, b)` returns a tuple `(a // b, a % b)` consisting of the quotient and remainder when `a` (`int`, `float`) is divided by `b` (`int`, `float`). + +``` python +>>> divmod(23, 3.5) +(6.0, 2.0) +>>> divmod(-10, 7) +(-2, 4) +``` +# Type Functions + +Python has built-in functions to handle various aspects of datatypes such as checking and conversion. + +## Type Checking + +`type()` and `isinstance()` builtin functions are used for checking the data type of objects. + +Check out the **Type Checking** section in the chapter **Variable, Objects & Data Types** to learn more about it in detail. + +## Built-in Type Functions + +We have previously discussed the various built-in data types available in Python. + +The following functions are often used to assign a default value or create an empty collection when no arguments are provided: + +| Function | Default Value | +|--|--| +| `bool()` | `False` | +| `int()` | `0` | +| `float()` | `0.0` | +| `complex()` | `0j` | +| `str()` | `''` | +| `list()` | `[]` | +| `tuple()` | `()` | +| `set()` | `set()` | +| `frozenset()` | `frozenset()` | +| `dict()` | `{}` | + +The **Type Casting** section of the chapter **Variable, Objects & Data Types** covers these functions in detail in case any argument is passed. +# I/O Functions + +Python provides the following built-in functions to handle user input and result output: + +## input() + +`input()` function can be used to accept a user input and assign it to a variable. + +When this function is encountered in the code, the python interpreter waits for the user to type a response which is read as a string. + +#### Code + +``` python +name = input("Enter name: ") +print("Hello,", name) +``` + +#### Output + +``` +Enter name: Python +Hello, Python +``` + +#br + +## print() + +The built-in `print()` function can be used to display an output (value of variables, expressions, etc.) on the standard output. + +For example, the below code computes the area of a rectangle and displays it: + +#### Code + +``` python +length = 10 +breadth = 5 +area = length * breadth +print("Area:", area) +``` + +#### Output + +``` +Area: 50 +``` + +#br + +Both, `input()` and `print()` functions are covered in detail in the chapter **Input & Output**. + +#br + +## open() + +`open()` function is used to open a file and return the corresponding file object. + +This function supports various modes useful for reading from a file and writing to a file. + +An example usage of `open()` function is shown below: + +``` python +f = open('data.txt', 'r+') +# f is the file object which +# can perform read and write +# operations on the file +``` + +This function is covered in detail in the chapter **File Handling**. +# Base/Unicode Conversion Functions + +## bin() + +Converts an `int` to a binary (base-2) string prefixed with `'0b'`. + +``` python +>>> bin(9) +'0b1001' +``` + +## oct() + +Converts an `int` to an octal (base-8) string prefixed with `'0o'`. + +``` python +>>> oct(9) +'0o11' +``` + +## hex() + +Converts an `int` to a lowercase hexadecimal (base-16) string prefixed with `"0x"`. + +``` python +>>> hex(29) +'0x1d' +``` + +## ord() + +Returns the integer Unicode code point for the given Unicode character `str`. + +``` python +>>> ord("a") +97 +>>> ord("β") +946 +``` + +## chr() + +Converts the integer Unicode code point into the corresponding Unicode string. + +``` python +>>> chr(97) +'a' +>>> chr(946) +'β' +``` +# Built-in Modules + +Apart from built-in functions, the **Python Standard Library** also contains a wide range of built-in modules which are a group of functions organized based on functionality. + +Some of the commonly used modules are mentioned below: + +- `math` - Mathematical functions +- `random` - Generate pseudo-random numbers +- `statistics` - Statistical functions + +## Accessing Modules + +A module can be accessed in a program using the `import` statement. + +``` python +>>> import math +``` + +The above `import` statement loads all the functions available in the `math` module. To access any function in the module, simply type the module name followed by a period (`.`), followed by the function name. + +``` python +>>> import math +>>> math.pow(3, 2) +9.0 +``` + +Instead of loading all the functions in a module, the `from` statement can be used to access only specified functions. + +``` python +>>> from math import pow +>>> pow(3, 2) +9.0 +``` +# math + +`math` module provides mathematical functions and constants as defined by the C standard. + +## Constants + +The following frequently used mathematical constants are available in `math` module: + +- `pi` : `π = 3.141592…` (to available precision) +- `e` : `e = 2.718281…` (to available precision) +- `tau` : `τ = 2π = 6.283185…` (to available precision) + +``` python +>>> import math +>>> math.pi +3.141592653589793 +>>> math.e +2.718281828459045 +>>> math.tau +6.283185307179586 +``` + +#br + +## Functions + +Following useful mathematical functions are available in the `math` module: + +### fabs() + +`fabs(x)` returns the absolute value of `x`. + +``` python +>>> import math +>>> math.fabs(-3.24) +3.24 +``` + +### gcd() + +`gcd(a, b)` returns the greatest common divisor of integers `a` and `b`. + +``` python +>>> import math +>>> math.gcd(54, 24) +6 +``` + +### ceil() + +`ceil(x)` returns the smallest integer greater than or equal to `x`. + +``` python +>>> import math +>>> math.ceil(2.13) +3 +``` + +### floor() + +`floor(x)` returns the largest integer less than or equal to `x`. + +``` python +>>> import math +>>> math.floor(2.13) +2 +``` + +### fmod() + +`fmod(x, y)` returns the value of the expression `x - n*y` such that the result has the same sign as `x` and magnitude less than `|y|` for some integer `n`. + +This function should be preferred when working with floating point numbers as compared to `x % y` that should be used when working with integers. + +``` python +>>> import math +>>> math.fmod(2.14, 0.5) +0.14000000000000012 +>>> math.fmod(-2.14, 0.5) +-0.14000000000000012 +``` + +### pow() + +`pow(x, y)` raises `x` to the power of `y`. + +``` python +>>> import math +>>> math.pow(5, 2) +25.0 +``` + +### sqrt() + +`sqrt(x)` returns the square root of `x`. + +``` python +>>> import math +>>> math.sqrt(25) +5.0 +``` + +### sin(), cos() & tan() + +`sin(x)`, `cos(x)` and `tan(x)` return the sine, cosine and tangent of `x` (radians) respectively. + +``` python +>>> import math +>>> math.cos(math.pi/3) +0.5000000000000001 +>>> math.sin(math.pi/2) +1.0 +>>> math.tan(math.pi/4) +0.9999999999999999 +``` + +### factorial() + +`factorial(n)` computes the factorial of a positive integer `n` which is the product of all positive integers less than or equal to `n`. +`n! = n×(n-1)×(n-2)...3×2×1`, +where `0! = 1` + +``` python +>>> import math +>>> math.factorial(5) +120 +``` +# random + +`random` module provides access to functions which can generate random numbers. + +## random() + +`random()` function draws a random float in the half open interval `[0.0, 1.0)` with a uniform probability. + +``` python +>>> import random +>>> random.random() +0.6857133962949904 +``` + +## Random Integer from Range + +`randrange(stop)` is used to randomly select an integer from a range `0` to `stop` (excluding). + +``` python +>>> import random +>>> random.randrange(10) +5 +``` + +`randrange(start, stop)` is used to randomly select an integer from a range `start` to `stop` (excluding). + +``` python +>>> import random +>>> random.randrange(5, 10) +8 +``` + +`randint(a, b)` is an alias for `randrange(a, b+1)`, provides an interface to generate a random integer `N` such that `a <= N <= b` (includes boundaries). + +``` python +>>> import random +>>> random.randint(10, 20) +12 +``` +# statistics + +`statistics` module provides functions that are useful for calculating mathematical statistics of numeric (Real-valued) data. + +## Mean + +`mean(data)` returns the arithmetic mean or average value of `data` (`list` or `tuple` of `int` or `float`). + +``` python +>>> from statistics import mean +>>> mean([1, 2, 3, 6]) +3 +``` + +## Median + +`median(data)` returns the median or middle value of `data` (`list` or `tuple` of `int` or `float`) using the common "mean of middle two" method. + +``` python +>>> from statistics import median +>>> median([1, 2, 3, 6]) +2.5 +``` + +## Mode + +`mode(data)` returns the most commonly occurring value in the `data` (`list` or `tuple` of `int`, `str` or `float`). + +If there are multiple modes with the same count, the first occurrence in the sequence is returned. + +``` python +>>> from statistics import mode +>>> mode([1, 2, 3, 6]) +1 +>>> mode([1, 2, 2, 3, 6]) +2 +>>> mode(["a", "b", "a", "c"]) +'a' +``` +# Need for File Handling + +So far we have written programs which accept input from the user via keyboard and display the generated output on the standard output (console). + +This activity has the following disadvantages: + +- Feasible for small inputs, but cumbersome in case of large inputs. +- The entire input has to be entered every time the program is executed. +- The output generated is not saved for sharing or later use. + +Just like words can be written on a piece of paper, information can be stored on a computer disk as a named location or a file. + +Python comes with the in-built ability to interact with files. Through file handling, Python programs can read a file to provide input data and output the results into a file for later use. +# File Types + +Primarily, there are two types of files: + +## Text File + +A text file is the simplest way to store information in a human readable text format (sequence of ASCII or Unicode characters), which includes numeric values. + +It is easy to view and modify the contents of a text file using any text editor like notepad or even IDLE. + +Even the python script is stored as a text file given by the extension `.py`. `.txt` is the most popular extension used for a generic text file. + +Although text files do not have any structure, there are international standards defining some rules for creating specialized text files like: + +- `.csv`, where each row is a set of comma separated values. This is the most popular data exchange format. +- `.tsv`, similar to CSV but the values are separated by tabs instead of commas. +- `.xml` and `.json` are popular web data exchange formats. +- `.html` files are text files with contents written in the Hypertext Markup Language designed to display contents in a web browser. + +## Binary File + +Although the contents of a text file is human readable, in reality this information is stored on the disk in form of machine readable bytes (1s and 0s) one character at a time. This makes the format simple to be operated by any application, but it is less efficient and consumes more memory (greater file size). + +In a binary file, the contents are also stored in form of bytes, but these bytes do not directly translate into ASCII or Unicode characters. + +Rather these bytes can represent anything like: + +- Complex Data Structures +- Image +- Audio +- Video + +and more. + +As there is no simple rule to determine the basic unit of information, so opening a binary file in a text editor will display garbage values and even a single bit of change can corrupt the entire file and make it unreadable. Hence, specialized softwares are required to read and write binary files. + +Python has a built-in `pickle` module which has implemented protocols to read and write binary files having `.dat` or `.pickle` file extension. `pickle` is a Python specific binary file format which can serialize any Python data structure (lists, dictionaries, etc) or code object into a binary file. This byte-content of this file can then be de-serialized and used later in any computer running Python. +# File Opening & Closing + +A text or binary file can be opened using the built-in `open(file_name, mode='r')` function. + +The parameters of the function are explained below: + +### file_name + +`file_name` is a required string parameter specifying the path of the file to be opened. + +It can either be an absolute path or a relative path as shown below: + +- `'fname.txt'` is the relative path of a text file residing in the current working directory from where the python script is being executed. +- `'../fname.txt'` is the relative path of a text file outside the current directory where the python script is being executed. +- `'/Users/edpunk/Documents/fname.txt'` is the absolute path of a text file which can be opened by the python script from any location as long as it is in the same system. + +#br + +### mode + +`mode` is an optional string parameter which specifies the mode in which the file has to be opened. It defaults to `'r'` which means open for reading in text mode. + +The available modes are: + +- `'r'` : Opens the file for reading (default). +- `'t'` : Opens the file in text mode (default). +- `'w'` : Opens the file for writing, truncating (emptying) the file if it already exists. +- `'x'` : Same as `'w'`, but it fails if the file already exists. +- `'a'` : Opens the file for writing, where any new data is added at the end. It creates a new file if the file does not exists. +- `'b'` : Opens the file in binary mode. +- `'rb'` : Opens the file in binary and read-only mode. +- `'wb'` : Opens the file for writing in binary mode, truncating (emptying) the file if it already exists. +- `'+'` : Allows both read and write operations on a file. +- `'r+'` : Opens the file in read and write mode. It throws an error in case the file does not exists. If the file already exists, new data is overwritten on top of the existing data if the position of stream is not moved to the end of the file. +- `'r+b'` : Opens the file in binary read and write mode. It does not truncate the file if it already exists. +- `'w+'` : Opens the file in read and write mode. It creates a new file or truncates the contents of the file if it already exists. +- `'w+b'` : Opens the file in binary read and write mode. It creates a new file or truncates the contents of the file if it already exists. +- `'a+'` : Opens the file in read and append mode. It creates a new file if it does not exist. If the file already exists, new data is automatically added at the end of the file after existing data. +- `'a+b'` : Opens the file in binary read and append mode. + +#br + +After opening a file and performing some file operations, it can be safely closed using the `close()` method. + +For example, let us write a program to open a file `data.txt` in read and append mode and close the file object in the successive statement. + +``` python +f = open('data.txt', 'a+') +f.close() +``` +# File Reading + +Opening a file using the `open()` function creates and returns a file object on which the following activities can be performed: + +## 1. Sequential Reading + +The following three methods can be used on a file object to sequentially read the contents of a file: + +### read() + +`read(size = -1)` method is used to read `size` numbers of bytes of data from a file at a time. + +In case `size` is not specified, it reads and returns the entire content of the file. + +#### Example + +Let us consider a file named `info.txt` containing the below text: + +``` +Hello World +Thank You +``` + +#### Code + +``` python +>>> f = open('info.txt', 'r') +>>> print(f.read(3)) +Hel +>>> print(f.read(4)) +lo W +>>> f.close() + +>>> f = open('info.txt', 'r') +>>> print(f.read()) +Hello World +Thank You +>>> f.close() +``` + +#br + +### readline() + +`readline(size = -1)` method without any arguments is used to read and return one line at a time from the given file. + +If `size` is specified, it returns at most `size` bytes of data or the data until it encounters the newline character. + +#### Example + +Let us consider a file named `info.txt` containing the below text: + +``` +Hello World +Thank You +``` + +#### Code + +``` python +>>> f = open('info.txt', 'r') +>>> f.readline(3) +'Hel' + +# Remaining data (byte size < 20) +# until it encounters newline +>>> f.readline(20) +'lo World\n' +>>> f.close() + +>>> f = open('info.txt', 'r') +>>> f.readline() +'Hello World\n' +>>> f.close() +``` + +#br + +Since `readline()` returns one row at a time, it can be used in a `while` statement to iterate over the data row-wise. Once it reaches the end of file it returns an empty string. + +#### Code + +``` python +f = open('info.txt', 'r') +line = f.readline() +while line: + # Removes newline + # character from the + # end of the line + line = line.strip() + + print(line) + + # read the next line + line = f.readline() +f.close() +``` + +#### Output + +``` +Hello World +Thank You +``` + +#br + +`for` statement can also be used to traverse the file row-wise without any requirement of the `readline()` method. Simply iterating over the file object returns the data one row at a time. + +#### Code + +``` python +f = open('info.txt', 'r') +for line in f: + # Removes newline + # character from the + # end of the line + line = line.strip() + print(line) +f.close() +``` + +#### Output + +``` +Hello World +Thank You +``` + +#br + +### readlines() + +`readlines()` method returns a list of strings representing the lines (along with the newline character) of text file content. + +#### Example + +Let us consider a file named `info.txt` containing the below text: + +``` +Hello World +Thank You +``` + +#### Code + +``` python +>>> f = open('info.txt', 'r') +>>> f.readlines() +['Hello World\n', 'Thank You'] +``` + +#br + +## 2. Random Access + +The following two methods can be used on a file object to randomly access contents of a file: + +### tell() + +`tell()` returns the current byte position (integer) of the file object in the file. + +Let us consider the same file `info.txt` for the below example: + +``` python +>>> f = open('info.txt', 'r') +>>> f.read(4) +'Hell' +>>> f.tell() +4 +``` + +#br + +### seek() + +`seek(offset, reference=0)` can be used to seek a location in the file object which is `offset` bytes from the provided `reference`. + +The default value for `reference` is `0` which stands for the beginning of the file. For this default `reference`, the `offset` has to be a whole number (`>=0`). + +Other allowed values of `reference` are: + +- `1`, which denotes that the offset will be calculated from the current position of the file object (`offset` can be positive or negative) +- `2`, which denotes that the offset is calculated from the end of the file (`offset` is negative) + +**Note**: In text files (those opened without a `b` in the mode string), only seek relative to the beginning of the file (`reference = 0`) is allowed. `reference = 1 or 2` is only valid when the file is opened in binary mode. + +Let us consider the same file `info.txt` for the below example: + +``` python +>>> f.seek(6) +6 + +# Hello World\nThank You +# ^ +# Position of file pointer +# after seek. + +>>> f.read() +'World\nThank You' +>>> f.tell() +21 + +>>> f.seek(12) +12 + +# Hello World\nThank You +# ^ +# Position of file pointer +# after seek. + +>>> f.read() +'Thank You' +``` +# File Writing + +The following modes support file writing: + +- Writing from the beginning of a file : `r+`, `r+b`, `w`, `x`, `wb`, `w+`, `w+b`. +- Appending at the end of an existing file : `a`, `ab`, `a+`, `a+b`. + +The following methods can be used to write data in a file: + +### write() + +`write(s)` method is useful for writing a string `s` into a file. + +``` python +>>> s = "Hi World\nThank You" +>>> f = open("info.txt", "w") +>>> f.write(s) +21 +# Number of characters written + +>>> f.close() +``` + +Now, on opening `info.txt` using a text editor, the following content is displayed. + +``` +Hi World +Thank You +``` + +### writelines() + +`writelines(lines)` method writes a list of strings into a file. + +This method does not add the line separator (newline character `\n`), so they should be present at the end of each string. + +``` python +>>> lines = ["Hi World\n", +... "Thank You\n"] +>>> f = open("info.txt", "w") +>>> f.writelines(lines) +>>> f.close() +``` + +Now, on opening `info.txt` using a text editor, the following content is displayed. + +``` +Hi World +Thank You + +``` + +Note the empty line at the end which is added due to the `\n` at the end of the last string. +# Pickle + +In Python, the protocols to read and write binary files (`.dat` or `.pickle` file extension) have been implemented in the built-in `pickle` module. + +`pickle` is a Python specific binary file format which can not only be used to store binary data, but also store any Python object. + +This process of translating data structures (lists, dictionaries, etc.) and code objects (classes, functions, etc.) into bytes that can be stored in a binary file is known as **Serialization**. This binary file can be stored on disk or shared and it can be de-serialized and used later via Python. + +## Dumping Data + +The `dump()` function can be used to write the pickled representation of any data or object into a file. + +**Syntax**: `pickle.dump(obj,file)` + +where: + +- `obj` is the object to be written +- `file` is an open file object (opened in binary write `wb` or append `ab` mode). + +``` python +>>> import pickle +>>> l = [["Anita","Maths",83], +... ["Amar","Maths",95], +... ["Ani","Maths",90]] +>>> f = open("marks.dat", "wb") +>>> pickle.dump(l, f) +>>> f.close() +``` + +#br + +## Loading Data + +The `load()` function can be used to read the pickled representation of an object or data from a file. + +**Syntax**: `pickle.load(file)` + +where `file` is an open file object (opened in binary read mode `rb`). + +``` python +>>> import pickle +>>> f = open("marks.dat", "rb") +>>> l = pickle.load(f) +>>> f.close() +>>> l +[['Anita', 'Maths', 83], ['Amar', 'Maths', 95], ['Ani', 'Maths', 90]] +``` + +#br + +## Example: Traversing a Binary File + +Write a program which performs the following Record Keeping activities: + +- Accept some student marks as input and write the data in a binary file +- read all data from the file +- add some more data to the file +- show the entire contents of the file + +#### Code + +``` python +import pickle + +# Open file in binary write mode +f = open("marks.dat", "wb") + +# Enter student marks data +flag = 1 +while flag != 0: + name = input("Enter student name: ") + subject = input("Enter subject: ") + marks = float(input("Enter marks: ")) + rec = [name, subject, marks] + pickle.dump(rec, f) + flag = int(input("Enter 1 to add more or 0 to terminate: ")) +f.close() + +# read contents of file and display +f = open("marks.dat", "rb") + +print("File contents:") + +# Iteratively read all pickle objects written +# in the file until the end of fie is reached +try: + while True: + rec = pickle.load(f) + print(rec) +except EOFError: + print("End of file reached") + f.close() + +# Add more data +f = open("marks.dat", "ab") +flag = 1 +while flag != 0: + name = input("Enter student name: ") + subject = input("Enter subject: ") + marks = float(input("Enter marks: ")) + rec = [name, subject, marks] + pickle.dump(rec, f) + flag = int(input("Enter 1 to add more or 0 to terminate: ")) +f.close() + +# show all contents +f = open("marks.dat", "rb") + +print("File contents after appending:") +try: + while True: + rec = pickle.load(f) + print(rec) +except EOFError: + print("End of file reached") + f.close() +``` + +#### Input/Output + +``` +Enter student name: Anita +Enter subject: Maths +Enter marks: 83 +Enter 1 to add more or 0 to terminate: 1 +Enter student name: Amar +Enter subject: Maths +Enter marks: 95 +Enter 1 to add more or 0 to terminate: 0 +File contents: +['Anita', 'Maths', 83.0] +['Amar', 'Maths', 95.0] +End of file reached +Enter student name: Akash +Enter subject: Science +Enter marks: 92 +Enter 1 to add more or 0 to terminate: 1 +Enter student name: Ira +Enter subject: Science +Enter marks: 99 +Enter 1 to add more or 0 to terminate: 0 +File contents after appending: +['Anita', 'Maths', 83.0] +['Amar', 'Maths', 95.0] +['Akash', 'Science', 92.0] +['Ira', 'Science', 99.0] +End of file reached +``` +# CSV + +Comma-separated value (CSV) file format is one of the most common data serialization and exchange format where each row is a set of values separated by a delimiter. + +The main rules for creating a CSV file are: + +- Each field is separated by a delimiter. Comma (`,`) is the default delimiter used in CSV files, but other delimiters (`;`, `\t`, `|`, etc.) can also be used. +- If any field value contains a delimiter, it must be surrounded by a pair of quote characters (usually double-quotes character `"` ). +- There is an optional single header line which contains the names of the fields. + +An example CSV file containing the marks data is given below: + +``` +Name,Subject,Marks +Anita,Maths,83.0 +Amar,Maths,95.0 +Akash,Science,92.0 +Ira,Science,99.0 +``` + +To demonstrate why quote characters are required, let us have a look at the below contents of a CSV file which contains the average marks of some subjects (separated by comma) for each student. + +``` +Name,Average Of,Marks +Anita,"Accounting,Maths",83.0 +Amar,"Accounting,Maths",95.0 +Akash,"Physics,Chemistry,Biology",92.0 +Ira,"Physics,Chemistry,Biology",99.0 +``` + +Python has built-in `csv` module which provides utilities to read and write CSV files. + +## Reading CSV File + +`csv.reader(csvfile, delimiter=',', quotechar='"')` function is used to return the reader object which iterates over CSV file line-by-line and returns it as a list of strings. + +The `csvfile` file object should be opened with `newline=''` argument as the `csv` module has its own newline handling which correctly interprets the newlines depending on platform or in case they are embedded inside quoted fields. + +### Example 1 + +Let us write a program to read the contents of `marks.csv`. + +#### marks.csv + +``` +Name,Subject,Marks +Anita,Maths,83.0 +Amar,Maths,95.0 +Akash,Science,92.0 +Ira,Science,99.0 +``` + +#### Code + +``` python +import csv +with open('marks.csv', + newline='') as f: + reader = csv.reader(f) + for row in reader: + print(row) +``` + +#### Output + +``` +['Name', 'Subject', 'Marks'] +['Anita', 'Maths', '83.0'] +['Amar', 'Maths', '95.0'] +['Akash', 'Science', '92.0'] +['Ira', 'Science', '99.0'] +``` + +#br + +### Example 2 + +Let us write a program to read the contents of `marks2.csv`. + +Note the change in delimiter & quote character. + +#### marks2.csv + +``` +Name|Average Of|Marks +Anita|^Accounting|Maths^|83.0 +Amar|^Accounting|Maths^|95.0 +Akash|^Physics|Chemistry|Biology^|92.0 +Ira|^Physics|Chemistry|Biology^|99.0 +``` + +#### Code + +``` python +import csv +with open('marks2.csv', + newline='') as f: + reader = csv.reader(f, + delimiter='|', + quotechar='^') + for row in reader: + print(row) +``` + +#### Output + +``` +['Name', 'Average Of', 'Marks'] +['Anita', 'Accounting|Maths', '83.0'] +['Amar', 'Accounting|Maths', '95.0'] +['Akash', 'Physics|Chemistry|Biology', '92.0'] +['Ira', 'Physics|Chemistry|Biology', '99.0'] +``` + +#br + +## Writing CSV File + +`csv.writer(csvfile, delimiter=',', quotechar='"')` function returns a writer object which converts data in form of a list into delimited strings which is passed down to the file object for writing. + +All non-string data in the list are automatically converted into string before it is written. + +The methods `writerow(row)` or `writerows(rows)` can be used to write a row (list of strings) or list of rows to a CSV file. + +### Example 3 + +Write a program to create a CSV file containing subject-wise marks of students delimited by semi-colon (`;`). + +#### Solution #1: Using writerow() + +``` python +import csv + +h = ["Name","Subject","Marks"] + +marks = [["Anita","Maths",83.0], + ["Amar","Maths",95.0], + ["Akash","Science",92.0], + ["Ira","Science",99.0]] + +with open('marks.csv', 'w', + newline='') as f: + writer = csv.writer(f, + delimiter=';') + + # Writing header + writer.writerow(h) + + #Writing Data + for row in marks: + writer.writerow(row) +``` + +#br + +#### Solution #2: Using writerows() + +``` python +import csv + +h = ["Name","Subject","Marks"] + +marks = [["Anita","Maths",83.0], + ["Amar","Maths",95.0], + ["Akash","Science",92.0], + ["Ira","Science",99.0]] + +with open('marks.csv', 'w', + newline='') as f: + writer = csv.writer(f, + delimiter=';') + + # Writing header + writer.writerow(h) + + #Writing Data + writer.writerows(marks) +``` + +#br + +#### Output - marks.csv + +``` +Name;Subject;Marks +Anita;Maths;83.0 +Amar;Maths;95.0 +Akash;Science;92.0 +Ira;Science;99.0 +``` +# User Defined Functions + +The built-in functions and modules of the Python Standard Library add tremendous value by performing generic operations and can be utilised by developers for any task. + +But, at times a programmer needs to perform a set of operations for a specific task multiple times. In such cases instead of rewriting the statements again and again, the block of code can be wrapped into a function which can be called anytime in the scope of the program. + +**User-defined functions** make the program more: + +- **Organized**, as a block of code is now replaced by a single function call which performs a specific task. +- **Manageable**, due to reduction of code length. +- **Reusable**, as the user defined function can be used anywhere in the current program or it can also be imported in another program. +# Function Structure + +Let us take a deep dive into a user defined function (provided below) and understand its various components: + +``` python +def adder(f, s, t = None): + """ + Returns the sum of f, s and t. + If t is not provided, + return the sum of f and s. + """ + s = f + s + if t: + s += t + return s +``` + +#br + +## Function Header + +``` python +def adder(f, s, t = None): +``` + +The function header begins with the keyword `def`. + +The function name follows the `def` keyword. As it is an identifier, the same nomenclature is followed while naming it. `adder` is the name of the function in the above example. + +The function name is followed by a pair of parenthesis `( )`. + +In case any parameters are required by the function, they are enclosed inside the parentheses. `f, s, t = None` are the three parameters of the function. + +Finally, the function header ends with a colon. + +#br + +## Function Body + +The body of the function consists of one or more Python statements which have the same amount of indentation (4 spaces) from the function header. + +It is a good practice to include the documentation string at the beginning of the function body that briefly explains how it works. This docstring can either be a single-line or a multiline string literal. In the above example the docstring is: + +``` python + """ + Returns the sum of f, s and t. + If t is not provided, + return the sum of f and s. + """ +``` + +This docstring is followed by a series of statements which represent the set of instructions to be executed. The set of instructions in the above example are + +``` python + s = f + s + if t: + s += t +``` + +The code block finally ends with a `return` statement which returns one or more values. + +``` python + return s +``` + +In the above example the value of `s` is returned which is the sum. + +A missing `return` statement or a `return` statement returning no value implies that the function returns `None`. These functions are known as void functions which display the result of statements via `print()` function. +# Parameters and Arguments + +``` python +def adder(f, s, t = None): + """ + Returns the sum of f, s and t. + If t is not provided, + return the sum of f and s. + """ + s = f + s + if t: + s += t + return s +``` + +After defining the above function, let us now invoke or call the function: + +``` python +fst = 20 +snd = 10 +trd = 10 +sm1 = adder(fst, snd, trd) +sm2 = adder(fst, snd) +``` + +`f`, `s` and `t` are known as positional parameters as they have a defined position in the function definition. + +Also there is a provision to assign a default value to a parameter using `=`. + +In the above example `t` has a default value of `None`. + +Arguments are the values passed to a function (or method) when it is called. In the above example `fst`, `snd` and `trd` are the arguments. Since `t` has a default value, the function can be invoked with or without the `trd` argument as shown for `sm2`. + +Argument values are assigned to the corresponding function parameters that are available as local variables inside the function. + +Thus, value of `fst` is assigned to `f` and `snd` is assigned to `s`. In case there is no third argument, `t` has the default value `None`. + +The values of `sm1` and `sm2` after executing the script are: + +``` python +>>> sm1 +40 +>>> sm2 +30 +``` +# Variable Scope + +In Python, every variable has a well defined scope, i.e., it is accessible by a part of the program and it cannot be accessed from outside its scope. + +Based on their scope, there are two types of variables: + +## Local Variables + +Local variables are defined inside a function or a code block and can only be accessed where they are defined. + +They exist only during the execution of the function or the code block. + +#### Code + +``` python +def triple(a): + result = 3*a + # variable result + # is accessible locally + print("local:", result) + +# Outputs value of result +# inside the function +triple(3) + +# Throws an error as result is +# not accessible outside the scope +# of function triple() +print("outside:", result) +``` + +#### Output + +``` +local: 9 +Traceback (most recent call last): + File "", line 1, in +NameError: name 'result' is not defined +``` + +## Global Variables + +Variables defined outside any function or code block are known as global variables. + +They are often used to specify mathematical constants, file path or other such values and can be accessed anywhere in the source code (by functions or code blocks). + +Below example demonstrates how the global variable `n` can be accessed by all the functions. + +#### Code + +``` python +n = 10 + +def uno(): + print(n) + +def tres(): + print(n*3) + +uno() +tres() +``` + +#### Output + +``` +10 +30 +``` + +#br + +In case a variable is defined inside a function with the same name as that of a global variable, then the variable is considered as a local variable and all references made to the variable point to this local variable. + +#### Code + +``` python +n = 10 + +# local n inside the +# function +def uno(): + n = 5 + print(n) + +# global n inside the +# function +def tres(): + print(n*3) + +uno() +tres() +``` + +#### Output + +``` +5 +30 +``` + +#br + +Any changes made to a global variable inside a code block or a function can modify it for that session. This can have an impact on all the code blocks/functions that access and use it. + +To modify the value of a global variable one can use the `global` keyword as shown in the example below. + +#### Code + +``` python +n = 10 + +# function modifies the +# value of global n +def uno(): + global n + n = 5 + print(n) + +def tres(): + print(n*3) + +uno() +tres() +``` + +#### Output + +``` +5 +15 +``` +# Passing Mutable Objects + +When mutable objects (`list`, `dict`) are provided as an argument to a function, any modification made to the corresponding parameters in the body of the function leads to the modification of the original object. + +Hence, care should be taken while passing mutable objects. + +## List + +#### Code + +``` python +def repeat(l): + for i in range(len(l)): + l[i] = l[i]*2 + +l = [1, 2, 3] +print(l) +repeat(l) +# l is modified +print(l) +``` + +#### Output + +``` +[1, 2, 3] +[2, 4, 6] +``` + +#br + +## Dictionary + +#### Code + +``` python +def repeat(d): + for i in d.keys(): + d[i] = d[i]*2 + +d = {'a':1, 'b':2, 'c':3} +print(d) +repeat(d) +# d is modified +print(d) +``` + +#### Output + +``` +{'a': 1, 'b': 2, 'c': 3} +{'a': 2, 'b': 4, 'c': 6} +``` +# Creating a Module + +Once a function is defined in the Python interpreter, it can be called any number of times. But, these function definitions are lost upon exiting the interpreter. + +To solve this problem we can create a python script with the function definitions at the beginning of teh file, followed by the rest of the code which includes statements invoking the defined functions. + +But, this process is tedious and not managable as what makes user-defined functions powerful is that the programmer can - **Write once, and use many times**. + +Instead of repeating the function definition again and again for each new program, one can put all the function definitions in a file from which the required function can be imported and invoked either in script mode or interactive mode. + +This file (`.py` extension) is known as a `module` and it is the most basic form of reusable code accessible by other programs. + +Let us create a new file `basics.py` containing the following functions: + +``` python +def adder(f, s, t = None): + """ + Returns the sum of f, s and t. + If t is not provided, + return the sum of f and s. + """ + s = f + s + if t: + s += t + return s + +def tripler(a): + """ + Multiplies a by 3 and + returns it + """ + result = 3*a + return result +``` + +After saving the `basics.py` file, reopen IDLE and create a new file `test.py` in the same directory as basics.py. + +The name of the file is the module name which is also available as the value of the global variable `__name__` in the module. + +Import the functions of the basics module in `test.py` by executing the following statement. + +``` python +import basics +``` + +The above `import` statement loads all the functions available in the `basics` module. To access any function in the module, simply type the module name followed by a period (`.`), followed by the function name. + +#### Code + +``` python +import basics +sa = basics.adder(20, 10, 10) +st = basics.tripler(20) +print(sa) +print(st) +``` + +### Output + +``` +40 +60 +``` + +#br + +The `as` keyword can also be used to create an alias which makes it easier and more manageable to use in the program. + +#### Code + +``` python +import basics as ba +sa = ba.adder(20, 10, 10) +st = ba.tripler(20) +print(sa) +print(st) +``` + +### Output + +``` +40 +60 +``` + +#br + +Instead of loading all the functions in a module, the `from` statement can be used to access only specified functions. + +#### Code + +``` python +from basics import adder +sa = adder(20, 10, 10) +print(sa) +``` + +### Output + +``` +40 +``` + +#br + +To import all functions and global variables in the module the `*` wildcard character can be used. + +#### Code + +``` python +from basics import * +sa = adder(20, 10, 10) +st = tripler(20) +``` + +### Output + +``` +40 +60 +``` + +#br + +The above method of using `*` to import the contents of a module is not recommended as it can clutter the namespace and cause issues if there are conflicts between the identifiers defined by the programmer and those defined in the module/package. +# Executable Scripts/Modules + +Apart from containing definitions, a module can also contain block of code which is executed whenever the stand-alone script is run in script mode. The block has to be enclosed in an `if` statement as shown below: + +``` python +if __name__ == '__main__': + ...code to be executed... +``` + +Using the above pattern, a file can be imported or executed directly. + +Let us undertake an example module (save it as `multi.py`) which multiplies two numbers: + +``` python +def multiply(a, b): + return a * b + +f = int(input("Enter a: ")) +s = int(input("Enter b: ")) +print(multiply(f, s)) +``` + +Now when we try to load all functions from the module it automatically executes the input assignment statements and prints the output. + +``` python +>>> from test import * +Enter a: 4 +Enter b: 5 +20 +>>> +``` + +Let us modify the code: + +``` python +def multiply(a, b): + return a * b + +if __name__ == '__main__': + f = int(input("Enter a: ")) + s = int(input("Enter b: ")) + print(multiply(f, s)) +``` + +Now, the block will execute only if the script is executed directly and not when the file is imported as a module. + +``` python +>>> from test import * +>>> multiply(4, 5) +20 +``` +# Creating a Package + +A collection of modules which can work together to provide a common functionality is known as a **package**. + +These modules are present in a folder along with the `__init__.py` file which tells Python that this folder is a package. + +A package can also contain subfolders (sub-packages), each containing their respective `__init__.py` files. + +Let us take the example of a package called `restaurant` which consists of various modules to perform activities such as order booking, reservation, staff attendance, etc. + +Here is a possible structure for the package: + +``` +restaurant/ + __init__.py + orders.py + reservation.py + employee.py + inventory.py +``` + +A package is simply the directory containing sub-packages and modules, but when this package or a collection of packages are made available for others to use (eg. via PyPI) it is known as a **library**. + +For example, `restaurant` can be called a library if it provides reusable codes to manage a restaurant and is built using multiple packages which handle the various aspects of a restaurant like human resource management, inventory management, order fulfilment and billing, etc. + +One should note that the above definition is not strict and often the terms package and library are used interchangeably. \ No newline at end of file diff --git a/images/0201a.png b/images/0201a.png new file mode 100755 index 0000000000000000000000000000000000000000..b9a15d9f739a50ec5e27f6f937c51dec10a0d225 GIT binary patch literal 35271 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 Df{5u< literal 0 HcmV?d00001 diff --git a/images/0201c.png b/images/0201c.png new file mode 100755 index 0000000000000000000000000000000000000000..78995babb4ebdb3d6e3fad03f69997032dea7d62 GIT binary patch literal 87680 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 z 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

jwT-6qf6O-I{Z|J7y_QQ46Ao1d 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
Uv?P~=&>JA!&6LZ+OR=^ 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 literal 0 HcmV?d00001 diff --git a/images/0201d.png b/images/0201d.png new file mode 100755 index 0000000000000000000000000000000000000000..ff20b3113f27a0054e62107228a0d20cc8f582f6 GIT binary patch literal 21131 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 literal 0 HcmV?d00001 diff --git a/images/0202c.png b/images/0202c.png new file mode 100755 index 0000000000000000000000000000000000000000..ddf5719084dec793ce14410347d56c038d22b690 GIT binary patch literal 41312 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 literal 0 HcmV?d00001 diff --git a/images/0303a.png b/images/0303a.png new file mode 100755 index 0000000000000000000000000000000000000000..0d3fd5e8aebe2332ce4859e248a881e05d7a8ff1 GIT binary patch literal 25767 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 literal 0 HcmV?d00001 diff --git a/images/0303c.png b/images/0303c.png new file mode 100755 index 0000000000000000000000000000000000000000..e8e063b0863ae18276392be2e5463bcb682e6975 GIT binary patch literal 16519 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 E0SqZHm;e9( literal 0 HcmV?d00001 diff --git a/images/0501a.png b/images/0501a.png new file mode 100755 index 0000000000000000000000000000000000000000..c8eab6471f9ebb67982db8a0e4e556c7683894ab GIT binary patch literal 7472 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 literal 0 HcmV?d00001 diff --git a/images/0501b.png b/images/0501b.png new file mode 100755 index 0000000000000000000000000000000000000000..d71a0e64d951b3505a05bff34be6494cfe42ba6f GIT binary patch literal 7979 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 literal 0 HcmV?d00001 diff --git a/images/0501c.png b/images/0501c.png new file mode 100755 index 0000000000000000000000000000000000000000..7144f34a8fb03ec89a01eb59b9517581c9127a67 GIT binary patch literal 13036 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 literal 0 HcmV?d00001 diff --git a/images/0501d.png b/images/0501d.png new file mode 100755 index 0000000000000000000000000000000000000000..d1c9ed0fd444b122781af84ee5b0f03ac505b595 GIT binary patch literal 19221 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�!+i~Z>ME8GF0#=yUo$40KnTr>1({&$ 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 f7Bgw{z)QXXpQ`700000NkvXXu0mjfbIq8J literal 0 HcmV?d00001 diff --git a/images/0702b.png b/images/0702b.png new file mode 100755 index 0000000000000000000000000000000000000000..8573c71a6d00de0bc5f41876a39bdb95221996ec GIT binary patch literal 14421 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 bjs5*E3bvhRaA)C+00000NkvXXu0mjf2Tt03 literal 0 HcmV?d00001 diff --git a/images/0802a.png b/images/0802a.png new file mode 100644 index 0000000000000000000000000000000000000000..dc57bb9244eb5c4c75c1e30122f49f0c29f65c16 GIT binary patch literal 8458 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 WVFPZZCA!UjAd0eTGBr}>A^!!Z&QcKo literal 0 HcmV?d00001 diff --git a/images/0802b.png b/images/0802b.png new file mode 100644 index 0000000000000000000000000000000000000000..4cdd4af14f173655eb530bf2162e06fdf4fb0395 GIT binary patch literal 7855 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 m{#6@x({U1o@tfUVA>jbhYO0G literal 0 HcmV?d00001 diff --git a/images/0803a.png b/images/0803a.png new file mode 100644 index 0000000000000000000000000000000000000000..284b77026d92ad153db88e310f14e0a8adde287e GIT binary patch literal 18410 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�|hA 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 literal 0 HcmV?d00001 diff --git a/images/0805a.png b/images/0805a.png new file mode 100644 index 0000000000000000000000000000000000000000..353e0b12aab3f5bd7bd30cfb2cde44053c593b89 GIT binary patch literal 14406 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