content added

Author: aryan

content/notes/iit-madras/data-science-and-application/foundational-level/python/week 1/lec1.1.md

@@ -6,4 +6,41 @@ tags:
   - IIT Madras
 excludeSearch: false
 weight: 1
----
+---
+
+The course is designed for beginners, including those who may have written some code before, but it is also useful for newcomers.
+
+The material is often presented in a structured, **bottom-up** fashion, starting with foundational concepts and gradually building towards more complex ones.
+
+Key areas covered in the introduction and foundational parts include:
+
+*   **Running Python Programs**: Learning how to execute Python code, whether by typing interactively or running code stored in files, potentially using tools like Replit. Replit provides features like a files panel for adding files and folders and built-in help for commands like `print`.
+*   **Basic Syntax**: Understanding Python's general syntax model and fundamental statements, including the importance of indentation.
+*   **Variables and Literals**: Introducing how to use variables to store values and understanding different types of literals.
+*   **Data Types and Operations**: Studying Python's built-in object types in depth.
+    *   Each data element has a specific **data type** (e.g., integer, float, string) which indicates the category it belongs to.
+    *   You can check the type of a variable using the `type()` command.
+    *   Specific types covered include **numbers**, **strings**, **lists**, **dictionaries**, **tuples**, **sets**, and **booleans**.
+    *   String concepts like concatenation (`+`), replication (`*`), **indexing** (accessing individual characters like `s`), and **slicing** (accessing substrings like `s[1:3]`) are introduced. The use of different types of quotes (single and double) and **escape characters** are also covered.
+    *   Operators are categorised into arithmetic, relational, and logical.
+*   **Keywords**: Understanding reserved words that have special meaning in Python, such as `and`, `or`, and `not`. Other keywords like `break`, `continue`, and `pass` are discussed in relation to control flow.
+*   **Comments and Documentation**: Learning about using comments and **documentation strings (docstrings)** to explain your code. The PyDoc system can extract and display these docstrings.
+
+Moving beyond the basics, the materials cover:
+
+*   **Statements and Control Flow**: Exploring Python's procedural statements, including loops (`for`, `while`) and conditional statements (`if`). The `range` function is used with `for` loops.
+*   **Functions**: Learning how to define and use functions to package code for reuse and avoid redundancy. This includes exploring **scope rules** and argument passing.
+*   **Modules**: Understanding how modules organize statements and functions into larger components, including how to create, use, and import them in different ways (`import calendar`, `from calendar import *`, `from calendar import month`, using `as`). Concepts like **module packages** and the `__name__` variable are also introduced. Module files live within a module, and classes live within a module.
+*   **Classes and Object-Oriented Programming (OOP)**: Introducing the class as Python's main OOP tool. Classes are used to implement new kinds of objects and support **inheritance**.
+    *   A **class statement** creates a **class object**.
+    *   An **object** is a unique instance of a class. You create an **instance** by calling the class name like a function.
+    *   Functions defined within a class are called **methods**. The first argument in a class method is special; by convention, it's called `self` and receives the instance object the method is called on.
+    *   The `__init__` method is a special **constructor** method that is automatically called when a new instance is created. It's commonly used to initialise instance attributes.
+    *   **Operator overloading** allows defining how instances of your classes interact with standard Python operators (like `+` or `[]`) by implementing special methods (e.g., `__init__`, `__getitem__`).
+    *   **Inheritance** allows a new class (child) to be a modified version of an existing class (parent), inheriting its methods and attributes.
+*   **Exceptions**: Covering Python's mechanism for handling errors and other conditions.
+*   **File Handling**: Discussing how to work with files, including reading and writing.
+
+The learning process is supported by end-of-chapter quizzes, answers to quizzes, and end-of-part exercises. The materials also highlight common coding mistakes or "gotchas" to help you avoid them.
+
+Overall, while covering core concepts in depth, the focus is on teaching the Python language itself rather than specific application areas like web development or graphical user interfaces, although these may be briefly mentioned as possibilities after mastering the core language. Some advanced topics may be considered optional reading.

content/notes/iit-madras/data-science-and-application/foundational-level/python/week 1/lec1.10.md

@@ -6,4 +6,75 @@ tags:
   - IIT Madras
 excludeSearch: false
 weight: 10
