diff --git a/tech_docs/arrays.md b/tech_docs/arrays.md new file mode 100644 index 0000000..a54a3a8 --- /dev/null +++ b/tech_docs/arrays.md @@ -0,0 +1,58 @@ +Certainly! In Python, array sequences are data structures that store a collection of elements in a specific order. The three main built-in array sequence types in Python are lists, tuples, and strings. Let's explore each of them: + +1. Lists (square brackets `[]`): + - Lists are mutable, meaning you can modify, add, or remove elements after creation. + - Elements in a list can be of different data types (e.g., integers, strings, objects). + - Lists are defined using square brackets `[]` and elements are separated by commas. + - Example: + ```python + my_list = [1, 2, 3, "apple", True] + ``` + +2. Tuples (parentheses `()`): + - Tuples are immutable, meaning you cannot modify them once they are created. + - Elements in a tuple can be of different data types, similar to lists. + - Tuples are defined using parentheses `()` and elements are separated by commas. + - Example: + ```python + my_tuple = (1, 2, 3, "apple", True) + ``` + +3. Strings (double quotes `""`): + - Strings are immutable sequences of characters. + - They are defined using either single quotes `''` or double quotes `""`. + - Example: + ```python + my_string = "Hello, World!" + ``` + +Indexing: +All three array sequence types support indexing, which allows you to access individual elements within the sequence using their position or index. In Python, indexing starts from 0. + +Example: +```python +my_list = [1, 2, 3, 4, 5] +print(my_list[0]) # Output: 1 +print(my_list[2]) # Output: 3 + +my_tuple = (1, 2, 3, 4, 5) +print(my_tuple[1]) # Output: 2 +print(my_tuple[4]) # Output: 5 + +my_string = "Hello" +print(my_string[0]) # Output: 'H' +print(my_string[4]) # Output: 'o' +``` + +You can also use negative indexing to access elements from the end of the sequence. For example, `-1` refers to the last element, `-2` refers to the second-to-last element, and so on. + +Example: +```python +my_list = [1, 2, 3, 4, 5] +print(my_list[-1]) # Output: 5 +print(my_list[-3]) # Output: 3 +``` + +In addition to indexing, array sequences in Python support various operations like slicing (extracting a portion of the sequence), concatenation (joining sequences together), and more. + +I hope this helps you understand array sequences, lists, tuples, strings, and indexing in Python better! Let me know if you have any further questions. diff --git a/tech_docs/indexing.md b/tech_docs/indexing.md new file mode 100644 index 0000000..537df9e --- /dev/null +++ b/tech_docs/indexing.md @@ -0,0 +1,57 @@ +Certainly! Indexing is a fundamental operation in Python that allows you to access individual elements within an array sequence (such as a list, tuple, or string) based on their position. It is useful in various scenarios: + +1. Accessing specific elements: + - When you have an array sequence and need to retrieve a specific element, indexing allows you to directly access that element using its position. + - Example: + ```python + my_list = [10, 20, 30, 40, 50] + first_element = my_list[0] # Accessing the first element + third_element = my_list[2] # Accessing the third element + ``` + +2. Modifying elements (for mutable sequences like lists): + - Indexing allows you to modify specific elements within a mutable sequence by assigning a new value to the desired position. + - Example: + ```python + my_list = [10, 20, 30, 40, 50] + my_list[1] = 25 # Modifying the second element + ``` + +3. Iterating over elements: + - Indexing is often used in combination with loops to iterate over the elements of an array sequence. + - Example: + ```python + my_list = [10, 20, 30, 40, 50] + for i in range(len(my_list)): + print(my_list[i]) + ``` + +4. Slicing: + - Indexing is used to define slices, which allow you to extract a portion of an array sequence. + - Slicing is done using the syntax `sequence[start:end:step]`, where `start` is the starting index (inclusive), `end` is the ending index (exclusive), and `step` is the stride or step size. + - Example: + ```python + my_list = [10, 20, 30, 40, 50] + subset = my_list[1:4] # Extracting elements from index 1 to 3 + ``` + +5. Checking membership: + - Indexing can be used in combination with conditional statements to check if an element exists at a specific position within an array sequence. + - Example: + ```python + my_list = [10, 20, 30, 40, 50] + if my_list[2] == 30: + print("The third element is 30") + ``` + +6. Accessing characters in strings: + - Since strings are also array sequences, indexing allows you to access individual characters within a string. + - Example: + ```python + my_string = "Hello" + first_char = my_string[0] # Accessing the first character + ``` + +These are just a few examples of how indexing is useful in Python. Indexing is a fundamental operation that is widely used in various scenarios when working with array sequences. It provides a way to directly access, modify, and manipulate elements based on their position within the sequence. + +Indexing is efficient in Python because array sequences are implemented as contiguous blocks of memory, allowing for fast access to elements based on their index. This makes indexing a valuable tool for performing operations on array sequences efficiently.