Merge branch 'main' into edit-user-persona

Author: mamtawardhani

content/pandas/concepts/dataframe/terms/join/join.md

@@ -0,0 +1,61 @@
+---
+Title: 'join()'
+Description: 'Combines columns from another DataFrame into the calling DataFrame based on the index or a key column.'
+Subjects:
+  - 'Code Foundations'
+  - 'Computer Science'
+Tags:
+  - 'DataFrame'
+  - 'Join'
+  - 'Pandas'
+  - 'Python'
+CatalogContent:
+  - 'learn-python-3'
+  - 'paths/computer-science'
+---
+
+In Pandas, **`DataFrame.join()`** combines columns from another DataFrame (or multiple DataFrames) into the calling DataFrame based on the index or a key column. It’s mainly used for merging DataFrames with different sets of columns but shared row indices.
+
+## Syntax
+
+```pseudo
+DataFrame.join(other, on=None, how='left', lsuffix='', rsuffix='', sort=False, validate=None)
+```
+
+**Parameters:**
+
+- `other`: Objects to join with the caller DataFrame.
+- `on`: Column(s) in the caller DataFrame to join on; must match the index in `other` if provided.
+- `how`: Type of join to perform — 'left', 'right', 'outer', or 'inner'.
+- `lsuffix`: Suffix to add to overlapping column names from the left DataFrame.
+- `rsuffix`: Suffix to add to overlapping column names from the right DataFrame.
+- `sort`: Sort the result DataFrame by the join keys if True.
+- `validate`: Checks if the join is of a specific type ('one_to_one', 'one_to_many', 'many_to_one', 'many_to_many').
+
+**Return value:**
+
+Returns a new DataFrame with columns of both joined DataFrames combined according to the join logic.
+
+## Example
+
+In this example, a list of words is joined into a single string separated by spaces:
+
+```py
+words = ['Codecademy', 'is', 'awesome']
+result = ' '.join(words)
+print(result)
+```
+
+This code produces the following output:
+
+```shell
+Codecademy is awesome
+```
+
+## Codebyte Example
+
+In this example, a list of characters is joined into a single string separated by commas:
+
+```codebyte/python
+print(','.join(['a', 'b', 'c']))
+```

content/python/concepts/functools-module/terms/singledispatch/singledispatch.md

