Update 6. Basic Data Structures.md

Author: venopyX

Python/6. Basic Data Structures.md

@@ -1,5 +1,4 @@
 ## 6. Python Basic Data Structures and Access Methods:
-
 ## 1. Lists:
    - Definition: Lists are ordered collections of items, which can be of any data type. They are mutable, meaning their elements can be changed after creation.
    - Access Methods:
@@ -28,6 +27,35 @@
        my_list.remove(3)  # Removes the first occurrence of 3
        my_list.sort()  # Sorts the list in ascending order
        ```
+   - List Comprehensions: List comprehensions provide a concise way to create lists. They consist of an expression followed by a for clause, then zero or more for or if clauses. 
+     ```python
+     squares = [x**2 for x in range(10)]
+     print(squares)  # Output: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
+     ```
+   - Nested Lists: Lists can contain other lists as elements, enabling the creation of nested data structures.
+     ```python
+     nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+     print(nested_list[1][0])  # Output: 4
+     ```
+   - List Operations: Python supports various operations on lists such as concatenation (`+`), repetition (`*`), membership (`in`), and length (`len()`).
+     ```python
+     list1 = [1, 2, 3]
+     list2 = [4, 5, 6]
+     concatenated_list = list1 + list2
+     print(concatenated_list)  # Output: [1, 2, 3, 4, 5, 6]
+     ```
+   - List Unpacking: Unpack the elements of a list into individual variables.
+     ```python
+     my_list = [1, 2, 3]
+     a, b, c = my_list
+     print(a, b, c)  # Output: 1 2 3
+     ```
+   - List Aliasing vs. Cloning: Understanding the difference between aliasing (multiple names referencing the same list) and cloning (creating a separate copy of a list).
+     ```python
+     original_list = [1, 2, 3]
+     aliased_list = original_list
+     cloned_list = original_list[:]
+     ```
 
 ## 2. Tuples:
    - Definition: Tuples are similar to lists but are immutable, meaning their elements cannot be changed after creation.
@@ -42,6 +70,23 @@
        my_tuple = (1, 2, 3, 4, 5)
        print(my_tuple[1:4])  # Output: (2, 3, 4)
        ```
+   - Tuple Packing and Unpacking: Tuples can be created without parentheses by simply separating the values with commas. Tuple unpacking allows assigning multiple variables at once.
+     ```python
+     my_tuple = 1, 2, 3  # Tuple packing
+     a, b, c = my_tuple  # Tuple unpacking
+     print(a, b, c)  # Output: 1 2 3
+     ```
+   - Tuple Methods: While tuples are immutable, they have a few methods like `count()` and `index()` for basic operations.
+     ```python
+     my_tuple = (1, 2, 2, 3, 4, 5)
+     print(my_tuple.count(2))  # Output: 2 (count occurrences of 2)
+     print(my_tuple.index(4))  # Output: 4 (get index of the first occurrence of 4)
+     ```
+   - Advantages of Tuples: Tuples offer advantages such as immutability (data integrity), faster iteration, and being used as dictionary keys.
+   - Use Cases: Tuples are often used for representing fixed collections of items, such as coordinates, database records, and function return values.
+   - Immutable vs. Mutable: Understanding the difference between immutable objects like tuples and mutable objects like lists is crucial for designing efficient and reliable programs.
+
+     
 
 ## 3. Dictionaries:
    - Definition: Dictionaries are unordered collections of key-value pairs. They are mutable and indexed by unique keys.
@@ -56,6 +101,42 @@
        my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}
        print(my_dict.keys())  # Output: dict_keys(['name', 'age', 'city'])
        ```
+   - Adding and Modifying Items: Dictionaries allow adding new key-value pairs or modifying existing ones using assignment.
+     ```python
+     my_dict = {'name': 'John', 'age': 30}
+     my_dict['city'] = 'New York'  # Add a new key-value pair
+     my_dict['age'] = 31  # Modify the value of an existing key
+     ```
+   - Removing Items: Use the `pop()` method to remove a specific key-value pair or the `clear()` method to remove all items.
+     ```python
+     my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}
+     my_dict.pop('age')  # Remove the key-value pair with the key 'age'
+     my_dict.clear()  # Remove all items from the dictionary
+     ```
+   - Dictionary Comprehensions: Similar to list comprehensions, dictionary comprehensions allow creating dictionaries in a concise manner.
+     ```python
+     squares = {x: x**2 for x in range(5)}
+     print(squares)  # Output: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
+     ```
+   - Nested Dictionaries: Dictionaries can contain other dictionaries as values, enabling the creation of nested data structures.
+     ```python
+     student = {
+         'name': 'John',
+         'age': 30,
+         'address': {
+             'city': 'New York',
+             'zip': '10001'
+         }
+     }
+     print(student['address']['city'])  # Output: New York
+     ```
+   - Dictionary Aliasing vs. Cloning: Similar to lists, dictionaries can be aliased or cloned, leading to different behaviors.
+     ```python
+     original_dict = {'name': 'John', 'age': 30}
+     aliased_dict = original_dict
+     cloned_dict = original_dict.copy()
+     ```
+
 
 ## 4. Sets:
    - Definition: Sets are unordered collections of unique elements. They are mutable but do not support duplicate elements.
@@ -71,26 +152,33 @@
        my_set.add(4)  # Adds 4 to the set
        my_set.remove(2)  # Removes 2 from the set
        ```
