python.stash

<meta>index: tags<>
# <#>Python<> Sheet
<meta>index: none<>
<b>Find it faster.<>


This is an interactive <b>Python<> cheat sheet. Covers the core Python programming language. Use the search to instantly get answers.


<card><b>Most Common Searches<>

<table><col><*><link "?q=for-loop#for_-_basics">for loop<>			
<link "?q=if-else#if_else">if else<>
<link "?q=comprehension#list_-_list_comprehension">list comprehension<>
<link "?q=sort+list#list_-_sort">sort list<>
<link "?q=start+async#coroutine_-_start_main_coroutine">start async<><><><col><*><link "?q=open+file">open file<>
<link "?q=file+io+read">read file<>
<link "?q=f-string#f-string_-_basics">f-string<>
<link "?q=reverse+format#format_codes_-_reverse_lookup">reverse format<>
<link "?q=convert+string+to+list#string_-_to_list">string to list<><><><><>


<table><col><b>Basics<>

<*><link "?q=hello+world">Hello World<>
<link "?q=fundamentals-only">Language Fundamentals<>
<link "?q=conventions-only">Naming Conventions<><>

<*><link "?q=control-structure-only">Control Structures<>
<link "?q=error-handling-only">Error Handling<>
<link "?q=functions-only">Functions<>
<link "?q=classes-only">Classes<>
<link "?q=context manager">Context Managers (with as)<>
<link "?q=decorators-only">Decorators<>
<link "?q=iterators">Iterators<>
<link "?q=generators">Generators<>
<link "?q=modules-only">Modules<>
<link "?q=operators-only">Operators<>
<link "?q=distribution">Packaging<>
<link "?q=regex-only">Regular Expressions<>
<link "?q=unit+tests">Unit Tests<>
<link "?q=type+hints">Type Hints<><>

<b>Control Structures<>

<*><link "?q=if-else-only">If Else<>
<link "?q=ternary-only">If / Inline<>
<link "?q=for-only#for_-_basics">For Loop<>
<link "?q=match-only#match_-_basics">Match<>
<link "?q=while-only#while_-_basics">While<><>

<b>Running Python<>

<*><link "?q=command-line-only">Command Line<>
<link "?q=pip-only">PIP / Libraries<>
<link "?q=venv-only">Virtual Environments<><>

<b>Files<>

<*><link "?q=file+io">File IO<>
<link "?q=file-only+operations">File Operations<>
<link "?q=directory+operations">Directory Operations<>
<link "?q=path-only">Path Operations<><>

<b>Functions<>

<*><link "?q=encode+decode">Encode / Decode<>
<link "?q=json-only">JSON<>
<link "?q=math-only">Math<>
<link "?q=random-only">Random<>
<link "?q=sequence-functions-only">Sequence<><>

<b>Libraries<>

<*><link "?q=argparse-only">Argparse<>
<link "?q=configparser-only">Config Parser<>
<link "?q=csv-only">CSV<>
<link "?q=http-only">HTTP / Internet<><>

<b>Parallelism<>

<*><link "?q=asyncio-only">Async / Await<>
<link "?q=thread-only">Threads<>
<link "?q=process-only">Processes<><>

<*><link "?q=event-only">Events<>
<link "?q=futures-only">Futures<>
<link "?q=lock-only">Lock<>
<link "?q=process-pipes-only">Pipes<>
<link "?q=process-pool-only">Process Pools<>
<link "?q=multi-queue-only">Queues<>
<link "?q=semaphore-only">Semaphore<>
<link "?q=shared-value-only">Shared Memory<><>

<b>Reference<>

<*><link "?q=acronyms-only">Acronyms<>
<link "?q=online-docs-only">Online Docs<>
<link "?q=reserved-only">Reserved Words<>
<link "?q=terms-only">Terms<>
<link "?q=symbols-only">Symbols<><>

<><col><b>Data Types<>

<*><link "?q=variables-only">Variables<>
<link "?q=literals-only">Literals<>
<link "?q=data-types-only">Data Types<>
<link "?q=conversions-only">Data Conversions<><>

<*><link "?q=none-only">None<>
<link "?q=boolean-only">Boolean<>
<link "?q=byte-only">Byte<>
<link "?q=complex-only">Complex Numbers<>
<link "?q=decimal-only">Decimal<>
<link "?q=float-only">Float<>
<link "?q=integer-only">Integer<>
<link "?q=strings-only">String<><>

<*><link "?q=date-only">Date<>
<link "?q=datetime-only">Datetime<>
<link "?q=timezone-only">Time Zones<>
<link "?q=timedelta-only">TimeDelta<>
<link "?q=timestamp-only">Timestamp<><>

<*><link "?q=enum-only">Enum<>
<link "?q=dict-only">Dict<>
<link "?q=list-only">List<>
<link "?q=set-only">Set<>
<link "?q=tuple-only">Tuple<><>

<*><link "?q=standard-queue-only">Queue<>
<link "?q=deque-only">Deque<>
<link "?q=ordered-dict-only">Ordered Dict<><>

<b>Sequences<>

<*><link "?q=sequence-only">Sequences<>
<link "?q=slice-only#index_and_slicing_-_basics">Slicing<>
<link "?q=destructure-only#sequence_destructuring_-_basics">Destructuring<><>

<b>Strings<>

<*><link "?q=strings-only">Strings<>
<link "?q=f-string#f-string_-_basics">F-Strings<>
<link "?q=string-format()-only">Format() Strings<>
<link "?q=formatting-only">Formatting<>
<link "?q=reverse+format#format_codes_-_reverse_lookup">Formatting / Reverse Lookup<>
<link "?q=regex-only">Regular Expressions<><>

<b>Structures<>

<*><link "?q=dataclass-only">Dataclass<>
<link "?q=namedtuple-only">Named Tuple<><>

<b>How To<>

<*><link "?q=how-to">How Tos<><>
<*><link "?q=execute-only">Run Commands<><>

<*><link "?q=input-only">Input<>
<link "?q=print-only">Print<>
<link "?q=formatting-only">Formatting<><>

<*><link "?q=sleep-only">Sleep<>
<link "?q=timer-only">Timers<><>

<b>Related SpeedSheets<>

<*><link "aiogram">aiogram<>
<link "aiohttp">aiohttp<>
<link "beautifulsoup">beatuiful soup<>
<link "jinja">jinja<>
<link "matplotlib">matplotlib<>
<link "numpy">numpy<>
<link "pillow">pillow<>
<link "poetry">poetry<>
<link "pynput">pynput<>
<link "pytest">pytest<>
<link "requests">requests<>
<link "tkinter">tkinter<><><><>



# Online Documents
@
@ online-docs-only, docs-only

##### Python Documents
<l>https://docs.python.org/3/<>

##### Python Language Reference
<l>https://docs.python.org/3/reference/index.html<>

##### Python Libraries
<l>https://docs.python.org/3/library/index.html<>

##### Python PEPs
<l>https://peps.python.org/pep-0000/<>

##### Amazing Python Scripts (I)
<l>https://github.com/vinta/awesome-python<>

##### Amazing Python Scripts (II)
<l>https://github.com/avinashkranjan/Amazing-Python-Scripts<>



# The Python Philosophy

Enter from within the Python CLI:

<cb>import this<>


Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!
@
@ Easter egg, import this



# Hello World
@
@ Examples



### Hello World

Create and run the following Python script.


File Name:

<cb>hello.py<>

File Contents:

<cb>print("<v>Hello World!<>")<>

Run From The Command-line:

<cb>python3 hello.py<>



### Hello World - With Input

File Name:

<cb>hello2.py<>

File Contents:

<cb><v>name<> = input("Enter Name: ")

if not <v>name<>:
	<v>name<> = "World"

print("<v>hello <>" + <v>name<> + "<v>!<>")<>

Run From The Command-line:

<cb>python3 hello2.py<>



### Hello World - With Command-line Arguments

This version takes one argument and displays it as the name.


File Name:

<cb>hello2.py<>

File Contents:

<cb>from sys import argv		<#>#1<>

if len(argv) > 1:			<#>#2<>
	<v>name<> = argv[1]			<#>#3<>
else:
	<v>name<> = "World"			<#>#4<>

print("<v>hello <>" + <v>name<> + "<v>!<>")<>

Run From The Command-line:

<cb>python3 hello2.py <v>your_name_here<><>


\#1  <s>-<>  Importing argv allows the program to get arguments passed in from the command-line.

\#2  <s>-<>  Check if any arguments were passed in.

\#3  <s>-<>  Take the first argument as the name.

\#4  <s>-<>  The default value for the name when none is given.
@
@ arguments, args, parameters, params



# Language Fundamentals
@
@ language-fundamentals-only, fundamentals-only



### Comments

<cb><#># This is a comment.<><>

Start the comment with a hash '#'.
Comments are ignored by the compiler.
@
@ #



### Comments - Multiline

There are no multiline comments in Python.
@
@ Multiline



### DocString

<cb><#>"""Python Docstring."""<><>

They are defined as a text between a set of 3 double quotes.
Place after the class or function definition.

See also: __doc__


Examples:

<cb>def <v>documented_function<>():
	<#>"""This docstring
	documents the function of this function
	"""<><>
@
@ code, documentation, docstring-only, docstr-only, doc-string-only, doc-str-only, """, double quotes, __doc__
 


### Escape Character

<table><col>Escape Syntax<><col><c>\\<v>x<><><>
<col> <>
<col>Backslash ( \\ )<><col><c>\\\\<><>
<col>Single Quote ( ' )<><col><c>\\'<><>
<col>Double Quote ( " )<><col><c>\\"<><>
<col> <>
<col>Backspace<><col><c>\\b<><>
<col>Carriage Return<><col><c>\\r<><>
<col>Newline<><col><c>\\n<><>
<col>Tab<><col><c>\\t<><>
<col>Vertical Tab<><col><c>\\v<><>
<col> <>
<col>Null<><col><c>\\0<><><col>(octal value)<>
<col> <>
<col>Hex Value<><col><c>\\x<><><col><c>\\x<v>ff<><><>
<col>Octal Value<><col><c>\\<><><col><c>\\<v>777<><><>
<col>Unicode, 16-Bit<><col><c>\\u<><><col><c>\\u<v>ff<><><>
<col>Unicode, 32-Bit<><col><c>\\U<><><col><c>\\U<v>77<><><>
<col> <>
<col>Unicode Character / Emoji<><col><c>\\N{}<><><col><c>\\N{<v>name<>}<><><>


Example:

<cb>= "<v>\\"A quoted string.\\"<>"<>

<cb>= "<v>1st Line\\n2nd Line<>"<>
@
@ Newline, New Line, End of Line, Line Separator, \\n, \\r, \\\\, \\', \\", \\t, null, \\00, String
@ /n, /r, //, /', /", /t, /00, single quote, double quote, backslash, carriage return
@ whitespaces, white spaces, characters, tab, newline, nl, null



### Blocks, Indentation

Blocks are defined by indentation.

Code on the same indent level are in the same block.
Python will not allow mixed indentation


Example:

<cb><#># Outer block<>
print('Outer Block')

if True:

	<#># Inner Block<>
	print('    Inner Block')<>
@
@ Tabs, indenting



### Class Inheritance

Python supports Multiple Inheritance.
@
@ extend


### Interfaces

Not supported in Python.

Use abstract classes instead.
Or simply rely on duck typing.



### Indexes

0 Based.

Indexes are 0 based.
To get the first element, reference element 0.


Example:

<cb><v>first<> = <v>some_list<>[0]<>
@
@ indexing, base, zero, one, []



### Identifiers

<cb>( <v>letter<> | _ )( <v>letter<> | <v>digit<> | _ )*<>

Regex Form:

<cb>[_a-zA-Z][_0-9a-zA-Z]*<>

Case sensitive.
The first character must be an alphabet letter or underscore, not a digit.
All other characters can be alphabet letters, underscores or digits.


Examples:

<cb><v>a1<>
<v>item_2<>
<v>three_word_name<><>
@
@ Python names, variable names, module names, class names
@ Rules, Valid, allowable, allowed, Name, Correct



### Python Environment Variable

<cb>PYTHONPATH<>

Path to modules and packages.


Python checks <c>PYTHONPATH<> directories for modules and packages.
Python adds this to <c>sys.path<>.
@
@ PYTHONPATH, path, sys.path



### Passing Arguments - Pass By Assignment (Default)

Pass by Assignment

Python passes by assignment by default (same as pass by value).
Objects are passed by assigning the object reference.
@
@ args, arguments, assignment, reference, pass by value, parameters, params



### Passing Arguments - Options

Call Passing as list:

<cb>= <v>func_1<>(*<v>list_1<>)			<#>#1<><>

Call Passing as dict:

<cb>= <v>func_2<>(**<v>dict_1<>)			<#>#2<><>


Receive as list:

<cb>def <v>func_3<>(*args):			<#>#3<>
	<v>...<><>

Receive as dict:

<cb>def <v>func_4<>(**kwargs):		<#>#4<>
	<v>...<><>


\#1  <s>-<>   <c>list_1<> will be unpacked to function arguments in list order.

\#2  <s>-<>   <c>dict_1<> will be converted into their named arguments inside the function.

\#3  <s>-<>   Converts arguments to a list.

\#4  <s>-<>   Converts named arguments to a dict.
@
@ args, arguments, list, dict, kwargs, Single Asterisk, Double Asterisks, parameters, params, *args, **kwargs, *kwargs



### Scope

Scope Levels

	Module
	Class
	Function
	Closure
	Generator Expression
	Comprehension

There is no block level scope


Example:

<cb><v>module_level_variable<> = "Module Scope"


class <v>SomeClass<>:
	def __init__(self):
		self.<v>class_level_variable<> = "Class Level"


def <v>SomeFunction<>():
	<v>function_level_variable<> = "Function Level"


<v>generator<> = (<v>generator_level_variable<>
		for <v>generator_level_variable<> in
		["Generator Level", "Generator Level"])


<v>comprehension<> = [<v>comprehension_level_variable<>
		for <v>comprehension_level_variable<> in
		["Comprehension Level", "Comprehension Level"]]<>
@
@ variables



### Startup Module - __main__.py

<cb>__main__.py<>


Python calls this as the starting module by default.
@
@ entry, starting



### Statement - Multiline Statement

<cb><v>...<> \\
<v>...<><>

The '\\' at the line's end indicates line continues on next line.


Note:

Prefer using parenthesis '<c>( )<>', brackets '<c>[ ]<>', braces '<c>{ }<>' for multiline statements for clarity.


Example:

<cb>string_1 = "<v>Part 1 and <>" + \\
		"<v>part 2 and <>" + \\
		"<v>part 3<>"<>
@
@ Split, Separate, Separator, Wrap, multiline statement, \\, next line, continue on



### Statement - Statement Separator

<cb><v>statement<>;<>

Optional

Use a semicolon ';' to separate statements.
Allows multiple statements in one line.


Examples:

<cb>print("Optional command separator");

print("one"); print("two"); print("three");<>
@
@ Line Terminator, multi-statement, multistatement line, ;, semicolon



# Naming Conventions
@
@ Names, naming-conventions-only, conventions-only



## Naming Conventions - Basics

<table><col>Class<><col><v>TitleCase<><>
<col> <>
<col>Constant<><col><v>UPPER_SNAKE_CASE<><>
<col> <>
<col>Magic Method<><col>__<v>snake_case<>__
(leading and trailing double underscore)<>
<col> <>
<col>Module<><col><v>snake_case<>
(short name)<>
<col> <>
<col>Private Name<><col>_<v>name<>
(use leading underscore)<>
<col> <>
<col>Variable<><col><v>snake_case<><>
<col> <>
<col>Variable - Constant<><col><v>UPPER_SNAKE_CASE<><>
<col> <><>
@
@ summary



## Naming Conventions - Details


### Convention - Class Names

<cb>class <v>ClassName1<>:<>

Use TitleCase, no underscore separator.



### Convention - Function Names

<cb>def <v>function_name_1<> <v>...<><>

Use snake case, all lower case letters, underscores between words.



### Convention - Magic Methods

<cb>__<v>magic_method_name<>__<>

Lead and end with a double underscore. All letters are lower case. Words are separated by underscores.



### Convention - Module Names

<cb><v>short_name<><>

Use a short name for module file names. Use snake case if necessary.



### Convention - Private Names

<cb>_<v>private_name_1<><>

Identify variables and functions as private by leading with an underscore.


Examples:

<cb>def _<v>private_func_1<>():
    <v>...<><>
@
@ _, leading underscore



### Convention - Variables

<cb><v>variable_name_1<><>

Use snake case, all lower case letters, underscore separator between words.


Example:

<cb><v>ok_status_code<> = <v>200<><>



### Convention - Variable Constants

<cb><v>CONSTANT_NAME_1<><>

Use upper snake case, all upper case letters, underscore separator between words.

Note: There is no mechanism in Python to enforce constants. They are normal variables.


Example:

<cb><v>OK_STATUS<> = <v>200<><>



### Convention - Underscores

<card><table><col>Single, Leading<><col><c>_<v>name<><>	<><col>Private function, method or variable.
For internal use only.<>
<col> <>
<col>Single, Trailing<><col><c><v>name<>_<><><col>Use to avoid clashing with reserved words.
(<c>class_<>, <c>def_<>, <c>in_<>)<>
<col> <>
<col>Double, Leading<><col><c>__<v>name<><><><col>Used by Python for class name mangling.
Avoid using.<>
<col> <>
<col>Double, Both Ends<><col><c>__<v>name<>__<><><col>Special methods used by Python to enable special features.
(<c>__name__<>, <c>__repr__<>, <c>__next__<>)<>
<col> <>
<col>Single<><col><c>_<><><col>Used as a temporary variable or to indicate 'any' value.
<c>(match _:), (lambda _ : <v>...<>)<><>
<><>
@
@ _ vs __, double, single



# Command-line
@
@ commandline, command line, cli, cli-only, command-line-only, commandline-only



### Python - Version

<cb>python --version<>

<cb>python3 --version<>

Shows the current python version from the command-line.
@
@ Get, number, python3, --version



### REPL - Start

<cb>python3<>


Starts the REPL.
@
@ cli, run, python3



### REPL - Get Last Evaluated Expression

<cb>= _<>

<cb>print (_)<>

Underscore <c>'_'<> stores the result of the last evaluated expression.
@
@ cli, value, underscore, _



### REPL - Exit

<cb>Control + D<>

<cb>exit()<>


Press the keys <c>Control + D<> or type <c>exit()<> to quit.
@
@ End, Terminate, Stop, kill, Quit, CLI, exit()



### Application / Script - Run Program

<cb>python3 <v>python_file.py<><>

Run from the source root directory.
@
@ Start, Launch, python3
@ program



### Application / Script - Run Module

<cb>python3 -m <v>package<>.<v>module_name<><>

Run from parent directory to the <c><v>package<><> directory.
<c><v>package<><> is the directory containing the module.
<c><v>module_name<><> is the python module file without the <c>.py<> extension.

Run from source root directory.
@
@ python3, -m, subdirectory, subfolder
@ program



### Application - Run Directory

<cb>python3 <v>source_directory<><>

This will run a python program from it's source directory.

The source directory must contain <c>__main__.py<>.
Place your startup code in that file.
Python will call it to start the application.


Directory Structure:

<cb><v>src<>\
	__main__.py
	<v>...<><>

Run:

<cb>python3 <v>src<><>
@
@ python3, program, src



# Unit Test - Command-line
@
@ cli, command-line-only, commandline-only, python3,
@ __mai__.py



### Unit Test - Run All

<cb>python3 -m unittest<>

Python will search for and run all tests in the current directory and subdirectories.



### Unit Test - Run Module

<cb>python3 -m unittest <v>module_name<><>

<cb>python3 -m unittest <v>package_name<>.<v>module_name<><>

Run from source root directory.
@
@ subfolder, subdirectory



### Unit Test - Run Test Class

<cb>python3 -m unittest <v>module_name<>.<v>TestClass<><>

<cb>python3 -m unittest <v>package_name<>.<v>module_name<>.<v>TestClass<><>

Run from source root directory.



### Unit Test - Run Test Method

<cb>python3 -m unittest <v>module_name<>.<v>TestClass<>.<v>test_method<><>

<cb>python3 -m unittest <v>package_name<>.<v>module_name<>.<v>TestClass<>.<v>test_method<><>

Run from source root directory.



# Distribution
@
@ Package, Dist
@ packaging
@ distribution-only, packaging-only, package-only



### Application Distribution - Egg - Create

Steps:

<*>Create the startup module <c>__main__.py<>.
Zip all python files into a single zip file.<>


Zip the contents of the source folder into a zip file to create a distibutable egg file.
Include the __main__.py file. This will be called on startup of the egg file.

The root directory of the zip file must be the root directory of the python source files.
Do not place files into a directory in the zip file.
@
@ Deploy, __main__.py



### Application Distribution - Egg - Run

<cb>python3 <v>egg_file<>.egg<>

<cb>python3 <v>egg_file<>.zip<>


This will run an egg file by calling the included __main__.py file.

Install and run an environment prior to running the egg file, if required.
@
@ .egg, .zip



### Application Distribution - Egg - Starting Module

<cb>__main__.py<>


Add a module called <v>__main__.py<> to your code.
Python will call this when starting your application.
@
@ __main__.py, entry point, startup



### Application Distribution - Wheel - Setup

Steps:

<*>Create <c>setup.py<>
Create <c>/src/__init_-.py<><>


Create <c>setup.py<> in the project directory.
Create <c>__init__.py<> in the source root directory.


Example setup.py:

<cb>from setuptools import setup, find_packages

setup(
	name='<v>package_name<>',  						<#># Required<>
	version='<v>2<>.<v>0<>.<v>1<>',  							<#># Required<>
	description='<v>package description here<>.',	<#># Required<>
	packages=find_packages(exclude=['contrib', 'docs', 'tests']),	<#># Required<>
)<>
@
@ setup.py, setuptools, find_packages, setup(), .whl, __init__.py



### Application Distribution - Wheel - Create

<cb>python3 setup.py sdist bdist_wheel<>

Run from project root directory.
Creates wheel distribution file in the<c>/dist<>.
@
@ setup.py, sdist, bdist_wheel, .whl



# PIP - Package Manager
Python's Package Manager.

Installs and manages libraries and their dependencies.

PIP = PIP Installs Packages
@
@ pip-only



## PIP - Installed Package Location

<cb><v>python_home_directory<>/lib/python3.<v>x<>/site-packages<>

The location of packages installed by PIP.
@
@ Directory, Library, GET



## PIP - Requirements File



### PIP - Requirements File - File Name

<cb>requirements.txt<>

Place in project root directory.


Note: The <c><v>requrements.txt<><> name is by convention only.
@
@ Library File, requirements.txt



### PIP - Requirements File - Sample File

In <c>requirements.txt<>:

<cb><#># This is a comment line.<>

<v>package_1_name<>					<#># Latest Version<>

<v>package_2<>==<v>1<>.<v>2<>.<v>3<>				<#># Specific Version<>

<v>package_3<>>=<v>1<>.<v>2<>.<v>3<>				<#># Specific Version or Higher<>

-r <v>other_requirements.txt<>		<#># Include packages from this file too.<><>
@
@ Example, Versioning, requirements.txt, ==, >=, !=, -r



## Commands



### PIP - Upgrade

<cb>pip install --upgrade pip<>

Upgrades PIP to the latest version.
@
@ Application, install --upgrade, update, --update



### PIP - Version

<cb>pip -V<>

or

<cb>pip --version<>
@
@ -v, --version



### PIP - Package - Install

<cb>pip install <v>package_name<><>

or

<cb>pip install <v>package_name<>==<v>1<>.<v>2<>.<v>3<><>
@
@ Library, version



### PIP - Package - Install From Requirements File

<cb>pip install -r <v>requirements.txt<><>

Installs all the packages listed in the requirements.txt file.
@
@ packages, libraries, library
@ -r, requirements.txt



### PIP - Package - Install From Wheel File

<cb>pip install <v>package_name<>.whl<>
@
@ Library, Package File, .whl



### PIP - Package - Install Using Proxy

<cb>pip install <v>package_name<> --proxy="<v>proxyserver.com<><>

<cb>pip install <v>package_name<> --proxy="https://<v>user<>:<v>password<>@<v>proxyserver.com<><>
@
@ packages, libraries, library
@ Library, --proxy



### PIP - Package - Install, Force

<cb>pip install --force-reinstall <v>package_name<><>
@
@ packages, libraries, library, virtual environment
@ --force-reinstall



### PIP - Package - Upgrade

<cb>pip install --upgrade <v>package_name<><>
@
@ packages, libraries, library
@ library, install, --upgrade, --update, update



### PIP - Package - Upgrade, Force

<cb>pip install --upgrade --force-reinstall <v>package_name<><>
@
@ packages, libraries, library
@ library, install, --upgrade, --force-reinstall, --update, update



### PIP - Package - Uninstall

<cb>pip uninstall <v>package_name<><>
@
@ packages, libraries, library
@ library, Remove



### PIP - Package - View Details

<cb>pip show <v>package_name<><>
@
@ show



### PIP - Packages - List All

<cb>pip list<>

Lists all installed packages and their versions.
@
@ all, libraries, show all



### PIP - Packages - Upgrade All

<cb>pip install -r requirements.txt<>


Upgrades any existing libraries.

Just run normal install command to upgrade the libraries.
@
@ update
@ pip install -r



### PIP - Requirements File - Create

<cb>pip freeze > <v>requirements.txt<><>

Create requirements file from installed packages.

Uses the packages installed in the current virtual environment.
If no environment, uses the global packages.
@
@ command, library, libraries, packages, freeze



# Operators
@
@ Operators, Operations, Expressions
@ op-only, operator-only, operators-only



### Arithmetic Operators

<in-2><table><col><c><v>a<> + <v>b<>		<><>
<col><c><v>a<> - <v>b<><><>
<col><c><v>a<> * <v>b<><><>
<col><c><v>a<> / <v>b<><><><col>Always Returns a Float<>
<col><c><v>a<> // <v>b<><><><col>Floor Divide ( 9 // 4 = 2)<>
<col> <>
<col><c><v>a<> % <v>b<><><><col>Modulo ( 7 % 3 = 1)<>
<col><c><v>a<> ** <v>b<><><><col>To The Power of<><><>
@
@ %, **, +, -, /, //
@ power, modulo, modulus, plus, minus, divide, multiply, floor
@ basics, summary



### Arithmetic Assignment Operators

Assign:

<in-2><table><col><c><v>a<> = <v>value<><><><><>

Calculate and update variable:

<in-2><table><col><c><v>a<> += <v>value<>	<><>
<col><c><v>a<> -= <v>value<><><>
<col><c><v>a<> *= <v>value<><><>
<col><c><v>a<> /= <v>value<><><>
<col><c><v>a<> //= <v>value<><><><col>Floor Divide<>
<col><c><v>a<> %= <v>value<><><><col>Modulo<>
<col><c><v>a<> **= <v>value<><><><col>To The Power of<><><>
@
@ =, +=, -=, *=, /=, //=, %=, **=, =+, =-, =*, =/, =//, =%, =**
@ power, modulo, modulus, plus, minus, divide, multiply, floor
@ basics, summary



### Assignment Operator - Conditional Operator

<cb>= <v>true_expression<> if <v>test_condition<> else <v>false_expression<><>


Ternary conditional operator.
@
@ Ternary conditional operator, tertiary
@ Inline If, iif, if else, ?
@ ternary-only



### Assignment Expression (Walrus Operator)

<cb><v>value_1<> := <v>value_2<><>

<cb>if <v>value_1<> := <v>value_2<>:
	<v>...<><>

<cb>while (<v>item<> := <v>next_item<>()):
	<v>...<><>

Does 2 Things:

	Assigns a Value
	Returns That Value

This is usually used when the right side of the assignment is a function.


Example:

<cb><v>count<> = 0

while (<v>count<> := count + 1) < 5:
	print(<v>count<>)

<#># Prints 1 to 4, Then Exits<><>
@
@ Walrus Operator, :=



### Comparison Operators

<in-2><table><col><c><v>a<> == <v>b<>	<><><col>Equal In Value<>
<col><c><v>a<> != <v>b<><><>
<col><c><v>a<> > <v>b<><><>
<col><c><v>a<> \< <v>b<><><>
<col><c><v>a<> >= <v>b<><><>
<col><c><v>a<> \<= <v>b<><><>
<col> <>
<col><c><v>a<> is <v>b<><><><col>Identity / Same Item<>
<col><c><v>a<> is not <v>b<><><><><>
@
@ Boolean, ==, !=, \<>, \<, \<=, >, >=, is, not
@ less than, greater than, less that or equal, greater than or equal
@ compare, camparator
@ basics, summary



### Logical Operators

<in-2><c><v>a<> and <v>b<><>
<c><v>a<> or <v>b<><>
<c>not <v>b<><><>

Versus <c>&&<>, <c>||<>, <c>!<> used in other languages.
@
@ Boolean, and, or, not, negation, &&, ||, !
@ basics, summary



### Bitwise Operators
@
@ bitwise-only, binary



#### Bitwise Operators - Basics

<in-2><table><col><c>~<v>a<><><><col>Complement / Inverse<>
<col> <>
<col><c><v>a<> & <v>b<><><><col>Bitwise AND<>
<col><c><v>a<> | <v>b<><><><col>Bitwise OR<>
<col><c><v>a<> ^ <v>b<><><><col>Bitwise XOR<>
<col> <>
<col><c><v>a<> \<\< <v>shift_count<><><><col>Bitwise Shift Left<>
<col><c><v>a<> >> <v>shift_count<><><><col>Bitwise Shift Right<><>
@
@ &, |, ^, \<\<, >>
@ summary



#### Bitwise Complement

<cb>= ~<v>a<><>

Same As:

<cb>= -<v>a<> - 1<>


Performs a bitwise complement on the value.
Because Python's integers are signed, this is not a straight inversion of the bits.


Example:

<cb><v>a<> = 0b<v>110<>

<v>complement<> = ~<v>a<>

print(f'{<v>complement<>:b}')

<#># Prints: -111<><>
@
@ ~, NOT



#### Bitwise AND

<cb>= <v>a<> & <v>b<><>


Example:

<cb><v>a<> = 0b<v>1100<>
<v>b<> = 0b<v>1010<>

<v>value<> = <v>a<> & <v>b<>

print(f'{<v>value<>:04b}')

<#># Prints: 1000<><>
@
@ &



#### Bitwise OR

<cb>= <v>a<> | <v>b<><>


Example:

<cb><v>a<> = 0b<v>1100<>
<v>b<> = 0b<v>1010<>

<v>value<> = <v>a<> | <v>b<>

print(f'{<v>value<>:04b}')

<#># Prints: 1110<><>
@
@ |



#### Bitwise XOR

<cb>= <v>a<> ^ <v>b<><>


Example:

<cb><v>a<> = 0b<v>1100<>
<v>b<> = 0b<v>1010<>

<v>value<> = <v>a<> ^ <v>b<>

print(f'{<v>value<>:04b}')

<#># Prints: 0110<><>
@
@ ^



#### Bitwise Shift Left

<cb>= <v>a<> \<\< <v>shift_count<><>


Example:

<cb><v>a<> = 0b<v>1100<>

<v>value<> = <v>a<> \<\< <v>2<>

print(f'{<v>value<>:b}')

<#># Prints: 110000<><>
@
@ \<\<



#### Bitwise Shift Right

<cb>= <v>a<> >> <v>shift_count<><>


Example:

<cb><v>a<> = 0b<v>1100<>

<v>value<> = <v>a<> >> <v>2<>

print(f'{<v>value<>:04b}')

<#># Prints: 0011<><>
@
@ >>




### Identity Operators

Is The Same?:

<cb>= <v>x<> is <v>y<><>

<cb>= <v>x<> is not <v>y<><>


Same Memory Location?:

<cb>= id(<v>x<>) is id(<v>y<>)<>

<cb>= id(<v>x<>) is not id(<v>y<>)<>


<c>is<> and <c>is not<> compare items' identities to see if they are the same.
<c>id<> compares memory locations.
@
@ id, is not, memory location, pointer, compare, same, equals
@ Object, id()



### Operators - Is Empty?

<cb>= not <v>var_1<><>

<cb>if not <v>var_1<>:
	<v>...<><>

Use on sequences, strings, lists, sets, dicts, tuples.


Example:

<cb>if not <v>dict_1<>:
	print("<v>dict_1<> is empty.")
else:
	print("<v>dict_1<> not empty.")<>
@
@ Non-empty, None, sequences, strings, lists, sets, dicts, tuples, equals, not



### Operators - Not Empty?

<cb>if <v>var_1<>:
	<v>...<><>

Use on sequences, strings, lists, sets, dicts, tuples.


Example:

<cb>if <v>dict_1<>:
	print("<v>dict_1<> not empty.")
else:
	print("<v>dict_1<> is empty.")<>
@
@ Non-empty, None, sequences, strings, lists, sets, dicts, tuples, equals, not



### Operators - Is Between

<cb>= <v>min<> \< <v>value<> \< <v>max<>

= <v>min<> \<= <v>value<> \<= <v>max<><>

<cb>if <v>min<> \< <v>value<> \< <v>max<>:
	<v>...<>

if <v>min<> \<= <v>value<> \<= <v>max<>:
	<v>...<><>


Examples:

<cb><v>value<> = <v>1<>

<#># True:<>

print (0 \< <v>value<> \< 2)

<#>`alse:<>

print (1 \< <v>value<> \< 2)

<#># True:<>

print (1 \<= <v>value<> \< 2)<>



### Operator Precedence

From Highest To Lowest:


<table><col><c>(<v>...<>)<>, <c>[<v>...<>]<>, <c>{<v>key<>: <v>value<>}<>, <c>{<v>...<>}<><><col><#># Parenthesis, List, Dictionary or Set<><>
<col> <>
<col><c><v>x<>[<v>index<>]<>, <c><v>func_1<>()<>, <c><v>x<>.<v>attrib<><><><col><#># Subscripts, Slicing, Calls, Attributes<><>
<col> <>
<col><c>await <v>x<><><><col><#># Await Expression<><>
<col> <>
<col><c>**<><><col><#># Exponent<><>
<col> <>
<col><c>+<v>x<><>, <c>-<v>x<><>, <c>~<v>x<><><><col><#># Positive, Negative, Bitwise NOT<><>
<col> <>
<col><c>*<>, <c>/<>, <c>//<>, <c>%<>, <c>@<><><col><#># Multiply, Divide, Floor Divide, Remainder (Modulo), Matrix Multiply<><>
<col> <>
<col><c>+<>, <c>-<><><col><#># Add, Subtract<><>
<col> <>
<col><c>\<\<<>, <c>>><><><col><#># Bitwise Shift<><>
<col> <>
<col><c>&<><><col><#># Bitwise AND<><>
<col> <>
<col><c>^<><><col><#># Bitwise XOR<><>
<col> <>
<col><c>|<><><col><#># Bitwise OR<><>
<col> <>
<col><c>in<>, <c>not in<>, <c>is<>, <c>is not<>, <c>\<<>, <c>\<=<>, <c>><>, <c>>=<>, <c>!=<>, <c>==<><><col><#># Comparators<><>
<col> <>
<col><c>not<><><col><#># Boolean NOT<><>
<col> <>
<col><c>and<><><col><#># Boolean AND<><>
<col> <>
<col><c>or <><><col><#># Boolean OR<><>
<col> <>
<col><c>if else<><><col><#># Conditional Operator<><>
<col> <>
<col><c>lambda<><><col><#># Lambda Expression<><>
<col> <>
<col><c>:=<><><col><#># Assignment Operator<><><>



### == vs is vs id()

==:

<*>Value Operator
Compares the Value of the Operands
True If Same Value<>

is:

<*>Identity Operator
Compares the Operands Identity
True If Same Item<>

id():

<*>Memery Operator
Compares Memory Locations
True If Same Location<>



# Control Structures
@
@ statements, flow
@ control-only, control-structure-only, control-structures-only
@ control-statements-only


### Control Structures - Basics

<table><col>If Else		<><col><c>if <v>condition_1<>:
	<v>...<><><>
<col> <>
<col> <>
<col> <><col><c>if <v>condition_1<>:
	<v>...<>
elif <v>condition_2<>:
	<v>...<>
else:
	<v>...<><><>
<col> <>
<col> <>
<col>For<><col><c>for <v>i<> in range(<v>max_plus_1<>):
	<v>...<><><>
<col> <>
<col> <>
<col> <><col><c>for <v>item<> in <v>sequence_1<>:
	<v>...<><><>
<col> <>
<col> <>
<col> <><col><c>for <v>item<> in <v>sequence_1<>:
	<v>...<>
	break
	<v>...<>
	continue
else:
	<v>...<><><>
<col> <>
<col> <>
<col>Match<><col><c>match <v>variable_1<>:

    case <v>value_1<>:
        <v>...<>

    case <v>value_2<> | <v>value_3<>:
        <v>...<>

    case (<v>value_4_1<>, <v>value_4_2<>):
        <v>...<>

    case <v>Class1<>(<v>param_1<>, <v>param_2<>):
        <v>...<>

    case <v>Enum1<>.<v>ENUM_1<>:
        <v>...<>

    case (<v>value_8<>, <v>x<>):
        <v>...<>

    case (<v>value_8<>, <v>x<>) if <v>condition<>:
        <v>...<>   

    case _:
        <v>...<><><>
<col> <>
<col> <>
<col>While<><col><c>while <v>condition<>:
	<v>...<><><>
<col> <>
<col> <>
<col> <><col><c>while <v>condition<>:
	<v>...<>
	break
	<v>...<>
	continue
	<v>...<>
else:
	<v>...<><><><>
@
@ summary



### If Else

<cb>if <v>condition_1<>:
	<v>...<>
elif <v>condition_2<>:
	<v>...<>
else:
	<v>...<><>
@
@ basics, conditionals
@ then, else, elif, elseif
@ if-only, if-else-only


### For
@
@ for-only, loop, loops, for-loops



#### For - Basics

<cb>for <v>item<> in <v>sequence_1<>:
	<v>...<><>

<cb>for <v>i<> in range(<v>max_plus_1<>):
	<v>...<><>

<cb>for <v>item_1<>, <v>item_2<>, <v>...<> in <v>sequence_1<>:      <#># Unpack<>
	<v>...<><>

<cb>for <v>item<> in <v>sequence_1<>:
	<v>...<>
	break
	<v>...<>
	continue
else:
	<v>...<><>
@
@ loop through, iterate, iterating, continue, break, else, skip



#### For - Else

<cb>for <v>i<> in range(<v>range_options<>):
	<v>...<>
else:
	<v>...<><>


The <c>else<> block executes after the <c>for<> block completes.

<c>break<> skips the <c>else<> block. 


Examples:

<cb>for <v>i<> in range(3):
	print(i)
else:
	print("done")<>
@
@ range, forelse, for-else



#### For - In Dict

<cb>for <v>key<>, <v>element<> in <v>dict_1<>.items():
	<v>...<><>
@
@ each, foreach, over
@ dict, dictionary, .items(), iterating, iterate



#### For - In Range

<cb>for <v>i<> in range(<v>end_plus_1<>):
	<v>...<><>

<cb>for <v>i<> in range(<v>start<>, <v>end_plus_1<>):
	<v>...<><>


Loops through a sequence of values from 0 (or <c>start<> if given) to one value before the end value.


Examples:

<cb>for <v>i<> in range(5):                        <#># Loops through 0, 1, 2, 3, 4.<>
	<v>...<><>

<cb>for <v>i<> in range(1,5):                  <#># Loops through 1, 2, 3, 4.<>
	<v>...<><>
@
@ range()



#### For - In Range With Step

<cb>for <v>i<> in range(<v>start<>, <v>end_plus_one<>, <v>step<>):
	<v>...<><>


Example:

<cb>for <v>i<> in range(2, 9, 2):                  <#># Loops through 2, 4, 6, 8.<>
	print(<v>i<>)<>
@
@ over, step, range()



#### For - In Sequence

<cb>for <v>element<> in <v>sequence<>:
	<v>...<><>

<cb>for <v>element<> in <v>sequence<>:
	<v>...<>
	break                               <#># Exit for loop.<>
	<v>...<>
	continue                            <#># Jump to next iteration.<><>

A sequence can be a list, array, etc.


Example:

<cb><v>list_1<> = [<v>'a'<>, <v>'b'<>, <v>'c'<>]

for <v>item<> in <v>list_1<>:
	<v>...<><>
@
@ each, foreach, over, iterate, iterating



#### For - In Sequence of Tuples, Unpacked

<cb>for <v>item_1<>, <v>item_2<>, <v>...<> in <v>tuple_sequence<>:
	<v>...<><>

Separates inside each element inside <c><v>tuple_sequence<><>.
Works for lists too.


Example:

<cb><v>tuples<> = [(<v>"tuple 1"<>, <v>1<>), (<v>"tuple 2"<>, <v>2<>), (<v>"tuple 3"<>, <v>3<>)]

for <v>name<>, <v>value<> in <v>tuples<>:
	print(<v>name<>, ":", <v>value<>)

<#># Prints:
\#
\# tuple 1 : 1
\# tuple 2 : 2
\# tuple 3 : 3<><>
@
@ each, foreach, destructure, destructuring, In



#### For - Nested For

<cb>for <v>i<> in range(<v>count_1<>):
	for <v>j<> in range(<v>count_2<>):
		<v>...<><>

Example:

<cb>for <v>tens<> in range(2):
    for <v>units<> in range(5):
    	print(str(<v>tens<>) + str(<v>units<>))<>
@
@ nesting



#### For - Break Continue

<cb>for <v>item<> in <v>sequence_1<>:
	<v>...<>
	break
	<v>...<>
	continue
@
@ next, skip, exit, iteration



### Match

Python Version: 3.10+
@
@ Structural Pattern Matching, match by
@ switch, case, match-only



#### Match - Basics

<cb>match <v>variable_1<>:

    case <v>value_1<>:
        <v>...<>

    case <v>value_2<> | <v>value_3<>:			<#>Matches Either Value<>
        <v>...<>

    case (<v>value_4_1<>, <v>value_4_2<>):	<#>Tuple<>
        <v>...<>

    case [<v>value_5_1<>, <v>value_5_2<>]:	<#>List<>
        <v>...<>

    case {<v>key_6<>: <v>value_6<>}:			<#>Dict (Contains)<>
        <v>...<>

    case <v>Class1<>(<v>field_1<>, <v>field_2<>):	<#>Class<>
        <v>...<>

    case <v>Enum1<>.<v>ENUM_1<>:				<#>Enum<>
        <v>...<>

    case (<v>value_8<>, <v>x<>):				<#>Bind To Variable<>
        <v>...<>

    case (<v>value_8<>, <v>x<>) if <v>condition<>:
        <v>...<>   

    case _:							<#>Unmatched<>
        <v>...<><>



#### Match - Bind To Variable

<cb>match <v>item_1<>:
    case <v>variable_1<>:
        <v>...<>
    case (<v>value<>, <v>variable_1<>):
        <v>...<>
    case (<v>variable_1<>, <v>variable_2<>, <v>variable_3<>):
        <v>...<>
    case _:
        <v>...<><>


Captures one or more values and binds them to variables.


Example:

<cb><v>item_1<> = (<v>1<>, <v>2<>)

match <v>item_1<>:
    case (1, <v>a<>):
        print (f'(1, a = {<v>a<>})')
    case (2, <v>b<>):
        print (f'(2, b = {<v>b<>})')
    case _:
        print('Unmatched Value')

<#># Prints: (1, a = 2)<><>
@
@ capture pattern, value



#### Match - Match Specific Values

<cb>match <v>item_1<>:
    case <v>value_1<>:
        <v>...<>
    case <v>value_2<> | <v>value_3<>:
        <v>...<>
    case _:
        <v>...<><>


Matches the value of the variable with the value of the case statements.
If matched, the case statement will execute.


Examples:

<cb><v>int_1<> = 2

match <v>int_1<>:
    case <v>1<>:
        print ('Value 1')
    case <v>2<> | <v>3<>:
        print ('Value 2 or 3')
    case _:
        print ('Unmatched Value')

<#># Prints: 'Value 2 or 3'<><>


<cb><v>month<> = '<v>feb<>'

match <v>int_1<>:
    case '<v>jan<>':
        print ('January')
    case '<v>feb<>':
        print ('February')
    case _:
        print ('Unmatched Month')

<#># Prints: 'It's February'<><>
@
@ multiple, either or



#### Match - Match 'Constants'

<cb>class <v>Constants<>:
    <v>CONSTANT_1<> = <v>value_1<>
    <v>CONSTANT_2<> = <v>value_2<>

match <v>item_1<>:
    case <v>Constants<>.<v>CONSTANT_1<>:
        <v>...<>
    case <v>Constants<>.<v>CONSTANT_2<>:
        <v>...<>
    case _:
        <v>...<><>


Define constants in a class and reference them statically.

Note: If you do not include the class name, <c>match<> will think these are structural pattern variables and will assign values to them.


<cb>class <v>Status<>:
	<v>OK<> = '<v>ok<>'
	<v>ERROR<> = '<v>error<>'

<v>status<> = '<v>ok<>'

match <v>status<>:
    case <v>Status<>.<v>OK<>:
        print ("Status OK")
    case <v>Status<>.<v>ERROR<>:
        print ("Status Error")
    case _:
        print ("Status Unknown")

<#># Prints: "Status OK"<><>



#### Match - Match Classes

<cb>match <v>value<>:
    case <v>Class1<>():
        <v>...<>
    case <v>Class2<>(<v>field_1<>, <v>field_2<>:
        <v>...<>
    case _:
        <v>...<><>


Matches on class type and class field values.
@
@ type, name



#### Match - Match Dict

<cb>match <v>dict_1<>:
    case {<v>key_1<>: <v>value_1<>}:
        <v>...<>
    case {<v>key_2<>: <v>value_2<>, <v>key_3<>: <v>value_3<>}:
        <v>...<>
    case _:
        <v>...<><>


Matches key, value pairs in a dictionary.
If the pair exists, the case block will execute.
This is independent of any other values in the dict.


Examples:

<cb><v>dict_1<> = {'<v>b<>': '<v>b1<>', '<v>z<>': '<v>z1<>'}

match <v>dict_1<>:
    case {'<v>a<>': '<v>a1<>'}:
        print('Value a:a1')
    case {'<v>b<>': '<v>b0<>'}:
        print('Value b:b0')
    case {'<v>b<>': '<v>b1<>'}:
        print('Value b:b1')
    case _:
        print('Unmatched value.')

<#># Prints: 'Value b:b1'<><>
@
@ by key, value, dicts



#### Match - Match Enums
@
@ enumerations

<cb>class <v>Enum1<>(Enum):
    <v>ENUM_1<> = <v>value_1<>
    <v>ENUM_2<> = <v>value_2<>

match <v>item_1<>:
    case <v>Enum1<>.<v>ENUM_1<>:
        <v>...<>
    case <v>Enum1<>.<v>ENUM_2<>:
        <v>...<>
    case _:
        <v>...<><>


Matches the values of an enumerated type.


<cb>from enum import Enum, auto

class <v>Status<>(Enum):
    <v>OK<> = '<v>ok<>'
    <v>ERROR<> = '<v>error<>'

<v>status<> = <v>Status<>.<v>OK<>

match <v>status<>:
    case <v>Status<>.<v>OK<>:
        print ("Status OK")
    case <v>Status<>.<v>ERROR<>:
        print ("Status Error")
    case _:
        print ("Status Unknown")

<#># Prints: "Status OK"<><>



#### Match - Match Lists

<cb>match <v>list_1<>:
    case [<v>value_1<>]:
        <v>...<>
    case [<v>value_2<>]:
        <v>...<>
    case [<v>value_3_1<>, <v>value_3_2<>]:
        <v>...<>
    case _:
        <v>...<><>


Matches the internal values of the variable with the value of the case statements.
If matched, the case statement will execute.


Example:

<cb><v>list_1<> =[<v>1<>, <v>3<>]

match <v>list_1<>:
    case [<v>1<>]:
        print ('Value [1]')
    case [<v>1<>, <v>2<>]:
        print ('Value [1, 2]')
    case [<v>1<>, <v>3<>]:
        print ('Value [1, 3]')
    case _:
        print ('Unmatched Value')

<#># Prints: Value (1, 3)'<><>
@
@ values



#### Match - Match Tuples

<cb>match <v>tuple_1<>:
    case (<v>value_1<>):
        <v>...<>
    case (<v>value_2<>):
        <v>...<>
    case (<v>value_3_1<>, <v>value_3_2<>):
        <v>...<>
    case _:
        <v>...<><>


Matches the internal values of the variable with the value of the case statements.
If matched, the case statement will execute.


Example:

<cb><v>tuple_1<> =(<v>1<>, <v>3<>)

match <v>tuple_1<>:
    case (<v>1<>):
        print ('Value (1)')
    case (<v>1<>, <v>2<>):
        print ('Value (1, 2)')
    case (<v>1<>, <v>3<>):
        print ('Value (1, 3)')
    case _:
        print ('Unmatched Value')

<#># Prints: Value (1, 3)'<><>



#### Match - Match If / Conditionally

<cb>match <v>item_1<>:
    case <v>...<> if <v>condition<>:
        <v>...<><>


Will match the case only when <v>condition<> is met.


Examples:

<cb><v>value<> = 2

match <v>value<>:
    case <v>x<> if <v>x<> % 2 == 0:
        print(f'Value {value} is even.')
    case <v>x<> if <v>x<> % 2 == 1:
        print(f'Value {x} is odd.')
    case _:
        print('Unmatched value')

<#>Prints: 'Value 2 is even.'<><>

<cb><v>item_1<> = (<v>1<>, <v>2<>)

match <v>item_1<>:
    case (<v>1<>, <v>x<>) if <v>x<> % 2 == 0:
        print('Value (1,x) x is even.')
    case (<v>1<>, <v>x<>):
        print('Value (1,x) x is odd.')
    case _:
        print('Unmatched value')

<#>Prints: 'Value (1,x) x is even.'<><>
@
@ with condition



#### Match - Fall Through

Not Supported.

Unlike other languages, <c>match<> does not fall through from one case block into the next. There is no need for a <c>break<> statement within a case block to exit the block.
@
@ case block



#### Match - Unmatched / Wildcard

<cb>match <v>item_1<>:

    case _:
        <v>...<><>


<c>_<> catches all values that were not matched in any other case statements.


<cb><v>item_1<> = <v>-1<>

match <v>item_1<>:
    case <v>1<>:
        print('Value 1')
    case <v>2<>:
        print('Value 2')
    case _:
        print('Unmatched Value')

<#>Prints: 'Unmatched Value'<><>
@
@ underscore, _, default case



### While
@
@ loop, loops
@ while-only, continue, break, skip


#### While - Basics

<cb>while <v>condition<>:
	<v>...<><>

<cb>while <v>condition<>:
	<v>...<>
else:
	<v>...<>                     <#># When <c>condition<> = <c>False<><><>

<cb>while <v>condition<>:
	<v>...<>
	break                   <#># Exit for loop.<>
	<v>...<>
	continue                <#># Jump to next iteration.<>
	<v>...<>
else:
	<v>...<>                     <#># When <c>condition<> = <c>False<><><>

<c>else<> block reached when <c>condition<> = false only. Not called for break, exception, etc.



#### While

<cb>while <v>condition<>:
	<v>...<><>



#### While - While Else

<cb>while <v>condition<>:
	<v>...<>
else:
	<v>...<><>

Executes else clause when <c>condition<> is <c>False<>.

<c>break<> skips the <c>else<> block. 



#### While - Break Continue
<cb>while <v>condition<>:
	<v>...<>
	break             <#># Exit for loop.<>
	<v>...<>
	continue          <#># Jump to next iteration.<>
	<v>...<><>


<c>break<> will skip the <c>else<> block if one is included.
@
@ next, skip, exit



### While - "Do-While" Form

<cb>while True:

	<v>...<>

	if <v>exit_condition<>:
		break<>


Executes the while loop at least one time.
@
@ execute at least once, do-while, do while



### Break

Exit Loop:

<cb>break<>

Applies to <c>for<> and <c>while<> loops.

<c>break<> will skip the <c>else<> block if one is included.
@
@ For, While, skip, exit



### Continue

Continue on Next Iteration:

<cb>continue<>

Applies to <c>for<> and <c>while<> loops.
@
@ For, While, skip, next



### Pass

<cb>pass<>

Use as a placeholder in places where a code block should exist but you don't have any code yet.


Examples:

<cb>for <v>i<> in range(<v>5<>):
	pass<>

<cb>def <v>new_function<>():
	pass<>
@
@ For, While



# Variables
@
@ vars, variable-only, variables-only, vars-only, var-only



### Variable - Assign

<cb><v>name<> = <v>value<><>


Creates a new variable called <c><v>name<><> with value <c><v>value<><>.


Examples:

<cb>int_1 = 11<>

<cb>float_1 = 9.75<>

<cb>string_1 = 1Life, the universe, and everything1<>
@
@ create new, assignment, set



### Variable - Global - Create or Update

<cb>global <v>name<><>


Updates an existing global variable from inside a function.
Without the keyword <c>global<>, Python will create a local variable.

Creates a new global variabel if it doesn't exist.


Usage:

<cb>def <v>some_function<>():

	global <v>name<>
	<v>name<> = <v>value<><>


Example:

<cb><v>global_1<> = 'Global Value'


def <v>update_global<>():

	global <v>global_1<>
	<v>global_1<> = <v>global_1<> + ' + Update'


<v>update_global<>()

<#># Sets global_1 to 'Global Value + Update'<><>
@
@ scope



### Variable - NonLocal - Update Parent Variable

<cb>nonlocal <v>value_1<><>


Use <c>nonlocal<> to update a variable outside the scope of a inner (nested) function.

Usage:

<cb>def <v>parent_function<>():

	<v>value_1<> = <v>...<>

	def <v>inner_function<>():

		nonlocal <v>value_1<>
		<v>value_1<> = <v>new_value<><>

Without the keyword <c>nonlocal<>, Python will create a local variable.
The non-local variable must be in scope of the nested function declaration.
Works with multi-level nesting.
You can not create a non-existing variable.


Note:

The function already has read access to the parent variables through closure.
Consider avoiding updating the values.


Example:

<cb>def <v>parent_function<>:

	<v>count<> = 0

	def <v>update_count<>():

		nonlocal <v>count<>
		<v>count<> += 1

	<v>update_count<>()

	<#># count is now 1<><>
@
@ Scope



### Variable - Equals?

<cb>= <v>item_1<> == <v>item_2<><>


Returns true if <c><v>item_1<><> is equal to <c><v>item_2<><>.


@
@ equals, is, compare



### Variable - Cast

<cb>= <v>new_type<>(<v>item_1<>)<>


Converts <c><v>item_1<><> into a variable of type <c><v>new_type<><>.


Example:

<cb><v>float_1<> = <v>10.5<>

<v>int_1<> = int(<v>float_1<>)                       <#># Converts float 10.5 into integer 10.<><>
@
@ Convert-To, casting, converting, change, to-type



### Variable - Delete

<cb>del <v>variable_1<><>


Removes a variable from memory.


Example:

<cb><v>a<> = 10
print(<v>a<>)

del <v>a<>
print(<v>a<>)

<#># Returns Error:
\# ...
\# NameError: name 'a' is not defined<><>
@
@ remove, clear



### Variable - Exists?

Exists In Local Scope?

<cb>= '<v>variable_name<>' in locals()<>

Exists In Global Scope?

<cb>= '<v>variable_name<>' in globals()<>


Returns <c>True<> if in the checked scope.


Example:

<cb><v>a<> = 10

if '<v>a<>' in locals():
	print('a exists')

<#># Prints: a exists<><>
@
@ globals(), locals()



### Variable Type - Get Type

<cb>= type(<v>item_1<>)<>

Returns the item type.


Example:

<cb><v>item_1<> = <v>1.0<>
<v>item_1_type<> = type(<v>item_1<>)                  <#># Returns <c>class 'float'<>.<><>
@
@ Variable, check, typeof, type()



### Variable Type - Get Type Name

<cb>= type(<v>item_1<>).__name__<>

Returns the type name of the item.


Example:

<cb><v>float_1<> = <v>1.0<>
print(type(<v>float_1<>).__name__)         <#># Prints <c>'float'<>.<><>
@
@ Variable, class, __name__, type()



### Variable Type - Is Type?

<cb>= type(<v>item_1<>) is <v>type_1<><>


Returns true if <c><v>item_1<><> is the same type as <c><v>type_1<><>.


Example:

<cb>item_1 = [1, 2, 3]

if type(<v>item_1<>) is list:
	<v>...<>                                   <#># Executes if arg_1 is of type <c>list<>.<><>
@
@ Variable, equals, is, compare, isclass, type(), type of, is instance of



### Variable Type - Is Type or Subtype?

<cb>= isinstance(<v>item_1<>, <v>type_1<>)<>

Is One of These:

<cb>= isinstance(<v>item_1<>, (<v>type_1<>, <v>type_2<>, <v>...<>))<>


Returns true if <c><v>item_1<><> is a type or a subtype of <c><v>type_1<><>.


Examples:

<cb>item_1 = []

if isinstance(<v>item_1<>, list):
	<v>...<><>

<cb>item_2 = 10

if isinstance(<v>item_1<>, (int, complex, float)):
	<v>...<><>
@
@ equals, is type?, subclass, isclass, isinstance()
@ check, compare, is instance of



### Variable Type - Is Subtype?

<cb>= issubclass(<v>item_1<>, <v>type_1<>)<>


Returns true if <c><v>item_1<><> is a subtype of <c><v>type_1<><>.@
@ equals, is subtype?, is subclass of
@ check, compare, issubclass()



### Variables - Memory Address

<cb>= id(<v>a<>)<>

Returns: <c>int<>


Returns the memory address of the variable.
@
@ id(), location



### Variables - Swap

<cb><v>a<>, <v>b<> = <v>b<>, <v>a<><>


This is an easy way to swap the values of <c><v>a<><> and <c><v>b<><>.
@
@ values



# Data Types - Built In
@
@ standard, builtin, data-types-only



### Standard Types

	<c>bool<>			(Boolean)
	<c>int<>				(Integer)
	<c>complex<>			(Complex Number)
	<c>float<>			(Floating Point)   
	<c>str<>				(String)



### Sequence Types

	<c>list<>			(List / Mutable Array)
	<c>tuple<>			(Immutable Array)
	<c>range<>			(Immutable Integers)
@
@ Array, data structures



### Collections

	<c>dict<>			(Dictionary of Key Value Pairs)
	<c>set<>				(Mutable Set)
	<c>frozenset<>		(Immutable Set)
@
@ data structures



### Mutable Types

	<c>bytearray<>
	<c>classes<>
	<c>class instances<>
	<c>dict<>
	<c>list<>
	<c>set<>



### Immutable Types

	<c>boolean<>
	<c>byte<>
	<c>float<>
	<c>frozenset<>
	<c>int<>
	<c>long<>
	<c>complex<>
	<c>str<>
	<c>tuple<>



# Data Types - From Library



#### Date And Time

	<c>date<>				(Date Only)
	<c>datetime<>			(Date And Time)
	<c>timedelta<>			(Time Difference)

	<c>float<> (<c>timestamp<>)		(Epoch Time, Seconds Since 1970) (Use <c>float<>)



#### Collections

	<c>chainmap<>
	<c>counter<>
	<c>deque<>
	<c>defaultdict<>
	<c>namedtuple<>
	<c>ordereddict<>
	<c>userdict<>
	<c>userlist<>
	<c>userstring<>

	<c>array<>			(List Constrained To A Single Basic Type)
@
@ data structures



#### Enumerations

	<c>enum<>



# Literals
@
@ literals-only, lit-only, literal-only


## Literals - Basics

<table><col>Boolean Literal	<><col><c>= True | False<><>
<col> <>
<col>Integer Literal<><col><c>= 11<><>
<col><><col><c>= -11<><>
<col><><col><c>= 12_345<><>
<col> <>
<col>Binary Literal<><col><c>= 0b<v>1011<><><>
<col>Octal Literal<><col><c>= 0o<v>13<><><>
<col>Hex Literal<><col><c>= 0x<v>0B<><><>
<col> <>
<col>Float Literal<><col><c>= 11.23<><>
<col><><col><c>= -1.23<><>
<col> <>
<col>Complex Literal<><col><c>= <v>1<> + <v>2<>j<><>
<col> <>
<col>String Literal<><col><c>= '<v>A String<>'<><>
<col><><col><c>= "<v>A String<>"<><>
<col><><col><c>= '''<v>A String<>'''<><>
<col><><col><c>= """<v>A String<>"""<><>
<col> <>
<col>Raw String Literal<><col><c>= r'<v>A\\String<>'<><>
<col><><col><c>= r"<v>A\\String<>"<><>
<col><><col><c>= r'''<v>A\\String<>'''<><>
<col><><col><c>= r"""<v>A\\String<>"""<><>
<col> <>
<col>F-String Literal<><col><c>= f'<v>...<> {<v>var1<>} <v>...<>'<><>
<col><><col><c>= f"<v>...<> {<v>var1<>} <v>...<>"<><>
<col><><col><c>= f'''<v>...<> {<v>var1<>} <v>...<>'''<><>
<col><><col><c>= f"""<v>...<> {<v>var1<>} <v>...<>"""<><><>
@
@ summary



## Literals - Details


### Boolean Literal

<cb>= True<>

<cb>= False<>
@
@ true, false



### Complex Literal

<cb>= <v>1<> + <v>2<>J<>

<cb>= <v>3<>J<>



### Integer Literal - Decimal

<cb>= <v>11<><>

<cb>= -<v>11<><>

<cb>= <v>12_345<><>


Underscores are for readability and are ignored by Python.
@
@ _, underscore, number



### Integer Literal - Binary

<cb>= 0b<v>1011<><>

<cb>= 0b<v>1011_1010<><>


Underscores are for readability and are ignored by Python.
@
@ 0b
@ _, underscore



### Integer Literal - Hex

<cb>= 0x<v>0B<><>
@
@ 0x, hexadecimal



### Integer Literal - Octal

<cb>= 0o<v>13<><>
@
@ 0o



### Float Literal

<cb>= <v>42<>.<v>42<><>

<cb>= -<v>42<>.<v>42<><>

<cb>= <v>12_345<>.<v>67_89<><>


Underscores are for readability and are ignored by Python.
@
@ 0b
@ _, underscore, number



### String Literals

<cb>= '<v>A String<>'<>

<cb>= "<v>A String<>"<>

<cb>= '''<v>A Multiline
String<>'''<>

<cb>= """<v>A Multiline
String<>"""<>



### String Literals - F-String

<cb>= f'<v>F-String with Value<> {<v>item1<>}'<>

<cb>= f"<v>F-String with Value<> {<v>item1<>}"<>

<cb>= f'''<v>Multiline F-String
With Value<> {<v>item1<>}'''<>

<cb>= f"""<v>Multiline F-String
With Value<> {<v>item1<>}"""<>
@
@ template



### String Literals - Raw String

<cb>= r'<v>A\\Raw\\String<>'<>

<cb>= r"<v>A\\Raw\\String<>"<>

<cb>= r'''<v>A\\Raw
Multiline\\String<>'''<>

<cb>= r"""<v>A\\Raw
Multiline\\String<>"""<>



### String Literals - Raw F-String

<cb>= rf'<v>Raw\\F-String\\with\\Value\\<>{<v>item1<>}'<>

<cb>= rf"<v>Raw\\F-String\\with\\Value\\<>{<v>item1<>}"<>

<cb>= rf'''<v>Multiline\\Raw\\F-String
With\\Value<> {<v>item1<>}'''<>

<cb>= rf"""<v>Multiline\\Raw\\F-String
With\\Value<> {<v>item1<>}"""<>
@
@ template



### String Literals - Escape Hex Value

<cb>\\x<v>ff<><>

Base:

<cb>\\x<>

Escapes a hex value into a string character.


Equivalent:

<cb>= "\\x61"

= "a"<>
@
@ \\x



### String Literals - Escape Octal Value

<cb>\\<v>777<><>

Base:

<cb>\\<>

Escapes an _ value into a string character.

Watch for any trailing digit characters that are not part of the octal value. They will be incorporated.


Equivalent:

<cb>= "\\141"

= "a"<>
@
@ \\



### String Literals - Escape Unicode, 16-Bit

<cb>\\u<v>ffff<><>

Base:

<cb>\\u<>

Escapes a 16 bit Unicode hex value into a string character.

Requires 4 hex digits.


Equivalent:

<cb>= "\\u0061"

= "a"<>
@
@ \\u



### String Literals - Escape Unicode, 32-Bit

<cb>\\U<v>ffffffff<><>

Base:

<cb>\\U<>

Escapes a 32 bit Unicode hex value into a string character.

Requires 8 hex digits.


Equivalent:

<cb>= "\\U00000061"

= "a"<>

<cb>= "\\U0001f44d"

= "👍"<>
@
@ \\U



### String Literals - Escape Unicode Character / Emoji

<cb>\\N{<v>name<>}<>

Base:

<cb>\\N{}<>

Escapes an unicode character name into a string character.


Equivalent:

<cb>= "\\N{thumbs up sign}"

= "👍"<>
@
@ \\N{}



# None Type

<cb>= None<>


Assigns 'no value' to a variable.

<c>None<> is a singleton in Python.


Examples:

<cb><v>var_1<> = None<>

<cb>if <v>var_1<> is None:
	<v>...<><>
@
@ character, none-only



### None - Is None

<cb>= <v>item_1<> is None<>

<cb>if not <v>item_1<>:
	<v>...<><>
@
@ equals?, equal to?, Compare



### None - Not None

<cb>= <v>item_1<> is not None<>

<cb>if <v>item_1<>:
	<v>...<><>
@
@ equals?, equal to?, Compare



# Boolean

<cb>= True
= False<>

Type: <c>bool<>


Immutable.
Subset of Integer
@
@ bool, bool-only, bools-only, boolean-only, booleans-only
@ Create, Define, Instantiate, New, True, False, data type




# Byte

<cb>= b"<v>String to bytes.<>"

= bytes([<v>66, 121, 116, 101, 115<>])     <#>#1<><>


Type: <c>bytes<>


\#1  <s>-<>  Same as b'Bytes'.


Creates a byte array.
@
@ bytes, byte-only, bytes-only, bytes(), b'', b""
@ Create, Define, Instantiate, New, binary, data type



# Byte Operations
@
@ ops, bytes, byte-only, bytes-only, binary



### Bytes - Length

<cb>= len(<v>bytes_1<>)<>
@
@ size, count, len()



# Complex Number

<cb>= <v>real<> + <v>imaginary<>j<>

<cb>= <v>imaginary<>j<>

<cb>= complex(<v>real<>, <v>imaginary<>)<>

Type: <c>complex<>


Why J:
Becaues i looks too much like a 1.
Because j is used in engineering.


Example:

<cb><v>complex_1<> = <v>1<> + <v>2<>j<>

<cb><v>complex_2<> = <v>3<>j<>
@
@ complex-only, complex-numbers-only, real, imaginary, numbers
@ Create, Define, Instantiate, New, i, j, .real, .imag, data type, complex()



# Complex Number Operations
@
@ complex-only, complex-numbers-only
@ Ops



### Complex Number - Real Part

<cb>= <v>complex_1<>.real<>
@
@ Get, .real



### Complex Number - Imaginary Part

<cb>= <v>complex_1<>.imag<>
@
@ Get, .imag



# Decimal

From String (Preferred):

<cb>from decimal import Decimal

= Decimal('<v>10.99<>')<>

<cb>= Decimal('<v>NaN<>')<>

From Float:

<cb> = Decimal(<v>10.99<>)<>


Creates an immutable decimal value.
Keeps the precision the decimal was created to.
Use for currency values where accuracy is important.


<*>Prefer creating from strings over floats.
Floats are stored at binary level precision.<>


Example:

From String:

<cb>from decimal import Decimal

<v>decimal_1<> = Decimal('<v>12.34<>')

print(<v>decimal_1<>)

<#># Prints 12.34<><>

From Float:

<cb>from decimal import Decimal

<v>decimal_1<> = Decimal(<v>12.34<>)

print(<v>decimal_1<>)

<#># Prints 12.339999999999999857891452847979962825775146484375<><>
@
@ money, currency
@ new, create
@ dec-only, decs-only, decimal-only, decimals-only



# Decimal Operations
@
@ dec-only, decs-only, decimal-only, decimals-only


### Decimal - Arithmetic Operators

Supports:

<cb><table><col>decimal<><col><v>operator<><><col>decimal<>
<col>decimal<><col><v>operator<><><col>int<><><><>

<cb><table><col><v>operators <><><col><c>+ - * ** / // % \< \<= == != >= ><><><><>

Not Supported:

<cb><table><col>decimal<><col><v>operator<><><col>float<><><>


Examples:

Decimal To Decimal:

<cb>from decimal import Decimal

<v>decimal_1<> = Decimal('<v>42<>')
<v>decimal_2<> = Decimal('<v>0.42<>')

<v>result<> = <v>decimal_1<> + <v>decimal_2<>

<#># Returns Decimal('42.42')<><>

Integer To Decimal:

<cb>from decimal import Decimal

<v>decimal_1<> = Decimal('<v>0.42<>')
<v>int_2<> = 42

<v>result<> = <v>decimal_1<> + <v>int_2<>

<#># Returns Decimal('42.42')<><>



### Decimal - Rounding - Get

<cb>from decimal import getcontext

= getcontext().rounding<>


Gets the rounding performed on decimal operations (*, /, etc.).
The default rounding is <c>ROUND_HALF_EVEN<>.
@
@ decimal.getcontext().prec, getcontext().prec, .prec



### Decimal - Rounding - Set

<cb>from decimal import getcontext

getcontext().rounding = <v>rounding<><>


Sets the rounding performed on decimal operations (*, /, etc.).
The default rounding is <c>ROUND_HALF_EVEN<>.


Rounding Values:

<card><table><col><c>decimal.ROUND_CEILING<><><col>Round Up To + Infinity<><col><c> 0.5 ->  1
-0.5 ->  0
 <><>
<col><c>decimal.ROUND_DOWN<><><col>Round To 0<><col><c> 0.5 ->  0
-0.5 ->  0
 <><>
<col><c>decimal.ROUND_FLOOR<><><col>Round Down To - Infinitiy<><col><c> 0.5 ->  0
-0.5 -> -1
 <><>
<col><c>decimal.ROUND_HALF_DOWN<><><col>Round To Nearest Integer
Ties Round to 0<><col><c> 0.6 ->  1
 0.5 ->  0
-0.5 ->  0
-0.6 -> -1
 <><>
<col><c>decimal.ROUND_HALF_EVEN<><><col>Round To Nearest Integer
Ties To Nearest Even Integer<><col><c>

 <><>
<col><c>decimal.ROUND_HALF_UP<><><col>Round To Nearest Integer
Ties Round to <><col><c> 0.5 ->  2
 0.4 ->  0
-0.4 ->  0
-0.5 ->  2
 <><>
<col><c>decimal.ROUND_UP<><><col>Round To ± Infinity<><col><c> 0.5 ->  1
-0.5 -> -1
 <><>
<col><c>decimal.ROUND_05UP<><><col>Round To 0
Except When Last Rounded Digit = 0 or 5
- Then Round To ± Infinity<><><>
@
@ decimal.getcontext().prec, getcontext().prec, .prec



### Decimal - Precision - Get

<cb>from decimal import getcontext

= getcontext().prec<>


Gets the precision for decimal operations (*, /, etc.).
The default precision is 28 digits including digits before and after the decimal place.



### Decimal - Precision - Set

<cb>from decimal import getcontext

getcontext().prec = <v>digits<><>


Sets the precision for decimal operations (*, /, etc.).
The default precision is 28 digits including digits before and after the decimal place.


Example:

<cb>from decimal import Decimal
from decimal import getcontext

<v>a<> = Decimal('1')
<v>b<> = Decimal('0.3')

print(<v>a<> / <v>b<>)

<#># Prints 3.333333333333333333333333333<>

getcontext().prec = <v>4<>

print(<v>a<> / <v>b<>)

<#># Prints 3.333<><>



# Float

<cb>= <v>1.0<>
= <v>123.345<>
= <v>123_345.67_89<>
= <v>1.9484E9<>
= <v>0.4388E-16<><>

Type: float


Immutable.
Underscores between digits are ignored. Use them to make numbers more readable.
@
@ float-only, floats-only
@ Create, Define, Instantiate, New, data type



### Decimal - To Float

<cb>= float(<v>decimal_1<>)<>

Converts a decimal to a float.



### Decimal - To Integer

<cb>= int(<v>decimal_1<>)<>

Converts a decimal to a int.



# Float Operations
@
@ float-only, floats-only
@ ops



### Float - NAN

<cb>= float('nan')<>
@
@ Not a number, is



# Integer

<cb>= <v>123<><>

<cb>= <v>123_456<><>

Type: <c>int<>


Immutable.
Length 32 or 64 bits. Depends on the machine.
Underscores between numbers are ignored. Use them to make the number more readable.
@
@ Long, int-only, ints-only, long-only, longs-only, integer-only
@ Create, Define, Instantiate, New, data type



# Integer Operations
@
@ Long, int-only, ints-only, long-only, longs-only, integer-only
@ ops



### Integer - Is Zero

<cb>= not <v>int_1<><>

<cb>if not <v>int_1<>:
	<v>...<><>
@
@ Not



### Integer - Not Zero

<cb>= bool(<v>int_1<>)<>

<cb>if <v>int_1<>:
	<v>...<><>
@
@ Non, bool()



### Integer - Length

<cb>from math import floor
from math import log10

<v>length<> = (1 + floor(log10(abs(<v>int_1<>)))) if <v>int_1<> else 0<>

Returns number of digits.


Example:

<cb><v>int_1<> = 256
<v>length<> = (1 + floor(log10(abs(<v>int_1<>)))) if <v>int_1<> else 0

<#># Returns 3<><>
@
@ Count, Digits, Size
@ math.floor(), .floor(), Size, bath.log10(), .log10()



### Integer - Maximum Value

<cb>import sys

<v>max_size<> = sys.maxsize<>

The maximum value of an integer is system dependent.
Use this function to find the value in your current environment.


32 bits = 2,147,483,647
64 bits = 9,223,372,036,854,775,807
@
@ Size, sys.maxsize, .maxsize, greatest, largest



# String

<cb>= "<v>A String<>"
= '<v>A String<>'
= str(<v>34<>)                         <#># Returns '34'<><>

Concatenated:

<cb>= '<v>123<>' + <v>string3<> + "<v>more text<>" + '<v>more text again<>'

= '123' '456'                     <#># Returns '123456'<><>

Escaped:

<cb>= ' "" ' + " '' "                <#># Returns ' ""  '' '<><>


Type: <c>str<>


Immutable.
Stored as variable byte unicode.
@
@ Strings, string-only, strings-only, str-only, text, text-only, str(), str., string.
@ Create, Define, Instantiate, New, "", '', single quote, double quote, data type



### String - Multiline String

<cb>= '''<v>This is
a multiline
string.<>'''<>

<cb>= """<v>This is
a multiline
string.<>"""<>


Enclose multiline string in <c>'''<> or <c>"""<>.
@
@ ''', """, multiline, multi-line



### String - Raw String

<cb>= r"<v>A\\String\\With\\Slashes<>"
= r'<v>A\\String\\With\\Slashes<>'<>


Returns text exactly as it is represented between the quotes.

No escaped character processing is done.
Useful for regular expressions.


Example:

<cb><v>normal_string<> = 'a\\tb\\tc'
<v>raw_string<> = r'a\\tb\\tc'

print("Normal", <v>normal_string<>)
print("Raw   ", <v>raw_string<>)

<#># Prints:
\#
\# Normal a    b    c
\# Raw    a\\tb\\tc<><>
@
@ r"", r''



# String Format - Format()
@
@ Strings, string-only, strings-only, str-only, text, text-only, .format(), {}
@ formatting, formats, new, create
@ string-format()-only



### String Format() - Basics

<cb>string_1 = "value 1"
string_2 = "value 2"
float_3 = 12345.67<>

<cb><v>formatted_string<> = "{}".format(<v>string_1<>)<>

<cb><v>string_1_and_2<> = "{} {}".format(<v>string_1<>, <v>string_2<>)<>

<cb><v>pad_right<> = "{:<v>\<20<>}".format(<v>string_1<>)<>

<cb><v>formatted_number<> = "{:<v>,.1f<>}".format(<v>float_3<>)<>
@
@ basics



### String Format() - Single Variable

<cb>= "{}".format(<v>item_1<>)<>


Example:

<cb><v>string_1<> = "<v>norminal<>"
<v>formatted<> = "Everything is {}.".format(<v>string_1<>)

<#># Returns "Everything is norminal."<><>



### String Format() - Multiplale Variables

<cb>= "{} {} <v>...<>".format(<v>item_1<>, <v>item_2<>, <v>...<>)<>


Example:


<cb><v>string_1<> = "<v>The cake<>"
<v>string_2<> = "<v>a lie<>"

<v>the_truth<> = "{} is {}.".format(<v>string_1<>, <v>string_2<>)

<#># Returns "The cake is a lie."<><>



### String Format() - With Formatting

<cb>= "{:<v>format<>}".format(<v>string_1<>)<>


Example:

<cb><v>string_1<> = "On the left!"
<v>padded<> = "{:<v>\<20<>}".format(<v>string_1<>)

<#># Returns "On the left!        "<><>

<cb><v>int_1<> = 12345
<v>comma_separated<> = "{:<v>,d<>}".format(<v>int_1<>)

<#># Returns "12,345"<><>



### String Format() - Escape

Escape {            <c>'{{'<>
Escape }            <c>'}}'<>

<cb>= "{{<v>...<>}}".format(<v>...<>)<>
@
@ {}, }



# String Format - F-String


Formatted String literal or f-string.

Creates a formatted string using a string literal.
@
@ Strings, string-only, strings-only, str-only, text, text-only
@ Formatted, template
@ {}, f"", f''
@ f-strings, fstrings, variable in, formatting, formats, f-string-only, f-strings-only



### F-String - Basics

<card><table><col>Variable<><col><c>= f'{<v>var_1<>}'<><><col><c>'value-1'<><>
<col><><col><c>= f"{<v>var_1<>}"<><><col><c>'value-1'<><>
<col> <>
<col>Text and Variable<><col><c>= f'<v>text<> {<v>var_1<>}'<><><col><c>'text value-1'<><>
<col><><col><c>= f"<v>text<> {<v>var_1<>}"<><><col><c>'text value-1'<><>
<col> <>
<col>Concatenate<><col><c>= f'{<v>string_1<>}{<v>string_2<>}'<><><col><c>'value-1value-2'<><>
<col><><col><c>= f'{<v>string_1<>}' f'{<v>string_2<>}'<><><col><c>'value-1value-2'<><>
<col> <>
<col>Align Right<><col><c>= f'{<v>string_1<>:<v>>10<>}'<><><col><c>'   value-1'<><>
<col>Align Center<><col><c>= f'{<v>string_1<>:<v>^10<>}'<><><col><c>' value-1  '<><>
<col>Align Left<><col><c>= f'{<v>string_1<>:<v>\<10<>}'<><><col><c>'value-1   '<><>
<col> <>
<col>Comma<><col><c>= f'{<v>float_1<>:<v>,<>}'<><><col><c>'12,345'<><>
<col>Decimals<><col><c>= f'{<v>float_1<>:<v>.2f<>}'<><><col><c>'12345.12'<><>
<col>Comma, Decimals<><col><c>= f'{<v>float_1<>:<v>,.2f<>}'<><><col><c>'12,345.12'<><><><>
@
@ Examples, summary



### F-String - Single Variable

<cb>= f'{<v>item_1<>}'

= f"{<v>item_1<>}"<>


Example:

<cb><v>string_1<> = "<v>norminal<>"

<v>formatted<> = f"Everything is {<v>string_1<>}."

<#># Returns "Everything is norminal."<><>



### F-String - Multiplale Variables

<cb>= f"{<v>item_1<>} {<v>item_2<>} <v>...<>"<>


Example:


<cb><v>string_1<> = "<v>The cake<>"
<v>string_2<> = "<v>a lie<>"

<v>the_truth<> = f"{<v>string_1<>} is {<v>string_2<>}."

<#># Returns "The cake is a lie."<><>


### F-String - From Expression

<cb>= f'{<v>expression<>}'<>


You can embed an expression in an f-string and it will evaluate it.


Example:

<cb>print(f'{<v>10 + 20<>}')

<#># Prints 30<><>



### F-String - Repr Variable

<cb>= f'{<v>item_1<>!r}'<>

Equvialent to:

<cb>= repr(<v>item_1<>)<>


Prints the repr() form of the value.


Example:

<cb><v>string_1<> = '<v>norminal<>'

<v>formatted<> = f'{<v>string_1<>!r}.'

<#># Returns: "'norminal'."<><>
@
@ !r, {!r}



### F-String - Show Variable Name With Output / Debug Mode

<cb>= f"{<v>item_1<> =}"<>


Prints the expression between <c>{<> and <c>}<> and it's value.
<c>=<> denotes debug mode.
Useful for debugging.


Example:

<cb><v>string_1<> = "<v>norminal<>"

<v>formatted<> = f"{<v>string_1<> =}"

<#># Returns "string_1 = 'norminal'"<><>
@
@ debugging, =, {=}
@ display



### F-String - With Formatting

<cb>= f"{<v>item_1<>:<v>format<>}"<>


Example:

<cb><v>string_1<> = "On the left!"
<v>padded<> = f"{<v>string_1<>:<v>\<20<>}"

<#># Returns "On the left!        "<><>

<cb><v>int_1<> = 12345
<v>comma_separated<> = f"{<v>int_1<>:<v>,d<>}"

<#># Returns "12,345"<><>
@
@ {:}, :



### F-String - Escape

Escape:

<cb>= f'{{<v>...<>}}''<>

Ugly Way:

<cb>= f"{'{'}"              <#>#1<><>

<cb>= f"{'}'}"              <#>#2<><>


\#1  -  Returns '{'

\#2  -  Returns '}'
@
@ {}, } {{, }}



# String Operations
@
@ Strings, string-only, strings-only, str-only, text, text-only, str., string.
@ Ops



### String - Append

<cb><v>string_1<> += <v>string_2<><>

Appends <c><v>string_2<><> to the end of <c><v>string_1<><>.
@
@ add, +=, append to



### String - Concatenate

<cb>= <v>string_1<> + <v>string_2<> + <v>...<><>

Concatenate Raw Strings:

<cb>= "String 1" "String 2" <v>...<><>

Combines 2 or more strings into one string.
@
@ add, +, Combine, join


### String - Contains?

<cb>= <v>string_1<> in <v>string_2<><>

<cb>if <v>string_1<> in <v>string_2<>:
	<v>...<><>

Returns <c>True<> when <c><v>string_1<><> is a substring of <c><v>string_2<><>.
@
@ has, in, includes, is substring



### String - Not Contains?

<cb>= <v>string_1<> not in <v>string_2<><>

<cb>if <v>string_1<> not in <v>string_2<>:
	<v>...<><>

Returns <c>True<> when <c><v>string_1<><> is not a substring of <c><v>string_2<><>.
@
@ not in, includes, does



### String - Ends With?

<cb>= <v>string_1<>.endswith(<v>test_value<>)<>

Returns: <c>bool<>


Returns <c>True<> if <c><v>string_1<><> ends with or equals <c><v>test_value<><>.
@
@ .endswith()



### String - Find

<cb>= <v>string_1<>.find(<v>search_value<>)<>

<cb>= <v>string_1<>.find(<v>search_value<>, <v>start<>)<>

<cb>= <v>string_1<>.find(<v>search_value<>, <v>start<>, <v>end<>)<>

Returns: <c>integer<>

If -1 is returned then no match was found.
@
@ search, position, index, .find()



### String - Find Last

<cb>= <v>string_1<>.rfind(<v>search_value<>)<>

Returns: <c>integer<>

If -1 is returned then no match was found.
@
@ search, position, end, right .rfind()



### String - Get Character

<cb>= <v>string_1<>[<v>position<>]<>

Example:

<cb><v>character_2<> = "<v>012345<>"[2]

<#># Returns "2"<><>



### String - Is Blank?

<cb>= not <v>string_1<> or <v>string_1<>.isspace()<>

<cb>if not <v>string_1<> or <v>string_1<>.isspace():
	<v>...<><>


Returns <c>True<> for <c>None<> or <c>""<> or is all whitespace.
@
@ None, whitespaces, white spaces, .isspace()



### String - Is Empty?

<cb>= not <v>string_1<><>

<cb>if not <v>string_1<>:
	<v>...<><>


Returns <c>True<> for <c>None<> or <c>""<>.
@
@ None, not



### String - Not Empty?

<cb>= (<v>string_1<> != None and <v>string_1<> != "")<>

<cb>if <v>string_1<> != None and <v>string_1<> != "":
	<v>...<><>


Returns <c>False<> for <c>None<> or <c>""<>.


A bit messy.
There isn't a clean Pythonic way to do this.
I recommend making a function like this:

<cb>def not_empty(<v>value<>):
	return <v>value<> != None and <v>value<> != ""<>

Then call like this:

<cb>if not_empty(<v>string_1<>):
	<v>...<><>
@
@ Size, None



### String - Is Equal?

<cb>= <v>string_1<> == <v>string_2<><>

<cb>if <v>string_1<> == <v>string_2<>:
	<v>...<><>


Example:

<cb>if <v>"a"<> == <v>"b"<>:
	print("Equal")
else:
	print("Not Equal")<>
@
@ Equals, Compares, Not, ==, identical



### String - Not Equal?

<cb>= <v>string_1<> != <v>string_2<><>

<cb>if <v>string_1<> != <v>string_2<>:
	<v>...<><>


Example:

<cb>if <v>"a"<> != <v>"b"<>:
	print("Not Equal")
else:
	print("Equal")<>
@
@ Equals, Compares, Not, !=



### String - Is Equal, Ignore Case?

<cb>= <v>string_1<>.casefold() == <v>string_2<>.casefold()<>

<cb>if <v>string_1<>.casefold() == <v>string_2<>.casefold():
	<v>...<><>


<c>casefold()<> is the correct way to compare strings caselessly.
This is especially true for unicode strings.
<c>casefold()<> convents the string to a safe case agnostic form.


Example:

<cb>if <v>"stoß"<>.casefold() == <v>"STOSS"<>.casefold():
	print("Equal")
else:
	print("Not Equal")

<#># These Are Equal<><>
@
@ Equals, Compares, Not, ==, identical, .casefold(), caseless, any
@ folding



### String - Not Equal, Ignore Case?

<cb>= <v>string_1<>.casefold() != <v>string_2<>.casefold()<>

<cb>if <v>string_1<>.casefold() != <v>string_2<>.casefold():
	<v>...<><>


<c>casefold()<> is the correct way to compare strings caselessly.
This is especially true for unicode strings.
<c>casefold()<> convents the string to a safe case agnostic form.

Example:

<cb>if <v>"stoß"<>.casefold() != <v>"STOSS"<>.casefold():
	print("Not Equal")
else:
	print("Equal")

<#># These Are Equal<><>
@
@ Equals, Compares, Not, !=, .casefold(), caseless, any



### String - is Alpha Only

<cb>= <v>string_1<>.isalpha()<>

Returns <c>True<> if consisting entirely of alphabet characters.

Includes international characters.
Returns <c>False<> for numbers, symbols, emojis, or whitespace characters.
@
@ .isalpha(), alphabet characters, ischaracter
@ is, contains, consists of



### String - is Alphanumerics Only

<cb>= <v>string_1<>.isalnum()<>

Returns <c>True<> if consisting entirely of alphabet characters or numbers..

Includes international characters.
Returns <c>False<> for symbols, emojis, or whitespace characters.
@
@ .isalnum(), .isalphanumeric()
@ alphabet characters, ischaracter, numeric, numbers
@ is, contains, consists of



### String - Is Digits Only

<cb>= <v>string_1<>.isdigit()<>


Checks if a string consists of digits only.


Returns <c>True<> when all characters are from 0 to 9.
Returns <c>False<> for <c>+<> or <c>-<>
@
@ is, .isdigit(), numbers, integer
@ is, contains, consists of



### String - Is Integer

<cb>from re import match

def is_int(<v>value<>):
	return match(r"^[+-]?\d+$", <v>value<>) is not None<>

<cb>= is_int(<v>string_1<>)<>


Works for any integer including those with plus or minus.
@
@ .isint(), .isinteger(), is_int(), an, check



### String - Is Lower Case Only

<cb>= <v>string_1<>.islower()<>


Checks if a string consists of all lower case letters.
@
@ .islower(), characters
@ is, contains, consists of



### String - Is Title Case Only

<cb>= <v>string_1<>.istitle()<>


Checks if a string consists of all title case words.

To be <c>True<> every word must start with a capitalized letter and the remaining letters must be lower case.
@
@ .istitle(), words, titlecase, caps
@ is, contains, consists of



### String - Is Upper Case Only

<cb>= <v>string_1<>.isupper()<>


Checks if a string consists of all upper case letters.
@
@ .isupper(), characters
@ is, contains, consists of



### String - Is Valid Python Identifier

<cb>= <v>string_1<>.isidentifier()<>


Checks if a string is a valid Python identifier.

Checks to see that the string meets the identifier name rules (starts with [a-zA-Z_] followed by [a-zA-Z0-9_])
@
@ .isidentifier(), characters
@ is, contains



### String - Iterate Over Characters

<cb>for <v>character<> in <v>string_1<>:
	<v>...<><>

Iterates over <c><v>string_1<><> one character at a time.
@
@ for loop, in, chars, iterating



### String - Compare?

Is Less Than?:

<cb>= <v>string_1<> < <v>string_2<><>

Is Greater Than?:

<cb>= <v>string_1<> > <v>string_2<><>


Compare strings using ==, !=, \<, >, \<=, >=.


Example:

<cb>if <v>"a"<> < <v>"b"<>:
	print("Less Than")
else:
	print("Not Less Than")<>
@
@ Is Less Than, Is Greater Than, \<, \<=, >, >=



### String - Count Occurences

<cb>= <v>string_1<>.count(<v>value<>)<>

Returns: <c>int<>


Returns the number of times <c>value<> exists in the string.


Examples:

<cb><v>count<> = '<v>abc abc a<>'.count('<v>a<>')

<#># Returns 3<><>

<cb><v>count<> = '<v>abc abc a<>'.count('<v>abc<>')

<#># Returns 2<><>
@
@ string.count(), str.count(), .count()
@ character, substring, match, times



### String - Length

<cb>= len(<v>string_1<>)<>
@
@ Size, Count, len()



### String - Pad on Left

<cb>= <v>string_1<>.rjust(<v>width<>)                 <#># Pad With Spaces<><>

<cb>= <v>string_1<>.rjust(<v>width<>, <v>fill_char<>)<>

Pads <c><v>string_1<><> on the left side to the given width.
Pads with <c><v>fill_char<><>, or spaces if not given.
@
@ Right Justify, .rjust(), start
@ pad-left, right-justify, align-right



### String - Pad on Right

<cb>= <v>string_1<>.ljust(<v>width<>)                 <#># Pad With Spaces<><>

<cb>= <v>string_1<>.ljust(<v>width<>, <v>fill_char<>)<>

Pads <c><v>string_1<><> to the given width on the right side.
Pads with <c><v>fill_char<><>, or spaces if not given.
@
@ Left Justify, .ljust(), end
@ pad-right, left-justify, align-left



### String - Repeat

<cb>= <v>string_1<> * <v>count<><>

Returns <v>string_1<> repeated <v>count<> times.


Example:

<cb><v>ten_asterisks<> = "*" * 10              <#># Returns "**********"<><>
@
@ *, Multiply, Multiple, expand, .repeat()



### String - Replace

<cb>= <v>string_1<>.replace(<v>original<>, <v>replacement<>)<>


Replaces all occurrenceses of a substring with another.

Replace is case sensitive.


Example:

<cb><v>string_1<> = '<v>Replace this and this and this.<>'
<v>replaced<> = <v>string_1<>.replace('<v>this<>', '<v>that<>')

print(<v>replaced<>)

<#># Prints 'Replace that and that and that.'<><>
@
@ Update, Modify, Change, substitute, all occurences, matches
@ .replace()



### String - Replace First Occurence

<cb>= <v>string_1<>.replace(<v>original<>, <v>replacement<>, 1)<>


Replaces the first occurrencese of a substring with another.

Replace is case sensitive.


Example:

<cb><v>string_1<> = '<v>Replace this and this and this.<>'
<v>replaced<> = <v>string_1<>.replace('<v>this<>', '<v>that<>', 1)

print(<v>replaced<>)

<#># Prints 'Replace that and this and this.'<><>
@
@ Update, Modify, Change, .replace(), substitute, only, 1st



### String - Replace Ignore Case

<cb>import re

<v>pattern<> = re.compile(<v>original<>, re.IGNORECASE)
<v>replacement<> = <v>pattern<>.sub(<v>replacement<>, <v>original<>)<>


Replaces the occurrences of one string with another

Replace is not case sensitive.


Example:

<cb>import re

<v>string_1<> = '<v>Replace this and THIS and ThIs.<>'

<v>pattern<> = re.compile('<v>this<>', re.IGNORECASE)
<v>replaced<> = <v>pattern<>.sub('<v>that<>', <v>string_1<>)

print(<v>replaced<>)

<#># Prints 'Replace that and this and this.'<><>
@
@ Update, Modify, Change, substitute
@ re.compile(), .sub()



### String - Replace Ignore Case, First Occurrence

<cb>import re

<v>pattern<> = re.compile(<v>original<>, re.IGNORECASE)
<v>replacement<> = <v>pattern<>.sub(<v>replacement<>, <v>original<>, 1)<>


Replaces the occurrences of one string with another

Replace is not case sensitive.


Example:

<cb>import re

<v>string_1<> = '<v>Replace this and THIS and ThIs.<>'

<v>pattern<> = re.compile('<v>this<>', re.IGNORECASE)
<v>replaced<> = <v>pattern<>.sub('<v>that<>', <v>string_1<>, 1)

print(<v>replaced<>)

<#># Prints 'Replace that and this and this.'<><>
@
@ Update, Modify, Change, substitute, only, 1st
@ re.compile(), .sub()



### String - Reverse

<cb>= <v>string_1<>[::-1]<>


Reverses a string.


Example:

<cb><v>string_1<> = '<v>12345<>'
<v>reversed<> = <v>string_1<>[::-1]

print(<v>reversed<>)

<#># Prints '54321'<><>
@
@ backwards



### String - Split

<cb>= <v>string_1<>.split(<v>split_string<>)

= <v>string_1<>.split(<v>split_string<>, <v>split_count<>)<>

Returns a list of strings split on <c><v>split_string<><>.

<c><v>split_string<><> is not returned in the results.
Stops after splitting <c><v>split_count<><> times if given.


Examples:

<cb><v>string_1<> = '<v>ab/cd/ef<>'

<v>split<> = <v>string_1<>.split('<v>/<>')
<#># Returns ['ab', 'cd', 'ef']<><>

<cb><v>string_1<> = '<v>ab/cd/ef<>'

<v>split<> = <v>string_1<>.split('<v>/<>', 1)
<#># Returns ['ab', 'cd/ef']<><>

<cb><v>string_1<> = '<v>abcd<>'

<v>split<> = <v>string_1<>.split('<v>/<>')
<#># Returns ['abcd']<><>

<cb><v>string_1<> = '<v>abcd/<>'

<v>split<> = <v>string_1<>.split('<v>/<>')
<#># Returns ['abcd', '']<><>

<cb><v>string_1<> = '<v>/abcd<>'

<v>split<> = <v>string_1<>.split('<v>/<>')
<#># Returns ['', 'abcd']<><>

<cb><v>string_1<> = '<v>ab//cd<>'

<v>split<> = <v>string_1<>.split('<v>/<>')
<#># Returns ['ab', '', 'cd']<><>
@
@ split start, split left side, .split(), delimiter, separate



### String - Split From End

<cb>= <v>string_1<>.rsplit(<v>split_string<>)<>

<cb>= <v>string_1<>.rsplit(<v>split_string<>, <v>split_count<>)<>

Returns a list of strings split on <c><v>split_string<><> starting from the end.
<c><v>split_string<><> is not returned in the results.
Stops after splitting <c><v>split_count<><> times if given.


Example:

<cb><v>string_1<> = "<v>ab/cd/ef<>"
<v>split_1<> = <v>string_1<>.rsplit("<v>/<>", 1)            <#># Returns ['ab-cd', 'ef']<><>
@
@ split right side, .rsplit(), delimiter, last



### String - Split / Partition

<cb>= <v>string_1<>.partition("<v>partition_string<>")<>


Returns: <c>tuple<>


Splits the string into 3 parts: before partition, partition and after partition.
If the partition can't be found, returns the string followed by two empty strings.
Splits at the first match only.


Examples:

<cb><v>partition1<> = "<v>aaa/bbb<>".partition("<v>/<>")

<#># Returns ('aaa', '/', 'bbb')<><>

<cb><v>partition1<> = "<v>aaa bbb<>".partition("<v>/<>")

<#># Returns ('aaa bbb', '', '')<><>
@
@ .partition()



### String - Split On Newline

<cb>= <v>string_2<>.splitlines()<>

Returs: <c>list<>


Returns a list of strings split by newline.


Example:

<cb>lines = 'one\\ntwo\\nthree'.splitlines()

<#># Returns ['one', 'two', 'three']<><>
@
@ .splitlines(), new line, line break., lines, by, into, to



### String - Split on White Space

<cb>= <v>string_1<>.split()

= <v>string_1<>.split(maxsplit = <v>count<>)<>

Returns a list of strings split on white space characters.
Empty splits are not returned.


Example:

<cb><v>string_1<> = '1\\t2\\t\\t3\\t\\t\\t4'

<v>split<> = <v>string_1<>.split()
<#># Returns ['1', '2', '3', '4']<><>

<cb><v>string_1<> = '1\\t2\\t\\t3\\t\\t\\t4'

<v>split<> = <v>string_1<>.split(maxsplit = 2)
<#># Returns ['1', '2', '3\\t\\t\\t4']<><>
@
@ split .split(), tabs, spaces



### String - Starts With?

<cb>= <v>string_1<>.startswith(<v>test_value<>)<>

Returns: <c>bool<>


Returns <c>True<> if <c><v>string_1<><> begins with or equals <c><v>test_value<><>.
@
@ Begins, .startswith(), Starting
@ is, substring



### String - Strip

<cb>= <v>string_1<>.strip()<>

Removes all whitespace characters from the beginning and end of the string.
@
@ trim, remove, delete, whitespaces, white spaces, .strip()



### String - Strip Left

<cb>= <v>string_1<>.lstrip()<>

Removes all whitespace characters at the start of the string.
@
@ trim, remove, whitespaces, white spaces, start, starting, leading, .lstrip(), spaces, delete



### String - Strip Right

<cb>= <v>string_1<>.rstrip()<>

Removes all whitespace characters at the end of the string.
@
@ trim, remove, whitespaces, white spaces, end, ending, .rstrip(), spaces, delete



### String - Substitute / Translate - With Dict

<cb><v>translation<> = str.maketrans(<v>mapping_dict<>)
<v>translated<> = <v>string_1<>.translate(<v>translation<>)<>

Returns: str


Finds all matches for the <c>mapping_dict<> keys in <c>string_1<> and replaces them with their values.


Example:

<cb><v>mappings<> = {
	'1': 'one',
	'2': 'two',
	'3': 'three'}

<v>translation<> = str.maketrans(<v>mappings<>)

<v>string_1<> = 'Items 1, 2, 3'
<v>translated<> = <v>string_1<>.translate(<v>translation<>)

<#># Returns: 'Items one, two, three'<><>
@
@ str.maketrans(), .maketrans()
@ string.translate(), .translate()
@ replace



### String - Substitute / Translate - With String

<cb><v>translation<> = str.maketrans('<v>originals<>', '<v>replacements<>')
<v>translated<> = string.translate(<v>translation<>)<>

Returns: str


Finds characters from <c>originals<> in <c>string_1<> and replaces them with the matching characters from <c>replacements<>.

<c>originals<> and <c>replacements<> must be the same size.


Example:

<cb><v>originals<> = '123'
<v>replacements<> = 'ABC'
<v>translation<> = str.maketrans(<v>originals<>, <v>replacements<>)

<v>string_1<> = 'Items 1, 2, 3'
<v>translated<> = <v>string_1<>.translate(<v>translation<>)

<#># Returns: 'Items A, B, C'<><>
@
@ str.maketrans(), .maketrans()
@ string.translate(), .translate()
@ replace



### String - Substring

<cb>= <v>string_1<>[<v>index<>]

= <v>string_1<>[<v>start<>:<v>end_plus_1<>]

= <v>string_1<>[:<v>end_plus_1<>]<>


See Also: <l "?q=slicing-only">Slicing Sequences<>


Examples:

<cb><v>string_1<> = "<v>12345<>"

<v>first<> = <v>string_1<>[0]                     <#># Returns '1'<>

<v>last<> = <v>string_1<>[-1]                     <#># Returns '5'<>

<v>index_1<> = <v>string_1<>[1]                   <#># Returns '2'<>

<v>index_1_to_3<> = <v>string_1<>[1:4]            <#># Returns '234'<>

<v>index_1_to_end<> = <v>string_1<>[1:]           <#># Returns '2345'<>

<v>start_to_index_3<> = <v>string_1<>[:4]         <#># Returns '1234'<><>
@
@ Partial, Slice, .substring(), []



### String - Substring - Left

<cb>= <v>string_1<>[:<v>length_plus_1<>]<>


Example:

<cb><v>string_1<> = "12345"

<v>substring<> = <v>string_1<>[:3]

<#># Returns "123"<><>
@
@ Start, Beginning, slice, partial, .left(), []


 
### String - Substring - Right

<cb>= <v>string_1<>[<v>start<>:]<>


Example:

<cb><v>string_1<> = "12345"

<v>substring<> = <v>string_1<>[2:]

<#># Returns "345"<><>
@
@ Last, End, slice, partial, .right(), []



### String - Substring - Remove Prefix

<cb>= <v>string_1<>.removeprefix(<v>prefix_1<>)<>


Removes the prefix but only if it is present.
No prefix returns the original string.

Python Version: 3.9+


Example:

<cb><v>string_1<> = 'https://speedsheet.io'

<v>substring<> = <v>string_1<>.removeprefix("https://")

<#># Returns 'speedsheet.io'<><>
@
@ partial, .removeprefix()
@ delete, start, leading, beginning, starting



### String - Substring - Remove Suffix

<cb>= <v>string_1<>.removesuffix(<v>suffix_1<>)<>


Removes the suffix but only if it is present.
No suffix returns the original string.

Python Version: 3.9+


Example:

<cb><v>string_1<> = 'file_name.txt'

<v>substring<> = <v>string_1<>.removesuffix(".txt")

<#># Returns 'file_name'<><>
@
@ Postfix, .removesuffix()
@ end, delete, ending



### String - Word Count

<cb>= len(<v>string_1<>.split())<>


Example:

<cb><v>words<> = '<v>one two three<>'

<v>count<> = len(<v>words<>.split())

<#># Returns 3<><>



### String - To Capitalized Case

<cb>= <v>string_1<>.capitalize()<>


Changes the first letter to upper case.


Example:

<cb><v>text<> = '<v>one two three<>'

<v>capitalized<> = <v>text<>.capitalize()

<#># Returns 'One two three'<><>
@
@ .capitalize(), caps, convert, conversion


 
### String - To Lower Case

<cb>= <v>string_1<>.lower()<>


Converts every letter to lower case.


Example:

<cb><v>text<> = '<v>One TWO three<>'

<v>lower_case<> = <v>text<>.lower()

<#># Returns 'one two three'<><>
@
@ .lower(), .tolower(), lowercase, convert, conversion



### String - To Title Case

<cb>= <v>string_1<>.title()<>


Capitalizes the first letter in every word.

Words are separated by spaces or underscores.


Example:

<cb><v>text<> = '<v>one two three<>'

<v>title_case<> = <v>text<>.title()

<#># Returns 'One Two Three'<><>

<cb><v>text<> = '<v>one_two_three<>'

<v>title_case<> = <v>text<>.title()

<#># Returns 'One_Two_Three'<><>
@
@ .title(), convert, conversion



### String - To Upper Case

<cb>= <v>string_1<>.upper()<>


Converts every letter to upper case.


Example:

<cb><v>text<> = '<v>one two three<>'

<v>upper_case<> = <v>text<>.upper()

<#># Returns 'ONE TWO THREE'<><>
@
@ .upper(), .toupper(), caps, uppercase, convert, conversion



### String - Fold Case

<cb>= <v>string_1<>.casefold()<>


Use this when you need to compare two strings but ignore the case (caseless).

Converts the string into a safe case agnostic form.
This is very important for unicode characters.

Why?
Because case rules (uppercase, lowercase) can get complicated, especially in foreign languages.
Some languages have more than one case or special rules for when a particular form of letter should be used.


Example:

<cb><v>case_folded<> = '<v>Ὀδυσσεύ<m>ς<><>'.casefold()

<#># Returns 'ὀδυσσεύ<m>σ<>'<><>


In Depth:

<cb><#># Helper Function:<>

def print_cases(text):
	print("Original:   ", text)
	print("Upper:      ", text.upper())
	print("Lower:      ", text.lower())
	print("Folded:     ", text.casefold())<>

<cb><#># German Letter SS/ß<>

print_cases("<v>Hegelstraße<>")

<#>\#  Original:   Hegelstra<m>ß<>e
\#  Upper:      HEGELSTRA<m>SS<>E
\#  Lower:      hegelstra<m>ß<>e
\#  Folded:     hegelstra<m>ss<>e<><>


<cb><#># Greek Letter Σ/σ/ς<>

print_cases("<v>Ὀδυσσεύς<>")

<#>\#  Original: Ὀδυσσεύ<m>ς<>
\#  Upper:    ὈΔΥΣΣΕΎ<m>Σ<>
\#  Lower:    ὀδυσσεύ<m>ς<>
\#  Folded:   ὀδυσσεύ<m>σ<><><>
@
@ .casefold(), case folding, compare strings unicode, normalize, normalization



### String - To Words

<cb>= <v>string_1<>.split()<>


Returns: <c>list<>


Splits the string along whitespaces.
@
@ .split(), whitespaces, white spaces, convert



### String List - Join

<cb>= ''.join(<v>strings<>)

= ''.join([<v>string1<>, <v>string2<>, <v>string3<>])

= ''.join(<v>iterable<>)<>


Joins all elements of <c><v>iterable<><> into 1 string with <c><v>separator<><> between each element.


Example:

<cb><v>list_1<> = ['<v>a<>', '<v>b<>', '<v>c<>']
<v>string_1<> = ''.join(<v>list_1<>)          <#># Returns 'abc'<><>
@
@ .join()
@ concatenate, combine, strings



### String List - Join With Separator

<cb>= <v>separator<>.join(<v>strings<>)

= <v>separator<>.join([<v>string1<>, <v>string2<>, <v>string3<>])

= <v>separator<>.join(<v>iterable<>)<>


Joins all elements of <c><v>iterable<><> into 1 string with <c><v>separator<><> between each element.


Example:

<cb><v>list_1<> = ['<v>a<>', '<v>b<>', '<v>c<>']
<v>string_1<> = '<v>, <>'.join(<v>list_1<>)          <#># Returns 'a, b, c'<><>
@
@ .join()
@ concatenate, combine, strings



### String List - Longest String

<cb>= max(<v>string_list<>, key = len)<>


Returns the longest string in the list.
@
@ strings, max()



### String List - Max Length

<cb>= max(len(<v>string<>) for <v>string<> in <v>string_list<>)<>


Returns the length of the longest string.
@
@ strings, max(), greatest, largest



# Dates
@
@ date-only, dates-only, datetime.date, date()
@ create, define, instantiate, new, now, current, data type


### Date - Create

<cb>= date(<v>year<>, <v>month<>, <v>day<>)<>

Usage:

<cb>from datetime import date

= date(<v>year<>, <v>month<>, <v>day<>)
= date(year = <v>year<>, month = <v>month<>, day = <v>day<>)<>

Returns: <c>date<>


Returns an instance of <c>date<> representing the year, month and day.


Unit Ranges:

<in><table><col>Year<><col>1 - 9999<>
<col>Month<><col>1 - 12<>
<col>Day<><col>1 - Last-Day-Of-Month<><><>


Example:

<cb>from datetime import date

<v>date_1<> = date(<v>2000<>, <v>1<>, <v>2<>)

print("Date 1", <v>date_1<>)

<#># Prints: Date-1 2000-01-02<><>
@
@ datetime.date(), .date()
@ _model_



### Date - Create Today's Date

<cb>date.today()<>

Usage:

<cb>from datetime import date

= date.today()<>

Returns: <c>date<>


Returns a <c>date<> for today.


Unit Ranges:

<table><col>Year<><col>1 - 9999<>
<col>Month<><col>1 - 12<>
<col>Day<><col>1 - Last-Day-Of-Month<><>


Example:

<cb>from datetime import date

<v>date_1<> = date.today()

print("Today", <v>date_1<>)<>
@
@ datetime.date.today(), date.today(), .today()
@ current date
@ _model_



# Date Operations
@
@ date-only, dates-only, date.
@ ops, .date(), datetime.date, .today(), date.



### Date - Compare

<cb>if <v>date_1<> == <v>date_2<>:
	<v>...<><>

<cb>if <v>date_1<> \< <v>date_2<>:
	<v>...<><>
@
@ less than, greater than, equals, ==, \<, \</, >, >=, !=



### Date - Difference, Get TimeDelta

<cb>= <v>date_2<> - <v>date_1<><>

Returns: <c>timedelta<>

Returns the difference in days.
@
@ minus, subtraction, timedelta



### Date - Add TimeDelta

<cb>= <v>date_1<> + <v>timedelta_2<><>

Returns: <c>date<>

Adds the day portion of <c><v>timedelta_2<><> to <c><v>date_1<><>.
@
@ time delta, +, plus



### Date - Subtract TimeDelta

<cb>= <v>date_1<> - <v>timedelta_2<><>

Returns: <c>date<>

Subtracts the day portion of <c><v>timedelta_2<><> to <c><v>date_1<><>.
@
@ time delta, -, minus



### Date - Get Now

<cb>from datetime import date

= date.today()<>
@
@ today, current, now, .today()



### Date - Get Last Day of Month

<cb>= calendar.monthrange(<v>date_1<>.year, <v>date_1<>.month)[1]<>

Usage:

<cb>import calendar

= calendar.monthrange(<v>date_1<>.year, <v>date_1<>.month)[1]<>

Returns: <c>int<>


Returns the last day of the month.


Example:

<cb>import calendar
from datetime import date

<v>date_1<> = date(<v>2000<>, <v>2<>, <v>1<>)

<v>last_day<> = calendar.monthrange(<v>date_1<>.year, <v>date_1<>.month)[1]

<#># Returns: 29<><>
@
@ calendar.monthrange(), .monthrange()
@ get, find, end



### Date - Get Next Month, First Day

<cb>= <v>date_1<> + relativedelta(months=1, day=1)<>

Usage:

<cb>from dateutil.relativedelta import relativedelta

= <v>date_1<> + relativedelta(months=1, day=1)<>


Returns a date for the first day of the next month.


Example:

<cb>from datetime import date
from dateutil.relativedelta import relativedelta

<v>date_1<> = date(<v>2000<>, <v>2<>, <v>1<>)

<v>next_month<> = <v>date_1<> + relativedelta(months=1, day=1)

<#># Returns: datetime(2000, 3, 1)<><>
@
@ 1st



### Date - Get Previous Month, Last Day

<cb>= <v>date_1<>.replace(day = 1) - timedelta(days=1)<>

Usage:

<cb>from datetime import timedelta

= <v>date_1<>.replace(day = 1) - timedelta(days=1)<>


Returns the last day of the previous month:


Example:

<cb>from datetime import date
from datetime import timedelta

<v>today<> = date.today()
<v>last_month<> = <v>today<>.replace(day = 1) - timedelta(days=1)

print('last month', <v>last_month<>)<>



### Date - Replace Unit

<cb>= <v>date_1<>.replace(<v>unit<> = <v>value<>)<>

Usage:

<cb>= <v>date_1<>.replace(year = <v>year<>)
= <v>date_1<>.replace(month = <v>month<>)
= <v>date_1<>.replace(day = <v>day<>)<>


Replaces one or more of the date units with a new value.


Unit Ranges:

<table><col>Year<><col>1 - 9999<>
<col>Month<><col>1 - 12<>
<col>Day<><col>1 - <v>Last-Day-Of-Month<><><>


Example:

<cb>from datetime import date

<v>today<> = date.today()

<v>start_of_month<> = <v>today<>.replace(day = 1)

print("Start of Month:", <v>start_of_month<>)<>
@
@ date.replace(), .replace()
@ year, month, day
@ update, change, set



### Date - To Year

<cb>= <v>date_1<>.year<>
@
@ Property, Properties, .years



### Date - To Month

<cb>= <v>date_1<>.month<>
@
@ Property, Properties, .months



### Date - To Day

<cb>= <v>date_1<>.day<>
@
@ Property, Properties, .days



### Date - To Day of Week

<cb>= <v>date_1<>.weekday()<>


Returns: <c>int<>

That is <c>.weekday()<> with a ().

0 is Monday.
6 is Sunday.
@
@ Property, Properties, .weekday(), days



### Date - From Timestamp

<cb>from datetime import date

<v>date_1<> = date.fromtimestamp(<v>timestamp_1<>)<>
@
@ Convert, Conversion, To, datetime.date, date.fromtimestamp(), .fromtimestamp()
@ from-date, to-timestamp



### Date - From String

<cb>from datetime import datetime

<v>date_1<> = datetime.strptime(<v>date_string<>, <v>date_format<>).date()<>


You must convert to a datetime first, then to a date.


Examples:

<cb>from datetime import datetime

<v>date_2<> = datetime.strptime(<v>"2000-01-02"<>, "<v>%Y-%m-%d<>").date()

<#># Returns: datetime.date(2000, 1, 2)<><>


<cb>from datetime import datetime

<v>date_2<> = datetime.strptime(<v>"2000-1-2"<>, "<v>%Y-%m-%d<>").date()

<#># Returns: datetime.date(2000, 1, 2)<><>
@
@ date.strptime(), date.strptime(), .strptime()
@ convert, conversion, to, from, parse
@ to-date, from-string



### Date - To String

<cb>= '{:<v>format<>}'.format(<v>date_1<>)<>

All Formatting Options:

<cb>= f'{<v>date_1<>:<v>format<>}'
= '{:<v>format<>}'.format(<v>date_1<>)
= <v>date_1<>.strftime(<v>format<>)
= <v>date_1<>.isoformat()<>


Converts a date into a string.

A typical format would be <c>'%Y-%m-%d'<> or <c>'%m/%d/%Y'<>.


Example:

<cb>from datetime import date

<v>date_1<> = date(2001, 1, 1)

<#># These are equivalent:<>

<v>string_1<> = f'{<v>date_1<>:%Y-%m-%d}'
<v>string_2<> = '{:%Y-%m-%d}'.format(<v>date_1<>)
<v>string_3<> = <v>date_1<>.isoformat()
<v>string_4<> = <v>date_1<>.strftime(<v>'%Y-%m-%d'<>)

<#># Returns '2001-01-01'<><>
@
@ Convert, Conversion, To, From, Format, Formatting, Formatted, .format(), .strftime()
@ from-date, to-string



### Date - From ISO-8601 String

<cb>from datetime import date

<v>date_1<> = date.fromisoformat(<v>iso_date_string<>)<>


Accepted Format:

<cb>'<v>YYYY<>-<v>MM<>-<v>DD<>'<>


Example:

<cb>from datetime import date

<v>date_1<> = date.fromisoformat(<v>"2000-01-02"<>)<>

<cb>from datetime import date
from datetime import datetime

<#># These are equivalent:<>

<v>date_1<> = date.fromisoformat(<v>"2000-01-02"<>)
<v>date_2<> = datetime.strptime(<v>"2000-01-02"<>, "<v>%Y-%m-%d<>").date()<>
@
@ date.fromisoformat(), .fromisoformat()
@ convert, conversion, to, from, parse
@ to-date, from-string, from-iso-8601, iso-8601



### Date - To ISO-8601 String

<cb>= <v>date_1<>.isoformat()<>


Returned Format:

<cb>'<v>YYYY<>-<v>MM<>-<v>DD<>'<>


Example:

<cb>from datetime import date

<v>date_1<> = date(2001, 1, 1)

<v>string_1<> = <v>date_1<>.isoformat()

<#>Returns '2001-01-01'<><>

<cb>from datetime import date

<v>date_1<> = date.today()

<#># These are equivalent:<>

<v>string_1<> = <v>date_1<>.isoformat()
<v>string_2<> = <v>date_1<>.strftime(<v>'%Y-%m-%d'<>)
<v>string_3<> = ':%Y-%m-%d'.format(<v>date_1<>)<>
@
@ Convert, Conversion, To, From, Format, Formatting, Formatted, .format()
@ iso-8601, date.isoformat(), .isoformat(), .strftime()
@ from-date, to-string



# DateTimes
@
@ datetime, datetimes, date times,
@ datetime-only, datetimes-only, date-time-only, date-times-only, dt
@ datetime.datetime, .datetime()
@ create, define, instantiate, new, now, current, data type


### Datetime - Create

<cb>= datetime(<v>year<>, <v>month<>, <v>day<>, <v>hour<>, <v>minute<>, <v>second<>)<>

Usage:

<cb>from datetime import datetime

= datetime(<v>year<>, <v>month<>, <v>day<>, <v>hour<>, <v>minute<>, <v>second<>)
= datetime(<v>year<>, <v>month<>, <v>day<>, <v>hour<>, <v>minute<>, <v>second<>, <v>microsecond<>)

= datetime(
        year = <v>year<>,
        month = <v>month<>,
        day = <v>day<>,
        hour = <v>hour<>,
        minute = <v>minute<>,
        second = <v>second<>,
        microsecond = <v>microsecond<>)<>

Returns: <c>datetime<>


Returns an instance of datetime representing the date and time.


Unit Ranges:

<table><col>Year<><col>1 - 9999<>
<col>Month<><col>1 - 12<>
<col>Day<><col>1 - Last-Day-Of-Month<>
<col>Hour<><col>0 - 23<>
<col>Minute<><col>0 - 59<>
<col>Second<><col>0 - 59<>
<col>Microseconds<><col>0 - 999,999<><>


Example:

<cb>from datetime import datetime

<v>date_1<> = datetime(<v>2000<>, <v>11<>, <v>28<>, <v>23<>, <v>59<>, <v>59<>)<>
@
@ datetime.datetime, .datetime()



### Datetime - Create UTC Time (Deprecated)

<m>This is deprecated and will be removed from future Python releases<>

<cb>= datetime.utcnow()<>

Usage:

<cb>from datetime import datetime

= datetime.utcnow()<>


Use this instead:

<cb>= datetime.now(tz = timezone.utc)<>


Returns the current UTC time.


Does not include time zone information.
@
@ datetime.datetime.utcnow(), datetime.utcnow(), .utcnow()



### Datetime - Create Now

<cb>= datetime.now()<>

Usage:

<cb>from datetime import datetime

= datetime.now()<>

Returns: <c>datetime<>


Returns an instance of the current date time.


Example:

<cb>from datetime import datetime

<v>date_1<> = datetime.now()<>
@
@ datetime.today(), .today(), datetime.now(), .now()



### Datetime - now() vs today()

<c>now()<>:

<*>Preferred
Allows for Time Zone<>

<c>today()<>

<*>No Time Zone Allowed<>


Prefer <c>now()<> to <c>today()<>.

<c>now()<> allows for time zone information to be included.
But in reality for non time zone datetimes, they are equivalent.
@
@ datetime.today(), .today(), datetime.now(), .now()



# DateTime - Operations
@
@ datetime, datetimes, Date Times, datetime-only, datetimes-only, date-time-only, date-times-only, DT
@ Ops, datetime.datetime, .datetime()



### DateTime - Compare

<cb>if <v>datetime_1<> == <v>datetime_2<>:
	<v>...<><>

<cb>if <v>datetime_1<> \< <v>datetime_2<>:
	<v>...<><>
@
@ Less Than, Greater Than, Equals, ==, \<, \</, >, >=, !=



### DateTime - Difference, Get TimeDelta

<cb>= <v>datetime_2<> - <v>datetime_1<><>

Returns: <c>timedelta<>
@
@ -, Subtract, Minus, subtraction, timedelta



### DateTime - Add TimeDelta

<cb>= <v>datetime_1<> + <v>time_delta_1<><>

Returns: <c>datetime<>
@
@ addition, timedelta, +



### DateTime - Subtract TimeDelta

<cb>= <v>datetime_1<> - <v>time_delta_1<><>

Returns: <c>datetime<>
@
@ timedelta, -, minus, subtraction



### DateTime - Get Now

<cb>from datetime import datetime

= datetime.today()<>
@
@ current, datetime.today(), .today()



### DateTime - Get Last Day of Month

<cb>= calendar.monthrange(<v>datetime_1<>.year, <v>datetime_1<>.month)[1]<>

Usage:

<cb>import calendar

= calendar.monthrange(<v>datetime_1<>.year, <v>datetime_1<>.month)[1]<>

Returns: <c>int<>


Returns the last day of the month.


Example:

<cb>import calendar
from datetime import datetime

<v>datetime_1<> = datetime(<v>2000<>, <v>2<>, <v>1<>, <v>0<>, <v>0<>, <v>0<>)

<v>last_day<> = calendar.monthrange(<v>datetime_1<>.year, <v>datetime_1<>.month)[1]

<#># Returns: 29<><>
@
@ calendar.monthrange(), .monthrange()
@ get, find, end



### DateTime - Get Next Month, First Day

<cb>= <v>datetime_1<> + relativedelta(months=1, day=1)<>

Usage:

<cb>from dateutil.relativedelta import relativedelta

= <v>datetime_1<> + relativedelta(months=1, day=1)<>


Returns a datetime for the first day of the next month.


Example:

<cb>from datetime import datetime
from dateutil.relativedelta import relativedelta

<v>datetime_1<> = datetime(<v>2000<>, <v>2<>, <v>1<>, <v>0<>, <v>0<>, <v>0<>)

<v>next_month<> = <v>datetime_1<> + relativedelta(months=1, day=1)

<#># Returns: datetime(2000, 3, 1, 0, 0)<><>
@
@ 1st
@ dateutil.relativedelta.relativedelta, .relativedelta.relativedelta, .relativedelta



### DateTime - Replace Unit

<cb>= <v>datetime_1<>.replace(<v>unit<> = <v>value<>)<>

Usage:

<cb>= <v>datetime_1<>.replace(year = <v>year<>)
= <v>datetime_1<>.replace(month = <v>month<>)
= <v>datetime_1<>.replace(day = <v>day<>)
= <v>datetime_1<>.replace(hour = <v>hour<>)
= <v>datetime_1<>.replace(minute = <v>minute<>)
= <v>datetime_1<>.replace(second = <v>second<>)
= <v>datetime_1<>.replace(microsecond = <v>microsecond<>)<>


Replaces one or more of the datetime units with a new value.


Unit Ranges:

<table><col>Year<><col>1 - 9999<>
<col>Month<><col>1 - 12<>
<col>Day<><col>1 - Last-Day-Of-Month<>
<col>Hour<><col>0 - 23<>
<col>Minute<><col>0 - 59<>
<col>Second<><col>0 - 59<>
<col>Microseconds<><col>0 - 999,999<><>


Example:

<cb>from datetime import datetime

<v>now<> = datetime.now()

<v>start_of_day<> = <v>now<>.replace(
        hour = 0,
        minute = 0,
        second = 0,
        microsecond = 0)

print("Start of Day:", <v>start_of_day<>)<>
@
@ datetime.replace(), .replace()
@ year, month, day, hour, minute, second, millisecond
@ update, change, set



### DateTime - To Year

<cb>= <v>datetime_1<>.year<>
@
@ property, properties



### DateTime - To Month

<cb>= <v>datetime_1<>.month<>
@
@ property, properties, .months



### DateTime - To Day

<cb>= <v>datetime_1<>.day<>
@
@ property, properties, .days



### DateTime - To Day of Week

<cb>= <v>datetime_1<>.weekday()<>


Returns: <c>int<>

Yes, this is <c>.weekday()<> with a <c>()<>.

0 is Monday.
6 is Sunday.
@
@ property, properties, .weekday()



### DateTime - To Hour

<cb>= <v>datetime_1<>.hour<>
@
@ property, properties, .hours



### DateTime - To Minute

<cb>= <v>datetime_1<>.minute<>
@
@ property, properties, .minutes



### DateTime - To Second

<cb>= <v>datetime_1<>.second<>
@
@ property, properties, .seconds



### DateTime - To Date

<cb>= <v>datetime_1<>.date()<>
@
@ convert, conversion, from, .date()
@ from-datetime, to-date



### DateTime - To Time

<cb>= <v>datetime_1<>.time()<>
@
@ convert, conversion, from, .time()
@ from-datetime, to-time



### DateTime - From Timestamp

<cb>from datetime import datetime

<v>datetime_1<> = datetime.fromtimestamp(<v>timestamp_1<>)<>


Get the datetime for the given timestamp or epoch time (the number of seconds since 1969-12-31 19:00:00).



Example:

<cb><v>datetime_1<> = datetime.fromtimestamp(<v>0<>)

<#># Returns 1969-12-31 19:00:00<><>

<cb><v>datetime_1<> = datetime.fromtimestamp(<v>978325200<>)

<#># Returns 2001-01-01 00:00:00<><>

<cb><v>datetime_1<> = datetime.fromtimestamp(<v>978325200.5<>)

<#># Returns 2001-01-01 00:00:00:500000<><>
@
@ Convert, Conversion, To, datetime.fromtimestamp(), .fromtimestamp()
@ to-datetime, from-timestamp



### DateTime - To TimeStamp

<cb><v>timestamp_1<> = <v>datetime_1<>.timestamp()<>

Or

<cb>from datetime import datetime

<v>timestamp_1<> = datetime.timestamp(<v>datetime_1<>)<>


Returns: <c>float<>


Returns the timestamp or epoch time in seconds.


Example:

<cb>from datetime import datetime

<v>datetime_1<> = datetime(2001, 1, 1)

<v>timestamp_1<> = <v>datetime_1<>.timestamp()

<#># Returns 978325200.0.<><>
@
@ convert, conversion, from, datetime.timestamp(), .timestamp()
@ from-datetime, to-timestamp



### DateTime - From String

<cb>from datetime import datetime

<v>datetime_1<> = datetime.fromisoformat(<v>iso_date_time_string<>)<>

or

<cb><v>datetime_2<> = datetime.strptime(<v>date_time_string<>, <v>date_time_format<>)<>


Example:

<cb>from datetime import datetime

<#># These are equivalent:<>

<v>date_1<> = datetime.fromisoformat("<v>2020-11-30 23:59:59<>")
<v>date_2<> = datetime.strptime("<v>2020-11-30 23:59:59<>", '<v>%Y-%m-%d %H:%M:%S<>')<>
@
@ convert, conversion, to,datetime.strptime(), .strptime(), parse
@ to-datetime, from-string



### DateTime - To String

<cb>= f'{<v>datetime_1<>:<v>format<>}<>

All Formatting Options:

<cb>= f'{<v>datetime_1<>:<v>format<>}
= '{:<v>format<>}'.format(<v>datetime_1<>)
= <v>datetime_1<>.strftime(<v>format<>)<>


Converts a datetime into a string.

A typical format would be <c>'%Y-%m-%d %H:%M:%S'<> or <c>'%m/%d/%Y %H:%M:%S'<>.


Example:

<cb>from datetime import datetime

<v>datetime_1<> = datetime(2001, 1, 1, 1, 1, 1)

<v>string_1<> = f'{<v>datetime_1<>:<v>%Y-%m-%d %H:%M:%S<>}'
<v>string_2<> = '{:<v>%Y-%m-%d %H:%M:%S<>}'.format(<v>datetime_1<>)
<v>string_3<> = <v>datetime_1<>.strftime('<v>%Y-%m-%d %H:%M:%S<>')

<#># All Return: '2001-01-01 01-01-01'<><>
@
@ convert, conversion, to, from, .format(), formatting, formatted, .strftime()
@ from-datetime, to-string



### DateTime - From ISO-8601 String

<cb>from datetime import datetime

<v>datetime_1<> = datetime.fromisoformat(<v>iso_date_time_string<>)<>


Accepted Formats:

<cb>'<v>YYYY<>-<v>MM<>-<v>DD<> <v>hh<>:<v>mm<>:<v>ss<>'
'<v>YYYY<>-<v>MM<>-<v>DD<>T<v>hh<>:<v>mm<>:<v>ss<>'<>


Example:

<cb>from datetime import datetime

<v>date_1<> = datetime.fromisoformat("<v>2020-11-30 23:59:59<>")<>

<cb>from datetime import datetime

<#># These are equivalent:<>

<v>date_1<> = datetime.fromisoformat("<v>2020-11-30 23:59:59<>")
<v>date_2<> = datetime.strptime("<v>2020-11-30 23:59:59<>", '<v>%Y-%m-%d %H:%M:%S<>')<>
@
@ convert, conversion, to, datetime.fromisoformat(), .fromisoformat(), parse, iso
@ to-datetime, from-string, from-iso-8601



### DateTime - To ISO-8601 String

<cb>= <v>datetime_1<>.isoformat()<>


Returns Format:

<cb>'<v>YYYY<>-<v>MM<>-<v>DD<>T<v>HH<>:<v>MM<>:<v>SS<>'<>

<cb>'<v>YYYY<>-<v>MM<>-<v>DD<>T<v>HH<>:<v>MM<>:<v>SS<>.<v>ssssss<>'<>


Example:

<cb>from datetime import datetime

<v>datetime_1<> = datetime(2001, 1, 1, 1, 1, 1)

<v>formatted_datetime<> = <v>datetime_1<>.isoformat()

<#># Returns '2001-01-01T01:01:01'<><>

<cb>from datetime import datetime

<v>datetime_1<> = datetime(2001, 1, 1, 1, 1, 1, 500)

<v>formatted_datetime<> = <v>datetime_1<>.isoformat()

<#># Returns '2001-01-01T01:01:01.000500'<><>
@
@ convert, conversion, to, from, .format(), formatting, formatted, .isoformat(), .strftime(), iso
@ iso-8601
@ from-datetime, to-string, to-iso-8601



# DateTime - Time Zones
@
@ datetime.datetime(), .datetime()
@ timezones, time-zones, datetimes
@ new, define, create
@ timezone-only, timezones-only, time-zone-only, time-zones-only


### Datetime - Create With Time Zone

<cb>= datetime(<v>...<>, tzinfo = <v>time_zone<>)<>

Usage:

<cb>from datetime import datetime
from zoneinfo import ZoneInfo

= datetime(<v>...<>, tzinfo = ZoneInfo('<v>time_zone<>'))<>

Return: <c>datetime<>


Creates a date time with the given time zone.


Example:

<cb>from datetime import datetime
from zoneinfo import ZoneInfo

<v>datetime_1<> = datetime(2001, 1, 1, 0, 0, 0,
        tzinfo = ZoneInfo('<v>America/New_York<>'))

print(<v>datetime_1<>)

<#># Prints: 2001-01-01 00:00:00-05:00<><>
@
@ datetime.datetime(), .datetime(), tzinfo=



### Datetime - Create With Local Time Zone

<cb>= datetime(<v>...<>).astimezone()<>

Usage:

<cb>from datetime import datetime

= datetime(<v>...<>).astimezone()<>

Return: <c>datetime<>


Example:

<cb>from datetime import datetime

<v>datetime_1<> = datetime(2001, 1, 1, 0, 0, 0).astimezone()

print(<v>datetime_1<>)<>
@
@ datetime.astimezone(), .astimezone()
@ datetime.datetime(), .datetime()



### Datetime - Create With UTC Time Zone

<cb>= datetime(<v>...<>, tzinfo = timezone.utc)<>

Usage:

<cb>from datetime import datetime
from datetime import timezone

= datetime(<v>...<>, tzinfo = timezone.utc)<>

Return: <c>datetime<>


Example:

<cb>from datetime import datetime
from datetime import timezone

<v>datetime_1<> = datetime(2001, 1, 1, 0, 0, 0, tzinfo = timezone.utc)

print(<v>datetime_1<>)

<#># Prints: 2001-01-01 00:00:00+00:00<><>
@
@ datetime.datetime(), .datetime(), tzinfo=



### Datetime - Create With Fold

<cb>= datetime(<v>...<>, fold = <v>fold_number<>)<>


Allows you to set the time unambiguously during a transition from daylight savings.


Daylight Savings Clock Change:

<in><table><col>Before	<><col>fold = 0<>
<col>After<><col>fold = 1<><><>


Example:

<cb>from datetime import datetime
from datetime import timezone
from zoneinfo import ZoneInfo

<v>before_clock_change<> = datetime(2000, 10, 29, 1, 30, 0,
	tzinfo = ZoneInfo('America/New_York'), fold = 0)

<v>after_clock_change<> = datetime(2000, 10, 29, 1, 30, 0,
	tzinfo = ZoneInfo('America/New_York'), fold = 1)

print(<v>before_clock_change<>)
print(<v>after_clock_change<>)

<#># Prints:
/#
/#   2000-10-29 01:30:00-04:00
/#   2000-10-29 01:30:00-05:00<><>

In UTC:

<cb>print(<v>before_clock_change<>.astimezone(timezone.utc))
print(<v>after_clock_change<>.astimezone(timezone.utc))

<#># Prints:
/#
/#   2000-10-29 05:30:00+00:00
/#   2000-10-29 06:30:00+00:00<><>
@
@ datetime.datetime(), .datetime(), tzinfo=, fold=
@ folding



### Datetime - Create Now With Time Zone

<cb>= now(tz = <v>time_zone<>)<>

<cb>from datetime import datetime
from zoneinfo import ZoneInfo

= datetime.now(tz = ZoneInfo('<v>time_zone<>'))<>

Return: <c>datetime<>


Returns the current date time with the given time zone.


Example:

<cb>from datetime import datetime
from zoneinfo import ZoneInfo

<v>datetime_1<> = datetime.now(tz = ZoneInfo('<v>America/New_York<>'))

print(<v>datetime_1<>)<>
@
@ datetime.today(), .today(), datetime.now(), .now(), tz=



### Datetime - Create Now With Local Time Zone

<cb>= datetime.now().astimezone()<>

Usage:

<cb>from datetime import datetime

= datetime.now().astimezone()<>

Return: <c>datetime<>


Example:

<cb>from datetime import datetime

<v>datetime_1<> = datetime.now().astimezone()

print(<v>datetime_1<>)<>
@
@ datetime.today(), .today(), datetime.now(), .now()
@ datetime.astimezone(), .astimezone()



### Datetime - Create Now With UTC Time Zone

<cb>= datetime.now(tz = timezone.utc)<>

Usage:

<cb>from datetime import datetime
from datetime import timezone

= datetime.now(tz = timezone.utc)<>

Return: <c>datetime<>


Example:

<cb>from datetime import datetime
from datetime import timezone

<v>datetime_1<> = datetime.now(tz = timezone.utc)

print(<v>datetime_1<>)<>
@
@ datetime.today(), .today(), datetime.now(), .now(), tz=
@ datetime.timezone.utc, .timezone.utc, .utc



# DateTime - Time Zone Operations
@
@ timezones, datetimes, time zones, time-zones
@ timezone-only, timezones-only


### Datetime - Change Time Zone

<cb>= <v>datetime_1<>.astimezone(<v>time_zone<>)<>


Changes the datetime to datetime in the provided time zone.


Example:

<cb>from datetime import datetime
from zoneinfo import ZoneInfo

<v>ny_datetime<> = datetime(2001, 1, 1, 0, 0, 0,
        tzinfo = ZoneInfo('America/New_York'))

<v>la_datetime<> = <v>ny_date<>.astimezone(ZoneInfo('America/Los_Angeles'))

print("NY:", <v>ny_datetime<>)
print("LA:", <v>la_datetime<>)

<#># Prints:
\#    NY: 2001-01-01 00:00:00-05:00
\#    LA: 2000-12-31 21:00:00-08:00<><>
@
@ datetime.astimezone(), .astimezone()



### Datetime - Change To Local Time Zone

<cb>= <v>datetime_1<>.astimezone()<>


Changes the datetime to the local time zone.


Example:

<cb>from datetime import datetime
from zoneinfo import ZoneInfo

<v>ny_datetime<> = datetime(2001, 1, 1, 0, 0, 0,
        tzinfo = ZoneInfo('America/New_York'))

<v>local_datetime<> = <v>ny_datetime<>.astimezone()<>
@
@ datetime.astimezone(), .astimezone()



### Datetime - Get Time Zone

<cb>= <v>datetime_1<>.tzname()<>

Returns: <c>str<>


Returns the name of the time zone.


Example:

<cb>from datetime import datetime
from zoneinfo import ZoneInfo

<v>datetime_1<> = datetime(2001, 1, 1, 0, 0, 0,
        tzinfo = ZoneInfo('<v>America/New_York<>'))

print(<v>datetime_1<>.tzname())

<#># Prints: EST<><>
@
@ datetime.tzname(), .tzname()



### Datetime - Is In Daylight Savings?

<cb>= <v>datetime_1<>.dst() == timedelta(seconds=3600)<>

Usage:

<cb>from datetime import timedelta

= <v>datetime_1<>.dst() == timedelta(seconds=3600)<>


Returns: <c>str<>


Returns <c>True<> if in daylight savings.

<cb>.dst()<> returns the difference in time from the non DST time.


Example:

<cb>from datetime import datetime
from zoneinfo import ZoneInfo
from datetime import timedelta

<v>datetime_1<> = datetime(2001, 7, 1, 0, 0, 0,
        tzinfo = ZoneInfo('<v>America/New_York<>'))

print(<v>datetime_1<>.dst() == timedelta(seconds=3600))

<#># Prints: True<><>
@
@ datetime.dst(), .dst()



### Datetime - Is Folded?

<cb>= <v>datetime_1<>.fold<>


Returns if the time is after a daylight savings change.


Daylight Savings Clock Change:

<in><table><col>Before	<><col>fold = 0<>
<col>After<><col>fold = 1<><><>


Example:

<cb>from datetime import datetime
from zoneinfo import ZoneInfo

after_clock_change = datetime(2000, 10, 29, 1, 30, 0,
	tzinfo = ZoneInfo('America/New_York'), fold = 1)

print(after_clock_change.fold)<>
@
@ datetime.fold, .fold, folding



### Datetime - Set / Replace Time Zone

<cb>= <v>datetime_1<>.replace(tzinfo = <v>time_zone<>)<>


Updates the time zone but keeps the time unchanged.


Example:

<cb>from datetime import datetime
from zoneinfo import ZoneInfo

<v>ny_date<> = datetime(2001, 1, 1, 0, 0, 0,
        tzinfo = ZoneInfo('America/New_York'))

<v>la_date<> = <v>ny_date<>.replace(tzinfo = ZoneInfo('America/Los_Angeles'))

print("NY:", <v>ny_date<>)
print("LA:", <v>la_date<>)

<#># Prints:
\#    NY: 2001-01-01 00:00:00-05:00
\#    LA: 2001-01-01 00:00:00-08:00<><>
@
@ datetime.replace(), .replace(), tzinfo=



# Time Zones
@
@ timezones, time-zones
@ timezone-only, timezones-only


### Time Zone - Get

<cb>= ZoneInfo('<v>time_zone<>')<>

Usage:

<cb>from zoneinfo import ZoneInfo

= ZoneInfo('America/EST')<>


Returns the zone info object for the given time zone.


Example:

<cb>from zoneinfo import ZoneInfo

<v>zone_1<> = ZoneInfo('America/New_York')<>



### Time Zones - List

<cb>= zoneinfo.available_timezones()<>

Usage:

<cb>from zoneinfo import available_timezones

zones = available_timezones())<>


Returns all the available time zones.


Example:

<cb>from zoneinfo import available_timezones

zones = available_timezones())

for zone in sorted(zones):
    print(zone)<>
@
@ zoneinfo.available_timezones(), .available_timezones()
@ view, get, all, available.



# TimeDelta

<cb>from datetime import timedelta

= timedelta(<v>unit<> = <v>value<>)<>

<cb>= timedelta(<v>unit<> = <v>value<>, <v>unit<>=<v>value<> <v>...<>)<>

<cb>= timedelta(
		weeks=<v>weeks_value<>,
		days=<v>days_value<>,
		hours=<v>hours_value<>,
		minutes=<v>minutes_value<>,
		seconds=<v>seconds_value<>,
		microseconds=<v>microseconds_value<>,
		milliseconds=<v>milliseconds_value<>)<>

<cb><v>timedelta_3<> = <v>datetime_1<> - <v>datetime_2<><>


Stores a duration in time as days and seconds.


Examples:

<cb>from datetime import timedelta

<v>timedelta_1<> = timedelta(seconds=<v>10<>)
<v>timedelta_2<> = timedelta(days=<v>4<>, hours=<v>3<>, minutes=<v>2<>, seconds=<v>1<>)<>
@
@ datetime.timedelta, time deltas, timedelta-only, timedeltas-only, time-delta-only, time-deltas-only
@ create, define, instantiate, new, .timedelta(), data type, duration



# TimeDelta - Operations
@
@ datetime.timedelta, time deltas, timedelta-only, timedeltas-only, time-delta-only, time-deltas-only
@ .timedelta(), data type, duration



### TimeDelta - Get Microseconds

<cb>= <v>timedelta_1<>.microseconds<>


Returns: <c>int<>
@
@ timedelta.microseconds, .microseconds


### TimeDelta - Get Milliseconds

<cb>= <v>timedelta_1<>.microseconds // 1000<>

Returns: <c>int<>


There is no built in way to do this.
Divide .microseconds by 1000 instead.
@
@ timedelta.milliseconds, .mililseconds



### TimeDelta - Get Seconds

<cb>= <v>timedelta_1<>.seconds<>


Returns: <c>int<>


Returns the number of seconds for the portion less than a day.


Example:

<cb>from datetime import timedelta

<v>timedelta_1<> = timedelta(days = 2, hours = 1, seconds = 15)

<v>seconds<> = <v>timedelta_1<>.seconds

<#># Returns 3615 Seconds (1 hour * 3600 + 15 seconds)<><>
@
@ timedelta.seconds, .seconds



### TimeDelta - Get Days

<cb>= <v>timedelta_1<>.days<>


Returns: <c>int<>


Returns the number of days for the timedelta.


Example:

<cb>from datetime import timedelta

<v>timedelta_1<> = timedelta(days = 2, hours = 1, seconds = 15)

<v>days<> = <v>timedelta_1<>.days

<#># Returns 2<><>
@
@ timedelta.days, .days



### TimeDelta - Get Total Seconds

<cb>= <v>timedelta_1<>.total_seconds()<>


Returns: <c>float<>


Returns the timedelta in seconds.
Returns fraction of a second too.
@
@ timedelta.total_seconds(), total_seconds(), entire



### TimeDelta - Is Equal?

<cb>= <v>timedelta_1<> == <v>timedelta_2<><>



### TimeDelta - Compares?

Is Less Than:

<cb>= <v>timedelta_1<> < <v>timedelta_2<><>

Is Greater Than:

<cb>= <v>timedelta_1<> > <v>timedelta_2<><>
@
@ is less than, is greater than, \<, \<=, >, >=



### TimeDelta - Absolute Value

<cb>= abs(<v>timedelta_1<>)<>
@
@ abs()



### TimeDelta - Add

<cb>= <v>timedelta_1<> + <v>timedelta_2<><>

<cb><v>timedelta_1<> += <v>timedelta_2<><>


Returns: <c>timedelta<>


Adds 2 timedeltas together.


Example:

<cb>from datetime import timedelta

<v>timedelta_1<> = timedelta(minutes = 1)
<v>timedelta_2<> = timedelta(seconds = 15)

<v>added<> = <v>timedelta_1<> + <v>timedelta_2<>

<#># Returns 1 Minute 15 Seconds TimeDelta<><>
@
@ combine, +, +=



### TimeDelta - Subtract

<cb>= <v>timedelta_1<> - <v>timedelta_2<><>

<cb><v>timedelta_1<> -= <v>timedelta_2<><>


Returns: <c>timedelta<>


Subtracts a timedelta from another.


Example:

<cb>from datetime import timedelta

<v>timedelta_1<> = timedelta(minutes = 1)
<v>timedelta_2<> = timedelta(seconds = 15)

<v>subtracted<> = <v>timedelta_1<> - <v>timedelta_2<>

<#># Returns a 45 Second TimeDelta<><>
@
@ minus, -, -=



### TimeDelta - Divide By TimeDelta

<cb>= <v>timedelta_1<> / <v>timedelta_2<><>


Returns: <c>float<>


Divides a timedelta by another.


Example:

<cb>from datetime import timedelta

<v>timedelta_1<> = timedelta(minutes = 1)
<v>timedelta_2<> = timedelta(seconds = 15)

<v>subtracted<> = <v>timedelta_1<> / <v>timedelta_2<>

<#># Returns 4<><>
@
@ /



### TimeDelta - Divide By Int / Float

<cb>= <v>timedelta_1<> / <v>int_2<><>

<cb>= <v>timedelta_1<> / <v>float<><>


Returns: <c>timedelta<>


Divides a timedelta by an integer or float.


Example:

<cb>from datetime import timedelta

<v>timedelta_1<> = timedelta(minutes = 1)

<v>subtracted<> = <v>timedelta_1<> / 4

<#># Returns timedelta(seconds = 15)<><>
@
@ /



### TimeDelta - To String

<cb>= str(<v>timedelta_1<>)<>


Formatting with <c>.format()<> or f"" is not an option.
@
@ from, convert, from-timedelta, to-string



### TimeDelta - To String Using Function

Function:

<cb>def <v>format_timedelta<>(<v>timedelta_1<>):

	<v>remainder<> = <v>timedelta_1<>.seconds

	<v>hours<> = int(<v>remainder<> // 3600)
	<v>remainder<> = <v>remainder<> % 3600

	<v>minutes<> = int(<v>remainder<> // 60)
	<v>seconds<> = int(<v>remainder<> % 60)

	if <v>timedelta_1<>.days > 0:
		return f"{<v>timedelta_1<>.days} days {<v>hours<>}:{<v>minutes<>:02}:{<v>seconds<>:02}"

	return f"{<v>hours<>}:{<v>minutes<>:02}:{<v>seconds<>:02}"<>

Call:

<cb>= <v>format_timedelta<>(<v>timedelta_1<>)<>


Prints days, hours, minutes, seconds.



# Timestamp

<cb>= <v>seconds_since_epoch<><>

<cb>from time import time

= time()<>


Returns: <c>float<>


Returns the number of seconds in Unix Time or Epoch Time.
Measures from the Epoch, January 1, 1970, at 00:00:00 UTC.


Example:

<cb><#>Set to 2001-01-01 00:00:00:<>

<v>timestamp_1<> = <v>978325200.0<><>
@
@ epoch time, unix time
@ time-only, timestamp-only, timestamp., timestamp(), time.time(), .time()
@ times, times-only, timestamps, timestamps-only



# Timestamp - Operations
@
@ epoch time, unix time
@ time-only, timestamp-only, timestamp., timestamp(), time.time(), .time()
@ times, times-only, timestamps, timestamps-only



### Timestamp - From Datetime

<cb>= <v>datetime_1<>.timestamp()<>
@
@ convert, datetime.timestamp(), .timestamp()



### Timestamp - To Datetime

<cb>= datetime.fromtimestamp(<v>timestamp_1<>)<>

Usage:

<cb>from datetime import datetime

= datetime.fromtimestamp(<v>timestamp_1<>)<>
@
@ convert, datetime.fromtimestamp(), .fromtimestamp()



### Timestamp - To String

<cb>= strftime("<v>format<>", localtime(<v>timestamp_1<>))<>

Usage:

<cb>from time import strftime
from time import localtime

= strftime("<v>format<>", localtime(<v>timestamp_1<>))<>

or

<card>Convert to a <c>datetime<> and then format.<>


Example:

<cb>from time import strftime
from time import localtime

<v>timestamp_2001<> = <v>978325200<>
<v>formatted<> = = strftime("<v>%Y-%m-%d %H:%M:%S<>", localtime(<v>timestamp_2001<>))<>
@
@ convert, time.strftime(), .strftime(), time.localtime(), .localtime()



# Datetime vs Timestamp

DateTime:

<*>Stores Date and Time in a Class
Has Many Date Time Manipulation Methods<>

Timestamp:

<*>Stores Number of Seconds
Since January 1st, 1970
Returned as a Float<>



# Enum

<cb>from enum import Enum, auto

class <v>EnumName<>(Enum):
	<v>ENUM_1<> = auto()
	<v>ENUM_2<> = auto()
	<v>...<><>


<cb>from enum import Enum

class <v>EnumName<>(Enum):
	<v>ENUM_1<> = <v>value_1<>
	<v>ENUM_2<> = <v>value_2<>
	<v>...<><>

<c>auto()<> is required if the Enum items don't have a value.
@
@ Definition, auto, enum.auto(), .auto(), enum.Enum
@ enum-only, enums-only, data type



# Enum Operations
@
@ enum-only, enums-only



### Enum - Assign

<cb>= <v>EnumName<>.<v>ENUM_1<><>
@
@ create, instantiate, new



### Enum - Get Name

<cb>= <v>ENUM_1<>.name<>
@
@ to string, tostring, .name



### Enum - Get Value

<cb>= <v>ENUM_1<>.value<>


Returns the numeric value of the enum (usually the enum position).
@
@ .value, index



### Enum - Is Equal?

<cb>= <v>item_1<> is <v>EnumName<>.<v>ENUM_1<><>



### Enum - From String

Define:

<cb>from enum import Enum, auto

class <v>EnumName<>(Enum):
	<v>ENUM_1<> = auto()
	<v>ENUM_2<> = auto()
	<v>...<>

	@classmethod
	def from_string(cls, <v>value<>):          <#>#1<>
		return cls.<v>_lookup<>[<v>value<>]         <#>#2<>

<v>EnumName<>.<v>_lookup<> = {                      <#>#3<>
		<v>"Enum 1a"<>: <v>EnumName<>.<v>ENUM_1<>,
		<v>"Enum 1b"<>: <v>EnumName<>.<v>ENUM_1<>,
		<v>"Enum 2a"<>: <v>EnumName<>.<v>ENUM_2<>,
		<v>"Enum 2b"<>: <v>EnumName<>.<v>ENUM_2<>}
<>

Use:

<cb>= <v>EnumName<>.from_string(<v>"Enum 1a"<>)<>

There is no built in way to do this but the example above will do it.
Implement a static method inside the <c><v>EnumName<><> class that will convert strings into enums.


\#1  <s>-<>  The static method that converts strings to Enums.

\#2  <s>-<>  Raises <c>KeyError<> if not found.

\#3  <s>-<>  Define string to enum mappings here.
@
@ convert, conversion, to, text, parse
@ to-enum, from-string



# Dict

<cb><v>dict_1<> = {}<>

<cb><v>dict_2<> = {<v>'key_1'<>: <v>'value_1'<>, <v>'key_2'<>: <v>'value_2'...<>}<>

<cb><v>dict_3<> = dict([(<v>'key_1'<>, <v>'value_1'<>), (<v>'key_2'<>, <v>'value_2'<>), <v>...<>])<>

Type: <c>dict<>


A collection of key value pairs.
Keys can be any immutable type.
Internally stored as a hash table.
@
@ dicts, dict(), dict-only, dicts-only, dictionary-only, dictionaries
@ create, define, instantiate, new, {}, }, :, {:}, empty, data type



# Dict Operations
@
@ dicts, dict-only, dicts-only, dictionary-only, dictionaries
@ ops, dict()



### Dict - Add / Update

<cb><v>dict_1<>[<v>key<>] = <v>value<><>

Will replace <v>key<> value if key exists.
Will add <v>key<> if it does not exist.


Examples:

Add Value:

<cb><v>dict_1<> = {<v>1<>: "<v>a<>", <v>2<>: "<v>b<>"}

<v>dict_1<>[<v>3<>] = "<v>c<>"

<#># Updates To: {1: 'a', 2: 'b', 3: 'c'}<><>

Update Value:

<cb><v>dict_1<> = {<v>1<>: "<v>a<>", <v>2<>: "<v>b<>"}

<v>dict_1<>[<v>2<>] = "<v>x<>"

<#># Updates To: {1: 'a', 2: 'x'}<><>
@
@ dict[]
@ add, put, insert, update, modify, change, item, element, value, append to




### Dict - Add / Update From Dict

<cb><v>dict_1<>.update(<v>dict_2<>)<>


Adds or updates items from <c>dict_2<> into <c>dict_1<>.


Example:

<cb><v>dict_1<> = {<v>1<>: "<v>a<>", <v>2<>: "<v>b<>"}
<v>dict_2<> = {<v>2<>: "<v>b2<>", <v>3<>: "<v>c<>"}

<v>dict_1<>.update(<v>dict_2<>)

<#># Updates To: {1: 'a', 2: 'b2', 3: 'c'}<><>
@
@ dict.update(), .update()
@ extend, extends, join, concatenate, addall, append to



### Dict - Dict Comprehension

<cb>= {<v>key_expression<> : <v>value_expression<> for <v>item<> in <v>sequence_1<>}<>

Returns: <c>dict<>


Iterates over a sequence, performing an operation on every item.
Returns the result as <c>dict<>.


Example:

<cb><v>items<> = [1, 2, 3, 4, 5]

<v>dict_1<> = {<v>i<> : str(<v>i<>) for <v>i<> in <v>items<>}<>

@
@ dict for in if {} :, conditional, iterating



### Dict - Dict Comprehension - If Condition

<cb>= {<v>key_expression<> : <v>value_expression<> for <v>item<> in <v>sequence_1<> if <v>condition<>}<>

Returns: <c>dict<>


Iterates over a sequence, performing an operation on items that matth the if condition.
Returns the result as <c>dict<>.


Example:

<cb><v>items<> = [1, 2, 3, 4, 5]

<v>dict_1<> = {<v>i<> : str(<v>i<>) for <v>i<> in <v>items<> if <v>i<> % 2 == 0}<>
@
@ dict for in if {} :, conditional, iterating



### Dict - Contains Key?

Contains Key?:

<cb>= <v>key_1<> in <v>dict_1<>               <#># Preferred<><>

or

<cb>= <v>dict_1<>.has_key(<v>key_1<>)         <#># Alternative<><>
@
@ dict.has_key(), .has_key()
@ has, check, exists, in, includes



### Dict - Not Contains Key?

<cb><v>key_1<> not in <v>dict_1<><>
@
@ dict.has_key(), .has_key()
@ has, check, exists, in, includes, doesn't, doesnt



### Dict - Contains Value?

<cb>= <v>value_1<> in <v>dict_1<>.values()<>
@
@ has, check, exists, item, element, in, includes, .values()



### Dict - Not Contains Value?

<cb>= <v>value_1<> not in <v>dict_1<>.values()<>
@
@ has, check, exists, item, element, in, includes, .values(), doesn't, doesnt



### Dict - Delete

<cb>del <v>dict_1<>[<v>key_1<>]<>


Will raise an error if key is not present.
@
@ remove, element, item



### Dict - Delete All

<cb><v>dict_1<>.clear()<>
@
@ dict.clear(), .clear()
@ clear, del, empty, remove, reset, elements, items, values



### Dict - Duplicate

<cb>= <v>dict_1<>.copy()<>


Creates a shallow copy.
@
@ .copy(), shallow, clone



### Dict - Duplicate - Deep Copy

<cb>from copy import deepcopy

= deepcopy(<v>dict_1<>)<>


Creates a deep copy.
@
@ copy, .deepcopy(), copy.deepcopy(), clone



### Dict - Is Empty?

<cb>= not <v>dict_1<><>

<cb>if not <v>dict_1<>:
	<v>...<><>
@
@ not



### Dict - Not Empty?

<cb>= bool(<v>dict_1<>)<>

<cb>if <v>dict_1<>:
	<v>...<><>
@
@ bool()



### Dict - Get Keys

<cb>= <v>dict_1<>.keys()<>

As List:

<cb>= list(<v>dict_1<>.keys())<>
@
@ retrieve, all, .keys(), names



### Dict - Get Key Value Pairs

<cb>= <v>dict_1<>.items()<>
@
@ retrieve, all, pairs, items, elements, keys, .items(), names, values



### Dict - Get Key Value Pairs - Sorted By Key

<cb>= sorted(<v>dict_1<>.items(), <v>key<>=lambda item: item[0])<>

Returns list of key value tuples.
@
@ @ dict.items(), .items(), sorted()
@ sorted, pairs, ordered, items, elements, names, keys, values



### Dict - Get Key Value Pairs - Sorted By Value

<cb>= sorted(<v>dict_1<>.items(), <v>key<>=lambda item: item[1])<>

Returns list of key value tuples.
@
@ dict.items(), .items(), sorted()
@ sorted, pairs, ordered, items, elements, names, keys, values



### Dict - Get Value

<cb>= <v>dict_1<>[<v>key_1<>]                         <#>#1<><>

or

<cb>= <v>dict_1<>.get(<v>key_1<>)                     <#>#2<><>

or

<cb>= <v>dict_1<>.get(<v>key_1<>, <v>default_value<>)<>


\#1  <s>-<>  Preferred style.

\#1  <s>-<>  Raises <c>KeyError<> if not found.

\#2  <s>-<>  Returns <c>None<> if not found.


Returns the value of a dict.


Example:

<cb><v>dict_1<> = {"a": "value a", "b": "value b", "c": "value c"}

<v>value_a<> = <v>dict_1<>["a"]
<v>value_a<> = <v>dict_1<>.get("a")
<v>value_a<> = <v>dict_1<>.get("z", "value a")

print(<v>value_a<>)

<#># Print: value a<><>
@
@ dict.get(), .get()
@ retrieve, item, elements, keyerror



### Dict - Get Values

<cb>= <v>dict_1<>.values()<>


Returns: <c>dict_values<>


As List:

<cb>= list(<v>dict_1<>.values())<>
@
@ .values(), dict.values()
@ retrieve, items, elements,



### Dict - Get Values Sorted By Key

<cb>= [<v>dict_1<>[<v>key<>] for <v>key<> in sorted(<v>dict_1<>.keys())]<>
@
@ dict.values(), .values(), dict.keys(), dict.keys
@ retrieve, items, elements



### Dict - Iterate Over Keys

<cb>for <v>key<> in <v>dict_1<>:
	<v>...<><>
@
@ for, loop, foreach, each, in, iterating, names



### Dict - Iterate Over Key, Value Pairs

<cb>for <v>key<>, <v>value<> in <v>dict_1<>.items():
	<v>...<><>
@
@ dict.items(), .items()
@ for, loop, foreach, each, in
@ items, elements, iterating, names, values



### Dict - Iterate Over Values

<cb>for <v>value<> in <v>dict_1<>.values():
	<v>...<><>
@
@ for, loop, foreach, each, in
@ items, elements, .values(), iterating



### Dict - Intersection

<cb>= {<v>key<> : <v>dict_1<>[<v>key<>] for <v>key<> in <v>dict_1<> if <v>key<> in <v>dict_2<>}<>

Returns: <c>dict<>


Return a dict with only those items in common between <c><v>dict_1<><> and <c><v>dict_2<><>.
@
@ dictionaries, dicts, in, conjuction



### Dict - Is Dict?

<cb>= type(<v>item_1<>) is dict<>
@
@ type of, instance of



### Dict - Merge

<cb>= dict_1 | dict_2                       <#>#1<><>

or

<cb>= {**<v>dict_1<>, **<v>dict_2<>}<>

Returns: <c>dict<>


Return a new dict with all items of <c><v>dict_1<><> and <c><v>dict_2<><>.


\#1  <s>-<>  Python 3.9+
@
@ addall, add all, join, union, dictionaries, **, combine, |



### Dict - Pop Value

<cb>= <v>dict_1<>.pop(<v>key<>)<>

Removes and returns the value for <c><v>key<><>.
@
@ retrieve, all, dict.pop(), .pop()



### Dict - Size

<cb>= len(<v>dict_1<>)<>
@
@ Size, Length, Count, len()



### Dict - Sort Keys

<cb>= sorted(<v>dict_1<>.keys())<>

<cb>for <v>key<> in sorted(<v>dict_1<>.keys()):
	<v>...<><>

Returns: <c>list<>
@
@ ordered by, sorted(), .keys(), dict.keys(), names



### Dict - Sort Values

<cb>= sorted(<v>dict_1<>.values())<>

<cb>for <v>key<> in sorted(<v>dict_1<>.values()):
	<v>...<><>

Returns: <c>list<>
@
@ ordered by, .sorted()
@ elements, items



### Dict - Subtraction

<cb>= {<v>key<>: <v>dict_1<>[<v>key<>] for <v>key<> in <v>dict_1<> if <v>key<> not in <v>dict_2<>}<>

Returns: <c>dict<>


Returns a new dict containing only those items in <c><v>dict_1<><> but not in <c><v>dict_2<><>.
@
@ Delete, Remove Matching, Difference, dictionaries, dicts, minus, not in
@ exclude, exclusion



### Dict - To List

<cb>= list(<v>dict_1<>.values())<>
@
@ from, convert, list(), .values()
@ from-dict, to-list



# List

<cb>= []
= [<v>value_1<>, <v>value_2<>, <v>...<>]<>

Type: list


An ordered list.
Implemented as a fixed-length array of pointers.


Example:

<cb><v>list_1<> = [<v>0<>, <v>1<>, <v>2<>, <v>3<>, <v>4<>]<>

<cb><v>list_2<> = [<v>1<>, <v>"1"<>, <v>"one"<>]<>
@
@ list-only, lists, lists-only
@ create, define, instantiate, new, [], ], empty, data type



### List - Nested Lists

<cb>= [[<v>0<>, <v>1<>, <v>2<>], [<v>10<>, <v>11<>, <v>12<>], <v>...<>]<>

<cb>= [<v>sublist_1<>, <v>sublist_2<>, <v>...<>]<>


Examples:

2D List:

<cb><v>list_1<> = [
		[1, 2, 3, 4],
		[5, 6, 7, 8]]

<v>value<> = <v>list_1<>[1][3]

<#># Returns 8<><>

3D List:

<cb><v>list_1<> = [
		[[1, 2, 3],
		 [4, 5, 6]],
		[[11, 12, 13],
		 [14, 15, 16]]]

<v>value<> = <v>list_1<>[0][1][2]

<#># Returns 6<><>
@
@ 2d, sublists, nesting, of lists, 3d



### List - Create With Initial Value

<cb>= [<v>value<>] * <v>size<><>


Example:

<cb><v>five_ones<> = [1] * 5

<#># Returns [1, 1, 1, 1, 1]<><>
@
@ repeating



# List Operations
@
@ list-only, lists, lists-only, [[]]



### List - Append

<cb><v>list_1<>.append(<v>value<>)<>


Appends a value to the end of a list.


Example:

<cb><v>list_1<> = [<v>1<>, <v>2<>]

<v>list_1<>.append(<v>3<>)

<#># Sets list_1 to [1, 2, 3]<><>
@
@ put, add, item, value, append to, .append()



### List - Append List

<cb><v>list_1<>.extend(<v>list_2<>)<>


Appends a list of items to the end of another list.


Example:

<cb><v>list_1<> = [<v>1<>, <v>2<>]
<v>list_2<> = [<v>3<>, <v>4<>]

<v>list_1<>.extend(<v>list_2<>)

<#># Sets list_1 to [1, 2, 3, 4]<><>
@
@ put, add, addall, concatenate, extend(), combine, append to, .extend()
@ 2nd, second, list2, list_2



### List - Apply Function

<cb>= list(map(<v>function_1<>, <v>list_1<>))<>

Returns: <c>list<>


Applies the function to each value in <v>list_1<> returning the results in a new list.


Example:

<cb>def <v>add_10<>(<v>value<>):
	return <v>value + 10<>

<v>list_1<> = [<v>1<>, <v>2<>, <v>3<>]

<v>applied_list<> = list(map(<v>add_10<>, <v>list_1<>))

<#># Returns: [11, 12, 13]<><>
@
@ map(), list()
@ to elements, items, values



### List - List Comprehension

<cb>= [<v>expression<> for <v>value<> in <v>list_1<>]<>

Returns: <c>list<>


Iterates over a list or sequence, performing an operation on every item.


Example:

<cb><v>list_1<> = [1, 2, 3, 4, 5]

<v>list_2<> = [ <v>i<> * 2 for <v>i<> in <v>list_1<>]               <#># Returns [2, 4, 6, 8, 10]<><>

@
@ for in [], iterate, iterating, sequences



### List - List Comprehension - If Condition

<cb>= [<v>expression<> for <v>value<> in <v>list_1<> if <v>condition<>]<>

Returns: <c>list<>


Iterates over a list or sequence, performing an operation on those items that match the if condition.


Example:

<cb><v>list_1<> = [1, 2, 3, 4, 5]

<v>list_2<> = [ <v>i<> * 2 for <v>i<> in <v>list_1<> if <v>i<> \<= 3]      <#># Returns [2, 4, 6]<><>
@
@ for in if [], conditional, iterate, iterating, sequences, find, with



### List - List Comprehension, Nested

<cb>= [[<v>expression<> for <v>value<> in <v>sublist<>] for <v>sublist<> in <v>list_1<>]<>

Returns: <c>list[list]<>


Iterates over a list of lists or sequece of sequences, performing operations on every value in each sublist.

Returns a list of lists.


Example:

<cb><v>list_1<> = [[<v>1<>, <v>2<>], [<v>3<>, <v>4<>]]

<v>plus_10<> = [[<v>value<> + 10 for <v>value<> in <v>sublist<>] for <v>sublist<> in <v>list_1<>]

<#># Returns: [[11, 12], [13, 14]]<><>
@
@ for in if [], conditional, iterate, iterating, sequences



### List - List Comprehension, Nested, Flatten

<cb>= [<v>expression<> for <v>sublist<> in <v>list_1<> for <v>value<> in <v>sublist<>]<>

Returns: <c>list<>


Iterates over a list of lists or sequece of sequences, as if it were a flat list.

Returns a flat list.


Example:

<cb><v>list_1<> = [[<v>1<>, <v>2<>], [<v>3<>, <v>4<>]]

<v>plus_10<> = [<v>value<> + 10 for <v>sublist<> in <v>list_1<> for <v>value<> in <v>sublist<>]

<#># Returns: [11, 12, 13, 14]<><>
@
@ for in if [], conditional, iterate, iterating, sequences



### List - Contains?

<cb>= <v>value<> in <v>list_1<><>

<cb>if <v>value<> in <v>list_1<>:
	<v>...<><>
@
@ has, check, exists, item, element, includes, in



### List - Contains Any From Second List?

<cb>= any(<v>value<> in <v>list_1<> for <v>value<> in <v>compare_list<>)<>

Returns: <c>bool<>


Returns <c>True<> if any item from <c><v>compare_list<> is in <c><v>list_1<><>.


Example:

<cb><v>list_1<> = [<v>1<>, <v>2<>, <v>3<>]
<v>compare_list<> = [<v>3<>, <v>5<>]

<v>match<> = any(<v>value<> in <v>list_1<> for <v>value<> in <v>compare_list<>)

<#># Returns: True<><>
@
@ has, check, exists, item, element, includes, in, matches, 2nd, other
@ list_2, list2, second



### List - Not Contains?

<cb>= <v>value<> not in <v>list_1<><>

<cb>if <v>value<> not in <v>list_1<>:
	<v>...<><>
@
@ has, check, exists, item, element, includes, in, doesnt, doesn't



### List - Count Occurrences

<cb>= <v>list_1<>.count(<v>value<>)<>


Returns the number of times <c><v>value<><> appears in <c><v>list_1<><>.
@
@ item, occurrences, .count(), times



### List - Count By Distinct Value

<cb>from collections import Counter

= Counter(<v>list_1<>)<>


Returns: <c>dict<>


Returns a dictionary with every unique value and the number of times of that value is present.
@
@ items, values, unique, individual, occurrences, .counter(), collections.counter()



### List - Count Distinct Values

<cb>= len(set(<v>list_1<>))<>


Returns the number of unique values in <c><v>list_1<><>.
@
@ items, unique, individual, occurrences, times, len(), .counter(), collections.counter()



### List - Delete

<cb><v>del<> <v>list_1<>[<v>index<>]<>
@
@ remove from, one, single, del, item, value



### List - Delete All

<cb><v>del<> <v>list_1<>[:]<>
@
@ clear, del, empty, remove, reset, elements, items, values



### List - Delete First

<cb><v>del<> <v>list_1<>[0]<>
@
@ remove from start, del, item, value, 1st



### List - Delete Last

<cb><v>del<> <v>list_1<>[-1]<>
@
@ remove from end, del, item, value



### List - Delete In Range

<cb>del <v>list_1<>[<v>start<> : <v>end_plus_1<>]<>

Example:

<cb><v>list_1<> = [1, 2, 3, 4, 5, 6, 7, 8, 9]

del <v>list_1<>[<v>2<>:<v>7<>]                           <#># Returns [1, 2, 8, 9]<><>
@
@ remove, clear, del



### List - Delete Matching Value

<cb><v>list_1<>.remove(<v>value<>)<>


Deletes the first item on the list that matches <v>value<>.

Throws <c>ValueError<> if not found.


Example:

<cb><v>list_1<> = ['<v>one<>', '<v>two<>', '<v>three<>']

<v>list_1<>.remove('<v>two<>')

print(<v>list_1<>)

<#># Prints: ['one', 'three']<><>
@
@ .remove(), remove
@ remove from, element, item



### List - Duplicate

<cb>= <v>list_1<>.copy()<>


Creates a shallow copy.
@
@ .copy(), shallow, clone, deepcopy()



### List - Duplicate - Deep Copy

<cb>from copy import deepcopy

= deepcopy(<v>list_1<>)<>


Creates a deep copy.
@
@ copy, .deepcopy(), copy.deepcopy(), clone



### List - Is Empty?

<cb>= not <v>list_1<><>

<cb>if not <v>list_1<>:
	<v>...<><>



### List - Not Empty?

<cb>= bool(<v>list_1<>)<>

<cb>if <v>list_1<>:
	<v>...<><>

Use <b>bool()<> if you need to get a True/False value.
There is no need for <b>bool()<> when using <b>if...<>.
@
@ bool()



### List - Is Equal?

<cb>= <v>list_1<> == <v>list_2<><>

<cb>if <v>list_1<> == <v>list_2<>:
	<v>...<><>


Returns True if both lists are of same size and contain the same values.


Example:

<cb><v>list_1<> = [<v>1, 2, 3<>]
<v>list_2<> = [<v>1, 2, 3<>]
<v>list_3<> = [<v>3, 2, 1<>]

<v>is_identical<> = <v>list_1<> == <v>list_2<>

<#># Returns True<>

<v>is_identical<> = <v>list_1<> == <v>list_3<>

<#># Returns False<><>
@
@ list_2, list2, second list, 2nd
@ equals, identical, ==



### List - Is List?

<cb>= type(<v>item_1<>) is list<>
@
@ type of, instance of



### List - Is Sublist?

Use Function:

<cb>def is_sublist(<v>list_1<>, <v>list_2<>):

	list_1_len = len(<v>list_1<>)

	for i in range(len(<v>list_2<>) - list_1_len + 1):
		if <v>list_1<> == <v>list_2<>[i : i + list_1_len]:
			return True

	return False<>

Call:

<cb>= is_sublist(<v>list_1<>, <v>list_2<>)<>


Returns True if <c><v>list_1<><> is a sublist of <c><v>list_2<><>.

Create the function <c>is_sublist()<> above to test if a list is a sublist of another list.


Example:

<cb><v>list_1<> = [<v>3, 4<>]
<v>list_2<> = [<v>1, 2, 3, 4, 5<>]

is_it_a_sublist = is_sublist(<v>list_1<>, <v>list_2<>)

<#># Returns True<><>
@
@ contains, is_sublist()
@ list_2, list2



### List - Exclude

<cb>= [ <v>item<> for <v>item<> in <v>list_1<> if <v>item<> not in <v>exclude_list<> ]<>


Removes all the items in the exclude list from <c><v>list_1<><>.

Preserves the order of the items in <c><v>list_1<><>.


Example:

<cb><v>list_1<> = [1, 2, 3, 4, 5]
<v>exclude<> = [2, 3]

<v>remaining<> = [ <v>item<> for <v>item<> in <v>list_1<> if <v>item<> not in <v>exclude<> ]

print(<v>remaining<>)

<#># Prints: [1, 4, 5]<><>
@
@ Delete, Remove Matching, minus, 
@ exclude, exclusion, subtraction



### List - Extract To Sublist

<cb>= <v>list_1<>[<v>start<> : <v>end_plus_1<>]<>

<cb>= <v>list_1<>[<v>start<>:]                        <#># From <c><v>start<><> to the end.<><>

<cb>= <v>list_1<>[:<v>end_plus_1<>]                   <#># From the start to before <c><v>end_plus_1<><>.<><>


See Also: <l "?q=slicing-only">Slicing Sequences<>


Examples:

<cb><v>list_1<> = [1, 2, 3, 4, 5, 6, 7, 8, 9]

= <v>list_1<>[0:5]                         <#># [1, 2, 3, 4, 5]<>
= <v>list_1<>[5:]                          <#># [6, 7, 8, 9]<>
= <v>list_1<>[0::8]                        <#># [1, 9] First, last items.<><>
@
@ Split, Slice, [:], ::, [::]



### List - Find Duplicates

<cb>= [item for item, count in Counter(<v>list_1<>).items() if count > 1]<>

Usage:

<cb>from collections import Counter

<v>duplicates<> = [item for item, count in Counter(<v>list_1<>).items() if count > 1]<>


Example:

<cb>from collections import Counter

<v>items<> = ['<v>a<>', '<v>b<>', '<v>b<>', '<v>c<>', '<v>d<>', '<v>d<>']

<v>duplicates<> = [item for item, count in Counter(<v>items<>).items() if count > 1]

print(<v>duplicates<>)

<#># Prints: ['b', 'd']<><>
@
@ collection.Counter(), Counter()



### List - Find Index

<cb>= <v>list_1<>.index(<v>value<>)<>

<cb>= <v>list_1<>.index(<v>value<>, <v>start<>)<>

<cb>= <v>list_1<>.index(<v>value<>, <v>start<>, <v>end<>)<>

Returns the index of the first match.

Throws <c><l "?q=valueerror-only">ValueError<><> if not found.
@
@ search, index, get, location, position, .index()



### List - Flatten

Define:

<cb>def flatten(<v>value<>):

	if type(<v>value<>) is not list:
		yield <v>value<>
		return

	for <v>subvalue<> in <v>value<>:
		yield from flatten(<v>subvalue<>)<>

Use:

<cb>= list(flatten(<v>list_1<>))<>


Will unwrap any combination of lists in lists into a flat list of values.
Python has no built in way to do this but the <c>flatten<> function above will do it.


Example:

<cb>def flatten(<v>value<>):

	if type(<v>value<>) is not list:
		yield <v>value<>
		return

	for <v>subvalue<> in <v>value<>:
		yield from flatten(<v>subvalue<>)


<v>list_1<> = [1, 2, [[3, 4, [5, 6]], 7], [8, 9]]

<v>flattened<> = list(flatten(<v>list_1<>))

<#># Returns: [1, 2, 3, 4, 5, 6, 7, 8, 9]<><>
@
@ flat list, flatten()



### List - Get

<cb>= <v>list_1<>[<v>index<>]<>
@
@ item, value



### List - Get First

<cb>= <v>list_1<>[0]<>
@
@ item, value, [0], 1st



### List - Get Last

<cb>= <v>list_1<>[-1]<>
@
@ item, value, [-1], end



### List - Get Sublist

<cb>= <v>list_1<>[<v>index<>][<v>sub_index<>]<>
@
@ item, value, 2d, sublists



### List - Get Sublist - All Except First

<cb>= <v>list_1<>[1:]<>

Return everything but the first item.


Example:

<cb><v>list_1<> = [<v>0<>, <v>1<>, <v>2<>, <v>3<>, <v>4<>]

<v>value<> = <v>list_1<>[1:]

<#># Returns [1, 2, 3, 4]<><>
@
@ tail, items, values, [1:]
@ second, 2nd, to end, to last, remainder, 1st



### List - Get Values Contained In Second List

<cb>= [<v>value<> for <v>value<> in <v>list_1<> if <v>value<> in <v>list_2<>]<>


Returns a subset of list 1 where each value exists in list 2.

Use a list comprehension with if to filter list 1 based on list 2.
Maintains the original order.
@
@ if exists, 2nd, second, contains, other, filter
@ list2, list_2



### List - Insert

<cb><v>list_1<>.insert(<v>index<>, <v>value<>)<>

Inserts at position <c><v>index<><>.


Example:

<cb><v>list_1<> = [<v>1<>, <v>2<>, <v>3<>]
<v>list_1<>.insert(1, 10)

<#># Sets: [1, 10, 2, 3]<><>
@
@ put, set, add
@ item, value, element
@ .insert()



### List - Insert First

<cb><v>list_1<>.insert(0, <v>value<>)<>

Adds to the start of the list.


Example:

<cb><v>list_1<> = [<v>1<>, <v>2<>, <v>3<>]
<v>list_1<>.insert(0, 10)

<#># Sets: [10, 1, 2, 3]<><>
@
@ put, set, add, prepend, 1st, first
@ item, value, element
@ .insert()



### List - Iterate

<cb>for <v>value<> in <v>list_1<>:
	<v>...<><>
@
@ for in, loop, items, elements, values, foreach, for each, iterating



### List - Merge

<cb>= <v>list_1<> + <v>list_2<><>
@
@ lists, join, concatenate, combine, union
@ list_2, list2



### List - Pop First

<cb>= <v>list_1<>.pop(0)<>

Removes the first item from the list and returns it.
@
@ .pop(), left, remove, delete, 1st


### List - Pop Last

<cb>= <v>list_1<>.pop()<>

Removes the last item from the list and returns it.
@
@ .pop(), right, end, remove, delete



### List - Repeat

<cb>= <v>list_1<> * <v>count<><>

Returns <v>list_1<> repeated <v>count<> times.


Example:

<cb><v>repeated<> = [1, 2, 3] * 2

<#># Returns [1, 2, 3, 1, 2, 3]<><>
@
@ *, Multiply, Multiple, expand, .repeat()



### List - Reverse

<cb>= <v>list_1<>[::-1]<>

Reverse in Place:

<cb><v>list_1<>.reverse()<>


Reverses a list.


Examples:

<cb><v>list_1<> = [<v>1<>, <v>2<>, <v>3<>]

<v>reversed<> = <v>list_1<>[::-1]

<#># Returns: [3, 2, 1]<><>

Reverse in Place:

<cb><v>list_1<> = [<v>1<>, <v>2<>, <v>3<>]

<v>list_1<>.reverse()

<#># Sets To: [3, 2, 1]<><>
@
@ .reverse()



### List - Size

<cb>= len(<v>list_1<>)<>
@
@ count, length, len()



### List - Sort

<cb>= sorted(<v>list_1<>)<>

<cb>= sorted(<v>list_1<>, key = str.lower)     <#># Ignores case.<><>

<cb>= sorted(<v>list_1<>, key = 
	lambda <v>x<>: (<v>x<>.<v>field_1<>, <v>x<>.<v>field_2<>)) <#># Multiple fields.<><>

<cb>= sorted(<v>list_1<>, key = <v>compare<>)       <#># <c>compare<> takes 1 argument.<><>

Returns a new list in sorted order.

<c><v>compare<><> is a function that takes a list element as an argument, and returns it's comparable value.
@
@ ignore case, sorted()



### List - Sort Reversed

<cb>= sorted(<v>list_1<>, reverse = True)<>

Returns: <c>list<>

Sorts the list elements in reverse order.
@
@ sorted(), descending



### List - Sort In Place

<cb><v>list_1<>.sort()<>

<cb><v>list_1<>.sort(key = str.lower)          <#># Ignores case.<><>

<cb><v>list_1<>.sort(key = <v>compare<>)              <#># <c>compare<> takes 1 argument.<><>


Sorts the list in place.

<c><v>compare<><> is a function that takes a list element as an argument, and returns it's comparable value.
@
@ ignore case, .sort(), sorted



### List - Unpack

<cb><v>item_1<>, <v>item_2<>, <v>...<> = <v>list_1<><>

Unpacks the values in <c><v>list_1<><> into separate variables.
The number of variables on the left must match the number of values in the list on the right.

Example:

<cb><v>tuple_1<> = (<v>1<>, <v>2<>, <v>3<>)

<v>int_1<>, <v>int_2<>, <v>int_3<> = <v>tuple_1<><>
@
@ Destructure, Destructuring Assignment



### List - Update

<cb><v>list_1<>[<v>index<>] = <v>updated_value<><>
@
@ change, modify, set, item, value



### List - From Dict

<cb>=list(<v>dict_1<>.values())<>

Returns the values of <c><v>dict_1<><> as a list.
@
@ convert, conversion, to
@ dict, dictionary, list(), .values()
@ from-dict, to-list



### List - To Dict

<cb>= {value:value for value in <v>list_1<>}<>

Returns: <c>dict<>


Use a dict comprehension
Returns a dict where every value is also the key to that value.
@
@ convert, conversion, from
@ dict, dictionary, {}
@ from-list, to-dict


### List - To Dict - Enumerated

<cb>= dict(enumerate(<v>list_1<>))<>

Returns: <c>dict<>


Returns a dict where the value's list position maps to the value.
@ convert, conversion, from
@ dict, dictionary, indexed, by position, enumerate(), dict()
@ from-list, to-dict



### List - To Dict - From 2 Lists

<cb>= dict(zip(<v>key_list<>, <v>value_list<>)<>

Returns: <c>dict<>
@
@ convert, conversion, from
@ dict, dictionary, two, dict(), zip()
@ from-lists, to-dict



### List - From Set

<cb>= list(<v>set_1<>)<>
@
@ convert, conversion, to, list()
@ to-list, from-set



### List - To Set

<cb>= set(<v>list_1<>)<>

Returns a set with all duplicates removed.
@
@ convert, conversion, from, set(), duplicates, deduplicate, unique
@ from-list, to-set, remove duplicates



### List - From Tuple

<cb>= list(<v>tuple_1<>)<>
@
@ convert, conversion, to, list()
@ to-list, from-tuple



### List - To Tuple

<cb>= tuple(<v>list_1<>)<>
@
@ convert, conversion, from, tuple()
@ from-list, to-tuple



### List - To Any Type

<cb>= list(map(<v>conversion<>, <v>list_1<>))<>


Converts elements in <c><v>list_1<><> to a different type.


Examples:

Convert Strings to Integers:

<cb><v>list_1<> = ['<v>1<>', '<v>2<>', '<v>3<>']
<v>list_as_ints<> = list(map(<v>int<>, <v>list_1<>))<>
@
@ map, convert, conversion, from, from-list, to-any



# Set

<cb>= {<v>value_1<>, <v>value_2<>, <v>...<>}

= set()                                 <#>#1<>

= set((<v>value_1<>, <v>value_2<>, <v>...<>))            <#>#2<><>

Unordered group of unique items.
Contains no duplicates.


\#1  <s>-<>  Empty Set

\#2  <s>-<>  Pass in items as a tuple.
@
@ set-only, sets-only
@ create, define, instantiate, new, {}, }, empty, set(), data type



# Set Operations
@
@ set-only, sets-only
@ ops



### Set - Add

<cb><v>set_1<>.add(<v>value<>)<>
@
@ Insert, put, update, modify, change, element, item, value, into
@ .add()



### Set - Add From Set

<cb><v>set_1<>.update(<v>set_2<>)<>

Inserts the elements from set 1 into set 2.
@
@ Insert, put, update, modify, change, append, elements, items, values, into
@ .update()



### Set - Contains?

Contains:

<cb>= <v>item_1<> in <v>set_1<><>

Does Not Contain:

<cb>= <v>item_1<> not in <v>set_1<><>
@
@ Has, Check, Exists, Item, Element, in, includes, not in



### Set - Duplicate

<cb>= <v>set_1<>.copy()<>


Creates a shallow copy of <c><v>set_1<><>.
@
@ Copy, Shallow, copy(), clone



### Set - Duplicate - Deep Copy

<cb>from copy import deepcopy

= deepcopy(<v>set_1<>)<>


Creates a deep copy of <c><v>set_1<><>.
@
@ copy, deepcopy(), copy.deepcopy(), clone



### Set - Get

<cb>= next(iter(<v>set_1<>))<>


Returns an item from the set.
Repeating this call will return the same item!
@
@ item, value, next(), iter()



### Set - Get, Pop

<cb>= <v>set_1<>.pop()<>

Removes and returns an item from the set.
@
@ item, value,
@ set.pop(), .pop()



### Set - Is Empty?

<cb>= not <v>set_1<><>

<cb>if not <v>set_1<>:
	<v>...<><>



### Set - Not Empty?

<cb>= bool(<v>set_1<>)<>

<cb>if <v>set_1<>:
	<v>...<><>

Use <b>bool()<> if you need to get a True/False value.
There is no need for <b>bool()<> when using <b>if...<>.
@
@ bool()



### Set - Is Equal?

<cb>= <v>set_1<> == <v>set_2<><>

<cb>if <v>set_1<> == <v>set_2<>:
	<v>...<><>


Returns True if both sets are of same size and contain the same values.


Example:

<cb><v>set_1<> = {<v>1, 2, 3<>}
<v>set_2<> = {<v>1, 2, 3<>}
<v>set_3<> = {<v>1, 2, 4<>}

<v>is_identical<> = <v>set_1<> == <v>set_2<>

<#># Returns True<>

<v>is_identical<> = <v>set_1<> == <v>set_3<>

<#># Returns False<><>
@
@ set_2, set2, second set, 2nd
@ equals, compare, identical, ==



### Set - Is Set?

<cb>= type(<v>item_1<>) is set<>
@
@ type of, instance of



### Set - Remove

<cb><v>set_1<>.remove(<v>value<>)<>

or

<cb><v>set_1<>.discard(<v>value<>)<>


Removes an item from the set.


remove() throws an error if <c><v>value<><> does not exists.
discard() ignores non-existent values.
@
@ Delete, update, modify, change, .remove(). discard()



### Set - Remove All

<cb><v>set_1<>.clear()<>
@
@ Delete, Clear, .clear()
@ clear, del, empty, remove, reset, elements, items, values



### Set - Set Comprehension

<cb>= {<v>expression<> for <v>item<> in <v>sequence_1<>}<>

Returns: <c>set<>


Iterates over a sequence, performing an operation on every item.
Returns the result as <c>set<>.


Example:

<cb><v>items<> = [1, 2, 3, 4, 5]

<v>set_<> = {str(<v>i<>) for <v>i<> in <v>items<>}<>

@
@ set for in if {}, conditional, iterating



### Set - Set Comprehension - If Condition

<cb>= {<v>expression<> for <v>item<> in <v>sequence_1<> if <v>condition<>}<>

Returns: <c>set<>


Iterates over a sequence, performing an operation on items that matth the if condition.
Returns the result as <c>set<>.


Example:

<cb><v>items<> = [1, 2, 3, 4, 5]

<v>set_1<> = {str(<v>i<>) for <v>i<> in <v>items<> if <v>i<> % 2 == 0}<>
@
@ set for in if {}, conditional, iterating



### Set - Size

<cb>= len(<v>set_1<>)<>


Returns the number of elements in the set.
@
@ count, length, len()



### Set - Sort

<cb>= sorted(<v>set_1<>)<>
@
@ sorted()



# Set on Set Operations
@
@ set-only, sets-only, set-operations-only
@ ops



### Set - Is Disjoint?

<cb>= <v>set_1<>.isdisjoint(<v>set_2<>)<>

Returns true if <c><v>set_1<><> and <c><v>set_2<><> have no elements in common.
@
@ .isdisjoint(), .is_disjoint()



### Set - Is Subset?

<cb>= <v>set_2<>.issubset(<v>set_1<>)<>

Returns true if <c><v>set_2<><> is a subset of <c><v>set_1<><>.


Example:

<cb><v>set_1<> = {"one", "two", "three"}
<v>set_2<> = {"one", "two"}

if <v>set_2<>.issubset(<v>set_1<>):
	print ("Is a subset.")
else:
	print ("Not a subset.")

<#># prints: Is a subset.<><>
@
@ .issubset(), .is_subset()



### Set - Is Superset?

<cb>= <v>set_2<>.issuperset(<v>set_1<>)<>

Returns true if <c><v>set_2<><> is a superset of <c><v>set_1<><>.


Example:

<cb><v>set_1<> = {"one", "two"}
<v>set_2<> = {"one", "two", "three"}

if <v>set_2<>.issuperset(<v>set_1<>):
	print ("Is a superset.")
else:
	print ("Not a superset.")

<#># prints: Is a superset.<><>
@
@ .issuperset(), .is_superset()



### Set - Difference

<cb>= <v>set_1<> - <v>set_2<><>

or

<cb>= <v>set_1<>.difference(<v>set_2<>)<>

Returns a set of the elements in <c><v>set_1<><> not in <c><v>set_2<><>.
@
@ .difference(), Difference
@ Delete, Remove Matching, dictionaries -, minus, subtract
@ exclude, exclusion



### Set - Intersection

<cb>= <v>set_1<> & <v>set_2<><>

or

<cb>= <v>set_1<>.intersection(<v>set_2<>)<>

Returns a set containing only those values in both <c><v>set_1<><> and <c><v>set_2<><>.
@
@ conjunction, intersects
@ set.intersection(), .intersection(), &



### Set - Symmetric Difference

<cb>= <v>set_1<>.symmetric_difference(<v>set_2<>)<>

<cb>= <v>set_1<>.symmetric_difference(<v>set_2<>, <v>set_3<>, <v>...<>)<>

Returns a set of the elements in <c><v>set_1<><> not in <c><v>set_2<><> and the elements in <c><v>set_2<><> not in <c><v>set_1<><>.
@
@ Delete, Remove Matching, Difference, dictionaries -, minus, .difference()



### Set - Union

<cb>= <v>set_1<> | <v>set_2<><>

or

<cb>= <v>set_1<>.union(<v>set_2<>)<>

Returns a set with all the values of <c><v>set_1<><> and <c><v>set_2<><>.
Will have no duplicates.
@
@ addall, add all, join, union, merge, combine, |, .union()



# Tuple

<cb>= ()        <#># Empty Tuple<>

= (<v>value_1<>, <v>value_2<>, <v>...<>)<>


Type: <c>tuple<>


Tuples are immutable arrays.
@
@ tuple-only, tuples-only, tuples, tupple
@ Create, Define, Instantiate, New, (), data type



# Tuple Operations
@
@ tuple-only, tuples-only, tuples, tupple
@ Ops



### Tuple - Contains?

<cb>= <v>value<> in <v>tuple_1<><>
@
@ in, Check, Item, Element, includes



### Tuple - Empty?

<cb>= not <v>tuple_1<><>

<cb>if not <v>tuple_1<>:
	<v>...<><>
@
@ not



### Tuple - Get

<cb>= <v>tuple_1<>[<v>index<>]<>



### Tuple - Get First

<cb>= <v>tuple_1<>[0]<>
@
@ [0], 1st



### Tuple - Get Last

<cb>= <v>tuple_1<>[-1]<>
@
@ [-1], end, value, item



### Tuple - Is Equal?

<cb>= <v>tuple_1<> == <v>tuple_2<><>


<cb>if <v>tuple_1<> == <v>tuple_2<>:
	<v>...<><>


Use <c>==<> to test if tuples are the same.

Python does a value by value comparison.


Example:

<cb><v>tuple_1<> = (1, 2)
<v>tuple_2<> = (2, 3)

print ("Equal?", <v>tuple_1<> == <v>tuple_2<>)

<#># Prints: Equal? False<><>
@
@ equals, second, 2nd, ==, identity, two



### Tuple - Subset

<cb>= <v>tuple_1<>[<v>start<>:<v>end_plus_1<>]<>


See Also: <l "?q=slicing-only">Slicing Sequences<>


Example:

<cb><v>tuple_1<> = (1, 2, 3, 4, 5)

<v>tuple_subset<> = <v>tuple_1<>[1:3]             <#># Returns (2, 3).<><>
@
@ Split, Slice



### Tuple - Unpack

<cb><v>item_1<>, <v>item_2<>, <v>...<> = <v>tuple_1<><>

Unpacks the values in <c><v>tuple_1<><> into separate variables.
The number of variables on the left must match the number of values in the tuple on the right.


Example:

<cb><v>tuple_1<> = (<v>1<>, <v>2<>, <v>3<>)

<v>int_1<>, <v>int_2<>, <v>int_3<> = <v>tuple_1<><>
@
@ destructure, destructuring assignment



# Sequences

Sequence operations can be performed on any sequence type including lists, and tuples.
@
@ sequence-only, sequences-only, seq-only
@ list, tuple



## Index and Slicing Operations
@
@ indexing, Slice, subsequence, Subscripts
@ slice-only, slicing-only, sequence-slicing-only



### Index and Slicing - Basics

Syntax:

<cb><table><col><v>first<><><col>= <v>sequence_1<>[0]<>
<col><v>nth<><><col>= <v>sequence_1<>[<v>n<>]<><col><#># Indexes are 0 based<><>
<col><v>second_last<><><col>= <v>sequence_1<>[-2]<><col> <>
<col><v>last<><><col>= <v>sequence_1<>[-1]<>
<col> <>
<col><v>all<><><col>= <v>sequence_1<>[:]<><col><#># Don't Use (Not Intuitive)<><>
<col><v>all_but_first<><><col>= <v>sequence_1<>[1:]<>
<col><v>all_but_last<><><col>= <v>sequence_1<>[:-1]<>
<col><v>reversed<><><col>= <v>sequence_1<>[::-1]<>
<col> <>
<col><v>from<><><col>= <v>sequence_1<>[<v>start<>:]<>
<col><v>from_to<><><col>= <v>sequence_1<>[<v>start<>:<v>end_plus_1<>]<>
<col><v>from_to_with_step<><><col>= <v>sequence_1<>[<v>start<>:<v>end_plus_1<>:<v>step<>]<>
<col><v>from_with_step<><><col>= <v>sequence_1<>[<v>start<>::<v>step<>]<>
<col><v>to<><><col>= <v>sequence_1<>[:<v>end_plus_1<>]<>
<col><v>step_over<><><col>= <v>sequence_1<>[::<v>step<>]<>
<col> <>
<col><v>m_to_nth<><><col>= <v>sequence_1<>[<v>m<> : <v>n<> + 1]<><><>


Examples:

<cb><v>list_1<> = [<v>0<>, <v>1<>, <v>2<>, <v>3<>, <v>4<>]

<table><col><v>first<><><col>= <v>list_1<>[0]		<><col><#># Returns 0<><>
<col><v>second<><><col>= <v>list_1<>[1]<><col><#># Returns 1<><>
<col><v>...<><>
<col><v>second_last<><><col>= <v>list_1<>[-2]<><col><#># Returns 3<><>
<col><v>last<><><col>= <v>list_1<>[-1]<><col><#># Returns 4<><>
<col> <>
<col><v>all<><><col>= <v>list_1<>[:]<><col><#># Returns [0, 1, 2, 3, 4] (Not Recommended)<><>
<col><v>all_but_first<><><col>= <v>list_1<>[1:]<><col><#># Returns [1, 2, 3, 4]<><>
<col><v>all_but_last<><><col>= <v>list_1<>[:-1]<><col><#># Returns [0, 1, 2, 3]<><>
<col><v>reversed<><><col>= <v>list_1<>[::-1]<><col><#># Returns [4, 3, 2, 1, 0]<><>
<col> <>
<col><v>from_1_to_3<><><col>= <v>list_1<>[<v>1<>:<v>4<>]<><col><#># Returns [1, 2, 3]<><>
<col><v>from_1_step_to_3<><><col>= <v>list_1<>[<v>1<>:<v>4<>:<v>2<>]<><col><#># Returns [1, 3]<><>
<col><v>even<><><col>= <v>list_1<>[::<v>2<>]<><col><#># Returns [0, 2, 4]<><>
<col><v>odd_from_1<><><col>= <v>list_1<>[<v>1<>::<v>2<>]<><col><#># Returns [1, 3]<><><><>
@
@ examples, [0], [-1], [:], [::], [:-1]
@ summary



### Sequence - Get Value

<cb>= <v>sequence_1<>[<v>index<>]<>


Returns one value from the sequence.


Example:

<cb><v>list_1<> = [<v>0<>, <v>1<>, <v>2<>, <v>3<>, <v>4<>]

<v>value<> = <v>list_1<>[<v>1<>]

<#># Returns 1<><>
@
@ item, []



### Sequence - Get First Value

<cb>= <v>sequence_1<>[0]<>


Returns the first value from the sequence.


Example:

<cb><v>list_1<> = [<v>0<>, <v>1<>, <v>2<>, <v>3<>, <v>4<>]

<v>value<> = <v>list_1<>[0]

<#># Returns 0<><>
@
@ item, [0], 1st



### Sequence - Get Last

<cb>= <v>sequence_1<>[-1]<>


Returns the last value from the sequence.


Example:

<cb><v>list_1<> = [<v>0<>, <v>1<>, <v>2<>, <v>3<>, <v>4<>]

<v>value<> = <v>list_1<>[-1]

<#># Returns 4<><>
@
@ item, value, end [-1]



### Sequence - Get Sublist

<cb>= <v>sequence_1<>[<v>start<> : <v>end_plus_1<>]<>


Return everything but the first item.


Example:

<cb><v>list_1<> = [<v>0<>, <v>1<>, <v>2<>, <v>3<>, <v>4<>]

<v>value<> = <v>list_1<>[<v>2<> : <v>4<>]

<#># Returns [2, 3]<><>
@
@ item, [:], subsequence



### Sequence - Get Sublist From Position

<cb>= <v>sequence_1<>[<v>start<>:]<>


Return everything but the first item.


Example:

<cb><v>list_1<> = [<v>0<>, <v>1<>, <v>2<>, <v>3<>, <v>4<>]

<v>value<> = <v>list_1<>[<v>2<>:]

<#># Returns [2, 3, 4]<><>
@
@ item, [1:], index, subsequence



### Sequence - Get Sublist To Position

<cb>= <v>sequence_1<>[<v>start<> : <v>end_plus_1<>]<>


Return everything but the first item.


Example:

<cb><v>list_1<> = [<v>0<>, <v>1<>, <v>2<>, <v>3<>, <v>4<>]

<v>value<> = <v>list_1<>[:<v>4<>]

<#># Returns [0, 1, 2, 3]<><>
@
@ item, [:], index, subsequence



### Sequence - Get Sublist - All Except First

<cb>= <v>sequence_1<>[1:]<>


Return everything but the first item.


Example:

<cb><v>list_1<> = [<v>0<>, <v>1<>, <v>2<>, <v>3<>, <v>4<>]

<v>value<> = <v>list_1<>[1:]

<#># Returns [1, 2, 3, 4]<><>
@
@ item, [1:], sublist, subsequence
@ second, 2nd, to end, to last, remainder, 1st



## Sequence Destructuring
@
@ destructure, unpack, unpacking, destructure-only, destructuring-only



### Sequence Destructuring - Basics

<cb><table><col><v>first<>, *<v>remainder<><><col>= <v>sequence_1  <><>
<col><v>first<>, <v>second<>, *<v>remainder<><><col>= <v>sequence_1<><>
<col><v>first<>, <v>second<>, *_<><col>= <v>sequence_1<><><col><#># Remainder is Ignored<><>
<col><v>first<>, _, <v>third<>, *_<><col>= <v>sequence_1<><><col><#># Second, Remainder are Ignored<><>
<col><v>first<>, *_, <v>last<><><col>= <v>sequence_1<><><col><#># Returns First, Last Only<><><><>

<c>*<> is returned as a list.
<c>_<> is an element that is ignored.
@
@ example, _, *_
@ summary



### Sequence - Destructure First Elements, Remainder

<cb><v>first<>, *<v>remainder<> = <v>sequence_1<><>

<cb><v>first<>, <v>second<>, <v>...<> *<v>remainder<> = <v>sequence_1<><>

Returns the first element, and the remainder as a list.


Example:

<cb><v>sequence_1<> = [1, 2, 3, 4, 5]

<v>first<>, *<v>remainder<> = <v>sequence_1<>                <#># Returns 1, [2, 3, 4, 5]<><>

<cb><v>sequence_1<> = [1, 2, 3, 4, 5]

<v>first<>, <v>second<>, *<v>remainder<> = <v>sequence_1<>      <#># Returns 1, 2, [3, 4, 5]<><>
@
@ tail, *, 1st



### Sequence - Destructure First, Last Only

<cb><v>first<>, *_, <v>last<> = <v>sequence_1<><>

Returns the first and last elements.
All others are ignored (denoted by <c>*_<>).


Example:

<cb><v>sequence_1<> = [1, 2, 3, 4, 5]

<v>first<>, *_, <v>last<> = <v>sequence_1<>          <#># Returns 1, 5<><>
@
@ *_, 1st, end, items, values



### Sequence - Destructure Ignore Element

<cb><v>first<>, _, <v>third<>, *<v>remainder<> = <v>sequence_1<><>

<c>_<> denotes the element to be ignored (second element in this case).


Example:

<cb><v>sequence_1<> = [1, 2, 3, 4, 5]

<v>first<>, _, <v>third<>, *<v>remainder<> = <v>sequence_1<>        <#># Returns 1, 3, [4, 5]<><>
@
@ tail, _, *



### Sequence - Destructure Ignore Remainder

<cb><v>first<>, <v>second<>, <v>third<>, *_ = <v>sequence_1<><>

Ignores everything after the third element (denoted by <c>*_<> ).


Example:

<cb><v>sequence_1<> = [1, 2, 3, 4, 5]

<v>first<>, <v>second<>, <v>third<>, *_ = <v>sequence_1<>       <#># Returns 1, 2, 3<><>
@
@ tail, *_



### Sequence - Destructure Ignore Start

<cb>*_, <v>second_last<>, <v>last<> = <v>sequence_1<><>

Ignores everything before the 2nd last element (denoted by <c>*_<> ).


Example:

<cb><v>sequence_1<> = [1, 2, 3, 4, 5]

*_, <v>second_last<>, <v>last<> = <v>sequence_1<>            <#># Returns 4, 5<><>
@
@ *_



## Sequence Operations



### Sequence - Contains?

<cb>= <v>value<> in <v>sequence_1<><>

<cb>if <v>value<> in <v>sequence_1<>:<>
@
@ has, check, exists, item, element, in, includes



### Sequence - Not Contains?

<cb>= <v>value<> not in <v>sequence_1<><>

<cb>if <v>value<> not in <v>sequence_1<>:<>
@
@ has, check, exists, item, element, in, includes, doesn't



### Sequence - Count Occurrences

<cb>= <v>sequence_1<>.count(<v>value<>)<>


Returns the number of times <c><v>value<><> appears in <c><v>sequence_1<><>.
@
@ items, .count(), times



### Sequence - Count Occurences With Counter

<cb>from collections import Counter

= Counter(<v>sequence_1<>)<>


Returns: <c>dict<>


Returns a dictionary with every unique value and the number of times of that value is present.
@
@ items, values, unique, individual, occurrences, collections.counter(), .counter()



### Sequence - Count By Distinct Value

<cb>= len(set(<v>sequence_1<>))<>


Returns the number of unique values in <c><v>sequence_1<><>.
@
@ items, unique, individual, occurrences, times, len(), .counter(), collections.counter()



### Sequence - Duplicate

<cb>= <v>sequence_1<>.copy()<>

Creates a shallow copy.
@
@ Copy, .copy()



### Sequence - Duplicate - Deep Copy

<cb>from copy import deepcopy

= deepcopy(<v>sequence_1<>)<>

Creates a deep copy.
@
@ Copy, deepcopy(), copy.deepcopy()



### Sequence - Is Empty?

<cb>= not <v>sequence_1<><>

<cb>if not <v>sequence_1<>:
	<v>...<><>



### Sequence - Not Empty?

<cb>= bool(<v>sequence_1<>)<>

<cb>if <v>sequence_1<>:
	<v>...<><>
@
@ bool()



### Sequence - Find

<cb>= <v>sequence_1<>.index(<v>value<>)<>

<cb>= <v>sequence_1<>.index(<v>value<>, <v>start<>)<>

<cb>= <v>sequence_1<>.index(<v>value<>, <v>start<>, <v>end<>)<>

Returns the index of the first match.
@
@ Search, Index, .index()




### Sequence - Iterate

<cb>for <v>value<> in <v>sequence_1<>:
	<v>...<><>
@
@ for in, foreach, iterating



### Sequence - To Dict

<cb>= {value:value for value in <v>sequence_1<>}<>

Returns: <c>dict<>


Returns a dict where every value is also the key to that value.
@
@ Convert, Conversion, From
@ Dict, Dictionary
@ from-sequence, to-dict



### Sequence - To Dict - Enumerated

<cb>= dict(enumerate(<v>sequence_1<>))<>

Returns: <c>dict<>


Returns a dict where the key to a value is the original index position of that value.
@
@ convert, conversion, from
@ dictionary, by position, indexed, by index, dict(), enumerate()
@ from-sequence, to-dict



### Sequence - To Set

<cb>= set(<v>sequence_1<>)<>

Returns a set with all duplicates removed.
@
@ Convert, Conversion, From, set()
@ from-sequence, to-set



### Sequence - To Tuple

<cb>= tuple(<v>sequence_1<>)<>
@
@ Convert, Conversion, From, tuple()
@ from-sequence, to-tuple



### Sequence - To Iterator

<cb>= iter(<v>sequence_1<>)<>

Turns any sequence type into an iterator.
@
@ list, tuple, iter()
@ from-sequence, to-iterator



## Sequence Functions
@
@ seq-functions-only, sequence-functions-only



### Sequence - All

<cb>= all(<v>boolean_sequence_1<>)<>

or

<cb>= all(map(<v>test_function<>, <v>sequence_1<>))<>

Returns true if all elements of <c><v>boolean_sequence_1<><> evaluate to True.
This function short-circuits when a False value is reached.

Use <c><v>test_function<><> to return the <c>True<> / <c>False<> value for <c><v>sequence_1<><> elements.
@
@ Boolean, all(), map()



### Sequence - Any

<cb>= any(<v>boolean_sequence_1<>)<>

or

<cb>= any(map(<v>test_function<>, <v>sequence_1<>))<>

Returns true if any element of <c><v>boolean_sequence_1<><> evaluates to True.
This function short-circuits when a True value is reached.

Use <c><v>test_function<><> to return the <c>True<> / <c>False<> value for <c><v>sequence_1<><> elements.
@
@ Boolean, any(), map(), is true



### Sequence - Average

<cb>= sum(<v>sequence_1<>) / len(<v>sequence_1<>)<>


Returns the average of the values in a list.


Example:

<cb><v>list_1<> = [3, 4, 7, 10]

<v>average<> = sum(<v>list_1<>) / len(<v>list_1<>)

<#># Returns: 6.0<><>
@
@ average()


### Sequence - Enumerate

<cb>= enumerate(<v>sequence_1<>)

= enumerate(<v>sequence_1<>, <v>starting_value<>)<>

<cb>for <v>index<>, <v>value<> in enumerate(<v>sequence_1<>):
	<v>...<><>

Returns:    <c>enumerate<>
		(generator of index, value tuples)


The <c>enumerate<> function returns a generator.

That generator returns an index, value tuple for each entry in the sequence.
The index is the position in the sequence (zero based).
The value is the value in the sequence at that position.


Example:

<cb><v>list_1<> = ["zero", "one", "two"]

for <v>index<>, <v>value<> in enumerate(<v>list_1<>):
	print (<v>index<>, <v>value<>)<>

Prints:

<cb><#>0 zero
1 one
2 two<><>
@
@ enumerate(), index, indexed, enumeration, enumerated



### Sequence - Min

<cb>= min(<v>sequence_1<>)

= min(<v>sequence_1<>, key = <v>test_function<>)<>
@
@ minimum, value, item, element, min(), key=



### Sequence - Max

<cb>= max(<v>sequence_1<>)

= max(<v>sequence_1<>, key = <v>test_function<>)<>
@
@ greatest, largest, maximum, value, item, element, max(), key=



### Sequence - Filter

<cb>= filter(<v>test_function<>, <v>sequence_1<>)<>

Returned Type: <c>filter<>


Returns all values where <c><v>test_function<>(<v>value<>)<> == <c>True<>.

Returns a filter that will return a subset of <c><v>sequence_1<><>.
Filters are lazy iterators.
Values are evaluated and returned one at a time, and only when requested.


Examples:

Using a Filter Function:

<cb><#># Define Test:<>

def <v>is_even<>(<v>value<>):
	return <v>value % 2 == 0<>

<#># Filter:<>

<v>sequence_1<> = [<v>1<>, <v>2<>, <v>3<>, <v>4<>, <v>5<>]

<v>filtered<> = list(filter(<v>is_even<>, <v>sequence_1<>))

<#># Returns values 2, 4.<><>

Using a Lambda Filter:

<cb><v>sequence_1<> = [<v>1<>, <v>2<>, <v>3<>, <v>4<>, <v>5<>]

<v>filtered<> = list(filter(
		lambda <v>value<> : <v>value % 2 == 0<>,
		<v>sequence_1<>))

<#># Returns values 2, 4.<><>
@
@ filter(), find in



#### Filter - Test Function

<cb>def <v>test_function<>(<v>value<>):
	return <v>true_or_false_value<><>


Used by <c>filter()<> to determine which values to return.
Must return <c>True<> or <c>False<>.
<c>True<> values will be returned by <c>filter()<>
@
@ filtering



#### Filter - To List

<cb>= list(<v>filtered_1<>)<>
@
@ Convert, Conversion, From, list()



### Sequence - Map

<cb>= map(<v>mapping_function<>, <v>sequence_1<>)<>

Returns: <c>map<>


Returns a map of <c><v>sequence_1<><> values passed through <c><v>mapping_function<><>.

Maps are lazy itorators. Wrap with <c>list()<> to get actual values.


Example:

<cb>def <v>add_10<>(<v>value<>):
	return <v>value<> + 10

<v>list_1<> = [<v>1<>, <v>2<>, <v>3<>]

<v>mapped<> = list(map(<v>add_10<>, <v>list_1<>))

<#># Returns: Map of 11, 12, 13.<><>
@
@ map()
@ from-sequence, to-map, convert, conversion



#### Map - Mapping Function

<cb>def <v>mapping_function<>(<v>value<>):
	return <v>some_transformation<><>

Returns a new value based on the original value.



#### Map - To List

<cb>= list(<v>mapped_1<>)<>

<cb>= list(map(<v>mapping_function<>, <v>list_1<>))<>



### Sequence - Reduce

<cb>from functools import reduce

<v>reduced_1<> = reduce(<v>reducing_function<>, <v>sequence_1<>)<>

<cb>= reduce(<v>reducing_function<>, <v>sequence_1<>, <v>initial_value<>)<>

Returns a single value calculated by passing every value in <c><v>sequence_1<><> into <c><v>reducing_function<><>.


Examples:

<cb>def <v>add<>(<v>previous_result<>, <v>value<>):
	return <v>previous_result + value<>

<v>sequence_1<> = [<v>1<>, <v>2<>, <v>3<>, <v>4<>, <v>5<>]
<v>total<> = reduce(<v>add<>, <v>sequence_1<>)                       <#># Returns 15.<><>

<cb><v>sequence_1<> = [<v>1<>, <v>2<>, <v>3<>, <v>4<>, <v>5<>]
<v>total<> = reduce(
		lambda <v>previous<>, <v>value<> : <v>previous + value<>,
		<v>sequence_1<>)                                   <#># Returns 15.<><>
@
@ functools.reduce(), .reduce()



#### Reducing Function

<cb>def <v>reducing_function<>(<v>previous_result<>, <v>next_value<>):
	return <v>some_calculation<><>                                    

Calculates a value base on <c><v>previous_result<><> and <c><v>next_value<><>.

For the first calculation, <c><v>previous_result<><> will either be:
	<c><v>initial_value<><> if provide, or
	<c><v>first_value<><> the first value in the sequence.



### Sequence - Shuffle

<cb>from random import shuffle

shuffle(<v>sequence_1<>)<>

Randomizes a sequence in place.
@
@ Randomize, random.shuffle(), .shuffle()



### Sequence - Sort

<cb>= sorted(<v>sequence_1<>)<>

<cb>= sorted(<v>sequence_1<>, key = <v>compare<>)<>

Returns: <c>list<>

Returns a new sorted list from <c><v>sequence_1<><>.

<c><v>compare<><> is a function that takes a sequence element as an argument, and returns it's comparable value.


Example:

<cb><v>values<> = ['<v>a<>', '<v>B<>', '<v>c<>']

<v>sorted_1<> = sorted(<v>values<>)
<#># Returns 'B', 'a', 'c'<>

<v>sorted_2<> = sorted(<v>values<>, key = str.lower)
<#># Returns 'a', 'B', 'c'<>

<v>sorted_3<> = sorted(<v>values<>, key = lambda <v>value<>: <v>value<>.lower())
<#># Returns 'a', 'B', 'c'<>


<v>to_lower<> = lambda value: value.lower()

<v>sorted_4<> = sorted(<v>values<>, key = <v>to_lower<>)
<#># Returns 'a', 'B', 'c'<><>
@
@ Sort By, sorted()



### Sequence - Sort Reversed

<cb>= sorted(<v>sequence_1<>, reverse = True)<>

Returns: <c>list<>

Sorts the elements in reverse order.
@
@ sorted()



### Sequence - Sum

<cb>= sum(<v>sequence_1<>)<>


Example:

<cb>= sum(<v>[1, 2, 3]<>)                      <#># Returns 6<><>
@
@ sum(), total



### Sequence - Zip

<cb>= zip(<v>sequence_1<>, <v>sequence_2<>)<>

or

<cb>= zip(<v>sequence_1<>, <v>sequence_2<>, <v>...<>)<>

Returns: <c>zip(*iterable)<>

Zips two or more sequences or iterables together.
The returned zip object is iterable and returns tuples.
Each tuple contains the element from each sequence at that position.
If the sequences are different sizes, returns the shortest size.


Example:

<cb><v>list_1<> = [1, 2]
<v>list_2<> = ["one", "two"]

<v>zipped<> = zip(<v>list_1<>, <v>list_2<>)
<v>combined<> = list(<v>zipped<>)

<#># Returns [(1, 'one'), (2, 'two')]<><>
@
@ Merge, Combine, List, Set, zip()



### Sequence - Zip Unequal Sized Lists

<cb>= zip_longest(<v>sequence_1<>, <v>sequence_2<>)<>

Usage:

<cb>from itertools import zip_longest

= zip_longest(<v>sequence_1<>, <v>sequence_2<>)<>

Returns: <c>zip_longest<>


Returns an iterable that returns tuples from each list.

Returns <c>None<> where shorter lists have no value.


Example:

<cb>from itertools import zip_longest

<v>list_1<> = [1, 2, 3, 4]
<v>list_2<> = ['one', 'two']

<v>zipped<> = zip_longest(<v>list_1<>, <v>list_2<>)
<v>combinded<> = list(<v>zipped<>)

<#># Returns: [(1, 'one'), (2, 'two'), (3, None), (4, None)]<><>
@
@ itertools.zip_longest(), .zip_longest(), zip()



# Collections
@
@ Structures



## Queue

<cb>= Queue()<>

Usage:

<cb>from queue import Queue

= Queue()
= Queue(<v>max_size<>)               <#>#1<><>

Asynchronous first in first out queue.

\#1  <s>-<>  Defins the maximum number of elements in the queue.
@
@ Create, Define, Instantiate, New
@ queue(), queue.queue(), maximum size
@ Queue-only, queues-only, standard-queue-only, standard-queues-only, std-queue-only, std-queues-only



## Queue Operations
@
@ queue(), queue.queue()
@ Queue-only, queues-only, standard-queue-only, standard-queues-only, std-queue-only, std-queues-only



#### Queue - Add

<cb><v>queue_1<>.put(<v>value_1<>)<>
@
@ put, append, insert, append to, .put()



#### Queue - Get Next

<cb>= <v>queue_1<>.get()                           <#>#1<><>

or

<cb>= <v>queue_1<>.get_nowait()                    <#>#2<><>


Get next item.


\#1  <s>-<>  If no items, waits until one becomes available.

\#2  <s>-<>  If no items, raises <c>QueueEmpty<>.
@
@ .get(), .get_nowait()



#### Queue - Is Empty?

<cb>= <v>queue_1<>.empty()<>

Returns: <c>bool<>

Returns <c>True<> if empty.
@
@ .empty()



#### Queue - Is Full?

<cb>= <v>queue_1<>.full()<>

Returns: <c>bool<>

Returns <c>True<> if the queue is full and can't take any more items.
@
@ .empty()



#### Queue - Maximum Size

<cb>= <v>queue_1<>.maxsize<>


Returns the maximum allowed size of the queue.
Returns 0 if no maximum set.
@
@ count, length, .maxsize, greatest, largest



#### Queue - Size

<cb>= <v>queue_1<>.qsize()<>

Returns the number of items in the queue.
@
@ count, length, .qsize()



# Conversions
@
@ convert, converting, to, from
@ conversions-only, convert-only



### ASCII Code - To String Character / chr()

<cb>= chr(<v>ascii_code<>)<>

Example:

<cb><v>string_1<> = chr(67)                        <#># Returns 'C'<><>
@
@ Character, chr(), ascii-to, to-char
@ Strings, string-only, strings-only, str-only, text, text-only, str(), str., string



### Base64 - To Bytes

<cb>from base64 import b64decode

= b64decode(<v>bytes_1<>)<>

Retuns: <c>bytes<>


Decodes a base64 encoded byte array.
Returns another byte array.


Example:

<cb>from base64 import b64decode

<v>base64_text<> = 'VGV4dCBpbiBCYXNlNjQ='
<v>base64_bytes<> = <v>base64_text<>.encode('ascii')

<v>decoded_bytes<> = b64decode(<v>base64_bytes<>)     <#>#1<>
<v>decoded_text<> = <v>decoded_bytes<>.decode("utf-8")

print (<v>decoded_text<>)                      <#>#2<><>

\#1  <s>-<>  Base64 Decoding

\#2  <s>-<>  Prints 'This in Base64'
@
@ .decode(), Base 64, base64.b64decode(), .b64decode()
@ to-bytes, from-base64, base64-to



### Binary String - To Integer

<cb>= int(<v>binary_string<>, 2)<>

<cb>= int("0b<v>value<>", 0)<>


Example:

<cb><v>bin_1<> = int("<v>00101010<>", 2)

<#># Returns 42<><>

<cb><v>bin_2<> = int("0x<v>00101010<>", 0)

<#># Returns 42<><>
@
@ int()
@ to-integer, from-string, from-binary-string, binary-to
@ Long, int-only, ints-only, long-only, longs-only, integer-only
@ Strings, string-only, strings-only, str-only, text, text-only, str(), str., string



### Boolean - To Integer

<cb>= int(<v>bool_1<>)<>

False = 0
True = 1
@
@ int(), from-boolean, bool-to, boolean-to, to-integer
@ bool, bool-only, bools-only, boolean-only, booleans-only



### Boolean - To String

<cb>= str(<v>value_1<>)<>

Returns 'True' or 'False'.
@
@ str(), from-boolean, bool-to, boolean-to, to-string
@ bool, bool-only, bools-only, boolean-only, booleans-only
@ Strings, string-only, strings-only, str-only, text, text-only, str(), str., string



### Bytes - To Base64

<cb>from base64 import b64encode

= b64encode(<v>bytes_1<>)<>

Returns: <c>bytes<>


Encodes a byte array into Base64.
Returns as another byte array.


Example:

<cb>from base64 import b64encode

<v>text<> = "Text in Base64"
<v>bytes<> = <v>text<>.encode("utf-8")

<v>base64_bytes<> = b64encode(<v>bytes<>)             <#>#1<>
<v>base64_text<> = <v>base64_bytes<>.decode("ascii")

print (<v>base64_text<>)                           <#>#2<><>

\#1  <s>-<>  Base64 Conversion

\#2  <s>-<>  Prints 'VGV4dCBpbiBCYXNlNjQ='
@
@ encode(), .encode(), Base 64, base64.b64encode(), b64encode()
@ from-bytes, byte-to, bytes-to, to-base64
@ bytes, byte-only, bytes-only, binary



### Bytes - To Hex

<cb>from binascii import hexlify

= hexlify(<v>bytes_1<>)<>

Returns: <c>bytes<>


Converts a byte array into its hex representation.


Example:

<cb>from binascii import hexlify

<v>value_bytes<> = b'in bytes'
<v>value_hex<> = hexlify(<v>value_bytes<>)

print (<v>value_hex<>.decode('ascii'))     <#>#1<><>

\#1  <s>-<>  Prints '696e206279746573'
@
@ hexadecimal, binascii.hexlify(), .hexlify()
@ from-bytes, byte-to, bytes-to,  to-hex
@ bytes, byte-only, bytes-only, binary



### Bytes - To Int

<cb>= int.from_bytes(<v>bytes_1<>, "big")<>

Use <c>"big"<> for bytes with the most significant byte first.
Use <c>"little"<> for bytes with the most significant byte first.
@
@ from-bytes, byte-to, bytes-to, to-integer
@ bytes, byte-only, bytes-only, binary



### Bytes - To String

<cb>= <v>bytes_1<>.decode("utf-8")<>
@
@ decode, utf-8, utf8, .decode()
@ from-bytes, byte-to, bytes-to, to-string
@ bytes, byte-only, bytes-only, binary
@ Strings, string-only, strings-only, str-only, text, text-only, str(), str., string



### Complex Number - To String

<cb>= str(<v>complex_1<>)<>
@
@ str()
@ from-complex, complex-to, complex-number-to, to-string
@ complex-only, complex-numbers-only
@ Strings, string-only, strings-only, str-only, text, text-only, str(), str., string



### Float - To Decimal

<cb>from decimal import Decimal

= Decimal(<v>float_value<>)<>


Creates an immutable decimal value.


Example:

<cb>from decimal import Decimal

<v>decimal_1<> = Decimal(<v>12.34<>)

print(<v>decimal_1<>)

<#># Prints 12.339999999999999857891452847979962825775146484375<><>
@ money, currency
@ from-float, float-to, to-decimal
@ dec-only, decs-only, decimal-only, decimals-only



### Float - To Integer

<cb>= int(<v>float_value<>)<>

Example:

<cb><v>int_1<> = int(<v>1234.567<>)   <#># Returns 1234<><>
@
@ int()
@ from-float, float-to, to-integer



### Float - To String

<cb>= "<v>format<>".format(<v>float_value<>)<>

Example:

<cb><v>string_1<> = "<v>{0:,.2f}<>".format(<v>1234.567<>)

<#># Returns "1,234.56"<><>
@
@ .format()
@ from-float, float-to, to-string
@ float-only, floats-only
@ Strings, string-only, strings-only, str-only, text, text-only, str(), str., string



### Hex String - To Integer

<cb>= int(<v>hex_string<>, 16)<>

<cb>= int("0x<v>hex_value<>", 0)<>


Example:

<cb><v>hex_1<> = int("<v>A9<>", 16)

<#># Returns 169<><>

<cb><v>hex_2<> = int("0x<v>A9<>", 0)

<#># Returns 169<><>
@
@ int(), hexadecimal
@ to-integer, from-string, from-hex-string, hex-to, hexadecimal-to
@ Long, int-only, ints-only, long-only, longs-only, integer-only
@ Strings, string-only, strings-only, str-only, text, text-only, str(), str., string



### Integer - To Binary String

<cb>= bin(<v>int_1<>)<>

Returns: <c>str<>


Example:

<cb><v>binary_1<> = bin(<v>11<>)

<#># Returns '0b1001'<><>
@
@ bin()
@ from-integer, int-to, integer-to, to-binary-string, to-string, bits, binary, byte
@ Long, int-only, ints-only, long-only, longs-only, integer-only
@ Strings, string-only, strings-only, str-only, text, text-only, str(), str., string



### Integer - To Hex String

<cb>= hex(<v>int_1<>)<>

Returns: <c>str<>


Example:

<cb><v>hex_1<> = hex(<v>169<>)

<#># Returns '0xa9'<><>
@
@ hex(), hexadecimal
@ from-integer, int-to, integer-to, to-hex-string, to-string
@ Long, int-only, ints-only, long-only, longs-only, integer-only
@ Strings, string-only, strings-only, str-only, text, text-only, str(), str., string



### Integer - To Octal String

<cb>= oct(<v>int_1<>)<>

Returns: <c>str<>


Example:

<cb><v>octal_1<> = oct(<v>57<>)

<#># Returns '0o71'<><>
@
@ oct()
@ from-integer, int-to, integer-to, to-oct-string, to-string
@ Long, int-only, ints-only, long-only, longs-only, integer-only
@ Strings, string-only, strings-only, str-only, text, text-only, str(), str., string



### Integer - To String

<cb>= str(<v>int_1<>)<>


Example:

<cb><v>string_1<> = str(<v>123<>)<>
@
@ str()
@ from-integer, int-to, integer-to, to-string
@ Long, int-only, ints-only, long-only, longs-only, integer-only
@ Strings, string-only, strings-only, str-only, text, text-only, str(), str., string



### List - To String

<cb>= ''.join(<v>list1<>)<>

Joins all elements of <c><v>list1<><> into 1 string.


Example:

<cb><v>list_1<> = ['<v>1<>', '<v>2<>', '<v>3<>', '<v>4<>']

<v>string_1<> = ''.join(<v>list_1<>)

<#># Returns: '1234'<><>
@
@ convert to, conversion, characters, .join()
@ from-list, list-to, to-string
@ Strings, string-only, strings-only, str-only, text, text-only, str(), str., string



### String Character - To ASCII Code / ord()

<cb>= ord('<v>character<>')<>

<c><v>character<><> must be a single letter string.


Example:

<cb><v>ascii_code<> = ord('<v>C<>')

<#># Returns 67<><>
@
@ character, ord(), value
@ from-string, string-to, char-to, character-to, to-ascii
@ Strings, string-only, strings-only, str-only, text, text-only, str(), str., string



### String - To Boolean

<cb>= <v>string_value<>.lower() in ['t', 'true', 'y', 'yes', 1]<>

Returns true if <c><v>string_value<><> is one of 't', 'true', 'y', 'yes', or 1.
Case is ignored.
@
@ True, False, parse, .tolower(), yes, no, to-boolean, from-string
@ bool, bool-only, bools-only, boolean-only, booleans-only
@ Strings, string-only, strings-only, str-only, text, text-only, str(), str., string
@ from-string, string-to, to-boolean


### String (Empty / Not Empty) - To Boolean

<cb>= bool(<v>string_value<>)<>


Tests for empty string.

Empty String = <v>False<>
Otherwise = <v>True<>
@
@ bool(), to-boolean, from-string
@ bool, bool-only, bools-only, boolean-only, booleans-only
@ Strings, string-only, strings-only, str-only, text, text-only, str(), str., string
@ from-string, string-to, to-boolean



### String - To Bytes

<cb>= <v>string_1<>.encode()<>

<cb>= <v>string_1<>.encode('utf-8')<>
@
@ .encode(), utf-8, utf8
@ to-bytes, from-string
@ bytes, byte-only, bytes-only, binary
@ Strings, string-only, strings-only, str-only, text, text-only, str(), str., string
@ from-string, string-to, to-bytes



### String - To Complex Number

<cb>= complex("<v>1<> + <v>2<>j")<>
@
@ parse, complex()
@ to-complex, from-string
@ complex-only, complex-numbers-only
@ Strings, string-only, strings-only, str-only, text, text-only, str(), str., string
@ from-string, string-to, to-complex-number



### String - To Decimal

<cb>from decimal import Decimal

= Decimal('<v>10.99<>')<>


Creates an immutable decimal value.
Keeps the precision the decimal was created to.


Example:

<cb>from decimal import Decimal

<v>decimal_1<> = Decimal('<v>12.34<>')

print(<v>decimal_1<>)

<#># Prints 12.34<><>
@ money, currency
@ dec-only, decs-only, decimal-only, decimals-only
@ Strings, string-only, strings-only, str-only, text, text-only, str(), str., string
@ from-string, string-to, to-decimal



### String - To Float

<cb>= float(<v>float_string<>)<>

Example:

<cb><v>float_1<> = float("<v>123.3<>")<>
@
@ parse, float()
@ from-string, string-to, to-float
@ float-only, floats-only
@ Strings, string-only, strings-only, str-only, text, text-only, str(), str., string



### String - To Integer

<cb>= int(<v>string_value<>)<>

Example:

<cb><v>int_1<> = int("<v>123<>")<>
@
@ int(), parse
@ from-string, string-to, to-integer
@ Long, int-only, ints-only, long-only, longs-only, integer-only
@ Strings, string-only, strings-only, str-only, text, text-only, str(), str., string



### String - To List

<cb>= [<v>character<> for <v>character<> in <v>string_1<>]<>


Returns: <c>list<> of <c>str<>


Converts a string to a list of characters.


Example:

<cb><v>string_1<> = '<v>abc<>'

<v>list_1<> = [<v>character<> for <v>character<> in <v>string_1<>]

<#># Returns: ['a', 'b', 'c']<><>
@
@ characters, from, chars
@ from-string, string-to, to-list
@ Strings, string-only, strings-only, str-only, text, text-only, str(), str., string



### String - To Set

<cb>= set(<v>string_1<>)<>


Returns: <c>set<> of <c>str<>


Converts a string to a set of characters.


Example:

<cb><v>string_1<> = '<v>abc<>'

<v>set_1<> = set(<v>string_1<>)

<#># Returns: ['a', 'b', 'c']<><>
@
@ characters, from, chars
@ from-string, string-to, to-set
@ Strings, string-only, strings-only, str-only, text, text-only, str(), str., string



# Context Manager

Allows a resource's lifecycle to be handled correctly.
The context manager will open the resource using <c>with<>
and will close it correctly when exiting the block.
No <c>close<>() method needs to be called, even if an exception is thrown.
@
@ managers
@ context-only, context-manager-only, context-managers-only


### Context Manager - Define

<cb>class <v>ManagedResource1<>:

	def __enter__ (self):                           <#># Called At Creation<>
		<v>...<>

	def __exit__ (self, type, value, traceback):    <#># Called At Completion<>
		<v>...<><>


Allows a class to be used as a managed resource.

<c>type<>, <c>value<>, <c>traceeback<> will be populated when an exception is raised. <c>value<> will contain the exception.
@
@ define, new, closeable auto close, __enter__, __exit__, enter, exit, reseource, autoclose
@ with-only



### Context Manager - Use / With

<cb>with <v>ManagedResource1<>() as <v>resource_item_1<>:
	<v>...<><>

Reference the resource using <c><v>resource_item_1<><>.
<c><v>resource_item_1<><> is automatically closed at the end of the block.
@
@ with, instantiate, auto close, closeable, open, reseource, autoclose
@ with-only



# Error Handling
@
@ Exceptions, except-only, exception-only, exceptions-only
@ Errors, error-only, error-handling-only, errors-only



## Exceptions



### Exceptions - Basics

<cb>class <v>Exception1<>(Exception):
	<v>...<><>

<cb>raise <v>Exception1<>()<>

<cb>try:
	<v>...<>
except <v>Exception1<> as exception:
	<v>...<>
finally:
	<v>...<><>
@
@ try, except, finally, raise
@ summary


### Define

<cb>class <v>Exception1<>(Exception):
	<v>...<><>

Defines a new exception type.
Inherit from <c>Exception<>.
@
@ create, new, exception



### Raise

<cb>raise <v>Exception1<>()<>

<cb>raise <v>Exception1<>() from <v>exception_1<>		<#>#1<><>

<#>#1<> - Chains Stack Traces From <c><v>exception_1<><>
@
@ Raises, Chaining, chains, create, new, stack traces



### Try Except

<cb>try:
	<v>...<>
except <v>Exception1<> as exception:
	<v>...<>
else:
	<v>...<>
finally:
	<v>...<><>

<cb>try:
	<v>...<>

except <v>Exception1<>:
	<#># Catches <c>Exception1<> (#1)<>
	<v>...<>

except <v>Exception2<> as <v>exception_2<>
	<#># Catches <c>Exception2<>, Reference with <c>exception_2<><>
	<v>...<>

except Exception as <v>exception_3<>
	<#># Catches Any Exception<>
	<v>...<>

else:
	<#># Called if no exception thrown.<>
	<v>...<>

finally:
	<#># Always Executed (#2)<>
	<v>...<><>

Catches an exception raised in the try part of the block.
All subclasses of a exception are caught in the same block as the exception.

\#1 - No exception variable assignd so exceptions can not be referenced in this block.

\#2 -  Always executes even if an exception is thrown.
@
@ exception, else, finally



### Try Except - Basic

<cb>try:
	<v>...<>
except <v>Exception1<> as exception:
	<v>...<>
except <v>Exception2<> as exception:
	<v>...<>
finally:
	<v>...<><>



### Try Except - Else, Finally

<cb>try:
	<v>...<>
except <v>Exception1<> as exception:
	<v>...<>
else:
	<v>...<>
finally:
	<v>...<><>



### Try Except - Single Line Multiple Exceptions

<cb>try:
	<v>...<>

except (<v>Exception1<>, <v>Exception2<>):
	<v>...<>

except (<v>Exception3<>, <v>Exception4<>) as <v>error<>
	<v>...<><>


Example:

<cb>try:
	<v>value<> = input("Enter number: ")

	if not <v>value<>:
		raise ValueError("Must enter a value.")

	if not <v>value<>.isdigit():
		raise TypeError("Must be a number.")

except (TypeError, ValueError):
	<v>...<><>



### Exception - Get Message

<cb>= str(<v>exception_1<>)<>

Works in some circumstances:

<cb>= <v>exception_1<>.args[0]<>

Returns the error message.
@
@ .args[0]



### Exception - Get Stack Trace

<cb>import traceback

<v>taceback_1<> = traceback.format_exc()<>

Returns: <c>str<>


Example:

<cb>except Exception as <v>exception_1<>:
	print(traceback.format_exc())<>
@
@ traceback.format_exc(), .format_exc()
@ print, show



## Standard Exceptions
@
@ std, standard-exceptions-only, std-exceptions-only


#### Exception - AssertionError

<cb>AssertionError<>

Raised when an assertion fails.
@
@ assertionerror-only



#### Exception - FileNotFoundError

<cb>FileNotFoundError<>
@
@ not found
@ filenotfounderror-only


#### Exception - IndexError

<cb>IndexError<>

Use to indicate index out of bounds or other index error.
@
@ index out of bounds
@ indexerror-only



#### Exception - NotImplementedError

<cb>NotImplementedError<>

A runtime exception.
@
@ not implemented error
@ notimplementederror-only



#### Exception - StopIteration

<cb>StopIteration<>

Use to indicate an iterator or generator has completed.
@
@ stop iterator, iterator finished, generator, yield
@ stopiteration-only



#### Exception - TypeError

<cb>TypeError<>

Use to indicate invalid or None type.
@
@ invalid, none type
@ typeerror-only



#### Exception - ValueError

<cb>ValueError<>

Use when type is correct but value is outside the expected range.
Use this for request validations.
@
@ invalid value, bad value
@ valueerror-only



# Functions
@
@ function-only, functions-only, func-only



## Function - Basics

<cb>def <v>function_1<>(<v>arg_1<>, <v>arg_2<> <v>...<>):
	<#>"""Function docstring."""<>

	<v>...<>

	return <v>response<><>

<cb><v>response_1<> = <v>function_1<>(<v>arg_1<>, <v>arg_2<>, <v>...<>)<>

<cb><v>response_1<> = <v>function_1<>(<v>arg_1_name<> = <v>arg_1<>, <v>...<>)		<#># With Named Arguments<><>

Functions are stored as global attributes.
Function definitions can be monkey patched by changing the global definition.
Functions are first class objects and can be passed as values.
@
@ examples, def, summary



## Function - Details



### Function - Define

<cb>def <v>function_1<>(<v>arg_1<>, <v>arg_2<> <v>...<>): 
	<v>...<><>

<cb>def <v>function_1<>(<v>arg_1<>, <v>arg_2<> <v>...<>):		<#># With Return<>
	return <v>response<><>
@
@ new, create, arguments, args, parameters, params, return, def



### Function - Define - Empty Function

<cb>def <v>empty_function_1<>():					<#># Empty Function, Does Nothing Yet<>
	pass<>

Use <c>pass<> to define an empty function.
@
@ new, create, pass



### Function - DocString - Define

<cb>def <v>function_1<>():
	<#>"""Place docstring here."""<>
	<v>...<><>
@
@ Doc String, Add, Create, """



### Function - Arguments - Default Values

<cb>def <v>function_1<>(<v>optional_arg_1<> = <v>default_value<>, <v>...<>):
	<v>...<><>

The arguments with default values are optional.
Optional arguments must come after standard non-optional arguments.


Example:

<cb>def <v>say_hello<>(<v>name<>, <v>greeting<> = "<v>Hello<>"):
	print(<v>greeting<>, <v>name<>)

<v>say_hello<>("<v>John<>")
<v>say_hello<>("<v>John<>", "<v>Hi<>")<>
@
@ new, create, values, optional, default, arguments, args, parameters, params



### Function - Arguments - As Key Word Dict

<cb>def <v>function_1<>(**<v>kwargs<>):
	<v>...<>
	<v>value_1<> = <v>kwargs<>[<v>key_1<>]				<#># References Argument <v>key_1<><>
	<v>...<><>

<c>kwargs<> Type: dict

The caller arguments are placed in a dictionary.
The caller must use named arguments.
"<c>kwargs<>" is the name by convention for this argument.

kwargs = key word arguments


Example:

<cb>def <v>say<>(**kwargs):
	print(kwargs[<v>'greeting'<>], kwargs[<v>'name'<>])

<v>say<>(greeting = "<v>Hi<>", name = "<v>John<>")<>
@
@ arguments, args, parameters, params
@ dictionary, **kwargs, *kwargs, kwargs, keyword



### Function - Arguments - As Tuple

<cb>def function1(*args):
	<v>...<>
	<v>value_1<> = <v>args<>[<v>index_1<>]				<#># Reference an Argument<>
	<v>...<><>

<c>args<> Type: tuple

The caller arguments are placed in a tuple.


Example:

<cb>def <v>say<>(*args):
	print(args[<v>0<>], args[<v>1<>])

<v>say<>("<v>Hi<>", "<v>John<>")<>
@
@ arguments, args, parameters, params
@ list, array, pass, *args



### Function - Return

<cb>def <v>function_1<>():
	return <v>value_1<><>


Returns a value.


Example:

<cb>def <v>return_a_1<>():
	return 1

<v>results<> = <v>return_a_1<>()<>
@
@ New, Create, Value



### Function - Return - Multiple Values

<cb>def <v>function_1<>():
	return <v>value_1<>, <v>value_2<>, <v>...<><>


Returns: <c>Tuple<>


Returns values as a tuple.


Example:

<cb>def <v>return_three_values<>():
	return "one", "two", "three"

<v>results<> = <v>return_three_values<>()<>
@
@ New, Create, Values



### Function - Call

<cb><v>function_1<>()							<#># No Arguments, No Return Value<><>

<cb><v>function_2<>(<v>arg_1<>, <v>...<>)					<#># With Arguments<><>

<cb>= <v>function_3<>(<v>arg_1<>, <v>...<>)				<#># When Returning a Value<><>
@
@ calling



### Function - Call - With Named Arguments

Call:

<cb><v>function_1<>(<v>arg_1_name<> = <v>value<>, <v>arg_2_name<> = <v>value<>, <v>...<>)<>


Pass arguments by name to by using the form <c><v>name<> = <v>value<><>.
Order is not important.


Example:

<cb>def <v>greet<>(<v>greeting<>, <v>name<>):
	print(<v>greeting<>, <v>name<>)

<#># Call:<>

<v>greet<>(name = 'John', greeting = 'Hi')<>
@
@ calling
@ arguments, args, parameters, params



### Function - Call - With Dict

<cb><v>function_1<>(**<v>dict_1<>)<>

Pass as <c><v>dict_1<><> it's arguments.
Unpacks the dictionary into keyword arguments inside the function.


Example:

<cb>def <v>say<>(<v>greeting<>, <v>name<>):
	print(<v>greeting<>, <v>name<>)

<v>dict_1<> = {<v>'greeting'<> : <v>'Hi'<>, <v>'name'<> : <v>'John'<>}

<v>say<>(**<v>dict_1<>)<>
@
@ dictionary
@ calling, passing, **kwags
@ arguments, args, parameters, params



### Function - Call - With Sequence

<cb><v>function_1<>(*<v>sequence_1<>)<>

Pass <c><v>sequence_1<><> to the function as it's arguments.
Unpacks the sequence into arguments in order they are declared in the function signature.


Example:

<cb>def <v>say<>(<v>greeting<>, <v>name<>):
	print(<v>greeting<>, <v>name<>)

<v>list_1<> = [<v>'Hi'<>, <v>'John'<>]

<v>say<>(*<v>list_1<>)<>
@
@ list, tuple
@ calling, passing, *args
@ arguments, args, parameters, params



## Function - Function Passing

Assign:

<cb><v>function_variable_1<> = <v>function_1<><>

Call:

<cb><v>function_variable_1<>(<v>...<>)<>

Pass:

<cb><v>function_2<>(<v>function_variable_1<>):<>

Pass Directly:

<cb><v>function_2<>(<v>function_1<>):<>

Can be passed as a value.
@
@ assignment, assigning, call, variable, passing



## Function - Get Name

<cb>= <v>function_1<>.__name__<>


Example:

<cb>def <v>function_1<>():
	return "This is a function."

<v>function_name<> = <v>function_1<>.__name__<>
@
@ __name__



## Function - Inner Functions


### Function - Inner Function - Define

Define:

<cb>def <v>parent_function<>(<v>...<>):

	def <v>inner_function<>(<v>...<>):			<#>#1<>
		<v>...<><>

Call:

<cb>def <v>parent_function<>(<v>...<>):

	<v>...<>

	<v>response_1<> = <v>inner_function<>()<>


\#1  -  Scope - <c><v>inner_function<><> is visible to <c><v>parent_function<><> only.
@
@ new, create, define, nested, outer



### Inner Function - Closure

An inner function has read access to it's parent's variables.
There are in scope due to the function 'closing' over the parent's environment.


Example:

<cb>def <v>parent<>():

	def <v>inner<>():
		print ('value =', <v>value<>)

	<v>value<> = <v>10<>
	<v>inner<>()

<v>parent<>()

<#># Prints 'value = 10'<><>

Here <c><v>value<><> is a non-local variable to <c><v>inner<><>.
@
@ nonlocal, non-local



## Function Decorators
@
@ decorated, decorator-only, decorators-only, decorated-only
@ wrapper, annotations, @decorators



### Decorators - Basics

Define:

<cb>def <v>decorator_1<>(<v>function<>):
	
	def wrapper(*args, **kwargs):
		<v>...<>                              <#># Pre-function Code<>
		<v>function<>(*args, **kwargs)        <#># Function Call<>
		<v>...<>                              <#># Post-function Code<>
		
	return wrapper<>

Use (Decorate):

<cb>@<v>decorator_1<>
def <v>decorated_2<>(<v>arg_1<>, <v>...<>):
	<v>...<><>

Uses:

<cb>decorated_2(<v>arg_1<>, <v>...<>)<>


Example:

<cb><#># Define Decorator:<>

def <v>decorate_before_and_after<>(<v>function<>):
	
	def wrapper(*args, **kwargs):

		print("Before:  " + function.__name__)
		<v>function<>(*args, **kwargs)
		print("After:   " + function.__name__)
		
	return wrapper

<#># Decorate Function:<>

\@<v>decorate_before_and_after<>
def <v>print_message<>(message):
	print("Message:", message)

<#># Call:<>

<v>print_message<>(<v>"This message appears after 'Before' but before 'After'."<>)<>
@
@ examples, \@, summary



### Decorator - Define - No Arguments

<cb>def <v>decorator_1<>(<v>decorated_function<>):

	def <v>wrapper<>():
		<v>...<>                           <#>#1<>
		<v>decorated_function<>()          <#>#2<>
		<v>...<>                           <#>#3<>

	return <v>wrapper<>()<>

When a function is decorated and then called, <c><v>decorated_function<><> will be called thorugh <c><v>wrapper<>()<>.

\#1  <s>-<>  Place pre-function call code here.
\#2  <s>-<>  Calls <c><v>decorated_function<><>.
\#3  <s>-<>  Place post-function call code here.
@
@ new, create, @, no return



### Decorator - Define - Passing Arguments

<cb>def <v>decorator_1<>(<v>decorated_function<>):

	def <v>wrapper<>(*args, **kwargs):             <#>#1<>
		<v>...<>
		<v>decorated_function<>(*args, **kwargs)       <#>#2<>
		<v>...<>

	return <v>wrapper<>()<>


When a function is decorated and then called, <c><v>decorated_function<><> will be called thorugh <c><v>wrapper<>()<>.

\#1  <s>-<>  Captures calling statement's arguments.

\#2  <s>-<>  Calls <c><v>decorated_function<><> and passes arguments.
@
@ new, create
@ arguments, args, parameters, params



### Decorator - Define - Return Result

<cb>def <v>decorator_1<>(<v>decorated_function<>):

	def <v>wrapper<>(*args, **kwargs):
		<v>...<>
		result = <v>decorated_function<>(*args, **kwargs)
		<v>...<>
		return result

	return <v>wrapper<>()<>
@
@ new, create, response, returning, with return, value



### Decorator - Define - With Decorator Arguments

<cb>def <v>decorator_1<>(<v>arg_1<>, <v>arg_2<>):

	def decorator_actual(<v>decorated_function<>)

		def <v>wrapper<>():
			<v>...<>                           <#>#1<>
			<v>decorated_function<>()          <#>#2<>
			<v>...<>                           <#>#3<>

		return <v>wrapper<>()

	return <v>decorator_actual<><>


Passes arguments to the decorator itself.

This uses an outer decorator factory.
Use this decorator factory as the @decorator name.


Example:

<cb>def <v>announce_from<>(<v>name<>):

	def decorator(<v>function<>):

		def function_wrapper():

			<v>function<>()
			print('From', <v>name<>)

		return function_wrapper

	return decorator


\@<v>announce_from<>("your-name-here")
def <v>say_hi<>():
	print("Hi")

<v>say_hi<>()

<#># Prints:
\#
\#    Hi
\#    From your-name-here<><>
@
@ new, create
@ arguments, args, parameters, params



### Decorator - Use

<cb>@<v>decorator_1<>
def <v>decorated_function<>(<v>...<>):
	<v>...<><>

Calls <c><v>decorated_function<><> through <c><v>decorator_1<><>.
@
@ use, assign, annotate, decorate, call



## Lambda

An anonymous function.
All lambdas return a value. Returns are implied.
@
@ lambdas, ->, =>, lambda-only,lambdas-only, lamda



### Lambda - Define

<cb>= lambda <v>arg_1<>, <v>arg_2<>, <v>...<> : <v>expression<><>


Example:

<cb><v>multiply<> = lambda <v>x<>, <v>y<> : <v>x<> * <v>y<>

<v>result<> = <v>multiply<>(2, 3)<>



### Lambda - Define - Alternative

<cb>def <v>lambda_name<>(<v>args_1<>, <v>args_2<>, <v>...<>): return <v>expression<><>

This is using the standard function form to return a 'lambda'.



### Lambda - Closure

A lambda has read access to it's parent's variables through closure.


Example:

<cb>def <v>test<>():

	<v>value<> = <v>10<>        <#># Closed Variable<> 

	<v>multiply_by<> = lambda <v>x<> : <v>x<> * <v>value<>

	print(<v>multiply_by<>(<v>3<>))

<v>test<>()

<#># Prints '30'<><>



## Partial Functions

<cb>from functools import partial

<v>partial_function_1<> = partial(<v>function_1<>, <v>arg_1_value<>)<>

Returns the function with some arguments applied.
Arguments are applied to arguments from first to last.
Call the returned function with additional arguments to make the actual call.

Also Called: Currying


Example:

<cb>def <v>say<>(<v>greeting<>, <v>name<>):
	print(<v>greeting<>, <v>name<>)

<v>say_hi<> = partial(<v>say<>, <v>"Hi"<>)
<v>say_hi<>(<v>"John"<>)<>
@
@ currying, partially applied function, functools.partial(), .partial()



# Classes
@
@ class-only, classes-only



## Standard Class



### Class - Basics

Define:

<cb>class <v>Class1<>:
	<#>"""Class docstring."""<>

	<v>class_variable<> = <v>value<>				<#># Static Variable<>

	def __init__(self, <v>arg_1<>, <v>...<>):		<#># Constructor<>
		self.<v>variable_1<> = <v>arg_1<>
		self._<v>private_variable_2<> = <v>arg_2<>

	def <v>method_1<>(self, <v>arg_1<>, <v>...<>):
		<#>"""Method docstring."""<>
		<v>...<>

	def _<v>private_method_2<>(self, <v>arg_1<>, <v>...<>):
		<v>...<>

	@classmethod						<#># Class Method<>
	def <v>class_method_3<>(cls, <v>arg_1<>, <v>...<>):
		<v>...<>

	@staticmethod						<#># Static Method<>
	def <v>static_method_3<>(<v>arg_1<>, <v>...<>):
		<v>...<><>

Call Class Method:

<cb><v>Class1<>.<v>class_method_3<>(<v>arg_1<>, <v>...<>)<>

Call Static Method:

<cb><v>Class1<>.<v>static_method_4<>(<v>arg_1<>, <v>...<>)<>

Read Static Variable:

<cb><v>value_1<> = <v>Class1<>.<v>class_variable<><>

Set Static Variable:

<cb><v>Class1<>.<v>class_variable<> = <v>value_2<><>

Create Class:

<cb><v>class_1<> = <v>Class1<>(<v>arg_1<>, <v>...<>)<>

Call Instance Method:

<cb><v>class_1<>.<v>method_1<>(<v>arg_1<>, <v>...<>)<>

Read Instance Variable:

<cb><v>value_1<> = <v>Class1<>.<v>variable_1<><>

Set Instance Variable:

<cb><v>Class1<>.<v>variable_1<> = <v>value_2<><>


All class functions and variables are public by default.

Function overloading is NOT supported.
- use arguments default values to solve this.
- use type checking to catch incorrect arguments.

Classes are mutable.
Class methods are stored as attributes and can be monkey patched.

Instance variables must be created in a class function and attached to self.

The <c>self<> argument is required for all class functions.
- <c>self<> is called <v>self<> by convention.
@
@ Examples, cls, summary



### Class - Define

<cb>class <v>Class1<>:
	<v>...<><>

With Constructor:

<cb>class <v>Class1<>:

	 def __init__(self, <v>arg_1<>, <v>...<>):

		self.<v>property_1<> = <v>...<><>

All Options:

<cb>class <v>Class1<>:
	<#>"""Class docstring."""<>

	<v>variable_1<> = <v>value<>					<#># Class Variable / Static Variable<>
	<v>_private_variable_2<> = <v>value<>

	def __init__(self, <v>arg_1<>, <v>...<>):		<#># Constructor<>

		super().__init__()

		self.<v>variable_3<> = <v>arg_1<>			<#># Instance Variable<>
		self._<v>private_variable_2<> = <v>arg_2<>

	def <v>method_1<>(self, <v>arg_1<>, <v>...<>):
		<#>"""Method docstring."""<>
		<v>...<>

	def <v>_private_method_1<>(self, <v>arg_1<>, <v>...<>):
		<v>...<><>
@
@ New, Definition, Create, __init__(), init



### Class - Define - Constructor

<cb>class <v>Class1<>:
	def __init__(self, <v>arg_1<>, <v>...<>):
		<v>...<><>

Define the constructor with the <c>__init__<> method.

Define instance arguments in the constructor.
@
@ Initializer
@ arguments, args, parameters, params, __init__()



### Class - Define - With Inheritance

<cb>class <v>Subclass1<>(<v>Superclass1<>):
	<v>...<><>

Initializing Parent:

<cb>class <v>Subclass1<>(<v>Superclass1<>):

	def __init__(self, <v>...<>):
		super().__init__()
		<v>...<><>

Initializing Parent With Arguments:

<cb>class <v>Subclass1<>(<v>Superclass1<>):

	def __init__(self, <v>...<>):
		super().__init__(<v>arg_1<>, <v>...<>)
		<v>...<><>
@
@ subclass, superclass, super(), __init__()
@ extend


### Class - Define - With Multiple Inheritance

<cb>class <v>Subclass1<>(<v>Superclass1<>, <v>Superclass2<>, <v>...<>):
	<v>...<><>

Priority is from left to right.
<c><v>Superclass1<><>'s members take precedence over other super classes.
@
@ subclass, superclass



### Class - Call Superclass

<cb>super().__init__()<>

<cb>class <v>class1<>(<v>Superclass1<>):

	def __init__(self, <v>...<>):
		super().__init__(<v>arg_1<>, <v>...<>)
<>
@
@ parent, __init__(), super().__init__()



### Class - New Instance

<cb>= <v>Class1<>(<v>arg_1<>, <v>...<>)<>
@
@ new, instantiate, create



### Class - Instance Variable

<cb>class <v>Class1<>:

	def <v>some_method<>(self):

		self.<v>variable_1<> = <v>value<>			<#># Create / Set<>

		= self.<v>variable_1<>				<#># Get<><>

Get:

<cb>= <v>class_1<>.<v>variable_1<><>

Set:

<cb><v>class_1<>.<v>variable_1<> = <v>new_value<><>

Define instance variables in the constructor so they are always available.
Reference instance variable internally in the class with '<b>self.<>' .
Reference instance variable through instance name outside of class.
@
@ define, create



### Class - Instance Method

Define:

<cb>class <v>Class1<>:

	def <v>method_1<>(self, <v>arg_1<>, <v>...<>):
		<v>...<><>

Call Inside Class:

<cb>class <v>Class1<>:

	def <v>...<>(self):

		self.<v>method_1<>(<v>arg_1<>, <v>...<>)<>

Call Outside Class:

<cb><v>class_1<>.<v>method_1<>(<v>arg_1<>, <v>...<>)<>

Reference instance methods internally in the class with '<b>self.<>' .
Reference instance methods externally through the instance name (<v>class_1<> in this case).
@
@ define, create



### Class - Class Variable

Define:

<cb>class <v>Class1<>:
	<v>variable_1<> = <v>value<>					<#># Static Variable<><>

Get:

<cb>= <v>Class1<>.<v>variable_1<><>

Set:

<cb><v>Class1<>.<v>variable_1<> = <v>new_value<><>

Reference class or static variable through it class name.
@
@ Static



### Class - Class Method

Define:

<cb>class <v>Class1<>:

	@classmethod					<#>#1<>
	<v>method_1<>(cls, <v>arg_1<>, <v>...<>):		<#>#2<>
		cls.<v>class_variable<> = <v>value<>
		<v>...<><>

Call:

<cb><v>Class1<>.<v>method_1<>(<v>arg_1<>, <v>...<>)<>


Define with <c>@classmethod<>.
Reference the method using the class name (<c><v>Class1<><> in this case).

This is useful if you need to know exactly what type of class was instantiated.


\#1  <s>-<>  <c>@classmethod<> defines a class method.

\#2  <s>-<>  The class is passed in as <c>cls<>.
@
@ @classmethod, static, cls



### Class - Static Method

Define:

<cb>class <v>Class1<>:

	@staticmethod						<#># Defines Static Method<>
	<v>method_1<>(<v>arg_1<>, <v>...<>):
		<v>...<><>

Call:

<cb><v>Class1<>.<v>method_1<>(<v>arg_1<>, <v>...<>)<>

Define with <c>@staticmethod<>.
Reference through the class name.
Can not update class variables.
@
@ @staticmethod



### Class - Class Method vs Static Method

Class Method:

Use for class level methods than work with the class itself.



Static Method:

Use for utility methods that are related to the class but do not interact with the class.
@
@ @classmethod, @staticmethod
@ versus



### Class - Equals - Is Type or Subtype?

<cb>= isinstance(<v>item_1<>, <v>Class1<>)<>

Returns true if <c><v>item_1<><> is a type or a subtype of <c><v>Class1<><>.
@
@ isinstance(), subclass, isclass, compare, is instance of



### Class - Equals - Is Same Class?

<cb>= type(<v>item_1<>) is <v>Class1<><>

Returns true if <c><v>item_1<><> is the class <c><v>Class1<><>.
Does not match subtypes.
@
@ subclass, isclass. type(), compare



### Class - Equals - Is Same

Implement Method:

<cb>def __eq__(self, <v>other<>):<>

Compare:

<cb>= <v>item1<> == <v>item2<><>

<cb>if <v>item1<> == <v>item2<>:<>


Implement <c>__eq__()<> to allow class instances to be compared with equals (<c>==<>).


Example:

<cb><#># Define Class:<>

class <v>SampleClass<>:

	def __init__(self, <v>value_1<> = None, <v>value_2<> = None):

		self.<v>value_1<> = <v>value_1<>
		self.<v>value_2<> = <v>value_2<>

	def __eq__ (self, <v>other<>):

		if not isinstance(<v>other<>, <v>SampleClass<>):
			return False

		return (self.<v>value_1<> == <v>other<>.<v>value_1<> and
				self.<v>value_2<> == <v>other<>.<v>value_2<>)

<#># Instantiate:<>

<v>item1<> = <v>SampleClass<>(<v>1<>, <v>"one"<>)
<v>item2<> = <v>SampleClass<>(<v>2<>, <v>"two"<>)

<#># Compare:<>

if <v>item1<> == <v>item2<>:
	print("The same.")
else:
	print("Different.")<>
@
@ Instance, __eq__(), ==



### Class - DocString

<cb>class <v>Class1<>:
	<#>"""Class docstring."""<>

	<v>...<><>
@
@ Create, Add, Document, """



### Class - DocString - Read

<cb>= <v>Class1<>.__doc__						<#># From Class<><>

<cb>= <v>class_1<>.__doc__						<#># From Instance<><>
@
@ to, get, retrieve, __doc__()



### Class - self

<cb>class <v>Class1<>:

	def <v>function_1<>(self):

		self.<v>_variable_1<> = <v>...<>
		<v>...<> = self.<v>_variable_1<>

		self.<v>function_1<>()<>


<c>self<> is the current instance of the class.

Reference any instance variables or functions using <c>self<>.
<c>self<> must be the first argument in any non static functions.
Do not pass <c>self<> to a non static function. It will be passed automatically.
@
@ this, instance, self-only, this-only, self.



### Class - To String

<cb>class <v>Class1<>:
	<v>...<>
	def __repr__(self):
		return <v>string_representing_class<><>

<cb>= <v>class_1<>__repr__())<>

<cb>= repr(<v>class_1<>)							<#># Equivalent to <c>.__repr()<><><>

Override <c>__repr__<> to create class string.
@
@ Repr, tostring, __repr__()



## Abstract Class
@
@ Interfaces



### Abstract Class - Define

<cb>from abc import ABC, abstractmethod

class <v>AbstractClass1<>(ABC):

	@abstractmethod
	def <v>abstract_method_1<>(self):
		pass<>
@
@ abc, @abstractmethod, interface, (ABC), abc.abc, abc.abstractmethod



### Abstract Class - Use

<cb>class <v>Subclass1<>(<v>AbstractClass1<>):

	def <v>abstract_method_1<>(self):		<#># Implement Abstract Method<>
		<v>...<><>



## Class Properties

Defines class functions as if they were class variables.
Use to encapsulate mutation of internal variables.
@
@ getter, setter, @property, method as, property, to, into, function as



### Class Property - Define

<cb>@property
def <v>method_name<>(self):<>

Usage:

<cb>class <v>Class1<>:

	def __init__(self):

		self.<v>_variable_1<> = <v>value<>

	@property
	def <v>variable_1<>(self):

		return self.<v>_variable_1<>

	@<v>variable_1<>.setter
	def <v>variable_1<>(self, <v>arg_1<>):

		self.<v>_variable_1<> = <v>arg_1<><>


Defines a method to work like a property (instance variable).

The decorator <c>@property<> does not need to be imported.
@
@ @property, .setter



### Class Property - Use

<cb><v>class_1<> = <v>Class1<>()

<v>class_1<>.<v>variable_1<> = <v>value_1<>		<#>#1<>
<v>value_2<> = <v>class_1<>.<v>variable_1<><>

\#1  -  Treat like an instance variable.
@
@ access, get, set


## Class Introspection



### Class - Name

<cb>= <v>Class1<>.__name__						<#># From Class<><>

<cb>= type(<v>class_1<>).__name__				<#># From Instance<><>
@
@ __name__, type()



### Class - Attribute - Exists?

<cb>= hasattr(<v>class_1<>, '<v>attribute_name<>')<>
@
@ hasattr(), member



### Class - Attribute - Get

<cb>= getattr(<v>class_1<>, '<v>attribute_name<>')<>
@
@ getattr(), member



### Class - Attribute - Set

<cb>setattr(<v>class_1<>, '<v>attribute_name<>', <v>value<>)<>

Creates or updates a class attribute.

Access using <c><v>class_1<>.<v>attribute_name<><>
@
@ setattr(), member, create, add, new



### Class - Attribute - Names

<cb>= <v>class_1<>.__dict__.keys()<>

<cb>= list(<v>class_1<>.__dict__.keys())			<#># As List<><>
@
@ __dict__, .keys()



### Class - Attributes - To Dict

<cb>= <v>instance_1<>.__dict__<>
@
@ __dict__, members



## Nested Class
@
@ Inner


### Nested Class - Basics

<cb>class <v>Outer<>:

	def __init__(self):
		self.<v>name<> = "Outer Class"
		self.<v>inner<> = self.<v>Inner<>()

	def <v>get_name<>(self):
		return self.<v>name<>

	class <v>Inner<>:

		def __init__(self):
			self.<v>name<> = "Inner Class"

		def <v>get_name<>(self):
			return self.<v>name<>

<v>outer<> = <v>Outer<>()

print("outer.name             ", <v>outer<>.<v>name<>)
print("outer.get_name()       ", <v>outer<>.<v>get_name<>())
print("outer.inner.name       ", <v>outer<>.<v>inner<>.<v>name<>)
print("outer.inner.get_name() ", <v>outer<>.<v>inner<>.<v>get_name<>())

<#># Prints:
\#
\# outer.name              Outer Class
\# outer.get_name()        Outer Class
\# outer.inner.name        Inner Class
\# outer.inner.get_name()  Inner Class<><>
@
@ summary



### Nested Class - Define

<cb>class <v>Outer<>:

    class <v>Inner<>:<>

<cb>class <v>Outer<>:

    def __init__(self):
        <v>...<>

    class <v>Inner<>:

        def __init__(self):
            <v>...<><>



### Nested Class - Instantiate From Parent

<cb>= self.<v>Inner<>()<>

<cb>class <v>Outer<>:

    def __init__(self):
        self.<v>inner<> = self.<v>Inner<>()

    class <v>Inner<>:
		<v>...<><>



### Nested Class - Instantiate Outside Parent

<cb>= <v>Outer<>.<v>Inner<>()<>


### Nested Class - Reference From Parent

<cb>= <v>self<>.<v>inner<><>

<cb>= <v>self<>.<v>inner<>.<v>function_1<>()
= <v>self<>.<v>inner<>.<v>property_1<><>


### Nested Class - Reference Outside Parent

<cb>= <v>outer<>.<v>inner<><>

<cb>= <v>outer<>.<v>inner<>.<v>function_1<>()
= <v>outer<>.<v>inner<>.<v>property_1<><>



## Class Extras



### Class - Monkey Patch

<cb><v>Class1<>.<v>method_to_patch<> = <v>patch_1<><>

<cb><#># Class to Patch:<>

class <v>Class1<>:
    def <v>method_to_patch<>(self):
        <v>...<>

<v>class_1<> = <v>Class1<>()


<#># Assign Patch:<>

def <v>patch_1<>(self):
    <v>...<>

<v>Class1<>.<v>method_to_patch<> = <v>patch_1<>

<v>class_1<>.<v>method_to_patch<>()<>


Changes the behaviour of a method at runtime.
Applies the patch to the class, not the instance.
This will affect all instances of the class, current and future.


Example:

<cb>class <v>Class1<>:
    def <v>print_message<>(self):
        print("Original Message")

def <v>patch_1<>(self):
    print("Patched Message")

<v>class_1<> = <v>Class1<>()
<v>class_1<>.print_message()

<v>Class1<>.print_message = patch_1
<v>class_1<>.print_message()

<#># Prints:
\#
\# Original Message
\# Patched Message<><>



### Class - View Help, Structure

<cb>help(<v>Class1<>)<>

Prints docstrings, methods, everything about the class.
@
@ help()



### Class - Operator - in

<cb>def <v>Class1<>:

	def __contains__(self, <v>key<>)
		<v>...<><>

<cb>if <v>item_1<> in <c>class_1<>:					<#># Using with <c>in<><>
	<v>...<><>

Override <c>__contains__<> to use class with <c>in<> operator.
Return true if <c><v>key<><> is in the class.
@
@ __contains__(), __in__(), contains



# Iterable, Iterator
@
@ iterable-only, iterator-only, iter-only, iterating, iterators
@ make


## Iterable



### Iterable - Define

<cb>def <v>IterableClass1<>:

    def __iter__(self):                 <#>#1<>
        return <v>iterator<>                    <#>#2<><>


Defines a class as iterable.


\#1  <s>-<>  Implement <c>__iter__()<> to make the class iterable.

\#2  <s>-<>  Return an iterator for the class data.


Example:

<cb><#># Define:<>

class <v>Integers<>:

    def __init__(self, <v>max<>):
        self.integers = range(1, <v>max<> + 1)

    def __iter__(self):
        return iter(self.integers)


<#># Use:<>

<v>integers_1<> = <v>Integers<>(<v>3<>)

for <v>integer<> in <v>integers_1<>:
    print(<v>integer<>)

<#># Prints:
\#
\# 1
\# 2
\# 3<><>
@
@ create, define, __iter__(), 



### Iterable - Define - Self Iterable

<cb>def <v>IterableIteratorClass1<>:

    def __iter__(self):                 <#>#1<>
        return self

    def __next__(self):                 <#>#2<>

        If <v>at_the_end<>:
            raise StopIteration         <#>#3<>
        else:
            return <v>next_item<>           <#>#4<><>


This class is both an iterator and an iterable.


\#1, #2  <s>-<>  Implement <c>__iter__()<> and <c>__next__()<> to make this both an iterabale and an iterator.

\#3  <s>-<>  Raise <c>StopIteration<> to indicate iterating is complete.

\#4  <s>-<>  Return the next item in the iteration with <c>__next__()<>.
@
@ create, define, iterator, iterable, __iter__(), __next__()



### Iterable - From Dict

<cb>def __iter__(self):
    = iter(<v>dict_1<>.values())<>


Returns an iterable list.


Example:

<cb>class <v>Integers<>:
    def __init__(self):
        self.<v>dict_values<> = {<v>1<>:<v>1<>, <v>2<>:<v>2<>, <v>3<>:<v>3<>}
    def __iter__(self):
        return iter(self.<v>dict_values<>.values())

<v>ints_1<> = <v>Integers<>()

for <v>item<> in <v>ints_1<>:
    print (<v>item<>)

<#># Prints:
\#
\# 1
\# 2
\# 3<><>
@
@ iter()



### Iterable - From List

<cb>def __iter__(self):
    = iter(<v>list_1<>)<>


Returns an iterable list.


Example:

<cb>class <v>Integers<>:
    def __init__(self):
        self.<v>values<> = [<v>1<>, <v>2<>, <v>3<>]
    def __iter__(self):
        return iter(self.<v>values<>)

<v>ints_1<> = <v>Integers<>()

for <v>item<> in <v>ints_1<>:
    print (<v>item<>)

<#># Prints:
\#
\# 1
\# 2
\# 3<><>
@
@ iter()


## Iterator


### Iterator - Define

<cb>class <v>Iterator1<>:

    def __next__(self):                 <#>#1<>

        If <v>at_the_end<>:
            raise StopIteration         <#>#2<>
        else:
            return <v>next_item<>           <#>#3<><>


Defines an iterator class.


\#1  <s>-<>  Implement <c>__next__()<> to make this an iterator.

\#2  <s>-<>  Raise <c>StopIteration<> to indicate iterating is complete.

\#3  <s>-<>  Return the next item in the iteration with <c>__next__()<>.


Example:

<cb><#># Define:<>

class <v>ListIterator<>:

    def __init__(self, <v>list<>):

        self.<v>list<> = <v>list<>
        self.<v>index<> = -1

    def __next__(self):

        self.<v>index<> += 1

        if self.<v>index<> == len(self.<v>list<>):
            raise StopIteration()

        return self.<v>list<>[self.<v>index<>]


<#># Use:<>

<v>iterator<> = <v>ListIterator<>([1, 2, 3])

try:
    while (<v>value<> := next(<v>iterator<>)):
        print(<v>value<>)
except StopIteration:
    print("Done.")<>
@
@ create, define, __next__()



### Iterator - Get Next

<cb>= next(<v>iterator_1<>)                     <#>#1<><>

or

<cb>= next(<v>iterator_1<>, <v>default_value<>)     <#>#2<><>


Returns the next value from an iterator.


\#1  <s>-<>  When no more elements, raises <c>StopIteration<>.

\#2  <s>-<>  When no more elements, returns <c><v>default_value<><>.



Example:

<cb><v>values<> = iter([1, 2, 3])

while <v>value<> := next(<v>values<>):
    print(<v>value<>)<>
@
@ Element, Item, Value, next()



# Generators

A generator is a function wrapped in an iterable.
The function should act like an iterator (eg: returns results with <c>yield<>).
@
@ generate



### Generator Expression

<cb>= (<v>expression<> for <v>item<> in <v>sequence_1<>)<>

<cb>= (<v>expression<> for <v>item<> in <v>sequence_1<> if <v>condition<>)<>

Returns: <c>generator<>


Similar to a list comprehension but are evaluated lazily.
Lazy iterators - Values are evaluated and returned one at a time, and only when requested.


Examples:

<cb><v>list_1<> = [1, 2, 3, 4, 5]

<v>generator<> = (<v>i<> * 2 for <v>i<> in <v>list_1<>)

print(list(generator))							<#># Prints [2, 4, 6, 8, 10]<><>

<cb><v>list_1<> = [1, 2, 3, 4, 5]

<v>generator<> = (<v>i<> * 2 for <v>i<> in <v>list_1<> if <v>i<> \<= 3)

print(list(generator))							<#># Prints [2, 4, 6]<><>
@
@ for in if ()
@ Filter, list, sequence



### Generator Expression - Get Next

<cb>= next(<v>generator_1<>)<>
@
@ next()



### Generator Expression - To List

<cb>= list(<v>generator_1<>)<>
@
@ from, convert, conversion, list()



### Yield

<cb>yield <v>return_value<><>

<cb>def <v>some_function<>():					<#>#1<>

	for <v>list_value<> in <v>list_1<>:
		yield <v>list_value<>				<#>#2<>


for <v>value<> in <v>some_function()<>:			<#>#3<>
	<v>...<><>

Returns: <c>generator<>

\#1  <s>-<>  <c>yield<> must be defined inside a function.

\#2  <s>-<>  <c>yield<> temporarily suspends operation and returns <c><v>list_value<><>.

\#3  <s>-<>  The function returns a generator that can be used to iterate over the yield values.


<c>yield<> turns a function into a generator.

The generator returns a result every time yield is executed, suspending the function.
Execution continues when the generator is called again.


Example:

<cb><#>Define:<>

from math import factorial

def <v>factorial_series<>(<v>n<>):
	for <v>i<> in range (<v>n<> + 1):
		yield factorial(<v>i<>)


<#>Use:<>

for <v>value<> in <v>factorial_series<>(4):
	print(<v>value<>)<>



### Yield From

<cb>yield from <v>generator_1<><>

<cb>def <v>some_function<>():
	yield from <v>generator_1<><>


Short For:

<cb>[yield <v>item<> for <v>item<> in <v>generator_1<>]<>


Allows the function to delegate part of its generator results to a 2nd generator.

Must be inside a function.
This is very useful when using recursion.
@
@ delegate, subgenerator, subgenerate, recursion, recursive, to


# Packages, Modules
@
@ packages-only, modules-only, module-only



### Package Directory - Define

Create File Named:

<cb>__init__.py<>

Create the file in the subdirectory that contains modules.

Package directories are typically defined with the presence of '<c>__init__.py<>'.
This file is not required as of Python 3.3.
<c>__init__.py<> can be empty.
This file is executed when the package is imported.
@
@ __init__.py



### Package Directory - Name

The package name is the directory name.



### Module - Name

<cb>= __name__<>

Returns the name of the current module (name of the python file without the extension).

<c>'__main__':<>
If the module is the starting module of the application, __name__ will be '<c>__main__<>'.
@
@ __name__, __main__



### Import - Module / Package

Import:

<cb>import <v>module_1<><>

<cb>import <v>package_1<>.<v>subpackage_1<>.<v>module_1<><>

<cb>from <v>package_1<>.<v>subpackage_1<> import <v>module_1<><>

<cb>from <v>package_1<>.<v>subpackage_1<> import <v>module_1<> as <v>alias<><>


Use:

<cb><v>module_1<>.<v>item_1<><v>...<><>


Imports a module or package into the current namespace.

This uses absolute imports and must contain the full package path to the project root.
@
@ namespace, from, as



### Import - Module / Package - Relative Import

Relative To Parent:

<cb>from .<v>module<> import <v>name<><>

Relative To Grandparent:

<cb>from ..<v>module<> import <v>name<><>

Parent of Current Package:

<cb>from .. import <v>module<><>


Imports a module relative to the current module.

Only available with <c>from <v>x<> import <v>y<><> syntax.
Imports must be within <c>toplevel_package<> only. Not other packages.
@
@ from, import, namespace, ...



### Import - Package - __init__.py

The file <c>__init__.py<> is executed when a package is imported as a module.

<cb>import <v>package_1<><>
@
@ namespace



### Import - Class / Function

<cb>from <v>package_1<>.<v>module_1<> import <v>Class1<><>

<cb>from <v>package_1<>.<v>module_1<> import <v>function_1<><>
@
@ namespace



# Math Functions
@
@ math-only, maths-only, manths, mathematics



## Standard



### Absolute Value

<cb>= abs(<v>value<>)<>
@
@ abs()



### Modulo

<cb>= <v>a<> % <v>b<><>

<cb><v>a<> %= <v>b<><>


Returns the remainder after dividing <c><v>a<><> by <c><v>b<><>.


Example:

<cb><v>modulus<> = <v>7<> % <v>3<>							<#># Returns Modulus 1<><>
@
@ Modulus, Remainder, %, %=



## Math Package



### Factorial

<cb>from math import factorial

= factorial(<v>n<>)<>
@
@ math.factorial(), .factorial()



## Power, Logarithm
@
@ Package, Library



### Exponent (exp)

<cb>from math import exp

= exp(<v>x<>)<>
@
@ math.exp(), .exp()


Returns e raised to the power of <v>x<>.
@
@ exp-only, exponent-only



### Exponent Minus 1 (expm1)

<cb>from math import expm1

= expm1(<v>x<>)<>

Returns e raised to the power of <v>x<> minus 1.
@
@ exponent - one, subtract one
@ exp-only, exponent-only, math.expm1, .expm1()




### Log

Natural Log

<cb>from math import log

= log(<v>x<>)<>

Log For Specific Base:

<cb>from math import log

= log(<v>x<>, <v>base<>)<>

Uses <v>base<> as the base if given.
Otherwise it uses the natural log (base e).
@
@ log-only, logarithm-only, math.log, .log(), ln(), natural



### Log 10

<cb>from math import log10

= log10(<v>x<>)<>
@
@ log 10, base 10, math.log10(), .log10()
@ log-only, logarithm-only




### Log 2

<cb>from math import log2

= log2(<v>x<>)<>
@
@ log2, base 2, math.log2(), .log2()
@ log-only, logarithm-only




### Log 1 Plus (log1p)

<cb>from math import log1p

= log1p(<v>x<>)<>

Equivalent to <c>log(1 + <v>x<>)<>.

Uses the natural log (base e).
@
@ log one +
@ log-only, logarithm-only, math.log1p(), .log1p()



### Power

<cb>= <v>x<> ** <v>y<><>

Or

<cb>= pow(<v>x<>, <v>y<>)<>


Returns <c><v>x<><> to the power of <c><v>y<><>.

<b>pow()<> is a standard function.  No import required.
@
@ inverse logarithm, power of, pow(), **



### Square

<cb>= <v>x<> ** 2<>

Or

<cb>= pow(<v>x<>, 2)<>


<b>pow()<> is a standard function.  No import required.
@
@ **, power of, pow()



### Square Root

<cb>from math import sqrt

= sqrt(<v>x<>)<>
@
@ math.sqrt, .sqrt()



## Rounding



### Round

<cb>= round(<v>value<>)<>

<cb>= round(<v>value<>, <v>decimals<>)<>


Rounds up or down.


Example:

<cb><v>rounded_1<> = round(<v>1.5<>)					<#># Returns 1.0<><>	

<cb><v>rounded_1<> = round(<v>1.6<>)					<#># Returns 2.0<><>

<cb><v>rounded_1<> = round(<v>1.56<>, <v>1<>)				<#># Returns 1.6<><>
@
@ decimals, digits, round()



### Round To Floor

<cb>from math import floor

<v>floor_1<> = floor(<v>value_1<>)<>

Always rounds downwards (e.g. -1.5 rounds to -2.0).


Examples:

<cb>from math import floor

<v>rounded_1<> = floor(<v>1.6<>)					<#># Returns 1.0<><>

<cb><v>rounded_1<> = floor(<v>-1.6<>)					<#># Returns -2.0<><>
@
@ package, library, math.floor(), .floor(), down



### Round To 0

<cb>= int(<v>value<>)<>


Rounds to the integer nearest to 0.


Examples:

<cb><v>rounded_1<> = int(<v>1.6<>)					<#># Returns 1<><>

<cb><v>rounded_1<> = int(<v>-1.6<>)					<#># Returns -1<><>
@
@ int(), down



### Round To Ceiling

<cb>from math import ceil

= ceil(<v>value<>)<>

Always rounds upwards (e.g. -1.5 rounds to -1.0).


Examples:

<cb>from math import ceil

<v>rounded_1<> = ceil(<v>1.6<>)					<#># Returns 2.0<><>

<cb><v>rounded_1<> = ceil(<v>-1.6<>)					<#># Returns -1.0<><>
@
@ ceiling, math.ceil(), .ceil(), up
@ package, library



## Trigonometry
@ 
@ Trigonometric, Package, Library


### Arccosine

<cb>from math import acos

= acos(<v>value<>)<>


Returns: <c>float<> (radians)

<c>-1 \<= <v>value<> \<= 0<>
<c> 0 \<= <v>result<> \<= pi<>
@
@ math.acos(), .acos(), arc cosine, inverse



### Arcsine

<cb>from math import asin

= asin(<v>value<>)<>


Returns: <c>float<> (radians)

<c>-1 \<= <v>value<> \<= 0<>
<c>-pi/2 \<= <v>result<> \<= pi/2<>
@
@ math.asin(), .asin(), arc sine, inverse



### Arctan

<cb>from math import atan

= atan(<v>value<>)<>


Returns: <c>float<> (radians)

<c>-pi/2 \<= <v>result<> \<= pi/2<>
@
@ arc tangent, math.atan(), .atan(), arc tan, inverse



### Cosine

<cb>from math import cos

= cos(<v>radians_1<>)<>


Returns: <c>float<> (radians)

<c>-1 \<= <v>value<> \<= 0<>
<c>0 \<= <v>result<> \<= pi<>
@
@ math.cos(), .cos()


### Sine

<cb>from math import sin

= sin(<v>radians_1<>)<>


Returns: <c>float<> (radians)

<c>-1 \<= <v>value<> \<= 0<>
<c>-pi/2 \<= <v>result<> \<= pi/2<>
@
@ math.sin(), .sin()



### Tan

<cb>from math import tan

= tan(<v>radians_1<>)<>


Returns: <c>float<> (radians)

<c>-pi/2 \<= <v>result<> \<= pi/2<>
@
@ tangent, math.tan(), .tan()



### Degrees To Radians

<cb>from math import radians

= radians(<v>degrees_1<>)<>
@
@ converting, conversion, from
@ math.radians(), rads



### Radians To Degrees

<cb>from math import degrees

= degrees(<v>radians_1<>)<>
@
@ converting, conversion, from
@ math.degrees(), .degrees(), rads



## Math Constants
@
@ Package, Library



### Constant - Exponential Constant

<cb>from math import e

= e<>

Euler's Number

Returns 2.718281828459045.
@
@ math.e, euler's number, eulers number



### Constant - Pi

<cb>from math import pi

= pi<>

π or 3.141592653589793
@
@ math.pi, trigonometry



### Constant - Tau

<cb>from math import tau

= tau<>

Returns 2π or 6.283185.
@
@ math.tau



### Constant - Infinity

<cb>from math import inf

= inf<>

<cb>= float('inf')<>

These are equivalent.

Positive infinity.
@
@ math.inf



### Constant - Not a Number (NAN)

<cb>from math import nan

= nan<>

Equivalent To:

<cb>= float('nan')<>


Returns: <c>float<>
@
@ math.nan, float, isnan



# Standard Functions

Built in functions in Python
@
@ std


### Hash

<cb>= hash(<v>value<>)<>

Returns: <c>int<>


Example:

<cb><v>hash_1<> = hash("The quick brown fox jumps over the lazy dog")

<#># Returns -7136537410058541255<><>
@
@ hashes, hashing, create, new, hash-only, hash()



## JSON Functions
@
@ json-only



### Json String - From JSON String

<cb>from json import loads

<v>data_1<> = loads(<v>json_string<>)<>


Converts a json string into a python object made up of lists, dicts and strings.

The s in loads stands for string.
@
@ parse, convert, from string, json.loads(), .loads()
@ convert, conversion, dict, list



### Json String - To JSON String

<cb>from json import dumps

<v>json_string<> = dumps(<v>data_1<>)<>


Converts data into a json string.

The s in dumps stands for string.
@
@ parse, from, to string, json.dumps(), .dumps()
@ convert, conversion



### Json String - To Formatted JSON String

<cb>from json import dumps

<v>json_string<> = dumps(<v>data_1<>, indent = 4)<>


Converts data into a formatted json string.


Example:

<cb>from json import dumps

<v>json<> = {"id": 0, "name": "Item Name"}
<v>formatted<> = dumps(<v>json<>, indent = 4)

print(<v>formatted<>)

<#># Prints:
\#
\# {
\#     "id": 0,
\#     "name": "Item Name"
\# }<><>
@
@ parse, from, to string, json.dumps(), .dumps()
@ convert, conversion, indented



### Json File - From JSON File

<cb>from json import load

with open(<v>file_name<>,'r') as <v>file<>:
    <v>data_1<> = load(<v>file<>)<>

Converts a json file into a python object made up of lists, dicts and strings.
@
@ parse, convert, from string, json.load(), .load()
@ convert, conversion



### Json File - To JSON File

<cb>from json import dump

with open(<v>file_name<>, 'w') as file:
	dump(<v>data_1<>, <v>file<>)<>
@
@ parse, from, to string, json.dump(), .dump()
@ convert, conversion



### Json - Custom Encoder

<cb>from json import JSONEncoder

class <v>ItemEncoder<>(JSONEncoder):

    def default(self, <v>value<>):
        if type(<v>value<>) is not <v>ItemType<>:
            return super().default(<v>value<>)

        return <v>...conver item to json...<>


json.dump(<v>data<>, cls = <v>ItemEncoder<>)<>



To create a custom json encoder, create a class inheriting from <c>JSONEncoder<> and override the <c>default()<> method.
@
@ json.jsonencoder, jsonencoder, default()


## Random

Creates pseudo-random numbers.
@
@ randomize, rnd
@ generate, create, new, generator
@ random-only



### Random Boolean

<cb>= choice([True, False])<>

Usage:

<cb>from random import choice

<v>random_1<> = choice([True, False])<>
@
@ choice, choose, pick, random.choice(), .choice()



### Random Character

<cb>= choice(<v>letters_string<>)<>

Usage:

<cb>from random import choice

<v>random_1<> = choice(<v>letters_string<>)<>

Returns a single random character from <v>letters_string<>.


Example:

<cb>from random import choice

<v>next<> = choice(<v>'abcde'<>)

print(<v>next<>)

<#># Prints: 'd'<><>
@
@ choice, choose, pick, random.choice(), .choice()



### Random Float - Between 0 and 1

<cb>= random()<>

Usage:

<cb>from random import random

= random()<>

Returns: <c>float  (0.0 \<= x \< 1.0)<>


Returns a random number between 0 and 1, excluding 1 itself.


Example:

<cb>from random import random

<v>next<> = random()

print(<v>next<>)

<#># Prints: 0.4748924784779134<><>
@
@ number, .uniform(), random.random(), .random()



### Random Float - Between Min to Max

<cb>= uniform(<v>min<>, <v>max<>)<>

Usage:

<cb>from random import uniform

<v>random_2<> = uniform(<v>min<>, <v>max<>)<>

Returns: <c>float  (<v>min<> \<= x \< <v>max<>)<>


Returns a random number between <c>min<> and <c>max<>, excluding <c>max<> itself.


Example:

<cb>from random import uniform

<v>random_float<> = uniform(<v>1.0<>, <v>5.0<>)	<#># Returns 1.0 \<= x \< 5.0<><>
@
@ number, random.uniform(), .uniform()



### Random Integer

<cb>= randrange(<v>max_plus_1<>)<>

Usage:

<cb>from random import randrange

= randrange(<v>max_plus_1<>)
= randrange(<v>min<>, <v>max_plus_1<>, <v>step<>)<>

Returns: <c>int  (0 \<= x \< <v>max_plus_1<>)<>


Returns a random integer value.


Example:

<cb>from random import randrange

<v>next<> = randrange(<v>100<>)

print(<v>next<>)

<#># Prints: 17<><>
@
@ number, random.randrange(), .randrange(), step, minimum, range



### Random Integer - Between Min to Max

<cb>randint(<v>min<>, <v>max<>)<>

Usage:

<cb>from random import randint

= randint(<v>min<>, <v>max<>)<>

Returns: <c>int (<v>min<> \<= x \< <c>max<>)<>


Returns a random integer value.

The range is from <c>min<> to <c>max<> inclusive.


Example:

<cb>from random import randint

<v>next<> = randint(<v>100<>, <v>200<>)

print(<v>next<>)

<#># Prints: 180<><>
@
@ number, random.randint(), .randint()



### Random - From Sequence

Choose 1 Value:

<cb>= sample(<v>sequence_1<>, 1)[0]<>

Choose n Values:

<cb>= sample(<v>sequence_1<>, <v>n<>)<>

Usage

<cb>from random import sample

= sample(<v>sequence_1<>, 1)[0]
= sample(<v>sequence_1<>, <v>n<>)<>

Returns: List of Items


Return one or more items from <c><v>sequence_1<><>.
@
@ list, tuple, pick, choose, item, element
@ random.sample(), .sample()



### Random - Set Seed

<cb>seed(<v>seed_value<>)<>

Usage:

<cb>from random import seed

seed(<v>seed_value<>)<>


Sets the seed value for all following random numbers.


Example:

<cb>from random import seed, randrange

seed(<v>999<>)

print('next', randrange(<v>100<>))
print('next', randrange(<v>100<>))

<#># Prints:
\#
\#    next 86
\#    next 10<><>
@
@ random.seed(), .seed()



## Range

<cb>= range(<v>max_plus_1<>)<>

<cb>= range(<v>min<>, <v>max_plus_1<>)<>

<cb>= range(<v>min<>, <v>max_plus_1<>, <v>step<>)<>

Type: <c>range<>


Range is an immutable sequence of integers.

The integers start with <c><v>min<><> and end with the value before <c><v>max_plus_1<><>.
<c><v>min<><> defaults to 0.
Technically <c>range<> is a class of immutable iterable objects.
Range can be used anywhere a sequence can be used.


Examples:

<cb><v>range_1<> = range(<v>4<>)						<#># Returns 0, 1, 2, 3<>
<v>range_2<> = range(<v>2<>, <v>4<>)					<#># Returns 2, 3<>
<v>range_3<> = range(<v>1<>, <v>11<>, <v>5<>)				<#># Returns 1, 5, 10<><>
@
@ step, range(), new, create



## Range - Float Range

Use Function:

<cb>def float_range(<v>min<>, <v>max<> = None, <v>step<> = 1):
    if <v>max<> is None:
        <v>min<>, <v>max<> = 0, min
    <v>value<> = <v>min<>
    while <v>value<> \< <v>max<>:
        yield <v>value<>
        <v>value<> += <v>step<><>

Usage:

<cb>= float_range(<v>max<>)
= float_range(<v>min<>, <v>max<>)
= float_range(<v>min<>, <v>max<>, <v>step<>)<>

Type: <c>range<>


There is no built in range for float.
Use the function declared here.

Returns a range of float values from <c>min<> to less than <c>max<>.


Examples:

<cb>def float_range(<v>min<>, <v>max<> = None, <v>step<> = 1):
    if <v>max<> is None:
        <v>min<>, <v>max<> = 0, min
    <v>value<> = <v>min<>
    while <v>value<> \< <v>max<>:
        yield <v>value<>
        <v>value<> += <v>step<>

for <v>value<> in float_range(1.0, 3.0, 0.5):
    print(<v>value<>)

<#># Prints:
\#
\# 1.0
\# 1.5
\# 2.0
\# 2.5<><>
@
@ step, new, create, floatrange(), float_range()



## UUID

<cb>import uuid 
  
<v>uuid_1<> = uuid.uuid1()<>

Returns: <c>UUID<>


Yes, there is a '1' in the function name '<c>.uuid1()<>'. Why? I've no idea.


Example:

<cb>import uuid 
  
<v>uuid_1<> = uuid.uuid1()

<v>uuid_bytes<> = <v>uuid_1<>.bytes		<#># b'\x03\xeamdJ\xc2\x11\xeb\xa9\xdd\xac\xdeH\x00\x11"'<>
<v>uuid_hex<> = <v>uuid_1<>.hex			<#># 03ea6d644ac211eba9ddacde48001122<>
<v>uuid_int<> = <v>uuid_1<>.int			<#># 5204900180851453705537495610857361698<><>
@
@ new, create, uuid-only, bytes, binary, hex, hexadecimal, uuid.uuid1(), .uuid1()



# Regular Expressions
@
@ regex, regexpression, expressions, regex-only, regular-expressions-only, patterns


## Regular Expression - Functions
@
@ string, strings, text


### Regular Expressions - Find

<cb>= search(<v>match_pattern<>, <v>string_to_search<>)<>

Usage:

<cb>from re import search

<v>match<> = search(<v>match_pattern<>, <v>string_to_search<>)
<v>match_text<> = <v>match<>.group()<>

<c>.search()<>   Returns:   <c>re.Match<> | <c>None<>
<c>.group() <>   Returns:   <c>str<>


Returns the first match in a string.

Returns <c>None<> if no match found.


Example:

<cb>from re import search

<v>string_1<> = "<v>123 abc 789<>"
<v>match<> = search(r"<v>[a-zA-Z]+<>", <v>string_1<>)		<#># Find the letters in the string.<>

<v>letters_1<> = <v>match<>.group()
<#># Returns "abc"<>

<v>letters_2<> = <v>string_1<>[<v>match<>.start():<v>match<>.end()]
<#># Returns "abc"<><>
@
@ get, match, exists, .search(), re.search(), first



### Regular Expressions - Find All

<cb>= findall(<v>match_pattern<>, <v>string_to_search<>)<>

Usage:

<cb>from re import findall

<v>matches<> = findall(<v>match_pattern<>, <v>string_to_search<>)<>

Returrns: <c>list[str]<>


Returns a list of all the matches.


Example:

<cb>from re import findall

<v>string_1<> = "<v>123 abc 456 def 789<>"
<v>matches<> = findall(r"<v>[a-zA-Z]+<>", <v>string_1<>)

<#># Returns ["abc", "def"]<><>
@
@ get, match, find, re.findall(), .findall()



### Regular Expressions - Match All

<cb>= fullmatch(<v>match_pattern<>, <v>string_1<>)<>

Usage:

<cb>from re import fullmatch

= fullmatch(<v>match_pattern<>, <v>string_1<>)
<v>match_text<> = <v>match<>.group()<>

<c>.fullmatch()<>   Returns:   <c>re.Match<> | <c>None<>
<c>.group()    <>   Returns:   <c>str<>


Returns a match if the pattern matches the complete string.


Otherwise returns None.


Example:

<cb>from re import fullmatch

<v>string_1<> = "1234"

match = fullmatch(r"\\d{4}", <v>string_1<>)

if match:
	print ("got a match")
else:
	print ("not a match")

<#>Prints: got a match<><>

<cb>from re import fullmatch

<v>string_1<> = "1234"

match = fullmatch(r"\\d{3}", <v>string_1<>)

if match:
	print ("got a match")
else:
	print ("not a match")

<#>Prints: not a match<><>
@
@ Matches, full, complete, entire
@ re.fullmatch(), .fullmatch(), .matchall(), re.matchall()



### Regular Expressions - Match Start

<cb>= match(<v>match_pattern<>, <v>string_1<>)<>

Usage:

<cb>from re import match

= match(<v>match_pattern<>, <v>string_1<>)
<v>match_text<> = <v>match<>.group()<>

<c>.match()<>   Returns:   <c>re.Match<> | <c>None<>
<c>.group()<>   Returns:   <c>str<>


Returns a match if the string starts with the given pattern.


Returns <c>re.Match<> object if <c><v>string_1<><> starts with <c><v>match_pattern<><>.
Otherwise returns None.


Example:

<cb>from re import match

<v>string_1<> = "123abc"

match = match(r"\\d{3}", <v>string_1<>)

if match:
	print ("got a match")
else:
	print ("not a match")

<#>Prints: got a match<><>
@
@ starts with
@ Matches, re.match(), .match(), re.matchstart(), .matchstart()



### Regular Expressions - Replace

<cb>= sub(<v>match_pattern<>, <v>replacement<>, <v>string_to_update<>)<>

Usage:

<cb>from re import sub

<v>string_2<> = sub(<v>match_pattern<>, <v>replacement<>, <v>string_to_update<>)
<v>string_2<> = sub(<v>match_pattern<>, <v>replacement<>, <v>string_to_update<>, <v>split_count<>)<>

Returns: <c>str<>


Returns a new string with all matches replaced.

<c>sub<> is short for substitute.


Example:

<cb>from re import sub

<v>original<> = "<v>ab 12 cd 345<>"
<v>updated<> = sub(r"<v>\\d+<>", "(digits)", <v>original<>)

<#># Returns "ab (digits) cd (digits)"<><>
@
@ Substitute, re.sub(), .sub()



### Regular Expressions - Split

<cb>from re import split

<v>splits<> = split(<v>split_pattern<>, <v>string_to_split<>)<>

or

<cb><v>splits<> = split(<v>split_pattern<>, <v>string_to_split<>, <v>split_count<>)<>

Returns: <c>list[str]<>


Returns a list of strings split on <c><v>split_expression<><>.

<c><v>split_expression<><> is not returned in the results.
Stops after splitting <c><v>split_count<><> times if given.


Example:

<cb>from re import split

<v>string_1<> = "<v>ab12cd34ef<>"
<v>split_1<> = split(r"<v>\\d+<>", <v>string_1<>)

<#># Returns ['ab', 'cd', 'ef']<><>
@
@ .split(), re.split()



### Regular Expressions - Match Type

Returned by:

<cb>=re.finditer()
= re.fullmatch()
= re.match()
= re.search()<>
@
@ regex, regexpression, expressions, regex-only, regular-expressions-only, pattern, match
@ match-only,
@ re.fullmatch(), .fullmatch(), re.match(), .match(), re.search(), .search()


### Regular Expressions - Match - To String

<cb>= <v>match_1<>.group()<>


Returns the matching text as a string.
@
@ string, string, convert, text, get
@ .group()



### Regular Expressions - Match - Start Position

<cb>= <v>match_1<>.start()<>


Returns the starting position of the matching text in the original string.
@
@ text beginning, first, index, get
@ .start()


### Regular Expressions - Match - End Position

<cb>= <v>match_1<>.end()<>


Returns the starting position of the matching text in the original string.
@
@ text, last, final, index, get
@ .end()



## Regular Expression Patterns
@
@ regex, regexpression, expressions, regex-only, regular-expressions-only, pattern


### Regular Expressions - Patterns

Escape					<c>\\<>

Escape These				<c>\ ^ $ . * + ? - & | {} [] () <>

Any Character			<c>.<>

Alphanumeric, _			<c>\\w<>			<#># A-Z, a-z, 0-9, _<>			
Non Alphanumeric, _		<c>\\W<>
Digit					<c>\\d<>			<#># 0-9<>	
Non Digit				<c>\\D<>

Whitespace				<c>\\s<>
Non Whitespace			<c>\\S<>

Starts With				<c>\\A<>
Ends With				<c>\\Z<>
Starts or Ends With		<c>\\b<>
Doesn't Start or Ends With	<c>\\B<>

Set. Either <v>a<>, <v>b<> or <v>c<>			<c>[<v>a<><v>b<><v>c<>]<>
Not						<c>^<v>a<><>
Or						<c><v>a<>|<v>b<><>
From - To				<c><v>a<>-<v>z<><>

0 or 1					<c>?<>
0 or More				<c>*<>
1 or More				<c>+<>
<c><v>n<><> Times					<c>{<v>n<>}<>
<c><v>m<><> to <c><v>n<><> Times				<c>{<v>m<>,<v>n<>}<>

Match After				<c>(?\<=<v>after_this<>)<v>match<><>
Match Before				<c><v>match<>(?\=<v>before_this<>)<>
@
@ Codes, Syntax, ?, *, +
@ whitespaces, white spaces



### Regular Expressions - Pattern Reverse Lookup

<c>\\<>		Escape

<c>.<>		Any Character
<c>^<>		Starts With
<c>$<>		Ends With

<c>*<>		0 or More Times
<c>+<>		1 or More Times
<c>?<>		0 or 1 Times
<c>{<v>m<>}<>		<c><v>m<><> Times
<c>{<v>m<>,<v>n<>}<>	<c><v>m<><> to <c><v>n<><> Times

<c>^<v>a<><>		Not
<c><v>a<>|<v>b<><>		<c><v>a<><> or <c><v>b<><>
<c><v>a<>-<v>z<><>		<c><v>a<><> to <c><v>z<><>

<c>[<v>...<>]<>	Set (One of These)
<c>(<v>...<>)<>	Group

<c>\\A<>		Start of String
<c>\\b<>		Beginning or End of Word
<c>\\B<>		Not Beginning or End of Word
<c>\\d<>		Digit (0-9)
<c>\\D<>		Non Digit (0-9)
<c>\\s<>		Whitespace Character
<c>\\S<>		Non Whitespace Character
<c>\\w<>		Word Character (a-z, A-Z, 0-9, _)
<c>\\W<>		Non Word Character
<c>\\Z<>		End of String
@
@ Codes



# Encode, Decode
@
@ encodings, decodings, to, from
@ encode-only, decode-only, encoders-only, decoders-only



### ASCII - Encode To ASCII

<cb>= <v>string_1<>.encode("ascii")<>

Returns: <c>bytes<>


Converts a string to an ASCII encoded byte array.
Non ASCII characters will raise an exception.
@
@ string, str, .encode()



### ASCII - Decode From ASCII

<cb>= <v>bytes_1<>.decode("ascii")<>

Retuns: <c>str<>


Converts an ASCII encoded byte array to a string.
@
@ bytes, string, .decode()



### UTF-8 - Encode To UTF-8

<cb>= <v>string_1<>.encode("utf-8")<>

Returns: <c>bytes<>

Converts a string to an utf-8 encoded byte array.
@
@ string, str, .encode(), utf8



### UTF-8 - Decode From UTF-8

<cb>= <v>bytes_1<>.decode("utf-8")<>

Retuns: <c>str<>

Converts a utf-8 encoded byte array to a string.
@
@ bytes, string, .decode(), utf8



### Hash - To MD5

<!>Do not use MD5
(deprecated, vulnerabilities)<>

<cb>from hashlib import md5

= md5(<v>bytes_1<>)<>


Returns: <c>_hashlib.HASH<>


Converts a byte array into an MD5 hash.


Note:

MD5 is deprecated. Do not use.
It has major vulnerabilities that can be exploited.

Use <#>SHA2<> instead.
@
@ hash, encode, hashlib.md5(), .md5()
@ hashes, hashing



#### Hash - To MD5 Digest

<!>Do not use MD5
(deprecated, vulnerabilities)<>

<cb>from hashlib import md5

= md5(<v>bytes_1<>).digest()<>


Returns: <c>bytes<>


Converts a byte array into an MD5 digest.
@
@ hashlib.md5(), .md5().digest(), .digest()
@ hashes, hashing



#### Hash - To MD5 Hex Digest

<!>Do not use MD5
(deprecated, vulnerabilities)<>

<cb>from hashlib import md5

= md5(<v>bytes_1<>).hexdigest()<>


Returns: <c>str<>


Converts a byte array into hex formatted MD5 digest.
@
@ hexadecimal
@ hashlib.md5(), .md5().hexdigest(), .hexdigest()
@ hashes, hashing



### Hash - To SHA256

<cb>from hashlib import sha256

= sha256(<v>bytes_1<>)<>


Returns: <c>_hashlib.HASH<>


Converts a byte array into a SHA2 hash.
@
@ hash, encode, hashlib.sha256(), .sha256()
@ md5, sha2
@ hashes, hashing



#### Hash - To SHA256 Digest

<cb>from hashlib import sha256

= sha256(<v>bytes_1<>).digest()<>


Returns: <c>bytes<>


Converts a byte array into an SHA2 digest.
@
@ hash, encode, hashlib.sha256().digest(), .sha256().digest(), .digest()
@ hashes, hashing



#### Hash - To SHA256 Hex Digest

<cb>from hashlib import sha256

= sha256(<v>bytes_1<>).hexdigest()<>


Returns: <c>str<>


Converts a byte array into an SHA2 digest in hex.
@
@ hexadecimal
@ hashlib.sha256().digest(), .sha256().hexdigest(), .hexdigest()
@ hashes, hashing



# Files



## Directory Operations
@
@ Directories, dir-only, directory-only, directories-only
@ ops, dir-ops-only, directory-ops-only, directory-operations-only
@ Folders, folder-only, folders-only, folder-ops-only



### Directory - Copy

<cb>copytree(<v>source<>, <v>target<>)<>

With Import:

<cb>from shutil import copytree

copytree(<v>source<>, <v>target<>)<>


Creates a copy of a directory..
@
@ shutil.copytree(), .copytree()



### Directory - Create

<cb>mkdir(<v>directory_name<>)<>

With Import:

<cb>from os import mkdir

mkdir(<v>directory_path<>)<>


Creates a directory
Raises <c>FileExistsError<> if the directory exists.
@
@ make, os.mkdir, .mkdir()



### Directory - Create Full Path

<cb>makedirs(<v>directory_name<>)<>

With Import:

<cb>from os import makedirs

makedirs(<v>directory_path<>)<>

Create, Ignore If Full Path Exists:

<cb>makedirs(<v>directory_path<>, exist_ok = True)<>


Creates all the directories needed to form <c><v>directory_path<><>.
By default, will throw an error if full path already exists unless <c>exist_ok = True<>.
@
@ make directories, os.makedirs, .makedirs(), all



### Directory - Delete - Empty

<cb>rmdir(<v>directory_name<>)<>

With Import:

<cb>from os import rmdir

rmdir(<v>directory_path<>)<>


Deletes empty directories only.
Raises <c>OSError<> if the directory is not empty.
@
@ remove, os.rmdir(), .rmdir()



### Directory - Delete - Non Empty

<cb>rmtree(<v>directory_name<>)<>

With Import:

<cb>from shutil import rmtree

rmtree(<v>directory_path<>)<>


Deletes the directory and all its contents.
@
@ shutil.rmtree(), .rmtree(), remove



### Directory - Delete All Files

<cb>for <v>file<> in glob(join(<v>directory_name<>, '<v>*<>')):
	remove (<v>file<>)<>

With Imports:

<cb>from glob import glob
from os import remove
from os.path import join

<v>files<> = glob(join(<v>directory_path<>, '<v>*<>'))
for <v>file<> in <v>files<>:
	remove (<v>file<>)<>


Deletes all the files in the directory.

To delete particular files, change <c>'*'<> to match (e.g. <c>'*.txt'<>).



### Directory - Exists? Is Directory?

<cb>= isdir(<v>directory_name<>)<>

With Import:

<cb>from os.path import isdir

<v>is_directory<> = isdir(<v>directory_path<>)<>

Returns: <c>bool<>


Returns <c>True<> if <c><v>directory_path<><> exists and is a directory.
Otherwise, returns <c>False<>.
@
@ os.path.isdir(), .path.isdir(), .isdir()



### Directory - Read

<cb>= listdir(<v>directory_name<>)<>

With Import:

<cb>from os import listdir

<v>file_names<> = listdir(<v>directory_path<>)<>

Returns: <c>list<> of <c>str<>


Returns all files and directories for <c><v>directory_path<><>.
Returns the file names only, not the full path.
@
@ os.listdir(), .listdir()
@ simple, basic, retrieve, ls



### Directory - Read, Directories Only

<cb>= filter(
		lambda file: isdir(join(<v>directory_name<>, file)),
		listdir(<v>directory_name<>))<>

With Imports:

<cb>from os import listdir
from os.path import isdir
from os.path import join

<v>directories<> = filter(
		lambda file: isdir(join(<v>directory_path<>, file)),
		listdir(<v>directory_path<>))<>

Returns: <c>filter<> of <c>str<>


Returns list of all directory names in <c><v>directory_path<><>.
Returns the file names only, not the path.


Examples:

Directories in Current Directory:

<cb>from os import listdir
from os.path import isdir
from os.path import join

<v>path<> = '.'

<v>directories<> = filter(
		lambda file: isdir(join(<v>path<>, file)),
		listdir(<v>path<>))

print(list(directories))<>
@
@ os.path.isdir(), .path.isdir(), .isdir(), os.listdir(), .listdir()
@ retrieve, ls



### Directory - Read, Files Only

<cb>= filter(
		lambda file: isfile(join(<v>directory_name<>, file)),
		listdir(<v>directory_name<>))<>

With Imports:

<cb>from os import listdir
from os.path import isfile
from os.path import join

<v>file_names<> = filter(
		lambda file: isfile(join(<v>directory_path<>, file)),
		listdir(<v>directory_path<>))<>

Returns: <c>filter<> of <c>str<>


Returns list of file names.
Only returns the name, not the path.


Examples:

Directories in Current Directory:

<cb>from os import listdir
from os.path import isfile
from os.path import join

<v>path<> = '.'

<v>files<> = filter(
		lambda file: isfile(join(<v>path<>, file)),
		listdir(<v>path<>))

print(list(files))<>
@
@ os.path.isfile(), .path.isfile(), .isfile(), os.listdir(), .listdir()
@ retrieve, ls



### Directory - Read, Filtered

<cb> = filter(listdir(<v>directory_name<>), <v>file_filter<>)<>

With Imports:

<cb>from os import listdir
from fnmatch import filter

<v>file_names<> = filter(listdir(<v>directory_path<>), <v>file_filter<>)<>

Returns: <c>list<> of <c>str<>


Returns list of matching file names only.
Returns the file names only, not the path.


Example:

<cb>from os import listdir
from fnmatch import filter

<v>file_names<> = filter(listdir("<v>.<>"), "<v>*.txt<>")<>
@
@ os.listdir(), .listdir(), fnmatch.filter(), .filter()
@ wildcards, wild cards, pattern expansion, * asterisk, retrieve, ls



### Directory - Read, Full Path

<cb>= glob(join(<v>directory_path<>, "*"))<>

With Imports:

<cb>from glob import glob
from os.path import join

<v>file_paths<> = glob(join(<v>directory_path<>, "*"))<>

Returns: <c>list<> of <c>str<>


Returns all files and sbdirectories in <c><v>directory_path<><>.
Returns the full path to the files.
@
@ glob.glob(), .glob()
@ retrieve, ls, absolute path



### Directory - Read, Full Path, Filtered

<cb>= glob(join(<v>directory_name<>, "<v>filter<>"))<>

With Imports:

<cb>from glob import glob
from os.path import join

<v>file_paths<> = glob(join(<v>directory_path<>, "<v>filter<>"))<>

Returns: <c>list<> of <c>str<>


Returns all files and sbdirectories in <v>directory_path<>.
Returns the full path to the files.


Examples:

<cb>from glob import glob
from os.path import join

<v>file_paths<> = glob(join(<v>directory_path<>, "<v>*.txt<>"))<>
@
@ glob.glob(), .glob()
@ Wildcards, Wild Cards, Pattern Expansion, * Asterisk, Retrieve, ls,
@ absolute path



### Directory - Read, Full Path, Recursive

<cb>= glob(join(<v>directory_path<>, "**", "*"), recursive=True)<>

With Imports:
 
<cb>from glob import glob
from os.path import join

<v>file_paths<> = glob(join(<v>directory_path<>, "**", "*"), recursive=True)<>

Returns: <c>list<> of <c>str<>


Recursively
Returns full path to all files.
@
@ glob.glob(), .glob()
@ subdirectories, recursively, retrieve, ls
@ absolute path



### Directory - Read, Full Path, Recursive, Filtered

<cb>= glob(join(<v>directory_path<>, "**", <v>filter<>), recursive=True)<>

With Imports:
 
<cb>from glob import glob
from os.path import join

<v>file_paths<> = glob(join(<v>directory_path<>, "**", <v>filter<>), recursive=True)<>

Returns: <c>list<> of <c>str<>


Returns full path to all files.


Examples:

<cb>from glob import glob
from os.path import join

<v>filtered_files<> = glob(join(<v>directory_path<>, "**", "<v>*.txt<>"), recursive=True)<>
@
@ @ glob.glob(), .glob()
@ wildcards, wild cards, pattern expansion, * asterisk, subdirectories, recursively, retrieve, ls
@ absolute path



### Directory - Read Recursively / Walk

<cb>from os import walk

for <v>root<>, <v>directories<>, <v>files<> in walk(<v>directory_path<>):
	<v>...<><>

Returns:

<indent><table><col><c>root<><><col><c>str<><>
<col><c>directories<><><col><c>list[str]<><>
<col><c>files<><><col><c>list[str]<><><><>


Returns the list of directories and files in each directory under and including <c><v>directory_path<><>).
The current directory is returned in <c><v>root<><>.
When no files or directories are found, returns an empty list (<c>[]<>).


Example:

Walk The Current Directory:

<cb>from os import walk

for <v>root<>, <v>directories<>, <v>files<> in walk(<v>'.'<>):

	print("Current Path:", <v>root<>)
	print("Directories:", <v>directories<>)
	print("Files:", <v>files<>)
	print()<>
@
@ os.walk(), .walk(), files, path



## File Operations
@
@ ops, file-ops, file-ops-only, file-operations, file-only



### File - Get Created Datetime

<cb>= datetime.fromtimestamp(getctime(<v>file_name<>))<>

With Import:

<cb>from datetime import datetime
from os.path import getctime

<v>created_datetime_1<> = datetime.fromtimestamp(getctime(<v>full_path<>))<>

Returns: <c>datetime<>


Returns the file creation time as a datetime.
@
@ os.path.getctime(), path.getctime(), .getctime(), .fromtimestamp()
@ creation, retrieve, read, date time



### File - Get Created Timestamp

<cb>= getctime(<v>file_name<>)<>

With Import:

<cb>from os.path import getctime

<v>created_timestamp_1<> = getctime(<v>full_path<>))<>

Returns: <c>float<>


Returns the file creation time as a unix timestamp (epoch).
@
@ os.path.getctime(), .path.getctime(), .getctime()
@ creation, retrieve, read, date time



### File - Get Modified Datetime

<cb>= datetime.fromtimestamp(getmtime(<v>file_name<>))<>

With Imports:

<cb>from os.path import getmtime
from datetime import datetime

<v>modified_datetime_1<> = datetime.fromtimestamp(getmtime(<v>full_path<>))<>

Returns: <c>datetime<>


Returns the file modification time as a datetime.
@
@ os.path.getmtime(), .path.getmtime(), .getmtime(), .fromtimestamp()
@ modification, retrieve, read, modify, date time



### File - Get Modified Timestamp

<cb>= getmtime(<v>file_name<>)<>

With Import:

<cb>from os.path import getmtime

<v>modified_timestamp_1<> = getmtime(<v>full_path<>)<>

Returns: <c>float<>


Returns the file modified time as a unix timestamp (epoch).
@
@ os.path.getmtime(), .path.getmtime(), .getmtime()
@ modification, retrieve, read, modify, date time



### File - Get Size

<cb>= getsize(<v>file_path<>)<>

With Import:

<cb>from os.path import getsize

<v>file_size<> = getsize(<v>file_path<>)<>


Returns the size of a file.
@
@ length
@ os.path.getsize(), .path.getsize(), .getsize()



### File - Copy

<cb>copyfile(<v>source_path<>, <v>destination_path<>)<>

With Import:

<cb>from shutil import copyfile

copyfile(<v>source_path<>, <v>destination_path<>)<>


Creates a copy of a file.

Does not copy metadata.
@
@ shutil.copyfile(), .copyfile(), cp



### File - Copy With Metadata

<cb>copy2(<v>source_path<>, <v>destination_path<>)<>

With Import:

<cb>from shutil import copy2

copy2(<v>source_path<>, <v>destination_path<>)<>


Creates a copy of a file along with the metadata.
@
@ shutil.copy2(), .copy2(), shutil.copyfile(), .copyfile(), cp



### File - Delete

<cb>remove(<v>file_path<>)<>

With Import:

<cb>from os import remove

remove(<v>file_path<>)<>


Deletes a file.
@
@ .remove(), os.remove()



### File - Exists?

<cb>= exists(<v>file_name<>)<>

With Import:

<cb>from os.path import exists

<v>file_exists<> = exists(<v>file_path<>)<>

Returns: <c>bool<>


Returns <c>True<> if a file exists.
@
@ os.path.exists(), path.exists(), .exists()



### File - Is File?

<cb>= isfile(<v>file_path<>)<>

With Import:

<cb>from os.path import isfile

<v>is_file<> = isfile(<v>file_path<>)<>

Returns <c>bool<>


Returns <c>True<> if <c><v>file_path<><> exists and is a file (not a directory).
Otherwise, returns <c>False<>.
@
@ os.path.isfile(), .path.isfile(), .isfile()



### File - Join Paths

<cb>= join(<v>path_1<>, <v>path_2<><v>...<>)<>

With Import:

<cb>from os.path import join

<v>joined_path<> = join(<v>path_1<>, <v>path_2<><v>...<>)<>


Returns the paths joined together with the correct OS specific file separator.
@
@ os.path.join(), .path.join(), .join()
@ merge, separator, combine, concatenate



### File - Move

<cb>rename(<v>source_path<>, <v>destination_path<>)<>

With Import:

<cb>from os import rename

rename(<v>source_path<>, <v>destination_path<>)<>


Moves a file to a location within the current drive only. 
@
@ os.rename(), .rename()



### File - Move - Across Drives

<cb>move(<v>source_path<>, <v>destination_path<>)<>

With Import:

<cb>from shutil import move

move(<v>source_path<>, <v>destination_path<>)<>


Moves a file within drive or copies it from one dirve to another.
When copying across drives, he original is not deleted.
@
@ shutil.move(), .move(), copy



### File - Rename

<cb>rename(<v>source_path<>, <v>destination_path<>)<>

With Import:

<cb>from os import rename

rename(<v>source_path<>, <v>destination_path<>)<>


Renames a filename.
@
@ os.rename(), .rename(), filename, name



## File IO
@
@ open as, .open()
@ file-io-only



### File - Create Empty File

<cb>with open(<v>file_name<>, 'w') as file:
    pass<>


This will create a file with 0 bytes.
@
@ with open, open()


### Binary File - Read

<cb>with open(<v>file_name<>,'rb') as file:
	<v>contents<> = file.read()<>

Returns: <c>bytes<>
@
@ 'rb', "rb", .read(), open(), with open, from, bytes



### Binary File - Read By Byte

<cb>with open(<v>file_name<>, "rb") as file:
	while (<v>next_byte<> := file.read(1)):
		<v>...<><>

Reads the file one byte at a time.
@
@ 'rb', "rb", .read(), open(), with open, from, bytes



### Binary File - Write

<cb>with open(<v>file_name<>, 'wb') as file:
	file.write(<v>contents<>)<>

Deletes the file if it exists before writing to it.
@
@ 'wb', "wb", .write(), open(), with open, bytes
@ create, new, save, to



### Binary File - Append

<cb>with open(<v>file_name<>, 'ab') as file:
	file.write(<v>contents<>)<>

Creates a new file or appends to an existing one.
@
@ 'ab', "ab", .write(), open()
@ create, new, write, append to, with open, bytes



### Text File - Read

<cb>with open(<v>file_name<>,'r') as file:
	<v>contents<> = file.read()<>

Returns: <c>str<>
@
@ 'r', "r", .read(), open(), with open, from



### Text File - Read By Character

<cb>with open(<v>file_name<>, 'r') as file:

	<v>characters<> = []
	while (<v>next_character<> := file.read(1)):
		<v>characters<>.append(<v>next_character<>)<>

Returns: <c>list<> of <c>str<>

Returns the contents of the file as a list in <c><v>lines<><>.
@
@ 'r', "r", .read(), open(), with open, from



### Text File - Read By Line

<cb>with open(<v>file_name<>, 'r') as file:

	<v>lines<> = []
	while (line := file.readline()):
		<v>lines<>.append(line.rstrip('\\n'))<>

Returns: <c>list<> of <c>str<>

Returns the contents of the file as a list in <c><v>lines<><>.
@
@ open(), with open, from
@ 'r', "r", 'rt', "rt"
@ .readline()



### Text File - Read All Lines

<cb>with open(<v>file_name<>, 'r') as file:
	<v>lines<> = file.readlines()<>

Returns: <c>list<> of <c>str<>

Returns the contents of the file as a list in <c><v>lines<><>.
The lines include the newline characters.
@
@ list, by
@ open(), with open, from, .readlines()
@ 'r', "r", 'rt', "rt"



### Text File - Read All Lines, Stripped Newlines

<cb>with open(<v>file_name<>, 'r') as file:
	<v>lines<> = [line.rstrip('\\n') for line in file]<>

Returns: <c>list<> of <c>str<>

Returns the contents of the file as a list in <c><v>lines<><>.
The line's newline character is returned by default. rstrip, removes it.
@
@ list, by
@ open(), with open, from
@ 'r', "r", 'rt', "rt"



### Text File - Write

<cb>with open(<v>file_name<>, 'w') as file:
	file.write(<v>contents<>)<>

Deletes the file if it exists before writing to it.
@
@ create, new, save
@ open(), with open, from
@ 'w', "w", 'wt', "wt"
@ .write(), to



### Text File - Write Line

<cb>with open(<v>file_name<>, 'w') as file:
	file.write(<v>line<> + '\\n')<>

Writes a single line to a file.

You have to add the newline character manually between lines.
Deletes the file if it exists before writing to it.
@
@ create, new, save
@ open(), with open, from
@ 'w', "w", 'wt', "wt"
@ .write(), to



### Text File - Write Lines

<cb>with open(<v>file_name<>, 'w') as file:
		file.write('\\n'.join(<v>lines<>))<>

Writes a sequence of lines to a file.

Inserts a newline character between each line.
Deletes the file if it exists before writing to it.
@
@ create, new, save
@ open(), with open, from
@ 'w', "w", 'wt', "wt"
@ .writeline()
@ list, sequence of, to



### Text File - Write Strings

<cb>with open(<v>file_name<>, 'w') as file:
		file.writelines(<v>strings<>)<>

Writes a sequence of strings to a file.

<c>writeline()<> will NOT insert a newline character between each string.
Deletes the file if it exists before writing to it.
@
@ create, new, save
@ open(), with open, from
@ 'w', "w", 'wt', "wt"
@ .writeline()
@ list, sequence of, to



### Text File - Write

<cb>with open(<v>file_name<>, 'w') as file:
	file.write(<v>contents<>)<>

Deletes the file if it exists before writing to it.
@
@ create, new, save
@ open(), with open, from
@ 'w', "w", 'wt', "wt"
@ .write(), to



### Text File - Append

<cb>with open(<v>file_name<>, 'a') as file:
	file.write(<v>contents<>)<>

Creates a new file or appends to an existing one.
@
@ create, new, write, append to
@ .write(), 'a', "a", open(), with open, to



### File - Seek

<cb><v>file<>.seek(<v>offset<>)<>

<cb><v>file<>.seek(<v>offset<>, <v>whence<>)<>

Positions the read / write position within a file.


<v>whence<>	= 0		Absolute Position (Default)
		= 1		Relative To Current Position
		= 2		Relative To End of File


Example:

<cb>with open(<v>file_name<>, 'r+') as file:
	file.seek(10)
	<v>content<> = file.read(10)
	file.seek(10)
	file.write("**********")<>



### File - Read / Write Modes

<card><table><col>				<><col><c>r<><><col><c>r+<><><col><c>w<><><col><c>w+<><><col><c>a<><><col><c>a+<><>
<col> <>
<col>Read<><col>✅<><col>✅<><col> <><col>✅<><col> <><col>✅<>
<col> <>
<col>Write<><col> <><col>✅<><col>✅<><col>✅<><col>✅<><col>✅<>
<col> <>
<col>Truncate<><col> <><col> <><col>✅<><col>✅<>
<col> <>
<col>Position At Start<><col>✅<><col>✅<><col>✅<><col>✅<>
<col> <>
<col>Position At End<><col> <><col> <><col> <><col> <><col>✅<><col>✅<><><>


<card><table><col><b>Mode<><><col><b>Operation<><><col><b>Pointer<><>
<col> <>
<col>r	<><col>Read Only	<><col>File Start<>
<col>r+<><col>Read / Write<><col>File Start<>
<col>w<><col>Write Only<><col>Truncated File<>
<col>w+<><col>Read / Write<><col>Truncated File<>
<col>a<><col>Write Only<><col>File End<>
<col>a+<><col>Read / Write<><col>File End<><>

<table><col>+	<><col>Read / Write<>
<col>b	<><col>Binary Mode<>
<col>t	<><col>Text Mode (Default)<><><>
@
@ r, r+, w, w+, a, a+, b, rb, wb, t, rt, wt, +
@ 'r', 'r+', 'w', 'w+', 'a', 'a+', '+', 'b', 'rb', 'wb', 't', 'rt', 'wt'
@ "r", "r+", "w", "w+", "a", "a+", "+", "b", "rb", "wb", "t", "rt", "wt"
@ chart



## File / Path Parts

<cb><v>full_path<> = /<v>root_directory<>/<v>parent_directory<>/<v>file_name<>.<v>extension<><>

<cb><v>base_name<> = <v>file_name<>.<v>extension<><>
@
@ path-parts, file-parts, components, path-only, paths-only



### Path - Get Absolute Path

<cb>= abspath(<v>relative_path<>)<>

Usage:

<cb>from os.path import abspath

= abspath(<v>relative_path<>)<>


Converts any path into its absolute form.

Will return as is if already an absolute path.


Example:

<cb>from os.path import abspath

<v>current_directory<> = abspath('<v>.<>')<>
@
@ name
@ os.path.abspath(), .path.abspath(), .abspath()



### Path - Get Directory Part

<cb>= dirname(<v>full_path<>)<>

Usage:

<cb>from os.path import dirname

= dirname(<v>full_path<>)<>

Returns:

<cb>str<>

Returns the full directory portion of the path.

If the last element is a directory, that will be removed.


Example:

<cb>from os.path import dirname

<v>directory<> = dirname('<v>/root/parent/file.txt<>')

<#># Returns '/root/parent'<><>
@
@ name
@ os.path.dirname(), .path.dirname(), .dirname()



### Path - Get Base Name Part

<cb>= basename(<v>file_path<>)<>

Usage:

<cb>from os.path import basename

= basename(<v>file<>)<>

Returns:

<cb>str<>


Returns the file name and extension, leaving out the directory.


Example:

<cb>from os.path import basename

<v>file_name<> = basename('<v>/root/parent/file.txt<>')

<#># Returns: 'file.txt'<><>
@
@ base name, body
@ os.path.basename(), .path.basename(), .basename()



### Path - Get Base Name Part / Windows Save Version

<cb>= basename(<v>file_path<>)<>

Usage:

<cb>from ntpath import basename

= basename(<v>file_path<>)<>

Returns:

<cb>str<>


Returns a file name and extension portion of a path

This works safely with both \\ and / file separators.


Example:

<cb>from ntpath import basename

<v>file_name<> = basename('<v>/root/parent/file.txt<>')

<#># Returns 'file.txt'<><>
@
@ base name, body
@ ntpath.basename(), .basename()



### Path - Get File Extension

<cb>= splitext(<v>file_name<>)[1]<>

Usage:

<cb>from os.path import splitext

= splitext(<v>file_name<>)[1]<>


Returns the file extension in <c><v>extension<><>.

Includes the '.' in the extension.


Example:

<cb>from os.path import splitext

<v>extension<> = splitext('<v>/root/parent/file.txt<>')[1]

<#># Returns: '.txt'<><>
@
@ part, end, name
@ os.path.splitext(), .path.splitext(), .splitext()
@ os.path.splittext(), .path.splittext(), .splittext(), splittext



### Path - Get File Name

<cb>= splitext(<v>file_name<>)[0]<>

Usage:

<cb>from os.path import splitext

= splitext(<v>file_name<>)[0]<>

Get File Name From Path:

<cb>from os.path import basename
from os.path import splitext

= splitext(basename(<v>file_path<>)[0]<>


Returns the file name, the 'file' from 'file.txt'.


Example:
<cb>from os.path import basename
from os.path import splitext

<v>name<>, = splitext(basename('<v>/root/parent/file.txt<>'))[0]

<#># Returns: 'file'<><>
@
@ part, base body and extension, stem
@ os.path.splitext(), .path.splitext(), .splitext()
@ os.path.splittext(), .path.splittext(), .splittext(), splittext
@ os.path.basename(), .path.basename(), .basename()



### Path - Get File Name, Extension

<cb><v>name<>, <v>extension<> = splitext(basename(<v>file_path<>)<>

Usage:

<cb>from os.path import basename
from os.path import splitext

<v>name<>, <v>extension<> = splitext(basename(<v>file_path<>)<>


Returns the name and extension of a file.
<c>basename()<> strips any directory information before splitting the parts.


Example:

<cb>from os.path import basename
from os.path import splitext

<v>name<>, <v>extension<> = splitext(basename('<v>/root/parent/file.txt<>'))

<#># Returns: 'file', '.txt'<><>
@
@ part, and, base, body, stem
@ os.path.splitext(), .path.splitext(), .splitext()
@ os.path.splittext(), .path.splittext(), .splittext(), splittext
@ os.path.basename(), .path.basename(), .basename()



### Path - Is Absolute Path?

<cb>= isabs(<v>path<>)<>

Usage:

<cb>from os.path import isabs

= isabs(<v>path<>)<>

Returns: <c>bool<>


Checks if a path is absolute or not.


Example:

<cb>from os.path import isabs

is_absolute = isabs('/Users/user-1')

<#># Returns: True<><>
@
@ full, complete
@ os.path.isabs(), path.isabs(), .isabs()



## Path Separators



#### Path Separator - File Separator

<cb>import os

<v>separator<> = os.path.sep<>

Returns the OS specific form of the internal path separator...
the <c>/<> or <c>\\<> in <c>/<v>dir_1<>/<v>file_1<><>.
@
@ /, \
@ os.path.sep, .path.sep, .sep



#### Path Separator - Paths Separator

<cb>import os

<v>separator<> = os.pathsep<>

Returns the OS specific form of the paths separator...
the <c>;<> or <c>:<> in <c><v>dir_1<>;<v>dir_2<>;<v>dir_3<><>
@
@ :, ;
@ os.pathsep, .pathsep



# Standard Libraries


## Argparse
@
@ argparser, argument parser
@ argparse-only
@ argparse.argumentparser()
@ parameters



### Argparse - Video Tutorial

Get going faster with our argparse in a Hurry Video:

<card><l https://youtu.be/66tRWijsm0U>Argparse in a Hurry (2 Mins)<><>



### Argparse Basics

<cb>from argparse import ArgumentParser

<v>parser<> = ArgumentParser(description = '<v>description<>')<>

Flag:

<cb><v>parser<>.add_argument('-<v>n<>', '--<v>name<>', action='store_true')<>

Optional Field:

<cb><v>parser<>.add_argument('-<v>n<>', '--<v>name<>')<>

Positional Fields:

<cb><v>parser<>.add_argument('<v>first<>')
<v>parser<>.add_argument('<v>second<>')<>

As Int:

<cb><v>parser<>.add_argument('<v>name<>', type = int)<>

From Choices:

<cb><v>parser<>.add_argument('<v>name<>', choices = ['<v>a<>', '<v>b<>', '<v>c<>'])<>

Parameter Help Text:

<cb><v>parser<>.add_argument(<v>...<>, help = '<v>help<>')<>


Parse:

<cb><v>arguments<> = <v>parser<>.parse_args()

if <v>argumets<>.<v>flag_name<>:
    <v>...<>

<v>value<> = <v>arguments<>.<v>name<><>


### Argparse - Create



#### Argparse - Create

<cb>= ArgumentParser()<>

Usage:

<cb>from argparse import ArgumentParser

<v>parser<> = ArgumentParser(
        description = '<v>help description<>')<>
@
@ argparser.argumentparser()
@ new, instantiate, define



#### Argparse - Create, Override Error

<cb>class ArgumentParserNoExit(ArgumentParser):
    def error(self, <v>message<>):
        <v>...<><>

Usage:

<cb>from argparse import ArgumentParser

class ArgumentParserNoExit(ArgumentParser):
    def error(self, <v>message<>):
        <v>...<>

<v>parser<> = ArgumentParserNoExit(<v>...<>)<>


Override the error() method.

Subclass ArgumentParser and implement the <c>error()<> method to override the error behavior.
Error messages will be sent to this method instead of calling <c>sys.exit()<>.
@
@ error(), argumentparsernoexit



### Argparse - Parse
@
@ parser.parse_args(), .parse_args()



#### Argparser - Parse Command-line

<cb>= parser.parse_args()<>


Parses the command-line arguments.

Will print help and exit if has '-h', '--help'.
Will print errors and exit if any errors found.
@
@ get, program, application, commandline



#### Argparse - Parse String

<cb>= parser.parse_args(<v>argument_list<>)<>

Will print help and exit if has '-h', '--help'.
Will print errors and exit if any errors found.
@
@ get



### Argparse - Flag Parameters
@
@ parser.add_argument(), .add_argument()



#### Argparse - Flag Parameter

<cb><v>parser<>.add_argument('--<v>name<>', '-<v>n<>',
        action = 'store_true')<>

Full Usage:

<cb><v>parser<>.add_argument('--<v>name<>', '-<v>n<>',
        action = 'store_true',
        help = '<v>help text<>')<>

<cb>if <v>arguments<>.<v>name<>:
    <v>...<><>

Returns: <c>bool<>


Defines an argument flag.

The first <c>add_argument<> parameter with leading '--' defines the field name.
Returns <c>True<> if present, <c>False<> if not.


Example:

<cb>from argparse import ArgumentParser

<v>parser<> = ArgumentParser()
<v>parser<>.add_argument('-d', '--debug', action = 'store_true')
<v>parser<>.add_argument('-v', '--verbose', action = 'store_true')

<v>arguments<> = parser.parse_args(['-d'])

print(<v>arguments<>.debug, <v>arguments<>.verbose)

<#># Prints: True False<><>
@
@ action='store_true', store_true



#### Argparse - Flag Parameter / As False

<cb><v>parser<>.add_argument(<v>...<>, action='store_false')<>

Full Usage:

<cb><v>parser<>.add_argument('-<v>n<>', '--<v>name<>',
        action = 'store_false',
        help = <v>help text<>)<>

<cb>if not <v>arguments<>.<v>name<>:
    <v>...<><>

Returns: <c>bool<>


Returns <c>False<> if present, <c>True<> if not.
@
@ action='store_false', store_false



#### Argparse - Flag Parameter / As Value

<cb><v>parser<>.add_argument(<v>...<>,
        action = 'store_const', const = <v>value<>)<>

Returns: <c>str<>


Returns <c>value<> if present, <c>None<> if not.
@
@ action='store_const', store_const, const=, constant



### Argparse - Optional Argument
@
@ named
@ parser.add_argument(), .add_argument()



#### Argparse - Optional Argument

<cb><v>parser<>.add_argument("-<v>n<>", "--<v>name<>")<>

Usage:

<cb><v>parser<>.add_argument("-<v>n<>", "--<v>name<>"
        help = '<v>help text<>')<>

<cb>= <v>arguments<>.<v>name<><>

Returns: <v>str<>


Defines optional (named) argument.

Returns the value if present, or <c>None<> if missing.


Example:

<cb>from argparse import ArgumentParser

<v>parser<> = ArgumentParser()
<v>parser<>.add_argument('-n', '--name')
<v>parser<>.add_argument('-i', '--id')

<v>arguments<> = parser.parse_args(['-i', '42'])

print(<v>arguments<>.name, <v>arguments<>.id)

<#># Prints: None 42<><>



#### Argparse - Optional Argument / As Integer

<cb><v>parser<>.add_argument(<v>...<>, type = int)<>

Usage:

<cb><v>parser<>.add_argument("-<v>n<>", "--<v>name<>",
        type = int,
        help = '<v>help text<>')<>

<cb>= <v>arguments<>.<v>name<><>

Returns: <v>int<>


Defines optional (named) argument.

Returns the value as an integer if present, or <c>None<> if missing.
@
@ type=int



#### Argparse - Optional Argument / Choice From List

<cb><v>parser<>.add_argument("-<v>n<>", "--<v>name<>", choices = [<v>value_1<>, <v>value_2<>, <v>value_3<>])<>


Defines optional (named) argument of limited choices.

Will report an error if an invalid value is given.
@
@ choices=, choose, limit, from list



#### Argparse - Optional Argument / Append Value

<cb><v>parser<>.add_argument("-<v>n<>", "--<v>name<>", action='append')<>

Returns: List


Adds optional argument (named argument).
@
@ action='append'



#### Argparse - Optional Argument / Append Constant

<cb><v>parser<>.add_argument("-<v>n<>", "--<v>name<>",
    action='append_const', const = <v>value<>)<>

Returns: List


Adds optional argument (named argument).
@
@ const=, action='append_const', append_const



### Argparse - Positional Arguments
@
@ parser.add_argument()



#### Argparse - Positional Argument

<cb><v>parser<>.add_argument("<v>name<>")<>

Usage:

<cb><v>parser<>.add_argument("<v>first<>", help="<v>first help text<>")
<v>parser<>.add_argument("<v>second<>", help="<v>second help text<>")
<v>...<>

<v>first_argument<> = <v>arguments<>.<v>first<><>

Returns: <v>str<>


Returns the argument in the position it was defined.


Example:

<cb>from argparse import ArgumentParser

<v>parser<> = ArgumentParser()
<v>parser<>.add_argument('id')
<v>parser<>.add_argument('name')

<v>arguments<> = parser.parse_args(['42', 'sample-name'])

print(arguments.id, arguments.name)

<#># Prints: 42 sample-name<><>
@
@ string, str



#### Argparse - Positional Argument / As Integer

<cb><v>parser<>.add_argument("<v>name<>", type = int)<>

Usage:

<cb><v>parser<>.add_argument("<v>name<>", type = int, help="<v>help text.<>")<>

Returns: <v>int<>
@
@ type=int, int



#### Argparse - Positional Argument / Choice From List

<cb><v>parser<>.add_argument("<v>name<>", choice = ['<v>one<>', '<v>two<>', '<v>three<>'])<>

Usage:

<cb><v>parser<>.add_argument("<v>name<>",
        choice = <v>choice_list<>))<>

Returns: <v>str<>
@
@ choice=[], from list, choose, limit



### Argparse - Groups


#### Argparse - Mutually Exclusive Group

<cb>group = parser.add_mutually_exclusive_group()

group.add_argument('<v>option_1<>', <v>...<>)
group.add_argument('<v>option_2<>', <v>...<>)<>


Defines a group of mutually exclusive arguments.

Only one of the defined arguments can exist.
@
@ parser.add_mutually_exclusive_group(), .add_mutually_exclusive_group()



### Argparse - Arguments
@
@ optional, named, positional



#### Argparse Argument - As Integer

<cb><v>parser<>.add_argument(<v>...<>, type = int)<>

Returns: <v>int<>


Returns the argument as an integer
@
@ type=int, int



#### Argparse Argument - As Return Type

<cb><v>parser<>.add_argument(<v>...<>, type = <v>return_type<>)<>


Casts the return value to the given type before returning.


Return Types:

<cb>int
float
ascii
ord
open<>
@
@ int, float, ascii, ord, open, integer, set, define
@ cast to, type=



#### Argparse Argument - Choice from List

<cb><v>parser<>.add_argument(<v>...<>, choice = ['<v>one<>', '<v>two<>', '<v>three<>'])<>

Returns: <v>str<>


Returns one of the integers in choices.
Will report an error if an invalid value is given.
@
@ limit, from selection, from list
@ choice=[]



#### Argparse Argument - Choice from Integers

<cb><v>parser<>.add_argument(type = int,
        choices = [<v>value_1<>, <v>value_2<>, <v>value_3<>])<>

Type: <v>int<>


Returns the argument as a choice of integers.

Returns one of the integers in <c>choices<>.
Will report an error if an invalid value is given.
@
@ limit, from selection, from list
@ choices=



#### Argparse Argument - 0 or 1 (Optional Value)

<cb><v>parser<>.add_argument("<v>name<>", nargs='?')<>

Usage:

<cb><v>parser<>.add_argument("<v>name<>", nargs='?', help="<v>help text.<>")<>

Returns: <v>str<>

Returns an optional value.

Applies to positional and named parameters.
@
@ nargs='?'



#### Argparse Argument - 0 or More Values

<cb><v>parser<>.add_argument("<v>name<>", nargs='*')<>

Usage:

<cb><v>parser<>.add_argument("<v>name<>", nargs='+', help="<v>help text.<>")<>

Returns: <c>list<>


Returns 0 or more values.

Applies to positional and named parameters.
@
@ string, str, zero, get, nargs=, '*', "*", *



#### Argparse Argument - 1 or More Values

<cb><v>parser<>.add_argument("<v>name<>", nargs='+')<>

Usage:

<cb><v>parser<>.add_argument("<v>name<>", nargs='+', help="<v>help text.<>")<>

Return: <c>list<>


Returns a list of values.

Throws an error if none found.
Applies to positional and named parameters.
@
@ string, str, get, one, nargs='+', '+', "+", +



#### Argparse Argument - N Values

<cb><v>parser<>.add_argument("<v>name<>", nargs=<v>n<>)<>

Usage:

<cb><v>parser<>.add_argument("<v>name<>", nargs=<v>n<>, help="<v>help text.<>")<>

Returns: <v>list<>


Returns a list of n values.

Applies to positional and named parameters.
@
@ nargs=, set number



### Argparse Help



#### Argparse Help - Add Help Flag

Included by default.

Help argument flags:

<cb><v>app_name<> -h
<v>app_name<> --help<>



#### Argparse Help - Disable Default Help

<cb>parser = ArgumentParser(<v>...<>, add_help = False)<>


Disables the default help options.
@
@ add_help=
@ argparse.argumentparser(), .argumentparser()



#### Argparse Help - Set Program Name

<cb>parser = ArgumentParser(<v>...<>,
        prog = "<v>program_name<>")<>

Defaults to: sys.argv[0]
@
@ prog=



#### Argparse Help - Set Usage Text

<cb>parser = ArgumentParser(<v>...<>,
        usage = "<v>Usage Text<>")<>


Sets the usage text that will be displayed with '-h'.
@
@ usage=


#### Argparse Help - Show Help

<cb><v>parser<>.print_help()<>


Prints the help text.
@
@ parser.print_help(), .print_help()
@ print



### Argparse Settings



#### Argparse - action

<cb><v>parser<>.add_argument(<v>...<>, action = <v>value<>)<>

action:

<card><table><col><c>= 'append'<><><col>Appends Value<>
<col><c>= 'append_const'<><><col>Appends Constant<>
<col><c>= 'store'<>	<><col>Stores Value<>
<col><c>= 'store_const'<><><col>Stores const=<v>value<><>
<col><c>= 'store_true'<><><col>Sets to True<>
<col><c>= 'store_false'<><><col>Sets to False<><><>
@
@ add_argument(), store, store_const, store_true, store_false, append, append_const



#### Argparse - nargs

<cb><v>parser<>.add_argument(<v>...<>, nargs = '<v>value<>')<>

nargs:

<card><table><col><c>= '?'<>			<><col>0 or 1<>
<col><c>= '*'<><><col>0 or More<>
<col><c>= '+'<><><col>1 or More<>
<col> <>
<col><c>= '<v>3<>'<><><col>3 Exactly<><><>
@
@ add_argument()



#### Argparse Argument - Custom Default Value

<cb><v>parser<>.add_argument(<v>...<>, default = <v>value<>)<>


Sets the default value when the argument doesn't exist.

By default, argparse returns <c>None<>.
@
@ default=


#### Argparse Argument - Custom Field Name

<cb><v>parser<>.add_argument(<v>...<>, dest = <v>field_name<>)<>

<cb><v>arguments<> = <v>parser<>.parse_args()
= <v>arguments<>.<v>field_name<><>


Explicitly defines the field name the argument value will be stored in.
@
@ dest=, variable



#### Argparse Settings - Disable Exit On Error

<cb>parser = ArgumentParser(<v>...<>, exit_on_error = False)<>

Usage:

<cb>from argparse import ArgumentParser, ArgumentError

<v>parser<> = ArgumentParser(<v>...<>, exit_on_error = False)

try:
    <v>arguments<> = <v>parser<>.parse_args()
    <v>...<>
except ArgumentError as <v>error<>:
    <v>...<><>

Default: True


Throws ArgumentError instead of exiting the application.
@
@ exit_on_error, argumenterror, argparse.argumenterror
@ argparse.argumentparser(), .argumentparser()



#### Argparse Argument - Make Require

<cb><v>parser<>.add_argument(<v>...<>, required = True)<>


Requires the argument to be present.

Will display help and exit if not found.
@
@ required=
@ mandatory, set



## ConfigParser

Reads, and writes Windows style ini files.
@
@ config parser
@ configparser-only, config-parser-only



### ConfigParser - Video Tutorial

Get going faster with our 5 minute tutorial here:

<cb><l "https://www.youtube.com/watch?v=JLMd7AJnzrc">ConfigParser Tutorial<><>



### ConfigParser - Basics

<cb>from configparser import ConfigParser

<v>config<> = ConfigParser()
<v>config<>.read(‘<v>file_name.ini<>')<>

Read Property:

<cb><v>value_1<> = <v>config<>['<v>section_name<>']['<v>property_name<>']<>

Read To Type:

<cb><v>boolean_1<> = <v>config<>.getboolean('<v>section_name<>', '<v>boolean_property<>')
<v>int_1<> = <v>config<>.getint('<v>section_name<>', '<v>int_property<>')
<v>float_1<> = <v>config<>.getfloat('<v>section_name<>', '<v>float_property<>')<>

Read From Section:

<cb><v>section_1<> = <v>config<>['<v>section_name<>']
<v>value_2<> = <v>section_1<>['<v>property_name<>']<>

Read Section Property To Type:

<cb><v>boolean_<> = <v>section_1<>.getboolean(<v>boolean_property<>')
<v>int_<> = <v>section_1<>.getint(<v>int_properte<>')
<v>float_<> = <v>section_1<>.getfloat(<v>float_property<>')<>


Sample File:

<cb>[<v>section_name<>]
<v>property_name<> = <v>Property Value<>

<v>int_property<> = <v>42<>
<v>float_property<> = <v>1.23<>
<v>boolean_property<> = <v>True<><>
@
@ Config File, Configuration, configparser.ConfigParser, .read()



### ConfigParser - File



#### ConfigParser - Read File

<cb>from configparser import ConfigParser

<v>config_parser<> = ConfigParser()
<v>config_parser<>.read(‘<v>file_name.ini<>')<>
@
@ .read()



#### ConfigParser - Read File - Sectionless Properties

Function:

<cb>from configparser import ConfigParser

def <v>read_sectionless<>(<v>file_name<>):

	with open(<v>file_name<>,'r') as file:
		contents = file.read()

	<v>config<> = ConfigParser()
	<v>config<>.read_string(f'[default]\n{contents}')
	return <v>config<>['default']<>

Read File:

<cb><v>config_1<> = <v>read_sectionless<>(<v>file_name<>)<>

Get Value:

<cb><v>property_1<> = <v>config_1<>.get('<v>property-1<>')<>



Returns all properties defined before any <c>[<v>section<>]<> in the config file.
All sections and their properties are ignored.
@
@ with sectionless properties, section-less, read



#### ConfigParser - Read From String

<cb>from configparser import ConfigParser

<v>config_parser<> = ConfigParser()
<v>config_parser<>.read_string(<v>string_representation<>)<>


Reads a string as if it were an ini file.
Useful for unit testing.
@
@ .read_string(),



#### ConfigParser - Write File

<cb>with open(<v>file_name<>, 'w') as file:
	<v>config_parser<>.write(file)<>
@
@ .write()



### ConfigParser Property


#### ConfigParser Property - Add / Update

<cb><v>config_parser<>.set('<v>section_name<>', '<v>property_name<>', <v>'value'<>)<>

or

<cb><v>config_parser<>['<v>section_name<>']['<v>property_name<>'] = <v>'value'<><>


Section <c><v>section_name<><> must exist.
<c><v>'value'<><> must be a string.
@
@ .set(), .update(), new, create



#### ConfigParser Property - Exists?

<cb>= <v>config_parser<>.has_option('<v>section_name<>', '<v>property_name<>')<>
@
@ contains, check, has, in, .has_option()



#### ConfigParser Property - Get

<cb>= <v>config_parser<>.get('<v>section_name<>', '<v>property_name<>')     <#>#1<><>

or

<cb>= <v>config_parser<>['<v>section_name<>']['<v>property_name<>']         <#>#2<><>


Returns: <c>str<>


\#1  -  Raises <c>configparser.NoSectionError<> if section not found.
\#1  -  Raises <c>configparser.NoOptionError<> if property not found.

\#2  -  Raises <c>NameError<> if section or property not found.
@
@ value, .get(), read



#### ConfigParser Property - Get or Default

<cb>= <v>config_parser<>.get('<v>section<>', '<v>property<>', fallback = '<v>fallback_value<>')<>


Returns: <c>str<>


Returns <c><v>fallback_value<><> if property not found.
@
@ value, .get(), read, default, fallback



#### ConfigParser Property - Get As Boolean

<cb>= <v>config_parser<>.getboolean('<v>section_name<>', '<v>property_name<>')<>


Returns: <c>bool<>



Raises <c>InvalidValue<> if not a boolean value.
Not case sensitive.



True Values:

<cb>true | yes | on | 1<>

False Values:

<cb>false | no | off | 0<>
@
@ value, .getbool(), .getboolean(), read



#### ConfigParser Property - Get As Integer

<cb>= <v>config_parser<>.getint('<v>section_name<>', '<v>property_name<>')<>


Returns: <c>int<>



Raises <c>InvalidValue<> if not an integer.
@
@ value, .getint(), read



#### ConfigParser Property - Get As Float

<cb>= <v>config_parser<>.getfloat('<v>section_name<>', '<v>property_name<>')<>


Returns: <c>float<>



Raises <c>InvalidValue<> if not a float.
@
@ value, .getfloat(), read



### ConfigParser Section

The ConfigParser section is a subclass of <c>MutableMapping<> (<c>collections.abc.MutableMap<>).
@
@ configparser.section, sectionproxy



#### ConfigParser Section - Add

<cb><v>config_parser<>.add_section('<v>section_name<>')<>

or

<cb><v>config_parser<>['<v>section_name<>'] = {}<>

or

<cb><v>config_parser<>['<v>section_name<>'] = {
	'<v>property-1<>': '<v>value-1<>',
	'<v>property-2<>': '<v>value-2<>',
	<v>...<>
}<>
@
@ add_section(), new, create



#### ConfigParser Section - Remove

<cb>= <v>config_parser<>.remove_section('<v>section_name<>')<>
@
@ remove_section()



#### ConfigParser Section - Exists?

<cb>= <v>config_parser<>.has_section('<v>section_name<>')<>
@
@ contains, check, has, in, .has_section()



#### ConfigParser Section - Get

<cb>= <v>config_parser<>['<v>section_name<>']<>


Raises <c>NameError<> if section not found.
@
@ read



#### ConfigParser Sections - Get All Section Names

<cb>= <v>config_parser<>.sections()<>


Returns: <c>list<> of <c>str<>


Returns a list of section names.
@
@ list of



### ConfigParser Section Properties



#### ConfigParser Section Property - Add / Update

<cb>= <v>section_1<>['<v>property_name<>'] = <v>'value'<><>
@
@ .set(), new, create



#### ConfigParser Section Property - Exists?

<cb>= '<v>property_name<>' in <v>section_1<><>
@
@ contains, check, has, in, .has_option()



#### ConfigParser Section Property - Get

<cb>= <v>section_1<>.get('<v>property_name<>')	<#>#1<><>

or

<cb>= <v>section_1<>['<v>property_name<>']		<#>#2<><>


\#1  -  Returns <c>None<> if not found.

\#2  -  Raises <c>KeyError<> if not found.
@
@ value, .get(), read



#### ConfigParser Section Property - Get As Boolean

<cb>= <v>section_1<>.getbool('<v>property_name<>')<>


Returns: <c>bool<>



Raises <c>InvalidValue<> if not a boolean value.
Not case sensitive.


True Values:

<cb>true | yes | on | 1<>

False Values:

<cb>false | no | off | 0<>
@
@ value, .getboolean(), .getbool(), read



#### ConfigParser Section Property - Get As Integer

<cb>= <v>section_1<>.getint('<v>property_name<>')<>


Returns: <c>int<>



Raises <c>InvalidValue<> if not an integer.
@
@ value, .getint(), read



#### ConfigParser Section Property - Get As Float

<cb>= <v>section_1<>.getfloat('<v>property_name<>')<>


Returns: <c>float<>



Raises <c>InvalidValue<> if not a float.
@
@ value, .getfloat(), read



#### ConfigParser Section Properties - Get All Names

<cb>= <v>config_parser<>.options(<v>section_name<>)<>

or

<cb>= list(<v>section_1<>.keys())<>


Returns: <c>list<> of <c>str<>


Returns a list of all the property names for that section.
@
@ list of property names, read



### ConfigParser - Iterate Over Values

<cb>for <v>section_name<> in <v>config_1<>.sections():

	<v>section<> = <v>config_1<>[<v>section_name<>]

	for <v>property_name<>, <v>value<> in <v>section<>.items():
		print(<v>section_name<>, <v>property_name<>, ":", <v>value<>)<>


Iterates over each section and displays all the properties and their values.
@
@ show all, configparser.sections()



### Ini File - Sample File

<cb><#># Comment line<>

[<v>section-1<>]
<v>property-1<> = <v>value 1<>
<v>property-2<> = <v>value 2<>

[<v>section-2<>]
<v>property-3<> = <v>value 3<>

[<v>types<>]
<v>bool-true-1<> = yes
<v>bool-true-2<> = true
<v>bool-true-3<> = 1
<v>bool-false<> = no

<v>int-1<> = <v>42<>
<v>float-1<> = <v>12.001<><>



## Internet / urllib
@
@ Http, Https, Urls, http-only, https-only, url-only, web, apis, io, links



### HTTP - Get

<cb>= urlopen(<v>url<>)<>

Usages:

<cb>from urllib.request import urlopen

with urlopen(<v>url<>) as response:
	<v>content<> = response.read()<>


Returns: <c>bytes<>


Makes a HTTP GET call to the url.


Example:

<cb>from urllib.request import urlopen

<v>url<> = "https://httpbin.org/get"

with urlopen(<v>url<>) as response:
	<v>content<> = response.read()

<v>text<> = <v>content<>.decode("utf-8", "ignore")

print("Response:", text)<>
@
@ urllib.request.urlopen, .request.urlopen(), .urlopen(), .read(), web page



### HTTP - Post

<cb>= urlopen(<v>url<>, data = <v>post_data<>)<>

Usage:

<cb>from urllib.request import urlopen

with urlopen(<v>url<>, data = <v>post_data<>) as response:
	<v>content<> = response.read()<>


Returns: <c>bytes<>


Makes a HTTP POST call when <c>data != None<>.


Example:

<cb>from urllib.request import urlopen
from urllib.parse import urlencode

<v>url<> = "https://httpbin.org/post"

<v>params<> = {
        "<v>param_1<>": "value 1",
        "<v>param_2<>": "value 2"}

<v>post_data<> = urlencode(<v>params<>).encode()

with urlopen(<v>url<>, data = <v>post_data<>) as response:
	<v>content<> = response.read()

<v>text<> = <v>content<>.decode("utf-8", "ignore")

print("Response:", text)<>
@
@ urllib.request.urlopen(), .request.urlopen(), .urlopen(), .read(), web page
@ urllib.parse.urlencode(), parse.urlencode(), .urlencode()



### HTTP - Handle Error

<cb>from urllib.request import urlopen
from urllib.error import HTTPError
from urllib.error import URLError

try:

	with urlopen(<v>url<>) as response:
		<v>content<> = response.read()
	<v>...<>

except URLError as <v>error<>:

	<#># Unable to make request...<>

	<v>message<> = <v>error<>.reason

except HTTPError as <v>error<>:

	<#># Server returned error...<>

	<v>status_code<> = <v>error<>.code
	<v>message<> = <v>error<>.reason
	<v>headers<> = <v>error<>.headers<>
@
@ status code
@ urllib.request.urlopen, .request.urlopen(), .urlopen(), .read()
@ urllib.error.HTTPError, urllib.error.URLError



### HTTP - URL - Escape

<cb>= quote(<v>url_1<>)<>

Usage:

<cb>from urllib.parse import quote

= quote(<v>url_1<>)<>


Example:

<cb><v>escaped<> = quote("<v>somewebsite.com/p/page numbered - 1<>")

<#># Returns 'somewebsite.com/p/page%20numbered%20-%201'<><>
@
@ urlib.parse.quote(), parse.quote(), .quote(), encode()
@ encode, uri



### HTTP - URL - Unescape

<cb>= unquote(<v>encoded_url_1<>)<>

Usage:

<cb>from urllib.parse import unquote

= unquote(<v>encoded_url_1<>)<>


Example:

<cb><v>url<> = unquote("<v>somewebsite.com/p/page%20numbered%20-%201<>")

<#># Returns 'somewebsite.com/p/page numbered - 1'<><>
@
@ urlib.parse.unquote(), parse.unquote(), .unquote(), decode()
@ decode, uri



### HTTP - URL Parameter - Escape

<cb>= quote_plus(<v>parameters_1<>)<>

Usage:

<cb>from urllib.parse import quote_plus

= quote_plus(<v>parameters_1<>)<>


Example:

<cb><v>escaped<> = quote_plus("<v>param1=param 1 value&param2= param 2 value<>")

<#># Returns 'param1%3Dparam+1+value%26param2%3D+param+2+value'<><>
@
@ urlib.parse.quote_plus(), parse.quote_plus(), .quote_plus(), encode()
@ encode



### HTTP - URL Parameter - Unescape

<cb>= unquote_plus(<v>encoded_parameter<>)<>

Usage:

<cb>from urllib.parse import unquote_plus

= unquote_plus(<v>encoded_parameter<>)<>


Example:

<cb><v>parameters<> = unquote_plus("<v>param1%3Dparam+1+value%26param2%3D+param+2+value<>")

<#># Returns 'param1=param 1 value&param2= param 2 value'<><>
@
@ urlib.parse.unquote_plus(), parse.unquote_plus(), .unquote_plus(), decode()
@ decode



## Pickle

Converts an object hierarchy into a byte stream so it can be saved and then restored later.

Unpickling is the inverse operation converting a byte stream back into the object hierarchy.
@
@ serialization



### Pickle - Pickle

<cb>import pickle

pickle.dump(<v>data<>, open(<v>file_name<>, "wb"))<>


Saves an object hierarchy as a binary file.
@
@ serialize, pickling, marshalling, open, to file
@ pickle.dump(), .dump()



### Pickle - Unpickle

<cb>import pickle

= pickle.load(open(<v>file_name<>, "rb"))<>


Converts a file back into the original object hierarchy.
@
@ deserialize, unpickling, unmarshalling, from file, read
@ pickle.load(), .load()



# Execute External Commands
@
@ executing, run, launch, process, subprocess
@ execute-only, exec-only, run-only, subprocess-only
@ execute-command-only, run-command-only



### Execute Command - Run

<cb>from subprocess import run

run(<v>command<>)<>

<cb>run([<v>command<>, <v>args_1<>, <v>args_2<>, <v>...<>])		<#>#1<><>


\#1  <s>-<>  Pass arguments with the command in a single list.


Example:

<cb>from subprocess import run

run(['ls', '-1'])<>
@
@ run(), subprocess.run()
@ arguments, args, parameters, params, call



### Execute Command - Run Shell Command

<cb>from subprocess import run

run(<v>command<>, shell = True)<>


Starts the shell and executes <c><v>command<><> on it.
Allows the script to run shell only commands (e.g. <c>echo<>).
<c><v>command<><> is a string with the complete command, arguments included.


Example:

<cb>from subprocess import run

run('echo "This is how to run a shell command."', shell=True)<>
@
@ run(), subprocess.run(), bash, shell script, call



### Execute Command - Get Exit Code

<cb>from subprocess import run

<v>results<> = run(<v>command<>)
<v>exit_code<> = <v>results<>.returncode<>

Returns: <c>int<>


Gets the exit code returned by the process after it completed.
@
@ run(), subprocess.run()
@ return code, return value, bash, shell script, call




### Execute Command - Get Standard Output

<cb>from subprocess import run
from subprocess import PIPE

<v>results<> = run(<v>command<>, stdout = PIPE)
<v>output<> = <v>results<>.stdout<>

Returns: <c>bytes<>


Captures the output sent to standard out.


Example:

<cb>from subprocess import run
from subprocess import PIPE

<v>results<> = run(['ls', '-1'], stdout = PIPE)
<v>output<> = <v>results<>.stdout
print(<v>output<>.decode("utf-8"))
<>
@
@ run(), subprocess.run(), stdout, subprocess.PIPE
@ capture output, console, stdout, bash, shell script



# Testing
@
@ Unit Tests, test-only, testing-only, unit-only, unit-test-only, unit-tests-only



### Test - Basics

<cb>from unittest import TestCase

class <v>TestMyStuff<>(TestCase):

	def setUp(self):					<#># Run Before Every Test<>
		<v>...<>

	def tearDown(self):					<#># Run After Every Test<>
		<v>...<>

	def test<v>_this_function<>(self)		<#># Name Must Start With <c>test<><>
		<v>...<><>
@
@ unittest.testcase, testcase, setup(), teardown(), test_
@ examples, summary



### Test - Example

<cb>from unittest import TestCase

class <v>BasicTest<>(TestCase):

	def setUp(self):
		self.<v>field1<> = True

	def tearDown(self):
		self.<v>field1<> = None

	def test<v>_IsTrue<>(self):
		self.assertTrue(self.<v>field1<>, "<v>failed_assertion_message<>")

	def test<v>_IsFalse<>(self):
		self.assertFalse(self.<v>field1<>, "<v>failed_assertion_message<>")<>
@
@ unittest.testcase, testcase, setup(), teardown(), test_



## Test - Definition
@
@ unittest.TestCase



### Test - Define - Class

<cb>class <v>TestClass1<>(TestCase):<>

Usage:

<cb>from unittest import TestCase

class <v>TestClass1<>(TestCase):

	def test<v>_function_1<>(self):
		<v>...<><>


Defines a test class.

All test functions must start with <c>test_<>.
@
@ new, create, definition
@ unittest.testcase, testcase, test_



### Test - Define - Function

<cb>def test<v>_function_1<>(self):<>

Usage:

<cb>from unittest import TestCase

class <v>TestClass1<>(TestCase):

	def test<v>_function_1<>(self):
		<v>...<><>


Defines a test function.

Test functions must start with <c>test_<>.
@
@ new, create, definition, def
@ unittest.testcase, testcase, test_, def



### Test - Define - Setup

<cb>class <v>TestClass1<>(TestCase):

	def setUp(self):
		<v>...<><>

Sets up the test environment before each test.

Add whatever data is needed to the class instance.
Runs before every test.
@
@ setup(), initialize, pre, fixtures



### Test - Define - Teardown

<cb>class <v>TestClass1<>(TestCase):

	def tearDown(self):
		<v>...<><>

Tears down the test environment after each test is run.

Runs after every test.
Runs even if test fails.
@
@ tear down
@ deconstructor, post, teardown(), fixtures



### Test - Define - Unit Test

<cb>class <v>TestClass1<>(TestCase):

	def test_<v>unit_test_name<>(self):
		<v>...<><>

Method names must start with '<c>test<>'.
@
@ testcase, test_



## Test Assertions



### Test Assertion - Equals

<cb>self.assertEqual(<v>actual<>, <v>expected<>, <v>comment<>)<>


Use <c>.assertEqual().
<!>.assertEquals()<> is deprecated.
@
@ is equal, assertequal(), self.assertequal(), , self.assertequals()



### Test Assertion - Not Equals

<cb>self.assertNotEqual(<v>actual<>, <v>expected<>, <v>comment<>)<>
@
@ assertnotequal(), self.assertnotequal(), is not equal



### Test Assertion - Contains

<cb>self.assertIn(<v>substring<>, <v>full_string<>, <v>comment<>)<>

Returns true if <c><v>substring<><> is in <c><v>full_string<><>.
@
@ substring, is in
@ assertin(), self.assertin()



### Test Assertion - Not Contains

<cb>self.assertNotIn(<v>substring<>, <v>full_string<>, <v>comment<>)<>


Returns true if <c><v>substring<><> is not in <c><v>full_string<><>.
@
@ substring, is not in
@ assertnotin(), self.assertnotin()



### Test Assertion - Is False

<cb>self.assertFalse(<v>actual<>, <v>comment<>)<>
@
@ boolean, not
@ assertfalse(), self.assertfalse()



### Test Assertion - Is None

<cb>self.assertIsNone(<v>actual<>, <v>comment<>)<>
@
@ boolean
@ self.assertisnone(), self.isnone()



### Test Assertion - Not None

<cb>self.assertIsNotNone(<v>actual<>, <v>comment<>)<>
@
@ boolean, not
@ is, self.assertisnotnone(), self.assertnotnone(),



### Test Assertion - Is True

<cb>self.assertTrue(<v>actual<>, <v>comment<>)<>
@
@ boolean
@ asserttrue(), self.asserttrue()



### Test Assertion - Exception Raised?

<cb>self.assertRaises(<v>ExceptionType<>, <v>function_1<>)<>

Calls the method to be tested (<c><v>function_1<><>).
Fails if the exception <c><v>ExceptionType<><> is not raised.
@
@ error, raises
@ assertraises(), self.assertraises()



### Test Assertion - Fail

<cb>self.fail()<>

Fails test immediately.
@
@ fail(), self.fail()



### Test Assertion - Attribute Exists

<cb>self.assertTrue(
	hasattr(obj, intendedAttr),
	msg=f'obj lacking an attribute. {obj=}, {intendedAttr=}')<>
@
@ assertTrue(), hasattr()



## Test Setup


### Test Setup - Define Source Folder

Given:

<cb><v>project_dir<>/
├─ src/
└─ tests/<>

Create:

<cb><v>tests<>/__init__.py<>

Contents:

<cb>from os import getcwd
from os.path import join
from sys import path

PROJECT_PATH = getcwd()
path.append (join (PROJECT_PATH, "<v>src<>"))<>


Defines the project source directory for tests to use.

Create __init__.py in tests folder and add the code.
If the source folder is other than <v><c>src<><>, change <v><c>src<><> (above) to match.
Run tests from the project root directory.
@
@ set
@ __init__.py, src, tests, path, directory



# doctest

A doctest is one or more tests written into the docstring.
They follow the format of python cli commands followed by their output.


Official Docs: 
<l>https://docs.python.org/3/library/doctest.html<>
@
@ doc tests, comments



### doctest - Basics

Define:

<cb>def <v>square<>(<v>x<>):
    <#>""" squares a number<>

    >>> square(<v>2<>)
    <v>4<>
    
    <#>"""<>

    return <v>x<> ** 2<>

Enable:

<cb>if __name__ == "__main__":
    import doctest
    doctest.testmod()<>

Run:

<cb>python3 <v>script<>.py<>
@
@ summary



### doctest - Define

<cb>def <v>function_1<>():
    <#>""" Function Description<>

    >>> function_1(<v>param_a<>)
    <v>result a<>
    
    >>> function_1(<v>param_b<>)
    <v>result b<>
    
    <#>"""<>

    <v>...<><>


Example:

<cb>def <v>square<>(<v>x<>):
    <#>""" squares a number<>

    >>> square(<v>2<>)
    <v>4<>
    
    <#>"""<>

    return <v>x<> ** 2<>


### doctest - Define Exception


<cb>def <v>function_1<>():
    <#>""" Function Description

    >>> function_1()
	Traceback (most recent call last):
	...
	<v>Stack Trace, Last Line<>
    
    """<>

    <v>...<><>


Example:

<cb>def <v>square<>(<v>x<>):
    <#>""" squares a number<>

    >>> square(<v>'a'<>)
	Traceback (most recent call last):
	...
	TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'int'
    
    <#>"""<>

    return <v>x<> ** 2<>



### doctest - Run

In Script File:

<cb>if __name__ == "__main__":
    import doctest
    doctest.testmod()<>

Command Line:

<cb>python3 <v>script<>.py<>



Verbose:

<cb>python3 <v>script<>.py -v<>




# Type Hints

Official Docs: <l "https://docs.python.org/3/library/typing.html">Typing<>
@
@ Static Typing, :, annotations, type-hints-only, type-annotations-only



### Type Hints - Any Type

<cb><v>item_1<>: Any<>

Usage:

<cb>from typing import Any

<v>item_1<>: Any
<v>list_1<>: list[Any]<>


Tells the type checker to ignore this type.
@
@ typing.any



### Type Hints - Dict Type

<cb><v>dict_1<>: Dict[str, str]<>

Usage:

<cb>from typing import Dict

<v>dict_1<>: Dict[<v>key_type<>, <v>value_type<>]<>
@
@ typing.dict



### Type Hints - Function Definition

<cb>def <v>function_1<>(<v>param_1<>: <v>type<>) -> <v>return_type<>:
	<v>...<><>


Defines the function parameter types and the return type.


Example:

<cb>def <v>area<>(<v>height<>: <v>float<>, <v>width<>: <v>float<>) -> float:
	return <v>height<> * <v>width<><>
@
@ ->, def, definition, parameters, return



### Type Hints - Function With Default Values

<cb>def <v>function_1<>(<v>param_1<>: <v>type<> = <v>default_value<>):
	<v>...<><>


Define the parameter type before the equals (<c>=<>).
@
@ def, definition, parameters



### Type Hints - Function Type

<cb><v>function_1<>: Callable<>

Usage:

<cb>from typing import Callable

def <v>main_function<>(<v>function_1<>: Callable):
	<v>...<><>


Identifies a parameter as a function.


Example:

<cb>from typing import Callable

def <v>print_message<>():
	print('the message.')

def call_message_function(<v>message_function<>: Callable):
	<v>message_function<>

call_message_function(<v>print_message<>)

<#># Prints: 'the message'<><>
@
@ type.callable, callable
@ ->, def, passing



### Type Hints - List Type

<cb><v>list_1<>: List[str]<>

Usage:

<cb>from typing import List

<v>list_1<>: List[<v>type<>]<>


Examples:

<cb><v>names<>: List[str]<>

<cb>from typing import Any

<v>items<>: List[Any]<>
@
@ typing.list



### Type Hints - None Type

<cb><v>item_1<>: None<>


Defines a type as <c>None<>.

This is normally done when None is one of the types a value can have.


Example:

<cb><v>string_1<>: str | None<>



### Type Hints - Tuple Type

<cb><v>tuple_1<>: Tuple[str, float]<>

Usage:

<cb>from typing import Tuple

<v>tuple_1<>: Tuple[<v>type_1<>, <v>type_2<>, <v>...<>]<>
@
@ typing.tuple



### Type Hints - Variable Type

<cb><v>name<>: <v>type<><>


Defines the type of a variable.
The type is not compiler enforced.


Basic Types:

<cb>bool, int, complex, float, str<>


Examples:

<cb><v>id<>: int<>

<cb><v>descrption<>: str<>

<cb><v>home_address<>: Address<>



### Type Hints - Variable Type, Subtype /  Generics

<cb><v>name<>: <v>type<>[<v>subtype<>]<>

<cb><v>name<>: <v>type<>[<v>subtype_1<>, <v>subtype_2<>]<>


Defines the type and subtype of a variable.
The type is not compiler enforced.


Basic Types:

<cb>tuple, list, dict<>


Examples:

<cb><v>names<>: list[str]<>

<cb><v>name_and_id<>: tuple[str, int]<>

<cb><v>addresses<>: dict[int, Address]<>
@
@ dict, list, tuple



### Type Hints - Variable Type, Multiple Types

<cb><v>name<>: <v>type1<> | <v>type2<> | <v>type3<><>


Define a variable that may have one of many types by separating the types with the pipe symbol (<c>|<>).



Examples:

<cb><v>id<>: int | str | None<>



# Virtual Environments

Use the <c>venv<> package to create a local python environment separate from the system environmnent.

This will allow your application to load and run it's own libraries in it's own version of python.
@
@ Venv, venv-only, virtual-only



### Virtual Environment - Create

<cb>python3 -m venv <v>venv_directory<><>

Creates a virtual environment in the directory <c><v>venv_directory<><>.


Typical Example:

<cb>python3 -m venv <v>venv<><>
@
@ python3 -m



### Virtual Environment - Upgrade

<cb>python3 -m venv --upgrade <v>venv_directory<><>


Typical Example:

<cb>python3 -m venv --upgrade <v>venv<><>
@
@ update
@ python3 -m --upgrade



### Virtual Environment - Start / Use

Bash:

<cb>. <v>venv_directory<>/bin/activate<>

DOS:

<cb><v>venv_directory<>\\Scripts\\activate<>

Run from the project root directory.
Run this bash script from the command-line.


Typical Example:

Bash:

<cb>. <v>venv<>/bin/activate<>

DOS:

<cb><v>venv<>\\Scripts\\activate<>
@
@ start, run, activate
@ /bin/activate



### Virtual Environment - Start Venv and Run Program

Bash:

<cb>. <v>venv_directory<>/bin/python <v>python_path/module.py<><>

DOS:

<cb><v>venv_directory<>\\Scripts\\python <v>python_path/module.py<><>

Starts the venv and then runs the module in that environment.

Run from the project root directory.
Run this bash script from the command-line.


Typical Example:

Bash:

<cb>. <v>venv<>/bin/python <v>src/__main__.py<><>

DOS:

<cb><v>venv<>\\Scripts\\python <v>src/__main__.py<><>
@
@ start, run, activate, execute, program, script
@ /bin/activate



### Virtual Environment - Exit

<cb>deactivate<>

Run <c>deactivate<> to exit the venv environment.
@
@ end, stop, deactivate



### Virtual Environment Variable

<cb>VIRTUAL_ENV<>

Contains the path to the parent of the virtual environment bin directory.
@
@ VIRTUAL_ENV



# Environment Variables


### Environment Variable - Exists?

<cb>from os import environ

= '<v>name<>' in environ<>


Returns true if the environment variable <v>name<> is set.


Example:

<cb>from os import environ

if 'PYTHONPATH' in environ:
	print ('PYTHONPATH exists.')
else:
	print ('PYTHONPATH does not exist.')<>
@
@ os.environ



### Environment Variable - Get

<cb>= environ['<v>name<>']<>

Usage:

<cb>from os import environ

= environ['<v>name<>']          <#>#1<><>

<cb>= environ.get('<v>name<>')      <#>#2<><>

<cb>= environ.get('<v>name<>', <v>default_value<>)<>

\#1  <s>-<>  Raises <c>KeyError<> if not found.

\#2  <s>-<>  Returns <c>None<> if not found.


Reads the value of the environment variable.


Equivalent To:

<cb>= os.getenv(<v>name<>)<>


Example:

<cb>from os import environ

print (environ['PYTHONPATH'])<>
@
@ value, read
@ getenv, os.environ



### Environment Variable - Get All

<cb>from os import environ

= environ.keys()<>


Example:

<cb>from os import environ

for <v>key<> in sorted(environ.keys(), key = str.lower):
	print(f'{<v>key<>:\<24}  {environ[<v>key<>]}')

print(f'{"Count":\<24}  {len(environ.keys())}')<>
@
@ read all, values
@ getenv, os.environ, keys()



### Environment Variable - Set

<cb>from os import environ

environ['<v>name<>'] = <v>value<><>


<c><v>value<><> must be a string.
@
@ value
@ os.environ



### Environment String - Expand

<cb>from os.path import expandvars

= expandvars('<v>...<> ${<v>VARIABLE_NAME<>} <v>...<>')<>


Example:

<cb><v>python_path<> = expandvars('The python path is ${PYTHONPATH}')<>
@
@ variable, os.path.expandvars()



# Parallelism



## Thread

The smallest sequence of instructions that can be managed by the OS.

Great for IO bound operations.
Do not use for CPU bound operations.


Each Thread Has:

	Registers
	Stack

Threads Share:

	Common Memory
	Resources

Local Variables

	Stored on thread's stack

Thread Synchronization

	Use Lock
	Use Semaphore
	Use Queue
@
@ thread-only, threads-only, threading-only, .thread(), therading.thread()
@ multitasking



### Thread - Basics
@
@ summary


#### Thread - Basic Thread

<cb>from threading import Thread<>

Create:

<cb><v>thread_1<> = Thread(
		target = <v>worker_function<>,
		args = (<v>worker_argument_1<>,)<>

Start:

<cb><v>thread_1<>.start()<>

Wait for Completion:

<cb><v>thread_1<>.join()<>



#### Thread - Basic Thread Class

<cb>from threading import Thread<>

Define:

<cb>class <v>ThreadClass<>(Thread):

	def run(self):
		<v>...<><>

Create:

<cb><v>thread_1<> = ThreadClass()<>

Start:

<cb><v>thread_1<>.start()<>

Wait for Completion:

<cb><v>thread_1<>.join()<>



### Thread - Create
@
@ new, define, instantiate



#### Thread - Create Thread

<cb>from threading import Thread<>

Create:

<cb><v>thread_1<> = Thread(
		target = <v>worker_function<>,
		args = (<v>worker_argument_1<>,)<>

Create With Name:

<cb><v>thread_1<> = Thread(
		name = "<v>thread name<>",
		<v>...<>)<>



#### Thread - Create Thread Class

<cb>from threading import Thread<>

Define:

<cb>class <v>ThreadClass<>(Thread):		<#>#1<>

	def __init__(self):
		Thread.__init__()

	def run(self):				<#>#2<>
		<v>...<><>

Create:

<cb><v>thread_1<> = ThreadClass()<>


\#1  -  Inherit from <c>Thread<>

\#2  -  Override <c>run()<>



#### Thread - Create Thread Class - With Arguments

<cb>from threading import Thread<>

Define:

<cb>class <v>WorkerClass<>(Thread):

	def __init__(self, <v>argument_1<>, <v>...<>):
		Thread.__init__(self)		<#>#1<>
		<v>...<><>

Start:

<cb><v>worker_1<> = WorkerClass(<v>argument_1<>, <v>...<>)<>


\#1  -  Must call <c>Thread.__init__()<>
\#1  -  Must Be First Line In <c>__init__<> Method



### Thread - Operations



#### Thread - Start

<cb><v>thread_1<>.start()<>


Starts the execution of the thread.
The thread is initially stopped.
@
@ thread.start(), .start()
@ class, initialize



#### Thread - Stop On Application Exit

<cb><v>thread_1<>.daemon = True<>


Stops execution when the parent or main thread terminate.
Must be called before calling <c>.start()<>.
@
@ thread.daemon, .daemon
@ end, terminate, kill



#### Thread - Wait For Completion

<cb><v>thread_1<>.join()<>

Blocks the current thread until <c><v>thread_1<><> completes.
@
@ thread.join(), .join(), block



#### Thread - Is Alive?

<cb>= <v>thread_1<>.is_alive()<>

Is alive means it is actively running.
<c>False<> when either not started or is terminated.
@
@ Not Terminated



#### Thread - Is Terminated?

<cb>= not <v>thread_1<>.is_alive()<>

Will be <c>True<> after the thread terminates.
Must call <c>.start()<> first.
@
@ Not Terminated



## Process

A running instance of a program.

It has:

	System Resources
	Assigned Memory Space
	Security Attributes
	Process State

Each Process Has:

	It's Own GIL
	Self Contained Memory

Processes can be paused or terminated.

Processes have a big memory footprint.
Context switch between processes is expensive.
@
@ processes, processing, process-only, processes-only, processing-only
@ multiprocessing.process(), .process()
@ multitasking


### Process - Basics
@
@ summary


#### Process - Basic Process

<cb>from processing import Process<>

Create:

<cb><v>process_1<> = Process(
		target = <v>worker_function<>,
		args = (<v>worker_argument_1<>,)<>

Start:

<cb><v>process_1<>.start()<>

Wait for Completion:

<cb><v>process_1<>.join()<>



#### Process - Basic Process Class

<cb>from processing import Process<>

Define:

<cb>class <v>ProcessClass<>(Process):

	def run(self):
		<v>...<><>

Create:

<cb><v>process_1<> = ProcessClass()<>

Start:

<cb><v>process_1<>.start()<>

Wait for Completion:

<cb><v>process_1<>.join()<>



### Process - Create


#### Process - Create Process

<cb>from processing import Process<>

Create:

<cb><v>process_1<> = Process(
		target = <v>worker_function<>,
		args = (<v>worker_argument_1<>,)<>

Create With Name:

<cb><v>process_1<> = Process(
		name = "<v>process name<>",
		<v>...<>)<>



#### Process - Create Process Class

<cb>from processing import Process<>

Define: 

<cb>class <v>ProcessClass<>(Process):	<#>#1<>

	def run(self):				<#>#2<>
		<v>...<><>

Create:

<cb><v>process_1<> = ProcessClass()<>


\#1  -  Inherit from <c>Process<>

\#2  -  Override <c>run()<>



#### Process - Create Process Class - With Arguments

<cb>from processing import Process<>

Define:

<cb>class <v>WorkerClass<>(Process):

	def __init__(self, <v>argument_1<>, <v>...<>):
		Process.__init__(self)			<#>#1<>
		<v>...<><>

Start:

<cb><v>worker_1<> = WorkerClass(<v>argument_1<>, <v>...<>)<>


\#1  -  Must call <c>Process.__init__()<>
\#1  -  Must Be First Line In <c>__init__<> Method



### Process - Operations



#### Process - Start

<cb><v>process_1<>.start()<>


Starts the execution of the process.
The process is initially stopped.
@
@ process.start(), .start()



#### Process - Stop on Application Exit

<cb><v>process_1<>.daemon = True<>


Stops execution when the parent or main process terminate.
Must be called before calling <c>.start()<>.
@
@ process.daemon, .daemon
@ end, terminate, kill


#### Process - Terminate

<cb><v>process_1<>.terminate()<>

May cause issues such as putting the system into an inconsistent state.
Will not run any finally clauses or exit handlers. Its Dead!

Prefer something like a poison pill.
@
@ process.terminate(), .terminate()
@ end, terminate, kill, stop



#### Process - Wait For Completion

<cb><v>process_1<>.join()<>

Blocks the current process until <c><v>process_1<><> completes.
@
@ process.join(), .join(), block



#### Process - Get Exit Code

<cb>= <v>process_1<>.exitcode<>

Values:

	0 -     No Error
	1 -     Error
	< 0 -       Terminated.
			Terminating Signal code = .exitcode * -1
@
@ process.exitcode, .exitcode



#### Process - Is Alive?

<cb>= <v>process_1<>.is_alive()<>

Is alive means it is actively running.
<c>False<> when either not started or is terminated.
@
@ Not Terminated



#### Process - Is Terminated?

<cb>= not <v>process_1<>.is_alive()<>

Will be <c>True<> after the process terminates.
Must call <c>.start()<> first.
@
@ Not Terminated



## Process Pool
@
@ pool-only, pools-only, process-pools-only, multiprocessing.pool(), .pool()
@ process-pool-only, process-pools-only



### Pool - Basics

<cb>from multiprocessing import Pool<>

Create:

<cb><v>pool_1<> = Pool(<v>process_count<>)<>


Run Single Task:

<cb><v>result<> = <v>pool_1<>.apply(<v>worker_function<>, <v>arguments<>)<>

Run Single Task Asynchronously:

<cb><v>async_result<> = <v>pool_1<>.apply_async(<v>worker_function<>, <v>arguments<>)<>

Run Series of Task:

<cb><v>results<> = <v>pool_1<>.map(<v>worker_function<>, <v>list_of_inputs<>)<>

Run Series of Tasks Asynchronously:

<cb><v>async_result<> = <v>pool_1<>.map_async(<v>worker_function<>, <v>list_of_inputs<>)<>


Close:

<cb><v>pool_1<>.close()<>

Wait Until All Complete:

<cb><v>pool_1<>.join()<>
@
@ summary



### Pool - Create

<cb>from multiprocessing import Pool<>

Create (Processes = Number of CPUs):

<cb><v>pool_1<> = Pool()<>

Create:

<cb><v>pool_1<> = Pool(<v>process_count<>)<>

Create All Options:

<cb><v>pool_1<> = Pool(
		processes = <v>process_count<>,
		initializen = <v>initializing_function<>,
		initargs = <v>initial_arguments<>,
		maxtasksperchild = <v>number_of_tasks<>)<>


By default processes live as long as the pool is alive.
Note the initial arguments do not need to be picklable!
@
@ New, Instantiate



### Pool - Operations



#### Pool - Close

<cb><v>pool_1<>.close()<>


Prevents any new tasks being added to the pool.
@
@ pool.close(), .close()



#### Pool - Perform Single Operation

<cb>= <v>pool_1<>.apply(<v>worker_function<>, <v>args<>)<>

<cb>= <v>pool_1<>.apply(
		func = <v>worker_function<>,
		args = <v>args<>,
		kwargs = <v>kwargs<>)<>


Returns: Result


Performs <v>worker_function<> on <v>args<>.
<c>apply()<> blocks until the worker function is done.
@
@ pool.apply(), .apply()



#### Pool - Perform Single Operation Asynchronously

<cb>= <v>pool_1<>.apply_async(
		<v>worker_function<>,
		<v>list_of_inputs<>)<>

<cb>= <v>pool_1<>.apply_async(
		func = <v>worker_function<>,
		args = <v>args<>,
		kwargs = <v>kwargs<>,
		callback = <v>callback_function<>
		error_callback = <v>error_handler<>)<>


Returns: <c>AsyncResult<>


<c>apply_async()<> does not block.
@
@ pool.apply_async(), .apply_async(), async_result



#### Pool - Get Single Async Result

<cb>= <v>async_result<>.get()<>

<cb>= <v>async_result<>.get(<v>timeout_seconds<>)<>


Returns: The Actual Result


<c>.get()<> blocks until all processes are finished.
@
@ pool.apply_async(), .apply_async(), asyncresult.get(), async_result.get(), .get()
@ value, async_result



#### Pool - Perform Multiple Operations

<cb><v>list_of_result<> = <v>pool_1<>.map(<v>worker_function<>, <v>list_of_arguments<>)<>


Performs <v>worker_function<> on all poll processes
This call blocks until all results are in.
<v>worker_function<> should take a single parameter which will be given from <c><v>list_of_arguments<><>.
@
@ pool.map(), .map()



#### Pool - Perform Multiple Operations Asynchronously

<cb>= <v>pool_1<>.map_async(
		<v>worker_function<>,
		<v>list_of_inputs<>)<>

<cb>= <v>pool_1<>.map_async(
		<v>worker_function<>,
		<v>list_of_inputs<>,
		callback = <v>callback_function<>,
		error_callback = <v>error_callback_function<>)<>


Returns: <c>AsyncResult<>


<c>map_async() does not block.
@
@ pool.map_async(), .map_async()



#### Pool - Get Map Async Results

<cb>= <v>async_result<>.get()<>

<cb>= <v>async_result<>.get(<v>timeout_seconds<>)<>


Returns: List of Actual Results


<c>.get()<> blocks until all processes are finished.
@
@ pool.map_async(), .map_async, asyncresult.get(), .get()
@ value



#### Pool - Terminate

<cb><v>pool_1<>.terminate()<> 
@
@ pool.terminate(), .terminate()



#### Pool - Wait

<cb><v>pool_1<>.join()<>


Blocks until all pool worker processes exit.
Can only be called after .close() or .terminate()
@
@ pool.join()



## Pool Executor

Abstract Class:

<cb>Executor<>

Concrete Classes:

<cb>concurrent.futures.ThreadPoolExecutor<>

<cb>concurrent.futures.ProcessPoolExecutor<>
@
@ PoolExecutor



### Pool Executor - Create


#### ProcessPoolExecutor - Create

<cb>from concurrent.futures import ProcessPoolExecutor<>

<cb>= ProcessPoolExecutor()<>

<cb>= ProcessPoolExecutor (
	max_workers = <v>worker_count<>)<>


max_workers default = # computer cores * 5
@
@ concurrent.futures.ProcessPoolExecutor



#### ProcessPoolExecutor - Create Using With

<cb>from concurrent.futures import ProcessPoolExecutor<>

<cb>with ProcessPoolExecutor() as <v>executor_1<>
	<v>...<><>
@
@ concurrent.futures.ProcessPoolExecutor, Process Pool Executor



#### ThreadPoolExecutor - Create

<cb>from concurrent.futures import ThreadPoolExecutor<>

<cb>= ThreadPoolExecutor()<>

<cb>= ThreadPoolExecutor (
	max_workers = <v>worker_count<>,
	thread_name_prefix = '<v>prefix_name<>')<>


max_workers default = # computer cores * 5
@
@ concurrent.futures.ThreadPoolExecutor, Thread Pool Executor



#### ThreadPoolExecutor - Create Using With

<cb>from concurrent.futures import ThreadPoolExecutor<>

<cb>with ThreadPoolExecutor() as <v>executor_1<>
	<v>...<><>
@
@ Thread Pool Executor, concurrent.futures.ThreadPoolExecutor



### Pool Executor - Operations



#### Executor - Submit Task

<cb><v>future_1<> = <v>executor_1<>.submit(<v>worker_function<>, *args, **kwargs)<>


Returns: <c>concurrent.futures.Future<>


Submits a single task.
<c>submit()<> does not block.

For ProcessPoolExecutor, make sure the worker function and arguments are pickleable!
@
@ executor.submit(), .submit()
@ concurrent.futures.ProcessPoolExecutor, Process Pool Executor
@ Thread Pool Executor, concurrent.futures.ThreadPoolExecutor



#### Executor - Submit Task Map

<cb><v>list_of_results<> = <v>executor_1<>.map(<v>worker_function<>, <v>list_of_arguments<>)<>

<cb><v>list_of_results<> = <v>executor_1<>.map (
		func = <v>worker_function<>,
		iterables = <v>list_of_arguments<>,
		timeout = <v>timeout_seconds<>,
		chunksize = 1)<>


Returns: <c>result_iterator<> (an iterator)


Submit multiple requests to the task.
<c>map()<> does not block.

For ProcessPoolExecutor, make sure the worker function and arguments are pickleable!
@
@ executor.map(), .map()
@ concurrent.futures.ProcessPoolExecutor, Process Pool Executor
@ Thread Pool Executor, concurrent.futures.ThreadPoolExecutor



#### Executor - Shutdown

<cb><v>executor_1<>.shutdown()<>

Block Until Complete:

<cb><v>executor_1<>.shutdown(wait = True)<>
@
@ executor.shutdown(), .shutdown()
@ concurrent.futures.ProcessPoolExecutor, Process Pool Executor, wait
@ Thread Pool Executor, concurrent.futures.ThreadPoolExecutor



## Concurrent Future
An object that is a proxy for a future result that has yet to be computed.

<cb>concurrent.futures.Future<>

Futures can raise exceptions.
@
@ submit(), executor.submit(), concurrent.futures.Future



#### Future - Cancel

<cb>= <v>future_1<>.cancel()<>


Returns: <c>bool<>


Attempts to cancel a request.
Returns <c>True<> if successful.
@
@ future.cancel(), .cancel()
@ stop, kill, end, terminate



#### Future - Is Complete?

<cb>= <v>future_1<>.done()<>
@
@ future.done(), .done(), done? stopped, terminated



#### Future - Get Value

<cb>= <v>future_1<>.result()<>


<c>result()<> blocks until the result is available.
@
@ future.result(), .result(), 



#### Future - Get With Exception Handling

<cb>try:
	<v>result<> = <v>future_1<>.result()
except Exception as <v>exception<>:
	<v>...<><>


Exceptions are returned through the future itself.
@
@ future.result(), .result(), 



#### Future - Get Exception

<cb>= <v>future_1<>.exception()<>

<cb>= <v>future_1<>.exception(timeout = <v>timeout_seconds<>)<>

<c>exception()<> blocks until a result is available unless a timeout is specified.
@
@ future.exception(), .exception(), future.getexception(), .getexception(), 



#### Future - Add Callback Function

<cb>= <v>future_1<>.add_done_callback(<v>callback_function<>)<>


Exceptions are not returned the the callback function.
@
@ future.add_done_callback(), .add_done_callback(), 



#### Futures - Wait Until All Complete

<cb>from concurrent.futures import wait
from concurrent.futures import ALL_COMPLETE<>

<cb>wait(<v>futures<>)<>

<cb>wait(<v>futures<>, timeout = <v>timeout_seconds<>, return_when = ALL_COMPLETE)<>

<v>futures<> is a list of futures to wait for.
Blocks until all futures are complete.
@
@ concurrent.futures.wait(), .futures.wait(), .wait()



#### Futures - Wait Until First Complete

<cb>from concurrent.futures import wait
from concurrent.futures import FIRST_COMPLETE<>

<cb>wait(<v>futures<>, timeout = <v>timeout_seconds<>, return_when = FIRST_COMPLETE)<>


<v>futures<> is a list of futures to wait for.
Blocks until the first future completes.
@
@ concurrent.futures.wait(), .futures.wait(), .wait()



#### Futures - Process As Completed

<cb>from concurrent.futures import as_completed<>

<cb>= as_completed(<v>futures<>)<>

<cb>= as_completed(<v>futures<>, timeout = <v>timeout_seconds<>)<>


Returns: iterable



## Pipe

Pipes allow communication between processes.
Pipes are bidirectional by default.
Contains no locks and no guarantees.
If two processes write to the same side of the queue, data can get corrupt.
@
@ multiprocessing.pipe(), .pipe(), pipe-only, pipes-only
@ process-pipe-only, process-pipes-only



### Pipe - Create



#### Pipe - Create - Bidirectional (Default)

<cb>from multiprocessing import Pipe<>

<cb><v>connection_1<>, <v>connection_2<> = Pipe()<>


Pass <c><v>connection_1<><>, <c><v>connection_2<><> to the target processes.
Ensure each process should send on one connection and receive on the other.

Example:

	Process 1 should send on  <c><v>connection_1<><>, and receive on <c><v>connection_2<><>.
	Process 2 should send on  <c><v>connection_2<><>, and receive on <c><v>connection_1<><>.



#### Pipe - Create - Unidirectional

<cb>from multiprocessing import Pipe<>

<cb><v>connection_receive<>, <v>connection_send<> = Pipe(False)<>


Pass <c><v>connection_receive<><>, <c><v>connection_send<><> to the target processes.



### Pipe - Operations



#### Pipe - Receive Data

<cb>= <v>connection_1<>.recv()<>


Blocks until a message is received.
@
@ Message



#### Pipe - Send Data

<cb><v>connection_1<>.send(<v>data<>)<>
@
@ Message



## Queues for Multitasking

The preferred way to communicate between threads or processes.
@
@ queue-only, queues-only, .queue(), parallel
@ process-queue-only, process-queues-only
@ thread-queue-only, thread-queues-only
@ multi-queue-only, multi-queues-only, multitask-queue-only, multitask-queues-only, multitasking-queue-only, multitasking-queues-only



### Queue - Create

#### Thread Queue - Create

<cb>from queue import Queue<>

<cb>= Queue()<>

<cb>= Queue(<v>max_size<>)<>
@
@ threading.queue(), queue.queue(), queue(), threads



#### Process Queue - Create

<cb>from multiprocessing import Queue<>

<cb>= Queue()<>

<cb>= Queue(<v>max_size<>)<>
@
@ multiprocessing.queue(), processes



### Queue - Operations
@
@ threading.queue(), threads



#### Queue - Add

<cb><v>queue_1<>.put(<v>value_1<>)<>

<cb><v>queue_1<>.put(
		obj = <v>value<>
		block = <v>true_or_false<>,
		timeout = <v>timeout_seconds<>)<>
@
@ put, append, insert, append to, .put()
@ multiprocessing.queue(), processes



#### Queue - Get Next

<cb>= <v>queue_1<>.get()                           <#>#1<><>

<cb>= <v>queue_1<>.get(
		block = <v>true_or_false<>,
		timeout = <v>timeout_seconds<>)<>

or

<cb>= <v>queue_1<>.get_nowait()                    <#>#2<><>


Get next item.


\#1  <s>-<>  If no items, waits until one becomes available.

\#2  <s>-<>  If no items, raises <c>QueueEmpty<>.
@
@ .get(), .get_nowait(), no wait
@ multiprocessing.queue(), processes



#### Queue - Is Empty?

<cb>= <v>queue_1<>.empty()<>

Returns: <c>bool<>

Returns <c>True<> if empty.
@
@ .empty()
@ multiprocessing.queue(), processes



#### Queue - Is Full?

<cb>= <v>queue_1<>.full()<>

Returns: <c>bool<>

Returns <c>True<> if the queue is full and can't take any more items.
@
@ .empty()
@ multiprocessing.queue(), processes



#### Queue - Maximum Size

<cb>= <v>queue_1<>.maxsize<>


Returns the maximum allowed size of the queue.
Returns 0 if no maximum set.
@
@ count, length, .maxsize
@ multiprocessing.queue(), processes



#### Queue - Size

<cb>= <v>queue_1<>.qsize()<>

Returns the number of items in the queue.
@
@ count, length, .qsize()
@ multiprocessing.queue(), processes



#### Queue - Wait Until Empty

<cb><v>queue_1<>.join()<>


Blocks until the queue is empty.
@
@ queue.join(), .join()
@ multiprocessing.queue(), processes



#### Queue - Wait Until Task Complete

<cb><v>queue_1<>.task_done()<>


Blocks until the queue is empty.
For thread queues only.
@
@ queue.task_done(), .task_done(), task done



## Event

Prefer Queues

Event is basically a listener that notifies other classes when a single event has occurred.
The server sets or notifies the go condition by setting <c>.set()<>.

Listeners will block while event is <c>False<>.
Listeners will go when the event is <c>True<>.
@
@ event-only, events-only, .event()



### Event - Basics


#### Thread Event - Basics

<cb>from threading import Event<>

<cb><v>event_1<> = Event()<>

Server - Notify:

<cb><v>event_1<>.set()<>

Server - Clear:

<cb><v>event_1<>.clear()<>

Listener - Wait for Event / Block:

<cb><v>event_1<>.wait()<>
@
@ threading.event()



#### Process Event - Basics

<cb>from multiprocessing import Event<>

<cb><v>event_1<> = Event()<>

Server - Notify:

<cb><v>event_1<>.set()<>

Server - Clear:

<cb><v>event_1<>.clear()<>

Listener - Wait for Event / Block:

<cb><v>event_1<>.wait()<>
@
@ multiprocessing.event()



### Event - Create



#### Event - Create Thread Event

<cb>from threading import Event<>

<cb>= Event()<>
@
@ threading.event(), threads



#### Event - Create Process Event

<cb>from multiprocessing import Event<>

<cb>= Event()<>
@
@ multiprocessing.event(), processes



### Event - Operations
@
@ threading.event(), threads
@ multiprocessing.event(), processes



#### Event - Server - Notify

<cb><v>event_1<>.set()<>


Notifies listeners that the event happened.
@
@ event.set(), .set()



#### Event - Server - Clear

<cb><v>event_1<>.clear()<>
@
@ event.clear(), .clear()



#### Event - Listener - Wait for Event

<cb><v>event_1<>.wait()<>

Blocks until the event happens.
@
@ event.wait(), .wait()



## Lock
@
@ .lock(), lock-only, locks-only



### Lock - Lock States

	Locked
	Unlocked



### Lock - When Not Needed

For atomic operations...

	Assigning a simple value
	Getting a dictionary or list item.
	Adding an item to a dictionary or list.



### Lock - Basics



#### Lock - Thread Lock - Basics

<cb>from threading import Lock<>

Create:

<cb><v>lock_1<> = Lock()<>

Use:

<cb><v>lock_1<>.acquire()

<v>...<>

<v>lock_1<>.release()<>
@
@ threading.lock(), threading, threads



#### Lock - Thread Lock - Basics Using With

<cb>from threading import Lock<>

Create and Use:

<cb>with Lock() as <v>lock_1<>:

	<v>...<><>

Automatically acquires and releases the lock.
@
@ threading.lock(), threading, threads



#### Lock - Process Lock - Basics

<cb>from multiprocessing import Lock<>

Create:

<cb><v>lock_1<> = Lock()<>

Use:

<cb><v>lock_1<>.acquire()

<v>...<>

<v>lock_1<>.release()<>
@
@ multiprocessing.lock(), processes



#### Lock - Process Lock - Basics Using With

<cb>from threading import Lock<>

Create and Use:

<cb>with Lock() as <v>lock_1<>:

	<v>...<><>

Automatically acquires and releases the lock.
@
@ multiprocessing.lock(), processes



### Lock - Create



#### Thread Lock - Create

<cb>from threading import Lock<>

<cb>=Lock()<>
@
@ threading.lock(), threads



#### Thread Lock - Create Reentrant Lock / RLock

<cb>from threading import RLock<>

<cb>= RLock()<>


Allows a thread to call acquire on a lock they have already acquired.
With <c>Lock<> this would block and the thread would be deadlocked.
@
@ threading.rlock(), processes



#### Process Lock - Create

<cb>from multiprocessing import Lock<>

<cb>= Lock()<>
@
@ multiprocessing.lock(), processes



#### Process Lock - Create Reentrant Lock / RLock

<cb>from multiprocessing import RLock<>

<cb>= RLock()<>


Allows a process to call acquire on a lock they have already acquired.
With <c>Lock<> this would block and the process would be deadlocked.
@
@ multiprocessing.rlock(), processes



### Lock - Operations
@
@ multiprocessing.lock(), threading.lock(), threads, processes
@ multiprocessing.rlock(), threading.rlock(), RLock(), Reentrant



#### Lock - Acquire

Acquire - Blocking:

<cb><v>lock_1<>.acquire()<>

Acquire - Non-blocking:

<cb><v>lock_1<>.acquire(False)<>

<cb>if <v>lock_1<>.acquire(False):
	<#># Lock acquired.<>
	<v>...<>
else:
	<#># Did not acquire lock<>
	<v>...<><>



#### Lock - Release

<cb><v>lock_1<>.release()<>


Only the locking thread or process can unlock a lock.



#### Lock - Is Locked?

<cb>= <v>lock_1<>.locked()<>



#### Lock - With

<cb>with Lock() as <v>lock_1<>:

	<v>...<><>

Automatically acquires and releases the lock.



## Semaphore
@
@ .semaphore(), semaphore-only, semaphores-only



### Semaphore - Basics


#### Thread Semaphore - Basics

<cb>from threading import Semaphore<>

Create With 1 Lock:

<cb><v>semaphore_1<> = Semaphore()<>

Create With <c><v>lock_count<><> Locks:

<cb><v>semaphore_1<> = Semaphore(<v>lock_count<>)<>

Use:

<cb><v>semaphore_1<>.acquire()

<v>...<>

<v>semaphore_1<>.release()<>


Acquire decrements the counter.
The semaphore will never let the counter go below 0.
Acquiring a counter at 0 blocks the thread until the counter increases.
@
@ threading.semaphore(), threads



#### Thread Semaphore - Basics Using With

<cb>from threading import Semaphore<>

Create:

<cb><v>semaphore_1<> = Semaphore(<v>lock_count<>)<>

Use:

<cb>with <v>semarphore_1<>:
	<v>...<><>

Automatically acquires and releases the semaphore.
@
@ threading.semaphore(), threads


#### Process Semaphore - Basics

<cb>from multiprocessing import Semaphore<>

Create With 1 Lock:

<cb><v>semaphore_1<> = Semaphore()<>

Create With <c><v>lock_count<><> Locks:

<cb><v>semaphore_1<> = Semaphore(<v>lock_count<>)<>

Use:

<cb><v>semaphore_1<>.acquire()

<v>...<>

<v>semaphore_1<>.release()<>


Acquire decrements the counter.
The semaphore will nevere let the counter go below 0.
Acquiring a counter at 0 blocks the process until the counter increases.
@
@ multiprocessing.semaphore(), processes



#### Process Semaphore - Basics Using With

<cb>from multiprocessing import Semaphore<>

Create:

<cb><v>semaphore_1<> = Semaphore(<v>lock_count<>)<>

Use:

<cb>with <v>semarphore_1<>:
	<v>...<><>

Automatically acquires and releases the semaphore.
@
@ multiprocessing.semaphore(), processes



### Semaphore - Create



#### Thread Semaphore - Create

<cb>from threading import Semaphore<>

Create With 1 Lock:

<cb><v>semaphore_1<> = Semaphore()<>

Create With <c><v>lock_count<><> Locks:

<cb><v>semaphore_1<> = Semaphore(<v>lock_count<>)<>
@
@ threading.semaphore(), threads



#### Process Semaphore - Create

<cb>from multiprocessing import Semaphore<>

Create With 1 Lock:

<cb><v>semaphore_1<> = Semaphore()<>

Create With <c><v>lock_count<><> Locks:

<cb><v>semaphore_1<> = Semaphore(<v>lock_count<>)<>
@
@ multiprocessing.semaphore(), processes



### Semaphore - Operations
@
@ multiprocessing.semaphore(), threading.semaphore(), threads, processes



#### Semaphore - Acquire

Acquire - Blocking:

<cb><v>semaphore_1<>.acquire()<>

Acquire - Non-blocking:

<cb><v>semaphore_1<>.acquire(False)<>

<cb>if <v>semaphore_1<>.acquire(False):
	<#># Semaphore acquired.<>
	<v>...<>
else:
	<#># Did not acquire semaphore<>
	<v>...<><>



#### Semaphore - Release

<cb><v>semaphore_1<>.release()<>


Only the acquiring thread or process can release a semaphore.



#### Semaphore - With

<cb>with Semaphore() as <v>semaphore_1<>:

	<v>...<><>

Automatically acquires and releases the semaphore.



## Shared Memory - Value

Creates a synchronized value that can be shared between different processes.
@
@ multiprocessing.value
@ shared-value-only, shared-values-only
@ shared-memory-only



### Shared Value - Basics

<cb>from multiprocessing import Value<>

Create:

<cb><v>shared_value_1<> = Value(<v>type<>, (<v>arguments<>))<>

Retrieve:

<cb><v>current_value<> = <v>shared_value_1<>.value<>

Update:

<cb><v>shared_value_1<>.value = <v>new_value<><>



### Shared Value - Create



#### Shared Value - Create

<cb>from multiprocessing import Value<>

<cb>= Value(<v>type<>, (<v>arguments<>))<>

<cb>= Value(
		typecode_or_type = <v>type<>,
		args = (<v>arguments<>),
		lock = <v>lock<>)<>


Examples:

<cb><v>counter<> = Value('i')          <#># Creates an Integer Value<><>



#### Shared Value - Create With Synchronizing Lock

<cb>from multiprocessing import Value<>

<cb>= Value(<v>...<>, lock = <v>lock_1<>)<>


Example:

<cb>from multiprocessing import Lock

<v>lock_1<> = Lock()
<v>lock_controlled_value<> = Value('i', 0, lock = <v>lock_1<>)<>
@
@ Synchronized



#### Shared Value - Create Unsynchronized

<cb>from multiprocessing import Value<>

<cb>= Value(<v>...<>, lock = False)<>


Example:

<cb><v>boolean_flag<> = Value(ctypes.c_bool, False)<>



#### Shared Value - Types

For:

<cb>= Value(<v>type<>, <v>...<>)<>

<c><v>type<><>        <c>ctypes.c_bool<>
		<c>ctypes.c_char<>
		<c>ctypes.c_wthar<>
		<c>ctypes.c_int<>
		<c>ctypes.c_long<>
		<c>ctypes.c_float<>
		<c>ctypes.c_char_p<>
		<c>ctypes.c_wchar_p<>
		<c>ctypes.c_void_p<>

		'c'             <#>Same as ctype.c_char, 1-character bytes object<>
		'u'             <#>Same as ctype.c_wchar, 1-character string<>
		'i'             <#>Same as ctypes.c_int, int<>
		'l'             <#>Same as ctypes.c_long, int<>
		'f'             <#>Same as ctypes.c_float, float<>


<c><v>type<><> is a C-Type value.


Example:

<cb><v>integer_1<> = Value(ctypes.c_int)<>

<cb><v>integer_2<> = Value('i')<>



### Shared Value - Operations



#### Shared Value - Get Value

<cb>= <v>value_1<>.value<>



#### Shared Value - Update Value

<cb><v>value_1<>.value = <v>new_value<><>
@
@ set, change, modify



#### Shared Value - Get Lock

<cb>= <v>value_1<>.get_lock()<>



## Parallel Extras
@
@ multiprocessing, multitasking



### Multiprocessing - Get Process Name

<cb>import multiprocessing<>

<cb>= multiprocessing.current_process().name<>



### Multiprocessing - Get CPU Count

<cb>import multiprocessing<>

<cb>= multiprocessing.cpu_count()<>



### Threads - Count

<cb>from threading import active_count

<v>thread_count<> = active_count()<>
@
@ threading.active_count(), .active_count()
@ get current, alive, active



# Asyncio
@
@ asyncio-only, async-only, await-only



## Async Def

<cb>async def <v>coroutine_1<>():
	<v>...<><>

Defines a coroutine that can be scheduled to run on an event loop.
@ async-only



## Async For

<cb>async for <v>item<> in <v>async_iterable<>:
	<v>...<><>


Use with asyncronous iterables.


Example:

<cb>class <v>AsyncIterable1<>:
	def __aiter__(self):
		return self

	async def __anext__(self):
		<v>next<> = await <v>get_next()<>
		return <v>next<>


async for <v>item<> in <v>AsyncIterable1<>:
	<v>...<><>
@
@ as, __aiter__, __anext__
@ async-only



## Async With

<cb>async with <v>AsyncClass1<>() as <v>async_1<>:
	<v>...<>
	await <v>async_1<>.<v>action<>()<>


Use with classes that use the asynchronous context manager.


Example:

<cb>class <v>AsyncClass1<>:

	async def __aenter__(self):
		<v>...<>

	async def __aexit__(self, exc_type, exc, tb):
		<v>...<>


async with <v>AsyncClass1<>() as async_1:
	<v>...<><>
@
@ as, __aenter__, __aexit__
@ async-only



## Await

<cb>await <v>future_1<>()<>

<cb>await <v>coroutine_fuction_1<>()<>

<cb>await <v>task_1<>()<>


Suspends operations and returns control from a coroutine function while it waits for the future or function to complete.
@
@ await-only



## Asyncio Sleep

<cb>from asyncio import sleep<>

<cb>await sleep(<v>time_in_seconds<>)<>


Example:

<cb>await sleep(<v>1.5<>)
<#># Sleep 1½ seconds.<><>
@
@ asyncio.sleep(), .sleep(), await
@ sleep-only, async-sleep-only, pause



## Asyncio Sleep - Suspend Execution

<cb>from asyncio import sleep<>

<cb>await sleep(0)<>

Suspends the current coroutine immediately.
Releases control back to the event loop so it can process other coroutines.
Execution returns to this immediately after the other tasks in the event loop have run.
@
@ asyncio.sleep(), .sleep(), sleep(0), await, release control
@ sleep-only, async-sleep-only, pause



## Asyncio Sleep - Until Given Time

Function:

<cb>from datetime import datetime
from asyncio import sleep

async def <v>sleep_until<>(<v>datetime_1<>):
	await sleep ((<v>datetime_1<> - datetime.now()).total_seconds())<>

Call:

<cb>await <v>sleep_until<>(<v>datetime_1<>)<>
@
@ asyncio.sleep(), .sleep(), await
@ sleep-only, async-sleep-only, pause



## Asyncio Coroutines
@
@ coroutine-only, coroutines-only



### Coroutine - Basics
@
@ async functions, summary



#### Coroutine - Start Main Coroutine

<cb>run(<v>main<>())<>

Usage:

<cb>from asyncio import run

async def <v>main<>():
	<v>...<>

run(<v>main<>())<>


This is a typical way to start your threads running.
It runs <c>main()<> on the main event loop.
@
@ run(), function, program, main()



#### Coroutine - Run with await

Define Coroutine Function:

<cb>async def <v>coroutine_function_1<>():
	<v>...<><>

Call:

<cb>await <v>coroutine_function_1<>()<>

<cb><v>result<> = await <v>coroutine_function_2<>()<>


Define the coroutine with <c>async def<>.
<c>await<> calls and then blocks until the coroutine completes.



#### Coroutine - Run as Task

<cb>from asyncio import create_task<>

Define:

<cb>async def <v>coroutine_function<>():
	<v>...<><>

Schedule Execution:

<cb><v>task_1<> = create_task(<v>coroutine_function<>())<>

Complete?:

<cb>= <v>task_1<>.done()<>

Get Result:

<cb>= <v>task_1<>.result()<>



Define the coroutine with <c>async def<>.
Schedule the coroutine to run with <c>create_task()<>.
Check it is complete with <c>.done()<>.
Get the final result with <c>.result()<>.
@
@ c



### Coroutine - Life Cycle

<cb>Coroutine Function

-> Coroutine

-> Task / Running Coroutine<>


Coroutines start out as coroutine functions defined with <c>async def<>.

They become coroutines (sometimes called coroutine object) when the function is called. The coroutine is not running yet.

There are at least 2 options to run it:

	Call with <c>await<>
	Create a <c>Task<>

Call with <c>await<> will run the coroutine immediately and wait for a result. <c>await<> must be called inside another coroutine.

Create a <c>Task<> with <c>create_task()<>. This will schedule the coroutine on the current event loop and will execute it once the event loop completes it's other tasks.



### Coroutine - Create



#### Coroutine - Define / async def

<cb>async def <v>coroutine_function_1<>():
	<v>...<><>


Defines a coroutine function that can be scheduled on the event loop.
@
@ async def



#### Coroutine - Create Coroutine

To Coroutine:

<cb><v>coroutine_1<> = <v>coroutine_function_1<>()<>


This is an intermediate  step that is usually done directly within <c>await<> or <c>create_task()<>.
@
@ coroutine object



### Coroutine - Operations



#### Coroutine - Call, Wait / await

<cb>await <v>coroutine_function_1<>()<>

or

<cb>await <v>coroutine_1<><>


<c>await<> blocks until the coroutine completes.
Can only be called from within another coroutine.



#### Coroutine - Call, Wait For Result / await

<cb><v>result<> = await <v>coroutine_function_1<>()<>

or

<cb><v>result<> = await <v>coroutine_1<><>


<c>await<> blocks until the coroutine completes.
Can only be called from within another coroutine.
@
@ run



#### Coroutine - Schedule Execution

<cb>from asyncio import create_task<>

<cb><v>task_1<> = create_task(<v>coroutine_function_1<>())<>

or

<cb><v>task_1<> = create_task(<v>coroutine_1<>)<>


Once converted to a task, the coroutine is scheduled to run on the current event loop.
@
@ asyncio.create_task(), create_task(), run, call



#### Coroutines - Chain Sequentially

<cb>await <v>subfunction_1<>()
await <v>subfunction_2<>()
<v>...<><>


Use <c>await<> to run coroutines sequentially.
@
@ chaining, serially, call, run, execute, await



#### Coroutines - Chain Sequentially With Chaining Function

<cb>async def <v>chaining_function<>():

	await <v>subfunction_1<>()
	await <v>subfunction_2<>()
	<v>...<><>


<c>chaining_function<> chains subroutines together and runs them sequentially.
Get the final result by calling <c><v>chaining_function<>()<> with <v>await<>.
@
@ chaining, serially, call, run, execute, await



#### Coroutines - Run 'In Parallel'

<cb>from asyncio import create_task
from asyncio import gather

<v>tasks<> = []
<v>tasks<>.append(create_task(<v>coroutine_1<>()))
<v>tasks<>.append(create_task(<v>coroutine_2<>()))
<v>tasks<>.append(create_task(<v>coroutine_3<>()))

<v>results<> = await gather(*<v>tasks<>)<>


Starts all coroutines and then waits for them to complete.
@
@ run in parallel, asyncio.gather(), .gather()



#### Coroutine - To Task

<cb>from asyncio import create_task<>

<cb><v>task_1<> = create_task(<v>coroutine_function_1<>())<>
@
@ asyncio.create_task(), create_task(), From, Convert, Conversion



## Asyncio Event Loop

Responsible for getting items from an event queue and processing them.
@
@ Event Loops, event-loop-only, event-loops-only



### Event Loop - Life Cycle

The event loop stores tasks in a queue.
The event loop calls the first/next task in that queue.

The task runs until it suspends itself, releasing control back to the event loop.

The event loop resumes the task
	once the io/external operation completes.



### Event Loop - Create / Get


#### Event Loop - Create

<cb>= new_event_loop()<>

Usage:

<cb>from asyncio import new_event_loop()

<v>event_loop<> = new_event_loop()<>


Returns: Subclass of <c>AbstractEventLoop<>


This event loop runs in the current thread by default.
@
@ asyncio.new_event_loop(), .new_event_loop(), new, start



#### Event Loop - Start on Main Loop

<cb>run(<v>main<>())<>

Usage:

<cb>from asyncio import run

async def <v>main<>():
	<v>...<>

run(<v>main<>())<>


This is a typical way to start your threads running.
It runs <c>main()<> on the main event loop.
@
@ asyncio.run(), .run(), new, start



#### Event Loop - Start on Main Loop (Verbose Version)

<cb>get_event_loop().run_until_complete(<v>main<>())<>

Usage:

<cb>from asyncio import get_event_loop

async def <v>main<>():
	<v>...<>

<v>loop<> = get_event_loop()
<v>loop<>.run_until_complete(<v>main<>())
<v>loop<>.close()<>


This is a typical way to start your threads running.
It runs <c>main()<> on the main event loop.
@
@ asyncio.get_event_loop(), .get_event_loop(), .run_until_complete(), new, start



#### Event Loop - Get Main Loop

<cb>from asyncio import get_event_loop()<>

<cb>= get_even_loop()<>


Returns: Subclass of <c>AbstractEventLoop<>
@
@ asyncio.get_even_loop(), .get_even_loop() 



### Event Loop - Operations



#### Event Loop - Start

<cb><v>event_loop_1<>.run_forever()<>


Starts the event loop.
@
@ eventloop.run_forever(), .run_forever(), Run Forever



#### Event Loop - Stop

<cb><v>event_loop_1<>.stop()<>


Stops the event loop at the next appropriate moment.
@
@ eventloop.stop(), .stop()



#### Event Loop - Close

<cb><v>event_loop_1<>.close()<>


Closes an event loop.
Make sure to call <c>.stop()<> first.
@
@ eventloop.close(), .close()



#### Event Loop - Run Until Complete

<cb><v>event_loop_1<>.run_until_complete(<v>future_1<>)<>

<cb><v>event_loop_1<>.run_until_complete(<v>coroutine_object_1<>)<>
@
@ start, eventloop.run_until_complete(), .run_until_complete(), execute, future, task



## Asyncio Future
An object that is a proxy for a future result that has yet to be computed.
@
@ future-only, futures-only



### Future - Cancel

<cb>= <v>future_1<>.cancel()<>


Returns: <c>bool<>


Attempts to cancel a request.
Returns <c>True<> if successful.
@
@ .cancel()



### Future - Is Complete?

<cb>= <v>future_1<>.done()<>
@
@ future.done(), .done(), done?



### Future - Get Value

<cb>= <v>future_1<>.result()<>


<c>.result()<> never blocks even if the result is not available.
@
@ future.result(), .result(), 



### Future - Get With Exception Handling

<cb>try:
	<v>result<> = <v>future_1<>.result()
except Exception as <v>exception<>:
	<v>...<><>


Exceptions are returned through the future itself.
@
@ future.result(), .result(), 



### Future - Get Exception

<cb>= <v>future_1<>.exception()<>

<c>.exception()<> never blocks.
@
@ future.exception(), .exception(), future.getexception(), .getexception(), 



### Future - Add Callback Function

<cb>= <v>future_1<>.add_done_callback(<v>callback_function<>)<>


<c><v>callback_fuction<><> is called once the future completes.
Exceptions are not returned to the callback function.
@
@ future.add_done_callback(), .add_done_callback(), 



## Asyncio Task

Subclass of Future.
Wraps and manages the execution of a coroutien in an event loop.
@
@ task-only, tasks-only



### Task - Operations



#### Create Task From Future / Coroutine Object

<cb>from asyncio import create_task<>

<cb>= create_task(<v>coroutine_function_1<>())<>


The task is placed on the event loop and scheduled to run.
Defaults to the default event loop.
@
@ asyncio.create_task(), .create_task()



#### Create Task From Future / Coroutine Object

<cb>from asyncio import ensure_future<>

<cb>= ensure_future(<v>coroutine_function_1<>())<>

<cb>= ensure_future(<v>coroutine_object_1<>)<>

<cb>= ensure_future(<v>future_<>)<>

<cb>= ensure_future(<v>...<>, loop = <v>event_loop_1<>)<>


The task is placed on the event loop and scheduled to run.
Defaults to the default event loop.
@
@ asyncio.ensure_future(), .ensure_future()



#### Task - Cancel

<cb>= <v>task_1<>.cancel()<>


Returns: <c>bool<>


Attempts to cancel a request.
Returns <c>True<> if successful.
@
@ .cancel()
@ stop, terminate, end, kill



#### Task - Is Complete?

<cb>= <v>task_1<>.done()<>
@
@ task.done(), .done(), done?, stopped



#### Task - Get Value

<cb>= <v>task_1<>.result()<>


<c>.result()<> never blocks even if the result is not available.
@
@ task.result(), .result(), 



#### Task - Get With Exception Handling

<cb>try:
	<v>result<> = <v>task_1<>.result()
except Exception as <v>exception<>:
	<v>...<><>


Exceptions are returned through the task itself.
@
@ task.result(), .result(), error



#### Task - Get Exception

<cb>= <v>task_1<>.exception()<>

<c>.exception()<> never blocks.
@
@ task.exception(), .exception(), task.getexception(), .getexception(), error



#### Task - Add Callback Function

<cb>= <v>task_1<>.add_done_callback(<v>callback_function<>)<>


Exceptions are not returned the the callback function.
@
@ task.add_done_callback(), .add_done_callback(), 



#### Task - Get Name

<cb>= <v>task_1<>.get_name()<>
@
@ task.get_name(), .get_name()




#### Task - Set Name

<cb><v>task_1<>.set_name(<v>name<>)<>
@
@ task.set_name(), .gst_name()



## Asyncio Tasks, Futures - Running
@
@ future-only, task-only, futures-only, tasks-only



#### Futures / Tasks - Run Single Task / Future

<cb>from asyncio import wait_for<>

<cb>wait_for(<v>future_1<>)<>

<cb>wait_for(<v>task_1<>)<>

<cb>wait_for(<v>future_1<>,
		timeout = <v>timeout_seconds<>,
		*,
		loop = <v>event_loop_1<>)<>

<cb>await wait_for(<v>future_1<>)<>
@
@ asyncio.wait_for(), .wait_for()



#### Futures / Tasks - Run Chained Sequentially

<cb>async def <c>chaining_function<>():

	await <v>task_1<>()
	await <v>task_2<>()
	<v>...<>
@
@ chaining, serially



#### Futures / Tasks - Run In Parallel

<cb>from asyncio import wait<>

<cb>wait(<v>futures<>)<>

<cb>wait(<v>tasks<>)<>

<cb>wait(<v>futures<>,
		*,
		loop = <v>event_loop_1<>,
		timeout = <v>timeout_seconds<>,
		return_when = <v>when<>)<>

With Results:

<cb><v>done<>, <v>pending<> = await wait(<v>futures<>)<>


Schedules futures for execution together.
Timeout does not cancel futures.
@
@ asyncio.wait(), .wait(), await



#### Futures / Tasks - Process As Completed

<cb>from asyncio import as_completed<>

<cb>for <v>task<> in as_completed(<v>futures<>):
	<v>result<> = await <v>task<><>


Returns tasks as they are completed.
Internally it sets up a call back function that yields a task when it completes.
@
@ asyncio.as_completed(), .as_completed(), await



#### Futures / Tasks - Wait, Gather Results

<cb>from asyncio import gather<>

<cb><v>results<> = await gather(*<v>futures<>)<>


Returns: List of results


Waits for all futures to complete and then returns the results.
The order of the results is the same order as the tasks were submitted.
@
@ asyncio.gather(), .gather(), await



## Asyncio - Popular Asyncio Libraries

<b>I/O:<>

<c><l "https://pypi.org/project/aiofiles/">aiofiles<><>			Asynchronous File I/O
<c><l "/s/aiohttp">aiohttp<><>				Asynchronous Web Requests (SpeedSheet)

<b>Databases:<>

<c><l "https://aiomysql.readthedocs.io/en/latest/">aiomysql<><>			Asynchronous MySql Library
<c><l "https://aiopg.readthedocs.io/en/stable/">aiopg<><>				Asynchronous PostgreSql Library
<c><l "https://pypi.org/project/aiocouchdb/">aiocouchdb<><>			Asynchronous Couch DB Library
<c><l "https://github.com/aio-libs/aiocassandra">aiocassandra<><>		Asynchronous Cassandra Library


Other Libraries:
<l>https://github.com/python/asyncio/wiki/ThirdParty<>



# CSV
@
@ csv-only


### CSV File - Read To Dict - With Header

<cb>= DictReader(<v>file<>)<>

<cb>from csv import DictReader

with open(<v>file_name<>) as file:

	<v>reader<> = DictReader(<v>file<>)

	for <v>row<> in <v>reader<>:
		<v>...<><>


Each <c><v>row<><> returns the row of values as a dict.
The keys are set by the header row (1st line in the CSV file).
Requires a header row.


Example:

<cb><v>file_name<> = '<v>path/data_file.csv<>'
with open(<v>file_name<>) as <v>file<>:

	<v>reader<> = DictReader(<v>file<>)
	<v>data<> = [<v>row<> for <v>row<> in <v>reader<>]<>
@
@ csv.dictreader(), .dictreader(), row
@ from file



### CSV File - Read To Dict - Without Header

<cb>= DictReader(<v>file<>, fieldnames = <v>field_names<>)<>

<cb>from csv import DictReader

with open(<v>file_name<>) as file:

	<v>reader<> = DictReader(<v>file<>, fieldnames = <v>field_names<>)

	for <v>row<> in <v>reader<>:
		<v>...<><>


Set the field names using the <c>fieldnames<> option.
Pass the field names as a list of strings.
Each <c><v>row<><> returns the row of values as a dict.


Example:

<cb><v>file_name<> = '<v>path/data_file.csv<>'
with open(<v>file_name<>) as <v>file<>:

	<v>reader<> = DictReader(<v>file<>, ["name", "date", "value"])
	<v>data<> = [<v>row<> for <v>row<> in <v>reader<>]<>
@
@ csv.dictreader(), .dictreader(), fieldnames=, row
@ from file



### CSV File - Read To List - With Header

<cb>= csv.reader(<v>file<>)<>

<cb>import csv

with open(<v>file_name<>) as file:

	<v>reader<> = csv.reader(<v>file<>)

	<v>header<> = next(<v>reader<>)
	for <v>row<> in <v>reader<>:
		<v>...<><>


<c><v>header<><> contains the fields returned from the first row as a list of strings.
Each <c><v>row<><> returns the row of values as a list.


Example:

<cb><v>file_name<> = '<v>path/data_file.csv<>'
with open(<v>file_name<>) as <v>file<>:

	<v>reader<> = csv.reader(<v>file<>)
	<v>header<> = next(<v>reader<>)
	<v>data<> = [<v>row<> for <v>row<> in <v>reader<>]<>
@
@ csv.reader(), .reader(), row
@ from file



### CSV File - Read To List - Without Header

<cb>= csv.reader(<v>file<>)<>

<cb>import csv

with open(<v>file_name<>) as file:

	<v>reader<> = csv.reader(<v>file<>)

	for <v>row<> in <v>reader<>:
		<v>...<><>


Example:

<cb><v>file_name<> = '<v>path/data_file.csv<>'
with open(<v>file_name<>) as <v>file<>:

	<v>reader<> = csv.reader(<v>file<>)
	<v>data<> = [<v>row<> for <v>row<> in <v>reader<>]<>
@
@ csv.reader(), .reader(), row
@ from file



### CSV File - When Reading Blank Lines

Using <b><c>csv.reader()<>:<>

<in>Returns a blank line as an empty list <c>[]<>.
The last line is ignored if blank.<>

Using <b><c>DictReader<>:<>

<in>Ignores all blank lines.<>



### CSV File - Write From Dict

<cb><v>writer<> = DictWriter(<v>file<>, fieldnames = <v>fields<>)

<v>writer<>.writerow(<v>row_dict<>)<>

<cb>from csv import DictWriter

with open(<v>file_name<>, 'w') as <v>file<>:

	<v>writer<> = DictWriter(<v>file<>, fieldnames = <v>fields<>)

	for <v>row_dict<> in <v>list_of_dicts<>:
		<v>writer<>.writerow(<v>row_dict<>)<>
@
@ csv.DictWriter.writerow(), .writerow(), row, dictionary, dictionaries
@ to file



### CSV File - Write List of Dicts

<cb><v>writer<> = DictWriter(<v>file<>, fieldnames = <v>fields<>)

<v>writer<>.writerows(<v>list_of_dicts<>)<>

<cb>from csv import DictWriter

with open(<v>file_name<>, 'w') as <v>file<>:

	<v>writer<> = DictWriter(<v>file<>, fieldnames = <v>fields<>)

	<v>writer<>.writerows(<v>list_of_dicts<>)<>
@
@ csv.DictWriter.writerows(), .writerows(), rows, dictionary, dictionaries
@ to file



### CSV File - Write Dict Header

<cb><v>writer<> = DictWriter(<v>file<>, fieldnames = <v>fields<>)

<v>writer<>.writeheader()<>

<cb>from csv import DictWriter

with open(<v>file_name<>, 'w') as <v>file<>:

	<v>writer<> = DictWriter(<v>file<>, fieldnames = <v>fields<>)

	<v>writer<>.writeheader()
	<v>...<><>
@
@ csv.DictWriter.writeheader(), .writeheader(), dictionary, dictionaries
@ to file



### CSV File - Write From List

<cb><v>writer<> = csv.writer(<v>file<>)

<v>writer<>.writerow(<v>item_list<>)<>

<cb>import csv

with open(<v>file_name<>, 'w') as <v>file<>:

	<v>writer<> = csv.writer(<v>file<>)

	for <v>item_list<> in <v>list_of_lists<>:
		<v>writer<>.writerow(<v>item_list<>)<>
@
@ writer.writerow(), .writerow(), row
@ to file



### CSV File - Write List of Lists

<cb><v>writer<> = csv.writer(<v>file<>)

<v>writer<>.writerows(<v>list_of_lists<>)<>

<cb>import csv

with open(<v>file_name<>, 'w') as <v>file<>:

	<v>writer<> = csv.writer(<v>file<>)

	<v>writer<>.writerows(<v>list_of_lists<>)<>
@
@ writer.writerows(), .writerows(), rows
@ to file



### CSV - Escaped Quotes

Automatically handled.

The csv library handles escaping quotes in values automatically.
When reading values, string values are automatically unescaped with extra quotes removed.
When writing, strings will be automatically escaped and then placed inside double quotes.

Escaped Double Quotes:  ""




### CSV Option - Delimiter

<cb><v>...<>(delimiter = "<v>delimiter<>")<>


Examples:

<cb><v>reader<> = csv.reader(<v>file<>, delimiter="\\t")<>

<cb><v>writer<> = csv.writer(<v>file<>, delimiter="\\t")<>
@
@ setting



### CSV Option - Dialect

<cb><v>...<>(dialect = "<v>dialect<>")<>

<indent><table><col><c>'excel'<><><col>Excel formatting, Comma Delimited, '\\n\\r' Newlines<>
<col><c>'excel-tab'<><><col>Excel formatting, Tab Delimited, '\\n\\r' Newlines<>
<col><c>'unix'<><><col>Unix formatting, Comma Delimited, All Values in Quotes, '\\n' Newlines<><><>


Examples:

<cb><v>reader<> = csv.reader(<v>file<>, dialect='excel')<>

<cb><v>writer<> = csv.writer(<v>file<>, dialect='unix')<>
@
@ dialect=, excel, unix



### CSV Option - Quoting

<cb><v>...<>(quoting = <v>quote_setting<>)<>

<c>quote_setting<>:

<indent><table><col><c>csv.QUOTE_NONE<><><col>Quote Nothing<>
<col><c>csv.QUOTE_MINIMAL<><><col>Add Quotes Only To Values That Need It (Default)<>
<col><c>csv.QUOTE_NONNUMERIC<><><col>Add Quotes To Non Numeric Values<>
<col><c>csv.QUOTE_ALL<><><col>Add Quotes To All Values<><><>


Examples:

<cb><v>writer<> = csv.writer(<v>file<>, quoting=csv.QUOTE_NONNUMERIC)<>
@
@ quotes, setting



# Dataclass
@
@ data class, dataclasses, dataclasses.dataclass, @dataclass
@ dataclass-only, dataclasses-only, data-class-only, data-classes-only



## Dataclass - Video Tutorial

Get going faster with our Dataclasses in a Hurry Video:

<card><l https://youtu.be/_KT2lX4Wm2U>Dataclasses in a Hurry (2 Mins)<><>



## Dataclass - Basics

Define:

<cb>from dataclasses import dataclass

\@dataclass
class <v>Dataclass1<>:
	<v>field_1<>: <v>int<>
	<v>field_2<>: <v>Str<>
	<v>...<>

	def <v>some_method<>(self):
		<v>...<><>

Create:

<cb>= <v>Dataclass1<>(<v>param_1<>, <v>param_2<>, <v>...<>)
= <v>Dataclass1<>(<v>field_1<> = <v>param_1<>, <v>field_2<> = <v>param_2<>, <v>...<>)<>

Access:

<cb>= <v>dataclass_1<>.<v>field_1<><>
@
@ summary



## Dataclass - Create


### Dataclass - Define

Define:

<cb>from dataclasses import dataclass

\@dataclass
class <v>Dataclass1<>:
	<v>field_1<>: <v>type<>
	<v>field_2<>: <v>type<>
	<v>...<><>

Create:

<cb><v>item_1<> = <v>NewClass1<>(<v>value_1<>, <v>value_2<> <v>...<>)<>

Or:

<cb><v>item_1<> = <v>NewClass1<>(<v>field_1<> = <v>value_1<>, <v>field_2<> = <v>value_2<> <v>...<>)<>


Example:

<cb>from dataclasses import dataclass

\@dataclass
class <v>Size<>:
	width: int
	height: int

size_1 = <v>Size<>(10, 20)
size_2 = <v>Size<>(width = 10, height = 20)<>
@
@ create, definition, new



### Dataclass - Define With Defaults

Define:

<cb>@dataclass
class <v>Dataclass1<>:
	<v>field_1<>: <v>type<> = <v>default_value<>
	<v>field_2<>: <v>type<> = <v>default_value<>
	<v>...<><>

Create:

<cb><v>item_1<> = <v>NewClass1<>()<>


Example:

<cb>@dataclass
class Size:
	width: int = 0
	height: int = 0

size_1 = Size()<>
@
@ create, definition, new, values



### Dataclass - Define With Default List

<cb>= field(default_factory = lambda: [])<>

Usage:

<cb>from dataclasses import dataclass
from dataclasses import field

\@dataclass
class <v>Dataclass1<>:
	<v>list_1<>: list = field(default_factory = lambda: [])<>
@
@ create, definition, new, field, values



### Dataclass - Define With Default Dict

<cb>= field(default_factory = lambda: {})<>

<cb>from dataclasses import dataclass
from dataclasses import field
from typing import Dict

\@dataclass
class <v>Dataclass1<>:

    <v>dict_1<>: Dict[<v>K<>: <v>V<>] = field(
            default_factory = lambda: {})

    <v>dict_2<>: Dict[<v>K<>: <v>V<>] = field(
            default_factory = lambda: {'<v>a<>': <v>1<>, '<v>b<>': <v>2<>})<>
@
@ dataclass.field, default_factory
@ create, definition, new, field, values



### Dataclass - Define With Comparison Functions

<cb>@dataclass(order=true)<>

Usage:

<cb>from dataclasses import dataclass

\@dataclass(order=true)
class <v>Dataclass1<>:
	<v>...<><>


Adds comparison functions to the dataclass.

Comparisons are done in order by field.


Implements:

<c>__lt__(), __le__(), __gt__(), and __ge__()<>
@
@ order=, order=true, @dataclass(order=true)
@ Comparators, compare dataclasses



### Dataclass - Define Immutable

Define:

<cb>@dataclass(frozen = True)
class <v>NewClass1<>:
	<v>...<><>


The class properties can not be changed.

This also implements <c>__hash__()<>.
@
@ @dataclass(frozen=True), frozen=true, __hash__
@ frozen, freeze, create, definition, new



### Dataclass - Define Constructor - Override

<cb>@dataclass
class <v>NewClass1<>:

	<v>field_1<>: <v>type<>
	<v>...<>

	def __init__(self, <v>...<>):
		<v>...<><>


You can override the constructor if you need.
Consider using __post_init__() instead.
@
@ __init__()



### Dataclass - Define Constructor - Post Init

<cb>@dataclass
class <v>NewClass1<>:
	<v>...<>

	def __post_init__(self):
		<v>...<><>


<c>__post_init__<> is called after the class is created.
Add any setup code you need in here including calling <c>super()<>.
@
@ __post_init_(), setup, after, initialize, __init__()



### Dataclass - Define Constructor - Call Parent Constructor

<cb>@dataclass
class <v>NewClass1<>(<v>ParentClass<>):
	<v>...<>

	def __post_init__(self):
		super().__init__()<>


Use <c>__post_init__<> to add a call to the parents constructor and add<c>super().__init__().
@
@ super(), __post_init_()



### Dataclass - Define Method

Works the same as a normal class.

Define:

<cb>@dataclass
class <v>NewClass1<>:
	
	def <v>method_1<>(self):
		<v>...<><>

Use:

<cb><v>item_1<>.<v>method_1<>()<>
@
@ methods, add, create, extend, extension



## Dataclass - Operations


### Dataclass - Is Dataclass

<cb>= is_dataclass(<v>item_1<>)<>

Usage:

<cb>from dataclasses import is_dataclass

= is_dataclass(<v>item_1<>)<>


Returns <c>True<> if the item is a type of dataclass.


Example:

<cb>from dataclasses import dataclass
from dataclasses import is_dataclass

\@dataclass
class <v>Person<>:
    name: str

<v>name<> = '<v>joe<>'
<v>person_1<> = Person(<v>name<>)

print(is_dataclass(<v>name<>))
print(is_dataclass(<v>person_1<>))

<#># Prints:
\#
\#    False
\#    True<><>
@
@ dataclasses.is_dataclass(), .is_dataclass(), type of



### Dataclass - Is Equal?

<cb>= <v>dataclass_1<> == <v>dataclass_2<><>


Use <c>==<> to test if the dataclasses are the same.

Python will do a field by field comparison.


Example:

<cb>from dataclasses import dataclass

\@dataclass
class <v>Item<>:
    name: str
    number: int

<v>item_1<> = Item('one', 1)
<v>item_2<> = Item('two', 2)

print ("Equal?", <v>item_1<> == <v>item_2<>)

<#># Prints: Equal? False<><>
@
@ equals, sendond, 2nd, ==, identity, two



### Dataclass - Is Equal?

<cb>= <v>dataclass_1<> == <v>dataclass_2<><>


<cb>if <v>dataclass_1<> == <v>dataclass_2<>:
	<v>...<><>


Use <c>==<> to test if the dataclasses are the same.

Python will do a field by field comparison.


Example:

<cb>from dataclasses import dataclass

\@dataclass
class <v>Item<>:
    name: str
    number: int

<v>item_1<> = Item('one', 1)
<v>item_2<> = Item('two', 2)

print ("Equal?", <v>item_1<> == <v>item_2<>)

<#># Prints: Equal? False<><>
@
@ equals, second, 2nd, ==, identity, two



### Dataclass - Property - Access

Same as a normal class.

<cb>= <v>item_1<>.<v>field_1<><>
@
@ properties, get



### Dataclass - Property - Update

Same as a normal class.

<cb><v>item_1<>.<v>field_1<> = <v>new_value<><>
@
@ properties, set, change



### Dataclass - From Dict

<cb>= <v>Dataclass1<>(**<v>dict_1<>)<>


Converts a dict into a dataclass.


Example:

<cb>from dataclasses import dataclass

\@dataclass
class <v>Person<>:
    id: int
    name: str

<v>person_dict<> = {'id': 1, 'name': 'Joe'}
<v>person_1<> = Person(**<v>person_dict<>)

print(<v>person_1<>)

<#># Prints: Person(id=1, name='Joe')<><>
@
@ convert, conversion, from, dictionary, from-dict, to-dataclass



### Dataclass - To Dict

<cb>= asdict(<v>dataclass_1<>)<>

Usage:

<cb>from dataclasses import asdict

= asdict(<v>dataclass_1<>)<>


Converts a dataclass into a dict.


Example:

<cb>from dataclasses import dataclass
from dataclasses import asdict

\@dataclass
class <v>Person<>:
    id: int
    name: str

<v>person_1<> = Person(1, 'Joe')
<v>person_dict<> = asdict(<v>person_1<>)

print(<v>person_dict<>)

<#># Prints: {'id': 1, 'name': 'Joe'}<><>
@
@ convert, conversion, from, dictionary, to-dict, from-dataclass



# Collections Library
@
@ from collections, collections.


## Deque

A double ended queue that is implemented as a linked list under the hood.

Guarantees O(1) performance for append, remove on either end of the queue.
@
@ collections.deque, deque(), double ended queue, linked list
@ deque-only, deques-only



### Deque - Basics

<cb>from collections import deque

<v>queue_1<> = deque()

<v>queue_1<>.append(<v>value<>)			<#># Append End / Right<>
<v>queue_1<>.appendleft(<v>value<>)		<#># Append Start / Left<>

<v>last<> = <v>queue_1<>.pop()			<#># Pop End / Right<>
<v>first<> = <v>queue_1<>.popleft()		<#># Pop Start / Left<>

<v>size<> = len(<v>queue_1<>)
<v>item<> = <v>queue_1<>[<v>1<>]

del <v>queue_1<>[<v>1<>]
<v>queue_1<>.clear()<>



### Deque - Create
@
@ new, instantiate, define


#### Deque - Create

<cb>= deque()<>

Usage:

<cb>from collections import deque

= deque()<>


Creates an empty queue.



#### Deque - Create From List

<cb>= deque(<v>list_1<>)<>

Usage:

<cb>from collections import deque

= deque(<v>list_1<>)

= deque([<v>value_1<>, <v>value_2<>, <v>...<>])<>



#### Deque - Create With Maximum Size

<cb>= deque(maxlen = <v>size<>)<>

Usage:

<cb>from collections import deque

= deque(maxlen = <v>size<>)<>


Sets the maximum size of deque().

The oldest item is removed when adding an item to a full deque.
@
@ maxlen



### Deque - Operations



#### Deque - Append

<cb><v>queue_1<>.append(<v>value<>)<>


Appends an item to the end / right of the queue.


Example:

<cb>from collections import deque

<v>queue_1<> = deque([<v>1<>, <v>2<>, <v>3<>])

<v>queue_1<>.append(10)

<#># Sets queue_1 To: [1, 2, 3, 10]<><>
@
@ .append(), end, right



#### Deque - Append List

<cb><v>queue_1<>.extend(<v>list_1<>)<>


Appends a list of items to the end / right of the queue.


Example:

<cb>from collections import deque

<v>queue_1<> = deque([<v>1<>, <v>2<>, <v>3<>])

<v>queue_1<>.extend([10, 20])

<#># Sets queue_1 To: [1, 2, 3, 10, 20]<><>
@
@ .extend(), extend, end, right



#### Deque - Count Occurences

<cb>= <v>queue_1<>.count(<v>value<>)<>


Returns the number of times <c><v>value<><> appears in <c><v>queue_1<><>.
@
@ item, occurrences, .count(), times



#### Deque - Delete

<cb><v>del<> <v>queue_1<>[<v>index<>]<>


Example:

<cb>from collections import deque

<v>queue_1<> = deque([<v>1<>, <v>2<>, <v>3<>])

<v>del queue_1<>[1]

<#># Sets queue_1 To: [1, 3]<><>
@
@ remove from, one, single, del



#### Deque - Delete All

<cb><v>queue_1<>.clear()<>
@
@ .clear()
@ clear, del, empty, remove, reset, elements, items, values



#### Deque - Is Empty?

<cb>= not <v>queue_1<><>

<cb>if not <v>queue_1<>:
	<v>...<><>



#### Deque - Not Empty?

<cb>= bool(<v>queue_1<>)<>

<cb>if <v>queue_1<>:
	<v>...<><>

Use <b>bool()<> if you need to get a True/False value.
There is no need for <b>bool()<> when using <b>if...<>.
@
@ bool()



#### Deque - Get

<cb>= <v>queue_1<>[<v>index<>]<>


Returns an item on the queue.


Example:

<cb>from collections import deque

<v>queue_1<> = deque([<v>1<>, <v>2<>, <v>3<>])

<v><v>item_1<> = queue_1<>[1]

<#># Returns: 2<><>
@
@ item, value



#### Deque - Get First

<cb>= <v>queue_1<>[0]<>


Returns the first item on the queue (first added).

Retrieves in O(1) time.


Example:

<cb>from collections import deque

<v>queue_1<> = deque([<v>1<>, <v>2<>, <v>3<>])

<v><v>first<> = queue_1<>[0]

<#># Returns: 1<><>
@
@ item, value, beginning, oldest



#### Deque - Get Last

<cb>= <v>queue_1<>[-1]<>


Returns the last item on the queue (most recently added).

Retrieves in O(1) time.


Example:

<cb>from collections import deque

<v>queue_1<> = deque([<v>1<>, <v>2<>, <v>3<>])

<v><v>item_1<> = queue_1<>[-1]

<#># Returns: 3<><>
@
@ item, value, last, end, newest



#### Deque - Insert

<cb><v>queue_1<>.insert(<v>index<>, <v>value<>)<>

Inserts at position <c><v>index<><>.


Example:

<cb>from collections import deque

<v>queue_1<> = deque([<v>1<>, <v>2<>, <v>3<>])

<v>queue_1<>.insert(1, 10)

<#># Sets queue_1 To: [1, 10, 2, 3]<><>
@
@ put, set, item, .insert()



#### Deque - Pop First

<cb>= <v>queue_1<>.popleft()<>

Removes the first / left item from the queue and returns it.
@
@ .pop(), left



#### Deque - Pop Last

<cb>= <v>queue_1<>.pop()<>

Removes the last / right item from the queue and returns it.
@
@ .pop(), right, end



#### Deque - Prepend

<cb><v>queue_1<>.appendleft(<v>value<>)<>


Prepends an item to the start / left of the queue.


Example:

<cb>from collections import deque

<v>queue_1<> = deque([<v>1<>, <v>2<>, <v>3<>])

<v>queue_1<>.appendleft(10)

<#># Sets queue_1 To: [10, 1, 2, 3]<><>
@
@ .appendleft(), append, start, left



#### Deque - Prepend List

<cb><v>queue_1<>.extendleft(<v>list_1<>)<>


Appends a list of items to the start / left of the queue.

⚠️ Adds items in reverse order!


Example:

<cb>from collections import deque

<v>queue_1<> = deque([<v>1<>, <v>2<>, <v>3<>])

<v>queue_1<>.extendleft([<v>10<>, <v>20<>])

<#># Sets queue_1 To: [20, 10, 1, 2, 3]<><>
@
@ .extendleft(), extend, append left, start



#### Deque - Reverse

<cb><v>queue_1<>.reverse()<>


Reverses the order of items in the queue.
Reverses in place.


Example:

<cb>from collections import deque

<v>queue_1<> = deque([<v>1<>, <v>2<>, <v>3<>])

<v>queue_1<>.reverse()

<#># Sets queue_1 To: [3, 2, 1]<><>
@
@ .reverse(), order



#### Deque - Shift / Rotate

<cb><v>queue_1<>.rotate(<v>count<>)<>


Rotates (shifts) the queue to the right <c><v>count<><> times by taking the last items and placing them at the start of the queue.
Rotates in place.


Example:

<cb>from collections import deque

<v>queue_1<> = deque([<v>1<>, <v>2<>, <v>3<>])

<v>queue_1<>.rotate(2)

<#># Sets queue_1 To: [2, 3, 1]<><>
@
@ deque.rotate(), .rotate()



#### Deque - Size

<cb>= len(<v>queue_1<>)<>
@
@ len(), length, count



#### Deque - Maximum Size

<cb>= <v>queue_1<>.maxlen<>



## Named Tuple

Named tuples allow you to access tuple values by name.

Use the <c>namedtuple<> function to create a class for a given tuple type.
@
@ collections.namedtuple, Named Tuples, nametuple, namedtuples, namedtuple()
@ namedtuple-only, named-tuple-only, named-tuples-only



### Named Tuple - Video Tutorial

Get going faster with our Named Tuples in a Hurry Video:

<card><l https://youtu.be/IyYayd6oApg>Named Tuples in a Hurry<>

(2½ Mins)<>



### Named Tuple - Basics

Define:

<cb>from collections import namedtuple

= namedtuple("<v>NamedTuple1<>", ["<v>field_1<>", "<v>field_2<>", <v>...<>])<>

Create:

<cb>= <v>NamedTuple1<>(<v>param_1<>, <v>param_2<>, <v>...<>)

= <v>NamedTuple1<>(<v>field_1<> = <v>param_1<>, <v>field_2<> = <v>param_2<>, <v>...<>)<>

Access:

<cb>= <v>named_tuple_1<>.<v>field_1<>

= <v>named_tuple_1<>[0]<>
@
@ summary



### Named Tuple - Create


#### Named Tuple - Define

<cb>= namedtuple("<v>NamedTuple1<>", ["<v>field_1<>", "<v>field_2<>"])<>

Usage:

<cb>from collections import namedtuple

= namedtuple("<v>NamedTuple1<>", ["<v>field_1<>", "<v>field_2<>", <v>...<>])

= namedtuple("<v>NamedTuple1<>", "<v>field_1<> <v>field_2<> <v>..."<>)

= namedtuple("<v>NamedTuple1<>", "<v>field_1<>, <v>field_2<>, <v>..."<>)<>

Returns: <c>class<>


Defines a named tuple, a tuple with named propeties.

Creates a subclass of <c>tuple<>.


Example:

<cb>from collections import namedtuple
<v>Size<> = namedtuple("Size", ["width", "height"])

<v>size_1<> = Size(<v>160<>, <v>100<>)

<v>width<> = <v>size_1<>.width
<v>height<> = <v>size_1<>.height<>
@
@ new, definition, create



#### Named Tuple - Instantiate

<cb>= <v>NamedTuple1<> (<v>value_1<>, <v>value_2<>, <v>...<>)

= <v>NamedTuple1<> (<v>field_1<> = <v>value_1<>, <v>field_2<> = <v>value_2<>, <v>...<>)<>


Creates an instance of the named tuple.


Example:

<cb>from collections import namedtuple
<v>Size<> = namedtuple("Size", ["width", "height"])

<v>size_1<> = Size(<v>160<>, <v>100<>)
<v>size_2<> = Size(width = <v>160<>, height = <v>100<>)<>
@
@ new, create



#### Named Tuple - Instantiate From Tuple

<cb>= <v>NamedTuple1<> (*<v>tuple_1<>)<>

or

<cb>= <v>NamedTuple1<> (*(<v>value_1<>, <v>value_2<>, <v>...<>))<>


Creates an instance of the named tuple from a regular tuple.


Example:

<cb>from collections import namedtuple
<v>Size<> = namedtuple("Size", ["width", "height"])

<v>tuple<> = (<v>160<>, <v>100<>)

<v>size_1<> = Size(*<v>tuple<>)<>
@
@ new, create



#### Named Tuple - Extend

<cb>class <v>ExtendedNamedTuple1<>(<v>NamedTuple1<>):

	def <v>method_1<>(self)...<>

Extend by creating an extended class.

Allows you to add custom fields and methods to your base namedtuple.


Example:

<cb>from collections import namedtuple

<v>BaseSize<> = namedtuple("Size", ["width", "height"])

class <v>Size<>(<v>BaseSize<>):

    def area(self):
        return self.<v>width<> * self.<v>height<>

<v>size_1<> = <v>Size<>(160, 100)
<v>area<> = <v>size_1<>.area()

<#>Returns: 16000<><>
@
@ base



### Named Tuple - Operations



#### Named Tuple - Get Field Names

<cb>= <v>named_tuple_1<>._fields<>

Returns: <c>tuple of str<>


Returns the named tuple's fields as a tuple of strings.


Example:

<cb>from collections import namedtuple
<v>Size<> = namedtuple("Size", ["width", "height"])

<v>size_1<> = Size(<v>160<>, <v>100<>)

print("Fields", <v>size_1<>._fields)

<#># Prints: Fields ('width', 'height')<><>
@
@ ._fields, namedtuple._fields
@ fields, properties, propertys



#### Named Tuple - Get Field Value

<cb>= <v>item_1<>.<v>field_1<><>

<cb>= <v>item_1<>[0]<>


Accesses a value of the named tuple by accessing the property name.


Example:

<cb>from collections import namedtuple
<v>Size<> = namedtuple("Size", ["width", "height"])

<v>size_1<> = Size(<v>160<>, <v>100<>)

<v>width<> = <v>size_1<>.width
<v>height<> = <v>size_1<>.height<>
@
@ fields, properties, get



#### Named Tuple - Is Equal?

<cb>= <v>named_1<> == <v>named_2<><>


<cb>if <v>named_1<> == <v>named_2<>:
	<v>...<><>


Use <c>==<> to test if the named tuples are the same.

Python does a field by field comparison.


Example:

<cb>from collections import namedtuple
<v>Size<> = namedtuple("Size", ["width", "height"])

<v>size_1<> = Size(<v>160<>, <v>100<>)
<v>size_2<> = Size(<v>100<>, <v>160<>)

print ("Equal?", <v>size_1<> == <v>size_2<>)

<#># Prints: Equal? False<><>
@
@ equals, sendond, 2nd, ==, identity, two



#### Named Tuple - Update Field Value

Not possible.
This is an immutable tuple.
@
@ fields, properties



#### Named Tuple - To Dict

<cb>= <v>named_tuple_1<>._asdict()<>

Returns: <c>tuple of str<>


Returns a named tuple as a dict.


Example:

<cb>from collections import namedtuple
<v>Size<> = namedtuple("Size", ["width", "height"])

<v>size_1<> = Size(<v>160<>, <v>100<>)

print("Dict", <v>size_1<>._asdict())

<#># Prints: Dict {'width': 160, 'height': 100}<><>
@
@ ._asdict(), namedtuple._asdict()
@ Convert, conversion, from



## Ordered Dict

<cb>from collections import OrderedDict

= OrderedDict()<>

<cb>= OrderedDict({<v>key<>: <v>value<>, <v>key<>: <v>value<>, <v>...<>})<>


Returns a dict where the keys are stored in insertion order.
Subclasses the dict type.

All dict operations work on ordered dict.


Example:

<cb>from collections import OrderedDict

<v>dict_1<> = OrderedDict()

<v>dict_1<>['<v>c<>'] = '<v>First<>'
<v>dict_1<>['<v>b<>'] = '<v>Second<>'
<v>dict_1<>['<v>a<>'] = '<v>Third<>'

for <v>key<> in <v>dict_1<>.keys():
	print (<v>key<>, <v>dict_1<>[<v>key<>])

<#># Prints:
\#
\# c First
\# b Second
\# a Third<><>
@
@ collections.ordereddict, .ordereddict, ordereddict()
@ ordered-dict-only, ordered-dicts-only, ordereddict-only




### Ordered Dict - Operations


#### Ordered Dict - Get Keys

<cb>= <v>dict_1<>.keys()<>

Returns: <c>odict_keys<>


Returns the keys in insertion order.


<cb>from collections import OrderedDict

<v>dict_1<> = OrderedDict()

<v>dict_1<>['<v>c<>'] = '<v>First<>'
<v>dict_1<>['<v>b<>'] = '<v>Second<>'
<v>dict_1<>['<v>a<>'] = '<v>Third<>'

for <v>key<> in <v>dict_1<>.keys():
	print (<v>key<>, <v>dict_1<>[<v>key<>])

<#># Prints:
\#
\# c First
\# b Second
\# a Third<><>
@
@ .keys()



#### Ordered Dict - Get Item

<cb>= list(<v>dict_1<>.items())[<v>index<>]<>

Returns: <c><v>value<><>


Returns an item.

The index references the item based on the insert order.


Example:

<cb>from collections import OrderedDict

<v>dict_1<> = OrderedDict({
        '<v>c<>': '<v>First<>',
        '<v>b<>': '<v>Second<>',
        '<v>a<>': '<v>Third<>'})

<v>second_tuple<> = list(<v>dict_1<>.items())[0]

print('2nd:', <v>second_tuple<>)

<#># Prints: "2nd: ('c', 'Second')"<><>
@
@ .items()[]



#### Ordered Dict - Get First Item

<cb>= <v>dict_1<>.popitem(last = False)<>

Returns: <c>tuple = (<v>key<>, <v>value<>)<>


Removes and returns the first item placed in the dictionary.

Example:

<cb>from collections import OrderedDict

<v>dict_1<> = OrderedDict({
        '<v>c<>': '<v>First<>',
        '<v>b<>': '<v>Second<>',
        '<v>a<>': '<v>Third<>'})

<v>first<> = <v>dict_1<>.popitem(last = False)

<#># Returns ('c', 'First')<><>
@
@ .popitem()



#### Ordered Dict - Get Last Item

<cb>= <v>dict_1<>.popitem()<>

Returns: <c>tuple = (<v>key<>, <v>value<>)<>


Removes and returns the last item placed in the dictionary.

Example:

<cb>from collections import OrderedDict

<v>dict_1<> = OrderedDict({
        '<v>c<>': '<v>First<>',
        '<v>b<>': '<v>Second<>',
        '<v>a<>': '<v>Third<>'})

<v>last<> = <v>dict_1<>.popitem()

<#># Returns ('a', 'Third')<><>
@
@ .popitem(), last, end



#### Ordered Dict - Get Items

<cb>= <v>dict_1<>.items()<>

Returns: <c>odict_items<>


Returns the items in insertion order.

The returned value is iterable but not indexable or slicable.


<cb>from collections import OrderedDict

<v>dict_1<> = OrderedDict()

<v>dict_1<>['<v>c<>'] = '<v>First<>'
<v>dict_1<>['<v>b<>'] = '<v>Second<>'
<v>dict_1<>['<v>a<>'] = '<v>Third<>'

for <v>item<> in <v>dict_1<>.items():
	print (<v>item<>)

<#># Prints:
\#
\# First
\# Second
\# Third<><>
@
@ .items(), values



# How To
@
@ how-to, how-only, how-to-only


### Assert

<cb>assert <v>expression<><>

<cb>assert <v>expression<>, <v>expression<>, <v>...<><>


Asserts an expression is true.

If false, rasises AssertionError.
Use to debug code or alert of unexpected conditions.
@
@ command, statement, assertionerror


### Anything - Convert To String

<cb>= repr(<v>variable<> <s>|<> <v>expression<>)<>

Converts any value to a machine intrepretable string.
@
@ repr()



### Bash - Make Python File Executable

Python File - 1st Line:

<cb>#!/usr/bin/env python3<>

Make Executable:

<cb>chmod +x <v>file_name.py<><>


1. Add the shebang to the file.
2. Set the file as executable.


Adding a shebang to the top of the script allows Bash to run it without explicitly having to tell it to use Python. 
@
@ shebang, run script from bash
@ #!/usr/bin/env python3



#### 1 - Add Shebang

<cb>#!/usr/bin/env python3<>

Called the shebang.
Add to the first line in your file.



#### 2 - Set File As Executable

<cb>chmod +x <v>file_name.py<><>

Makes the file executable.
@
@ chmod +x



### Bitwise Not

<cb>= (1 \<\< <v>bit_count<>) - 1 - <v>value<><>

Bitwise NOT Function:

<cb>def bitwise_not(<v>value<>, <v>bits<> = 8):
	return (1 \<\< <v>bits<>) - 1 - <v>value<><>


There is no built in bitwise NOT that simply flips the bits.
Use this formula instead.


Examples:

Using Formula:

<cb><v>value<> = 0b11

<v>bitwise_not<> = (1 \<\< <v>4<>) - 1 - <v>value<>

<#># Returns: 0b1100<><>

Using Function:

<cb>def bitwise_not(<v>value<>, <v>bits<> = 8):
	return (1 \<\< <v>bits<>) - 1 - <v>value<>

<v>value<> = 0b11

<v>not_value<> = bitwise_not(<v>value<>)

<#># Returns: 0b11111100<>

<v>not_value<> = bitwise_not(<v>value<>, 4)

<#># Returns: 0b1100<><>
@
@ inverse, invert, inversion



### Byte Code - Print

<cb>from dis import dis<>

Print Function:

<cb>dis(<v>function_name<>)<>

Print Class:

<cb>dis(<v>class_name<>)<>


Prints the byte code operations for the given function or class.
@
@ dis.dis(), .dis()
@ operations, op codes



### Command-line Arguments - Get

<cb>from sys import argv

<v>arguments<> = argv[1:]<>

Use <c>argv[1:]<> to return arguments.
<c>.argv[0]<> returns the module file name.
@
@ sys.argv
@ commandline start, command line, application, program
@ parameters, params, args, arguments, system



### Command-line Arguments - Has

<cb>from sys import argv

= len(argv) > 1<>


Returns True when the program has command-line arguments.
@
@ sys.argv
@ commandline start, command line, application, program
@ parameters, params, args, arguments, system



### Cached Compiled Files - Delete

Bash:

<cb>find . -type f -name '*.py[co]' -delete -o -type d -name __pycache__ -delete<>


Deletes all __pycache__ directories in your project.
@
@ clear, __pycache__ directory, directories, remove



### Console Screen - Clear

Use This Function:

<cb>from os import system, name

def <v>clear_screen<>():
    if name == 'nt':
        system('cls')	<#># Windows<>
    else:
        system('clear')	<#># Mac, Linux<><>

Call:

<cb><v>clear_screen<>()<>


Clears the console screen.
@
@ clear_screen(), cls



### Current Working Directory - Get

<cb>from os import getcwd

<v>directory<> = getcwd()<>
@
@ os.getcwd(), .getcwd(), getpwd(), pwd, cwd, path



### Current Working Directory - Change

<cb>from os import chdir

chdir(<v>new_directory<>)<>
@
@ set, os.chdir(), cd(), cwd, pwd, path



### Email - Send Basic Text Email

<cb>from email.message import EmailMessage
from smtplib import SMTP

<v>MAIL_HOST<> = '...'
<v>MAIL_PORT<> = 587
<v>MAIL_ID<> = '...'
<v>MAIL_PASSWORD<> = '...'

def new_message(<v>sender<>, <v>to<>, <v>subject<>, <v>body<>):
    <v>message<> = EmailMessage()
    <v>message<>['From'] = <v>sender<>
    <v>message<>['To'] = <v>to<>
    <v>message<>['Subject'] = <v>subject<>
    <v>message<>.set_content(<v>body<>)
    return <v>message<>

def new_smtp(<v>host<>, <v>port<>, <v>id<>, <v>password<>):
    <v>smtp<> = SMTP(<v>host<>, <v>port<>)
    <v>smtp<>.login(<v>id<>, <v>password<>)
    return <v>smtp<>


message = new_message(
    sender = '<v>...<>',
    to = '<v>...<>',
    subject = '<v>Test Subject<>',
    body = '<v>Test Message.<>')

with new_smtp(<v>MAIL_HOST<>, <v>MAIL_PORT<>, <v>MAIL_ID<>, <v>MAIL_PASSWORD<>) as <v>smtp<>
    <v>smtp<>.send_message(<v>message<>)<>
@
@ smtplib.smtp, smtp, email.message.emailmessage, message.emailmessage
@ smtp.send_message(), .send_message()



### Evaluate String Expression

<cb>= eval("<v>expression<>")<>


Evaluates the python expression and returns the value.
The expression can contain local and global variables.

Syntax errors will raise <c>SyntaxError<>.
Referencing non-existent variables will raise <c>NameError<>.


Examples:

<cb><v>a<> = eval('<v>2 * 3<>')               <#># Returns 6<><>

<cb><v>a<> = <v>3<>
<v>b<> = eval('<v>2 * a<>')               <#># Returns 6<><>

<cb><v>b<> = eval("<v>'2' + ' * ' + '3'<>")   <#># Returns "2 * 3"<><>
@
@ eval()



### Global Symbols - Get

<cb>= globals()<>


Returns: <c>dict<>


Returns all symbols currently in global scope from the symbol table.
@
@ globals(), in scope



### Input - Read

<cb>= input()<>

<cb>= input()
= input("<v>Enter value: <>")
= input("<v>Enter value:\\n<>")<>


Read a line from the standard input.


Example:

<cb><v>name<> = input("<v>Enter your name:\\n<>")

print("You entered", <v>name<>)<>
@
@ input(), user, input-only, enters, get
@ input-only, inputs-only



### Input - Read Integer

<cb>= int(input("<v>Input number: <>"))<>


Read input as an integer.

Throws <c>ValueError<> if not an integer.


Example:

<cb><v>number<> = int(input("<v>Enter a number: <>"))

print("You entered", <v>number<>)<>
@
@ input(), int(), user, input-only, enters, to
@ input-only, inputs-only



### Input - Read Password

<cb>= getpass()<>

<cb>from getpass import getpass

= getpass()
= getpass("<v>Enter password: <>")
= getpass("<v>Enter password:\\n<>")<>


Read a line from the standard input but doesn't display it.


Example:

<cb>from getpass import getpass

<v>password<> = getpass("<v>Enter your password:\\n<>")

print("You entered", <v>password<>)<>
@
@ input(), user, input-only, enters, secret, hidden, get
@ input-only, inputs-only



### Is Palindrome?

<cb>def is_palindrome(<v>word<>):
    return <v>word<> == <v>word<>[::-1]<>


Tests if a word is a palindrome.


<#>Not sure why everyone is searching for this but here you go - Tim O'.<>


Example:

<cb>def is_palindrome(<v>word<>):
    return <v>word<> == <v>word<>[::-1]

print(is_palindrome("racecar"))
print(is_palindrome("not a palindrome"))

<#># Prints:
\#
\# True
\# False<><>



### Item - Copy - Deep Copy

<cb>from copy import copy<>

<cb>= deepcopy(<v>item_1<>)<>

Makes a copy of any variable, particularly objects or collections.
All child objects will also be replicated.
The new item will be completely independent of the original.
@
@ copy.deepcopy(), .deepcopy(), object, instance



### Item - Copy - Shallow Copy

<cb>from copy import copy<>

<cb>= copy.copy(<v>item_1<>)<>

Makes a shallow copy of any variable, particularly objects or collections.
All child objects will be referenced from the new item.
@
@ copy.copy(), .copy(), object, instance



### Item - dir - Show Methods, Attributes

<cb>dir(<v>Class1<>)<>

<cb>dir(<v>instance_1<>)<>

Prints all available methods and attributes on an item.
Works for classes, class instances, functions, just about everything.
@
@ dir(), available methods, attributes, class, view, functions
@ help-only



### Line Separator

<cb>from os import linesep

= linesep<>

Returns the OS specific new line character.
@
@ newline, new line
@ os.linesep



### Local Symbols - Get

<cb>= locals()<>


Returns: <c>dict<>


Locals returns all symbols currently in local scope from the local symbol table.
@
@ locals(), in scope



### Logical Operator - XOR

<cb>= bool(<v>a<>) != bool(<v>b<>)<>

If <c><v>a<><>, <c><v>b<><> Are Booleans:

<cb>= <v>a<> != <v>b<><>


There is no explicit XOR operator but <c>!=<> works just fine.



#### Match - Match If in List

<cb>match <v>item_1<>:
    case <v>item_1<> if <v>item_1<> in <v>list_2<>:
        <v>...<><>


Will match the case only when <v>condition<> is met.


<cb><v>item_1<> = 1

even = [2, 4, 6, 8, 10]
odd = [1, 3, 5, 7, 9]

match <v>item_1<>:
    case <v>item<> if <v>item<> in <v>even<>: print('Even')
    case <v>item<> if <v>item<> in <v>odd<>: print('Odd')
    case _: print("Didn't match value.")

<#>Prints: 'Odd'<><>
@
@ with condition, contains
@ match-only



### Module - File Path

<cb>= __file__<>
@
@ __file__



### Module - Root

<cb>= __main__<>
@
@ __main__



### Module - Root - File Path

<cb>= __main__.__file__<>
@
@ __main__.__file__, __main__ __file__



### Operating System - Get

<cb>from platform import system<>

<cb>= system()<>


Returns the current Operating System

Linux:

<cb>= 'Linux'<>

MacOS:

<cb>= 'Darwin'<>

Windows:

<cb>= 'Windows'<>

@
@ get, os, windows, linux, macos, darwin, find, os name
@ platform.system(), .system()



### Print

<cb>print("<v>Text to be printed.<>")<>

<cb>print("<v>item 1<>", "<v>item 2<>", <v>...<>)			<#>#1<><>

<cb>print(repr(<v>item_1<>))						<#>#2<><>


\#1  -  Puts a space between items.

\#2  -  Use when <c>print(<v>item_1<>)<> wouldn't work.


Prints to the standard out.
Automatically moves to the next line.
@
@ print(), echo, to console, print-only, standard output, stdout, print()
@ print-only, printing-only



### Print - Newline Only

<cb>print()<>

Prints an empty line.
@ print-only, printing-only



### Print - No Newline

<cb>print('<v>text...<>', end='')<>
@
@ print(), echo, to console, print-only, standard output, stdout, new line, end=
@ print-only, printing-only



### Print - No Separator

<cb>print('<v>text1<>', '<v>text2<>', '<v>text3<>', sep='')<>
@
@ print(), echo, to console, print-only, standard output, stdout, sep=
@ print-only, printing-only



### Print - PPrint

<cb>import pprint

pprint.pprint(<v>value<>)<>

Prints Python data structures in a readable format.
@
@ pretty print pprint.pprint()
@ print-only, printing-only



### Print - Stay on Same Line

<cb>print('<v>text...<>', end='\\r')<>


Returns the print cursor to the start of the line.


'\\r' - Carriage Return


Example:

<cb><#># 5 Second Countdown:<>

from time import sleep

for <v>i<> in range(5,0,-1):
	print(<v>i<>, end='\\r')
	sleep(1)

print('Done.')<>
@
@ \\r, Carriage Return
@ print-only, printing-only




### Print - To Standard Error

Preferred:

<cb>print('<v>text...<>', file = sys.stderr)<>

Alternative:

<cb>sys.stderr.write('<v>text...<>')<>
@
@ print(), echo, to console, print-only, standard output, stderr, sys.stderr, file=
@ print-only, printing-only



### Print - To Standard Out

Preferred:

<cb>print('<v>text...<>')<>

Explicit:

<cb>print('<v>text...<>', file = sys.stdout)<>
@
@ print(), echo, to console, print-only, standard output, stdout, sys.stdout, file=
@ print-only, printing-only



### Program - Starting Module

<cb>from sys import argv

<v>module_name<> = argv[0]<>

Returns the name of the starting module file.
@
@ sys argv, sys.argv
@ command line, commandline, command-line, entry point, program, script



### Project - Recommended Project Structure

<cb><v>project_name<>/
├─ README.md
├─ pyproject.toml
├─ setup.cfg
├─ dist/
├─ docs/
│  └─ ...
├─ src/
│  ├─ __main__.py
│  └─ <v>package<>/
│     ├─__init__.py
│     └─<v>module<>.py
└─ tests/
   └─ ...<>


There are many ways to structure your project but this is perhaps the most standard way.


Official Doc:
<l>https://packaging.python.org/en/latest/tutorials/packaging-projects/<>
@
@ directories, standard, python



### Project - Minimal setup.py

<cb>from setuptools import find_packages, setup

setup(
	name='<v>app_name<>',
	version='1.0.0',
	description='<v>App description.<>',
	packages=find_packages('<v>src<>'),
	package_dir={'': '<v>src<>'}
)<>

Note:
'<c>src<>' is the standard directory for the project source code. On many projects the source folder has the same name as the root directory. In these cases, change <v><c>src<><> to the correct name.
@
@ file



### Python Home Directory

<cb>from sys import prefix

<v>python_home_directory<> = prefix<>

This is where Python thinks it's home directory is.
@
@ sys.prefix, path, folder



### Python Module - Search Path

<cb>import path from sys

<v>module_search_path<> = path<>


Returns the python module search path.
@
@ sys.path, get, mod, source directory



### Python Module - Add Path

<cb>import path from sys

path.append(<v>new_module_root_directory<><>


Adds a directory to the sources for python modules and scripts.
@
@ sys.path, get, mod



### Python Version

<cb>import sys

<v>version<> = sys.version					<#># Text Form of Version Number<><>

<cb>= sys.version_info						<#># Properties <c>major<>, <c>minor<>, And <c>micro<><><>


Example:

<cb>import sys

print(
		sys.version_info.major, '-',
		sys.version_info.minor, '-',
		sys.version_info.micro)<>
@
@ sys.version, sys.version_info
@ language, number, get



### Python Version - Descriptive

<cb>from sys import version

<v>descriptive_version<> = version<>

Includes version number, build date, clang version.
@
@ version, sys.version



### Show Help

<cb>help(<v>item<>)<>

Shows help documentation for <c><v>item<><>.
Will display the docstring if available.
Works for keywords, functions, classes, methods, or modules.
@
@ functions, help(), docstring, class, documentation, keyword, module, methods
@ help-only



### Sleep

<cb>from time import sleep

sleep(<v>time_in_seconds<>)<>

Sleep for the time in seconds.

Takes floats (0.030 = 30 ms).
Will pause current thread to allow other threads to run.


Example:

<cb>from time import sleep

sleep(1.5)
<#># Sleep 1½ seconds.<><>
@
@ sleep(), pause, suspend, time delay, time.sleep()
@ sleep-only



### Sleep - Until Given Time

Function:

<cb>from datetime import datetime
from time import sleep

def <v>slee_until<>(<v>datetime_1<>):
	sleep((<v>datetime_1<> - datetime.now()).total_seconds())<>

Call:

<cb><v>sleep_until<>(<v>datetime_1<>)<>

Sleeps until the given time has passed.
Works fine for sub-second times.
@ sleep-only



### System - Exit, Return Exit Code

<cb>import sys

sys.exit(<v>exit_code<>)<>

Returns from execution with the given exit code.

Recommended Exit Codes:

	0	OK
	1	General Error
	2	Command-line Validation
@
@ error code, status, number, end program, stop, quit, sys.exit(), .exit(), .quit(), python, script, application



### System - Exit, Return Exit Messages

<cb>import sys

sys.exit(<v>exit_message<>)<>

Returns from execution with error code 1.
Prints <c><v>exit_message<><>.
@
@ error, status, end program, stop, quit, sys.exit(), .exit(), .quit(), python, script, application



### Timer - Measure Elapsed Time

<cb>from time import perf_counter

<v>start<> = perf_counter()
<v>...<>
<v>end<> = perf_counter()

<v>difference_in_seconds<> = <v>end<> - <v>start<><>

Returns: <c>float<>


<c>perf_counter()<> returns the elapsed time in seconds,
Prefer over <c>time.time()<> as <c>perf_counter()<> is more accurate.
@
@ time.perf_counter(), .per_counter(), create, calculate
@ timers, timing, time operation, time something, measure
@ timer-only, timers-only



### Timer - Measure Execution Time (CPU Time)

<cb>from time import process_time

<v>start<> = process_time()
<v>...<>
<v>end<> = process_time()

<v>difference_in_seconds<> = <v>end<> - <v>start<><>

Returns: <c>float<>


<c>process_time()<> returns the execution time (CPU time) in seconds as a float.
Does not measure time while a process is sleeping or suspended.
@
@ time.process_time(), .process_time(), create, calculate
@ timers, timing, time operation, time something, measure
@ timer-only, timers-only



### Timing - perf_counter() vs process_time() vs time()

<c>perf_counter()<>:

<*>Prefer over <c>time()<> (more accurate).
Measures elapsed time precisely.
perf_counter -> Performance Counter
<c>import time.perf_counter<><>

<c>process_time()<>:

<*>Measures CPU time only.
If the process sleeps, that time will not be tracked.
<c>import time.process_time<><>

<c>time()<>:

<*>Measures absolute elapsed time.
Not guaranteed to be accurate as it can be changed.
<c>import time.time<><>
@
@ time.perf_counter(), .per_counter()
@ time.process_time(), .process_time()
@ time.time(), .time()
@ versus
@ timer-only, timers-only


# Reference - Formatting

Python Format Page:
<l>https://docs.python.org/3/library/string.html#format-specification-mini-language<>
@
@ format-only, formatting-only, formats-only, f-strings, fstrings, .format(), f"", f'', codes
@ string-format()-only



### Format - Padding
@
@ strings, integers, floats, numbers



#### Format - Pad Center Text

With Spaces:

<cb>= f'{<v>item_1<>:^<v>length<>}'<>

<cb>= '{:^<v>length<>}'.format(<v>item_1<>)<>


With Fill Character:

<cb>= f'{<v>item_1<>:<v>fill_character<>^<v>length<>}'<>

<cb>= '{:<v>fill_character<>^<v>length<>}'.format(<v>item_1<>)<>


Text centered, pad both sides.


Example:

<cb><v>formatted_1<> = "{:^15}".format(<v>"Center"<>)

<#># Returns '<c>    Center     <>'<><>

<cb><v>formatted_2<> = "{:*^15}".format(<v>"Center"<>)

<#># Returns '<c>****Center*****<>'<><>
@
@ Around



#### Format - Pad on Left

With Spaces:

<cb>= f'{<v>item_1<>:><v>length<>}'<>

<cb>= '{:><v>length<>}'.format(<v>item_1<>)<>


With Fill Character:

<cb>= f'{<v>item_1<>:<v>fill_character<>><v>length<>}'<>

<cb>= '{:<v>fill_character<>><v>length<>}'.format(<v>item_1<>)<>


Pads on the left side of the value.


Example:

<cb><v>formatted_1<> = "{:>15}".format(<v>"Pad Left"<>)

<#># Returns '<c>       Pad Left<>'<><>

<cb><v>formatted_2<> = "{:*>15}".format(<v>"Pad Left"<>)

<#># Returns '<c>*******Pad Left<>'<><>
@
@ Right Justify, start
@ pad-left, right-justify, align-right



#### Format - Pad on Right

With Spaces:

<cb>= f'{<v>item_1<>:\<<v>length<>}'<>

<cb>= '{:\<<v>length<>}'.format(<v>item_1<>)<>


With Fill Character:

<cb>= '{<v>item_1<>:<v>fill_character<>\<<v>length<>}'<>

<cb>= '{:<v>fill_character<>\<<v>length<>}'.format(<v>item_1<>)<>


Pads on the right side of the value.


Example:

<cb><v>formatted_1<> = "{:\<15}".format(<v>"Pad Right"<>)

<#># Returns '<c>Pad Right      <>'<><>

<cb><v>formatted_2<> = "{:*\<15}".format(<v>"Pad Right"<>)

<#># Returns '<c>Pad Right******<>'<><>
@
@ Left Justify, End
@ pad-right, left-justify, align-left



### Format Binary
@
@ to string, integer, bits


#### Format Integer - As Binary

<cb>= f'{<v>value<>:b}'<>

<cb>= '{:b}'.format(<v>value<>)<>


Examples:

<cb><v>value<> = <v>12<>

print(f'{<v>value<>:b}')

<#># Prints: 1100<><>

<cb><v>value<> = <v>12<>

print('{:b}'.format(<v>value<>))

<#># Prints: 1100<><>



#### Format Integer - As Binary, Leading Zeros

<cb>= f'{<v>int_1<>:0<v>length<>b}'<>

<cb>= '{:0<v>length<>b}'.format(<v>int_1<>)<>


Examples:

<cb><v>value<> = <v>12<>

print(f'{<v>value<>:0<v>8<>b}')

<#># Prints: 00001100<><>

<cb><v>value<> = <v>12<>

print('{:0<v>8<>b}'.format(<v>value<>))

<#># Prints: 00001100<><>
@
@ to string, integer, pad, fixed length, 8



### Format Hex
@
@ to string, integer, hexadecimal


#### Format Integer - As Hex, Lower Case

<cb>= f'{<v>value<>:x}'<>

<cb>= '{:x}'.format(<v>value<>)<>


Format to lower case hex values using lower case 'x'.


Examples:

<cb><v>value<> = <v>42<>

print(f'{<v>value<>:x}')

<#># Prints: 2a<><>

<cb><v>value<> = <v>42<>

print('{:x}'.format(<v>value<>))

<#># Prints: 2a<><>



#### Format Integer - As Hex, Lower Case, Leading Zeros

<cb>= f'{<v>int_1<>:0<v>length<>x}'<>

<cb>= '{:0<v>length<>x}'.format(<v>int_1<>)<>


Format to lower case hex values using lower case 'x'.
Format with leading zeros by adding '0' and length after the ':'.


Examples:

<cb><v>value<> = <v>42<>

print(f'{<v>value<>:0<v>4<>x}')

<#># Prints: 002a<><>

<cb><v>value<> = <v>42<>

print('{:0<v>4<>x}'.format(<v>value<>))

<#># Prints: 002a<><>
@
@ to string, integer, pad, fixed length



#### Format Integer - As Hex, Upper Case

<cb>= f'{<v>value<>:X}'<>

<cb>= '{:X}'.format(<v>value<>)<>


Format to upper case hex values using upper case 'X'.


Examples:

<cb><v>value<> = <v>42<>

print(f'{<v>value<>:X}')

<#># Prints: 2A<><>

<cb><v>value<> = <v>42<>

print('{:X}'.format(<v>value<>))

<#># Prints: 2A<><>



#### Format Integer - As Hex, Upper Case, Leading Zeros

<cb>= f'{<v>int_1<>:0<v>length<>X}'<>

<cb>= '{:0<v>length<>X}'.format(<v>int_1<>)<>


Format to upper case hex values using upper case 'X'.
Format with leading zeros by adding '0' and length after the ':'.


Examples:

<cb><v>value<> = <v>42<>

print(f'{<v>value<>:0<v>4<>X}')

<#># Prints: 002A<><>

<cb><v>value<> = <v>42<>

print('{:0<v>4<>X}'.format(<v>value<>))

<#># Prints: 002A<><>
@
@ to string, integer, pad, fixed length



### Format - Date / Date Time

<cb>= f'{<v>datetime_1<>:<v>date_format<>}'<>

<cb>= '{:<v>date_format<>}'.format(<v>datetime_1<>)<>
@
@ To String, datetime, date times



#### Format Date - Date Format Codes

<table><col><b>Item<><><col><b>Output<><><col><b>Symbol<><>
<col> <>
<col>Literal %		<><col><c>%		<><><col><c>%%	<><>
<col>	<>
<col>Day<><col><c>1-31<><><col><c>%-d<><>
<col>	<><col><c>01-31<><><col><c>%d<><>
<col>	<>
<col>Day of Week<><col><c>0-6<><><col><c>%w<><>
<col>	<><col><c>1-7<><><col><c>%u<><><col><#>(ISO 8601)<><>
<col>	<><col><c>Mon<><><col><c>%a<><>
<col>	<><col><c>Monday<><><col><c>%A<><>
<col>	<>
<col>Day of Year<><col><c>1-365<><><col><c>%-j<><>
<col>	<><col><c>001-365<><><col><c>%j<><>
<col>	<>
<col>Month<><col><c>1-12<><><col><c>%-m<><>
<col>	<><col><c>01-12<><><col><c>%m<><>
<col>	<><col><c>Jan<><><col><c>%b<><>
<col>	<><col><c>January<><><col><c>%B<><>
<col>	<>
<col>Week<><col><c>0-53<><><col><c>%-U<><><col><#>(Starts Sunday)<><>
<col>	<><col><c>00-53<><><col><c>%U<><><col><#>(Starts Sunday)<><>
<col>	<><col><c>0-53<><><col><c>%-W<><><col><#>(Starts Monday)<><>
<col>	<><col><c>00-53<><><col><c>%W<><><col><#>(Starts Monday)<><>
<col>	<><col><c>0-53<><><col><c>%-V<><><col><#>(Starts Monday) (ISO 8601)<><>
<col>	<><col><c>00-53<><><col><c>%V<><><col><#>(Starts Monday) (ISO 8601)<><>
<col>	<>
<col>Year<><col><c>00-99<><><col><c>%y<><>
<col>	<><col><c>2001<><><col><c>%Y<><>
<col>	<>
<col>Time Zone<><col><c>%Z<><>
<col>UTC Offset<><col><c>%z<><>
<col>	<>
<col>Local Date<><col><c>%x<><>
<col>	<>
<col>Local Date Time<><col><c>%c<><><>
@
@ pattern, formats
@ %%, %a, %b, %c, %d, %j, %m, %u, %v, %w, %x, %y
@ yyyy-mm-dd, year, month, day, week, local, iso 8601, iso-8601



#### Format Date - Time Format Codes

<table><col><b>Item<><><col><b>Output<><><col><b>Symbol<><>
<col>	<>
<col>Literal %		<><col><c>%		<><><col><c>%%	<><>
<col>	<>
<col>Milliseconds<><col><c>000000-999999<><><col><c>%f<><>
<col>	<>
<col>Second<><col><c>00-59<><><col><c>%S<><>
<col>	<><col><c>0-59<><><col><c>%-S<><>
<col>Minute<><col><c>00-59<><><col><c>%M<><>
<col>	<><col><c>0-59<><><col><c>%-M<><>
<col>	<>
<col>Hour<><col><c>00-12<><><col><c>%I<><>
<col>	<><col><c>0-12<><><col><c>%-I<><>
<col>	<><col><c>00-23<><><col><c>%H<><>
<col>	<><col><c>0-23<><><col><c>%-H<><>
<col>	<>
<col>AM/PM<><col><c>AM <s>|<> PM<><><col><c>%p<><>
<col>	<>
<col>Time Zone<><col><c>UTC<><><col><c>%Z<><>
<col>	<>
<col>UTC Offset<><col><#># -0500<><><col><c>%z<><>
<col>	<>
<col>Local Time<><col><><col><c>%X<><><>
@
@ formats, timezones, pattern
@ %%, %f, %s, %m, %i, %h, %p, %z, %x
@ hh-mm-ss, am, pm, UTC, timezone, time zone, hour, minute, second, millisecond, local time



#### Format Date - HH:MM:SS

Using F-String:

<cb>= f'{<v>datetime_1<>:%H:%M:%S}'<>

Using format():

<cb>= '{:%H:%M:%S}'.format(<v>datetime_1<>)<>


Returns hour, minute, second.
@
@ datetime, time, hour, minute, second, hhmmss



#### Format Date - YYYY-MM-DD

Using F-String:

<cb>= f'{<v>datetime_1<>:%Y-%m-%d}'<>

Using format():

<cb>= '{:%Y-%m-%d}'.format(<v>datetime_1<>)<>

Returns year, month, day.

Works with dates and datetimes.
@
@ datetime, Year, Month, Day, iso 8601, iso-8601, yyyymmdd



#### Format Date - YYYY-MM-DD HH:MM:SS

Using F-String:

<cb>= f'{<v>datetime_1<>:%Y-%m-%d %H:%M:%S}'<>

Using format():

<cb>= '{:%Y-%m-%d %H:%M:%S}'.format(<v>date_1<>)<>

<cb>= '{:%Y-%m-%d %H:%M:%S}'.format(<v>datetime_1<>)<>

Returns year, month, day, hour, minute, second.
For dates will print time as '00:00:00'
@
@ datetime, year, month, day, hour, minute, second, yyyymmdd, hhmmsss



#### Format Date - YYYY-MM-DD HH:MM:SS - Time Zone

Using F-String:

<cb>= f'{<v>datetime_1<>:%Y-%m-%d %H:%M:%S %Z}'<>

Using format():

<cb>= '{:%Y-%m-%d %H:%M:%S %Z}'.format(<v>date_1<>)<>

<cb>= '{:%Y-%m-%d %H:%M:%S %Z}'.format(<v>datetime_1<>)<>

Returns year, month, day, hour, minute, second and timezone.
For dates will print time as '00:00:00'
@
@ datetime, year, month, day, hour, minute, second, yyyymmdd, hhmmsss



ash.#### Format Date - YYYY-MM-DD HH:MM:SS - UTC Offset

Using F-String:

<cb>= f'{<v>datetime_1<>:%Y-%m-%d %H:%M:%S %z}'<>

Using format():

<cb>= '{:%Y-%m-%d %H:%M:%S %z}'.format(<v>date_1<>)<>

<cb>= '{:%Y-%m-%d %H:%M:%S %z}'.format(<v>datetime_1<>)<>

Returns year, month, day, hour, minute, second and utc offset.
For dates will print time as '00:00:00'
@
@ datetime, year, month, day, hour, minute, second, yyyymmdd, hhmmsss, utc



### Format Date - Standard Formats
@
@ dates


#### Format Date - Ireland / UK

Using F-String:

<cb>= f'{<v>datetime_1<>:%d/%m/%Y}'<>

Using format():

<cb>= '{:%d/%m/%Y}'.format(<v>datetime_1<>)<>

Format:

<cb><v>dd<>/<v>mm<>/<v>yyyy<><>
@
@ DD/MM/YYYY, DD-MM-YYYY



#### Format Date - Europe

Using F-String:

<cb>= f'{<v>datetime_1<>:%d.%m.%Y}'<>

Using format():

<cb>= '{:%d.%m.%Y}'.format(<v>datetime_1<>)<>

Format:

<cb><v>dd<>.<v>mm<>.<v>yyyy<><>
@
@ DD.MM.YYYY



#### Format Date - USA

Using F-String:

<cb>= f'{<v>datetime_1<>:%m/%d/%Y}'<>

Using format():

<cb>= '{:%m/%d/%Y}'.format(<v>datetime_1<>)<>

Format:

<cb><v>mm<>/<v>dd<>/<v>yyyy<><>
@
@ MM/DD/YYYY, MM-DD-YYYY, MMDDYYYY



#### Format Date - ISO 8601 / International

YYYY-MM-DD:

<cb>= f'{<v>datetime_1<>:%Y-%m-%d}'<>

<cb>= '{:%Y-%m-%d}'.format(<v>datetime_1<>)<>

YYYYMMDD:

<cb>= f'{<v>datetime_1<>:%Y%m%d}'<>

<cb>= '{:%Y%m%d}'.format(<v>datetime_1<>)<>
@
@ iso-8601, YYYY-MM-DD, YYYYMMDD



#### Format Date Time - ISO 8601 / International

YYYYMMDDThhmmss:

<cb>= f'{<v>datetime_1<>:%Y%m%dT%H%M%S}'<>

<cb>= '{:%Y%m%dT%H%M%S}'.format(<v>datetime_1<>)<>

YYYY-MM-DDThh:mm:ss:

<cb>= f'{<v>datetime_1<>:%Y-%m-%dT%H:%M:%S}'<>

<cb>= '{:%Y-%m-%dT%H:%M:%S}'.format(<v>datetime_1<>)<>

YYYY-MM-DDThh:mm:ssZ:

<cb>= f'{<v>datetime_1<>:%Y-%m-%dT%H:%M:%S%Z}'<>

<cb>= '{:%Y-%m-%dT%H:%M-:S%Z}'.format(<v>datetime_1<>)<>
@
@ iso-8601, YYYYMMDDThhmmss, YYYY-MM-DDThh:mm:ss, YYYY-MM-DDThh:mm:ssz



### Format Integer
@
@ Numbers, integers



#### Format Integer - Comma Separated

Using F-String:

<cb>= f'{<v>int_1<>:,}'<>

Using format():

<cb>= '{:,}'.format(<v>int_1<>)<>


Example:

<cb><v>an_int<> = 1234

<v>formatted<> = f'{<v>an_int<>:,}'

<#># Returns '1,234'<><>



#### Format Integer - Leading Zeros

Using F-String:

<cb>= f'{<v>int_1<>:0<v>length<>}'<>

Using format():

<cb>= '{:0<v>length<>}'.format(<v>int_1<>)<>


<c><v>length<><> is the total length including leading zeros.


Example:

<cb><v>an_int<> = 1234

<v>formatted<> = f'{<v>an_int<>:0<v>6<>}'

<#># Returns '001234'<><>
@
@ pad with, pad left



### Format - Float

Basic:

<cb>= f'{<v>value<>:f}'<>

<cb>= '{:f}'.format(<v>value<>)<>


With Formatting:

<cb>= f'{<v>value<>:<v>format<>f}'<>

<cb>= '{:<v>format<>f}'.format(<v>value<>)<>
@
@ Numbers, floats



#### Format Float - Decimals

<cb>= f'{<v>value<>:.<v>decimals<>f}'<>

<cb>= '{:.<v>decimals<>f}'.format(<v>value<>)<>


Rounds up or down as needed.


Example:

<cb><v>formatted_1<> = '{:.<v>2<>f}'.format(<v>12.3456<>)

<#># Returns '12.35'<><>
@
@ decimal point



#### Format Float - Decimals, Comma Separated

<cb>= '{<v>value<>:,.<v>decimals<>f}'<>

<cb>= '{:,.<v>decimals<>f}'.format(<v>value<>)<>


Rounds up or down as needed.


Example:

<cb><v>formatted_1<> = '{:,.<v>2<>f}'.format(<v>1234.567<>)

<#># Returns '1,234.57'<><>
@
@ decimal point



### Format Codes - Reverse Lookup

Codes for the <c><v>format<><> Part In:

<cb>f'{<v>value<>:<v>format<>}'

'{:<v>format<>}'.format(<v>value<>)<>


<c>%%<>			Escaped %
<c>{{<>			Escaped {
<c>}}<>			Escaped }

<c>,<>			Comma Separated Numbers
<c>.<v>2<><>			Decimal Places

<c>\<<v>10<><>			Align Left  /  Pad Right
<c>><v>10<><>			Align Right  /  Pad Left
<c>^<v>10<><>			Align Center

<c>0<v>10<><>			Leading Zeroes

<c><v>char<>\<<v>10<><>		Alight Left, Fill Character <c><v>char<><>
<c><v>char<>><v>10<><>		Alight Right, Fill Character <c><v>char<><>
<c><v>char<>^<v>10<><>		Alight Center, Fill Character <c><v>char<><>

<c>%%<>			Literal %			<c>%<>
<c>%-d<>			Day 			<c>1-31<>
<c>%-H<>			Hour			<c>0-23<>
<c>%-I<>			Hour			<c>0-12<>
<c>%-j<>			Day of Year		<c>1-365<>
<c>%-M<>			Minute			<c>0-59<>
<c>%-m<>			Month			<c>1-12<>
<c>%-S<>			Second			<c>0-59<>
<c>%-U<>			Week			<c>0-53<> (Starts Sunday)
<c>%-V<>			Week			<c>0-53<> (Starts Monday) (ISO 8601)
<c>%-W<>			Week			<c>0-53<> (Starts Monday)
<c>%a<>			Day of Week		<c>Mon<>
<c>%A<>			Day of Week		<c>Monday<>
<c>%b<>			Month			<c>Jan<>
<c>%B<>			Month			<c>January<>
<c>%c<>			Local Date Time
<c>%d<>			Day				<c>01-31<>
<c>%f<>			Milliseconds		<c>000000-999999<>
<c>%H<>			Hour			<c>00-23<>
<c>%I<>			Hour			<c>00-12<>
<c>%j<>			Day of Year		<c>001-365<>
<c>%m<>			Month			<c>01-12<>
<c>%M<>			Minute			<c>00-59<>
<c>%p<>			AM/PM			<c>AM <s>|<> PM<>
<c>%S<>			Second			<c>00-59<>
<c>%u<>			Day of Week		<c>1-7<>	 (ISO 8601)
<c>%U<>			Week			<c>00-53<> (Starts Sunday)
<c>%V<>			Week			<c>01-53<> (Starts Monday) (ISO 8601)
<c>%w<>			Day of Week		<c>0-6<>
<c>%W<>			Week			<c>00-53<> (Starts Monday)
<c>%x<>			Local Date
<c>%y<>			Year			<c>00-99<>
<c>%Y<>			Year			<c>2001<>
<c>%z<>			UTC Offset		(e.g. -0500)
<c>%Z<>			Time Zone		<c>UTC<>
<c>%X<>			Local Time
@
@ @%%, %-d, %-H, %-I, %-j, %-M, %-m, %-S, %-U, %-V, %-W, %a, %A, %b, %B, %c, %d, %f, %H, %I, %j, %M, %m, %p, %S, %u, %U, %V, %w, %W, %x, %y, %Y, %Z, %z, %X



# Reference - Magic Methods
@
@ magic-only, magic-methods-only, double underscore, dunder methods


### Basics


__all__				Defines 
__bool__
__contains__
__dict__
__doc__
__file__
__hash__
__init__
__iter__
__len___
__main__
__name__
__next__
__repr__
__str__


### __bool__

Returns the true or false value of an object.
Return True for non zero, non empty values.
Use with if statements or <c>bool()<> function.


Example:

<cb>class <v>GetBoolean<>:

	def __init__(self, <v>bool_value<>):
		self.<v>bool_value<> = <v>bool_value<>

	def __bool__(self):
		return self.<v>bool_value<><>

<cb><v>is_true<> = <v>GetBoolean<>(<v>True<>)				<#># Set To True<>

<v>actual_value<> = bool(<v>is_true<>)			<#># Returns True<><>

<cb><v>is_true<> = <v>GetBoolean<>(<v>True<>)				<#># Set To True<>

if <v>is_true<>:
	<v>...<><>
@
@ bool, __bool__()



### __contains__

<cb>def __contains__(self, <v>value<>):
	<v>...<><>

<cb>if <v>item<> in <v>class_1<>:
	<v>...<><>

Overloads 'in' operator.
@
@ __contains__(), Overload, in, __in__()



### __dict__

<cb>= <v>class_1<>.__dict__.keys()<>

Returns class attributes as a dict.



### __doc__

<cb>= <v>Class1<>.__doc__						<#># From Class<><>

<cb>= <v>class_1<>.__doc__						<#># From Instance<><>

Returns the object's docstring.



### __file__

Returns the file name of the current module.



### __hash__

<cb>def __hash__(self):
	return hash(<v>key_tuple<>)<>

Usage:

<cb>def __hash__(self):
    return hash(<v>key_tuple<>)<>

<cb>def __hash__(self):
    return hash((self.<v>key_1<>, self.<v>key_2<>, <v>...<>))<>


Hashes the identity of an object.

Use an object's keys to create hash.
The key should never change for the lifetime of the object.
Prefer immutable objects over mutable ones.


Object Identity vs Object Hash:

<cb>if <v>a<> == <v>b<> then
    hash(<v>a<>) == hash(<v>b<>)

if hash(<v>a<>) == hash(<v>b<>) then
    <v>a<> maybe == <v>b<>

if hash(<v>a<>) != hash(<v>b<>) then
    <v>a<> != <v>b<><>



### __init__

<cb>class <v>Class1<>:

	def __init__(self, <v>...<>):
		<v>...<><>

Class initializer / constructor.



### __iter__

Returns an iterator usable with <c>for<> and <c>in<> statements.
Implement this method if you want to return an iterator for your object.

See: <c>__next__<>
See: Class - Iterator - Define



### __len___

Returns the length or count of an object.
Use with len function.


Example:

<cb>class <v>GetLength<>:

	def __init__(self, length):
		self.length = length

	def __len__(self):
		return self.length


<v>of_length_10<> = <v>GetLength<>(<v>10<>)

<v>length<> = len(<v>of_length_10<>)				<#># Returns 10<><>
@
@ size, count, len()



### __main__

<cb>__name__ == '__main__'<>

Usage:

<cb>if __name__ == '__main__':
	<v>...<><>


The main/root module reference.


Why use <c>__name__ == '__main__'<>:

Use this when you want to run a file as the main program and also as a module.
<c>__name__<> will only be <c>'__main__'<> when the file is the starting file / entry point into the program.

Add module classes and functions as normal.
But to run as a the main application, add code after the <c>if<> statement.

Form:

<cb>if __name__ == '__main__':

	<#># Code for main program here...<><>
@
@ Startup, entry point



### __name__

The name of the object.

For modules, it is the file name (no extension).

e.g. module, class or function name.



### __next__

Iterator: Returns the next item in the collection.
Iterator: Raises an exception beyond the last point.



### __repr__

Returns unambiguous string representation of the class.
Always implement this.
@
@ tostring()



### __str__

Returns a readable string representation of the class.
Will call <c>__repr__<> if no <c>__str__()<> method found.
@
@ tostring()



### __repr__ vs __str__

<c>__repr__<>

	Use to show an unambiguous version of the class.
	You should always implement this.

<c>__str__<>

	Use to show a human readable version of the class.
	If not present, Python will call <c>__repr__<>.
@
@ versus



# Reference - Standard Packages



### Package - kombu

Message Queue Library



### Package - os

OS and File Related Functions



### Package - sys

System Utilities



### Package - zipfile

Zip Class, Functions



# Reference - External Libraries


### NumPy - A Data Crunching Library

A scientific computing/ data crunching library.

SpeedSheet:
<l>/s/numpy<>

Library Name:

<cb>numpy<>

<cb>pip install numpy<>

Import:

<cb>import numpy as np<>


Official Site:
<l>https://numpy.org/doc/stable/<>
@
@ ndarray, ndim, shapes



### pynput - Keyboard / Mouse Library

Ideal for sending keystrokes, mouse actions to the current windown.
Ideal for monitoring the keyboard and mouse.

Library:

<cb>pynput<>

<cb>pip install pynput<>

Import:

<cb>from pynput import mouse, keyboard<>


SpeedSheet (Partial Details):
<l>/s/pynput<>

Official Site:
<l>https://pynput.readthedocs.io/en/latest/<>
@
@ keystrokes, move



### pyperclip - A Clipboard Library

A simple and useful library for copying to and from the clipboard.

Library Name:

<cb>pyperclip<>

<cb>pip install pyperclip<>

Import:

<cb>import pyperclip<>

Basics:

<cb>pyperclip.copy(<v>text<>)

<v>text<> = pyperclip.paste()<>


Official Site:
<l>https://github.com/asweigart/pyperclip<>

PyPi:
<l>https://pypi.org/project/pyperclip/<>
@
@ copy, paste



### pyttsx3 - Text To Speech

Good library for text to speech.
Uses OS for speech.

Library:

<cb>pyttsx3<>

<cb>pip install pyttsx3<>

Import:

<cb>import pyttsx3<>

Basic Example:

<cb>import pyttsx3

<v>engine<> = pyttsx3.init()

voices = <v>engine<>.getProperty('voices') 
<v>engine<>.setProperty('voice', voices[0].id)

<v>engine<>.say ("<v>Hello meatbag.<>")
<v>engine<>.runAndWait()<>
@
@ synthesis, say, talk, speach



# Reference - Configuration Files



### pyproject.toml

Place in your project root directory.

Sample:

<cb>[project]
name = "<v>project_name<>"
description = "<v>Project description.<>"
version = "<v>0.1.0<>"
license = "<v>license type<>"
authors = [
	{ name = "<v>your_name_here<>", email = "<v>your_email_here<>" }
]

dependencies = [
	"<v>package_1<>",
	"<v>package_2<>"
]

[project.optional-dependencies]
dev = [
	"pytest",
	"<v>test_package_1<>"
]

[build-system]
requires = [
    "setuptools >= 35.0.2",
    "setuptools_scm >= 2.0.0, \<3"
]
build-backend = "setuptools.build_meta"<>



# Reference - Coming From Other Languages


### ++, -- Operators

Not supported in Python.

Use Instead:

<cb><v>a<> += 1;
<v>a<> -= 1;<>
@
@ increment, decrement


### Arrays

Use <c><l "?q=list-only">list<><>.

Python does not have built in arrays.
Use lists instead.
You can also use the Array library.
@
@ Create, New, Define, Instantiate



### Arrow Functions, ->, =>

Use <c><l "?q=lambda-only">lambdas<><>.



### Hash Maps, Tables

Use <c><l "?q=dict-only">dicts<><>.
@
@ associative array, hashmap, hash, maps



### istype, instanceof

Use <c><l "?q=type()">type()<><> or <c><l "?q=isinstance()">isinstance()<><>.



### Long

Use <c><l "?q=int-only">int<><>.

Python has only one integer type and that is <c>int<>.
@
@ long-only
@ Create, Define, Instantiate, New



### Money, Currency

Use <c><l "?q=decimal-only">Decimal<><>.
@
@ $, ¢, €, £, ¥, ¤, usd, euro, yen, yuan, dollars, cents



### New Keyword

Not needed.

Python does not require <c>new<> when creatin a new instance of a class.


Example:

<cb><v>instance_1<> = <v>Class1<>()		<#># Creates a New Instance of Class1<><>
@
@ classes



### Nil, Null

Use <c><l "?q=none-only">None<><>.

Python's version of <c>nil<> or <c>null<> is <c>None<>.

For char(0), use <c>"\\00"<>.
@
@ long-only
@ Create, Define, Instantiate, New, is, isnull



### Stack

There is no stack. Use <c><l "?q=list-only">list<><> instead.


Example:

<cb><v>stack_1<> = []

<v>stack_1<>.append(<v>item<>)

<v>item<> = <v>stack_1<>.pop()<>
@
@ data type, collections, stacks, push, pop, add, remove, append to



### Throw

Use:

<cb>raise <v>Exception1<>()<>

See: <l "?q=exceptions-only">Exceptions<>.
@
@ throws, thrown



### Try Catch

Use:

<cb>try:

except Exception as <v>exception_1<>:<>

See: <l "?q=exceptions-only">Exceptions<>.
@
@ thrown



# Symbols
@
@ lookup
@ symbol-only, symbols-only, sym-only


## Symbols - Basics

<table><col><c><#># A comment.<><><><col>Programmer Comment<>
<col> <>
<col><c><v>statement<>;<><><col>Semicolon Statement Separator<>
<col> <>
<col><c>@<v>function_1<>()<><><col>Decorated Function<><col><#># At Sign '@'<><>
<col> <>
<col><c>*args<><><col>Arguments Passed as a Tuple (Array<><col><#># Single Asterisk '*'<><>
<col><c>**kwargs<><><col>Arguments Passed as a Key Value Dictionary<><col><#># Double Asterisks '**'<><>
<col> <>
<col><c>*<v>value_1<><><><col>A Sublist Extracted from Some Sequence<>
<col><c>*_<><><col>A Sublist Extracted from Some Sequence But Ignored<>
<col><c>_<><><col>A Value Extracted from a Sequence But Ignored<>
<col> <>
<col><c>self.<v>some_member<><><><col>Class instance reference to internal member<><col><#># <c>self.<><><>
<col> <>
<col><c>'<v>A string<>'<><><col>String<>
<col><c>"<v>A string<>"<><><col>Also A String<>
<col> <>
<col><c><#>"""Doc comment."""<><><><col>DocString<>
<col> <>
<col><c>"""<v>Multiline
String<>"""<><><col>A Multiline String<>
<col> <>
<col><c>'''<v>Multiline
String<>'''<><><col>A Multiline String<>
<col> <>
<col><c>_<v>name_1<><><><col>Private Function or Variable<><col><#># Single Underscore '_'<><>
<col><c>__<v>method_name<>__<><><col>Magic Method / System Method<><col><#># Double Underscore, Both Ends '__'<><>
<col> <>
<col><c>{}<><><col>Empty Dictionary<>
<col><c>{<v>key1<> : <v>value1<>, <v>...<>}<><><col>Dictionary<>
<col><c>{<v>value1<>, <v>...<>}<><><col>Set<><col><#># No Colon ':'<><>
<col> <>
<col><c>[]<><><col>Empty List<>
<col><c>[<v>value1<>, <v>value2<>, <v>...<>]<><><col>List<>
<col><c>(<v>value1<>, <v>value2<>, <v>...<>)<><><col>Tuple<>
<col> <>
<col><c><v>a<> := <v>b<><><><col>Walrus Operator / Assignment Expression<><>



## Symbols - Details


### Symbol ''

String

<cb>'<v>This is a string.<>'<>

Empty String

<cb>''<>




### Symbol '''

Multiline String

<cb>multiline_string = '''<v>This is
a multiline
string.<>'''<>


### Symbol ""

String

<cb>"<v>This is a string.<>"<>

Empty String

<cb>""<>



### Symbol """

DocString

<cb>def <v>function_1<>():
	<#>""" DocString describing function_1. """<><>

Multiline String

<cb>multiline_string = """<v>This is
a multiline
string.<>"""<>


### Symbol @
Denotes a decorated function.

<cb>@<v>decorator<>()
def <v>decorated_function<>():
    <v>...<><>

A function name leading with an at sign is a decorator
@
@ at sign



### Symbol #
Comment

<cb><#># This is a comment<><>

The hash denotes a comment section at the end of a line.
@
@ hash, pound



### Symbol ;
Statement Separator

<cb><v>statement_1<>;<>

The semicolon identifies the division between one statement and another.
It is not required in Python but is accepted.
@
2 semicolon, statement separator



### Symbol *args

Arguments received as a tuple.

<cb>def <v>function_1<>(*args):
	<v>...<><>

When calling the function, the sequence or list is converted to the function arguments in order.
When the arguments as defined as <c>*args<> in the function, arguments are converted to a tuple and then passed in.
@
@ params, args, arguments
@ single asterisk, star



### Symbol **kwargs
Key Word Arguments

Denotes arguments received by a function as a key value dict.

<cb>def <v>function_1<>(**kwargs):
	<v>...<><>

When calling the function, the keys are mapped to the function's internal arguments by name.
When the arguments are defined as <c>**kwargs<> in the function, named arguments are converted to a dict and then passed in.
@
@ kwargs
@ parameter, params, arguments
@ double asterisks, stars, keyword arguments, key word



### Symbol *list
A sequence or list to be unpacked when calling a function.

When calling a function, the sequence or list will be unpacked into parameter order before passing to the function.

<cb><v>function_1<>(*<v>parameters<>)<>

<cb><v>parameters<> = (1, "name", "description")
<v>create<>(*<v>parameters<>)<>



### Symbol *sublist
Sublist destructured (extracted) from a sequence or other list.

<cb><v>first<>, *<v>remainder<> = <v>sequence_1<><>

See: <l "?q=destructur&select=2jr2">Destructuring<>



### Symbol *_
An ignored sublist during destructuring of a sequence.

<cb><v>first<>, *_, <v>last<> = <v>sequence_1<><>

See: <l "?q=destructur&select=2jr2">Destructuring<>
@
@ asterisk, star, underscore


### Symbol _

Private Method or Variable (Name with Leading _)

<cb>def _<v>private_method_1<>():
	<v>...<><>

Number Literal (For Readability)

<cb><v>12<>_<v>345.00<>_<v>00<><>

Destructuring - Ignored Value

<cb>_, *<v>remainder<> = <v>list_1<><>

Default Match Clause

<cb>match <v>value<>:
    case _:
        <v>...<><>
@
@ underscore


### Symbol __

A Dunder Method, A System Reserved Method

<cb><v>instance_1<>.__name__<>
@
@ double underscore, dunder, magic method



### Symbol .

Method or Property Accessor

<cb><v>instance_1<>.<v>method_1<>()<>

<cb>= <v>instance_1<>.<v>property_1<><>



### Symbol self

References the current class instance.

<cb> = self.<v>property_1<><>



### Symbol []

List

<cb><v>list_1<> = [1, 2, 3]<>


Empty List

<cb><v>empty_list<> = []<>



### Symbol {}

Dict

<cb><v>dict_1<> = {1 : "one", 2 : "two", 3 : "three"}<>

Empty Dict

<cb><v>empty_dict<> = {}<>

Set

<cb><v>set_1<> = {1, 2, 3}<>



### Symbol ()

Tuple

<cb><v>tuple_1<> = (1, 2, 3)<>


Empty Tuple

<cb><v>empty_tuple<> = ()<>



## Symbols - Operator Symbols


### Symbol +

Addition (Arithmetic Operator)
String Concatenation (Arithmetic Operator)

<cb><v>a<> + <v>b<><>


### Symbol -

Subtraction (Arithmetic Operator)

<cb><v>a<> - <v>b<><>


### Symbol *

Multiplication (Arithmetic Operator)

<cb><v>a<> * <v>b<><>


### Symbol /

Division (Arithmetic Operator)

<cb><v>a<> / <v>b<><>


### Symbol //

Floor Division (Arithmetic Operator)

<cb>/<v>a<> // <v>b<><>


### Symbol %

Modulus (Arithmetic Operator)

<cb><v>a<> % <v>b<><>


### Symbol **

Power (Arithmetic Operator)

<cb><v>a<> ** <v>b<><>


### Symbol +=

Add And Assign (Arithmetic Operator)

<cb><v>a<> += <v>b<><>

String Concatenation (Arithmetic Operator)

<cb><v>string_1<> += <v>string_2<><>


### Symbol -=

Subtract And Assign (Arithmetic Operator)

<cb><v>a<> -= <v>b<><>


### Symbol *=

Multiply And Assign (Arithmetic Operator)

<cb><v>a<> *= <v>b<><>


### Symbol /=

Divide And Assign (Arithmetic Operator)

<cb><v>a<> /= <v>b<><>


### Symbol //=

Floor Divide And Assign (Arithmetic Operator)

<cb>/<v>a<> //= <v>b<><>


### Symbol %=

Calculate Modulus And Assign (Arithmetic Operator)

<cb><v>a<> %= <v>b<><>


### Symbol **=

Calculate Power And Assign (Arithmetic Operator)

<cb><v>a<> **= <v>b<><>


### Symbol \<

Less Than (Comparison Operator)

<cb><v>a<> \< <v>b<><>


### Symbol \<=

Less Than Or Equal To (Comparison Operator)

<cb><v>a<> \<= <v>b<><>


### Symbol >

Greater Than (Comparison Operator)

<cb><v>a<> > <v>b<><>


### Symbol >=

Greater Than Or Equal To (Comparison Operator)

<cb><v>a<> >= <v>b<><>


### Symbol ==

Equal To (Comparison Operator)

<cb><v>a<> == <v>b<><>


### Symbol !=

Not Equal To (Comparison Operator)

<cb><v>a<> != <v>b<><>


### Symbol :=
Walrus Operator / Assignment Expression

<cb><v>variable<> := <v>expression<><>

Evaluates an expression, assigns it to the variable and returns the result to the calling function.
@
@ walrus operator


### Symbol ~

Complement / Inverse

<cb>~<v>a<><>


### Symbol &

Bitwise AND (Bitwise Operator)

<cb><v>a<> & <v>b<><>


### Symbol |

Bitwise OR (Bitwise Operator)

<cb><v>a<> | <v>b<><>


### Symbol ^

Bitwise XOR (Bitwise Operator)

<cb><v>a<> ^ <v>b<><>


### Symbol \<\<

Bitwise Shift Left (Bitwise Operator)

<cb><v>a<> \<\< <v>shift_count<><>


### Symbol >>

Bitwise Shift Right (Bitwise Operator)

<cb><v>a<> >> <v>shift_count<><>


### Symbol f''

F-String

Returns formated text.

<cb>f'<v>text<>'<>

<cb>f'{<v>variable<>}'<>
@
@ f'{}'



### Symbol f""

F-String

Returns formated text.

<cb>f"<v>text<>"<>

<cb>f"{<v>variable<>}"<>
@
@ f"{}"



### Symbol r''

Raw String

Returns text exactly as it is represented between the quotes.

<cb>r'<v>text\\text\\text\\n<>'<>



### Symbol r""

Raw String

Returns text exactly as it is represented between the quotes.

<cb>r"<v>text\\text\\text\\n<>"<>


# What Is The Difference
@
@ whats, what's, between



### Iterable vs Iterator vs Generator

Iterable:

<*>Think "contains iterable data"
Implements <c>__iter__()<>
Returns an Iterator<>


Iterator:

<*>Think "the data being iterated over"
Implements <c>__next__()<>
Returns Data One at a Time<>


Generator:

<*>A Type of Iterable
Wraps an Iterator Function with an Iterable<>



### List Comprehension vs Generator Expression

List Comprehension:

<*>Executes immediately
Results are stored in memory.
Syntax: <c>[<v>expression<> for <v>item<> in <v>items<>]<><>


Generator Expression:

<*>Similar to List Comprehension
Evaluates Lazily
Only uses memory for each item, never the entire result set.
Syntax: <c>(<v>expression<> for <v>item<> in <v>items<>)<><>



### List vs Tuple vs Sequence vs Array vs NumPy Array

List:

<*>Mutable List<>

<*>Mutable Ordered List of Items
Can Mix and Match Types<>

Tuple:

<*>Immutable List<>

<*>Immutable Ordered List of Items
Can Mix and Match Types<>

Sequence:

<*>General Type For All Lists<>

<*>Any Type of Ordered List
Includes Lists, Tuples<>

Array:

<*>High Performance Single Type List<>

<*>A High Performance List of Items
Data Must Single Type<>

NumPy Array:

<*>High Performance Multidimenisonal Array<>

<*>Requires NumPy Library (External Library)
Data Most Be Single Type<>



# Reserved Words
@
@ reserved-words-only, reserved-only
@ keywords-only, keyword-only

A reserved word is a keyword that has special meaning or purpose to Python.
It can not be used as the name of an object, variable or function.

<*><c>and<>
<c>as<>
<c>assert<>
<c>break<>
<c>class<>
<c>continue<>
<c>def<>
<c>del<>
<c>elif<>
<c>else<>
<c>except<>
<c>False<>
<c>finally<>
<c>for<>
<c>from<>
<c>global<>
<c>if<>
<c>import<>
<c>in<>
<c>is<>
<c>lambda<>
<c>None<>
<c>nonlocal<>
<c>not<>
<c>or<>
<c>pass<>
<c>raise<>
<c>return<>
<c>True<>
<c>try<>
<c>while<>
<c>with<>
<c>yield<><>
@
@ Keywords
@ and, as, assert, break, class, continue, def, del, elif, else, except
@ False, finally, for, from, global, if, import, in, is, lambda, None
@ nonlocal, not, or, pass, raise, return, True, try, while, with, yield



# Acronyms
@
@ glossary, glossary-only
@ acronyms-only, acronym-only


### ABC
Abstract Base Class



### AST
Abstract Syntax Tree



### arg
An argument passed into a function.



### AWS
This is used in coroutines and event loops.

Best guess:
Awaitable subroutine.

<!>Someone who knows, can you please help us out and tell us what this stands for?<>



### FP
File Pointer

<cb>with open(<v>file_name<>, "w") as <v>fp<>:
	<v>fp<>.write()<>

See: <l "?q=open()+write">Write File<>



### GIL
Global Interpreter Lock



### PEP
Python Enhancement Proposals



### PIP
Pip Installs Packages (Python’s Package Manager)



### PyPI
Python Package Index



#### Python File Extension .py
Python code file.



#### Python File Extension .pyc
Python compiled bytecode.
Automatically generated.



#### Python File Extension .pyo
Python compiled module.
Created by interpreter when a module is imported.



#### Python File Extension .pyd
Windows dynamic link library that contains a python module.
Called from other python applications.



### REPL
Read Eval Print Loop

Pythons inteactive command-line interface for executing Python code.



### VENV
Virtual Environment



# Terms
@
@ glossary, glossary-only
@ terms-only, term-only


### Asynchronous Programs
Breaks a task into internal and external steps.

The external steps are submitted.
Then the internal steps are performed.
Finally the responses from the external steps are collected.

The external task is often represented by an object
called future, promise or task.

Best for I/O bound processes and Python threads.



### Attribute
A class variable or function. Anything you reference with '.' . 



### Awaitable

Anything that can be used with <c>await<>.

Main types: coroutines, Tasks, and Futures



### Class
A class object defined in a module file. Classes should use Pascal case.



### Class Member
Any variable or function defined in the class.

All members are public.



### Class Method
Stored as an attribute on a class.



### Closure
Is a function that "closes over" the environment it was defined in. It has access to all the variables in that are in scope in that environment without having to explicitly have them passed in.

This applies to lambdas and nested functions.



### Constants
There is no mechanism to enforce constants in Python.

Use a regular variable, style it as a constant and trust your fellow developers to play by the rules!
@
@ variable



### Coroutine
A suspendable function for use in concurrent thread processes.

It can be stopped and restarted and will voluntarily yield control to other functions on the current thread instead of blocking.
Use this to work on single threaded event loops.



### Daemon Process
A process that runs independently of its parent process.

It will continue to run when the parent terminates.



### Decorator
A method or class that runs before a method is called.

The decorator method is applied with <c>@<v>decorator<><> ('@' + decorator function name).
Not related to the decorator pattern.



### Deep vs Shallow Copying

Shallow Copy:
Creates a copy of the parent object but reuses the original child objects.

Deep Copy:
Creates duplicates of the parent object and all related child objects.
Can break if there are circular references.
@
@ deepcopy
@ versus



### Dictionary
A dict. A collection of key value pairs.



### Duck Typing
If it walks like a duck and quacks like a duck, it is a duck.

Duck typing states that if the method exists, the object supports that action and you can invoke it.
There is no type checking to see if the object type or superclass explicitly supports that method.



### Dunder Method
Any method that stars and ends with a double underscore.

Example: <c>__name__<>

Dunder = Double Underscore
See: Magic Method
@
@ double underscore



### Egg File
A zip file containing Python files. It is runnable if it contains __main__.py in the root directory.



### Epoch
The time at Unix Time 0.

January 1st, 1970 at 00:00:00 UTC.
@
@ unix time



### Epoch Time / Unix Time
The time that has passed in seconds since the Unix epoch (January 1st, 1970).



### Event Loop
A single threaded process that places coroutines and tasks on a queue and executes them one at a time.
The task or coroutine will voluntarily give up control back to the event loop when blocked, allowing other tasks to continue.

Great for handling IO bound operations where you don't want to block execution when waiting for external operations to complete.



### Executable Directory
An executable directory is any directory containing <c>__main__.py<>.

When called from python, it will execute the code in <c>__main__.py<> to start the application.



### Expression
Some code that evaluates to a value.

Examples:

<cb>1 + 3
"A string"
<v>my_variable<><>



### Formatted String literal
An f-string or string in the form <c>f"<v>text<>"<>.

Used to create a formatted string.



### Function
A callable section of code that has a name, takes arguments and performs an action or calculation.
Python functions can be stand alone or in a class.



### Function - Function Overloading
Not supported by Python.

Use named argument passing or optional function arguments.

Function overloading is where multiple functions are defined with the same name but have different arguments. For Python, use named arguments with default values inside a single function instead.



### Function - Inner Function
A function defined inside another function.



### Generics
Strictly speaking not supported in Python.

Python is a dynamic language and uses duck typing. No need for Generics.

Python's typing library allows you to declare generic types but they are ignored by the compiler.



### Global Interpreter Lock (GIL)
Used by python to protect the interpreter's state during multitasking operations.

Prevents multiple native threads from executing python code at the same time.

It is needed to prevent race conditions and dead locks with Python's memory management unit.
It is implemented as a mutex (lock) that allows only one thread to hold control of Python's interpreter.
A thread must obtain the lock before it can execute.
IO bound operations automatically release control to the GIL so other threads can run.

See: Multitasking, Thread



### Gorilla
Here is a gorilla  🦍



### Goto
Not supported in Python
@
@ go to



### Green Threads
Python's mechanism for emulating multi-threading.

They are managed in user space instead of kernel space, enabling them to work in environments that do not have native thread support. They work like cooperative multi-threading. Each thread voluntarily/explicitly give up control to one another at specified points in your code.

Also called: Greenlets
@
@ Greenlets



### Guido van Rossum
The creator of Python.

Guido created Python in 1991.
@
@ python creator



### Inter-Process Communication

Use any of these:

	Pipe
	Queue
	Shared Memory
	Shared Manager



#### Inter-Process Communication - Shared Memory

<cb>multiprocessing.Value<>

<cb>multiprocessing.Array<>


These are faster than a shared manager but have restrictions.



#### Inter-Process Communication - Shared Manager

Slower, uses proxy to write to shared memory.
Supports a wider range of types (dicts, lists, semaphores, etc.)

Can share memory over the network.



### Iterable
Any object that returns an iterator.

Used by any class that has data that can be iterated over.



### Iterator
An object that iterates over a set of data.

It returns the data one element at a time.



### Kitchen Sink
So we might have lied about the kitchen sink. But we are doing our best to make this as complete as possible.

Let us know what we should have in here but don't.

And one day, we may also add the kitchen sink!



### Lazy Iterators
These iterators evaluate each value one at a time and only when required.

Examples: Generator Expression, Yield



### Magic Method
A python language method that adds "magic" functionality to a class.

Reserved for system methods. These methods are always in the form <c>__<v>methodname<>__<>. The double underscores is a way of ensuring system method names don't collide with user names.

Also called: A Dunder method (<b>d<>ouble-<b>under<>score).
@
@ dunder, double underscore



### Map Data Structure
Use Python's <c>dict<> for other languages' map() or dictionary() data structures.
@
@ map()



### Memory Management
Python uses reference counting to track when objects become unused. When the count is 0, the object memory gets freed.



### Method or Function Overloading
Not supported in Python.

Use named argument passing or optional method arguments.

Use default values in the method signatures and pass arguments by name.



### Mixin
A special kind of multiple inheritance.

Used to either: 
- provide a lot of optional features for a class.
- use a particular feature in a lot of classes.

For the optional feature classes, these classes are not designed to stand alone but add some functionality to another class type.



### Module
A file that contains related Python definitions and statements. Should be short and lower case. Module names map to file names.



### Monkey Patch
Python's mechanism for changing the behaviour of a piece of code at runtime.

Functions or class methods can be changed dynamically while the application is running.
Usually done for testing purposes (unit tests).



### Multitasking
Python implements multitasking through non-blocking event loops, multithreading or multiprocessing.
Each has their benefits and costs.



#### Multitasking - Event Loops
Runs non blocking functions on a single threaded event loop.
Functions identify themselves as non-blocking and voluntarily give up control to the interpreter.

This has very little overhead and improves performance for IO bound operations.
It is slower than Multithreading but easier to code and is faster than sequential processing.
All core Python IO operations are non-blocking and work well.



#### Multitasking - Multithreading
Pythons multitasking implementation using threads.

It allows cooperative multitasking and uses shared memory.
It is light weight and starts up fast but will not do true multitasking.
Threads must voluntarily give up control to the interpreter.
However, it is ideal for processing IO bound operations.

See: Threads



### Multiprocessing
Pythons multitasking implementation using processes.

It allows multitasking in separate memory spaces.
It is costly to start and does not share memory (by default) with other processes but it preforms true multitasking.

See: Process



### Namespace Package
A package that is split across multiple root directories (those listed in <c>sys.path<>) but with the same package name.

Python scans all directories in sys.path for namespace packages.
If it finds package directories of the same name but no <c>__init__.py<> file, it will treat them as one single package.

Can not have <c>__init__.py<> files.
This is to avoid the complexity and issues of deciding the order of running <c>__init__<> files.



### Object Aliasing
The ability for Python to assign multiple names to Python objects.

e.g. Functions can be referenced through multiple names.



### Operators
A symbols takes one or two arguments and performs a calculation on them.

Example: +, -, *, /



### Package
Generally a directory that contains module files and the file <c>__info__.py<> (required).

All packages are modules but not all modules are packages.



### Pass By Assignment
Python passes arguments by assignment (object reference).

All variables are references(pointers) to an object. The references are copied in the arguments. Thus the function/method has access to the original value and mutable objects can be changed. However, reassign the variable ( var = …) and the reference to the original object is gone.



### PEP 8 - Style Guide
Python Standard Style Guide

<l>https://www.python.org/dev/peps/pep-0008/<>
@
@ pep-8



### Pickling
Converting an object hierarchy into a byte stream.

Unpickling is the inverse operation converting a byte stream back into an object hierarchy.
@
@ pickle



### Process
A single execution unit executing a part of the program.

Processes run on their own python interpeter and have their own memory space. As a result, there are no issues with GIL and performance is improved. They are costly to start up (use Pool to get the startup hit only one time) but perform true multitasking.

Library: multiprocessing

See Also: Multitasking, Threads
@
@ Multitasking



### PyPy
An alternative to the standard python language.

Features: Just in time compiler, better memory management, Stackless.
PyPy is written in RPython and compiled into c.



### Python Package Index (PiPy)
Python software repository.
@
@ Pipy, Pypi



### Python Programming Language
Python was created in 1991 by Guido van Rossum.
@
@ 1991



### Raw String
A string where values between the quotes are seet as in. No processing is done on the values between the quotes.



### Read Eval Print Loop (REPL)
Python’s interactive command-line environment.



### RPython
A strict subset of python that can be statically compiled into C.



### Samples
Congratulations in testing out the <b>-only<> feature. Here are your samples 👍

Not happy with this? Let us know and we'll put something better in here.
@
@ Sample-only, Samples-only



### self
A reference to the class instance.

Use it to reference any instance variables or methods inside the class..
Must be declared in every instance method in a class.

Similar to <c>this<> in other languages.


Example:

<cb>self.<v>property_1<> = <v>...<>

self.<v>function_1<>()<>



### Sequence
Any iterable type in Python.

Includes lists, sets, tuples, range, strings, etc.



### Symbol Table
A structure used by python to track and manage what program elements have been loaded and are are in scope.


#### Global Symbol Table
Manages all program elements that are global.

See: globals()


#### Local Symbol Table
Manages all program elements that are currently in local scope.

See: locals()



### Thread
A single execution unit executing a part of the program.

Threads run in shared memory, on a single execution thread and use the same python interpreter. A thread needs to acquire GIL lock before it can execute. Threads are light weight to start up. Threads do not give an overall performance improvement as they use cooperative multitasking inside a single process.

Library: threading

See Also: Multitasking, Process, GIL

@ Multitasking, Multithreading



### Timestamp
The number of seconds since January 1st, 1970 at 00:00:00 UTC.

Can be an integer or float.

Also called Unix Time, Epoch Time.
@
@ Unix Time, Epoch Time



### Top Level Statement
Statements in a module (python file) that are outside functions and classes.



### Tuple
An immutable Array.



### Typing Library
Added to Python 3.5, this allows you to label types in function signatures.

<l>https://docs.python.org/3/library/typing.html<>
@
@ type hinting



### Venv / Virtual Environment
Creates an isolated python environment for a program to run in.

Ships standard with Python 3. It contains it's own packages independent of the global python environment but it links back to the standard python installation when possible. The environment must be accessed through a custom shell started up by one of the script files. Does not support Python 2.

vs <c>virtualenv<>



### VirtualEnv
A 3rd party tool used to create isolated Python environments.

virtualenv creates a directory which contains all the necessary executables to use the packages that a Python project would need. It works by installing required python files and binaries in a directory (eg: env/), and then modifying the PATH environment variable to prefix it with a custom bin directory (eg: env/bin/).

Prefer <c>venv<>.



### Wheel
A packaging system used to distribute but not execute python files. It is preferred over egg files. Can be stored on PyPI servers.

vs: Egg



# Other SpeedSheets
@
@ sheets


### aiohttp SpeedSheet
The aiohttp library for making asynchronous http calls.

Sheet:	<l "/s/aiohttp">aiohttp<>
@
@ async http library, asynchronous, post, put, get, request, url



### BeautifulSoup SpeedSheet
An easy to use library for processing HTML or XML.

Sheet:	<l "/s/beautifulsoup">BeautifulSoup<>
@
@ bs4.BeautifulSoup(), .BeautifulSoup(), scrape website, extract html, parse html



### Numpy SpeedSheet
A great library for manipulating large amounts of data.

Sheet:	<l "/s/numpy">numpy<>
@
@ np.array, numpy.array, numpy,ndarray, np.ndarray, averages, means, statistics



### Pandas SpeedSheet

⚠️ The Pandas SpeedSheet doesn't hava any content. Send us a note if you'd like to see this updated. Or contribute on Github.

Sheet: <l "/s/pandas">Pandas<>

Git Source: <l>https://github.com/speedsheet/sheet-python-pandas<>
@
@ pandas, dataframe, df, frame


### Pillow SpeedSheet
An image manipulation library.

Sheet:	<l "/s/pillow">pillow<>
@
@ pillow, pil.image, images



### Requests SpeedSheet
The requests library for making http calls.

Sheet:	<l "/s/requests">requests<>
@
@ http library, post, put, get, request, url



# More Speedsheets?

This sheet covers core python only. But want to see more here? Or for other libraries? Please let us know.

Or make contributions on Github:
<l "https://github.com/speedsheet?tab=repositories&q=&type=&language=&sort=name">SpeedSheet Source on GitHub<>
@
@ delta, terminal, process
@ Anacond, Arrowm, BeautifulSoup, Bokeh, Cirq, Conda, Databases, Delorean, Django, Eli5, Fire, FlashText, Flask, Gensim, HTTP, Image, Images, Imaging, Keras, LightGBM, Luminoth, Mahotas, Matplotlib, MoviePy, Networkx, NLTK, Pandas, Pendulum, Picture, Pixel, Poetry, PyGame, PyQt, PyPi, PyTorch, Requests, Scikit Learn, Scikit-Learn, SciPy, SqlAlchemy, TensorFlow, Theano, Tkinter, wxPython, ai, a.i., artifical intelligence