Python Guide (WIP)

Version: 0.0.1
Author:
- Nathan Nellans
- Email: me@nathannellans.com
- Web:
  - https://www.nathannellans.com
  - https://github.com/nnellans/python-guide

Important

This is an advanced guide and assumes you already know the basics of Python. Think of this more like an advanced cheat sheet. I went through various sources, captured any notes that I felt were important, and organized them into the README file you see here.

Warning

This is a live document. Some of the sections are still a work in progress. I will be continually updating it over time.

Variables

# creating variables and assigning values
var_name: typeHint = "value"

: typeHint is optional
- Helpful for complex types like: var_name: dict[str, tuple[int,int,int]]
  This would be a dict with strings for keys, and tuples containing 3 integers as values
= "value" is optional
- You can declare a variable without a value. However, you can't use that variable until you assign a value to it

# assign the same value to multiple variables at once
var_name1 = var_name2 = var_name3 = "some value"

# assign a seperate variable to each value from an iterable (unpacking)
iterable = ["value1", "value2", "value3"]
var1, var2, var3 = iterable

Data Types

String: `str`

# enclosed with single or double quotes
var_name = "this is a string"
var_name = 'this is also a string'

# multi-line strings can be created with triple quotes (single or double quotes)
var_name = """
this is a
multi-line string
"""

var_name = """\
add the slash as shown above
and the initial new line will not be included
"""

# raw strings leave everything intact, and do not support escape sequences
var_name = r"This is a raw string"  # precede the string with an r or R

# formatted strings (f-string) allow interpolation as well as many other modifications (TO-DO)
var_name = f"This is {another_var} inside a string"  # precede the string with an f or F

# convert other data types to a string with str()
var_name = str(int_var)

Integer Number: `int`

# un-quoted whole numbers, can be positive or negative
var_name = 234

# for better readability, you can optionally use _ as a thousands separator
var_name = 1_000_000

# convert other data types to an integer with int()
var_name = int("40")

Floating-Point Number: `float`

# un-quoted numbers with a decimal point, can be positive or negative
var_name = 37.33

# for better readability, you can optionally use _ as a thousands separator
var_name = 3_000.25

# convert other data types to a floating-point number with float()
var_name = float(31)

Boolean: `bool`

# un-quoted True or False literals, capitalization required
var_name = True
var_name = False

# convert other data types to a boolean with bool()
# any value that is empty or zero will be converted to False
# anything else will be converted to True
var_name = bool(0)

List: `list`

# square brackets surrounding comma-separated values
var_name = ["value", 356, True, "fourth"]

# use a single value from a list by referencing its index
list_name[3]

# convert other data types to a list with list()
# TO-DO

# add an value to the end of the list
list_name.append("new value")

# remove the first matching value
list_name.remove("value")

# remove a value by index
del list_name[3]

# find the number of items in a list
len(list_name)

# sort a list
list_name.sort()
list_name.sort(reverse=True)

# reverse the entries in a list
list_name.reverse()

Tuple: `tuple`

# parenthesis surrounding comma-separated values
var_name = ("value", 356, True, "fourth")

# use a single value form a tuple by referencing its index
tuple_name[2]

# convert other data types to a tuple with tuple()
# TO-DO

The values in a Tuple can not be changed, added, or removed
The parenthesis are optional, as the comma is what actually creates the Tuple
- The exception is creating an empty tuple, where parenthesis are required: var_name = ()

Set: `set`

# curly brackets surrounding comma-separated values
var_name = {"value", 356, True, "fourth"}

The values in a Set can not be duplicated, they must be unique
The values in a Set are not ordered, and therefore do not have indexes
The values in a Set can not be changed. However, values can be added, or removed

Dictionary `dict`

# curly brackets surrounding key/value pairs, which are separated by commas
var_name = {
    "key1": "value",
    "key2": 356,
    "key3": True,
    "key4": "fourth"
}

# use a single value form a dictionary by referencing its index
dict_name["key2"]

# find the number of kv pairs in a dict
len(dict_name)

# remove a kv pair by index
del dict_name["key"]

The keys in a Dictionary can not be duplicated, they must be unique

Comparison of Collection & Mapping Types

Type	Example	Ordered	Mutable Values	Add/Remove Values	Duplicates
`list`	`['value', 'value']`	✅ (number index)	✅	✅	✅
`tuple`	`('value', 'value')`	✅ (number index)	🔴*	🔴*	✅
`set`	`{'value1', 'value2'}`	🔴	🔴	✅	🔴*
`dict`	`{'key1':'value', 'key2':'value'}`	✅ (key index)	✅	✅	keys: 🔴 values: ✅

* = defining feature

Functions

def function_name(param1: typeHint = defaultValue, param2: typeHint, param3) -> typeHint:
    """documentation string"""
    do stuff
    return something

For naming, use lowercase_with_underscores for functions and methods
Params are optional
- : typeHint for params are optional
- Default values for params are optional
-> typeHint for the function is optional
- typeHint can be None if the function returns nothing
docstring is optional

def function_name(*args):
    do stuff using args[2]

*args represents any number of positional parameters
all values will be stored in a tuple named args
args is convention, but any name can be used here

def function_name(**kwargs):
    do stuff using kwargs["key"]

**kwargs represents any number of named arugments (keywords)
all keys & values will be stored in a dict named kwargs
kwargs is convention, but any name can be used here

Documentation Strings

To-DO

Lambda Functions

TO-DO

Comparison Operators

a == b  # equal to
a != b  # not equal to
a > b   # greater than
a >= b  # greater than or equal to
a < b   # less than
a <= b  # less than or equal to

# and, or, not
a == b and c == d  # both statements must be true
a == b or c == d   # at least one of the statements must be true
not a == b         # the statement must not be true

