join() tips addition

Author: venopyX

Diff for: Tips & Tricks/Lambda Function.md

@@ -19,31 +19,31 @@ Here's its features and a quick shortcuts to get you up to speed with lambda fun
     return x + y
    ```
 
-3. **Single Expression Only**: Lambda functions can only contain a single expression.
+2. **Single Expression Only**: Lambda functions can only contain a single expression.
 
    Example:
    ```python
    # This lambda function adds 10 to the input number
    add_ten = lambda x: x + 10
    ```
 
-4. **No Statements**: Lambda functions cannot contain statements, only expressions.
+3. **No Statements**: Lambda functions cannot contain statements, only expressions.
 
    Example:
    ```python
    # Incorrect: Lambda functions cannot contain statements like print, because it's assigning obtained value to vaiable.
    greet = lambda name: print(f"Hello, {name}!")
    ```
 
-5. **Anonymous Functions**: Lambda functions are anonymous, meaning they don't have a name.
+4. **Anonymous Functions**: Lambda functions are anonymous, meaning they don't have a name.
 
    Example:
    ```python
    # Anonymous lambda function to check if a number is even
    is_even = lambda x: x % 2 == 0
    ```
 
-6. **Use Cases**: Lambda functions are handy for short, one-off functions, especially when used with functions like `map()`, `filter()`, and `sorted()`.
+5. **Use Cases**: Lambda functions are handy for short, one-off functions, especially when used with functions like `map()`, `filter()`, and `sorted()`.
 
    Example:
    ```python

Diff for: Tips & Tricks/join() usage.md

@@ -0,0 +1,61 @@
+🔓**Python `.join()` Power and Secret Tips/Tricks**:
+
+1. **String Concatenation with `.join()`**: Instead of using `+` for string concatenation, use `.join()` for better performance, especially with large strings.
+   ```python
+   words = ['Hello', 'world', '!']
+   sentence = ' '.join(words)
+   ```
+
+2. **List to String Conversion**: Use `.join()` to convert a list of strings into a single string efficiently.
+   ```python
+   words = ['Python', 'is', 'awesome']
+   sentence = ' '.join(words)
+   ```
+
+3. **Joining Iterable of Integers**: Convert a list of integers to a single string efficiently.
+   ```python
+   numbers = [1, 2, 3, 4, 5]
+   num_string = ''.join(map(str, numbers))
+   ```
+
+4. **Joining Generator Expression**: Utilize a generator expression within `.join()` for memory efficiency.
+   ```python
+   data = ['a' * i for i in range(100000)]
+   result = ''.join(item for item in data)
+   ```
+
+5. **Custom Delimiter**: Specify a custom delimiter other than space for joining elements.
+   ```python
+   words = ['apple', 'banana', 'orange']
+   csv_string = ','.join(words)
+   ```
+
+6. **Joining Nested Lists**: Flatten a nested list efficiently using `.join()` with list comprehension.
+   ```python
+   nested_list = [['a', 'b', 'c'], ['1', '2', '3'], ['x', 'y', 'z']]
+   flat_list = ''.join(item for sublist in nested_list for item in sublist)
+   ```
+
+7. **Joining Lines from File**: Concatenate lines from a file efficiently using `.join()` and file reading.
+   ```python
+   with open('file.txt', 'r') as file:
+       file_content = ''.join(file.readlines())
+   ```
+
+8. **Joining Elements with Formatting**: Apply formatting while joining elements for custom output.
+   ```python
+   data = [('apple', 3), ('banana', 5), ('orange', 2)]
+   output = '\n'.join(f'{item[0]}: {item[1]}' for item in data)
+   ```
+
+9. **Joining Set of Strings**: Join a set of strings while preserving uniqueness and order.
+   ```python
+   unique_words = {'apple', 'banana', 'orange'}
+   sentence = ' '.join(unique_words)
+   ```
+
+10. **Joining with Newline Character**: Concatenate elements with newline character for multiline output.
+    ```python
+    lines = ['First line', 'Second line', 'Third line']
+    multiline_string = '\n'.join(lines)
+    ```