Merge pull request #5 from gauravfs-14/main

[Add]: Strings, Numeric Representation

Author: gauravfs-14

docs/python-basics/numeric-representation.md

@@ -0,0 +1,120 @@
+---
+sidebar_position: 5
+---
+
+# Numeric Representation
+
+Python supports different ways of representing numbers, including integer and real (floating point) numbers.
+
+## Integer Types (int)
+
+Integers in Python can be represented in various numerical systems:
+
+- **Decimal Notation (Base 10):**
+
+  - This is the default way we represent numbers, such as `3` or `-89`.
+
+- **Binary Notation (Base 2):**
+
+  - Represented using a prefix of `0b`. It consists only of `0` and `1`.
+  - Example: `0b1011` is equivalent to `11` in decimal.
+
+- **Octal Notation (Base 8):**
+
+  - Represented using a prefix of `0o`. It uses digits from `0` to `7`.
+  - Example: `0o12` is equivalent to `10` in decimal.
+
+- **Hexadecimal Notation (Base 16):**
+  - Represented using a prefix of `0x`. It uses digits from `0` to `9` and letters `A` to `F` to represent values `10` to `15`.
+  - Example: `0x2B` is equivalent to `43` in decimal.
+
+### Conversion between Notations
+
+- To **convert binary to decimal**, sum each digit multiplied by `2` raised to the power of its position, starting from `0` on the right.
+
+  - Example: `0b1011` in decimal is calculated as:
+    - \( 1 \times 2^3 + 0 \times 2^2 + 1 \times 2^1 + 1 \times 2^0 = 8 + 0 + 2 + 1 = 11 \)
+
+- To **convert octal to decimal**, use powers of `8`.
+
+  - Example: `0o52` in decimal is calculated as:
+    - \( 5 \times 8^1 + 2 \times 8^0 = 40 + 2 = 42 \)
+
+- To **convert hexadecimal to decimal**, use powers of `16`.
+  - Example: `0x2B` in decimal is calculated as:
+    - \( 2 \times 16^1 + 11 \times 16^0 = 32 + 11 = 43 \)
+
+Python can perform these conversions using built-in functions:
+
+- `bin(value)` returns the binary representation as a string.
+- `oct(value)` returns the octal representation as a string.
+- `hex(value)` returns the hexadecimal representation as a string.
+
+To **convert a string representation** back to an integer, use the `int()` function.
+
+- Example: `int("0b1011", 2)` converts the binary string to decimal.
+
+### Integer Variables in Different Notations
+
+When working with different notations, Python internally treats the value as an integer regardless of how it is expressed.
+
+- Example:
+  ```python title="numbers.py"
+  a = 10
+  b = 0b1010
+  c = 0o12
+  d = 0xA
+  print(a, b, c, d)  # Outputs: 10 10 10 10
+  ```
+  All four variables have the same value, `10`, but are written in different notations.
+
+## Floating-Point Numbers (float)
+
+Floating-point numbers represent real numbers and can have a fractional part.
+
+- **Standard Notation:**
+
+  - Examples: `3.0`, `-89.14`.
+
+- **Scientific Notation:**
+  - Represented using `e` or `E` to indicate powers of `10`.
+  - Example: `1.5e3` is equivalent to \( 1.5 \times 10^3 = 1500 \).
+
+### Precision Issues with Floating-Point Numbers
+
+- Floating-point numbers may have **precision issues** because they cannot precisely represent all real numbers due to limitations in memory representation.
+- Example:
+  ```python title="numbers.py"
+  a = 0.1
+  b = 0.2
+  sum = a + b
+  print("The sum is", sum)  # Outputs: The sum is 0.30000000000000004
+  ```
+  Instead of `0.3`, Python returns a value close to `0.3` due to rounding errors in binary representation.
+
+### Addressing Precision Issues
+
+- For cases where precision is critical (e.g., financial calculations), Python provides the `decimal` module, which offers more accurate representation and operations. This module is beyond the scope of the video.
+
+## Practical Examples
+
+- **Printing Variables in Different Notations:**
+
+  ```python title="numbers.py"
+  a = 10
+  b = 0b1010
+  c = 0o12
+  d = 0xA
+  print(bin(a), oct(b), hex(c), hex(d))  # Outputs: 0b1010 0o12 0xa 0xa
+  ```
+
+  This example prints the binary, octal, and hexadecimal representations of the value `10`.
+
+- **Floating-Point Precision Example:**
+  ```python title="numbers.py"
+  a = 0.1
+  b = 0.2
+  sum = a + b
+  print(f"The sum is approximately: {sum:.2f}")  # Outputs: The sum is approximately: 0.30
+  ```
+  By formatting the output, we can display the sum as `0.30`, but the underlying value still contains precision errors.

docs/python-basics/stings.md

