Python

• .bit_length(): length of digits in binary. Exclude the sign and leading zeros.
• .bit_count(): number of ones in binary. Exclude the sign. aka. population count.

• .format(): formats {(<empty>|<int>|<identifier>):<format_spec>} within the string.
  • It calls the __format__ of the object with <format_string>.

• Generalized bitwise operations.
• A - B: in A, not B.
• A & B: in A and In B.
• A | B: in A or in B.
• A ^ B: in A not B, or in B not A.
  • Shorthand for symmetric_difference

• format(<object>, <format string>) apply str to the object and format it.
• iter() calls the __iter__() method that returns a generator.
• next() calls the __next__() method

• @<decorator> is used before a function definition.
• A decorator is a function that act on a function and ouputs a function.

@decorator
def f():
    pass     # is equivalent to

f = decorator(f)

• .__subclasses__() -> List[class]

• def __init__(self, ...): is called when the object is being initalized.

  • def __new__(cls, ...) -> <instance>: is called when the object

  is being created.

• __add__(self, other), __sub__(self, other) is called when the standard binary operation is performed.

  • __radd__(self, other), __rsub__(self, other) is called when

  the object comes after the operator.

• __invert__(self) is called when binary not operator ~ is used.
• __call__(self, ...) is called when the object itself is called.

• __str__(self), __repr__(self) is called when an object is to be shown. The str() function is meant to return representations of values which are fairly human-readable, while repr() is meant to generate representations which can be read by the interpreter.¹

  • print(), str(), format() call str on the object. It

  calls __str__, when it is not defined, calls repr. repr calls __repr__, when it is not defined it returns the default representation.

  • A cell in ipython shell will return the repr of an object.

• __getattr__(self, key) is called when there's no property of name key.

  • e.g. obj.some_key => obj.__getattr__("some_key")
  • __getattribute__(self, key) is always called when accessing a

  property and overrides others.

• __format__(self, format_string) -> str is called on format(<obect>, <format_string>).

• Every class is inherited from the metaclass type.

• System Path -> Local Path -> Others

• Prefix with ., .., ..., … each for this package, parent package, grandparent package, …
• Only from ... import ... is possible.

• python -m venv DIR
  • --system-site-packages: Allow the access to the system packages.
• VENV/bin/activate is the script that setup the virtual environment.

• partial partial application of a function

• groupby(Iterable, key=Function) -> Dict{Function -> A: A : List[Iterable -> B: B]}
• takewhile(Function -> bool, Iterable) take the elements one by one until it's evaluated to false.
• Take inspiration from APL.
  • APL-Inspired Python! - YouTube

• deque class
  • It supports popleft, appendleft, extendleft

• The standard Unix path expansion within Python.

• Method: glob('<pattern>') -> list[str]

  • Return: List of filenames that matches the pattern in current

  directory.

A replacement for os

• run(cmds: list[str]) -> CompletedProcess run the shell command

• remove(path) remove a file

• match(pattern: str, string: str) -> Match check if the entire string exactly match the pattern
• search(pattern: str, string: str) -> Match look for a substring that matches the pattern
• findall(pattern, string, flags=0) -> list[str] match all occurences
• finditer(pattern, string, flags=0) -> Iterable[Match]
• Match
  • .expand(template: str) -> str perform substitution on the template
  • .group(group: str|int|list[str|int]) -> str|tuple[str]
• See re — Regular expression operations — Python 3.13.2 documentation

• Protocol creates inheritance-free interfaces. class Interface(Protocol): value: int def func(param: int) -> int: ...

• Thread(target=..., [args=...]) setup the thread, and thread.start() starts it.
• thread.join() is where the thread returns.

• Modern Python logging - YouTube
• logging is the root logger.
• logger = logging.getLogger() makes a child logger.
• logger can show debug, info, warn, error, exception or critical

• see source code.

• import customization

• csv.writer

  • Instance of this(_writer) will take the file and the table and

  write it.

• csv.reader

  • Instance of this(_reader) is an iterable that gives out each

  line.

Object Serialization

• random() sample uniformly between 0 and 1
  • uniform(a, b) uniform distribution
  • gauss(mu=0, sigma=1) Gaussian distribution