-## 5. Strings:
-   - Definition: Strings are immutable sequences of characters. They can be accessed and manipulated using various methods.
-   - Access Methods:
-     - Indexing: Access individual characters using their indices.
-       ```python
-       my_string = "Hello"
-       print(my_string[0])  # Output: H
-       ```
-     - Slicing: Extract substrings using slicing notation.
-       ```python
-       my_string = "Hello"
-       print(my_string[1:3])  # Output: el
-       ```
-     - String Methods: Python provides numerous methods to manipulate strings such as `upper()`, `lower()`, `split()`, `join()`, `strip()`, `replace()`, etc.
-       ```python
-       my_string = "Hello, world"
-       print(my_string.upper())  # Output: HELLO, WORLD
-       ```
+   - Set Operations: Sets support various operations such as union, intersection, difference, and symmetric difference.
+     ```python
+     set1 = {1, 2, 3}
+     set2 = {3, 4, 5}
+     union_set = set1.union(set2)  # Union of set1 and set2
+     intersection_set = set1.intersection(set2)  # Intersection of set1 and set2
+     difference_set = set1.difference(set2)  # Elements in set1 but not in set2
+     symmetric_difference_set = set1.symmetric_difference(set2)  # Elements in either set1 or set2 but not both
+     ```
+   - Set Comprehensions: Similar to list and dictionary comprehensions, set comprehensions allow creating sets in a concise manner.
+     ```python
+     squares = {x**2 for x in range(5)}
+     print(squares)  # Output: {0, 1, 4, 9, 16}
+     ```
+   - Frozen Sets: Frozen sets are immutable counterparts of sets and can be used as dictionary keys or elements of another set.
+     ```python
+     my_set = frozenset([1, 2, 3])
+     ```
+   - Use Cases: Sets are useful for tasks that involve checking for uniqueness or performing mathematical set operations.
+   - Set Aliasing vs. Cloning: Like other mutable objects, sets can be aliased or cloned, resulting in different behaviors.
+     ```python
+     original_set = {1, 2, 3}
+     aliased_set = original_set
+     cloned_set = original_set.copy()
+     ```
 
-## 6. Arrays:
+## 5. Arrays:
    - Definition: Arrays in Python are data structures used to store collections of elements. Unlike lists, arrays can only store elements of the same data type. Arrays are created using the `array` module.
    - Access Methods:
        1. Indexing: Access individual elements using their indices.
@@ -124,6 +212,84 @@
          arr.append(6)
          print(arr)  # Output: array('i', [1, 2, 3, 4, 5, 6])
          ```
+   - Multi-dimensional Arrays: Arrays can be multi-dimensional, allowing the storage of data in multiple dimensions, such as matrices.
+      ```python
+      from array import array
+
+      arr = array('i', [[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+      print(arr[1][2])  # Output: 6
+      ```
+
+   - Array Methods: In addition to basic methods like `append()` and `extend()`, arrays support methods such as `fromlist()` and `tolist()` for conversion between arrays and lists.
+      ```python
+      from array import array
+
+      arr = array('i', [1, 2, 3])
+      list_representation = arr.tolist()  # Convert array to list
+      print(list_representation)  # Output: [1, 2, 3]
+      ```
+
+   - Advantages of Arrays: Arrays are advantageous for numerical computations and memory efficiency due to their fixed type and contiguous memory allocation.
+   
+   - Limitations: Arrays in Python are less flexible than lists because they can only store elements of the same data type and have a fixed size upon creation.
+   
+   - Use Cases: Arrays are commonly used in numerical computations, scientific computing, and implementing algorithms that require fixed-size data structures.
+
+
+## 6. Strings:
+   - Definition: Strings are immutable sequences of characters. They can be accessed and manipulated using various methods.
+   - Access Methods:
+     - Indexing: Access individual characters using their indices.
+       ```python
+       my_string = "Hello"
+       print(my_string[0])  # Output: H
+       ```
+     - Slicing: Extract substrings using slicing notation.
+       ```python
+       my_string = "Hello"
+       print(my_string[1:3])  # Output: el
+       ```
+     - String Methods: Python provides numerous methods to manipulate strings such as `upper()`, `lower()`, `split()`, `join()`, `strip()`, `replace()`, etc.
+       ```python
+       my_string = "Hello, world"
+       print(my_string.upper())  # Output: HELLO, WORLD
+       ```
+   - String Formatting: Strings support various formatting options such as `%` formatting, `str.format()`, and f-strings (formatted string literals).
+     ```python
+     name = "John"
+     age = 30
+     print("My name is %s and I am %d years old." % (name, age))
+     print("My name is {} and I am {} years old.".format(name, age))
+     print(f"My name is {name} and I am {age} years old.")
+     ```
+   - String Concatenation: Combine strings using the `+` operator or the `join()` method for efficiency.
+     ```python
+     str1 = "Hello"
+     str2 = "world"
+     concatenated_str = str1 + ", " + str2
+     efficient_concatenation = ", ".join([str1, str2])
+     ```
+   - String Interpolation: Embed expressions within strings using f-strings or the `format()` method.
+     ```python
+     price = 10
+     quantity = 5
+     print(f"Total cost: ${price * quantity}")
+     print("Total cost: ${}".format(price * quantity))
+     ```
+   - String Operations: Strings support operations such as concatenation (`+`), repetition (`*`), membership (`in`), and length (`len()`).
+     ```python
+     str1 = "Hello"
+     str2 = "world"
+     concatenated_str = str1 + " " + str2
+     print(len(concatenated_str))  # Output: 11
+     ```
+   - Escape Characters: Use escape characters such as `\n` (newline), `\t` (tab), and `\\` (backslash) to include special characters in strings.
+     ```python
+     print("Hello\nworld")
+     print("This is a\ttab")
+     print("C:\\path\\to\\file")
+     ```
+
 
 ## Difference between Data Structures: