Merge branch 'Codecademy:main' into main

Author: mamtawardhani

content/matplotlib/concepts/pyplot/terms/stackplot/stackplot.md

@@ -0,0 +1,103 @@
+---
+Title: '.stackplot()'
+Description: 'Creates a stacked area plot to show how multiple datasets contribute cumulatively over time or categories.'
+Subjects:
+  - 'Data Science'
+  - 'Data Visualization'
+Tags:
+  - 'Charts'
+  - 'Matplotlib'
+  - 'Stacks'
+CatalogContent:
+  - 'learn-python-3'
+  - 'paths/data-science'
+---
+
+The **`.stackplot()`** method in Matplotlib creates stacked area plots (also known as stacked area charts) that display multiple datasets as vertically stacked areas. Each area represents the cumulative contribution of different categories to a total, making it ideal for visualizing proportional relationships as those relationships change over time.
+
+## Syntax
+
+```pseudo
+matplotlib.pyplot.stackplot(x, *args, labels=(), colors=None, hatch=None, baseline='zero', data=None, **kwargs)
+```
+
+**Parameters:**
+
+- `x`: Array-like. The x-coordinates of the data points.
+- `*args`: One or more array-like sequences representing the y-values for each stack layer.
+- `labels`: List of strings, optional. Labels for each stack layer (used in legends).
+- `colors`: List of colors or color specifications for each stack layer.
+- `hatch`: String or sequence, optional. Hatching patterns applied to the filled areas.
+- `baseline`: String, defines the baseline for stacking:
+  - `'zero'` (default): Stack from y = 0.
+  - `'sym'`: Symmetric stacking around zero.
+  - `'wiggle'`: Minimizes slope changes between layers.
+  - `'weighted_wiggle'`: Weighted version of the wiggle baseline.
+- `data`: Object with labeled data (e.g., dict or DataFrame). Optional data source.
+- `**kwargs`: Additional keyword arguments passed to `PolyCollection` (e.g., `alpha` for transparency).
+
+**Return value:**
+
+Returns a list of `PolyCollection` objects, one for each stack layer.
+
+## Example 1: Visualizing Monthly Sales by Category
+
+This example shows a stacked area chart of sales data across product categories over time:
+
+```py
+import matplotlib.pyplot as plt
+
+# Sample data
+months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun']
+electronics = [20, 25, 30, 28, 35, 40]
+clothing = [15, 18, 22, 25, 20, 30]
+books = [10, 12, 15, 18, 22, 25]
+
+# Create stacked area plot
+plt.stackplot(months, electronics, clothing, books,
+  labels=['Electronics', 'Clothing', 'Books'],
+  colors=['#ff9999', '#66b3ff', '#99ff99'],
+  alpha=0.8)
+
+plt.xlabel('Month')
+plt.ylabel('Sales (in thousands)')
+plt.title('Monthly Sales by Category')
+plt.legend(loc='upper left')
+plt.show()
+```
+
+This creates a stacked area chart where each colored area represents a product category's contribution to total sales:
+
+![Stackplot Example](https://raw.githubusercontent.com/Codecademy/docs/main/media/stackplot-example.png)
+
+## Example 2: Stacked Areas with Multiple Series
+
+This example demonstrates stacking multiple data series using numeric values:
+
+```py
+import matplotlib.pyplot as plt
+import numpy as np
+
+# Create sample data
+x = [1, 2, 3, 4, 5]
+y1 = [1, 2, 3, 2, 1]
+y2 = [2, 3, 2, 4, 3]
+y3 = [1, 1, 2, 1, 2]
+
+# Create stackplot
+plt.stackplot(x, y1, y2, y3,
+  labels=['Series A', 'Series B', 'Series C'],
+  colors=['lightcoral', 'lightblue', 'lightgreen'],
+  alpha=0.8)
+
+plt.xlabel('X Values')
+plt.ylabel('Y Values')
+plt.title('Basic Stackplot Example')
+plt.legend(loc='upper left')
+plt.grid(True, alpha=0.3)
+plt.show()
+```
+
+This creates a basic stacked area plot with three data series, demonstrating the fundamental structure of stackplot visualizations:
+
+![Stackplot Example 2](https://raw.githubusercontent.com/Codecademy/docs/main/media/stackplot-example-2.png)

content/numpy/concepts/ndarray/terms/cumprod/cumprod.md

@@ -0,0 +1,117 @@
+---
+Title: '.cumprod()'
+Description: 'Returns the cumulative product of array elements along a specified axis.'
+Subjects:
+  - 'Computer Science'
+  - 'Data Science'
+Tags:
+  - 'Arrays'
+  - 'Linear Algebra'
+  - 'Matrices'
+  - 'NumPy'
+CatalogContent:
+  - 'learn-python-3'
+  - 'paths/data-science'
+---
+
+In NumPy, the **`.cumprod()`** method returns the cumulative product of the array elements over a particular axis. This method belongs to the `ndarray` class.
+
+## Syntax
+
+```pseudo
+ndarray.cumprod(axis=None, dtype=None, out=None)
+```
+
+**Parameters:**
+
+- `axis` (optional): Axis along which the cumulative product is computed. The default (None) flattens the array.
+- `dtype` (optional): The data type of the output array. Useful when input elements are of smaller types and may overflow.
+- `out` (optional): An alternative output array where results will be stored. It must have the same shape as the expected output.
+
+**Return value:**
+
+Returns a new array that contains the cumulative product of elements along the specified axis. If `out` is provided, the result is placed into it.
+
+## Example 1: Cumulative Product of a 1D Array
+
+This example computes the cumulative product of all elements in a one-dimensional array:
+
+```py
+import numpy as np
+
+a = np.array([1, 2, 3, 4])
+print("Original array:", a)
+
+result = a.cumprod()
+print("Cumulative product:", result)
+```
+
+The output of this code is:
+
+```shell
+Original array: [1 2 3 4]
+Cumulative product: [ 1  2  6 24]
+```
+
+Each element in the output represents the product of all elements up to that index in the input array.
+
+## Example 2: Cumulative Product Along Different Axes
+
+This example shows how `.cumprod()` behaves when applied across rows and columns of a 2D array:
+
+```py
+import numpy as np
+
+b = np.array([[1, 2, 3],
+              [4, 5, 6]])
+
+print("Original array:")
+print(b)
+
+# Cumulative product along rows (axis=1)
+row_cumprod = b.cumprod(axis=1)
+print("\nCumulative product along rows (axis=1):")
+print(row_cumprod)
+
+# Cumulative product along columns (axis=0)
+col_cumprod = b.cumprod(axis=0)
+print("\nCumulative product along columns (axis=0):")
+print(col_cumprod)
+```
+
+The output of this code is:
+
+```shell
+Original array:
+[[1 2 3]
+ [4 5 6]]
+
+Cumulative product along rows (axis=1):
+[[  1   2   6]
+ [  4  20 120]]
+
+Cumulative product along columns (axis=0):
+[[ 1  2  3]
+ [ 4 10 18]]
+```
+
+- When `axis=1`, the cumulative product is computed across each row.
+- When `axis=0`, it’s computed down each column.
+
+## Codebyte Example
+
+Run this interactive example to experiment with `.cumprod()` on a 2D array:
+
+```codebyte/python
+import numpy as np
+
+a = np.array([[2, 3, 4],
+              [5, 6, 7]])
+
+print("Original array:")
+print(a)
+
+print("\nCumulative product (flattened):", a.cumprod())
+print("\nCumulative product along axis=0:\n", a.cumprod(axis=0))
+print("\nCumulative product along axis=1:\n", a.cumprod(axis=1))
+```

content/numpy/concepts/ndarray/terms/diagonal/diagonal.md

@@ -0,0 +1,165 @@
+---
+Title: '.diagonal()'
+Description: 'Returns the specified diagonal elements of an array.'
+Subjects:
+  - 'Computer Science'
+  - 'Data Science'
+Tags:
+  - 'Arrays'
+  - 'Linear Algebra'
+  - 'Matrices'
+  - 'NumPy'
+CatalogContent:
+  - 'learn-python-3'
+  - 'paths/data-science'
+---
+
+The **`.diagonal()`** method returns the specified diagonal elements of a NumPy array. For 2D arrays, the diagonal consists of elements where the row index equals the column index (or with an offset). For multi-dimensional arrays, the axes specified by `axis1` and `axis2` define the matrix dimensions from which to extract the diagonal.
+
+Unlike [`.trace()`](https://www.codecademy.com/resources/docs/numpy/ndarray/trace), which returns the sum of diagonal elements, `.diagonal()` returns the actual diagonal elements as an array. This method typically returns a view rather than a copy, making it memory-efficient for large arrays.
+
+## Syntax
+
+```pseudo
+ndarray.diagonal(offset=0, axis1=0, axis2=1)
+```
+
+**Parameters:**
+
+- `offset` (Optional): The diagonal offset from the main diagonal. A positive value selects a diagonal above the main diagonal, while a negative value selects one below. Default is `0` (main diagonal).
+- `axis1` (Optional): The axis to be used as the first axis of the 2D sub-arrays from which the diagonals should be taken. Default is `0`.
+- `axis2` (Optional): The axis to be used as the second axis of the 2D sub-arrays from which the diagonals should be taken. Default is `1`.
+
+**Return value:**
+
+Returns an array containing the diagonal elements. For 2D arrays, this is a 1D array. For higher-dimensional arrays, the result has one fewer dimension than the input.
+
+## Example 1: Extracting Diagonals from 2D and Rectangular Arrays
+
+This example demonstrates how to extract diagonals from both square and rectangular arrays using different `offset` values:
+
+```py
+import numpy as np
+
+# Create a 3×3 square array
+square = np.array([[1, 2, 3],
+                   [4, 5, 6],
+                   [7, 8, 9]])
+
+print("Square array:")
+print(square)
+
+print("\nMain diagonal:", square.diagonal())
+print("Upper diagonal (offset=1):", square.diagonal(offset=1))
+print("Lower diagonal (offset=-1):", square.diagonal(offset=-1))
+
+# Create a 4×3 rectangular array
+rectangular = np.array([[1, 2, 3],
+                        [4, 5, 6],
+                        [7, 8, 9],
+                        [10, 11, 12]])
+
+print("\nRectangular array:")
+print(rectangular)
+
+print("\nMain diagonal:", rectangular.diagonal())
+print("Upper diagonal (offset=1):", rectangular.diagonal(offset=1))
+print("Lower diagonal (offset=-2):", rectangular.diagonal(offset=-2))
+```
+
+The output produced by this code is:
+
+```shell
+Square array:
+[[1 2 3]
+ [4 5 6]
+ [7 8 9]]
+
+Main diagonal: [1 5 9]
+Upper diagonal (offset=1): [2 6]
+Lower diagonal (offset=-1): [4 8]
+
+Rectangular array:
+[[ 1  2  3]
+ [ 4  5  6]
+ [ 7  8  9]
+ [10 11 12]]
+
+Main diagonal: [1 5 9]
+Upper diagonal (offset=1): [2 6]
+Lower diagonal (offset=-2): [7 11]
+```
+
+For rectangular matrices, the diagonal length is determined by the smaller dimension, and different offsets extract parallel diagonals above or below the main one.
+
+## Example 2: Using `.diagonal()` with Multi-Dimensional Arrays
+
+This example demonstrates how to extract diagonals from higher-dimensional arrays by specifying axes:
+
+```py
+import numpy as np
+
+# Create a 3D array (2x3x3)
+array_3d = np.array([[[1, 2, 3], [4, 5, 6], [7, 8, 9]],
+                     [[10, 11, 12], [13, 14, 15], [16, 17, 18]]])
+print("3D array shape:", array_3d.shape)
+print("3D array:")
+print(array_3d)
+
+# Extract diagonal from the last two dimensions
+diag_default = array_3d.diagonal()
+print("\nDiagonal (axis1=0, axis2=1):")
+print(diag_default)
+
+# Extract diagonal with different axes
+diag_12 = array_3d.diagonal(axis1=1, axis2=2)
+print("\nDiagonal (axis1=1, axis2=2):")
+print(diag_12)
+```
+
+The output produced by this code is:
+
+```shell
+3D array shape: (2, 3, 3)
+3D array:
+[[[ 1  2  3]
+  [ 4  5  6]
+  [ 7  8  9]]
+
+ [[10 11 12]
+  [13 14 15]
+  [16 17 18]]]
+
+Diagonal (axis1=0, axis2=1):
+[[ 1 13]
+ [ 2 14]
+ [ 3 15]]
+
+Diagonal (axis1=1, axis2=2):
+[[ 1  5  9]
+ [10 14 18]]
+```
+
+For 3D arrays, `.diagonal()` extracts diagonal elements from 2D slices defined by the specified axes, resulting in an array with one fewer dimension.
+
+## Codebyte Example
+
+Run the following codebyte example to understand the usage of the `.diagonal()` method:
+
+```codebyte/python
+import numpy as np
+
+# Create a 4x4 matrix
+matrix = np.array([[1, 2, 3, 4],
+                   [5, 6, 7, 8],
+                   [9, 10, 11, 12],
+                   [13, 14, 15, 16]])
+print("Original matrix:")
+print(matrix)
+
+# Extract and display different diagonals
+print("\nMain diagonal:", matrix.diagonal())
+print("First upper diagonal:", matrix.diagonal(1))
+print("Second upper diagonal:", matrix.diagonal(2))
+print("First lower diagonal:", matrix.diagonal(-1))
+```