• choice(seq: Iterable) select random element
• choices(population: Iterable, weghts: Iterable|None, *, cum_weghts: Iterable|None, k: int)
  • select k elements from population allowing repetition.
  • cum_weights are the cumulative weights.
• shuffle(x)
• sample(population, k, *, counts=None)
  • select k unique elements

Builtin Python functionality for testing.

• Examples section within the function docstring would run on doctest.modtest().

Use functional programming style, such as monad.

• Struct annotation

• BaseModule

  • It is inherited to specify the structure of an object, which

  then can be instantiated directly, or a ((66b7fc0d-d021-48de-97f7-471cdcd6fd52)) can be passed with ** spread.

  • A property of a BaseModule can be another BaseModule and the

  JSON data is automatically propagated accordingly.

• Field
  • It defines the details of a field within the BaseModule

SQL interface

HTML parser

Project Templates

• It solves linear programs.

• Machine Learning Framework based on the Torch library.
• Originally developed by Meta AI and now part of the Linux Foundation.
• import torch

• Based on MuPDF or MμPDF.
• import fitz

• Based on tk originally written in tcl, the programming language.
• # pacman -S tk is required on Arch machine, although the tkinter package is installed.
• tkinter.Tk is the root object that is at the top of the widget hierarchy.
• A widget can be configured through the initialization, or .config[ure](), or ["option"] =

• Installed within ~/Video/alsciokat/.venv