----
+---
+
+Okay, let's continue our discussion on **Operators and Expressions**, building upon the foundational concepts we covered previously. The sources provide further details and examples across various operator types and how they form expressions.
+
+As established, in Python, expressions are combinations of values, variables, and **operators** that are evaluated by the interpreter to produce a value. Operators are special symbols or keywords that perform computations or actions on operands.
+
+The sources categorize operators into several types:
+
+1.  **Arithmetic Operators**: These perform mathematical operations.
+    *   `+`: Addition. For numbers, it adds. For sequences like strings or lists, it performs concatenation.
+    *   `-`: Subtraction. For numbers, it subtracts.
+    *   `*`: Multiplication. For numbers, it multiplies. For sequences, it performs repetition.
+    *   `/`: Division. In Python 3.0, this performs **true division**, keeping fractional remainders. In Python 2.6, it performed classic division, truncating for integers.
+    *   `//`: **Floor Division**. This divides and truncates fractional remainders, resulting in the integer quotient.
+    *   `%`: **Modulus**. This divides the left operand by the right and returns the remainder.
+    *   `**`: **Exponentiation** (power). `x ** y` calculates x raised to the power of y. Note that `^` is a bitwise operator in Python, not exponentiation.
+    *   There are also unary `+` and `-` for identity and negation.
+
+2.  **Comparison (Relational) Operators**: These compare values and return a Boolean result (`True` or `False`).
+    *   `==`: Equal value.
+    *   `!=`: Not equal value. Python 2.6 also used `<>` for not equal, but this was removed in Python 3.0.
+    *   `>`: Greater than.
+    *   `<`: Less than.
+    *   `>=`: Greater than or equal to.
+    *   `<=`: Less than or equal to.
+    *   Comparison operators can be **chained**. For example, `X < Y < Z` is evaluated similarly to `X < Y and Y < Z`. If all relational operators give a true result, the chain is true.
+    *   In Python 3.0, nonnumeric mixed-type magnitude comparisons are generally not allowed and raise exceptions, unlike in Python 2.x. Magnitude comparisons for dictionaries are also no longer supported in Python 3.0, though equality tests still are.
+
+3.  **Assignment Operators**: Used to assign values.
+    *   `=`: Basic assignment.
+    *   **Augmented assignment operators** (`+=`, `-=`, `*=`, `/=`, `%=`, `**=`, `//=`, etc.) provide a shorthand. For instance, `x += 1` is equivalent to `x = x + 1`. These work on any type that supports the implied binary expression.
+
+4.  **Logical Operators**: These combine Boolean expressions using the keywords `and`, `or`, and `not`.
+    *   `and`: True if both operands are true.
+    *   `or`: True if either operand is true.
+    *   `not`: Reverses the logical state of the operand.
+    *   While comparison operators return `True` or `False` (which are essentially custom versions of integers 1 and 0), the `and` and `or` operators can return an object (either the left or right operand), not necessarily just `True` or `False`. In a Boolean context (like an `if` statement), a nonzero number or a nonempty collection object is considered true.
+
+5.  **Membership Operators**: `in` and `not in`. These test if a value is present in a sequence (like strings, lists, or tuples) or a set.
+
+6.  **Identity Operators**: `is` and `is not`. These test if two variables point to the same object in memory, which is a stricter test than `==`. For example, `True is 1` is `False`, but `True == 1` is `True`.
+
+7.  **Bitwise Operators**: These operate on the individual bits of integers (`&`, `|`, `^`, `~`, `<<`, `>>`).
+
+8.  **Other Operators/Operations**:
+    *   Indexing (`[]`). Used for accessing elements in sequences or mappings.
+    *   Slicing (`[:]`). Used for extracting subsequences from sequences. Python 3.0 allows extended slicing with three parts: `X[I:J:K]`.
+    *   Call (`()`). Used to invoke functions, methods, or classes.
+    *   Attribute reference (`.`). Used to access attributes or methods of objects.
+
+**Operator Precedence**:
+When an expression includes multiple operators, Python follows **operator precedence** rules to determine the order of evaluation.
+*   **Parentheses (`()`)** have the highest precedence and can override the default order. Expressions within parentheses are evaluated first.
+*   **Exponentiation (`**`)** is next.
+*   **Multiplication (`*`), Division (`/`, `//`), and Modulus (`%`)** have higher precedence than Addition (`+`) and Subtraction (`-`).
+*   Operators at the same precedence level are generally evaluated from **left to right**, except for exponentiation.
+*   It is often good practice to use parentheses for clarity even when not strictly required by precedence. For example, `2 * 3 + 4` evaluates to 10 because multiplication happens first, while `2 * (3 + 4)` evaluates to 14 because parentheses force the addition first.
+
+**Expressions and Statements**:
+Expressions can appear as **statements**. Common forms of expression statements include calling functions and methods. In Python 3.0, the `print()` function is typically used as an expression statement. Expressions typed directly into the interactive interpreter are also expression statements.
+
+**Operators and Data Types**:
+The behaviour of an operator depends on the type of object it is applied to. For instance, `+` performs addition on numbers but concatenation on strings, and `*` performs multiplication on numbers but repetition on strings. Some operations like indexing (`[]`) and slicing (`[:]`) are specifically defined for sequence types like strings, lists, and tuples.
+
+**Operator Overloading**:
+Classes in Python can intercept and respond to operators by defining special methods (often starting and ending with double underscores). This is known as **operator overloading**.
+*   For example, defining `__add__(self, other)` in a class allows instances of that class to be used with the `+` operator.
+*   The `__init__` method, called when an object is created (e.g., `X = Class(args)`), is the most commonly used operator overloading method.
+*   Methods like `__getitem__` and `__setitem__` can be defined to support indexing and slicing (`[]`) for custom objects.
+*   `__str__` and `__repr__` handle how objects are displayed when printed or represented.
+*   Methods like `__bool__` or `__len__` (in Python 2.6, `__nonzero__`) determine how an object evaluates in a Boolean context.
+*   Operator overloading is useful when a custom object needs to behave like a built-in type (emulating its interface) or when the operations naturally map to the object's purpose, such as adding vector objects. Python often tries a specific overloading method first and falls back to a more general one if needed; for instance, iteration might try `__iter__` before `__getitem__`, and in-place addition (`+=`) tries `__iadd__` before `__add__`.