@@ -0,0 +1,85 @@
+---
+Title: 'singledispatch()'
+Description: 'Turn a function into a single-dispatch generic function, allowing different implementations to be registered based on the type of the first argument.'
+Subjects:
+  - 'Computer Science'
+  - 'Data Science'
+Tags:
+  - 'Function'
+  - 'Decorators'
+CatalogContent:
+  - 'learn-python-3'
+  - 'paths/data-science'
+---
+
+In Python, **`functools.singledispatch`** is a [decorator](https://www.codecademy.com/resources/docs/python/decorators) that converts a [function](https://www.codecademy.com/resources/docs/python/functions) into a generic function(a type single function that can perform different actions depending on the data type of the input it receives) with behavior varying by the type of its first argument. It simplifies type-specific logic by allowing separate implementations to be registered instead of relying on multiple [if statements](https://www.codecademy.com/resources/docs/python/conditionals).
+
+## Syntax
+
+The `singledispatch()` function is included in the `functools` [module](https://www.codecademy.com/resources/docs/python/functools-module):
+
+```py
+@functools.singledispatch
+def func(arg, ...):
+  ...
+```
+
+**Parameters:**
+
+- Takes a single callable (function) as the argument when used as a decorator.
+- The decorated function must accept at least one argument (the one whose type determines dispatch).
+
+**Return value:**
+
+- `singledispatch()` returns a single-dispatch generic function object.
+- Additional implementations can be registered for different types using the .register(type) method on the generic function.
+
+## Example 1: Creat a generic function `process`
+
+This example uses the `singledispatch` decorator to handle different input types in a custom way:
+
+```py
+from functools import singledispatch
+
+@singledispatch
+def process(value):
+  print("Processing:", value)
+
+@process.register(int)
+def _(value):
+  print("Processing an integer:", value)
+
+@process.register(str)
+def _(value):
+  print("Processing a string:", value)
+
+# Function calls
+process(10)
+process("Hello")
+```
+
+Here is the output for this code:
+
+```shell
+Processing an integer: 10
+Processing a string: Hello
+```
+
+## Codebyte Example: Basic type-based greeting
+
+This minimal example shows how `singledispatch()` changes behavior based on the type of its first argument:
+
+```codebyte/python
+from functools import singledispatch
+
+@singledispatch
+def greet(value):
+  print("Hello!")
+
+@greet.register(str)
+def _(value):
+  print(f"Hello, {value}!")
+
+greet("Alice")
+greet(42)
+```

content/python/concepts/functools-module/terms/update-wrapper/update-wrapper.md

@@ -0,0 +1,116 @@
+---
+Title: 'update_wrapper()'
+Description: 'Updates a wrapper function to look like the wrapped function by copying attributes like `__name__`, `__doc__`, and `__module__`.'
+Subjects:
+  - 'Computer Science'
+  - 'Data Science'
+  - 'Web Development'
+Tags:
+  - 'Best Practices'
+  - 'Decorators'
+  - 'Functions'
+  - 'Metadata'
+CatalogContent:
+  - 'learn-python-3'
+  - 'paths/computer-science'
+---
+
+The **`update_wrapper()`** function from the `functools` module updates a wrapper function to look like the wrapped function by copying attributes such as `__name__`, `__doc__`, and `__module__`. This is essential for creating decorators that preserve the original function's metadata, making debugging and introspection much easier.
+
+## Syntax
+
+```pseudo
+from functools import update_wrapper
+
+update_wrapper(wrapper, wrapped, assigned=WRAPPER_ASSIGNMENTS, updated=WRAPPER_UPDATES)
+```
+
+**Parameters:**
+
+- `wrapper`: The function that is acting as a wrapper (e.g., inside a decorator).
+- `wrapped`: The original function being wrapped.
+- `assigned`: A tuple of attribute names to copy (defaults to `WRAPPER_ASSIGNMENTS`).
+- `updated`: A tuple of attribute names to update (defaults to `WRAPPER_UPDATES`).
+
+**Return value:**
+
+The `update_wrapper()` function returns the `wrapper` function itself, after updating it with the attributes of `wrapped`.
+
+## Example
+
+This example demonstrates how `update_wrapper()` preserves the original function's metadata when creating a decorator:
+
+```py
+from functools import update_wrapper
+
+def my_decorator(func):
+  def wrapper(*args, **kwargs):
+    print(f"Calling {func.__name__}")
+    return func(*args, **kwargs)
+
+  # Update the wrapper to look like the original function
+  update_wrapper(wrapper, func)
+  return wrapper
+
+@my_decorator
+def greet(name):
+  """A simple greeting function."""
+  return f"Hello, {name}!"
+
+# Check that metadata is preserved
+print(f"Function name: {greet.__name__}")
+print(f"Function docstring: {greet.__doc__}")
+```
+
+Here is the output:
+
+```shell
+Function name: greet
+Function docstring: A simple greeting function.
+```
+
+## Codebyte Example
+
+This codebyte example shows the difference between using and not using `update_wrapper()`:
+
+```codebyte/python
+from functools import update_wrapper
+
+def decorator_without_update(func):
+  def wrapper(*args, **kwargs):
+    print(f"Executing {func.__name__}")
+    return func(*args, **kwargs)
+  return wrapper
+
+def decorator_with_update(func):
+  def wrapper(*args, **kwargs):
+    print(f"Executing {func.__name__}")
+    return func(*args, **kwargs)
+
+  # This preserves the original function's metadata
+  update_wrapper(wrapper, func)
+  return wrapper
+
+@decorator_without_update
+def function1():
+  """This is function1."""
+  return "Hello from function1"
+
+@decorator_with_update
+def function2():
+  """This is function2."""
+  return "Hello from function2"
+
+# Check metadata preservation
+print("Without update_wrapper:")
+print(f"Name: {function1.__name__}")
+print(f"Docstring: {function1.__doc__}")
+
+print("\nWith update_wrapper:")
+print(f"Name: {function2.__name__}")
+print(f"Docstring: {function2.__doc__}")
+
+# Call the functions
+print(f"\nResult: {function1()}")
+print(f"Result: {function2()}")
+```

content/python/concepts/inheritance/terms/hierarchical-inheritance/hierarchical-inheritance.md

@@ -0,0 +1,126 @@
+---
+Title: 'Hierarchical Inheritance'
+Description: 'Allows multiple subclasses to inherit from the same parent class, enabling shared behavior across different child classes.'
+Subjects:
+  - 'Code Foundations'
+  - 'Computer Science'
+Tags:
+  - 'Classes'
+  - 'Inheritance'
+  - 'OOP'
+CatalogContent:
+  - 'learn-python-3'
+  - 'paths/computer-science'
+---
+
+**Hierarchical inheritance** is a type of [object-oriented programming (OOP)](https://www.codecademy.com/resources/blog/object-oriented-programming) structure where multiple subclasses inherit from a single parent class. Each child class gets access to the shared attributes and methods of the base class, while also defining its own specific behavior.
+
+This approach promotes code reuse and consistency, especially when different classes share core functionality but need their own specialized features.
+
+## Syntax
+
+```pseudo
+class Parent:
+  # Base class with shared behavior
+
+class ChildA(Parent):
+  # Inherits from Parent
+
+class ChildB(Parent):
+  # Also inherits from Parent
+```
+
+Here:
+
+- `Parent`: The superclass that defines common functionality.
+- `ChildA` and `ChildB`: Independent subclasses that derive from the same base.
+
+Each subclass can use the base functionality or override it as needed.
+
+## Example
+
+In this example, `Bird` and `Fish` inherit from the `Animal` class and override the `move()` method to define specific behaviors:
+
+```py
+class Animal:
+  def move(self):
+    return "Moves in some way"
+
+class Bird(Animal):
+  def move(self):
+    return "Flies"
+
+class Fish(Animal):
+  def move(self):
+    return "Swims"
+
+b = Bird()
+f = Fish()
+
+print(b.move())
+print(f.move())
+```
+
+The output of this code is:
+
+```shell
+Flies
+Swims
+```
+
+In this code:
+
+- `Bird` and `Fish` both inherit from the `Animal` class.
+- The `move()` method is overridden in each subclass to define movement specific to that type of animal.
+- This demonstrates how each child can provide its own interpretation of a shared method.
+
+An illustration of how hierarchical inheritance is structured:
+
+```plaintext
+        +-------------+
+        |   Animal    |
+        |-------------|
+        |  move()     |
+        +------+------+
+         /          \
+        ▼            ▼
++-------------+   +-------------+
+|    Bird     |   |    Fish     |
+|-------------|   |-------------|
+|  move()     |   |  move()     |
++-------------+   +-------------+
+```
+
+## Codebyte Example
+
+In this example, `Laptop` and `Desktop` inherit shared functionality from the `Device` class while adding their own unique methods:
+
+```codebyte/python
+class Device:
+  def power(self):
+    return "Powered on"
+
+class Laptop(Device):
+  def feature(self):
+    return "Portable computing"
+
+class Desktop(Device):
+  def feature(self):
+    return "High-performance workstation"
+
+l = Laptop()
+d = Desktop()
+
+print(l.power())      # Inherited from Device
+print(l.feature())    # Specific to Laptop
+print(d.power())      # Inherited from Device
+print(d.feature())    # Specific to Desktop
+```
+
+## Benefits of Hierarchical Inheritance
+
+- **Efficient reuse**: Shared logic is centralized in the parent class.
+- **Cleaner structure**: Each subclass can focus on its unique behavior.
+- **Expandable design**: New types can be introduced without modifying existing code.
+
+> Choose hierarchical inheritance when multiple types share standard features but diverge in implementation.