• sympy. Package Structure

  • abc.
    • This module contains the common variables: a, b, x, y, z, t,

  which can also defined directly by sympy.symbols("x y z": str) -> list[Symbol]

  • core.
    • symbol.
      • class Symbol
    • numbers.
      • class Integer
      • class Rational
    • expr.
      • class Expr
        • probably the parent class of most of the classes.
        • .equals(Expr) -> bool
        • .subs(Expr, Expr) .subs(Iterable[tuple[Expr, Expr]])
        • .evalf() -> float
        • .rewrite(Expr)
        • .diff(Iterable[Tuple[Symbol, int|Symbol]]) -> Expr
        • .series(Symbol, start_order: int, end_order: Number)
        • .removeO() -> Expr
        • .func The parent node
        • .args top-level argument
    • relational.
      • class Equality alias Eq
        • .__init__(Expr, Expr)
  • matrices.
    • class MutableDenseMatrix alias Matrix
      • .__init__(Iterable[Iterable[Number]])
      • .row(int) -> Covector .col(int) -> Vector
      • .nullspace() -> list[Vector],

  .columnspace() -> list[Vector]

  • .eigenvals() -> dict[eigenvalue, algebraic_multiplicity]
  • .eigenvects() -> list[tupe[eigenvalue, algebraic_multiplicity, list[eigenvector]]]
  • .charpoly(Symbol) -> Expr

  • vector.

    • coordsysrect
      • class CoordSys3D(name: str, transformation: Lambda, Tuple, str)
        • transformation includes "spherical", …
        • .x .y .z coordinate variables
        • .i .i .k unit vectors
        • .create_new(name: str, transformation) -> CoordSys3D
        • .locate_new(name: str, position: Vector) -> CoordSys3D
        • .orient_new(name: str, orienters) -> CoordSys3D
        • .base_vectors() -> tuple[Vector]

    .base_scalar() -> tuple[Expr]

    • vector
      • class Vector
        • .components -> dict[basis_vector, component]
        • .cross(Vector) -> Vector, .dot(Vector) -> Number
        • .magnitude() -> Number, .normalize() -> Vector
        • .outer(Vector) -> Dyadic
        • .projection(Vector) -> Vector
        • .separate() -> dict[CoordSys3D, Vector]
        • .to_matrix(CoordSys3D) -> Matrix
    • dyadic
      • class Dyadic
    • parametricregion
      • class ParametricRegion(definition: tuple[Expr*], *bounds: *tuple[Symbol, Number, Number]])
    • implicitregion
      • class ImplicitRegion(tuple[Symbol*], Expr)
    • express(Vector|Dyadic|sympyfiable, CoordSys3D, CoordSys3D?, bool) -> Vector|Dyadic|Expr
    • curl(Vector) -> Vector
    • divergence(Vector) -> Expr
    • gradient(Expr) -> Vector
    • is_conservative(Vector) -> bool
  • integrals.
    • integrals.
      • class Integral
      • class ParametricIntegral(Vector | sympyfiable, ParametricRegion)
    • vector_integrate(Vector, region | *bounds)

  • physics.

    • vector.
      • This vectors are different from the regular Vector
      • frame.
        • class ReferenceFrame(name: str)
          • .x .y .z basis vectors
          • .orient(ReferenceFrame, rot_type: str, amount: list[Symbol, Vector])
            • rot_type can be 'Axis' to rotates the reference

    frame by Symbol amount arount Vector axis.

    • [0] [1] [2] coordinate variable
    • class CoordinateSym(name: str, ReferenceFrame, index: int)
      • Extract the coordinate variable
    • vector.
      • class Vector
        • .diff(Symbol, ReferenceFrame) -> Vector
        • .cross(Vector) -> Vector, .dot(Vector) -> Expr
        • .express(ReferenceFrame, variables: bool) -> Vector|Expr
        • .magnitude() -> Expr, .normalize() -> Vector
        • .outer(Vector) -> Dyadic
        • .to_matrix(ReferenceFrame) -> ImmutableMatrix(shape(3,1))
        • .free_dynamicsymbols(ReferenceFrame) -> set[Function]
        • .free_symbols(ReferenceFrame) -> set[Symbol]
    • dyadic.
      • class Dyadic
    • point.
      • class Point(name: str)
        • .locatenew(name: str, value: Vector) -> Point
        • .set_acc(ReferenceFrame, Vector) set acceleration
        • .set_pos(Point, Vector),

    .set_vel(ReferenceFrame, Vector)

    • vel(ReferenceFrame) -> Vector,

    acc(ReferenceFrame) -> Vector

    • functions.
      • dot(Vector, Vector) -> Expr,

    cross(Vector, Vector) -> Vector, outer(Vector, Vector) -> Dyadic

    • These are just wrappers.
    • express(Vector|Dyadic|sympyfiable, ReferenceFrame, ReferenceFrame?, variables) -> Vector|Dyadic|Expr
    • dynamicssymbols(names: str) -> *Symbol
      • Return a symbol that is a function of time t.
    • fieldfunctions.
      • divergence(Vector, ReferenceFrame) -> Expr
      • curl(Vector, ReferenceFrame) -> Vector
      • gradient(scalar_field: Expr, ReferenceFrame) -> Vector
      • scalar_potential(Vector, ReferenceFrame) -> Expr
      • is_conservative(Vector) -> bool,

    is_solenoidal(Vector) -> bool

    • mechanics.

• Package can import itself, since it is already installed.

Written in Rust Automatically manage virtual environments and packages.

• uv init to make a uv environment
• uv add PACKAGE, uv remove PACKAGE
• uv run FILE.PY

• help() to enter

• THIS is Why List Comprehension is SO Efficient! - YouTube
• Python compiles the python code into bytecode, so that Python Virtual Machine(PVM) can execute it.
• Access the bytecode via dis (disassemble) package.

• GIL
• It is a feature of the interpreter that limits the interpreter to only operate on a single thread.
• It is still applicable even when the threads package is used, limiting the computing power.
• multiprocessor module make use of multiple interpreters. So it is not affected by GIL, but it has its own limitations.

• !COMMAND it calls os.system()
• Most of the tools are available.

• _i _ii _iii previous three input
  • _i4 _ih[2:5] input history line 4, line 2-4
• _ __ ___ previous three output
  • _oh ouput history
• _dh directory history

• The arguments are given only positionally.
• %quickref show the quick reference
• %timeit %%timeit
• %%latex render a cell as a block of LaTeX

• obj? obj?? (?obj ??obj) get help or more help for object

• ipykernel Jupyter kernel based on IPython.
  • python -m ipykernel install --user --name=<kernel name> or ipython kernel install --user --name=<kernel name> to install the kernel to Jupyter environment.

• --to (latex|pdf|markdown|html|...)