Merge branch 'main' into add-data-visualization-in-UX

Author: AnamolR

content/c-sharp/concepts/lists/lists.md

@@ -0,0 +1,96 @@
+---
+Title: 'Lists'
+Description: 'A List in C# is a dynamic data structure that stores multiple objects of a specified type.'
+Subjects:
+  - 'Computer Science'
+  - 'Code Foundations'
+  - 'Developer Tools'
+Tags:
+  - 'Data Structures'
+  - 'Lists'
+CatalogContent:
+  - 'learn-c-sharp'
+  - 'paths/computer-science'
+---
+
+A **`List`** in [C#](https://www.codecademy.com/resources/docs/c-sharp) is a dynamic [data structure](https://www.codecademy.com/resources/docs/general/data-structures) that stores multiple objects of a specified type. These objects can be accessed by their zero-based index. Unlike [arrays](https://www.codecademy.com/resources/docs/c-sharp/arrays). Lists can grow to accommodate a very large number of elements (up to about 2 billion), limited primarily by available system memory and the maximum value of an integer index."
+
+## Syntax
+
+> **Note:** Before creating a list, include the `System.Collections.Generic` namespace.
+
+There are two common ways to create a `List` in C#:
+
+```pseudo
+// Creating a List without any elements
+List<T> myList = new List<T>();
+```
+
+Or alternatively:
+
+```pseudo
+// Creating a List with three elements
+List<T> myList = new List<T> { element1, element2, element3 };
+```
+
+**Parameters:**
+
+- `T`: Represents any data type.
+- `element`: Any object or variable of type `T`.
+
+## Example: Creating and Accessing a List
+
+In this example, a list is created, numbers are added, and elements are accessed by their index:
+
+```cs
+using System;
+using System.Collections.Generic;
+
+class Program
+{
+  static void Main()
+  {
+    // Create a list of integers
+    List<int> numbers = new List<int>();
+
+    // Add elements to the list
+    numbers.Add(10);
+    numbers.Add(20);
+    numbers.Add(30);
+
+    // Access elements by index
+    Console.WriteLine(numbers[0]);
+    Console.WriteLine(numbers[1]);
+    Console.WriteLine(numbers[2]);
+  }
+}
+```
+
+The output of this code is:
+
+```shell
+10
+20
+30
+```
+
+## Codebyte Example: Printing elements in a List
+
+This example creates a new `List` that stores three numbers. Since each element has an index, we can print each element in the `numbers` list by its index:
+
+```codebyte/csharp
+using System;
+using System.Collections.Generic;
+
+public class Test
+{
+  public static void Main()
+  {
+    List<int> numbers = new List<int> { 2, 5, 10 };
+
+    Console.WriteLine(numbers[0]);
+    Console.WriteLine(numbers[1]);
+    Console.WriteLine(numbers[2]);
+  }
+}
+```

content/java/concepts/strings/terms/equals/equals.md

@@ -36,8 +36,8 @@ public class MyClass {
 
     // With string objects
     String myFavoriteLanguage = "Java";
-    String codeNinjasFavoriteLangauge = "Java";
-    System.out.println(myFavoriteLanguage.equals(codeNinjasFavoriteLangauge));
+    String codeNinjasFavoriteLanguage = "Java";
+    System.out.println(myFavoriteLanguage.equals(codeNinjasFavoriteLanguage));
   }
 }
 ```

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()}")
+```