@@ -0,0 +1,152 @@
+---
+sidebar_position: 6
+---
+
+# Strings
+
+## Definition of a String
+
+- A **string** is a sequence of characters, essentially text data. In Python, a string is represented by enclosing characters within either **single** (`'`) or **double quotes** (`"`).
+- Example:
+  ```python title="strings.py"
+  name = "John"
+  greeting = 'Hello, world!'
+  ```
+
+## Creating Strings
+
+- Strings can be assigned to variables:
+  ```python title="strings.py"
+  city = "San Francisco"
+  ```
+- **Double vs. Single Quotes**:
+  - You can use both single or double quotes to create strings.
+  - The opening and closing quotes must match.
+  - Example:
+    ```python title="strings.py"
+    sentence = 'It\'s a sunny day'
+    # Alternatively, using double quotes avoids the need to escape the single quote:
+    sentence = "It's a sunny day"
+    ```
+
+## Multi-line Strings
+
+- For **multi-line strings**, use **triple quotes** (`'''` or `"""`).
+- Example:
+  ```python title="strings.py"
+  address = """123 Elm Street
+  Springfield
+  USA"""
+  ```
+- This allows the string to span multiple lines.
+
+## String Concatenation
+
+- You can **concatenate** (join) strings using the **`+` operator**:
+  ```python title="strings.py"
+  full_name = "John" + " " + "Doe"
+  # Output: "John Doe"
+  ```
+- Note that **spaces** between words must be explicitly added, as shown.
+
+## String Length
+
+- Use the **`len()` function** to get the length of a string:
+  ```python title="strings.py"
+  length = len(full_name)
+  print("Length of the full name:", length)
+  # Output: 8
+  ```
+
+## String Repetition
+
+- You can **repeat** a string using the `*` operator:
+  ```python title="strings.py"
+  dash_line = "-" * 5
+  # Output: "-----"
+  ```
+
+## String Methods
+
+- **`upper()`**: Converts all characters to uppercase.
+  ```python title="strings.py"
+  greeting = "hello"
+  print(greeting.upper())  # Output: "HELLO"
+  ```
+- **`lower()`**: Converts all characters to lowercase.
+  ```python title="strings.py"
+  print(greeting.lower())  # Output: "hello"
+  ```
+- **`title()`**: Converts the first character of each word to uppercase.
+  ```python title="strings.py"
+  title_greeting = "welcome to python"
+  print(title_greeting.title())  # Output: "Welcome To Python"
+  ```
+
+## Whitespace Removal
+
+- **`strip()`**: Removes leading and trailing whitespace.
+  ```python title="strings.py"
+  spaced_string = "  Hello  "
+  print(spaced_string.strip())  # Output: "Hello"
+  ```
+- **`lstrip()`**: Removes leading whitespace only.
+- **`rstrip()`**: Removes trailing whitespace only.
+
+## Replacing Substrings
+
+- **`replace(old, new)`**: Replaces all occurrences of `old` with `new` in the string.
+  ```python title="strings.py"
+  text = "I like apples"
+  new_text = text.replace("apples", "bananas")
+  print(new_text)  # Output: "I like bananas"
+  ```
+
+## Finding Substrings
+
+- **`count(sub)`**: Counts how many times a substring appears in the string.
+  ```python title="strings.py"
+  phrase = "banana"
+  print(phrase.count("a"))  # Output: 3
+  ```
+- **`find(sub)`**: Returns the index of the first occurrence of the substring. If not found, returns `-1`.
+  ```python title="strings.py"
+  print(phrase.find("na"))  # Output: 2
+  ```
+
+## Accessing Characters in a String
+
+- You can **access individual characters** in a string using **indexing** with square brackets.
+- **Index starts at `0`** (first character):
+  ```python title="strings.py"
+  first_char = phrase[0]  # Output: 'b'
+  ```
+- **Negative indexing** starts from the end:
+  ```python title="strings.py"
+  last_char = phrase[-1]  # Output: 'a'
+  ```
+
+## Comments and Disabling Code
+
+- Use the **`#` symbol** to add comments to your code.
+- Example:
+  ```python title="strings.py"
+  # This is a comment
+  print("Hello, World!")  # This line prints a greeting
+  ```
+- You can **comment out lines of code** to prevent them from executing, especially useful during debugging:
+  ```python title="strings.py"
+  # print("This line won't run")
+  print("This line will run")
+  ```
+
+## String Slicing
+
+- You can extract **substrings** using slicing syntax `[start:end]`:
+  ```python title="strings.py"
+  text = "Python programming"
+  sub_text = text[0:6]  # Output: "Python"
+  ```
+- **`start`** is inclusive, **`end`** is exclusive.
+
+This overview gives a foundational understanding of working with strings in Python, covering creating, manipulating, and accessing string data effectively.