Merge branch 'main' into python-plotly-graph-carpet

Author: aatidua

content/javascript/concepts/dom-manipulation/terms/querySelectorAll/querySelectorAll.md

@@ -0,0 +1,56 @@
+---
+Title: '.querySelectorAll()'
+Description: 'Returns a static (non-live) NodeList of all elements in the document that match the given CSS selectors.'
+Subjects:
+  - 'Code Foundations'
+  - 'Web Development'
+Tags:
+  - 'Methods'
+  - 'Node'
+  - 'Selectors'
+CatalogContent:
+  - 'introduction-to-javascript'
+  - 'paths/front-end-engineer-career-path'
+---
+
+In JavaScript, the **`.querySelectorAll()`** method under the `document` object returns a static (not live) `NodeList` of all elements that match the given group of [selectors](https://www.codecademy.com/resources/docs/css/selectors).
+
+## Syntax
+
+```pseudo
+document.querySelectorAll(selectors);
+```
+
+- `selectors`: Represents a string containing one or more CSS selectors used to match elements in the document. It follows the same rules as CSS selectors and can include:
+  - Type selectors (`div`, `p`, `span`)
+  - Class selectors (`.class-name`)
+  - ID selectors (`#id-name`)
+  - Attribute selectors (`[type="text"]`, `[disabled]`)
+  - Combinations (`div p`, `.container > p`, `ul > li:first-child`)
+
+## Examples
+
+### Example 1
+
+In this example, a `NodeList` of all `<p>` elements in the document is obtained:
+
+```js
+const matches = document.querySelectorAll('p');
+```
+
+### Example 2
+
+The following example returns a list of all `<div>` elements in the document with a class of either `note` or `alert`:
+
+```js
+const matches = document.querySelectorAll('div.note, div.alert');
+```
+
+### Example 3
+
+In this example, a list of `<p>` elements is obtained, whose immediate parent is a `<div>` with the class `highlighted`, and which are inside a container with the ID `test`:
+
+```js
+const container = document.querySelector('#test');
+const matches = container.querySelectorAll('div.highlighted > p');
+```

content/javascript/concepts/dom-manipulation/terms/removeChild/removeChild.md

@@ -0,0 +1,66 @@
+---
+Title: '.removeChild()'
+Description: 'Removes a given child node from the DOM and returns the removed node.'
+Subjects:
+  - 'Web Development'
+  - 'Web Design'
+Tags:
+  - 'DOM'
+  - 'ES6'
+  - 'Arguments'
+  - 'Functions'
+CatalogContent:
+  - 'introduction-to-javascript'
+  - 'paths/front-end-engineer-career-path'
+---
+
+The **`.removeChild()`** method in JavaScript is a key DOM (Document Object Model) manipulation tool that removes a specified child node from the DOM tree. It enables developers to dynamically modify a webpage's structure by removing elements from their parent nodes. When called on a parent node with a child node argument, it removes that child from the DOM and returns the removed node. The returned node can still be used for other purposes, such as being inserted elsewhere in the DOM.
+
+## Syntax
+
+```pseudo
+parentNode.removeChild(childNode);
+```
+
+- `parentNode`: The parent DOM node from which the child will be removed.
+- `childNode`: The node to remove (must be a child of the parent node).
+
+### Notes
+
+- The removed node still exists in memory and can be reused, though it's no longer in the DOM.
+- If the specified child is not a child of the parent node, the method will throw an error.
+- The node must be a direct child of the parent node.
+
+## Example
+
+The following example shows how to use `.removeChild()` to remove a paragraph from a `<div>`.
+
+Here's the HTML code:
+
+```html
+<div id="container">
+  <p id="removeme">This paragraph will be removed!</p>
+</div>
+```
+
+Here's the JavaScript code:
+
+```js
+// Select the parent node
+const parentDiv = document.getElementById('container');
+
+// Select the paragraph to remove
+const paragraphToRemove = document.getElementById('removeme');
+
+// Remove the paragraph
+const removedParagraph = parentDiv.removeChild(paragraphToRemove);
+
+// Print the removed paragraph
+console.log(removedParagraph.textContent);
+```
+
+The above code produces the following output:
+
+```shell
+"This paragraph will be removed!"
+```

content/plotly/concepts/graph-objects/terms/sankey/sankey.md

@@ -0,0 +1,93 @@
+---
+Title: '.Sankey()'
+Description: 'Creates Sankey diagrams, which visualize flow between categories using nodes and links.'
+Subjects:
+  - 'Data Science'
+  - 'Data Visualization'
+Tags:
+  - 'Charts'
+  - 'Graphics'
+  - 'Plotly'
+  - 'Python'
+CatalogContent:
+  - 'learn-python-3'
+  - 'paths/data-science'
+---
+
+**`.Sankey()`** is a method in Plotly's [`graph_objects`](https://www.codecademy.com/resources/docs/plotly/graph-objects) module that creates Sankey diagrams, which visualize the flow between different values. The connected elements are called nodes, and the connections between them are links, where the width of each link represents the quantity of flow.
+
+## Syntax
+
+```pseudo
+plotly.graph_objects.Sankey(node=None, link=None, arrangement = 'snap', orientation = 'h', valueformat = None, ...)
+```
+
+- `node`: A dictionary that defines the properties of the nodes in the Sankey diagram. It has the following keys:
+  - `label`: Names of the nodes, where the order corresponds to their indices used in `link`.
+  - `color`: A string or an array of strings specifying the color of each node. If a single string is provided, all nodes will have the same color. If an array is provided, each element defines the color of the node with the same index.
+- `link`: A dictionary that defines the links (connections) between nodes and their flow values. It contains the following keys:
+  - `source`: An array of numerical indices. Each index specifies the source node of a link. The numerical index refers to the position of the node's name in the `label` array.
+  - `target`: An array of numerical indices. Each index specifies the target node of a link. The numerical index refers to the position of the node's name in the `label` array.
+  - `value`: An array of numerical values. Each value represents the flow quantity associated with a specific link. The order of values corresponds to the order of the source-target pairs.
+
+> **Note:** The `source`, `target`, and `value` arrays must have the same length.
+
+- `arrangement`: Sets the arrangement of the nodes in the Sankey diagram. The possible values are: `snap`, `perpendicular`, `freeform`, and `fixed`. The default value is `snap`.
+- `orientation`: Determines whether the Sankey diagram is displayed horizontally or vertically. The possible values are: `h` for horizontal, and `v` for vertical. The default value is `h`.
+- `valueformat`: Sets the numerical format for flow values, using d3-format syntax.
+
+> **Note:** There are many additional, optional parameters that are not listed here, as indicated by the ellipsis (`...`) in the syntax.
+
+## Example
+
+This code displays a Sankey diagram, illustrating the advertising cash flow through its nodes, and links:
+
+```py
+import plotly.graph_objects as go
+
+# Define the data for the Sankey diagram (Advertising Cash Flow).
+data = {
+    'source': ['Ad Campaign', 'Social Media', 'Search Engines', 'Referrals', 'Social Media', 'Search Engines', 'Referrals', 'Social Media', 'Search Engines', 'Referrals'],
+    'target': ['Clicks', 'Clicks', 'Clicks', 'Clicks', 'Leads', 'Leads', 'Leads', 'Conversions', 'Conversions', 'Conversions'],
+    'value': [500, 300, 200, 100, 150, 80, 40, 60, 30, 10]
+}
+
+# Create a list of unique nodes.
+all_nodes = data['source'] + data['target']
+
+# Create a dictionary that links the name of the node to its index.
+node_to_index = {node: i for i, node in enumerate(all_nodes)}
+
+# Convert source, and target names to indices.
+source_indices = [node_to_index[source] for source in data['source']]
+target_indices = [node_to_index[target] for target in data['target']]
+
+# Create the Sankey diagram.
+fig = go.Figure(data=[go.Sankey(
+    node=dict(
+        label=all_nodes,
+        pad=20,  # Add padding between nodes.
+        thickness=10,  # Define the thickness of the nodes.
+        line=dict(color="black", width=0.5)  # Add a border to the nodes.
+    ),
+    link=dict(
+        source=source_indices,
+        target=target_indices,
+        value=data['value'],
+        color=['lightblue', 'lightgreen', 'lightcoral', 'indigo', 'turquoise', 'mediumvioletred', 'darkorange', 'yellowgreen', 'dodgerblue', 'lightblue'],  # Define the color of the links.
+        line=dict(color='black', width=0.2)  # Define the border of the links.
+    ),
+    arrangement='snap',  # Set the arrangement of the nodes.
+    orientation='h'  # Set the orientation of the diagram.
+)])
+
+# Update layout to add a title.
+fig.update_layout(title_text="Advertising Cash Flow", font_size=10)
+
+# Display the plot.
+fig.show()
+```
+
+This example results in the following output:
+
+![The output will be a Sankey diagram.](https://raw.githubusercontent.com/Codecademy/docs/main/media/sankey-cash-flow.png)

content/pytorch/concepts/tensor-operations/terms/acosh/acosh.md

@@ -0,0 +1,61 @@
+---
+Title: '.acosh()'
+Description: 'Computes the inverse hyperbolic cosine of elements in a PyTorch tensor.'
+Subjects:
+  - 'Computer Science'
+  - 'Data Science'
+Tags:
+  - 'Deep Learning'
+  - 'Programming'
+  - 'PyTorch'
+CatalogContent:
+  - 'intro-to-py-torch-and-neural-networks'
+  - 'paths/data-science'
+---
+
+The **`.acosh()`** method in PyTorch computes the inverse hyperbolic cosine of each element in a [tensor](https://www.codecademy.com/resources/docs/pytorch/tensors). This operation is applied element-wise and is commonly used in scientific computations involving hyperbolic functions.
+
+## Syntax
+
+```pseudo
+torch.acosh(input, *, out=None) → Tensor
+```
+
+**Parameters:**
+
+- `input`: The input tensor containing values greater than or equal to 1.
+- `out` (Optional): The output tensor to store the result. If not provided, a new tensor is created.
+
+**Returns:**
+
+A tensor with the inverse hyperbolic cosine of each element from the input tensor.
+
+## Example
+
+This example shows how to use `.acosh()` to compute the inverse hyperbolic cosine of a tensor:
+
+```py
+import torch
+
+# Define a tensor with values >= 1
+input_tensor = torch.tensor([1.0, 2.0, 3.0, 10.0])
+
+# Compute the inverse hyperbolic cosine
+output_tensor = torch.acosh(input_tensor)
+
+print("Input Tensor:")
+print(input_tensor)
+
+print("\nOutput Tensor:")
+print(output_tensor)
+```
+
+This example results in the following output:
+
+```shell
+Input Tensor:
+tensor([ 1.,  2.,  3., 10.])
+
+Output Tensor:
+tensor([0.0000, 1.3169, 1.7627, 2.9932])
+```