# comparison operators can be chained together
a < b <= c  # this is equivalent to: a < b and b <= c

# checking for a value in a list
'value' in list_variable      # returns true if the value is in the list
'value' not in list_variable  # returns true if the value is not in the list

Conditional Logic

`if` Statement

if condition:
    do stuff
elif condition:
    do stuff
else:
    do stuff

# shortened, single-line if statement
if condition: do one command

# condensed if/else statement, aka ternary operator
"trueValue" if condition else "falseValue"

The elif and else sections are optional

`match` Statement

match expression:
    case pattern:
        do stuff
    case patternA | patternB | patternC:
        do stuff
    case pattern if condition:
        do stuff
    case _:
        catch-all, wildcard case

Loops

`for` Loops

# loop through a list, dict, or str
for iterator in sequence:
    do stuff using iterator

# loop 10 times
for iterator in range(10):
    do stuff using iterator

# loop through a list with index and value
for index, value in enumerate(listVariable):
    do stuff using index/value

# loop through a dict with key and value
for key, value in dictVariable.items():
    do stuff using key/value

# loop through a dict's keys
for key in dictVariable.keys():
    do stuff using key

# loop through a dict's values
for value in dictVariable.value():
    do stuff using value

`while` Loops

# continues as long as condition is true
while condition:
    do stuff

Special Loop Statements

continue end the current loop iteration, start the next iteration
break end the loop altogether
else see below

# 'else' statements can optionally be used in 'for' loops that use break
for iterator in sequence:
    if condition:
        break
    do stuff
# when all iterations are successful, and no break occurred
else:
    do stuff

# 'else' can optionally be used in 'while' loops that use break
while condition:
    if condition:
        break
    do stuff
# when all iterations are successful, no break occurred, and the while condition is now false
else:
    do stuff

List Comprehensions

TO-DO

Dict Comprehensions

TO-DO

Imports, Modules, Packages

Packages

Popular package registry: PyPI
- Python Package Index
- https://pypi.org
Popular package manager: pip
- The latest versions of Python come with pip
- Install a package: pip install packageName
  - By default, pip fetches packages from PyPI
  - After install, you can import the package into your program (see below)

Modules (aka Libraries)

Python comes with many modules, but not all are loaded by default
Note: It is customary to place all import statements at the beginning of a script
import random
- Use a function from the module: random.choice()
import random as alias
- Makes the random module available under an alias
- Use a function from the module's alias: alias.choice()
from random import choice, randint
- Imports only specific function(s) from the random module into the current namespace
- No longer requires the use of the random. namespace
- Use the imported functions: choice() or randint()
- from random import *
  - Imports all functions from the random module into the current namespace
  - In general, don't do this
from random import choice as alias
- Imports a specific function from the random module into the current namespace, but makes it available under an alias
- No longer requires the use of the random. namespace
- Use the aliased function: alias()

Classes

class some_name:

    # instance method
    # used when creating a new instance/object of the class
    def __init__(self, parameter1, parameter2, parameter3=default):
        # assigning parameter values to instance variables (self._xxx)
        if not parameter1:
            raise ValueError(“parameter1 is undefined”)
        if parameter2 not in [“value1”, “value2”]:
            raise ValueError(“invalid value for parameter2”)
        self._parameter1 = parameter1
        self._parameter2 = parameter2
        self._parameter3 = parameter3
        # or, if you are using "setters"
        parameter1(parameter1)
        parameter2(parameter2)
    
    # instance method
    # used when printing an instance/object of the class
    def __str__(self):
        return f”{self._parameter1} and also {self._parameter2}”

    # custom instance method
    def yourCustomMethod(self, parameter1):
        commands
        return ...

    # “getter” for parameter1
    @property
    def parameter1(self):
        return self._parameter1

    # “setter” for parameter1
    @parameter1.setter
    def parameter1(self, parameter1):
        if parameter1 not in [“one”, “two”, “three”]:
            raise ValueError(“invalid value for parameter1”)
        self._parameter1 = parameter1

    # class variables
    class_var1 = "value"
    class_var2 = "value"

    # class methods
    @classmethod
    def method_name(cls, parameter1):
        commands
        return ...

Try & Except

try:
    commands to try
except ErrorType:
    commands to run if the given ErrorType is thrown
else:
    commands that run if the try was successful

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Python Guide (WIP)

Variables

Data Types

String: `str`

Integer Number: `int`

Floating-Point Number: `float`

Boolean: `bool`

List: `list`

Tuple: `tuple`

Set: `set`

Dictionary `dict`

Comparison of Collection & Mapping Types

Functions

Documentation Strings

Lambda Functions

Comparison Operators

Conditional Logic

`if` Statement

`match` Statement

Loops

`for` Loops

`while` Loops

Special Loop Statements

List Comprehensions

Dict Comprehensions

Imports, Modules, Packages

Packages

Modules (aka Libraries)

Classes

Try & Except

FilesExpand file tree

README.md

Latest commit

History

README.md

File metadata and controls

Python Guide (WIP)

Variables

Data Types

String: str

Integer Number: int

Floating-Point Number: float

Boolean: bool

List: list

Tuple: tuple

Set: set

Dictionary dict

Comparison of Collection & Mapping Types

Functions

Documentation Strings

Lambda Functions

Comparison Operators

Conditional Logic

if Statement

match Statement

Loops

for Loops

while Loops

Special Loop Statements

List Comprehensions

Dict Comprehensions

Imports, Modules, Packages

Packages

Modules (aka Libraries)

Classes

Try & Except

String: `str`

Integer Number: `int`

Floating-Point Number: `float`

Boolean: `bool`

List: `list`

Tuple: `tuple`

Set: `set`

Dictionary `dict`

`if` Statement

`match` Statement

`for` Loops

`while` Loops