diff --git a/docs/languages/html/html.md b/docs/languages/html/html.md
index ff38c53..ebe59dd 100644
--- a/docs/languages/html/html.md
+++ b/docs/languages/html/html.md
@@ -1,600 +1,600 @@
-# HTML
-
-## Terminology
-
-**Web design**: The process of planning, structuring and creating a website.
-**Web development**: The process of programming dynamic web applications.
-**Front end**: The outwardly visible elements of a website or application.
-**Back end**: The inner workings and functionality of a website or application.
-
-## Anatomy of an HTML Element
-
-**Element**: Building blocks of web pages, an individual component of HTML.
-**Tag**: Opening tag marks the beginning of an element & closing tag marks the end.
-Tags contain characters that indicate the tag's purpose content.
-
-` content `
-
-**Container Element**: An element that can contain other elements or content.
-**Stand Alone Element**: An element that cannot contain anything else.
-**Attribute**: Provides additional information about the HTML element. Placed inside an opening tag, before the right angle bracket.
-**Value**: Value is the value assigned to a given attribute. Values must be contained inside quotation marks (“”).
-
-## The Doctype
-
-The first thing on an HTML page is the doctype, which tells the browser which version of the markup language the page is using.
-
-### XHTML 1.0 Strict
-
-```html
-
-```
-
-### HTML4 Transitional
-
-```html
-
-```
-
-### HTML5
-
-``
-
-## The HTML Element
-
-After ``, the page content must be contained between tags.
-
-```html
-
-
-
-
-```
-
-### The HEAD Element
-
-The head contains the title of the page & meta information about the page. Meta information is not visible to the user, but has many purposes, like providing information to search engines.
-UTF-8 is a character encoding capable of encoding all possible characters, or code points, defined by Unicode. The encoding is variable-length and uses 8-bit code units.
-
-XHTML and HTML4: ` content `
-
-### Meta Tag Structure
-
-` paragraph-content
- paragraph-content
-```
-
-### Headings
-
-Heading numbers indicates hierarchy, not size.
-
-```html
- Heading 1
- Heading 2
-```
-
-### Formatted Text
-
-With semantic value:
-
-* Emphasized text (default cursive): ` text/image
-
-
-Scheme-relative URL
-Origin-relative URL
-Directory-relative URL
-
-
- Back to Top
-
-
-address@domain
-
-
-+39 111 2223334
-
-
-Download
-```
-
-`target`:
-
-* `_blank`: opens linked document in a new window or *tab*
-* `_self`: opens linked document in the same frame as it was clicked (DEFAULT)
-* `_parent`: opens the linked document in the parent frame
-* `_top`: opens linked document in the full body of the window
-* `frame-name`: opens the linked document in the specified frame
-
-### Images
-
-```html
-
- caption of the figure
-
-```
-
-### Unordered list (bullet list)
-
-```html
-
-```
-
-### Ordered list (numbered list)
-
-```html
-
-
-```
-
-### Description list (list of terms and descriptions)
-
-```html
-
- term
- definition
- term
- definition
-
-```
-
-### Tables
-
-```html
-
-```
-
-### Character Codes
-
-Code | Character
----------|-----------------
-`©` | Copyright
-`<` | less than (`<`)
-`>` | greater than (`>`)
-`&` | ampersand (`&`)
-
-### Block Element
-
-Used to group elements together into sections, eventually to style them differently.
-
-```html
-
-
-
-```
-
-### Inline Element
-
-Used to apply a specific style inline.
-
-```html
- non-styled content styled content non-styled content
-```
-
-### HTML5 new tags
-
-```html
-
-` tag is used to define the labels for `
- Value
- Value
- Value
-
-```
-
-Use `` rather than radio buttons when the number of options to choose from is large
-`selected` is used rather than checked.
-Provides the ability to select multiple options.
-Conceptually, `` becomes more similar to checkboxes.
-
-### File Select
-
-Upload a local file as an attachment. The `accept` attribute value is a string that defines the file types the file input should accept.
-This string is a comma-separated list of [unique file type specifiers][file_type_specifiers_docs].
-
-```html
-
-
-```
-
-`submit`: sends the form data to the location specified in the action attribute.
-`reset`: resets all forms controls to the default values.
-
-### Button
-
-```html
-
- Color
- Red
- Green
- Red
-
-```
-
-### Email Field
-
-Used to receive a valid e-mail address from the user. Most browsers can validate this without needing javascript.
-Older browsers don't support this input type.
-
-```html
-
-```
-
-### Progress Bar
-
-```html
- 70%
-```
-
-### Slider
-
-```html
-` HTML element represents either a scalar value within a known range or a fractional value.
-
-```html
-current value
-```
-
-### Datalist (Autocomplete)
-
-The `datalist` HTML element can provide suggestions to an input that targets it's `id` with the `list` attribute.
-
-```html
-
-
-
-
-
-```
-
-### More Input Types
-
-```html
- content `
+
+**Container Element**: An element that can contain other elements or content.
+**Stand Alone Element**: An element that cannot contain anything else.
+**Attribute**: Provides additional information about the HTML element. Placed inside an opening tag, before the right angle bracket.
+**Value**: Value is the value assigned to a given attribute. Values must be contained inside quotation marks (“”).
+
+## The Doctype
+
+The first thing on an HTML page is the doctype, which tells the browser which version of the markup language the page is using.
+
+### XHTML 1.0 Strict
+
+```html
+
+```
+
+### HTML4 Transitional
+
+```html
+
+```
+
+### HTML5
+
+``
+
+## The HTML Element
+
+After ``, the page content must be contained between tags.
+
+```html
+
+
+
+
+```
+
+### The HEAD Element
+
+The head contains the title of the page & meta information about the page. Meta information is not visible to the user, but has many purposes, like providing information to search engines.
+UTF-8 is a character encoding capable of encoding all possible characters, or code points, defined by Unicode. The encoding is variable-length and uses 8-bit code units.
+
+XHTML and HTML4: ` content `
+
+### Meta Tag Structure
+
+` paragraph-content
+ paragraph-content
+```
+
+### Headings
+
+Heading numbers indicates hierarchy, not size.
+
+```html
+ Heading 1
+ Heading 2
+```
+
+### Formatted Text
+
+With semantic value:
+
+* Emphasized text (default cursive): ` text/image
+
+
+Scheme-relative URL
+Origin-relative URL
+Directory-relative URL
+
+
+ Back to Top
+
+
+address@domain
+
+
++39 111 2223334
+
+
+Download
+```
+
+`target`:
+
+* `_blank`: opens linked document in a new window or *tab*
+* `_self`: opens linked document in the same frame as it was clicked (DEFAULT)
+* `_parent`: opens the linked document in the parent frame
+* `_top`: opens linked document in the full body of the window
+* `frame-name`: opens the linked document in the specified frame
+
+### Images
+
+```html
+
+ caption of the figure
+
+```
+
+### Unordered list (bullet list)
+
+```html
+
+```
+
+### Ordered list (numbered list)
+
+```html
+
+
+```
+
+### Description list (list of terms and descriptions)
+
+```html
+
+ term
+ definition
+ term
+ definition
+
+```
+
+### Tables
+
+```html
+
+```
+
+### Character Codes
+
+Code | Character
+---------|-----------------
+`©` | Copyright
+`<` | less than (`<`)
+`>` | greater than (`>`)
+`&` | ampersand (`&`)
+
+### Block Element
+
+Used to group elements together into sections, eventually to style them differently.
+
+```html
+
+
+
+```
+
+### Inline Element
+
+Used to apply a specific style inline.
+
+```html
+ non-styled content styled content non-styled content
+```
+
+### HTML5 new tags
+
+```html
+
+` tag is used to define the labels for `
+ Value
+ Value
+ Value
+
+```
+
+Use `` rather than radio buttons when the number of options to choose from is large
+`selected` is used rather than checked.
+Provides the ability to select multiple options.
+Conceptually, `` becomes more similar to checkboxes.
+
+### File Select
+
+Upload a local file as an attachment. The `accept` attribute value is a string that defines the file types the file input should accept.
+This string is a comma-separated list of [unique file type specifiers][file_type_specifiers_docs].
+
+```html
+
+
+```
+
+`submit`: sends the form data to the location specified in the action attribute.
+`reset`: resets all forms controls to the default values.
+
+### Button
+
+```html
+
+ Color
+ Red
+ Green
+ Red
+
+```
+
+### Email Field
+
+Used to receive a valid e-mail address from the user. Most browsers can validate this without needing javascript.
+Older browsers don't support this input type.
+
+```html
+
+```
+
+### Progress Bar
+
+```html
+ 70%
+```
+
+### Slider
+
+```html
+` HTML element represents either a scalar value within a known range or a fractional value.
+
+```html
+current value
+```
+
+### Datalist (Autocomplete)
+
+The `datalist` HTML element can provide suggestions to an input that targets it's `id` with the `list` attribute.
+
+```html
+
+
+
+
+
+```
+
+### More Input Types
+
+```html
+
- ,
- document.getElementById("DomID");
-)
-```
-
-```js
-// Component.js
-import { Route, Route } from "react-router-dom";
-
-
- {/* match route pattern exactly, all sub-routes will be matched otherwise */}
-
-
-// only one child can match, similar to Route-case
-
- Text
-Text
-```
+# [React Router](https://reactrouter.com)
+
+Popular routing library. Allows to specify a route through React components, declaring which component is to be loaded for a given URL.
+
+Key Components:
+
+- **Router**: wrap the app entry-point, usually `BrowserRouter`
+- **Route**: "Load this component for this URL"
+- **Link**: react-managed anchors that won't post back to the browser
+
+## Routers
+
+Router Types:
+
+- *HashRouter*: `#route`, adds hashes to the URLs
+- *BrowserRouter*: `/route`, uses HTML5 history API to provide clean URLs
+- *MemoryRouter*: no URL
+
+```js
+// index.js
+
+//other imports ...
+
+import { BrowserRouter as Router } from "react-router-dom";
+
+React.render(
+
+ ,
+ document.getElementById("DomID");
+)
+```
+
+```js
+// Component.js
+import { Route, Route } from "react-router-dom";
+
+
+ {/* match route pattern exactly, all sub-routes will be matched otherwise */}
+
+
+// only one child can match, similar to Route-case
+
+ Text
+Text
+```
diff --git a/docs/languages/javascript/react/react.md b/docs/languages/javascript/react/react.md
index 9a025fc..c28072e 100644
--- a/docs/languages/javascript/react/react.md
+++ b/docs/languages/javascript/react/react.md
@@ -1,261 +1,261 @@
-# React
-
-## Components
-
-There are two types of react components:
-
-- Function Components
-- Class Components
-
-Both types can be stateful and have side effects or be purely presentational.
-
-```jsx
-// functional component
-const Component = (props) => {
- return (
- Hello, world!
-);
-
-// compiled JS shipped to browser
-const element = React.createElement(
- 'h1', // HTML tag name
- {className: 'greeting'}, // attrs as JSON
- 'Hello, world!' // tag content (can be nested component)
-);
-```
-
-### App Entry-point
-
-```js
-const container = document.getElementById('root')!;
-const root = createRoot(container);
-
-const element = Hello World
-root.render(element)
-```
-
-### Dynamic Expressions
-
-```js
-{expression} // expression is evaluated an it's result is displayed
-{expression}
- func(args)}>{expression}
-```
-
-### Props
-
-```js
-
- {count}
-
- );
-}
-
-export default Button;
-```
-
-### Simple Class Component
-
-```js
-class Button extends React.Component {
-
- state = {count: 0};
- //or
- constructor(props) {
- super(props);
- this.state = {count: 0};
- }
-
- componentDidMount() {} // called on successful component mount
-
- handleClick = () => {
- this.setState({ count: this.state.count + 1 });
- }
- // or
- handleClick = () => {
- this.setState((state, props) => ({ count: state.count + props.increment }) );
- }
-
- render(){
- return (
-
- {this.state.count}
-
- );
- }
-}
-```
-
-### Nesting Components
-
-```js
-import { useState } from "react";
-
-function Button(props) {
- return (
-
- +1
-
- );
-}
-
-function Display (props) {
- return (
- {props.message}
- );
-}
-
-function App() {
-
- // state must be declare in the outer component it can be passed to each children
- const [count, setCount] = useState(0);
- const incrementCounter = () => setCount(count + 1);
-
- return (
-
-
-
-
- );
-}
-
-export default App;
-```
-
-### User Input (Forms)
-
-```js
-function Form() {
- const [userName, setUserName] = useState("");
-
- handleSubmit = (event) => {
- event.preventDefault();
- // ...
- }
-
- return(
-
- );
-}
-```
-
-### Lists of Components
-
-```js
-// ...
-
- {array.map(item => )}
-
-// ...
-```
-
-> **Note**: The `key` attribute of the component is needed to identify a particular item. It's most useful if the list has to be sorted.
-
-## Hooks
-
-### `useState`
-
-Hook used to create a state object.
-
-`useState()` results:
-
-- state object (getter)
-- updater function (setter)
-
-```js
-const [state, setState] = useState(default);
-```
-
-### `useEffect`
-
-Hook used to trigger an action on each render of the component or when one of the watched items changes.
-
-```js
-
-useEffect(() => {
- // "side effects" operations
-
- return () => {/* clean up side effect */} // optional
-}, [/* list of watched items, empty triggers once */]);
-```
-
-### Custom Hooks
-
-```js
-// hook definitions
-const useCustomHook = () => {
- // eventual state definitions
-
- // eventual function definitions
-
- // ...
-
- return { obj1, obj2, ... };
-}
-
-const Component(){
- // retrieve elements from the hook
- const {
- obj1,
- obj2,
- ...
- } = useCustomHook();
-}
-```
+# React
+
+## Components
+
+There are two types of react components:
+
+- Function Components
+- Class Components
+
+Both types can be stateful and have side effects or be purely presentational.
+
+```jsx
+// functional component
+const Component = (props) => {
+ return (
+ Hello, world!
+);
+
+// compiled JS shipped to browser
+const element = React.createElement(
+ 'h1', // HTML tag name
+ {className: 'greeting'}, // attrs as JSON
+ 'Hello, world!' // tag content (can be nested component)
+);
+```
+
+### App Entry-point
+
+```js
+const container = document.getElementById('root')!;
+const root = createRoot(container);
+
+const element = Hello World
+root.render(element)
+```
+
+### Dynamic Expressions
+
+```js
+{expression} // expression is evaluated an it's result is displayed
+{expression}
+ func(args)}>{expression}
+```
+
+### Props
+
+```js
+
+ {count}
+
+ );
+}
+
+export default Button;
+```
+
+### Simple Class Component
+
+```js
+class Button extends React.Component {
+
+ state = {count: 0};
+ //or
+ constructor(props) {
+ super(props);
+ this.state = {count: 0};
+ }
+
+ componentDidMount() {} // called on successful component mount
+
+ handleClick = () => {
+ this.setState({ count: this.state.count + 1 });
+ }
+ // or
+ handleClick = () => {
+ this.setState((state, props) => ({ count: state.count + props.increment }) );
+ }
+
+ render(){
+ return (
+
+ {this.state.count}
+
+ );
+ }
+}
+```
+
+### Nesting Components
+
+```js
+import { useState } from "react";
+
+function Button(props) {
+ return (
+
+ +1
+
+ );
+}
+
+function Display (props) {
+ return (
+ {props.message}
+ );
+}
+
+function App() {
+
+ // state must be declare in the outer component it can be passed to each children
+ const [count, setCount] = useState(0);
+ const incrementCounter = () => setCount(count + 1);
+
+ return (
+
+
+
+
+ );
+}
+
+export default App;
+```
+
+### User Input (Forms)
+
+```js
+function Form() {
+ const [userName, setUserName] = useState("");
+
+ handleSubmit = (event) => {
+ event.preventDefault();
+ // ...
+ }
+
+ return(
+
+ );
+}
+```
+
+### Lists of Components
+
+```js
+// ...
+
+ {array.map(item => )}
+
+// ...
+```
+
+> **Note**: The `key` attribute of the component is needed to identify a particular item. It's most useful if the list has to be sorted.
+
+## Hooks
+
+### `useState`
+
+Hook used to create a state object.
+
+`useState()` results:
+
+- state object (getter)
+- updater function (setter)
+
+```js
+const [state, setState] = useState(default);
+```
+
+### `useEffect`
+
+Hook used to trigger an action on each render of the component or when one of the watched items changes.
+
+```js
+
+useEffect(() => {
+ // "side effects" operations
+
+ return () => {/* clean up side effect */} // optional
+}, [/* list of watched items, empty triggers once */]);
+```
+
+### Custom Hooks
+
+```js
+// hook definitions
+const useCustomHook = () => {
+ // eventual state definitions
+
+ // eventual function definitions
+
+ // ...
+
+ return { obj1, obj2, ... };
+}
+
+const Component(){
+ // retrieve elements from the hook
+ const {
+ obj1,
+ obj2,
+ ...
+ } = useCustomHook();
+}
+```
diff --git a/docs/languages/javascript/react/redux.md b/docs/languages/javascript/react/redux.md
index 823da1f..bff0378 100644
--- a/docs/languages/javascript/react/redux.md
+++ b/docs/languages/javascript/react/redux.md
@@ -1,465 +1,465 @@
-# [Redux](https://redux.js.org/)
-
-Redux is a pattern and library for managing and updating application state, using events called *actions*. It serves as a centralized store for state that needs to be used across the entire application, with rules ensuring that the state can only be updated in a predictable fashion.
-
-## Actions, Store, Immutability & Reducers
-
-### Actions & Action Creators
-
-An **Action** is a plain JavaScript object that has a `type` field. An action object can have other fields with additional information about what happened.
-By convention, that information is stored in a field called `payload`.
-
-**Action Creators** are functions that create and return action objects.
-
-```js
-function actionCreator(data)
-{
- return { type: ACTION_TYPE, payload: data }; // action obj
-}
-```
-
-### Store
-
-The current Redux application state lives in an object called the **store**.
-The store is created by passing in a reducer, and has a method called `getState` that returns the current state value.
-
-The Redux store has a method called `dispatch`. The only way to update the state is to call `store.dispatch()` and pass in an action object.
-The store will run its reducer function and save the new state value inside.
-
-**Selectors** are functions that know how to extract specific pieces of information from a store state value.
-
-In `initialState.js`;
-
-```js
-export default {
- // initial state here
-}
-```
-
-In `configStore.js`:
-
-```js
-// configStore.js
-import { createStore, applyMiddleware, compose } from "redux";
-
-export function configStore(initialState) {
- const composeEnhancers =
- window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ || compose; // support for redux devtools
-
- return createStore(
- rootReducer,
- initialState,
- composeEnhancers(applyMiddleware(middleware, ...))
- );
-}
-
-// available functions & methods
-replaceReducer(newReducer); // replace an existing reducer, useful for Hot Reload
-store.dispatch(action); // trigger a state change based on an action
-store.subscribe(listener);
-store.getState(); // retrieve current state
-```
-
-### Reducers
-
-**Reducers** are functions that receives the current state and an action, decide how to update the state if necessary, and return the new state.
-
-Reducers must **always** follow some specific rules:
-
-- They should only calculate the new state value based on the `state` and `action` arguments
-- They are not allowed to modify the existing `state`.
- Instead, they must make *immutable updates*, by copying the existing `state` and making changes to the copied values.
-- They must not do any asynchronous logic, calculate random values, or cause other "side effects"
-
-```js
-import initialState from "path/to/initialState";
-
-function reducer(state = initialState, action) {
- switch(action.type){
- case "ACTION_TYPE":
- return { ...state, prop: value }; // return modified copy of state (using spread operator)
- break;
-
- default:
- return state; // return unchanged state (NEEDED)
- }
-}
-
-// combining reducers
-import { combineReducers } from "redux";
-
-const rootReducer = combineReducers({
- entity: entityReducer.
- ...
-});
-```
-
-> **Note**: multiple reducers can be triggered by the same action since each one operates on a different portion of the state.
-
-## [React-Redux](https://react-redux.js.org/)
-
-### Container vs Presentational Components
-
-Container Components:
-
-- Focus on how thing work
-- Aware of Redux
-- Subscribe to Redux State
-- Dispatch Redux actions
-
-Presentational Components:
-
-- Focus on how things look
-- Unaware of Redux
-- Read data from props
-- Invoke callbacks on props
-
-### Provider Component & Connect
-
-Used at the root component and wraps all the application.
-
-```js
-// index.js
-import React from 'react';
-import ReactDOM from 'react-dom';
-import { Provider } from 'react-redux';
-
-import { configStore } from 'path/to/configStore';
-import initialState from "path/to/initialState";
-import App from './App';
-
-const store = configStore(initialState);
-
-const rootElement = document.getElementById('root');
-ReactDOM.render(
-
- ,
- rootElement
-);
-```
-
-```js
-// Component.js
-import { connect } from 'react-redux';
-import { increment, decrement, reset } from './actionCreators';
-
-// const Component = ...
-
-// specifies which state is passed to the component (called on state change)
-const mapStateToProps = (state, ownProps /* optional */) => {
- // structure of the props passed to the component
- return { propName: state.property };
-};
-
-// specifies the action passed to a component (the key is the name that the prop will have )
-const mapDispatchToProps = { actionCreator: actionCreator };
-// or
-function mapDispatchToProps(dispatch) {
- return {
- // wrap action creators
- actionCreator: (args) => dispatch(actionCreator(args))
- };
-}
-// or
-function mapDispatchToProps(dispatch) {
- return {
- actionCreator: bindActionCreators(actionCreator, dispatch),
- actions: bindActionCreators(allActionCreators, dispatch)
- };
-}
-
-// both args are optional
-// if mapDispatch is missing the dispatch function is added to the props
-export default connect(mapStateToProps, mapDispatchToProps)(Component);
-```
-
-## Async Operations with [Redux-Thunk](https://github.com/reduxjs/redux-thunk)
-
-**Note**: Redux middleware runs *after* and action and *before* it's reducer.
-
-Redux-Thunk allows to return functions instead of objects from action creators.
-A "thunk" is a function that wraps an expression to delay it's evaluation.
-
-In `configStore.js`:
-
-```js
-import { createStore, applyMiddleware, compose } from "redux";
-import thunk from "redux-thunk";
-
-function configStore(initialState) {
- const composeEnhancers =
- window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ || compose; // support for redux devtools
-
- return createStore(
- rootReducer,
- initialState,
- composeEnhancers(applyMiddleware(thunk, ...)) // add thunks middleware
- );
-}
-```
-
-```js
-// usually action on async func success
-function actionCreator(arg) {
- return { type: TYPE, data: arg };
-}
-
-export function thunk() {
- return function (dispatch) { // redux-thunk injects dispatch as arg
- return asyncFunction().then((data) => { // async function returns a promise
- dispatch(actionCreator(data));
- })
- .catch((error) => {
- throw error;
- });
- };
-}
-
-// or using async/await
-export async function thunk() {
- return function (dispatch) { // redux-thunk injects dispatch as arg
- try {
- let data = await asyncFunction();
- return dispatch(actionCreator(data));
- } catch(error) {
- throw error;
- }
- }
-}
-```
-
-## [Redux-Toolkit](https://redux-toolkit.js.org/)
-
-The Redux Toolkit package is intended to be the standard way to write Redux logic. It was originally created to help address three common concerns about Redux.
-
-Redux Toolkit also includes a powerful data fetching and caching capability dubbed "RTK Query". It's included in the package as a separate set of entry points. It's optional, but can eliminate the need to hand-write data fetching logic yourself.
-
-These tools should be beneficial to all Redux users. Whether you're a brand new Redux user setting up your first project, or an experienced user who wants to simplify an existing application, Redux Toolkit can help you make your Redux code better.
-Installation
-Using Create React App
-
-The recommended way to start new apps with React and Redux is by using the official Redux+JS template or Redux+TS template for Create React App, which takes advantage of Redux Toolkit and React Redux's integration with React components.
-
-```sh
-# Redux + Plain JS template
-npx create-react-app my-app --template redux
-
-# Redux + TypeScript template
-npx create-react-app my-app --template redux-typescript
-```
-
-Redux Toolkit includes these APIs:
-
-- [`configureStore()`][cfg_store]: wraps `createStore` to provide simplified configuration options and good defaults.
- It can automatically combines slice reducers, adds whatever Redux middleware supplied, includes redux-thunk by default, and enables use of the Redux DevTools Extension.
-
-- [`createReducer()`][new_reducer]: that lets you supply a lookup table of action types to case reducer functions, rather than writing switch statements.
- In addition, it automatically uses the `immer` library to let you write simpler immutable updates with normal mutative code, like `state.todos[3].completed = true`.
-
-- [`createAction()`][new_action]: generates an action creator function for the given action type string.
- The function itself has `toString()` defined, so that it can be used in place of the type constant.
-- [`createSlice()`][new_slice]: accepts an object of reducer functions, a slice name, and an initial state value, and automatically generates a slice reducer with corresponding action creators and action types.
-- [`createAsyncThunk`][new_async_thunk]: accepts an action type string and a function that returns a promise, and generates a thunk that dispatches pending/fulfilled/rejected action types based on that promise
-- [`createEntityAdapter`][entity_adapt]: generates a set of reusable reducers and selectors to manage normalized data in the store
-- The `createSelector` utility from the Reselect library, re-exported for ease of use.
-
-[cfg_store]: https://redux-toolkit.js.org/api/configureStore
-[new_reducer]: https://redux-toolkit.js.org/api/createReducer
-[new_action]: https://redux-toolkit.js.org/api/createAction
-[new_slice]: https://redux-toolkit.js.org/api/createSlice
-[new_async_thunk]: https://redux-toolkit.js.org/api/createAsyncThunk
-[entity_adapt]: https://redux-toolkit.js.org/api/createEntityAdapter
-
-### [`configureStore`](https://redux-toolkit.js.org/api/configureStore)
-
-Included Default Middleware:
-
-- Immutability check middleware: deeply compares state values for mutations. It can detect mutations in reducers during a dispatch, and also mutations that occur between dispatches.
- When a mutation is detected, it will throw an error and indicate the key path for where the mutated value was detected in the state tree. (Forked from `redux-immutable-state-invariant`.)
-
-- Serializability check middleware: a custom middleware created specifically for use in Redux Toolkit
- Similar in concept to `immutable-state-invariant`, but deeply checks the state tree and the actions for non-serializable values such as functions, Promises, Symbols, and other non-plain-JS-data values
- When a non-serializable value is detected, a console error will be printed with the key path for where the non-serializable value was detected.
-
-- In addition to these development tool middleware, it also adds `redux-thunk` by default, since thunks are the basic recommended side effects middleware for Redux.
-
-Currently, the return value of `getDefaultMiddleware()` is:
-
-```js
-// development
-const middleware = [thunk, immutableStateInvariant, serializableStateInvariant]
-
-// production
-const middleware = [thunk]
-```
-
-```js
-
-import { combineReducers } from 'redux'
-import { configureStore } from '@reduxjs/toolkit'
-import monitorReducersEnhancer from './enhancers/monitorReducers'
-import loggerMiddleware from './middleware/logger'
-import usersReducer from './usersReducer'
-import postsReducer from './postsReducer'
-
-const rootReducer = combineReducers({
- users: usersReducer,
- posts: postsReducer,
-})
-
-const store = configureStore({
- // reducers combined automatically
- reducer: rootReducer,
- middleware: (getDefaultMiddleware) => getDefaultMiddleware().concat(loggerMiddleware),
- enhancers: [monitorReducersEnhancer]
-})
-
-export default store
-```
-
-### [`createAction`](https://redux-toolkit.js.org/api/createAction)
-
-```js
-import { createAction } from '@reduxjs/toolkit';
-
-const increment = createAction('counter/increment');
-
-const action = increment(); // { type: 'counter/increment' }
-const action = increment(3); // { type: 'counter/increment', payload: 3 }
-
-increment.toString(); // 'counter/increment'
-```
-
-### [`createReducer`](https://redux-toolkit.js.org/api/createReducer)
-
-```js
-import { createAction, createReducer } from '@reduxjs/toolkit'
-
-interface CounterState {
- value: number
-}
-
-const increment = createAction('counter/increment')
-const decrement = createAction('counter/decrement')
-const incrementByAmount = createAction('counter/incrementByAmount')
-
-const initialState = { value: 0 } as CounterState
-
-const counterReducer = createReducer(initialState, (builder) => {
- builder
- .addCase(increment, (state, action) => {
- state.value++
- })
- .addCase(decrement, (state, action) => {
- state.value--
- })
- .addCase(incrementByAmount, (state, action) => {
- state.value += action.payload
- })
-})
-```
-
-### [`createSlice`](https://redux-toolkit.js.org/api/createSlice)
-
-A function that accepts an initial state, an object of reducer functions, and a "slice name", and automatically generates action creators and action types that correspond to the reducers and state.
-
-Internally, it uses `createAction` and `createReducer`, so it's possible to use Immer to write "mutating" immutable updates.
-
-**Note**: action types will have the `/` shape.
-
-```js
-import { createSlice, PayloadAction } from '@reduxjs/toolkit'
-
-interface CounterState {
- value: number
-}
-
-const initialState = { value: 0 } as CounterState
-
-const counterSlice = createSlice({
- name: 'counter',
- initialState,
- reducers: {
- increment(state) {
- state.value++
- },
- decrement(state) {
- state.value--
- },
- incrementByAmount(state, action: PayloadAction) {
- state.value += action.payload
- },
- },
-})
-
-export const { increment, decrement, incrementByAmount } = counterSlice.actions
-export default counterSlice.reducer
-```
-
-### [`createAsyncThunk`](https://redux-toolkit.js.org/api/createAsyncThunk)
-
-The function `createAsyncThunk` returns a standard Redux thunk action creator.
-The thunk action creator function will have plain action creators for the pending, fulfilled, and rejected cases attached as nested fields.
-
-The `payloadCreator` function will be called with two arguments:
-
-- `arg`: a single value, containing the first parameter that was passed to the thunk action creator when it was dispatched.
-- `thunkAPI`: an object containing all of the parameters that are normally passed to a Redux thunk function, as well as additional options:
- - `dispatch`: the Redux store dispatch method
- - `getState`: the Redux store getState method
- - `extra`: the "extra argument" given to the thunk middleware on setup, if available
- - `requestId`: a unique string ID value that was automatically generated to identify this request sequence
- - `signal`: an `AbortController.signal` object that may be used to see if another part of the app logic has marked this request as needing cancellation.
- - [...]
-
-The logic in the `payloadCreator` function may use any of these values as needed to calculate the result.
-
-```js
-import { createAsyncThunk, createSlice } from '@reduxjs/toolkit'
-
-const payloadCreator = async (arg, ThunkAPI): Promise => { /* ... */ };
-const thunk = createAsyncThunk("", payloadCreator);
-
-thunk.pending; // action creator that dispatches an '/pending'
-thunk.fulfilled; // action creator that dispatches an '/fulfilled'
-thunk.rejected; // action creator that dispatches an '/rejected'
-
-const slice = createSlice({
- name: '',
- initialState,
- reducers: { /* standard reducer logic, with auto-generated action types per reducer */ },
- extraReducers: (builder) => {
- // Add reducers for additional action types here, and handle loading state as needed
- builder.addCase(thunk.fulfilled, (state, action) => { /* body of the reducer */ })
- },
-})
-```
-
-## RTK Query
-
-RTK Query is provided as an optional addon within the `@reduxjs/toolkit` package.
-It is purpose-built to solve the use case of data fetching and caching, supplying a compact, but powerful toolset to define an API interface layer got the app.
-It is intended to simplify common cases for loading data in a web application, eliminating the need to hand-write data fetching & caching logic yourself.
-
-RTK Query is included within the installation of the core Redux Toolkit package. It is available via either of the two entry points below:
-
-```cs
-import { createApi } from '@reduxjs/toolkit/query'
-
-/* React-specific entry point that automatically generates hooks corresponding to the defined endpoints */
-import { createApi } from '@reduxjs/toolkit/query/react'
-```
-
-RTK Query includes these APIs:
-
-- [`createApi()`][new_api]: The core of RTK Query's functionality. It allows to define a set of endpoints describe how to retrieve data from a series of endpoints,
- including configuration of how to fetch and transform that data.
-- [`fetchBaseQuery()`][fetch_query]: A small wrapper around fetch that aims to simplify requests. Intended as the recommended baseQuery to be used in createApi for the majority of users.
-- [`
+ ,
+ rootElement
+);
+```
+
+```js
+// Component.js
+import { connect } from 'react-redux';
+import { increment, decrement, reset } from './actionCreators';
+
+// const Component = ...
+
+// specifies which state is passed to the component (called on state change)
+const mapStateToProps = (state, ownProps /* optional */) => {
+ // structure of the props passed to the component
+ return { propName: state.property };
+};
+
+// specifies the action passed to a component (the key is the name that the prop will have )
+const mapDispatchToProps = { actionCreator: actionCreator };
+// or
+function mapDispatchToProps(dispatch) {
+ return {
+ // wrap action creators
+ actionCreator: (args) => dispatch(actionCreator(args))
+ };
+}
+// or
+function mapDispatchToProps(dispatch) {
+ return {
+ actionCreator: bindActionCreators(actionCreator, dispatch),
+ actions: bindActionCreators(allActionCreators, dispatch)
+ };
+}
+
+// both args are optional
+// if mapDispatch is missing the dispatch function is added to the props
+export default connect(mapStateToProps, mapDispatchToProps)(Component);
+```
+
+## Async Operations with [Redux-Thunk](https://github.com/reduxjs/redux-thunk)
+
+**Note**: Redux middleware runs *after* and action and *before* it's reducer.
+
+Redux-Thunk allows to return functions instead of objects from action creators.
+A "thunk" is a function that wraps an expression to delay it's evaluation.
+
+In `configStore.js`:
+
+```js
+import { createStore, applyMiddleware, compose } from "redux";
+import thunk from "redux-thunk";
+
+function configStore(initialState) {
+ const composeEnhancers =
+ window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ || compose; // support for redux devtools
+
+ return createStore(
+ rootReducer,
+ initialState,
+ composeEnhancers(applyMiddleware(thunk, ...)) // add thunks middleware
+ );
+}
+```
+
+```js
+// usually action on async func success
+function actionCreator(arg) {
+ return { type: TYPE, data: arg };
+}
+
+export function thunk() {
+ return function (dispatch) { // redux-thunk injects dispatch as arg
+ return asyncFunction().then((data) => { // async function returns a promise
+ dispatch(actionCreator(data));
+ })
+ .catch((error) => {
+ throw error;
+ });
+ };
+}
+
+// or using async/await
+export async function thunk() {
+ return function (dispatch) { // redux-thunk injects dispatch as arg
+ try {
+ let data = await asyncFunction();
+ return dispatch(actionCreator(data));
+ } catch(error) {
+ throw error;
+ }
+ }
+}
+```
+
+## [Redux-Toolkit](https://redux-toolkit.js.org/)
+
+The Redux Toolkit package is intended to be the standard way to write Redux logic. It was originally created to help address three common concerns about Redux.
+
+Redux Toolkit also includes a powerful data fetching and caching capability dubbed "RTK Query". It's included in the package as a separate set of entry points. It's optional, but can eliminate the need to hand-write data fetching logic yourself.
+
+These tools should be beneficial to all Redux users. Whether you're a brand new Redux user setting up your first project, or an experienced user who wants to simplify an existing application, Redux Toolkit can help you make your Redux code better.
+Installation
+Using Create React App
+
+The recommended way to start new apps with React and Redux is by using the official Redux+JS template or Redux+TS template for Create React App, which takes advantage of Redux Toolkit and React Redux's integration with React components.
+
+```sh
+# Redux + Plain JS template
+npx create-react-app my-app --template redux
+
+# Redux + TypeScript template
+npx create-react-app my-app --template redux-typescript
+```
+
+Redux Toolkit includes these APIs:
+
+- [`configureStore()`][cfg_store]: wraps `createStore` to provide simplified configuration options and good defaults.
+ It can automatically combines slice reducers, adds whatever Redux middleware supplied, includes redux-thunk by default, and enables use of the Redux DevTools Extension.
+
+- [`createReducer()`][new_reducer]: that lets you supply a lookup table of action types to case reducer functions, rather than writing switch statements.
+ In addition, it automatically uses the `immer` library to let you write simpler immutable updates with normal mutative code, like `state.todos[3].completed = true`.
+
+- [`createAction()`][new_action]: generates an action creator function for the given action type string.
+ The function itself has `toString()` defined, so that it can be used in place of the type constant.
+- [`createSlice()`][new_slice]: accepts an object of reducer functions, a slice name, and an initial state value, and automatically generates a slice reducer with corresponding action creators and action types.
+- [`createAsyncThunk`][new_async_thunk]: accepts an action type string and a function that returns a promise, and generates a thunk that dispatches pending/fulfilled/rejected action types based on that promise
+- [`createEntityAdapter`][entity_adapt]: generates a set of reusable reducers and selectors to manage normalized data in the store
+- The `createSelector` utility from the Reselect library, re-exported for ease of use.
+
+[cfg_store]: https://redux-toolkit.js.org/api/configureStore
+[new_reducer]: https://redux-toolkit.js.org/api/createReducer
+[new_action]: https://redux-toolkit.js.org/api/createAction
+[new_slice]: https://redux-toolkit.js.org/api/createSlice
+[new_async_thunk]: https://redux-toolkit.js.org/api/createAsyncThunk
+[entity_adapt]: https://redux-toolkit.js.org/api/createEntityAdapter
+
+### [`configureStore`](https://redux-toolkit.js.org/api/configureStore)
+
+Included Default Middleware:
+
+- Immutability check middleware: deeply compares state values for mutations. It can detect mutations in reducers during a dispatch, and also mutations that occur between dispatches.
+ When a mutation is detected, it will throw an error and indicate the key path for where the mutated value was detected in the state tree. (Forked from `redux-immutable-state-invariant`.)
+
+- Serializability check middleware: a custom middleware created specifically for use in Redux Toolkit
+ Similar in concept to `immutable-state-invariant`, but deeply checks the state tree and the actions for non-serializable values such as functions, Promises, Symbols, and other non-plain-JS-data values
+ When a non-serializable value is detected, a console error will be printed with the key path for where the non-serializable value was detected.
+
+- In addition to these development tool middleware, it also adds `redux-thunk` by default, since thunks are the basic recommended side effects middleware for Redux.
+
+Currently, the return value of `getDefaultMiddleware()` is:
+
+```js
+// development
+const middleware = [thunk, immutableStateInvariant, serializableStateInvariant]
+
+// production
+const middleware = [thunk]
+```
+
+```js
+
+import { combineReducers } from 'redux'
+import { configureStore } from '@reduxjs/toolkit'
+import monitorReducersEnhancer from './enhancers/monitorReducers'
+import loggerMiddleware from './middleware/logger'
+import usersReducer from './usersReducer'
+import postsReducer from './postsReducer'
+
+const rootReducer = combineReducers({
+ users: usersReducer,
+ posts: postsReducer,
+})
+
+const store = configureStore({
+ // reducers combined automatically
+ reducer: rootReducer,
+ middleware: (getDefaultMiddleware) => getDefaultMiddleware().concat(loggerMiddleware),
+ enhancers: [monitorReducersEnhancer]
+})
+
+export default store
+```
+
+### [`createAction`](https://redux-toolkit.js.org/api/createAction)
+
+```js
+import { createAction } from '@reduxjs/toolkit';
+
+const increment = createAction('counter/increment');
+
+const action = increment(); // { type: 'counter/increment' }
+const action = increment(3); // { type: 'counter/increment', payload: 3 }
+
+increment.toString(); // 'counter/increment'
+```
+
+### [`createReducer`](https://redux-toolkit.js.org/api/createReducer)
+
+```js
+import { createAction, createReducer } from '@reduxjs/toolkit'
+
+interface CounterState {
+ value: number
+}
+
+const increment = createAction('counter/increment')
+const decrement = createAction('counter/decrement')
+const incrementByAmount = createAction('counter/incrementByAmount')
+
+const initialState = { value: 0 } as CounterState
+
+const counterReducer = createReducer(initialState, (builder) => {
+ builder
+ .addCase(increment, (state, action) => {
+ state.value++
+ })
+ .addCase(decrement, (state, action) => {
+ state.value--
+ })
+ .addCase(incrementByAmount, (state, action) => {
+ state.value += action.payload
+ })
+})
+```
+
+### [`createSlice`](https://redux-toolkit.js.org/api/createSlice)
+
+A function that accepts an initial state, an object of reducer functions, and a "slice name", and automatically generates action creators and action types that correspond to the reducers and state.
+
+Internally, it uses `createAction` and `createReducer`, so it's possible to use Immer to write "mutating" immutable updates.
+
+**Note**: action types will have the `/` shape.
+
+```js
+import { createSlice, PayloadAction } from '@reduxjs/toolkit'
+
+interface CounterState {
+ value: number
+}
+
+const initialState = { value: 0 } as CounterState
+
+const counterSlice = createSlice({
+ name: 'counter',
+ initialState,
+ reducers: {
+ increment(state) {
+ state.value++
+ },
+ decrement(state) {
+ state.value--
+ },
+ incrementByAmount(state, action: PayloadAction) {
+ state.value += action.payload
+ },
+ },
+})
+
+export const { increment, decrement, incrementByAmount } = counterSlice.actions
+export default counterSlice.reducer
+```
+
+### [`createAsyncThunk`](https://redux-toolkit.js.org/api/createAsyncThunk)
+
+The function `createAsyncThunk` returns a standard Redux thunk action creator.
+The thunk action creator function will have plain action creators for the pending, fulfilled, and rejected cases attached as nested fields.
+
+The `payloadCreator` function will be called with two arguments:
+
+- `arg`: a single value, containing the first parameter that was passed to the thunk action creator when it was dispatched.
+- `thunkAPI`: an object containing all of the parameters that are normally passed to a Redux thunk function, as well as additional options:
+ - `dispatch`: the Redux store dispatch method
+ - `getState`: the Redux store getState method
+ - `extra`: the "extra argument" given to the thunk middleware on setup, if available
+ - `requestId`: a unique string ID value that was automatically generated to identify this request sequence
+ - `signal`: an `AbortController.signal` object that may be used to see if another part of the app logic has marked this request as needing cancellation.
+ - [...]
+
+The logic in the `payloadCreator` function may use any of these values as needed to calculate the result.
+
+```js
+import { createAsyncThunk, createSlice } from '@reduxjs/toolkit'
+
+const payloadCreator = async (arg, ThunkAPI): Promise => { /* ... */ };
+const thunk = createAsyncThunk("", payloadCreator);
+
+thunk.pending; // action creator that dispatches an '/pending'
+thunk.fulfilled; // action creator that dispatches an '/fulfilled'
+thunk.rejected; // action creator that dispatches an '/rejected'
+
+const slice = createSlice({
+ name: '',
+ initialState,
+ reducers: { /* standard reducer logic, with auto-generated action types per reducer */ },
+ extraReducers: (builder) => {
+ // Add reducers for additional action types here, and handle loading state as needed
+ builder.addCase(thunk.fulfilled, (state, action) => { /* body of the reducer */ })
+ },
+})
+```
+
+## RTK Query
+
+RTK Query is provided as an optional addon within the `@reduxjs/toolkit` package.
+It is purpose-built to solve the use case of data fetching and caching, supplying a compact, but powerful toolset to define an API interface layer got the app.
+It is intended to simplify common cases for loading data in a web application, eliminating the need to hand-write data fetching & caching logic yourself.
+
+RTK Query is included within the installation of the core Redux Toolkit package. It is available via either of the two entry points below:
+
+```cs
+import { createApi } from '@reduxjs/toolkit/query'
+
+/* React-specific entry point that automatically generates hooks corresponding to the defined endpoints */
+import { createApi } from '@reduxjs/toolkit/query/react'
+```
+
+RTK Query includes these APIs:
+
+- [`createApi()`][new_api]: The core of RTK Query's functionality. It allows to define a set of endpoints describe how to retrieve data from a series of endpoints,
+ including configuration of how to fetch and transform that data.
+- [`fetchBaseQuery()`][fetch_query]: A small wrapper around fetch that aims to simplify requests. Intended as the recommended baseQuery to be used in createApi for the majority of users.
+- [`
-
-Raises:
- Exception: Cause of the exception
-"""
-```
-
-### *args **kwargs
-
-`*args` allows the function to accept a variable number of parameters (parameters stored in a tuple)
-`**kwargs` allows the function to accept a variable number of key-value parameters (parameters stored in a dictionary)
-
-When used in combination `*args` always goes before`**kwargs` (in def function and in function call)
-
-```py
-def func(*args, **kwargs):
- # code here
-```
-
-### Function with default parameters
-
-```py
-def function(parameter1 = value1, parameter2 = value3): # default values in case of omitted use of arguments in the call
- # code here
- return expression
-
-function(parameter2 = value2, parameter1 = value1) # arguments passed with keyword to enforce the order of reference
-```
-
-### Global And Local Variables
-
-```py
-# global scope
-
-def external_func():
- # enclosing local scope
-
- def internal_func():
- # local scope
-```
-
-**LEGB Rule**:
-
-- **L** - **Local**: Names assigned in any way within a function (`def` or `lambda`), and not declared global in that function.
-- **E** - **Enclosing function locals**: Names in the local scope of any and all enclosing functions (`def` or `lambda`), from inner to outer.
-- **G** - **Global** (module): Names assigned at the top-level of a module file, or declared global in a def within the file.
-- **B** - **Built-in** (Python): Names preassigned in the built-in names module : `open`, `range`, `SyntaxError`,...
-
-`Note`: variables declared inside a function are not usable outside
-
-```py
-def function():
- # global statement makes a variable global
- # actions on global variable within the function also have an effect outside
-
- global variable
-```
-
-### Iterables, Iterators & Generators
-
-**Iterable**: object implementing `__iter __()`, sequences and objects supporting `__getitem__` with index `0`
-
-**Iterator**: object implementing `__next__` and `__iter__` (**iterator protocol**), when entirely consumed by `next()` it becomes unusable. Returns `StopIteration` when `next()` has returned all elements.
-
-**Generator Function**: function with keyword `yield` (if present also `return` causes `StopIteration`), returns a generator that produces the values one at a time.
-
-**Generator Factory**: generator returning function (may not contain `yield`).
-
-Operation `iter()`:
-
-- calls `__iter__()`
-- in the absence of it python uses `__getitem__()` (if present) to create an iterator that tries to retrieve the items in order, starting from the index `0`
-- on failure it returns `TypeError`
-
-**Note**: `abc.Iterable` does not check for the presence of `__getitem__` to decide if a sub-object is a member therefore the best test for iterability is to use `iter()` and handle exceptions.
-
-### `next()` & `iter()`
-
-```py
-next(iterable) # next item of the iterable or error StopIteration
-
-iter(object) # get an iterator from an object
-# call callable_onj.next () with no arguments as long as it returns non-sentinel values
-
-iter(callable_obj, sentinel)
-```
-
-### Customs Generators
-
-Used to generate a sequence of values to be used once (they are not stored)
-
-```py
-def custom_generator(parameters):
- while condition: # or for loop
- yield variable # returns the value without terminating the function, values passed to the caller without storing in a variable
-
-# generator implementation
-for item in custom_generator(parameters):
- # code here
-```
-
-### Termination Generator And Exception Handling
-
-```py
-# raise exception at the suspension point and return generator value
-# if the generator terminates without returning values it raises StopIteration
-# if an exception is not handled it is propagated to the caller
-generator.throw(ExceptionType, exception_value, traceback)
-
-# raises GeneratorExit to the point of suspension
-# if generator returns a value -> RuntimeError
-# if an exception is raised it propagates to the caller
-generator.close()
-```
-
-### Generator Comprehensions
-
-```py
-# zero-length sequence (instantaneously generated values)
-var = (for expression iterable in sequence if condition)
-# EDUCATION ENUMERATE ()
-# returns a list of tuples associating a position index to each element of the sequence
-# [(0, sequence [0]), (1, sequence [1]), (2, sequence [2]), ...)
-enumerate(sequence) # -> enumerate object
-```
-
-## Coroutines
-
-```py
-def simple_coroutine():
- """coroutine defined as a generator: yield in block"""
-
- # yield in expression to receive data
- # returns None (no variables on the right of yield)
- var = yield value # returns value and then suspends coroutine waiting for input
- # instructions to the right of = executed before instructions to the left of =
-
-gen_obj = simple_coroutine() # returns generator object
-next(gen_obj) # start coroutine (PRIMING)
-gen_obj.send(None) # start coroutine (PRIMING)
-gen_obj.send(value) # send value to the coroutine (only possible in suspended state)
-
-# STATES OF COROUTINE
-inspect.generatorstate() # returns the status of the coroutine
-# GEN_CREATED: waiting to start execution
-# GEN_RUNNING: currently run by the interpreter (visible if multithreaded)
-# GEN_SUSPENDED: currently suspended by yield statement
-# GEN_CLOSED: execution completed successfully
-
-# COROUTINE PRIMING
-from functools import wraps
-
-def coroutine(func):
- "Decorator: primes 'func' by advancing to first 'yield'"
-
- @wraps(func)
- def primer(*args, **kwargs):
- gen = func(*args, **kwargs)
- next(gen)
- return gen
- return primer
-
-# COROUTINE TERMINATION AND EXCEPTION HANDLING
-# exceptions in unhandled coroutines propagate to subsequent iterations
-# an exception causes the coroutine to terminate which it cannot resume
-
-# yield raises exception, if handled loop continues
-# throw() returns value of the generator
-coroutine.throw(exc_type, exc_value, traceback)
-
-# yield raises GeneratorExit to the suspension point
-# if the generator yields a value -> RuntimeError
-# if there are other exceptions they are propagated to the caller
-coroutine.close()
-# coroutine state becomes GEN_CLOSED
-```
-
-### `yield from `
-
-**Note**: auto-priming generators incompatible with `yield from`
-
-**DELEGATING GENERATOR**: generator function containing `yield from`
-**SUBGENERATOR**: generator obtained from `yield from`
-**CALLER-CLIENT**: code calling *delegating generator*
-
-The main function of `yield from` is to open a bidirectional channel between the external caller (*client*) and the internal *subgenerator* so that values and exceptions can pass between the two.
-
-1. client calls delegating generator, delegating generator calls subgenerator
-2. exhausted subgenerator returns value to `yield from ` (`return ` statement)
-3. delegating generator returns `` to client
-
-- Any values that the subgenerator yields are passed directly to the caller of the delegating generator (i.e., the client code).
-
-- Any values sent to the delegating generator using `send()` are passed directly to the subgenerator.
- - If the sent value is `None`, the subgenerator's `__next__()` method is called.
- - If the sent value is not `None`, the subgenerator's `send()` method is called.
- - If the call raises `StopIteration`, the delegating generator is resumed.
- - Any other exception is propagated to the delegating generator.
-
-- `return ` in a generator (or subgenerator) causes `StopIteration()` to be raised upon exit from the generator.
-
-- The value of the `yield from` expression is the first argument to the `StopIteration` exception raised by the subgenerator when it terminates.
-
-- Exceptions other than `GeneratorExit` thrown into the delegating generator are passed to the `throw()` method of the subgenerator.
- - If the call raises `StopIteration`, the delegating generator is resumed.
- - Any other exception is propagated to the delegating generator.
-
-- If a `GeneratorExit` exception is thrown into the delegating generator, or the `close()` method of the delegating generator is called, then the `close()` method of the subgenerator is called if it has one.
- - If this call results in an exception, it is propagated to the delegating generator.
- - Otherwise, `GeneratorExit` is raised in the delegating generator
-
-```py
-def sub_gen():
- sent_input = yield
- # result of sub_gen() returned to delegating_gen()
- # result of yield from
-
- return result
-
-def delegating_gen(var):
- var = yield from sub_gen() # get values from sub_gen
-
-def client():
- result = delegating_gen() # use delegating_gen
- result.send(None) # terminate sub_gen instance (IMPORTANT)
-```
-
-## LAMBDA Functions
-
-Possible use within functions. Useful for replacing functions if the logic is simple.
-
-```py
-var = lambda argument_list:
-```
-
-## Object Oriented Programming
-
-### Class Definition
-
-```py
-class Class:
-
- static_var = expression
-
- def __init__(self, value_1, value_2): # parameterized default constructor
- self.variable = value_1 # create instance variables
- self.__private = value_2 # private, accessed via NAME MANGLING
-
- def method(self, parameters):
- ...
-
- @staticmethod
- def static_method(parameters): # static methods do not affect instance variables (SELF not needed)
- ...
-
- @classmethod # method acting on the class and not on the object (useful for alternative constructors)
- def class_method(cls, parameters):
- ...
-
- object = Class(parameters) # creation of an object
- object.variable = expression # edit public variable
- object.method(parameters) # invocation method of instance
- object._Class__private # access to variable specifying the membership class (NAME MANGLING)
- Class.method(parameters) # static method invocation
-```
-
-### Setter & Getter with `@Property`
-
-```py
-class Class:
- def __init__(self, parameter):
- self.__parameter = parameter
-
- @property # getter
- def parameter(self):
- return self.__parameter
-
- @.setter
- def parameter(self, value):
- self.__parameter = value
-```
-
-### `__slots__`
-
-The `__slots__` attribute implements the **Flyweight Design Pattern**: it saves the instance attributes in a tuple and can be used to decrease the cost in memory by inserting only the instance variables into it (suppress the instance dictionary).
-
-**Default**: attributes saved in a dictionary (`object .__ dict__`)
-**Usage**: `__slots_ = [attributes]`
-
-`__slots__` is not inherited by subclasses, it prevents dynamically adding attributes.
-
-### Inner Classes
-
-```py
-class Class:
- def __init__(self, parameters):
- ...
-
- class InnerClass:
- def __init__(self, parameters):
- ...
-
- def method(self):
- ...
-
-object_1 = Class(arguments) # create 'external' class
-object_2 = Class.InnerClass(arguments) # inner class created as object of the 'external' class
-```
-
-### Special Methods
-
-Special methods are defined by the use of double underscores; they allow the use of specific functions (possibly adapted) on the objects defined by the class.
-
-```py
-class Class():
-
- def __init__(self, parameters):
- instructions
-
- # used by str() and print() method
- # handle requests for impersonation as a string
- def __str__ (self):
- return expression # return required
-
- def __len__ (self):
- return expression # must return as len requires a length / size
-
- def __del__ (self): # delete the class instance
- instruction # any instructions that occur on deletion
-
-object = Class()
-len(object) # special function applied to an object
-del object # delete object
-```
-
-#### Special Methods List
-
-**Note**: if the operator cannot be applied, returns `NotImplemented`
-
-```py
-# arithmetic operators
-__add__(self, other) # +
-__sub__(self, other) # -
-__mul__(self, other) # *
-__matmul__(self, other) # (@) matrix multiplication
-__truediv__(self, other) # /
-__floordiv__(self, other) # //
-__mod__(self, other) # %
-__divmod__(self, other) # divmod()
-__pow__(self, other) # **, pow()
-__lshift__(self, other) # <<
-__rshift__(self, other) # >>
-__and__(self, other) # &
-__xor__(self, other) # ^
-__or__(self, other) # |
-
-# reflex arithmetic operators
-# if self.__ dunder __(other) fails, other.__ dunder__(self) is called
-__radd__(self, other) # reverse +
-__rsub__(self, other) # reverse -
-__rmul__(self, other) # reverse *
-__rmatmul__(self, other) # reverse @
-__rtruediv__(self, other) # reverse /
-__rfloordiv__(self, other) # reverse //
-__rmod__(self, other) # reverse %
-__rdivmod__(self, other) # reverse divmod()
-__rpow__(self, other) # reverse **, pow()
-__rlshift__(self, other) # reverse <<
-__rrshift__(self, other) # reverse >>
-__rand__(self, other) # reverse &
-__rxor__(self, other) # reverse ^
-__ror__(self, other) # reverse |
-
-# in-place arithmetic operators
-# base implementation (built-in) like self = self other
-#! not to be implemented for immutable objects!
-#! in-place operators return self!
-__iadd__(self, other) # +=
-__isub__(self, other) # -=
-__imul__(self, other) # *=
-__imatmul__(self, other) # @=
-__itruediv__(self, other) # /=
-__ifloordiv__(self, other) # //=
-__imod__(self, other) # %=
-__ipow__(self, other) # **=
-__ilshift__(self, other) # <<=
-__irshift__(self, other) # >>=
-__iand__(self, other) # &=
-__ixor__(self, other) # ^=
-__ior__(self, other) # |=
-
-# unary mathematical operators (-, +, abs (), ~)
-__neg__(self) # (-) negazione matematica unaria [if x = 2 then -x = 2]
-__pos__(self) # (+) addizione unaria [x = +x]
-__abs__(self) # [abs()] valore assoluto [|-x| = x]
-__invert__(self) # (~) inversione binaria di un intero [~x == -(x + 1)]
-
-# numeric type conversion
-__complex__(self)
-__int__(self) # if not defined fall-back on __trunc__()
-__float__(self)
-__index__(self) # conversion in bin(), hex(), oct() e slicing
-
-# operations round() math.trunc(), math.floor(), math.ceil()
-__round__(self)
-__trunc__(self)
-__floor__(self)
-__ceil__(self)
-
-# equality operators
-self.__eq__(other) # self == other
-self.__ne__(other) # self != other
-self.__gt__(other) # self > other
-self.__ge__(other) # self >= other
-self.__lt__(other) # self < other
-self.__le__(other) # self <= other
-
-# reflected equality operators
-other.__eq__(self) # other == self, fall-back id(self) == id(other)
-other.__ne__(self) # other != self, fall-back not (self == other)
-other.__gt__(self) # reverse self < other, fall-back TypeError
-other.__ge__(self) # reverse self <= other, fall-back TypeError
-other.__lt__(self) # reverse self > other, fall-back TypeError
-other.__le__(self) # reverse self >= other, fall-back TypeError
-
-# called when the instance is "called" as a function
-# x (arg1, arg2, arg3) is short for x .__ call __ (arg1, arg2, arg3)
-__call__(self, args)
-
-# string object representation for the developer
-__repr__(self)
-
-# string object representation for user (used by print)
-__str__(self)
-
-# specify formatting for format ), str.format() [format_spec = format-mini-language]
-__format__(format_spec)
-
-# returns unique (integer) value for objects that have equal value
-# __EQ__ MUST EXIST IN THE CLASS, usually hash((self.param_1, self.param_2, ...))
-__hash__(self)
-
-# makes object iterable:
-# - returning self (in the iterator)
-# - returning an iterator (in the iterable)
-# - using yield (in the __iter__ generator)
-__iter__(self)
-
-# returns next available element, StopIteration otherwise (iterator scrolls)
-__next__()
-
-# returns truth value
-__bool__()
-
-# returns item associated with key of a sequence (self [key])
-# IndexError if key is not appropriate
-__getitem__(self, key)
-
-# item assignment operation in sequence (self [key] = value)
-# IndexError if key is not appropriate
-__setitem__(self, key, value)
-
-# operation deleting item in sequence (del self [key])
-# IndexError if key is not appropriate
-__delitem__(self, key)
-
-# called by dict.__getitem__() to implement self [key] if key is not in the dictionary
-__missing__(self, key)
-
-# implement container iteration
-__iter__(self)
-
-# implement membership test
-__contains__(self, item)
-
-# implementation issublass (instance, class)
-__instancecheck__(self, instance)
-
-# implementation issubclass (subclass, class)
-__subclasscheck__(self, subclass)
-
-# implement attribute access (obj.name)
-# called if AttributeError happens or if called by __getattribute __()
-__getattr__(self, name)
-
-# implement value assignment to attribute (obj.name = value)
-__setattr__(self, name, value)
-```
-
-**Note**: Itearbility is tricky.
-
-To make an object directly iterable (`for i in object`) `__iter__()` and `__next__()` are needed.
-To make an iterable through an index (`for i in range(len(object)): object[i]`) `__getitem()__` is needed.
-
-Some of the mixin methods, such as `__iter__()`, `__reversed__()` and `index()`, make repeated calls to the underlying `__getitem__()` method.
-Consequently, if `__getitem__()` is implemented with constant access speed, the mixin methods will have linear performance;
-however, if the underlying method is linear (as it would be with a linked list), the mixins will have quadratic performance and will likely need to be overridden.
-
-### Inheritance
-
-```py
-class Parent ():
- def __init __ (self, parameters):
- ...
-
- def method_1(self):
- ...
-
- def method_2(self):
- ...
-
-class Child(Parent): # parent class in parentheses to inherit variables and methods
-
- def __init__(self, parameters, parent_parameters):
- Parent.__init__(self, parent_parameters) # inherit parent variables
- ...
-
- def method (self):
- ...
-
- def method_parent_1 (self): # override method (child class with homonymous method to parent class)
- ...
-
-class Child(Parent): # parent class in brackets to inherit properties
-
- def __init__(self, parameters, parent_parameters):
- super().__init__(parent_parameters) # different method to inherit parent variables (SELF not needed) using SUPER()
- super(Parent, self).__init__(parent_parameters) # parent constructor invoked separately
-
- def method(self):
- ...
-
- def method_2(self): # parent method updated
- super().method_2() # invoke parent method as is
- ...
-```
-
-### Polymorphism
-
-**Note**: python does not support method overloading
-
-```py
-# DUCKTYPING
-# Working with objects regardless of their type, as long as they implement certain protocols
-
-class Class1:
- def method_1(self):
- ...
-
-class Class2:
- def method_1(self):
- ...
-
-# since python is a dynamic language it doesn't matter what type (class) the object passed is
-# the function invokes the object method passed regardless of the object class
-def polymorph_method(object):
- object.method_1()
-
-# DEPENDENCY INJECTION WITH DUCKTYPING
-class Class:
- def __init__(self, object):
- self.dependency = object
-
- def method_1(self): # the function invokes the method of the object passed
- self.dependency.method_1()
-```
-
-### Operator Overloading
-
-**Operators fundamental rule**: *always* return an object, if operation fails return `NotImplemented`
-
-Limitations of operator overloading:
-
-- no overloading of built-in types
-- no creation of new operators
-- no overloading operators `is`, `and`, `or`, `not`
-
-### Astrazione
-
-The **interfaces** are abstract classes with *all* abstract methods, they are used to indicate which methods such as child classes *must* have. Interfaces have *only* a list of abstract methods.
-
-**abstract classes** have *at least* one abstract method; child classes that inherit from an abstract class *must* implement abstract methods. Abstract classes *cannot* be instantiated.
-
-Virtual subclasses are used to include third-party classes as subclasses of a class of their own. They are recognized as belonging to the parent class without however having to implement their methods.
-
-The `@Class.register` or `Class.register(subclass)` decorators are used to mark subclasses.
-
-```py
-from abc import abstractmethod, ABC
-
-class Abstract(ABC): # abstract class MUST INHERIT from parent class ABC
- def __init__(self, parameters):
- ...
-
- def parent_method (self):
- ...
-
- @abstractmethod # abstract method MUST be marked with @abstractmethod decorator
- def abstract_method (self):
- pass
- # abstract method MUST be overridden (can be non-empty)
- # super() to invoke it in the concrete class
-
-class Child(Abstract):
-
- def __init__(self, parameters, parent_parameters):
- parent_class.__init__(self, parent_parameters)
-
- def method (self):
- ...
-
- def parent_method (self): # override method (child class with homonymous method to parent class)
- ...
-
- def abstract_method (self): # implementation of abstract method inherited from abstract class (NECESSARY) by override
- ...
-```
-
-## Exception Handling
-
-```py
-# CHECK ASERATIONS
-assert condition, 'error message' # if the assertion is false show an error message
-
-# particular errors are objects of a particular class of exceptions which in turn is a child of the base exception class (exception)
-class CustomExceptionError(Exception): # MUST somehow inherit from class exception (even in later inheritance steps)
- pass # or instructions
-
-# try block contains code that might cause an exception
-# code inside try and after the error it is not executed
-try:
- ...
- raise CustomExceptionError ("message") # raise the exception
-
-# except takes control of error handling without passing through the interpreter
-# block executed if an error occurs in try
-
-# except error specified by class
-except ExceptionClass:
- # Default error message is not shown
- # the program does not stop
-
-# except on generic errors
-except:
- # code here
-
-# block executed if exception does not occur
-else:
- # code here
-
-# block executed in all cases, cleanup code goes here
-finally:
- # code here
-```
-
-## File
-
-### Opening A File
-
-Text file opening mode:
-
-- `w`: write, overwrite the contents of the file
-- `r`: read, read file contents
-- `a`: append, add content to the file
-- `w +`: write & read
-- `r +`: write & read & append
-- `a +`: append & read
-- `x`: exclusive creation, if the file already exists -> `FileExistError` (extended write mode)
-
-Open binary file mode:
-
-- `wb`: write, overwrites the contents of the file
-- `rb`: read, read file contents
-- `ab`: append, add content to the file
-- `w + b`: write & read
-- `r + b`: write & read & append
-- `a + b`: append & read
-- `xb`: exclusive creation, if the file already exists -> `FileExistError` (extended write mode)
-
-**Note**: Linux and MacOSX use `UTF-8` everywhere while windows uses `cp1252`, `cp850`,`mbcs`, `UTF-8`. Don't rely on default encoding and use **explicitly** `UTF-8`.
-
-```py
-object = open('filename', mode = 'r', encoding = 'utf-8') # encoding MUST BE utf-8 for compatibility
-# filename can be the absolute path to the file location (default: file created in the source code folder)
-# double slash to avoid \ escaping
-
-with open('filename') as file:
- instructions_to_file # block use filename to indicate file
-
-# CLOSE A FILE
-object.close()
-
-# WRITE TO A FILE
-object.write(string) # write single string to file
-object.writelines(* strings) # write multiple strings to file
-
-# READING FROM A FILE
-object.read() # return ALL the contents of the file (including escape sequence) and place the "cursor" at the end of the file
-object.seek(0) # returns 0 (zero) and places the cursor at the beginning of the file
-object.readlines() # return list of file lines (ATTENTION: keep everything in memory, be careful with large files)
-object.readline() # returns single line file
-
-# CHECK FILE EXISTENCE
-import os, sys
-if os.path.isfile('filepath'): # check file existence (TRUE if it exists)
- # code here
-else:
- # code here
- sys.exit() # exits the program and does not execute the next cosice
-```
-
-## COPY
-
-**SHALLOW COPY**: copies the "container" and references to the content
-**DEEP COPY**: copies the "container" and contents (no reference)
-
-```py
-copy (x) # returns shallow copy of xor
-deepcopy (x) # returns shallow copy of x
-```
+# Python Notes
+
+## Basics
+
+### Naming Convention
+
+Class -> PascalCase
+Method, Function -> snake_case
+Variable -> snake_case
+
+```py
+# standard comment
+'''multiline comment'''
+"""DOCSTRING"""
+
+help(object.method) # return method explanation
+dir(object) # return an alphabetized list of names comprising (some of) the attributes of the given object
+
+import sys # import module
+from sys import argv # import single item from a module
+from sys import * # import all elements of a module (no module syntax.method needed)
+import sys as alias # import the module with an alias, I use alias.method
+
+# CHARACTER SET
+import string
+string.ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'
+string.asci_uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+string.asci_letters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
+string.digits = '0123456789'
+string.hexdigits = '0123456789abcdefABCDEF'
+string.octdigits = '01234567'
+string.punctuation
+string.whitespace
+
+# SPECIAL CHARACTERS
+# (\a, \b, \f, \n, \r, \t, \u, \U, \v, \x, \\)
+```
+
+### Assignment Operation
+
+```py
+"""instructions to the right of = executed before instructions to the left of ="""
+variable = expression # the type of the variable is dynamically decided by python based on the content
+var_1, var_2 = value1, value2 # parallel assignment
+var_1, var_2 = var_2, var_1 # swap values
+
+# conditional assignment
+x = a if condition else b
+x = a or b # If bool (a) returns False, then x is assigned the value of b
+# a series of OR expressions has the effect of returning the first item that evaluates True, or the last item (last item should be a literal).
+```
+
+### Variable Type Conversion
+
+`type(expression)`
+
+### Expression Assignment
+
+```py
+(var: = expression) # assign an expression to a variable to avoid repeating the expression
+```
+
+### Variable Comparison (`==` vs `is`)
+
+`==` compares the values of objects
+`is` compares the identities of objects
+
+### On Screen Output
+
+```py
+print() # print blank line and wrap
+print('string' * n) # print string n times
+print('string1 \ n string2') # wrap with \ n
+print(variable) # print variable content
+print('string', end = '') # print without wrapping
+
+# FORMATTING
+name = 'Alex'
+marks = 94.5
+print(name, marks)
+print('Name is', name, '\ nMarks are', marks)
+# expand the rest of the expression and write tense before = in output
+print(f '{name =}, {marks =}') # OUTPUT: name = Alex, marks = 94.5
+
+# USE OF PLACEHOLDERS
+print('Name is% s, Marks are% 3.2f'%(name, marks)) # method inherited from C. Variable is substituted for% ..
+print("Name is {}, Marks are {}". format(name, marks))
+print("Name is {1}, Marks are {2}". format(marks, name)) # indices in brackets sort elements in .format
+print("Name is {n}, Marks are {m}". format(m = '94 .5 ', n =' Alex ')) # indices in brackets sort elements in .format
+print(f'Name is {name}, Marks are {marks} ') # formatting with f-strings
+```
+
+### Format Specification Mini-Language
+
+`{value:width.precision symbol}`
+
+Format: `[[fill]align] [sign] [#] [width] [grouping] [.precision] [type]`
+
+| `[align]` | Alignment |
+| --------- | ---------------------- |
+| `:<` | left alignment |
+| `:>` | right alignment |
+| `:=` | padding after the mark |
+| `:^` | centered |
+
+| `[sign]` | NUMBER SIGNS |
+| -------- | --------------------------------------------------------------------------------------------------------------- |
+| `:+` | sign for both positive and negative numbers |
+| `:-` | sign only for negative numbers |
+| `:` | space for num > 0, '-' for num < 0 |
+| `:#` | alternative form:prefix integers type (0x, 0b, 0o), floats and complexes always have at least one decimal place |
+
+| `[grouping]` | GROUPING |
+| ------------ | ------------------------------------ |
+| `:,` | use comma to separate thousands |
+| `:_` | use underscore to separate thousands |
+
+| `[type]` | OUTPUT TYPE |
+| -------- | --------------------------------------------------------------------------- |
+| `:s` | output is string |
+| `:b` | output is binary |
+| `:c` | output is character |
+| `:d` | output is a decimal integer (base 10) |
+| `:or` | output is octal integer (base 8) |
+| `:x` | output is hexadecimal integer (base 16) |
+| `:X` | output is hexadecimal integer (base 16) with uppercase |
+| `:e` | output is exponential notation (6-digit base precision) |
+| `:E` | output is exponential notation (6-digit base precision) uppercase separator |
+| `:f` | output is float (6-digit base precision) |
+| `:%` | output is percentage (multiplies * 100, displays as:f) |
+
+### Keyboard Input
+
+```py
+# input always returns a STRING
+s = input() # input request without message
+s = input('Prompt') # request input
+i = int(input('prompt')) # request input with type conversion
+
+# MULTIPLE INPUTS
+list = [int(x) for x in input('prompt'). split('separator')]
+# save multiple inputs in a list(.split separates values and defines separator
+```
+
+## Numeric Types
+
+```py
+a = 77
+b = 1_000_000 # underscore can be used to separate groups of digits
+c = -69
+
+# float numbers
+x = 3.15
+y = 2.71
+z = 25.0
+
+d = 6 + 9j # complex number
+# returns a complex number starting with two reals
+complex(real, imag) # -> complex #(real + imag * 1j)
+
+e = 0B1101 # BINARY TYPE(0B ...)
+f = 0xFF # EXADECIMAL TYPE(0X ...)
+o = 0o77 # OCTAL TYPE
+g = True # BOOLEAN TYPE
+
+# VARIABLE TYPE CONVERSION
+h = int(y)
+i = float('22 .5 ')
+
+# NUMERIC BASIC CONVERSION
+bin(3616544)
+hex(589)
+oct(265846)
+
+# UNICODE CONVERSION
+ord(c) # Given a string representing one Unicode character, return an integer representing the Unicode code point of that character
+chr(i) # Return the string representing a character whose Unicode code point is the integer i
+
+
+pow(x, y) # x ^ y
+abs(num) # returns absolute value of num(| num |)
+round(num, precision) # rounds number to given precision, does not convert float to int
+```
+
+### Comparison of Decimal Numbers
+
+Do not use `==` or `! =` To compare floating point numbers. They are approximations or have several digits.
+It is worth checking if the difference between the numbers is small enough.
+
+## Strings
+
+```py
+
+string = 'string content' # assignment and creation of string variable
+string = '''multi
+line
+string'''
+
+string3 = string1 + string2 # string concatenation(operator polymorphism +)
+
+# INDEXING(selection of a character in the string)
+string[0]
+string[2]
+string[-3] # selection starting from the bottom(negative index)
+
+# REPETITION (repeat string output)
+print(string * n)
+
+len(string) # show the length of a string
+
+# SLICING (extraction of sub-strings, does not include the position of the last index)
+string[0: 5]
+string[: 6]
+string[-3: -1]
+
+# SLICING WITH STEP
+string[0: 12: 3]
+string[15 :: - 1]
+string[:: - 1] # selection in reverse order (negative step)
+
+# STRIPPING (elimination of spaces before and after string)
+string = 'stripping test'
+string.strip()
+string.lstrip() # only left spaces removed
+string.rstrip() # only right spaces removed
+string.removeprefix(prefix) # If the string starts with the prefix string, return string [len (prefix):]
+string.removesuffix(suffix) # If the string ends with the suffix string and that suffix is not empty, return string [: - len (suffix)]
+
+# SUBSTRING IDENTIFICATION
+#returns starting index of the substring or -1 if it is not present
+string.find('substring', 0, len (string)) # you can specify the start and end index of the search
+
+# COUNT OF APPARITIONS
+string.count('t')
+
+# REPLACEMENT
+string.replace('multi', 'multiple')
+
+# UPPER CASE CONVERSION
+string.upper()
+string.lower()
+string.title()
+string.capitalize()
+
+# SEPARATION IN LIST ELEMENTS
+string.split()
+string.split('separator') # separate using separator (separator omitted in list)
+string.partition('char') # -> tuple # separates the string from the 3 parts at the first occurrence of separator
+
+# IS_CHECK METHODS -> bool
+string.isalnum()
+string.isalpha()
+string.islower()
+string.isspace()
+string.istitle()
+string.isupper()
+string.endswith('char')
+
+# JOIN INSTRUCTION()
+''.join(iterable) # merges all elements of the iterable into the new string
+
+# FORMATTING
+string.center(width, 'char') # stretch the string with char to width
+'...\t...'.expandtabs() # transform tabs into spaces
+```
+
+## Lists
+
+```py
+list = [9, 11, 'WTC', -5.6, True] # lists can contain data of different types
+
+list[3] # indexing
+list[3: 5] # slicing
+list * 3 # repetition
+len(list) # length
+list3 = list1 + list2 # list concatenation (operator + polymorphism)
+list[index] = value # modify list element
+del (list [1]) # remove by index (INBUILT IN PYTHON)
+# modify the list between the start and stop indices by reassigning the elements of the iterable
+list[start: stop] = iterable
+
+# LIST METHODS
+list.append(object) # add object to background
+list.count(item) # counts the number of occurrences of item
+list.extend(sequence) # add sequence elements to the list
+list.insert(position, object) # insert object in list [position]
+list.index(item) # returns the index of item
+list.remove(item) # remove item
+poplist(item) # delete item and return it
+list.clear() # remove all elements
+
+list.sort() # sorts in ascending order (in place)
+list.sort(reverse = True) # sorts in descending order (in place)
+list.reverse() # invert the string (in place)
+
+# CLONING
+list1 = [...]
+list2 = list1 # list2 points to the same object of list 1 (changes are shared)
+list3 = list1 [:] # list3 is a clone of list1 (no shared changes)
+
+# NESTED LISTS (MATRICES)
+list_1 = [1, 2, 3]
+list_2 = [4, 5, 6]
+list_3 = [7, 8, 9]
+
+matrix = [list_1, list_2, list_3]
+matrix [i][j] # identify element of list_i index j
+
+# MAXIMUM AND MINIMUM
+max(list)
+min(list)
+
+# ALL () & ANY ()
+all(sequence) # returns TRUE if all elements of the sequence are true
+any(sequence) # returns TRUE if at least one element of the sequence has the value True
+
+# MAP INSTRUCTION
+# apply function to iterable and create new list (map object)
+# function can be lambda
+map(function, iterable) # -> map object
+
+# FILTER INSTRUCTION ()
+# create a new list composed of the iterable elements for which the function returns TRUE
+filter(function, iterable) # -> filter object
+
+# ZIP INSTRUCTION ()
+# create a tuple generator by joining two or more iterables
+# [(seq_1 [0], seq_2 [0], ...), (seq_1 [1], seq_2 [1], ...), ...]
+# truncate the sequence to the length of the shortest input sequence
+zip(seq_1, seq_2, ...) # -> zip object (tuple generator)
+
+# LIST COMPREHENSIONS
+var = [expression for element in sequence if condition] # create list from pre-existing list (instead of map, filter, reduce) applying any manipulations
+# expression can be lambda, if is optional
+var = [expression if condition else statement for element in sequence] # list comprehension with IF-ELSE
+var = [expression_1 for element in [expression_2 for element in sequence]] # nested list comprehension
+var = [(exp_1, exp_2) for item_1 in seq_1 for item_2 in seq_2] # -> [(..., ...), (..., ...), ...]
+```
+
+## Tuple
+
+```py
+# TUPLES CANNOT BE MODIFIED
+tuple = (69, 420, 69, 'abc') # tuple assignment
+tuple = (44,) # single element tuples need a comma
+
+tuple[3] # indexing
+tuple * 3 # repetition
+tuple.count(69) # counting
+tuple.index(420) # find index
+len(tuple) # length tuple
+
+# CONVERSION FROM TUPLE TO LIST
+tuple = tuple(list)
+
+# TUPLE UNPACKING
+tup = (item_1, item_2, etc)
+var_1, var_2, etc = tup
+# var_1 = item_1, var_2 = item_2, ...
+
+tup = (item_1, (item_2, item_3))
+var_1, (var_2, var_3) = tup
+# var_1 = item_1, var_2 = item_2, var_3 = item_3
+
+#OPERATOR * VAR (tuple unpacking)
+var_1, var_2, * rest = sequence # var_1 = seq [0], var_2 = seq [1], rest = seq [2:]
+var_1, * body, var_2, var_3 = sequence # var_1 = seq [0], body = seq [1: -2], var_2 = sequence [-2], var_3 = seq [-1]
+# * var retrieves the excess items, if in parallel assignment usable max once but in any position
+```
+
+## Set
+
+```py
+# SETS MAY NOT CONTAIN REPEATED ELEMENTS (THEY ARE OMITTED)
+# THE ORDER DOES NOT MATTER (NO SLICING, INDEXING, REPETITION, ...)
+set = {10, 20, 30, 'abc', 20}
+len(set) # length set
+set() # create empty set ({} create empty dictionary)
+# FREEZING SETS (no longer editable)
+fset = frozenset(set)
+
+# OPERATORS
+set_1 - set_2 # elements in set_1 but not in set_2
+set_1 | set_2 # elements in set_1 or set_2
+set_1 & set_2 # elements in set_1 and set_2
+set_1 ^ set_1 # elements in either set_1 or set_2
+set_1 <= set_2 # elements set_1 also in set_2
+set_1 < set_2 # set_1 <= set_2 and set_1! = set_2
+set_1 >= set_2 # elements set_2 also in set_1
+set_1 > set_2 # set_1> = set_2 and set_1! = set_2
+
+# METHODS SET
+set.pop(item) # remove and return item
+set.add(item) # add item to set
+
+set.copy() # -> set # returns a copy of the set
+set.clear() # remove all elements from the set
+set.remove(item) # remove item from set if present, otherwise raise KeyError
+set.discard(item) # remove item from set if present, otherwise do nothing
+set.difference(* sets) # -> set # returns elements in set that are absent in * sets
+set.difference_update(* sets) # remove differences from set_2
+set.union(* sets) # -> set # returns all elements of sets
+set.update(* sets) # add * sets elements to set
+set.intersection(* sets) # -> set # returns the elements common to sets
+set.intersection_update(* sets) # remove all elements except those common to sets
+set.symmetric_difference(* sets) # -> set # returns elements not common to sets
+set.symmetric_difference_update(* sets) # remove all elements common to sets (leave only uncommon elements)
+
+set_1.isdisjoint(set_2) # -> bool # True if there are no common elements (intersection is empty)
+set_1.issubset(set_2) # -> bool # True if every element of set_1 is also in set_2
+set_1.issuperset(set_2) # -> bool # True if every element of set_2 is also in set_1
+
+# SET COMPREHENSIONS
+var = {expression for element in sequence if condition}
+
+# SLICE OBJECT
+# [start: stop: step] -> slice object (start, stop, step)
+var_1 = slice(start, stop, step) # assignment to variable
+var_2[var_1] # same as var_2 [start: stop: step]
+
+# ELLIPSIS OBJECT
+var[i, ...] # -> shortcut for var [i,:,:,:,]
+# used for multidimensional slices (NumPy, ...)
+
+```
+
+## Bytes e Bytearray
+
+```py
+# THE BYTES CANNOT BE MODIFIED OR INDEXED
+# THE BYTEARRAYS CAN BE MODIFIED AND INDEXED
+# YOU CANNOT DO REPETITION AND SLICING ON BYTE OR BYTEARRAY
+
+b = bytes(list)
+ba = bytearray(list)
+
+# item of bytes and bytearray is always integer between 0 and 255
+# slice of bytes and bytearray is binary sequence (even if len = 1)
+
+# BYTES AND BYTEARRAY METHODS
+bytes.fromhex(pair_hex_digits) # -> byte literal
+b'bite_literal'.hex() # -> str # returns a string containing hex digit pairs
+bytearray.fromhex(pair_hex_digits) # -> byte literal
+bytes.count(subseq, start, end) # returns subseq appearance count between start and end positions
+bytearray.count(subseq, start, end) # returns subseq appearance count between start and end positions
+```
+
+## Encoding-Decoding & Unicode
+
+Unicode Literals:
+
+- `\u0041` --> 'A'
+- `\U00000041` --> 'A'
+- `\x41` --> 'A'
+
+```py
+# ENCODING
+# transform string into literal byte
+# UnicodeEncodeError on error
+# errors = ignore -> skip error-causing characters
+# errors = replace -> replace? to characters causing error
+# errors = xmlcharrefreplace -> substitutes XML entities for error-causing characters
+string.encode('utf-8', errors = 'replace') # -> b'byte literals'
+
+# BOM (BYTE ORDER MARK)
+# byte literal given to indicate byte ordering (little-endian vs big-endian)
+# in little-endian the least significant bytes come first (e.g. U + 0045 -> DEC 069 -> encoded as 69 and 0)
+# U + FEFF (ZERO WIDTH NO-BREAK SPACE) -> b '\ xff \ xfe' indicates little-endian
+
+# DECODING
+# transform byte literal to string
+# error = 'replace' replaces errors (byte literals not belonging to decoding format) with U + FFFD "REPLACEMENT CHARACTER"
+bytes.decode ('utf-8', errors = 'replace') # -> str
+
+# UNICODE NORMALIZATION
+# handling canonical unicode equivalents (e.g. é, and \ u0301 are equivalent for unicode)
+unicodedata.normalize(form, unicode_string) # FORM: NFC, NFD, NFCK, NFDK
+# NFC -> "Normalization Form C" -> produces the shortest equivalent string
+# NFD -> "Normalization Form D" -> produces the longest equivalent string
+
+# CASE FOLDING UNICODE
+# transform to lowercase with some differences (116 differences, 0.11% of Unicode 6.3)
+string.casefold()
+
+# USEFUL FUNCTIONS FOR NORMALIZED EQUIVALENCE (Source: Fluent Python p. 121, Luciano Ramalho)
+from unicodedata import normalize
+
+def nfc_eual(str_1, str_2):
+ return (normalize('NFC', str1) == normalize('NFC', str2))
+def fold_equal (str_1, str_2):
+ return (normalize('NFC', str_1).casefold() ==
+ normalize('NFC', st_2).casefold())
+```
+
+## Memoryview
+
+```py
+# memoryview objects allow python to access the data inside the object
+# without copy if it supports the buffer protocol
+v = memoryview(object) # create a memoryview with reference to object
+# slice of memoryview produces new memoryview
+
+# MEMORYVIEW METHODS
+v.tobytes() # return data as bytestring, equivalent to bytes (v)
+v.hex() # returns string containing two hex digits for each byte in the buffer
+v.tolist() # returns the data in the buffer as a list of elements
+v.toreadonly()
+v.release() # release the buffer below
+v.cast(format, shape) # change the format or shape of the memoryview
+see object # object of the memoryview
+v.format # format of the memoryview
+v.itemsize # size in bytes of each element of the memoryview
+v.ndim # integer indicating the size of the multidimensional array represented
+v.shape # tuple of integers indicating the shape of the memoryview
+```
+
+| Format String | C Type | Python Type | Standard Size |
+| ------------- | -------------------- | ----------- | ------------- |
+| `x` | `pad byte` | `no value` |
+| `c` | `char` | `bytes` | `1` |
+| `b` | `signed char` | `integer` | `1` |
+| `B` | `unsigned char` | `integer` | `1` |
+| `?` | `_Bool` | `bool` | `1` |
+| `h` | `short` | `integer` | `2` |
+| `H` | `unsigned short` | `integer` | `2` |
+| `i` | `int` | `integer` | `4` |
+| `I` | `unsigned int` | `integer` | `4` |
+| `l` | `long` | `integer` | `4` |
+| `L` | `unsigned long` | `integer` | `4` |
+| `q` | `long long` | `integer` | `8` |
+| `Q` | `unsigned long long` | `integer` | `8` |
+| `n` | `ssize_t` | `integer` |
+| `N` | `size_t` | `integer` |
+| `f` | `float` | `float` | `4` |
+| `F` | `double` | `float` | `8` |
+| `s` | `char[]` | `bytes` |
+| `P` | `char[]` | `bytes` |
+
+## Dictionaries
+
+```py
+# SET OF KEY-VALUE PAIRS
+d = {1: 'Alex', 2: 'Bob', 3: 'Carl'}
+d = dict (one = 'Alex', two = 'Bob', three = 'Carl')
+d = dict (zip ([1,2,3], ['Alex', 'Bob', 'Carl']))
+d = dict ([(1, 'Alex'), (2, 'Bob'), (3, 'Carl')])
+
+d[key] # returns value associated with key
+d[4] = 'Dan' # add or change element
+list(d) # returns a list of all elements
+len(d) # returns the number of elements
+del(d[2]) # delete element
+
+# DICTIONARY METHODS
+d.clear() # remove all elements
+d.copy() # shallow copy of the dictionary
+d.get(key) # returns the value associated with key
+d.items() # return key-value pairs (view object)
+d.keys() # return dictionary keys (view object)
+d.values() # returns dictionary values (view object)
+d.pop(key) # remove and return the value associated with key
+d.popitem() # remove and return the last key-value pair
+d.setdefault(key, default) # if the key is present in the dictionary it returns it, otherwise it inserts it with the default value and returns default
+
+d.update(iterable) # add or modify dictionary elements, argument must be key-value pair
+
+# DICT UNION
+d = {'spam': 1, 'eggs': 2, 'cheese': 3}
+e = {'cheese': 'cheddar', 'aardvark': 'Ethel'}
+
+d | e # {'spam': 1, 'eggs': 2, 'cheese': 'cheddar', 'aardvark': 'Ethel'}
+e | d # {'aardvark': 'Ethel', 'spam': 1, 'eggs': 2, 'cheese': 3}
+d |= e # {'spam': 1, 'eggs': 2, 'cheese': 'cheddar', 'aardvark': 'Ethel'}
+
+# NESTED DICTIONARIES (it is possible to nest dictionaries within dictionaries)
+my_dict = {'key_1': 123, 'key_2': [12, 23, 33], 'key_3': ['item_0', 'item_1', 'item_2']}
+my_dict ['key'][0] # returns nested element
+
+# DICT COMPREHENSIONS
+var = {key: value for element in sequence}
+```
+
+## Operators
+
+### Mathematical Operators
+
+| Operator | Operation |
+| -------- | ------------------------------ |
+| x `+` y | addition, string concatenation |
+| x `-` y | subtraction |
+| x `*` y | multiplication |
+| x `*+` y | exponentiation |
+| x `/` y | division (result always float) |
+| x `//` y | integer division |
+| x `%` y | modulo, remainder |
+
+### Relational Operators
+
+| Operator | Operation |
+| -------- | ------------------- |
+| x `<` y | less than |
+| x `<=` y | less or equal to |
+| x `>` y | greater than |
+| x `>=` y | greater or equal to |
+| x `==` y | equality |
+| x `!=` y | inequality |
+
+### Assignment
+
+| Operator | Operation |
+| --------- | ---------- |
+| x `+=` y | x = x + y |
+| x `-=` y | x = x - y |
+| x `*=` y | x = x \* y |
+| x `/=` y | x = x / y |
+| x `//=` y | x = x // y |
+| x `%=` y | x = x % y |
+| x `<<=` y | x = x << y |
+| x `>>=` y | x = x >> y |
+| x `&=` y | x = x & y |
+| x ` | =` y | x = x | y |
+| x `^=` y | x = x ^ y |
+
+### Bitwise Operators
+
+| Operator | Operation |
+| -------- | --------------- |
+| `~`x | bitwise NOT |
+| x `&` y | bitwise AND |
+| x `^` y | bitwise XOR |
+| x `|` y | bitwise OR |
+| x `<<` y | left bit shift |
+| x `>>` y | right bit shift |
+
+### Logical Operators
+
+| Operator | Operation |
+| -------- | ----------- |
+| `and` | logical AND |
+| `or` | logical OR |
+| `not` | logical NOT |
+
+### Identity Operators
+
+| Operator | Operation |
+| -------- | -------------------- |
+| `is` | reference equality |
+| `is not` | reference inequality |
+
+### Membership Operators
+
+| Operator | Operation |
+| -------- | ---------------------- |
+| `in` | item in collection |
+| `not in` | item not in collection |
+
+### OPerator Precedence
+
+1. assignment operators `+=`, `-=`, `*=`, `/=`, `%=`, `**=`, `//=`
+2. binary arithmetic operators `*`, `/`, `%`, `//` (floor division)
+3. binary arithmetic operators `+`, `-`
+4. boolean operators `<`, `>`, `<=`, `>=`
+5. boolean operators `==`, `!=`
+6. boolean operator `and`
+7. boolean operator `or`
+8. boolean operator `not`
+
+## Conditional Statements
+
+Any object can be tested for truth value for use in an if or while condition or as operand of the Boolean operations.
+
+built-in objects considered *false*:
+
+- constants defined to be false: `None` and `False`.
+- zero of any numeric type: `0`, `0.0`, `0j`, `Decimal(0)`, `Fraction(0, 1)`
+- empty sequences and collections: `''`, `()`, `[]`, `{}`, `set()`, `range(0)`
+
+### `if-else`
+
+```py
+if (condition):
+ # code here
+elif (condition):
+ # code here
+else:
+ # code here
+```
+
+### Context Manager
+
+```py
+with resource as target:
+ # code here
+
+# start context manager and bind resource returned by method to target using as operator
+contextmanager.__enter__(self)
+
+# exit runtime context
+# returns exc_type, exc_value, traceback
+contextmanager.__exit__(self, exc_type, exc_value, traceback)
+# exc_type: exception class
+# exc_value: exception instance
+# traceback: traceback object
+# NO EXCEPTION -> returns None, None, None
+# SUPPRESSION EXCEPTION: Must return True value
+```
+
+## Loops
+
+### `while`
+
+```py
+while(condition):
+ # code here
+else:
+ # executed only if condition becomes False
+ # break, continue, return in block while do not perform else block
+ # code here
+```
+
+### `for`
+
+```py
+for index in sequence: # sequence can be a list, set, tuple, etc ..
+ # code here
+else:
+ # executed only if for reaches the end of the loop
+ # break, continue, return in block for do not perform else block
+ # code here
+
+for index in range (start, end, step):
+ # code here
+
+for key, value in dict.items ():
+ # code here
+```
+
+### `break` & `continue`
+
+`break`: causes the loop to exit immediately without executing subsequent iterations
+`continue`: skip the remaining iteration statements and continue the loop
+
+### `range`
+
+```py
+range(start, end, step) # generate sequence num integers (does not include num stops) with possible step
+list(range(start, end, step)) # return sequence of integers in a list
+```
+
+### `enumerate`
+
+```py
+enumerate(iterable) # iterable of item & index pairs
+list(enumerate(iterable)) # returns list of tuples [(1, iterable [0]), (2, iterable [1]), (3, iterable [2])]
+```
+
+### `zip`
+
+```py
+list_1 = [1, 2, 3, 4, 5]
+list_2 = ['a', 'b', 'c', 'd', 'e']
+
+zip(list_1, list_2) # return zip object
+list(zip(list_1, list_2)) # returns list of tuples by merging list [(list_1 [0], list_2 [0]), (list_1 [1], list_2 [1]), ...]
+```
+
+### `shuffle` & `randint`
+
+```py
+from random import shuffle, randint
+shuffle(iterable) # shuffle the list
+randint(start, end) # returns a random integer between start and end
+```
+
+### `in`
+
+```py
+item in iterable # check for the presence of item in iterable (returns True or False)
+```
+
+## Functions
+
+### Function Definition
+
+```py
+def function_name (parameters):
+ "" "DOCSTRING" ""
+ # code here
+ return expression # if return id missing the function returns None
+```
+
+### Specify Type Parameters In Functions
+
+- parameters before `/` can only be *positional*
+- parameters between `/` and `*` can be *positional* or *keyworded*
+- parameters after `*` can only be *keyworded*
+
+```py
+def func (a, b, /, c, d, *, e, f):
+ # code here
+```
+
+### Docstring Style
+
+```py
+"""function description
+
+Args:
+ argument: Type - description of the parameter
+
+Returns:
+ Type - description of
+
+Raises:
+ Exception: Cause of the exception
+"""
+```
+
+### *args **kwargs
+
+`*args` allows the function to accept a variable number of parameters (parameters stored in a tuple)
+`**kwargs` allows the function to accept a variable number of key-value parameters (parameters stored in a dictionary)
+
+When used in combination `*args` always goes before`**kwargs` (in def function and in function call)
+
+```py
+def func(*args, **kwargs):
+ # code here
+```
+
+### Function with default parameters
+
+```py
+def function(parameter1 = value1, parameter2 = value3): # default values in case of omitted use of arguments in the call
+ # code here
+ return expression
+
+function(parameter2 = value2, parameter1 = value1) # arguments passed with keyword to enforce the order of reference
+```
+
+### Global And Local Variables
+
+```py
+# global scope
+
+def external_func():
+ # enclosing local scope
+
+ def internal_func():
+ # local scope
+```
+
+**LEGB Rule**:
+
+- **L** - **Local**: Names assigned in any way within a function (`def` or `lambda`), and not declared global in that function.
+- **E** - **Enclosing function locals**: Names in the local scope of any and all enclosing functions (`def` or `lambda`), from inner to outer.
+- **G** - **Global** (module): Names assigned at the top-level of a module file, or declared global in a def within the file.
+- **B** - **Built-in** (Python): Names preassigned in the built-in names module : `open`, `range`, `SyntaxError`,...
+
+`Note`: variables declared inside a function are not usable outside
+
+```py
+def function():
+ # global statement makes a variable global
+ # actions on global variable within the function also have an effect outside
+
+ global variable
+```
+
+### Iterables, Iterators & Generators
+
+**Iterable**: object implementing `__iter __()`, sequences and objects supporting `__getitem__` with index `0`
+
+**Iterator**: object implementing `__next__` and `__iter__` (**iterator protocol**), when entirely consumed by `next()` it becomes unusable. Returns `StopIteration` when `next()` has returned all elements.
+
+**Generator Function**: function with keyword `yield` (if present also `return` causes `StopIteration`), returns a generator that produces the values one at a time.
+
+**Generator Factory**: generator returning function (may not contain `yield`).
+
+Operation `iter()`:
+
+- calls `__iter__()`
+- in the absence of it python uses `__getitem__()` (if present) to create an iterator that tries to retrieve the items in order, starting from the index `0`
+- on failure it returns `TypeError`
+
+**Note**: `abc.Iterable` does not check for the presence of `__getitem__` to decide if a sub-object is a member therefore the best test for iterability is to use `iter()` and handle exceptions.
+
+### `next()` & `iter()`
+
+```py
+next(iterable) # next item of the iterable or error StopIteration
+
+iter(object) # get an iterator from an object
+# call callable_onj.next () with no arguments as long as it returns non-sentinel values
+
+iter(callable_obj, sentinel)
+```
+
+### Customs Generators
+
+Used to generate a sequence of values to be used once (they are not stored)
+
+```py
+def custom_generator(parameters):
+ while condition: # or for loop
+ yield variable # returns the value without terminating the function, values passed to the caller without storing in a variable
+
+# generator implementation
+for item in custom_generator(parameters):
+ # code here
+```
+
+### Termination Generator And Exception Handling
+
+```py
+# raise exception at the suspension point and return generator value
+# if the generator terminates without returning values it raises StopIteration
+# if an exception is not handled it is propagated to the caller
+generator.throw(ExceptionType, exception_value, traceback)
+
+# raises GeneratorExit to the point of suspension
+# if generator returns a value -> RuntimeError
+# if an exception is raised it propagates to the caller
+generator.close()
+```
+
+### Generator Comprehensions
+
+```py
+# zero-length sequence (instantaneously generated values)
+var = (for expression iterable in sequence if condition)
+# EDUCATION ENUMERATE ()
+# returns a list of tuples associating a position index to each element of the sequence
+# [(0, sequence [0]), (1, sequence [1]), (2, sequence [2]), ...)
+enumerate(sequence) # -> enumerate object
+```
+
+## Coroutines
+
+```py
+def simple_coroutine():
+ """coroutine defined as a generator: yield in block"""
+
+ # yield in expression to receive data
+ # returns None (no variables on the right of yield)
+ var = yield value # returns value and then suspends coroutine waiting for input
+ # instructions to the right of = executed before instructions to the left of =
+
+gen_obj = simple_coroutine() # returns generator object
+next(gen_obj) # start coroutine (PRIMING)
+gen_obj.send(None) # start coroutine (PRIMING)
+gen_obj.send(value) # send value to the coroutine (only possible in suspended state)
+
+# STATES OF COROUTINE
+inspect.generatorstate() # returns the status of the coroutine
+# GEN_CREATED: waiting to start execution
+# GEN_RUNNING: currently run by the interpreter (visible if multithreaded)
+# GEN_SUSPENDED: currently suspended by yield statement
+# GEN_CLOSED: execution completed successfully
+
+# COROUTINE PRIMING
+from functools import wraps
+
+def coroutine(func):
+ "Decorator: primes 'func' by advancing to first 'yield'"
+
+ @wraps(func)
+ def primer(*args, **kwargs):
+ gen = func(*args, **kwargs)
+ next(gen)
+ return gen
+ return primer
+
+# COROUTINE TERMINATION AND EXCEPTION HANDLING
+# exceptions in unhandled coroutines propagate to subsequent iterations
+# an exception causes the coroutine to terminate which it cannot resume
+
+# yield raises exception, if handled loop continues
+# throw() returns value of the generator
+coroutine.throw(exc_type, exc_value, traceback)
+
+# yield raises GeneratorExit to the suspension point
+# if the generator yields a value -> RuntimeError
+# if there are other exceptions they are propagated to the caller
+coroutine.close()
+# coroutine state becomes GEN_CLOSED
+```
+
+### `yield from `
+
+**Note**: auto-priming generators incompatible with `yield from`
+
+**DELEGATING GENERATOR**: generator function containing `yield from`
+**SUBGENERATOR**: generator obtained from `yield from`
+**CALLER-CLIENT**: code calling *delegating generator*
+
+The main function of `yield from` is to open a bidirectional channel between the external caller (*client*) and the internal *subgenerator* so that values and exceptions can pass between the two.
+
+1. client calls delegating generator, delegating generator calls subgenerator
+2. exhausted subgenerator returns value to `yield from ` (`return ` statement)
+3. delegating generator returns `` to client
+
+- Any values that the subgenerator yields are passed directly to the caller of the delegating generator (i.e., the client code).
+
+- Any values sent to the delegating generator using `send()` are passed directly to the subgenerator.
+ - If the sent value is `None`, the subgenerator's `__next__()` method is called.
+ - If the sent value is not `None`, the subgenerator's `send()` method is called.
+ - If the call raises `StopIteration`, the delegating generator is resumed.
+ - Any other exception is propagated to the delegating generator.
+
+- `return ` in a generator (or subgenerator) causes `StopIteration()` to be raised upon exit from the generator.
+
+- The value of the `yield from` expression is the first argument to the `StopIteration` exception raised by the subgenerator when it terminates.
+
+- Exceptions other than `GeneratorExit` thrown into the delegating generator are passed to the `throw()` method of the subgenerator.
+ - If the call raises `StopIteration`, the delegating generator is resumed.
+ - Any other exception is propagated to the delegating generator.
+
+- If a `GeneratorExit` exception is thrown into the delegating generator, or the `close()` method of the delegating generator is called, then the `close()` method of the subgenerator is called if it has one.
+ - If this call results in an exception, it is propagated to the delegating generator.
+ - Otherwise, `GeneratorExit` is raised in the delegating generator
+
+```py
+def sub_gen():
+ sent_input = yield
+ # result of sub_gen() returned to delegating_gen()
+ # result of yield from
+
+ return result
+
+def delegating_gen(var):
+ var = yield from sub_gen() # get values from sub_gen
+
+def client():
+ result = delegating_gen() # use delegating_gen
+ result.send(None) # terminate sub_gen instance (IMPORTANT)
+```
+
+## LAMBDA Functions
+
+Possible use within functions. Useful for replacing functions if the logic is simple.
+
+```py
+var = lambda argument_list:
+```
+
+## Object Oriented Programming
+
+### Class Definition
+
+```py
+class Class:
+
+ static_var = expression
+
+ def __init__(self, value_1, value_2): # parameterized default constructor
+ self.variable = value_1 # create instance variables
+ self.__private = value_2 # private, accessed via NAME MANGLING
+
+ def method(self, parameters):
+ ...
+
+ @staticmethod
+ def static_method(parameters): # static methods do not affect instance variables (SELF not needed)
+ ...
+
+ @classmethod # method acting on the class and not on the object (useful for alternative constructors)
+ def class_method(cls, parameters):
+ ...
+
+ object = Class(parameters) # creation of an object
+ object.variable = expression # edit public variable
+ object.method(parameters) # invocation method of instance
+ object._Class__private # access to variable specifying the membership class (NAME MANGLING)
+ Class.method(parameters) # static method invocation
+```
+
+### Setter & Getter with `@Property`
+
+```py
+class Class:
+ def __init__(self, parameter):
+ self.__parameter = parameter
+
+ @property # getter
+ def parameter(self):
+ return self.__parameter
+
+ @.setter
+ def parameter(self, value):
+ self.__parameter = value
+```
+
+### `__slots__`
+
+The `__slots__` attribute implements the **Flyweight Design Pattern**: it saves the instance attributes in a tuple and can be used to decrease the cost in memory by inserting only the instance variables into it (suppress the instance dictionary).
+
+**Default**: attributes saved in a dictionary (`object .__ dict__`)
+**Usage**: `__slots_ = [attributes]`
+
+`__slots__` is not inherited by subclasses, it prevents dynamically adding attributes.
+
+### Inner Classes
+
+```py
+class Class:
+ def __init__(self, parameters):
+ ...
+
+ class InnerClass:
+ def __init__(self, parameters):
+ ...
+
+ def method(self):
+ ...
+
+object_1 = Class(arguments) # create 'external' class
+object_2 = Class.InnerClass(arguments) # inner class created as object of the 'external' class
+```
+
+### Special Methods
+
+Special methods are defined by the use of double underscores; they allow the use of specific functions (possibly adapted) on the objects defined by the class.
+
+```py
+class Class():
+
+ def __init__(self, parameters):
+ instructions
+
+ # used by str() and print() method
+ # handle requests for impersonation as a string
+ def __str__ (self):
+ return expression # return required
+
+ def __len__ (self):
+ return expression # must return as len requires a length / size
+
+ def __del__ (self): # delete the class instance
+ instruction # any instructions that occur on deletion
+
+object = Class()
+len(object) # special function applied to an object
+del object # delete object
+```
+
+#### Special Methods List
+
+**Note**: if the operator cannot be applied, returns `NotImplemented`
+
+```py
+# arithmetic operators
+__add__(self, other) # +
+__sub__(self, other) # -
+__mul__(self, other) # *
+__matmul__(self, other) # (@) matrix multiplication
+__truediv__(self, other) # /
+__floordiv__(self, other) # //
+__mod__(self, other) # %
+__divmod__(self, other) # divmod()
+__pow__(self, other) # **, pow()
+__lshift__(self, other) # <<
+__rshift__(self, other) # >>
+__and__(self, other) # &
+__xor__(self, other) # ^
+__or__(self, other) # |
+
+# reflex arithmetic operators
+# if self.__ dunder __(other) fails, other.__ dunder__(self) is called
+__radd__(self, other) # reverse +
+__rsub__(self, other) # reverse -
+__rmul__(self, other) # reverse *
+__rmatmul__(self, other) # reverse @
+__rtruediv__(self, other) # reverse /
+__rfloordiv__(self, other) # reverse //
+__rmod__(self, other) # reverse %
+__rdivmod__(self, other) # reverse divmod()
+__rpow__(self, other) # reverse **, pow()
+__rlshift__(self, other) # reverse <<
+__rrshift__(self, other) # reverse >>
+__rand__(self, other) # reverse &
+__rxor__(self, other) # reverse ^
+__ror__(self, other) # reverse |
+
+# in-place arithmetic operators
+# base implementation (built-in) like self = self other
+#! not to be implemented for immutable objects!
+#! in-place operators return self!
+__iadd__(self, other) # +=
+__isub__(self, other) # -=
+__imul__(self, other) # *=
+__imatmul__(self, other) # @=
+__itruediv__(self, other) # /=
+__ifloordiv__(self, other) # //=
+__imod__(self, other) # %=
+__ipow__(self, other) # **=
+__ilshift__(self, other) # <<=
+__irshift__(self, other) # >>=
+__iand__(self, other) # &=
+__ixor__(self, other) # ^=
+__ior__(self, other) # |=
+
+# unary mathematical operators (-, +, abs (), ~)
+__neg__(self) # (-) negazione matematica unaria [if x = 2 then -x = 2]
+__pos__(self) # (+) addizione unaria [x = +x]
+__abs__(self) # [abs()] valore assoluto [|-x| = x]
+__invert__(self) # (~) inversione binaria di un intero [~x == -(x + 1)]
+
+# numeric type conversion
+__complex__(self)
+__int__(self) # if not defined fall-back on __trunc__()
+__float__(self)
+__index__(self) # conversion in bin(), hex(), oct() e slicing
+
+# operations round() math.trunc(), math.floor(), math.ceil()
+__round__(self)
+__trunc__(self)
+__floor__(self)
+__ceil__(self)
+
+# equality operators
+self.__eq__(other) # self == other
+self.__ne__(other) # self != other
+self.__gt__(other) # self > other
+self.__ge__(other) # self >= other
+self.__lt__(other) # self < other
+self.__le__(other) # self <= other
+
+# reflected equality operators
+other.__eq__(self) # other == self, fall-back id(self) == id(other)
+other.__ne__(self) # other != self, fall-back not (self == other)
+other.__gt__(self) # reverse self < other, fall-back TypeError
+other.__ge__(self) # reverse self <= other, fall-back TypeError
+other.__lt__(self) # reverse self > other, fall-back TypeError
+other.__le__(self) # reverse self >= other, fall-back TypeError
+
+# called when the instance is "called" as a function
+# x (arg1, arg2, arg3) is short for x .__ call __ (arg1, arg2, arg3)
+__call__(self, args)
+
+# string object representation for the developer
+__repr__(self)
+
+# string object representation for user (used by print)
+__str__(self)
+
+# specify formatting for format ), str.format() [format_spec = format-mini-language]
+__format__(format_spec)
+
+# returns unique (integer) value for objects that have equal value
+# __EQ__ MUST EXIST IN THE CLASS, usually hash((self.param_1, self.param_2, ...))
+__hash__(self)
+
+# makes object iterable:
+# - returning self (in the iterator)
+# - returning an iterator (in the iterable)
+# - using yield (in the __iter__ generator)
+__iter__(self)
+
+# returns next available element, StopIteration otherwise (iterator scrolls)
+__next__()
+
+# returns truth value
+__bool__()
+
+# returns item associated with key of a sequence (self [key])
+# IndexError if key is not appropriate
+__getitem__(self, key)
+
+# item assignment operation in sequence (self [key] = value)
+# IndexError if key is not appropriate
+__setitem__(self, key, value)
+
+# operation deleting item in sequence (del self [key])
+# IndexError if key is not appropriate
+__delitem__(self, key)
+
+# called by dict.__getitem__() to implement self [key] if key is not in the dictionary
+__missing__(self, key)
+
+# implement container iteration
+__iter__(self)
+
+# implement membership test
+__contains__(self, item)
+
+# implementation issublass (instance, class)
+__instancecheck__(self, instance)
+
+# implementation issubclass (subclass, class)
+__subclasscheck__(self, subclass)
+
+# implement attribute access (obj.name)
+# called if AttributeError happens or if called by __getattribute __()
+__getattr__(self, name)
+
+# implement value assignment to attribute (obj.name = value)
+__setattr__(self, name, value)
+```
+
+**Note**: Itearbility is tricky.
+
+To make an object directly iterable (`for i in object`) `__iter__()` and `__next__()` are needed.
+To make an iterable through an index (`for i in range(len(object)): object[i]`) `__getitem()__` is needed.
+
+Some of the mixin methods, such as `__iter__()`, `__reversed__()` and `index()`, make repeated calls to the underlying `__getitem__()` method.
+Consequently, if `__getitem__()` is implemented with constant access speed, the mixin methods will have linear performance;
+however, if the underlying method is linear (as it would be with a linked list), the mixins will have quadratic performance and will likely need to be overridden.
+
+### Inheritance
+
+```py
+class Parent ():
+ def __init __ (self, parameters):
+ ...
+
+ def method_1(self):
+ ...
+
+ def method_2(self):
+ ...
+
+class Child(Parent): # parent class in parentheses to inherit variables and methods
+
+ def __init__(self, parameters, parent_parameters):
+ Parent.__init__(self, parent_parameters) # inherit parent variables
+ ...
+
+ def method (self):
+ ...
+
+ def method_parent_1 (self): # override method (child class with homonymous method to parent class)
+ ...
+
+class Child(Parent): # parent class in brackets to inherit properties
+
+ def __init__(self, parameters, parent_parameters):
+ super().__init__(parent_parameters) # different method to inherit parent variables (SELF not needed) using SUPER()
+ super(Parent, self).__init__(parent_parameters) # parent constructor invoked separately
+
+ def method(self):
+ ...
+
+ def method_2(self): # parent method updated
+ super().method_2() # invoke parent method as is
+ ...
+```
+
+### Polymorphism
+
+**Note**: python does not support method overloading
+
+```py
+# DUCKTYPING
+# Working with objects regardless of their type, as long as they implement certain protocols
+
+class Class1:
+ def method_1(self):
+ ...
+
+class Class2:
+ def method_1(self):
+ ...
+
+# since python is a dynamic language it doesn't matter what type (class) the object passed is
+# the function invokes the object method passed regardless of the object class
+def polymorph_method(object):
+ object.method_1()
+
+# DEPENDENCY INJECTION WITH DUCKTYPING
+class Class:
+ def __init__(self, object):
+ self.dependency = object
+
+ def method_1(self): # the function invokes the method of the object passed
+ self.dependency.method_1()
+```
+
+### Operator Overloading
+
+**Operators fundamental rule**: *always* return an object, if operation fails return `NotImplemented`
+
+Limitations of operator overloading:
+
+- no overloading of built-in types
+- no creation of new operators
+- no overloading operators `is`, `and`, `or`, `not`
+
+### Astrazione
+
+The **interfaces** are abstract classes with *all* abstract methods, they are used to indicate which methods such as child classes *must* have. Interfaces have *only* a list of abstract methods.
+
+**abstract classes** have *at least* one abstract method; child classes that inherit from an abstract class *must* implement abstract methods. Abstract classes *cannot* be instantiated.
+
+Virtual subclasses are used to include third-party classes as subclasses of a class of their own. They are recognized as belonging to the parent class without however having to implement their methods.
+
+The `@Class.register` or `Class.register(subclass)` decorators are used to mark subclasses.
+
+```py
+from abc import abstractmethod, ABC
+
+class Abstract(ABC): # abstract class MUST INHERIT from parent class ABC
+ def __init__(self, parameters):
+ ...
+
+ def parent_method (self):
+ ...
+
+ @abstractmethod # abstract method MUST be marked with @abstractmethod decorator
+ def abstract_method (self):
+ pass
+ # abstract method MUST be overridden (can be non-empty)
+ # super() to invoke it in the concrete class
+
+class Child(Abstract):
+
+ def __init__(self, parameters, parent_parameters):
+ parent_class.__init__(self, parent_parameters)
+
+ def method (self):
+ ...
+
+ def parent_method (self): # override method (child class with homonymous method to parent class)
+ ...
+
+ def abstract_method (self): # implementation of abstract method inherited from abstract class (NECESSARY) by override
+ ...
+```
+
+## Exception Handling
+
+```py
+# CHECK ASERATIONS
+assert condition, 'error message' # if the assertion is false show an error message
+
+# particular errors are objects of a particular class of exceptions which in turn is a child of the base exception class (exception)
+class CustomExceptionError(Exception): # MUST somehow inherit from class exception (even in later inheritance steps)
+ pass # or instructions
+
+# try block contains code that might cause an exception
+# code inside try and after the error it is not executed
+try:
+ ...
+ raise CustomExceptionError ("message") # raise the exception
+
+# except takes control of error handling without passing through the interpreter
+# block executed if an error occurs in try
+
+# except error specified by class
+except ExceptionClass:
+ # Default error message is not shown
+ # the program does not stop
+
+# except on generic errors
+except:
+ # code here
+
+# block executed if exception does not occur
+else:
+ # code here
+
+# block executed in all cases, cleanup code goes here
+finally:
+ # code here
+```
+
+## File
+
+### Opening A File
+
+Text file opening mode:
+
+- `w`: write, overwrite the contents of the file
+- `r`: read, read file contents
+- `a`: append, add content to the file
+- `w +`: write & read
+- `r +`: write & read & append
+- `a +`: append & read
+- `x`: exclusive creation, if the file already exists -> `FileExistError` (extended write mode)
+
+Open binary file mode:
+
+- `wb`: write, overwrites the contents of the file
+- `rb`: read, read file contents
+- `ab`: append, add content to the file
+- `w + b`: write & read
+- `r + b`: write & read & append
+- `a + b`: append & read
+- `xb`: exclusive creation, if the file already exists -> `FileExistError` (extended write mode)
+
+**Note**: Linux and MacOSX use `UTF-8` everywhere while windows uses `cp1252`, `cp850`,`mbcs`, `UTF-8`. Don't rely on default encoding and use **explicitly** `UTF-8`.
+
+```py
+object = open('filename', mode = 'r', encoding = 'utf-8') # encoding MUST BE utf-8 for compatibility
+# filename can be the absolute path to the file location (default: file created in the source code folder)
+# double slash to avoid \ escaping
+
+with open('filename') as file:
+ instructions_to_file # block use filename to indicate file
+
+# CLOSE A FILE
+object.close()
+
+# WRITE TO A FILE
+object.write(string) # write single string to file
+object.writelines(* strings) # write multiple strings to file
+
+# READING FROM A FILE
+object.read() # return ALL the contents of the file (including escape sequence) and place the "cursor" at the end of the file
+object.seek(0) # returns 0 (zero) and places the cursor at the beginning of the file
+object.readlines() # return list of file lines (ATTENTION: keep everything in memory, be careful with large files)
+object.readline() # returns single line file
+
+# CHECK FILE EXISTENCE
+import os, sys
+if os.path.isfile('filepath'): # check file existence (TRUE if it exists)
+ # code here
+else:
+ # code here
+ sys.exit() # exits the program and does not execute the next cosice
+```
+
+## COPY
+
+**SHALLOW COPY**: copies the "container" and references to the content
+**DEEP COPY**: copies the "container" and contents (no reference)
+
+```py
+copy (x) # returns shallow copy of xor
+deepcopy (x) # returns shallow copy of x
+```
-
-```
-
-```html
-
-
-