content/notes/iit-madras/data-science-and-application/foundational-level/python/week 1/lec1.11.md

@@ -6,4 +6,55 @@ tags:
   - IIT Madras
 excludeSearch: false
 weight: 11
----
+---
+
+Okay, let's delve into strings, drawing from the provided sources and our previous conversation about operators and expressions.
+
+**What are Strings?**
+
+Strings are a fundamental data type in Python used to record textual information as well as arbitrary collections of bytes. They are essentially an ordered collection of characters used to store and represent text-based information. In Python, unlike some other languages, there isn't a separate type for individual characters; instead, you use one-character strings. Strings are a core object type provided by Python.
+
+**Creating Strings (String Literals)**
+
+Strings can be created using literal expressions. Common ways to code strings include using single quotes (`'...'`) or double quotes (`"..."`). Single and double-quoted strings are treated the same.
+
+For special characters, you can use backslash escape sequences, such as `\n` for a newline or `\t` for a tab. Raw strings (`r'...'`) suppress the interpretation of escape sequences. Triple-quoted strings (`"""..."""` or `'''...'''`) can span multiple lines.
+
+In Python 3.0, there's a distinction between text strings (Unicode, represented by the `str` type) and binary data (byte strings, represented by the `bytes` type), although byte strings can reflect encoded Unicode text. Python 2.6 handled strings and Unicode differently, with `str` and `unicode` types.
+
+**Basic String Operations**
+
+Strings support various operations. Some key basic operations include:
+
+*   **Concatenation** (`+`): This operator combines two strings by placing one next to the other. We saw this in our previous discussion on operators, noting that `+` means concatenation for strings. For example, combining the strings "coffee" and "bread" using `+` results in "coffee bread".
+*   **Repetition/Replication** (`*`): This operator repeats a string a specified number of times. We also touched upon this in our last lecture on operators. For example, `'Spam!' * 8` results in `'Spam!Spam!Spam!Spam!Spam!Spam!Spam!Spam!'`. Similarly, if a variable `s` is the string "good", `s * 5` would repeat "good" five times.
+*   **Length** (`len()`): The built-in `len()` function returns the number of characters in a string. For a string with 36 characters, the length is 36.
+*   **Membership** (`in`, `not in`): These operators check if a substring is present within a string.
+*   **Comparison**: Strings can be compared using relational operators like `==`, `!=`, `<`, `>`, `<=`, and `>=`.
+
+**Accessing String Elements: Indexing and Slicing**
+
+Strings are **sequences**, which means their items have a left-to-right positional order and can be accessed by their relative position (offset).
+
+*   **Indexing** (`[]`): You can access individual characters in a string by using the bracket operator with an integer index. Indexing starts at 0 for the first character. For example, `alpha` accesses the first letter, and `alpha` accesses the 11th letter (if 'a' is at index 0, 'k' is at index 10). Similarly, for a string `s`, `s` gives the first letter, `s` the second, and so on. Negative indices can be used to count from the right; `T[-2]` fetches the second to last element.
+*   **Slicing** (`[:]`): You can extract a portion (a substring) of a string using slicing. Slicing fetches sections from the string. For example, `s[1:3]` might extract characters from index 1 up to (but not including) index 3. Extended slicing with a third index allows specifying a "step size", determining how many characters to skip.
+
+**Immutability**
+
+A crucial property of Python strings is that they are **immutable**. This means that once a string object is created, its contents cannot be changed in-place. Operations like concatenation or slicing don't modify the original string; they create *new* string objects. If you need to change a string, you effectively create a new string and reassign it to the variable.
+
+**String Methods**
+
+In addition to basic operations, string objects have a rich set of built-in methods that perform common string-specific tasks. These methods are called using dot notation (e.g., `string_variable.method_name()`). Examples include methods for splitting and joining, case conversions, content tests (`isalnum()`, `isdigit()`, etc.), substring searches (`find()`, `index()`), and replacements.
+
+You can discover the available methods and attributes for a string object using the built-in `dir()` function and get help on what they do using the `help()` function.
+
+**String Formatting**
+
+Python provides ways to format strings, such as using the string formatting operator (`%`) or the string formatting method (`.format()`).
+
+**Strings as Sequences**
+
+As mentioned, strings are a type of sequence. This is important because many operations that work on strings (like indexing, slicing, and iteration) also work on other sequence types such as lists and tuples. We've seen how lists also support concatenation and repetition, similar to strings.
+
+In summary, strings are a fundamental, immutable sequence type in Python used for text, supporting various operations, indexing, slicing, and a wide array of methods for manipulation and processing.