Merge branch 'main' into feat/add-numpy-byteswap-term

Author: prakhar14-op

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

@@ -0,0 +1,120 @@
+---
+Title: '.axis()'
+Description: 'Gets or sets the properties of the plot axes, including axis limits, scaling, and visibility.'
+Subjects:
+  - 'Computer Science'
+  - 'Data Science'
+  - 'Data Visualization'
+Tags:
+  - 'Data'
+  - 'Graphs'
+  - 'Libraries'
+  - 'Matplotlib'
+  - 'Plotting'
+CatalogContent:
+  - 'learn-python-3'
+  - 'paths/computer-science'
+---
+
+The **`.axis()`** function in Matplotlib's [`pyplot`](https://www.codecademy.com/resources/docs/matplotlib/pyplot) module gets or sets properties of the plot axes, including axis limits, aspect ratio, and visibility.
+
+## Syntax
+
+```pseudo
+matplotlib.pyplot.axis(arg=None, emit=True, **kwargs)
+```
+
+The function can be called in several ways:
+
+- `axis()`: Returns current axis limits as `(xmin, xmax, ymin, ymax)`
+- `axis([xmin, xmax, ymin, ymax])`: Sets axis limits
+- `axis(option)`: Sets axis properties using predefined options
+- `axis(**kwargs)`: Sets axis properties using keyword arguments
+
+**Parameters:**
+
+- `arg` (optional): Defines how the axes are set or displayed. Accepts the following values:
+  - A list or tuple `[xmin, xmax, ymin, ymax]` to set axis limits.
+  - `'off'` to hide the axes.
+  - `'on'` to show the axes.
+  - `'equal'`, `'scaled'`, `'tight'`, `'auto'`, `'image'`, `'square'` — control axis scaling and aspect ratio.
+- `emit` (bool, default: True): If `True`, notifies observers of axis limit changes.
+- `kwargs` (optional): Additional axis properties such as `xmin`, `xmax`, `ymin`, and `ymax`.
+
+**Return value:**
+
+Returns a [tuple](https://www.codecademy.com/resources/docs/python/tuples) `(xmin, xmax, ymin, ymax)` representing the current axis limits.
+
+## Example 1: Using `.axis()` to Control Axis Properties
+
+This example creates three subplots demonstrating different axis control modes. The first subplot uses `axis([2, 8, -0.5, 0.5])` to restrict the view to specific x and y ranges. The second subplot uses `axis('equal')` to ensure both axes use the same scale. The third subplot uses `axis('off')` to hide the axis lines, ticks, and labels:
+
+```py
+import matplotlib.pyplot as plt
+import numpy as np
+
+# Generate sample data
+x = np.linspace(0, 10, 100)
+y = np.sin(x)
+
+# Create a basic plot
+plt.figure(figsize=(10, 4))
+
+# Subplot 1: Custom axis limits
+plt.subplot(1, 3, 1)
+plt.plot(x, y)
+plt.axis([2, 8, -0.5, 0.5])
+plt.title('Custom Limits')
+plt.grid(True, alpha=0.3)
+
+# Subplot 2: Equal aspect ratio
+plt.subplot(1, 3, 2)
+plt.plot(x, y)
+plt.axis('equal')
+plt.title('Equal Scaling')
+plt.grid(True, alpha=0.3)
+
+# Subplot 3: Axis turned off
+plt.subplot(1, 3, 3)
+plt.plot(x, y)
+plt.axis('off')
+plt.title('Hidden Axes')
+
+plt.tight_layout()
+plt.show()
+```
+
+The output of this code is:
+
+![Output of matplotlib.pyplot.axis() method example 1](https://raw.githubusercontent.com/Codecademy/docs/main/media/matplotlib-axis-example1.png)
+
+## Example 2: Getting and Setting Axis Limits
+
+This example demonstrates how to set custom axis limits and retrieve the current limits. The `axis()` function is called with a list of four values to set the x and y axis ranges, then called without arguments to return the current limits as a tuple.
+
+```py
+import matplotlib.pyplot as plt
+import numpy as np
+
+# Create data
+x = np.linspace(0, 2*np.pi, 100)
+y = np.sin(x)
+
+# Create plot
+plt.plot(x, y, linewidth=2)
+plt.title('Sine Wave with Custom Axes')
+
+# Set custom axis limits
+plt.axis([0, 2*np.pi, -1.5, 1.5])
+
+# Get and print current axis limits
+limits = plt.axis()
+print(f"Current axis limits: {limits}")
+
+plt.grid(True, alpha=0.3)
+plt.show()
+```
+
+The output of this code is:
+
+![Output of matplotlib.pyplot.axis() method example 2](https://raw.githubusercontent.com/Codecademy/docs/main/media/matplotlib-axis-example2.png)

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

@@ -0,0 +1,73 @@
+---
+Title: '.figure()'
+Description: 'Creates a new figure window or activates an existing one for plotting.'
+Subjects:
+  - 'Data Science'
+  - 'Data Visualization'
+Tags:
+  - 'Charts'
+  - 'Graphs'
+  - 'Matplotlib'
+CatalogContent:
+  - 'learn-python-3'
+  - 'paths/data-science'
+---
+
+The **`.figure()`** function in Matplotlib creates a new top-level container, called a figure, which acts as the canvas for all plots and axes in Matplotlib. If a figure with the given identifier already exists, it makes that figure active instead.
+
+## Syntax
+
+```pseudo
+matplotlib.pyplot.figure(
+    num=None,
+    figsize=None,
+    dpi=None,
+    facecolor=None,
+    edgecolor=None,
+    frameon=True,
+    FigureClass=<class 'matplotlib.figure.Figure'>,
+    clear=False,
+    **kwargs
+)
+```
+
+**Parameters:**
+
+- `num` (int or str, optional): Identifier for the figure. If the number or name already exists, that figure becomes active; otherwise, a new one is created.
+- `figsize` (tuple, optional): Width and height of the figure in inches, e.g. `(8, 6)`.
+- `dpi` (float, optional): Dots per inch; controls the resolution of the figure.
+- `facecolor` (color, optional): Background color of the figure.
+- `edgecolor` (color, optional): Border color of the figure.
+- `frameon` (bool, default: True): Whether to draw the figure frame.
+- `FigureClass` (`Figure` subclass, optional): The class used to create the figure instance. Defaults to `matplotlib.figure.Figure`.
+- `clear` (bool, default: False): If `True`, clears the existing figure before reusing it.
+- `**kwargs`: Additional parameters passed to the `Figure` constructor.
+
+**Return value:**
+
+Returns a `Figure` object, which is the main container that holds all plot elements like axes, titles, labels, and legends.
+
+## Example
+
+This example creates a new figure canvas with a specific size and background color, then adds a simple sine wave plot to it:
+
+```py
+import matplotlib.pyplot as plt
+import numpy as np
+
+x = np.linspace(0, 2 * np.pi, 100)
+y = np.sin(x)
+
+plt.figure(figsize=(8, 4), facecolor='lightblue')
+ax = plt.subplot(1, 1, 1)
+ax.plot(x, y)
+ax.set_title('Simple Sine Wave')
+ax.set_xlabel('X-axis')
+ax.set_ylabel('Y-axis')
+
+plt.show()
+```
+
+The output of this code is:
+
+![Output of matplotlib.pyplot.figure() method example](https://raw.githubusercontent.com/Codecademy/docs/main/media/figure_example.png)

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

@@ -0,0 +1,101 @@
+---
+Title: '.dot()'
+Description: 'Computes the dot product of two arrays.'
+Subjects:
+  - 'Code Foundations'
+  - 'Computer Science'
+Tags:
+  - 'Arrays'
+  - 'Linear Algebra'
+  - 'Methods'
+  - 'NumPy'
+CatalogContent:
+  - 'learn-python-3'
+  - 'paths/computer-science'
+---
+
+The **`.dot()`** method computes the dot product of an array with another array or scalar. For one-dimensional arrays, it calculates the standard inner product of vectors. When applied to two-dimensional arrays, it performs matrix multiplication. For arrays with higher dimensions, it executes a sum-product over the last axis of the first array and the second-to-last axis of the second array.
+
+## Syntax
+
+```pseudo
+ndarray.dot(b, out=None)
+```
+
+**Parameters:**
+
+- `ndarray`: The first array (A) in the dot product operation (A $\cdot$ B).
+- `b`: The second array (B) or scalar in the dot product operation.
+- `out` (optional): An alternative output array to place the result in. It must have the same shape and buffer length as the expected output, but the type will be cast if necessary.
+
+**Return value:**
+
+Returns the dot product as a scalar, 2-D array, or ndarray, depending on the input dimensions.
+
+## Example
+
+This example shows how to use the `.dot()` method for matrix multiplication between two 2D NumPy arrays, `matrix_a` and `matrix_b`:
+
+```py
+# Import NumPy
+import numpy as np
+
+# Create the first 2x3 matrix
+matrix_a = np.array([[1, 2, 3],
+                     [4, 5, 6]])
+
+# Create the second 3x2 matrix
+matrix_b = np.array([[7, 8],
+                     [9, 10],
+                     [11, 12]])
+
+# Use the '.dot()' method for matrix multiplication (2x3 @ 3x2 = 2x2)
+result_matrix = matrix_a.dot(matrix_b)
+
+print("Matrix A:")
+print(matrix_a)
+print("\nMatrix B:")
+print(matrix_b)
+print("\nResult (A.dot(B)):")
+print(result_matrix)
+```
+
+The output of the above code will be:
+
+```shell
+Matrix A:
+[[1 2 3]
+ [4 5 6]]
+
+Matrix B:
+[[ 7  8]
+ [ 9 10]
+ [11 12]]
+
+Result (A.dot(B)):
+[[ 58  64]
+ [139 154]]
+```
+
+## Codebyte Example
+
+In the following codebyte example, the `.dot()` method is used to calculate the inner product (dot product) of two one-dimensional vectors, `vector_x` and `vector_y`:
+
+```codebyte/python
+import numpy as np
+
+# Create two 1-D arrays (vectors)
+vector_x = np.array([1, 2, 3])
+vector_y = np.array([5, 6, 7])
+
+# Calculate the inner product (dot product)
+dot_product = vector_x.dot(vector_y)
+
+print(f"Vector x: {vector_x}")
+print(f"Vector y: {vector_y}")
+print(f"Dot product (x.dot(y)): {dot_product}")
+```
+
+Calculation breakdown:
+
+$$\vec{x} \cdot \vec{y} = (1 \times 5) + (2 \times 6) + (3 \times 7) = 5 + 12 + 21 = 38$$

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

@@ -0,0 +1,76 @@
+---
+Title: '.nbytes'
+Description: 'Returns the total number of bytes consumed by the elements of the array.'
+Subjects:
+  - 'Code Foundations'
+  - 'Computer Science'
+Tags:
+  - 'Arrays'
+  - 'Attributes'
+  - 'Memory'
+  - 'NumPy'
+CatalogContent:
+  - 'learn-python-3'
+  - 'paths/computer-science'
+---
+
+The **`.nbytes`** attribute returns the total number of bytes consumed by the elements of a [NumPy array](https://www.codecademy.com/resources/docs/numpy/ndarray). This value is calculated as the product of the number of elements in the array (given by `.size`) and the number of bytes per element (given by `.itemsize`).
+
+## Syntax
+
+```pseudo
+ndarray.nbytes
+```
+
+**Parameters:**
+
+The `.nbytes` attribute takes no parameters.
+
+**Return value:**
+
+Returns an integer representing the total number of bytes consumed by the array elements.
+
+## Example
+
+The following example creates a one-dimensional NumPy array `arr` with 12 elements. The `.nbytes` attribute reports the total bytes used by all array elements. On a 64-bit system where the default integer type (`int64`) uses 8 bytes per element, $12 \text{ elements} \times 8 \text{ bytes}/\text{element} = 96 \text{ bytes}$:
+
+```py
+# Import NumPy
+import numpy as np
+
+# Create a NumPy array with 12 elements (default type is usually int64, or 8 bytes per item)
+arr = np.arange(12)
+
+# Use the '.nbytes' attribute
+total_bytes_nbytes = arr.nbytes
+
+print(f"Array: {arr}")
+print(f"Bytes per element (.itemsize): {arr.itemsize}")
+print(f"Total number of elements (.size): {arr.size}")
+print(f"Total bytes consumed (.nbytes): {total_bytes_nbytes}")
+```
+
+The result will be similar to the following (the value of `arr.itemsize` might vary based on system architecture):
+
+```shell
+Array: [ 0  1  2  3  4  5  6  7  8  9 10 11]
+Bytes per element (.itemsize): 8
+Total number of elements (.size): 12
+Total bytes consumed (.nbytes): 96
+```
+
+## Codebyte Example
+
+The example below demonstrates a two-dimensional NumPy array `arr` with a specified data type (`float32`). Since `float32` uses 4 bytes per element and the array contains $2 \times 3 = 6$ elements, the total memory consumed is $6 \times 4 = 24$ bytes:
+
+```codebyte/python
+import numpy as np
+
+# Create a 2x3 array of type float32 (4 bytes per element)
+arr = np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], dtype=np.float32)
+
+print(f"Array shape: {arr.shape}")
+print(f"Array data type: {arr.dtype}")
+print(f"Bytes per element (.itemsize): {arr.itemsize}")
+print(f"Bytes consumed by elements (.nbytes): {arr.nbytes}")
+```